chore(fast-inbox): delete legacy L1 inbox path (A-1386)

Remove the frontier-tree machinery, legacy consume(), the LAG/inboxLag
plumbing and the dead MessageSent event field now that propose enforces
streaming-inbox consumption (AZIP-22 Fast Inbox).

Inbox / IInbox:
- Drop the frontier tree forest (trees mapping, forest, HEIGHT/SIZE/EMPTY_ROOT),
  the per-message tree insert, getRoot(), and consume().
- Drop the LAG immutable and the _lag/_height constructor args; the constructor
  now takes only (rollup, feeAsset, version, bucketRingSize).
- Source the compact message index from the current bucket's running total
  instead of a parallel counter; drop InboxState.inProgress and getInProgress().
- Drop the meaningless checkpointNumber (former inProgress) from MessageSent.
- Keep the 128-bit rolling hash, InboxState.{rollingHash,totalMessagesInserted}
  and getState()/getTotalMessagesInserted(): the node still consumes them for
  message sync and L1-reorg detection until that path is retired.

Rollup / config / errors:
- Remove RollupConfigInput.inboxLag and the RollupCore constructor pass-through;
  drop Constants.L1_TO_L2_MSG_SUBTREE_HEIGHT from the Inbox construction.
- Sweep orphaned errors Inbox__Unauthorized, Inbox__MustBuildBeforeConsume and
  Rollup__InvalidInHash; refresh the now-stale ProposeLib NatSpec.

Tests: delete the frontier/consume suites and fuzz, re-home the bucket/rolling-hash
coverage, update the propose-path fixtures (inHash is an unconstrained hint now),
and fix the flip-stranded fee-portal/token-portal index and event expectations.

FrontierLib is kept: it still backs the base-parity and merkle Frontier tests.

Author: spalladino

l1-contracts/script/deploy/RollupConfiguration.sol

