The Action precompile

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @notice Precompile at 0x0000000000000000000000000000000000000901
interface IAction {
    /// @notice LEP 5 availability commitment for Cascade storage verification.
    struct AvailabilityCommitment {
        string commitmentType;     // e.g. "merkle_blake3"
        uint8 hashAlgo;            // 0 = unspecified, 1 = BLAKE3, 2 = SHA256
        uint32 chunkSize;          // bytes per chunk
        uint64 totalSize;          // total file size in bytes
        uint32 numChunks;          // number of chunks
        bytes root;                // Merkle root hash
        uint32[] challengeIndices; // chunk indices the SuperNode must prove
    }

    /// @notice LEP 5 Merkle inclusion proof for a single challenged chunk.
    struct ChunkProof {
        uint32 chunkIndex;         // which chunk this proves
        bytes leafHash;            // hash of the chunk data
        bytes[] pathHashes;        // sibling hashes along the Merkle path
        bool[] pathDirections;     // true = right sibling, false = left
    }

    /// @notice Represents a single action on the Lumera chain.
    struct ActionInfo {
        string actionId;
        address creator;
        uint8 actionType;          // 1 = Sense, 2 = Cascade
        uint8 state;               // see the state table above
        string metadata;           // JSON metadata (type-specific)
        uint256 price;             // fee paid in ulume
        int64 expirationTime;
        int64 blockHeight;
        address[] superNodes;
    }

    event ActionRequested(
        string indexed actionId,
        address indexed creator,
        uint8 actionType,
        uint256 price
    );

    event ActionApproved(
        string indexed actionId,
        address indexed creator
    );

    /// @notice Request a Cascade storage action.
    function requestCascade(
        string calldata dataHash,
        string calldata fileName,
        uint64 rqIdsIc,
        string calldata signatures,
        uint256 price,
        int64 expirationTime,
        uint64 fileSizeKbs,
        AvailabilityCommitment calldata commitment  // pass an empty root to skip
    ) external returns (string memory actionId);

    /// @notice Request a Sense analysis action.
    function requestSense(
        string calldata dataHash,
        uint64 ddAndFingerprintsIc,
        uint256 price,
        int64 expirationTime,
        uint64 fileSizeKbs
    ) external returns (string memory actionId);

    /// @notice Finalize a Cascade action with storage proofs.
    function finalizeCascade(
        string calldata actionId,
        string[] calldata rqIdsIds,
        ChunkProof[] calldata chunkProofs  // pass empty for pre-LEP5
    ) external returns (bool success);

    /// @notice Finalize a Sense analysis action with results.
    function finalizeSense(
        string calldata actionId,
        string[] calldata ddAndFingerprintsIds,
        string calldata signatures
    ) external returns (bool success);

    /// @notice Approve a finalized action (creator only).
    function approveAction(
        string calldata actionId
    ) external returns (bool success);

    /// @notice Get details of a specific action by ID.
    function getAction(
        string calldata actionId
    ) external view returns (ActionInfo memory action);

    /// @notice Calculate the fee for an action of the given data size.
    function getActionFee(
        uint64 dataSizeKbs
    ) external view returns (uint256 baseFee, uint256 perKbFee, uint256 totalFee);

    /// @notice List actions created by a specific address.
    function getActionsByCreator(
        address creator,
        uint64 offset,
        uint64 limit
    ) external view returns (ActionInfo[] memory actions, uint64 total);

    /// @notice List actions filtered by state.
    function getActionsByState(
        uint8 state,
        uint64 offset,
        uint64 limit
    ) external view returns (ActionInfo[] memory actions, uint64 total);

    /// @notice List actions assigned to a specific SuperNode.
    function getActionsBySuperNode(
        address superNode,
        uint64 offset,
        uint64 limit
    ) external view returns (ActionInfo[] memory actions, uint64 total);

    /// @notice Get the action module parameters.
    function getParams() external view returns (
        uint256 baseActionFee,
        uint256 feePerKbyte,
        uint64 maxActionsPerBlock,
        uint64 minSuperNodes,
        int64 expirationDuration,
        string memory superNodeFeeShare,
        string memory foundationFeeShare,
        uint32 svcChallengeCount,
        uint32 svcMinChunksForChallenge
    );
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./IAction.sol";

contract CascadeStorageClient {
    IAction constant ACTION = IAction(0x0000000000000000000000000000000000000901);

    mapping(string => string) public uploads;

    event UploadRequested(string indexed dataHash, string actionId, uint256 totalFee);

    function uploadFile(
        string calldata dataHash,
        string calldata fileName,
        uint64 rqIdsIc,
        string calldata signatures,
        uint64 fileSizeKbs
    ) external {
        // 1. Query the fee to determine the price
        (, , uint256 totalFee) = ACTION.getActionFee(fileSizeKbs);

        // 2. Set expiration to 1 hour from now
        int64 expiration = int64(int256(block.timestamp)) + 3600;

        // 3. Request the Cascade action. An empty commitment skips LEP 5.
        IAction.AvailabilityCommitment memory commitment;
        string memory actionId = ACTION.requestCascade(
            dataHash,
            fileName,
            rqIdsIc,
            signatures,
            totalFee,
            expiration,
            fileSizeKbs,
            commitment
        );

        uploads[dataHash] = actionId;
        emit UploadRequested(dataHash, actionId, totalFee);
    }

    function checkUploadState(string calldata dataHash) external view returns (uint8 state) {
        IAction.ActionInfo memory info = ACTION.getAction(uploads[dataHash]);
        return info.state;
    }

    function approveUpload(string calldata dataHash) external {
        ACTION.approveAction(uploads[dataHash]);
    }
}

import { ethers } from "ethers";

const ACTION_ADDRESS = "0x0000000000000000000000000000000000000901";

const ACTION_ABI = [
  "function getActionFee(uint64 dataSizeKbs) view returns (uint256 baseFee, uint256 perKbFee, uint256 totalFee)",
  "function getAction(string actionId) view returns (tuple(string actionId, address creator, uint8 actionType, uint8 state, string metadata, uint256 price, int64 expirationTime, int64 blockHeight, address[] superNodes))",
  "event ActionRequested(string indexed actionId, address indexed creator, uint8 actionType, uint256 price)",
];

// Point at your node's EVM JSON-RPC endpoint (port 8545)
const provider = new ethers.JsonRpcProvider("http://localhost:8545");
const action = new ethers.Contract(ACTION_ADDRESS, ACTION_ABI, provider);

// Query the fee for 100 KB
const [baseFee, perKbFee, totalFee] = await action.getActionFee(100n);
console.log(`Total fee for 100 KB: ${totalFee} ulume`);

// Watch for new actions
action.on("ActionRequested", (actionId, creator, actionType, price) => {
  console.log(`New action ${actionId} by ${creator}, type=${actionType}, price=${price}`);
});