Cryo Explorer Ethereum Mainnet

// (c) Cartesi and individual authors (see AUTHORS)
// SPDX-License-Identifier: Apache-2.0 (see LICENSE)

pragma solidity ^0.8.8;

/// @title Canonical Machine Constants Library
///
/// @notice Defines several constants related to the reference implementation
/// of the RISC-V machine that runs Linux, also known as the "Cartesi Machine".
library CanonicalMachine {
    /// @notice Maximum input size (64 kilobytes).
    uint256 constant INPUT_MAX_SIZE = 1 << 16;

    /// @notice Log2 of maximum number of outputs.
    uint256 constant LOG2_MAX_OUTPUTS = 63;
}

// (c) Cartesi and individual authors (see AUTHORS)
// SPDX-License-Identifier: Apache-2.0 (see LICENSE)

pragma solidity ^0.8.8;

/// @title Inputs
/// @notice Defines the signatures of inputs.
interface Inputs {
    /// @notice An advance request from an EVM-compatible blockchain to a Cartesi Machine.
    /// @param chainId The chain ID
    /// @param appContract The application contract address
    /// @param msgSender The address of whoever sent the input
    /// @param blockNumber The number of the block in which the input was added
    /// @param blockTimestamp The timestamp of the block in which the input was added
    /// @param prevRandao The latest RANDAO mix of the post beacon state of the previous block
    /// @param index The index of the input in the input box
    /// @param payload The payload provided by the message sender
    /// @dev See EIP-4399 for safe usage of `prevRandao`.
    function EvmAdvance(
        uint256 chainId,
        address appContract,
        address msgSender,
        uint256 blockNumber,
        uint256 blockTimestamp,
        uint256 prevRandao,
        uint256 index,
        bytes calldata payload
    ) external;
}

// (c) Cartesi and individual authors (see AUTHORS)
// SPDX-License-Identifier: Apache-2.0 (see LICENSE)

pragma solidity ^0.8.8;

/// @notice Provides data availability of inputs for applications.
/// @notice Each application has its own append-only list of inputs.
/// @notice Off-chain, inputs can be retrieved via events.
/// @notice On-chain, only the input hashes are stored.
/// @notice See `LibInput` for more details on how such hashes are computed.
interface IInputBox {
    /// @notice MUST trigger when an input is added.
    /// @param appContract The application contract address
    /// @param index The input index
    /// @param input The input blob
    event InputAdded(address indexed appContract, uint256 indexed index, bytes input);

    /// @notice Input is too large.
    /// @param appContract The application contract address
    /// @param inputLength The input length
    /// @param maxInputLength The maximum input length
    error InputTooLarge(address appContract, uint256 inputLength, uint256 maxInputLength);

    /// @notice Send an input to an application.
    /// @param appContract The application contract address
    /// @param payload The input payload
    /// @return The hash of the input blob
    /// @dev MUST fire an `InputAdded` event.
    function addInput(address appContract, bytes calldata payload)
        external
        returns (bytes32);

    /// @notice Get the number of inputs sent to an application.
    /// @param appContract The application contract address
    function getNumberOfInputs(address appContract) external view returns (uint256);

    /// @notice Get the hash of an input in an application's input box.
    /// @param appContract The application contract address
    /// @param index The input index
    /// @dev The provided index must be valid.
    function getInputHash(address appContract, uint256 index)
        external
        view
        returns (bytes32);

    /// @notice Get number of block in which contract was deployed
    function getDeploymentBlockNumber() external view returns (uint256);
}

// (c) Cartesi and individual authors (see AUTHORS)
// SPDX-License-Identifier: Apache-2.0 (see LICENSE)

pragma solidity ^0.8.18;

import {IInputBox} from "./IInputBox.sol";
import {CanonicalMachine} from "../common/CanonicalMachine.sol";
import {Inputs} from "../common/Inputs.sol";

contract InputBox is IInputBox {
    /// @notice Deployment block number
    uint256 immutable _deploymentBlockNumber = block.number;

    /// @notice Mapping of application contract addresses to arrays of input hashes.
    mapping(address => bytes32[]) private _inputBoxes;

    /// @inheritdoc IInputBox
    function addInput(address appContract, bytes calldata payload)
        external
        override
        returns (bytes32)
    {
        bytes32[] storage inputBox = _inputBoxes[appContract];

        uint256 index = inputBox.length;

        bytes memory input = abi.encodeCall(
            Inputs.EvmAdvance,
            (
                block.chainid,
                appContract,
                msg.sender,
                block.number,
                block.timestamp,
                block.prevrandao,
                index,
                payload
            )
        );

        if (input.length > CanonicalMachine.INPUT_MAX_SIZE) {
            revert InputTooLarge(
                appContract, input.length, CanonicalMachine.INPUT_MAX_SIZE
            );
        }

        bytes32 inputHash = keccak256(input);

        inputBox.push(inputHash);

        emit InputAdded(appContract, index, input);

        return inputHash;
    }

    /// @inheritdoc IInputBox
    function getNumberOfInputs(address appContract)
        external
        view
        override
        returns (uint256)
    {
        return _inputBoxes[appContract].length;
    }

    /// @inheritdoc IInputBox
    function getInputHash(address appContract, uint256 index)
        external
        view
        override
        returns (bytes32)
    {
        return _inputBoxes[appContract][index];
    }

    /// @inheritdoc IInputBox
    function getDeploymentBlockNumber() external view override returns (uint256) {
        return _deploymentBlockNumber;
    }
}