@arbitrum/nitro-contracts 1.0.0-beta.7 → 1.0.0

package/src/bridge/IOutbox.sol

@@ -2,32 +2,13 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
-import {AlreadyInit, NotRollup} from "../libraries/Error.sol";
-
-/// @dev The provided proof was too long
-/// @param proofLength The length of the too-long proof
-error ProofTooLong(uint256 proofLength);
-
-/// @dev The output index was greater than the maximum
-/// @param index The output index
-/// @param maxIndex The max the index could be
-error PathNotMinimal(uint256 index, uint256 maxIndex);
-
-/// @dev The calculated root does not exist
-/// @param root The calculated root
-error UnknownRoot(bytes32 root);
-
-/// @dev The record has already been spent
-/// @param index The index of the spent record
-error AlreadySpent(uint256 index);
-
-/// @dev A call to the bridge failed with no return data
-error BridgeCallFailed();
+import "./IBridge.sol";
 
 interface IOutbox {
-    event SendRootUpdated(bytes32 indexed blockHash, bytes32 indexed outputRoot);
+    event SendRootUpdated(bytes32 indexed outputRoot, bytes32 indexed l2BlockHash);
     event OutBoxTransactionExecuted(
         address indexed to,
         address indexed l2Sender,
@@ -35,18 +16,105 @@ interface IOutbox {
         uint256 transactionIndex
     );
 
+    function rollup() external view returns (address); // the rollup contract
+
+    function bridge() external view returns (IBridge); // the bridge contract
+
+    function spent(uint256) external view returns (bytes32); // packed spent bitmap
+
+    function roots(bytes32) external view returns (bytes32); // maps root hashes => L2 block hash
+
+    // solhint-disable-next-line func-name-mixedcase
+    function OUTBOX_VERSION() external view returns (uint128); // the outbox version
+
+    function updateSendRoot(bytes32 sendRoot, bytes32 l2BlockHash) external;
+
+    /// @notice When l2ToL1Sender returns a nonzero address, the message was originated by an L2 account
+    ///         When the return value is zero, that means this is a system message
+    /// @dev the l2ToL1Sender behaves as the tx.origin, the msg.sender should be validated to protect against reentrancies
     function l2ToL1Sender() external view returns (address);
 
+    /// @return l2Block return L2 block when the L2 tx was initiated or 0 if no L2 to L1 transaction is active
     function l2ToL1Block() external view returns (uint256);
 
+    /// @return l1Block return L1 block when the L2 tx was initiated or 0 if no L2 to L1 transaction is active
     function l2ToL1EthBlock() external view returns (uint256);
 
+    /// @return timestamp return L2 timestamp when the L2 tx was initiated or 0 if no L2 to L1 transaction is active
     function l2ToL1Timestamp() external view returns (uint256);
 
-    // @deprecated batch number is now always 0
-    function l2ToL1BatchNum() external view returns (uint256);
-
+    /// @return outputId returns the unique output identifier of the L2 to L1 tx or 0 if no L2 to L1 transaction is active
     function l2ToL1OutputId() external view returns (bytes32);
 
-    function updateSendRoot(bytes32 sendRoot, bytes32 l2BlockHash) external;
+    /**
+     * @notice Executes a messages in an Outbox entry.
+     * @dev Reverts if dispute period hasn't expired, since the outbox entry
+     *      is only created once the rollup confirms the respective assertion.
+     * @dev it is not possible to execute any L2-to-L1 transaction which contains data
+     *      to a contract address without any code (as enforced by the Bridge contract).
+     * @param proof Merkle proof of message inclusion in send root
+     * @param index Merkle path to message
+     * @param l2Sender sender if original message (i.e., caller of ArbSys.sendTxToL1)
+     * @param to destination address for L1 contract call
+     * @param l2Block l2 block number at which sendTxToL1 call was made
+     * @param l1Block l1 block number at which sendTxToL1 call was made
+     * @param l2Timestamp l2 Timestamp at which sendTxToL1 call was made
+     * @param value wei in L1 message
+     * @param data abi-encoded L1 message data
+     */
+    function executeTransaction(
+        bytes32[] calldata proof,
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external;
+
+    /**
+     *  @dev function used to simulate the result of a particular function call from the outbox
+     *       it is useful for things such as gas estimates. This function includes all costs except for
+     *       proof validation (which can be considered offchain as a somewhat of a fixed cost - it's
+     *       not really a fixed cost, but can be treated as so with a fixed overhead for gas estimation).
+     *       We can't include the cost of proof validation since this is intended to be used to simulate txs
+     *       that are included in yet-to-be confirmed merkle roots. The simulation entrypoint could instead pretend
+     *       to confirm a pending merkle root, but that would be less practical for integrating with tooling.
+     *       It is only possible to trigger it when the msg sender is address zero, which should be impossible
+     *       unless under simulation in an eth_call or eth_estimateGas
+     */
+    function executeTransactionSimulation(
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external;
+
+    /**
+     * @param index Merkle path to message
+     * @return true if the message has been spent
+     */
+    function isSpent(uint256 index) external view returns (bool);
+
+    function calculateItemHash(
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external pure returns (bytes32);
+
+    function calculateMerkleRoot(
+        bytes32[] memory proof,
+        uint256 path,
+        bytes32 item
+    ) external pure returns (bytes32);
 }

package/src/bridge/IOwnable.sol

@@ -2,7 +2,8 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.4.21 <0.9.0;
 
 interface IOwnable {
     function owner() external view returns (address);

package/src/bridge/ISequencerInbox.sol

@@ -2,11 +2,13 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.0;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
+pragma experimental ABIEncoderV2;
 
 import "../libraries/IGasRefunder.sol";
-import {AlreadyInit, HadZeroInit, NotOrigin, DataTooLarge, NotRollup} from "../libraries/Error.sol";
 import "./IDelayedMessageProvider.sol";
+import "./IBridge.sol";
 
 interface ISequencerInbox is IDelayedMessageProvider {
     struct MaxTimeVariation {
@@ -50,63 +52,109 @@ interface ISequencerInbox is IDelayedMessageProvider {
     /// @dev a keyset was invalidated
     event InvalidateKeyset(bytes32 indexed keysetHash);
 
-    /// @dev Thrown when someone attempts to read fewer messages than have already been read
-    error DelayedBackwards();
+    function totalDelayedMessagesRead() external view returns (uint256);
 
-    /// @dev Thrown when someone attempts to read more messages than exist
-    error DelayedTooFar();
+    function bridge() external view returns (IBridge);
 
-    /// @dev Force include can only read messages more blocks old than the delay period
-    error ForceIncludeBlockTooSoon();
+    /// @dev The size of the batch header
+    // solhint-disable-next-line func-name-mixedcase
+    function HEADER_LENGTH() external view returns (uint256);
 
-    /// @dev Force include can only read messages more seconds old than the delay period
-    error ForceIncludeTimeTooSoon();
+    /// @dev If the first batch data byte after the header has this bit set,
+    ///      the sequencer inbox has authenticated the data. Currently not used.
+    // solhint-disable-next-line func-name-mixedcase
+    function DATA_AUTHENTICATED_FLAG() external view returns (bytes1);
 
-    /// @dev The message provided did not match the hash in the delayed inbox
-    error IncorrectMessagePreimage();
+    function rollup() external view returns (IOwnable);
 
-    /// @dev This can only be called by the batch poster
-    error NotBatchPoster();
+    function isBatchPoster(address) external view returns (bool);
 
-    /// @dev The sequence number provided to this message was inconsistent with the number of batches already included
-    error BadSequencerNumber(uint256 stored, uint256 received);
-
-    /// @dev The batch data has the inbox authenticated bit set, but the batch data was not authenticated by the inbox
-    error DataNotAuthenticated();
-
-    /// @dev Tried to create an already valid Data Availability Service keyset
-    error AlreadyValidDASKeyset(bytes32);
+    struct DasKeySetInfo {
+        bool isValidKeyset;
+        uint64 creationBlock;
+    }
 
-    /// @dev Tried to use or invalidate an already invalid Data Availability Service keyset
-    error NoSuchKeyset(bytes32);
+    // https://github.com/ethereum/solidity/issues/11826
+    // function maxTimeVariation() external view returns (MaxTimeVariation calldata);
+    // function dasKeySetInfo(bytes32) external view returns (DasKeySetInfo calldata);
+
+    /// @notice Remove force inclusion delay after a L1 chainId fork
+    function removeDelayAfterFork() external;
+
+    /// @notice Force messages from the delayed inbox to be included in the chain
+    ///         Callable by any address, but message can only be force-included after maxTimeVariation.delayBlocks and
+    ///         maxTimeVariation.delaySeconds has elapsed. As part of normal behaviour the sequencer will include these
+    ///         messages so it's only necessary to call this if the sequencer is down, or not including any delayed messages.
+    /// @param _totalDelayedMessagesRead The total number of messages to read up to
+    /// @param kind The kind of the last message to be included
+    /// @param l1BlockAndTime The l1 block and the l1 timestamp of the last message to be included
+    /// @param baseFeeL1 The l1 gas price of the last message to be included
+    /// @param sender The sender of the last message to be included
+    /// @param messageDataHash The messageDataHash of the last message to be included
+    function forceInclusion(
+        uint256 _totalDelayedMessagesRead,
+        uint8 kind,
+        uint64[2] calldata l1BlockAndTime,
+        uint256 baseFeeL1,
+        address sender,
+        bytes32 messageDataHash
+    ) external;
 
     function inboxAccs(uint256 index) external view returns (bytes32);
 
     function batchCount() external view returns (uint256);
 
-    function addSequencerL2Batch(
+    function isValidKeysetHash(bytes32 ksHash) external view returns (bool);
+
+    /// @notice the creation block is intended to still be available after a keyset is deleted
+    function getKeysetCreationBlock(bytes32 ksHash) external view returns (uint256);
+
+    // ---------- BatchPoster functions ----------
+
+    function addSequencerL2BatchFromOrigin(
         uint256 sequenceNumber,
         bytes calldata data,
         uint256 afterDelayedMessagesRead,
         IGasRefunder gasRefunder
     ) external;
 
-    // Methods only callable by rollup owner
+    function addSequencerL2Batch(
+        uint256 sequenceNumber,
+        bytes calldata data,
+        uint256 afterDelayedMessagesRead,
+        IGasRefunder gasRefunder,
+        uint256 prevMessageCount,
+        uint256 newMessageCount
+    ) external;
+
+    // ---------- onlyRollupOrOwner functions ----------
 
     /**
-     * @notice Set max time variation from actual time for sequencer inbox
-     * @param timeVariation the maximum time variation parameters
+     * @notice Set max delay for sequencer inbox
+     * @param maxTimeVariation_ the maximum time variation parameters
      */
-    function setMaxTimeVariation(MaxTimeVariation memory timeVariation) external;
+    function setMaxTimeVariation(MaxTimeVariation memory maxTimeVariation_) external;
 
     /**
      * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
      * @param addr the address
-     * @param isBatchPoster if the specified address should be authorized as a batch poster
+     * @param isBatchPoster_ if the specified address should be authorized as a batch poster
      */
-    function setIsBatchPoster(address addr, bool isBatchPoster) external;
+    function setIsBatchPoster(address addr, bool isBatchPoster_) external;
 
+    /**
+     * @notice Makes Data Availability Service keyset valid
+     * @param keysetBytes bytes of the serialized keyset
+     */
     function setValidKeyset(bytes calldata keysetBytes) external;
 
+    /**
+     * @notice Invalidates a Data Availability Service keyset
+     * @param ksHash hash of the keyset
+     */
     function invalidateKeysetHash(bytes32 ksHash) external;
+
+    // ---------- initializer ----------
+
+    function initialize(IBridge bridge_, MaxTimeVariation calldata maxTimeVariation_) external;
 }