@@ -110,7 +110,6 @@ contract RollupConfiguration is IRollupConfiguration, Test {
     config.targetCommitteeSize = vm.envUint("AZTEC_TARGET_COMMITTEE_SIZE");
     config.lagInEpochsForValidatorSet = vm.envUint("AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET");
     config.lagInEpochsForRandao = vm.envUint("AZTEC_LAG_IN_EPOCHS_FOR_RANDAO");
-    config.inboxLag = vm.envUint("AZTEC_INBOX_LAG");
     config.aztecProofSubmissionEpochs = vm.envUint("AZTEC_PROOF_SUBMISSION_EPOCHS");
     config.localEjectionThreshold = vm.envUint("AZTEC_LOCAL_EJECTION_THRESHOLD");
     config.slashingQuorum = vm.envOr("AZTEC_SLASHING_QUORUM", slashingRoundSize / 2 + 1);

l1-contracts/src/core/RollupCore.sol

@@ -15,7 +15,6 @@ import {IStakingCore} from "@aztec/core/interfaces/IStaking.sol";
 import {IValidatorSelectionCore} from "@aztec/core/interfaces/IValidatorSelection.sol";
 import {IInbox} from "@aztec/core/interfaces/messagebridge/IInbox.sol";
 import {IOutbox} from "@aztec/core/interfaces/messagebridge/IOutbox.sol";
-import {Constants} from "@aztec/core/libraries/ConstantsGen.sol";
 import {CommitteeAttestations} from "@aztec/core/libraries/rollup/AttestationLib.sol";
 import {Errors} from "@aztec/core/libraries/Errors.sol";
 import {RollupOperationsExtLib} from "@aztec/core/libraries/rollup/RollupOperationsExtLib.sol";
@@ -619,18 +618,7 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
     rollupStore.config.epochProofVerifier = _epochProofVerifier;
     rollupStore.config.version = _config.version;
 
-    IInbox inbox = IInbox(
-      address(
-        new Inbox(
-          address(this),
-          _feeAsset,
-          _config.version,
-          Constants.L1_TO_L2_MSG_SUBTREE_HEIGHT,
-          _config.inboxLag,
-          INBOX_BUCKET_RING_SIZE
-        )
-      )
-    );
+    IInbox inbox = IInbox(address(new Inbox(address(this), _feeAsset, _config.version, INBOX_BUCKET_RING_SIZE)));
 
     rollupStore.config.inbox = inbox;
     rollupStore.config.outbox = IOutbox(address(new Outbox(address(this), _config.version)));

l1-contracts/src/core/interfaces/IRollup.sol

@@ -84,7 +84,6 @@ struct RollupConfigInput {
   RewardBoostConfig rewardBoostConfig;
   StakingQueueConfig stakingQueueConfig;
   uint256 localEjectionThreshold;
-  uint256 inboxLag;
 }
 
 struct RollupConfig {

l1-contracts/src/core/interfaces/messagebridge/IInbox.sol

@@ -11,16 +11,14 @@ import {DataStructures} from "../../libraries/DataStructures.sol";
  */
 interface IInbox {
   struct InboxState {
-    // Rolling hash of all messages inserted into the inbox.
-    // Used by clients to check for consistency.
-    // TODO: remove once the streaming inbox (AZIP-22 Fast Inbox) flips on and clients rely on the
-    // consensus rolling hash tracked in the buckets instead.
+    // Legacy 128-bit keccak rolling hash of all messages inserted into the inbox. Consumed only by the
+    // node for message sync and L1-reorg detection.
+    // TODO: remove once the node relies on the full-width consensus rolling hash tracked in the buckets
+    // instead (AZIP-22 Fast Inbox).
     bytes16 rollingHash;
-    // This value is not used much by the contract, but it is useful for synching the node faster
-    // as it can more easily figure out if it can just skip looking for events for a time period.
+    // Cumulative number of messages inserted into the inbox. Useful for synching the node faster as it can
+    // more easily figure out if it can just skip looking for events for a time period.
     uint64 totalMessagesInserted;
-    // Number of a tree which is currently being filled
-    uint64 inProgress;
   }
 
   /**
@@ -45,20 +43,14 @@ interface IInbox {
 
   /**
    * @notice Emitted when a message is sent
-   * @param checkpointNumber - The checkpoint number in which the message is included
-   * @param index - The index of the message in the L1 to L2 messages tree
+   * @param index - The compact cumulative index of the message in the Inbox insertion order
    * @param hash - The hash of the message
-   * @param rollingHash - The rolling hash of all messages inserted into the inbox
+   * @param rollingHash - The legacy 128-bit rolling hash of all messages inserted into the inbox
    * @param inboxRollingHash - The consensus rolling hash (truncated sha256 chain) after this message
    * @param bucketSeq - The sequence number of the bucket this message was absorbed into
    */
   event MessageSent(
-    uint256 indexed checkpointNumber,
-    uint256 index,
-    bytes32 indexed hash,
-    bytes16 rollingHash,
-    bytes32 inboxRollingHash,
-    uint256 bucketSeq
+    uint256 index, bytes32 indexed hash, bytes16 rollingHash, bytes32 inboxRollingHash, uint256 bucketSeq
   );
 
   // docs:start:send_l1_to_l2_message
@@ -69,37 +61,19 @@ interface IInbox {
    * @param _content - The content of the message (application specific)
    * @param _secretHash - The secret hash of the message (make it possible to hide when a specific message is consumed
    * on L2)
-   * @return The key of the message in the set and its leaf index in the tree
+   * @return The key of the message in the set and its compact cumulative index
    */
   function sendL2Message(DataStructures.L2Actor memory _recipient, bytes32 _content, bytes32 _secretHash)
     external
     returns (bytes32, uint256);
   // docs:end:send_l1_to_l2_message
 
-  // docs:start:consume
-  /**
-   * @notice Consumes the current tree, and starts a new one if needed
-   * @dev Only callable by the rollup contract
-   * @dev In the first iteration we return empty tree root because first checkpoint's messages tree is always
-   * empty because there has to be a 1 checkpoint lag to prevent sequencer DOS attacks
-   *
-   * @param _toConsume - The checkpoint number to consume
-   *
-   * @return The root of the consumed tree
-   */
-  function consume(uint256 _toConsume) external returns (bytes32);
-  // docs:end:consume
-
   function getFeeAssetPortal() external view returns (address);
 
-  function getRoot(uint256 _checkpointNumber) external view returns (bytes32);
-
   function getState() external view returns (InboxState memory);
 
   function getTotalMessagesInserted() external view returns (uint64);
 
-  function getInProgress() external view returns (uint64);
-
   /**
    * @notice Returns the sequence number of the bucket currently accumulating messages
    * @return The current bucket sequence number

l1-contracts/src/core/libraries/Errors.sol

@@ -22,12 +22,10 @@ library Errors {
   error DevNet__InvalidProposer(address expected, address actual); // 0x11e6e6f7
 
   // Inbox
-  error Inbox__Unauthorized(); // 0xe5336a6b
   error Inbox__ActorTooLarge(bytes32 actor); // 0xa776a06e
   error Inbox__VersionMismatch(uint256 expected, uint256 actual); // 0x47452014
   error Inbox__ContentTooLarge(bytes32 content); // 0x47452014
   error Inbox__SecretHashTooLarge(bytes32 secretHash); // 0xecde7e2c
-  error Inbox__MustBuildBeforeConsume(); // 0xc4901999
   error Inbox__BucketOutOfWindow(uint256 seq, uint256 current); // 0xfee255b7
 
   // Outbox
@@ -58,7 +56,6 @@ library Errors {
   error Rollup__InvalidCheckpointHeader(bytes32 expected, bytes32 actual);
   error Rollup__InvalidCheckpointHeaderCount(uint256 expected, uint256 actual);
   error Rollup__InvalidCheckpointNumber(uint256 expected, uint256 actual); // 0xd1ba9bfa
-  error Rollup__InvalidInHash(bytes32 expected, bytes32 actual); // 0xcd6f4233
   error Rollup__InvalidInboxRollingHash(bytes32 expected, bytes32 actual); // 0xed1f7bb5
   error Rollup__InvalidPreviousInboxRollingHash(bytes32 expected, bytes32 actual); // 0x2fe7cae5
   error Rollup__UnconsumedInboxMessages(uint256 nextBucketSeq); // 0x2bd4bf10

l1-contracts/src/core/libraries/rollup/ProposeLib.sol

@@ -142,7 +142,7 @@ library ProposeLib {
    *          - Checkpoint header validations (see validateHeader function for details)
    *          - Proposer signature is valid for designated slot proposer:
    *            Errors.ValidatorSelection__MissingProposerSignature
-   *          - Inbox hash matches expected value: Errors.Rollup__InvalidInHash
+   *          - Streaming Inbox consumption is valid: Errors.Rollup__InvalidInboxRollingHash
    *          - Archive root is within the scalar field: Errors.Rollup__FieldElementOutOfRange
    *
    *          Validations NOT performed:
@@ -154,7 +154,7 @@ library ProposeLib {
    *          - Store archive root for the new checkpoint number
    *          - Store checkpoint metadata in circular storage (TempCheckpointLog)
    *          - Update L1 gas fee oracle
-   *          - Consume inbox messages
+   *          - Validate streaming Inbox consumption against the parent checkpoint
    *          - Setup epoch for validator selection (first block of the epoch)
    *
    * @param _args - The arguments to propose the checkpoint
@@ -401,8 +401,8 @@ library ProposeLib {
 
   /**
    * @notice Validates a checkpoint's Inbox consumption against the streaming inbox buckets and returns how
-   *         far consumption has reached. Not yet called from propose(): the legacy `consume()`/`inHash` flow
-   *         remains the enforced path until the streaming inbox (AZIP-22 Fast Inbox) flips on.
+   *         far consumption has reached. Called from propose() as the enforced consumption path (AZIP-22 Fast
+   *         Inbox).
    *
    * @dev Read-only; performs no Inbox write. Checks, in order:
    *      1. The checkpoint header's `inboxRollingHash` must equal the rolling hash snapshotted in the Inbox

l1-contracts/src/core/messagebridge/Inbox.sol

@@ -5,7 +5,6 @@ pragma solidity >=0.8.27;
 import {IRollup} from "@aztec/core/interfaces/IRollup.sol";
 import {IInbox} from "@aztec/core/interfaces/messagebridge/IInbox.sol";
 import {Constants} from "@aztec/core/libraries/ConstantsGen.sol";
-import {FrontierLib} from "@aztec/core/libraries/crypto/FrontierLib.sol";
 import {Hash} from "@aztec/core/libraries/crypto/Hash.sol";
 import {DataStructures} from "@aztec/core/libraries/DataStructures.sol";
 import {Errors} from "@aztec/core/libraries/Errors.sol";
@@ -31,71 +30,41 @@ uint256 constant MIN_BUCKET_RING_SIZE = 512;
  */
 contract Inbox is IInbox {
   using Hash for DataStructures.L1ToL2Msg;
-  using FrontierLib for FrontierLib.Forest;
-  using FrontierLib for FrontierLib.Tree;
 
   // Maximum number of messages a single bucket can hold before further messages in the same L1 block
   // spill over into the next bucket. Matches the number of L1 to L2 messages a single L2 block can
-  // insert once the streaming inbox is live, so any one bucket is always consumable by one block.
+  // insert, so any one bucket is always consumable by one block.
   uint256 public constant MAX_MSGS_PER_BUCKET = 256;
 
   address public immutable ROLLUP;
   uint256 public immutable VERSION;
   address public immutable FEE_ASSET_PORTAL;
 
-  uint256 public immutable LAG;
-
   uint256 public immutable BUCKET_RING_SIZE;
 
-  uint256 internal immutable HEIGHT;
-  uint256 internal immutable SIZE;
-  bytes32 internal immutable EMPTY_ROOT; // The root of an empty frontier tree
-
-  // Practically immutable value as we only set it in the constructor.
-  FrontierLib.Forest internal forest;
-
-  mapping(uint256 checkpointNumber => FrontierLib.Tree tree) public trees;
+  // Legacy 128-bit keccak rolling hash over every inserted message leaf. Consumed only by the node's
+  // message sync and L1-reorg detection; retained until those switch to the full-width consensus rolling
+  // hash tracked in the buckets (AZIP-22 Fast Inbox).
+  bytes16 internal messagesRollingHash;
 
-  InboxState internal state;
-
-  // Ring of rolling-hash buckets, keyed by `bucketSeq % BUCKET_RING_SIZE`. Inert for the legacy
-  // frontier-tree flow; consumed by the streaming inbox checks at `propose` (AZIP-22 Fast Inbox).
+  // Ring of rolling-hash buckets, keyed by `bucketSeq % BUCKET_RING_SIZE`. Consumed by the streaming inbox
+  // checks at `propose` (AZIP-22 Fast Inbox).
   mapping(uint256 ringIndex => InboxBucket bucket) internal buckets;
 
   uint64 internal currentBucketSeq;
 
-  constructor(
-    address _rollup,
-    IERC20 _feeAsset,
-    uint256 _version,
-    uint256 _height,
-    uint256 _lag,
-    uint256 _bucketRingSize
-  ) {
+  constructor(address _rollup, IERC20 _feeAsset, uint256 _version, uint256 _bucketRingSize) {
     ROLLUP = _rollup;
     VERSION = _version;
 
-    HEIGHT = _height;
-    SIZE = 2 ** _height;
-
-    require(_lag > 0, "LAG TOO SMALL");
-    LAG = _lag;
-
     require(_bucketRingSize >= MIN_BUCKET_RING_SIZE, "BUCKET RING TOO SMALL");
     BUCKET_RING_SIZE = _bucketRingSize;
 
-    state = InboxState({
-      rollingHash: 0, totalMessagesInserted: 0, inProgress: SafeCast.toUint64(Constants.INITIAL_CHECKPOINT_NUMBER + LAG)
-    });
-
     // Genesis bucket: a checkpoint consuming no messages references the same bucket as its parent, so the
     // first checkpoint against an empty Inbox references this one and no base case leaks into `propose`.
     buckets[0] =
       InboxBucket({rollingHash: 0, totalMsgCount: 0, timestamp: SafeCast.toUint64(block.timestamp), msgCount: 0});
 
-    forest.initialize(_height);
-    EMPTY_ROOT = trees[type(uint256).max].root(forest, HEIGHT, SIZE);
-
     FEE_ASSET_PORTAL = address(new FeeJuicePortal(IRollup(_rollup), _feeAsset, IInbox(this), VERSION));
   }
 
@@ -109,7 +78,7 @@ contract Inbox is IInbox {
    * @param _secretHash - The secret hash of the message (make it possible to hide when a specific message is consumed
    * on L2)
    *
-   * @return Hash of the sent message and its leaf index in the tree.
+   * @return Hash of the sent message and its compact cumulative index.
    */
   function sendL2Message(DataStructures.L2Actor memory _recipient, bytes32 _content, bytes32 _secretHash)
     external
@@ -121,24 +90,11 @@ contract Inbox is IInbox {
     require(uint256(_content) <= Constants.MAX_FIELD_VALUE, Errors.Inbox__ContentTooLarge(_content));
     require(uint256(_secretHash) <= Constants.MAX_FIELD_VALUE, Errors.Inbox__SecretHashTooLarge(_secretHash));
 
-    // Is this the best way to read a packed struct into local variables in a single SLOAD
-    // without having to use assembly and manual unpacking?
-    InboxState memory _state = state;
-    bytes16 rollingHash = _state.rollingHash;
-    uint64 totalMessagesInserted = _state.totalMessagesInserted;
-    uint64 inProgress = _state.inProgress;
-
-    FrontierLib.Tree storage currentTree = trees[inProgress];
-
-    if (currentTree.isFull(SIZE)) {
-      inProgress += 1;
-      currentTree = trees[inProgress];
-    }
-
     // Compact cumulative message index (AZIP-22 Fast Inbox): the zero-based position of this message in the Inbox's
-    // insertion order, equal to the number of messages inserted before it. It is embedded in the leaf preimage and
-    // matches the streaming L1-to-L2 tree's leaf count, so consumers do not need per-checkpoint tree geometry.
-    uint256 index = totalMessagesInserted;
+    // insertion order, equal to the number of messages inserted before it. It matches the streaming L1-to-L2 tree's
+    // leaf count, so consumers do not need per-checkpoint tree geometry. Sourced from the current bucket's running
+    // total, which the absorb below then advances (a rollover carries the total forward unchanged).
+    uint256 index = _totalMessagesInserted();
 
     // If the sender is the fee asset portal, we use a magic address to simpler have it initialized at genesis.
     // We assume that no-one will know the private key for this address and that the precompile won't change to
@@ -154,16 +110,12 @@ contract Inbox is IInbox {
     });
 
     bytes32 leaf = message.sha256ToField();
-    currentTree.insertLeaf(leaf);
 
-    bytes16 updatedRollingHash = bytes16(keccak256(abi.encodePacked(rollingHash, leaf)));
-    state = InboxState({
-      rollingHash: updatedRollingHash, totalMessagesInserted: totalMessagesInserted + 1, inProgress: inProgress
-    });
+    messagesRollingHash = bytes16(keccak256(abi.encodePacked(messagesRollingHash, leaf)));
 
     (uint64 bucketSeq, bytes32 inboxRollingHash) = _absorbIntoBucket(leaf);
 
-    emit MessageSent(inProgress, index, leaf, updatedRollingHash, inboxRollingHash, bucketSeq);
+    emit MessageSent(index, leaf, messagesRollingHash, inboxRollingHash, bucketSeq);
 
     return (leaf, index);
   }
@@ -209,55 +161,16 @@ contract Inbox is IInbox {
     return (bucketSeq, bucket.rollingHash);
   }
 
-  /**
-   * @notice Consumes the current tree, and starts a new one if needed
-   *
-   * @dev Only callable by the rollup contract
-   * @dev In the first iteration we return empty tree root because first checkpoint's messages tree is always
-   * empty because there has to be a 1 checkpoint lag to prevent sequencer DOS attacks
-   *
-   * @param _toConsume - The checkpoint number to consume
-   *
-   * @return The root of the consumed tree
-   */
-  function consume(uint256 _toConsume) external override(IInbox) returns (bytes32) {
-    require(msg.sender == ROLLUP, Errors.Inbox__Unauthorized());
-
-    uint64 inProgress = state.inProgress;
-    require(_toConsume < inProgress, Errors.Inbox__MustBuildBeforeConsume());
-
-    bytes32 root = EMPTY_ROOT;
-    if (_toConsume > Constants.INITIAL_CHECKPOINT_NUMBER) {
-      root = trees[_toConsume].root(forest, HEIGHT, SIZE);
-    }
-
-    // Once consumption reaches the current lag boundary, open the next checkpoint
-    // so new inserts keep a full LAG-sized buffer ahead of the rollup.
-    if (_toConsume + LAG == inProgress) {
-      state.inProgress = inProgress + 1;
-    }
-
-    return root;
-  }
-
   function getFeeAssetPortal() external view override(IInbox) returns (address) {
     return FEE_ASSET_PORTAL;
   }
 
-  function getRoot(uint256 _checkpointNumber) external view override(IInbox) returns (bytes32) {
-    return trees[_checkpointNumber].root(forest, HEIGHT, SIZE);
-  }
-
   function getState() external view override(IInbox) returns (InboxState memory) {
-    return state;
+    return InboxState({rollingHash: messagesRollingHash, totalMessagesInserted: _totalMessagesInserted()});
   }
 
   function getTotalMessagesInserted() external view override(IInbox) returns (uint64) {
-    return state.totalMessagesInserted;
-  }
-
-  function getInProgress() external view override(IInbox) returns (uint64) {
-    return state.inProgress;
+    return _totalMessagesInserted();
   }
 
   function getCurrentBucketSeq() external view override(IInbox) returns (uint64) {
@@ -269,4 +182,9 @@ contract Inbox is IInbox {
     require(_seq <= current && current - _seq < BUCKET_RING_SIZE, Errors.Inbox__BucketOutOfWindow(_seq, current));
     return buckets[_seq % BUCKET_RING_SIZE];
   }
+
+  // Cumulative number of messages inserted into the Inbox, tracked by the current bucket's running total.
+  function _totalMessagesInserted() internal view returns (uint64) {
+    return buckets[currentBucketSeq % BUCKET_RING_SIZE].totalMsgCount;
+  }
 }