Refactor accumulator flow

contracts/src/bridge/Bridge.sol

@@ -11,6 +11,8 @@ import "./IBridge.sol";
 import "./Messages.sol";
 import "../libraries/DelegateCallAware.sol";
 
+import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
+
 /**
  * @title Staging ground for incoming and outgoing messages
  * @notice Holds the inbox accumulator for delayed messages, and is the ETH escrow
@@ -26,16 +28,21 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         bool allowed;
     }
 
-    mapping(address => InOutInfo) private allowedInboxesMap;
+    mapping(address => InOutInfo) private allowedDelayedInboxesMap;
     mapping(address => InOutInfo) private allowedOutboxesMap;
 
-    address[] public allowedInboxList;
+    address[] public allowedDelayedInboxList;
     address[] public allowedOutboxList;
 
     address private _activeOutbox;
 
     /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
-    bytes32[] public override inboxAccs;
+    bytes32[] public override delayedInboxAccs;
+
+    /// @dev Accumulator for sequencer inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    bytes32[] public override sequencerInboxAccs;
+
+    address public sequencerInbox;
 
     address private constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
 
@@ -55,14 +62,71 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         return outbox;
     }
 
-    function allowedInboxes(address inbox) external view override returns (bool) {
-        return allowedInboxesMap[inbox].allowed;
+    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+        return allowedDelayedInboxesMap[inbox].allowed;
     }
 
     function allowedOutboxes(address outbox) external view override returns (bool) {
         return allowedOutboxesMap[outbox].allowed;
     }
 
+    /// @param batchPoster sequencer that included the batch, or zero if not a sequencer
+    function enqueueSequencerMessage(
+        bytes32 dataHash,
+        uint256 afterDelayedMessagesRead,
+        address batchPoster
+    )
+        external
+        override
+        returns (
+            uint256 seqMessageCount,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        )
+    {
+        if (msg.sender != sequencerInbox) revert NotSequencerInbox(msg.sender);
+        seqMessageCount = sequencerInboxAccs.length;
+        if (sequencerInboxAccs.length > 0) {
+            beforeAcc = sequencerInboxAccs[sequencerInboxAccs.length - 1];
+        }
+        if (afterDelayedMessagesRead > 0) {
+            delayedAcc = delayedInboxAccs[afterDelayedMessagesRead - 1];
+        }
+        acc = keccak256(abi.encodePacked(beforeAcc, dataHash, delayedAcc));
+        sequencerInboxAccs.push(acc);
+
+        if (batchPoster != address(0)) {
+            // we ignore the return value as we don't need the updated delayed inbox count
+            // as this msg isn't included in the current sequencer batch
+            submitBatchSpendingReport(batchPoster, dataHash, seqMessageCount);
+        }
+    }
+
+    function submitBatchSpendingReport(
+        address batchPoster,
+        bytes32 dataHash,
+        uint256 seqMessageCount
+    ) internal returns (uint256) {
+        bytes memory messageData = abi.encodePacked(
+            block.timestamp,
+            batchPoster,
+            dataHash,
+            seqMessageCount,
+            block.basefee
+        );
+
+        return
+            addMessageToDelayedAccumulator(
+                L1MessageType_batchPostingReport,
+                batchPoster,
+                uint64(block.number),
+                uint64(block.timestamp), // solhint-disable-line not-rely-on-time,
+                block.basefee,
+                keccak256(messageData)
+            );
+    }
+
     /**
      * @dev Enqueue a message in the delayed inbox accumulator.
      * These messages are later sequenced in the SequencerInbox, either by the sequencer as
@@ -73,9 +137,9 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         address sender,
         bytes32 messageDataHash
     ) external payable override returns (uint256) {
-        if (!allowedInboxesMap[msg.sender].allowed) revert NotInbox(msg.sender);
+        if (!allowedDelayedInboxesMap[msg.sender].allowed) revert NotDelayedInbox(msg.sender);
         return
-            addMessageToAccumulator(
+            addMessageToDelayedAccumulator(
                 kind,
                 sender,
                 uint64(block.number),
@@ -85,15 +149,15 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
             );
     }
 
-    function addMessageToAccumulator(
+    function addMessageToDelayedAccumulator(
         uint8 kind,
         address sender,
         uint64 blockNumber,
         uint64 blockTimestamp,
         uint256 baseFeeL1,
         bytes32 messageDataHash
     ) internal returns (uint256) {
-        uint256 count = inboxAccs.length;
+        uint256 count = delayedInboxAccs.length;
         bytes32 messageHash = Messages.messageHash(
             kind,
             sender,
@@ -105,9 +169,9 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         );
         bytes32 prevAcc = 0;
         if (count > 0) {
-            prevAcc = inboxAccs[count - 1];
+            prevAcc = delayedInboxAccs[count - 1];
         }
-        inboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
         emit MessageDelivered(
             count,
             prevAcc,
@@ -140,21 +204,28 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         emit BridgeCallTriggered(msg.sender, to, value, data);
     }
 
-    function setInbox(address inbox, bool enabled) external override onlyOwner {
-        InOutInfo storage info = allowedInboxesMap[inbox];
+    function setSequencerInbox(address _sequencerInbox) external override onlyOwner {
+        sequencerInbox = _sequencerInbox;
+        emit SequencerInboxUpdated(_sequencerInbox);
+    }
+
+    function setDelayedInbox(address inbox, bool enabled) external override onlyOwner {
+        InOutInfo storage info = allowedDelayedInboxesMap[inbox];
         bool alreadyEnabled = info.allowed;
         emit InboxToggle(inbox, enabled);
         if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
             return;
         }
         if (enabled) {
-            allowedInboxesMap[inbox] = InOutInfo(allowedInboxList.length, true);
-            allowedInboxList.push(inbox);
+            allowedDelayedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
+            allowedDelayedInboxList.push(inbox);
         } else {
-            allowedInboxList[info.index] = allowedInboxList[allowedInboxList.length - 1];
-            allowedInboxesMap[allowedInboxList[info.index]].index = info.index;
-            allowedInboxList.pop();
-            delete allowedInboxesMap[inbox];
+            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
+                allowedDelayedInboxList.length - 1
+            ];
+            allowedDelayedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
+            allowedDelayedInboxList.pop();
+            delete allowedDelayedInboxesMap[inbox];
         }
     }
 
@@ -178,7 +249,11 @@ contract Bridge is OwnableUpgradeable, DelegateCallAware, IBridge {
         }
     }
 
-    function messageCount() external view override returns (uint256) {
-        return inboxAccs.length;
+    function delayedMessageCount() external view override returns (uint256) {
+        return delayedInboxAccs.length;
+    }
+
+    function sequencerMessageCount() external view override returns (uint256) {
+        return sequencerInboxAccs.length;
     }
 }

contracts/src/bridge/IBridge.sol

@@ -8,7 +8,11 @@ import {NotContract} from "../libraries/Error.sol";
 
 /// @dev Thrown when an un-authorized address tries to access an only-inbox function
 /// @param sender The un-authorized sender
-error NotInbox(address sender);
+error NotDelayedInbox(address sender);
+
+/// @dev Thrown when an un-authorized address tries to access an only-sequencer-inbox function
+/// @param sender The un-authorized sender
+error NotSequencerInbox(address sender);
 
 /// @dev Thrown when an un-authorized address tries to access an only-outbox function
 /// @param sender The un-authorized sender
@@ -41,32 +45,55 @@ interface IBridge {
 
     event OutboxToggle(address indexed outbox, bool enabled);
 
+    event SequencerInboxUpdated(address newSequencerInbox);
+
     function enqueueDelayedMessage(
         uint8 kind,
         address sender,
         bytes32 messageDataHash
     ) external payable returns (uint256);
 
+    function enqueueSequencerMessage(
+        bytes32 dataHash,
+        uint256 afterDelayedMessagesRead,
+        address batchPoster
+    )
+        external
+        returns (
+            uint256 sequencerMessageCount,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 acc
+        );
+
     function executeCall(
         address to,
         uint256 value,
         bytes calldata data
     ) external returns (bool success, bytes memory returnData);
 
     // These are only callable by the admin
-    function setInbox(address inbox, bool enabled) external;
+    function setDelayedInbox(address inbox, bool enabled) external;
 
     function setOutbox(address inbox, bool enabled) external;
 
+    function setSequencerInbox(address _sequencerInbox) external;
+
     // View functions
 
+    function sequencerInbox() external view returns (address);
+
     function activeOutbox() external view returns (address);
 
-    function allowedInboxes(address inbox) external view returns (bool);
+    function allowedDelayedInboxes(address inbox) external view returns (bool);
 
     function allowedOutboxes(address outbox) external view returns (bool);
 
-    function inboxAccs(uint256 index) external view returns (bytes32);
+    function delayedInboxAccs(uint256 index) external view returns (bytes32);
+
+    function sequencerInboxAccs(uint256 index) external view returns (bytes32);
+
+    function delayedMessageCount() external view returns (uint256);
 
-    function messageCount() external view returns (uint256);
+    function sequencerMessageCount() external view returns (uint256);
 }

contracts/src/bridge/IInbox.sol

@@ -73,12 +73,6 @@ interface IInbox is IMessageProvider {
         bytes calldata data
     ) external payable returns (uint256);
 
-    function submitBatchSpendingReportTransaction(
-        address batchPosterAddr,
-        bytes32 dataHash,
-        uint256 batchNumber
-    ) external returns (uint256);
-
     /// @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
     function createRetryableTicket(
         address to,

contracts/src/bridge/Inbox.sol

@@ -16,7 +16,6 @@ import {
     L1MessageType_L2FundedByL1,
     L1MessageType_submitRetryableTx,
     L1MessageType_ethDeposit,
-    L1MessageType_batchPostingReport,
     L2MessageType_unsignedEOATx,
     L2MessageType_unsignedContractTx
 } from "../libraries/MessageTypes.sol";
@@ -198,26 +197,6 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
             );
     }
 
-    function submitBatchSpendingReportTransaction(
-        address batchPosterAddr,
-        bytes32 dataHash,
-        uint256 batchNumber
-    ) external virtual override whenNotPaused returns (uint256) {
-        require(ISequencerInbox(msg.sender) == sequencerInbox, "unauthorized");
-        return
-            _deliverMessage(
-                L1MessageType_batchPostingReport,
-                batchPosterAddr,
-                abi.encodePacked(
-                    block.timestamp,
-                    batchPosterAddr,
-                    dataHash,
-                    batchNumber,
-                    block.basefee
-                )
-            );
-    }
-
     /**
      * @notice Get the L1 fee for submitting a retryable
      * @dev This fee can be paid by funds already in the L2 aliased address or by the current message value