Optimisations in the sequencer inbox

deploy/BridgeStubCreator.js

@@ -3,7 +3,7 @@ module.exports = async hre => {
   const { deploy } = deployments
   const { deployer } = await getNamedAccounts()
 
-  await deploy('BridgeStub', { from: deployer, args: [] })
+  await deploy('BridgeStub', { from: deployer, args: [deployer] })
 }
 
 module.exports.tags = ['BridgeStub', 'test']

package.json

@@ -30,8 +30,10 @@
     "test:e2e": "hardhat test test/e2e/*.ts",
     "postinstall": "patch-package",
     "deploy-factory": "hardhat run scripts/deployment.ts",
+    "deploy-rollup": "hardhat run scripts/rollupCreation.ts",
     "deploy-eth-rollup": "hardhat run scripts/createEthRollup.ts",
-    "deploy-erc20-rollup": "hardhat run scripts/createERC20Rollup.ts"
+    "deploy-erc20-rollup": "hardhat run scripts/createERC20Rollup.ts",
+    "test": "hardhat --network hardhat test test/contract/*.spec.ts"
   },
   "dependencies": {
     "@offchainlabs/upgrade-executor": "1.1.0-beta.0",

scripts/config.ts.example

@@ -19,10 +19,10 @@ export const config = {
       '{"chainId":13331370,"homesteadBlock":0,"daoForkBlock":null,"daoForkSupport":true,"eip150Block":0,"eip150Hash":"0x0000000000000000000000000000000000000000000000000000000000000000","eip155Block":0,"eip158Block":0,"byzantiumBlock":0,"constantinopleBlock":0,"petersburgBlock":0,"istanbulBlock":0,"muirGlacierBlock":0,"berlinBlock":0,"londonBlock":0,"clique":{"period":0,"epoch":0},"arbitrum":{"EnableArbOS":true,"AllowDebugPrecompiles":false,"DataAvailabilityCommittee":false,"InitialArbOSVersion":10,"InitialChainOwner":"0x1234123412341234123412341234123412341234","GenesisBlockNum":0}}',
     genesisBlockNum: ethers.BigNumber.from('0'),
     sequencerInboxMaxTimeVariation: {
-      delayBlocks: ethers.BigNumber.from('5760'),
-      futureBlocks: ethers.BigNumber.from('12'),
-      delaySeconds: ethers.BigNumber.from('86400'),
-      futureSeconds: ethers.BigNumber.from('3600'),
+      delayBlocks: 5760,
+      futureBlocks: 12,
+      delaySeconds: 86400,
+      futureSeconds: 3600,
     },
   },
   validators: [

scripts/rollupCreation.ts

@@ -85,15 +85,11 @@ export async function createRollup(feeToken?: string) {
       maxDataSize: maxDataSize,
       nativeToken: feeToken,
       deployFactoriesToL2: true,
-      maxFeePerGasForRetryables: MAX_FER_PER_GAS
+      maxFeePerGasForRetryables: MAX_FER_PER_GAS,
     }
-    const createRollupTx = await rollupCreator.createRollup(
-      deployParams,
-      {
-        value: feeCost,
-      }
-
-    )
+    const createRollupTx = await rollupCreator.createRollup(deployParams, {
+      value: feeCost,
+    })
     const createRollupReceipt = await createRollupTx.wait()
 
     const rollupCreatedEvent = createRollupReceipt.events?.find(

src/bridge/AbsBridge.sol

@@ -14,11 +14,15 @@ import {
     NotSequencerInbox,
     NotOutbox,
     InvalidOutboxSet,
-    BadSequencerMessageNumber
+    BadSequencerMessageNumber,
+    EmptyDelayedMessagesRead,
+    DelayedBackwards,
+    DelayedTooFar
 } from "../libraries/Error.sol";
 import "./IBridge.sol";
 import "./Messages.sol";
 import "../libraries/DelegateCallAware.sol";
+import "./ISequencerInbox.sol";
 
 import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
 
@@ -55,8 +59,15 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
 
     uint256 public override sequencerReportedSubMessageCount;
 
+    uint256 public totalDelayedMessagesRead;
+
     address internal constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
 
+    function postUpgradeInit() external onlyDelegated onlyProxyOwner {
+        totalDelayedMessagesRead = ISequencerInbox(sequencerInbox).totalDelayedMessagesRead();
+        if (totalDelayedMessagesRead == 0) revert EmptyDelayedMessagesRead();
+    }
+
     modifier onlyRollupOrOwner() {
         if (msg.sender != address(rollup)) {
             address rollupOwner = rollup.owner();
@@ -101,7 +112,9 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         bytes32 dataHash,
         uint256 afterDelayedMessagesRead,
         uint256 prevMessageCount,
-        uint256 newMessageCount
+        uint256 newMessageCount,
+        TimeBounds memory timeBounds,
+        BatchDataLocation batchDataLocation
     )
         external
         onlySequencerInbox
@@ -119,6 +132,9 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         ) {
             revert BadSequencerMessageNumber(sequencerReportedSubMessageCount, prevMessageCount);
         }
+        if (afterDelayedMessagesRead > delayedInboxAccs.length) revert DelayedTooFar();
+        if (afterDelayedMessagesRead < totalDelayedMessagesRead) revert DelayedBackwards();
+
         sequencerReportedSubMessageCount = newMessageCount;
         seqMessageIndex = sequencerInboxAccs.length;
         if (sequencerInboxAccs.length > 0) {
@@ -129,6 +145,18 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
         }
         acc = keccak256(abi.encodePacked(beforeAcc, dataHash, delayedAcc));
         sequencerInboxAccs.push(acc);
+        totalDelayedMessagesRead = afterDelayedMessagesRead;
+
+        emit SequencerBatchDelivered(
+            seqMessageIndex,
+            beforeAcc,
+            acc,
+            delayedAcc,
+            afterDelayedMessagesRead,
+            timeBounds,
+            batchDataLocation,
+            msg.sender
+        );
     }
 
     /// @inheritdoc IBridge
@@ -304,5 +332,5 @@ abstract contract AbsBridge is Initializable, DelegateCallAware, IBridge {
      * variables without shifting down storage in the inheritance chain.
      * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
      */
-    uint256[40] private __gap;
+    uint256[39] private __gap;
 }

src/bridge/AbsOutbox.sol

@@ -76,6 +76,7 @@ abstract contract AbsOutbox is DelegateCallAware, IOutbox {
         });
         bridge = _bridge;
         rollup = address(_bridge.rollup());
+        if (address(rollup) == address(0)) revert RollupNotChanged();
     }
 
     function postUpgradeInit() external onlyDelegated onlyProxyOwner {

src/bridge/IBridge.sol

@@ -4,10 +4,24 @@
 
 // solhint-disable-next-line compiler-version
 pragma solidity >=0.6.9 <0.9.0;
+pragma experimental ABIEncoderV2;
 
 import "./IOwnable.sol";
 
 interface IBridge {
+    enum BatchDataLocation {
+        TxInput,
+        SeparateBatchEvent,
+        NoData
+    }
+
+    struct TimeBounds {
+        uint64 minTimestamp;
+        uint64 maxTimestamp;
+        uint64 minBlockNumber;
+        uint64 maxBlockNumber;
+    }
+
     event MessageDelivered(
         uint256 indexed messageIndex,
         bytes32 indexed beforeInboxAcc,
@@ -26,6 +40,17 @@ interface IBridge {
         bytes data
     );
 
+    event SequencerBatchDelivered(
+        uint256 indexed batchSequenceNumber,
+        bytes32 indexed beforeAcc,
+        bytes32 indexed afterAcc,
+        bytes32 delayedAcc,
+        uint256 afterDelayedMessagesRead,
+        TimeBounds timeBounds,
+        BatchDataLocation dataLocation,
+        address sequencerInbox
+    );
+
     event InboxToggle(address indexed inbox, bool enabled);
 
     event OutboxToggle(address indexed outbox, bool enabled);
@@ -66,13 +91,17 @@ interface IBridge {
 
     function sequencerMessageCount() external view returns (uint256);
 
+    function totalDelayedMessagesRead() external view returns (uint256);
+
     // ---------- onlySequencerInbox functions ----------
 
     function enqueueSequencerMessage(
         bytes32 dataHash,
         uint256 afterDelayedMessagesRead,
         uint256 prevMessageCount,
-        uint256 newMessageCount
+        uint256 newMessageCount,
+        TimeBounds memory timeBounds,
+        BatchDataLocation dataLocation
     )
         external
         returns (

src/bridge/ISequencerInbox.sol

@@ -11,36 +11,18 @@ import "./IDelayedMessageProvider.sol";
 import "./IBridge.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;
-        uint256 delaySeconds;
-        uint256 futureSeconds;
+        uint64 delayBlocks;
+        uint64 futureBlocks;
+        uint64 delaySeconds;
+        uint64 futureSeconds;
     }
 
-    struct TimeBounds {
-        uint64 minTimestamp;
-        uint64 maxTimestamp;
-        uint64 minBlockNumber;
-        uint64 maxBlockNumber;
-    }
-
-    enum BatchDataLocation {
-        TxInput,
-        SeparateBatchEvent,
-        NoData
-    }
-
-    event SequencerBatchDelivered(
-        uint256 indexed batchSequenceNumber,
-        bytes32 indexed beforeAcc,
-        bytes32 indexed afterAcc,
-        bytes32 delayedAcc,
-        uint256 afterDelayedMessagesRead,
-        TimeBounds timeBounds,
-        BatchDataLocation dataLocation
-    );
-
     event OwnerFunctionCalled(uint256 indexed id);
 
     /// @dev a separate event that emits batch data when this isn't easily accessible in the tx.input
@@ -52,6 +34,8 @@ interface ISequencerInbox is IDelayedMessageProvider {
     /// @dev a keyset was invalidated
     event InvalidateKeyset(bytes32 indexed keysetHash);
 
+    /// @notice The total number of delated messages read in the bridge
+    /// @dev    We surface this here for backwards compatibility
     function totalDelayedMessagesRead() external view returns (uint256);
 
     function bridge() external view returns (IBridge);
@@ -78,21 +62,11 @@ interface ISequencerInbox is IDelayedMessageProvider {
         uint64 creationBlock;
     }
 
-    function maxTimeVariation()
-        external
-        view
-        returns (
-            uint256,
-            uint256,
-            uint256,
-            uint256
-        );
+    /// @notice Returns the max time variation settings for this sequencer inbox
+    function maxTimeVariation() external view returns (ISequencerInbox.MaxTimeVariation memory);
 
     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
@@ -127,7 +101,9 @@ interface ISequencerInbox is IDelayedMessageProvider {
         uint256 sequenceNumber,
         bytes calldata data,
         uint256 afterDelayedMessagesRead,
-        IGasRefunder gasRefunder
+        IGasRefunder gasRefunder,
+        uint256 prevMessageCount,
+        uint256 newMessageCount
     ) external;
 
     function addSequencerL2Batch(
@@ -141,12 +117,6 @@ interface ISequencerInbox is IDelayedMessageProvider {
 
     // ---------- onlyRollupOrOwner functions ----------
 
-    /**
-     * @notice Set max delay for sequencer inbox
-     * @param maxTimeVariation_ the maximum time variation parameters
-     */
-    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
@@ -174,9 +144,6 @@ interface ISequencerInbox is IDelayedMessageProvider {
      */
     function setIsSequencer(address addr, bool isSequencer_) external;
 
-    // ---------- initializer ----------
-
-    function initialize(IBridge bridge_, MaxTimeVariation calldata maxTimeVariation_) external;
-
+    /// @notice Allows the rollup owner to sync the rollup address
     function updateRollupAddress() external;
 }