@arbitrum/nitro-contracts 2.0.0 → 3.0.0-alpha.0

package/src/bridge/IInbox.sol

@@ -1,5 +1,5 @@
 // Copyright 2021-2022, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
 // solhint-disable-next-line compiler-version
@@ -129,5 +129,7 @@ interface IInbox is IInboxBase {
      * @dev function to be called one time during the inbox upgrade process
      *      this is used to fix the storage slots
      */
-    function postUpgradeInit(IBridge _bridge) external;
+    function postUpgradeInit(
+        IBridge _bridge
+    ) external;
 }

package/src/bridge/IInboxBase.sol

@@ -16,19 +16,19 @@ interface IInboxBase is IDelayedMessageProvider {
 
     function maxDataSize() external view returns (uint256);
 
-    /**
-     * @notice Send a generic L2 message to the chain
-     * @dev This method is an optimization to avoid having to emit the entirety of the messageData in a log. Instead validators are expected to be able to parse the data from the transaction's input
-     * @param messageData Data of the message being sent
-     */
-    function sendL2MessageFromOrigin(bytes calldata messageData) external returns (uint256);
+    /// @dev Deprecated due to EIP-3074
+    function sendL2MessageFromOrigin(
+        bytes calldata
+    ) external returns (uint256);
 
     /**
      * @notice Send a generic L2 message to the chain
      * @dev This method can be used to send any type of message that doesn't require L1 validation
      * @param messageData Data of the message being sent
      */
-    function sendL2Message(bytes calldata messageData) external returns (uint256);
+    function sendL2Message(
+        bytes calldata messageData
+    ) external returns (uint256);
 
     function sendUnsignedTransaction(
         uint256 gasLimit,
@@ -54,10 +54,10 @@ interface IInboxBase is IDelayedMessageProvider {
      * @param dataLength The length of the retryable's calldata, in bytes
      * @param baseFee The block basefee when the retryable is included in the chain, if 0 current block.basefee will be used
      */
-    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
-        external
-        view
-        returns (uint256);
+    function calculateRetryableSubmissionFee(
+        uint256 dataLength,
+        uint256 baseFee
+    ) external view returns (uint256);
 
     // ---------- onlyRollupOrOwner functions ----------
 
@@ -71,10 +71,14 @@ interface IInboxBase is IDelayedMessageProvider {
     function setAllowList(address[] memory user, bool[] memory val) external;
 
     /// @notice enable or disable allowList
-    function setAllowListEnabled(bool _allowListEnabled) external;
+    function setAllowListEnabled(
+        bool _allowListEnabled
+    ) external;
 
     /// @notice check if user is in allowList
-    function isAllowed(address user) external view returns (bool);
+    function isAllowed(
+        address user
+    ) external view returns (bool);
 
     /// @notice check if allowList is enabled
     function allowListEnabled() external view returns (bool);

package/src/bridge/IOutbox.sol

@@ -10,21 +10,24 @@ import "./IBridge.sol";
 interface IOutbox {
     event SendRootUpdated(bytes32 indexed outputRoot, bytes32 indexed l2BlockHash);
     event OutBoxTransactionExecuted(
-        address indexed to,
-        address indexed l2Sender,
-        uint256 indexed zero,
-        uint256 transactionIndex
+        address indexed to, address indexed l2Sender, uint256 indexed zero, uint256 transactionIndex
     );
 
-    function initialize(IBridge _bridge) external;
+    function initialize(
+        IBridge _bridge
+    ) external;
 
     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 spent(
+        uint256
+    ) external view returns (bytes32); // packed spent bitmap
 
-    function roots(bytes32) external view returns (bytes32); // maps root hashes => L2 block hash
+    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
@@ -104,7 +107,9 @@ interface IOutbox {
      * @param index Merkle path to message
      * @return true if the message has been spent
      */
-    function isSpent(uint256 index) external view returns (bool);
+    function isSpent(
+        uint256 index
+    ) external view returns (bool);
 
     function calculateItemHash(
         address l2Sender,

package/src/bridge/ISequencerInbox.sol

@@ -9,8 +9,15 @@ pragma experimental ABIEncoderV2;
 import "../libraries/IGasRefunder.sol";
 import "./IDelayedMessageProvider.sol";
 import "./IBridge.sol";
+import "./Messages.sol";
+import "./DelayBufferTypes.sol";
 
 interface ISequencerInbox is IDelayedMessageProvider {
+    /// @notice The maximum amount of time variatin between a message being posted on the L1 and being executed on the L2
+    /// @param delayBlocks The max amount of blocks in the past that a message can be received on L2
+    /// @param futureBlocks The max amount of blocks in the future that a message can be received on L2
+    /// @param delaySeconds The max amount of seconds in the past that a message can be received on L2
+    /// @param futureSeconds The max amount of seconds in the future that a message can be received on L2
     struct MaxTimeVariation {
         uint256 delayBlocks;
         uint256 futureBlocks;
@@ -39,6 +46,29 @@ interface ISequencerInbox is IDelayedMessageProvider {
     /// @dev a keyset was invalidated
     event InvalidateKeyset(bytes32 indexed keysetHash);
 
+    /// @dev Owner set max time variation.
+    ///      This event may have been introduced in an upgrade and therefore might not give the full history.
+    ///      To get the full history, search for `OwnerFunctionCalled(0)` events.
+    event MaxTimeVariationSet(MaxTimeVariation maxTimeVariation);
+
+    /// @dev Owner set a batch poster.
+    ///      This event may have been introduced in an upgrade and therefore might not give the full history.
+    ///      To get the full history, search for `OwnerFunctionCalled(1)` events.
+    event BatchPosterSet(address batchPoster, bool isBatchPoster);
+
+    /// @dev Owner or batch poster manager set a sequencer.
+    ///      This event may have been introduced in an upgrade and therefore might not give the full history.
+    ///      To get the full history, search for `OwnerFunctionCalled(4)` events.
+    event SequencerSet(address addr, bool isSequencer);
+
+    /// @dev Owner set the batch poster manager.
+    ///      This event may have been introduced in an upgrade and therefore might not give the full history.
+    ///      To get the full history, search for `OwnerFunctionCalled(5)` events.
+    event BatchPosterManagerSet(address newBatchPosterManager);
+
+    /// @dev Owner set the buffer config.
+    event BufferConfigSet(BufferConfig bufferConfig);
+
     function totalDelayedMessagesRead() external view returns (uint256);
 
     function bridge() external view returns (IBridge);
@@ -85,9 +115,16 @@ interface ISequencerInbox is IDelayedMessageProvider {
 
     function rollup() external view returns (IOwnable);
 
-    function isBatchPoster(address) external view returns (bool);
+    function isBatchPoster(
+        address
+    ) external view returns (bool);
+
+    function isSequencer(
+        address
+    ) external view returns (bool);
 
-    function isSequencer(address) external view returns (bool);
+    /// @notice True is the sequencer inbox is delay bufferable
+    function isDelayBufferable() external view returns (bool);
 
     function maxDataSize() external view returns (uint256);
 
@@ -111,14 +148,16 @@ interface ISequencerInbox is IDelayedMessageProvider {
             uint256 futureSeconds
         );
 
-    function dasKeySetInfo(bytes32) external view returns (bool, uint64);
+    function dasKeySetInfo(
+        bytes32
+    ) external view returns (bool, uint64);
 
     /// @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
+    ///         Callable by any address, but message can only be force-included after maxTimeVariation.delayBlocks
+    ///         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
@@ -135,17 +174,34 @@ interface ISequencerInbox is IDelayedMessageProvider {
         bytes32 messageDataHash
     ) external;
 
-    function inboxAccs(uint256 index) external view returns (bytes32);
+    function inboxAccs(
+        uint256 index
+    ) external view returns (bytes32);
 
     function batchCount() external view returns (uint256);
 
-    function isValidKeysetHash(bytes32 ksHash) external view returns (bool);
+    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);
+    function getKeysetCreationBlock(
+        bytes32 ksHash
+    ) external view returns (uint256);
+
+    /// @dev    The delay buffer can change due to pending depletion/replenishment.
+    ///         This function applies pending buffer changes to proactively calculate the force inclusion deadline.
+    ///         This is only relevant when the buffer is less than the delayBlocks (unhappy case), otherwise force inclusion deadline is fixed at delayBlocks.
+    /// @notice Calculates the upper bounds of the delay buffer
+    /// @param blockNumber The block number when a delayed message was created
+    /// @return blockNumberDeadline The block number at when the message can be force included
+    function forceInclusionDeadline(
+        uint64 blockNumber
+    ) external view returns (uint64 blockNumberDeadline);
 
     // ---------- BatchPoster functions ----------
 
+    /// @dev Deprecated, kept for abi generation and will be removed in the future
     function addSequencerL2BatchFromOrigin(
         uint256 sequenceNumber,
         bytes calldata data,
@@ -153,6 +209,7 @@ interface ISequencerInbox is IDelayedMessageProvider {
         IGasRefunder gasRefunder
     ) external;
 
+    /// @dev Will be deprecated due to EIP-3074, use `addSequencerL2Batch` instead
     function addSequencerL2BatchFromOrigin(
         uint256 sequenceNumber,
         bytes calldata data,
@@ -179,13 +236,51 @@ interface ISequencerInbox is IDelayedMessageProvider {
         uint256 newMessageCount
     ) external;
 
+    /// @dev    Proves message delays, updates delay buffers, and posts an L2 batch with blob data.
+    ///         DelayProof proves the delay of the message and syncs the delay buffer.
+    function addSequencerL2BatchFromBlobsDelayProof(
+        uint256 sequenceNumber,
+        uint256 afterDelayedMessagesRead,
+        IGasRefunder gasRefunder,
+        uint256 prevMessageCount,
+        uint256 newMessageCount,
+        DelayProof calldata delayProof
+    ) external;
+
+    /// @dev    Proves message delays, updates delay buffers, and posts an L2 batch with calldata posted from an EOA.
+    ///         DelayProof proves the delay of the message and syncs the delay buffer.
+    ///         Will be deprecated due to EIP-3074, use `addSequencerL2BatchDelayProof` instead
+    function addSequencerL2BatchFromOriginDelayProof(
+        uint256 sequenceNumber,
+        bytes calldata data,
+        uint256 afterDelayedMessagesRead,
+        IGasRefunder gasRefunder,
+        uint256 prevMessageCount,
+        uint256 newMessageCount,
+        DelayProof calldata delayProof
+    ) external;
+
+    /// @dev    Proves message delays, updates delay buffers, and posts an L2 batch with calldata.
+    ///         delayProof is used to prove the delay of the message and syncs the delay buffer.
+    function addSequencerL2BatchDelayProof(
+        uint256 sequenceNumber,
+        bytes calldata data,
+        uint256 afterDelayedMessagesRead,
+        IGasRefunder gasRefunder,
+        uint256 prevMessageCount,
+        uint256 newMessageCount,
+        DelayProof calldata delayProof
+    ) external;
+
     // ---------- onlyRollupOrOwner functions ----------
 
     /**
      * @notice Set max delay for sequencer inbox
      * @param maxTimeVariation_ the maximum time variation parameters
      */
-    function setMaxTimeVariation(MaxTimeVariation memory maxTimeVariation_) external;
+    function setMaxTimeVariation(
+        MaxTimeVariation memory maxTimeVariation_
+    ) external;
 
     /**
      * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
@@ -198,13 +293,17 @@ interface ISequencerInbox is IDelayedMessageProvider {
      * @notice Makes Data Availability Service keyset valid
      * @param keysetBytes bytes of the serialized keyset
      */
-    function setValidKeyset(bytes calldata keysetBytes) external;
+    function setValidKeyset(
+        bytes calldata keysetBytes
+    ) external;
 
     /**
      * @notice Invalidates a Data Availability Service keyset
      * @param ksHash hash of the keyset
      */
-    function invalidateKeysetHash(bytes32 ksHash) external;
+    function invalidateKeysetHash(
+        bytes32 ksHash
+    ) external;
 
     /**
      * @notice Updates whether an address is authorized to be a sequencer.
@@ -218,12 +317,18 @@ interface ISequencerInbox is IDelayedMessageProvider {
      * @notice Updates the batch poster manager, the address which has the ability to rotate batch poster keys
      * @param newBatchPosterManager The new batch poster manager to be set
      */
-    function setBatchPosterManager(address newBatchPosterManager) external;
+    function setBatchPosterManager(
+        address newBatchPosterManager
+    ) external;
 
     /// @notice Allows the rollup owner to sync the rollup address
     function updateRollupAddress() external;
 
     // ---------- initializer ----------
 
-    function initialize(IBridge bridge_, MaxTimeVariation calldata maxTimeVariation_) external;
+    function initialize(
+        IBridge bridge_,
+        MaxTimeVariation calldata maxTimeVariation_,
+        BufferConfig calldata bufferConfig_
+    ) external;
 }