Aggregate out hashes and set on L1 per epoch.

Author: LeilaWang

docs/versioned_docs/version-v3.0.0-devnet.4/developers/migration_notes.md

@@ -9,6 +9,35 @@ Aztec is in full-speed development. Literally every version breaks compatibility
 
 ## 3.0.0-devnet.4
 
+### L2-to-L1 messages are now grouped by epoch.
+
+L2-to-L1 messages are now aggregated and organized per epoch rather than per block. This change affects how you compute membership witnesses for consuming messages on L1. You now need to know the epoch number in which the message was emitted to retrieve and consume the message.
+
+**Note**: This is only an API change. The protocol behavior remains the same - messages can still only be consumed once an epoch is proven as before.
+
+#### What changed
+
+Previously, you might have computed the membership witness without explicitly needing the epoch:
+
+```typescript
+const witness = await computeL2ToL1MembershipWitness(
+  node,
+  l2TxReceipt.blockNumber,
+  l2ToL1Message
+);
+```
+
+Now, you should provide the epoch number:
+
+```typescript
+const epoch = await rollup.getEpochNumberForBlock(l2TxReceipt.blockNumber);
+const witness = await computeL2ToL1MembershipWitness(
+  node,
+  epoch,
+  l2ToL1Message
+);
+```
+
 ## [aztec.js] Removal of barrel export
 
 `aztec.js` is now divided into granular exports, which improves loading performance in node.js and also makes the job of web bundlers easier:

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

@@ -26,6 +26,7 @@ import {IERC20} from "@oz/token/ERC20/IERC20.sol";
 struct PublicInputArgs {
   bytes32 previousArchive;
   bytes32 endArchive;
+  bytes32 outHash;
   address proverId;
 }
 

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

@@ -3,6 +3,7 @@
 pragma solidity >=0.8.27;
 
 import {DataStructures} from "../../libraries/DataStructures.sol";
+import {Epoch} from "../../libraries/TimeLib.sol";
 
 /**
  * @title IOutbox
@@ -11,21 +12,18 @@ import {DataStructures} from "../../libraries/DataStructures.sol";
  * and will be consumed by the portal contracts.
  */
 interface IOutbox {
-  event RootAdded(uint256 indexed l2BlockNumber, bytes32 indexed root);
-  event MessageConsumed(
-    uint256 indexed l2BlockNumber, bytes32 indexed root, bytes32 indexed messageHash, uint256 leafId
-  );
+  event RootAdded(Epoch indexed epoch, bytes32 indexed root);
+  event MessageConsumed(Epoch indexed epoch, bytes32 indexed root, bytes32 indexed messageHash, uint256 leafId);
 
   // docs:start:outbox_insert
   /**
-   * @notice Inserts the root of a merkle tree containing all of the L2 to L1 messages in
-   * a block specified by _l2BlockNumber.
+   * @notice Inserts the root of a merkle tree containing all of the L2 to L1 messages in an epoch specified by _epoch.
    * @dev Only callable by the rollup contract
    * @dev Emits `RootAdded` upon inserting the root successfully
-   * @param _l2BlockNumber - The L2 Block Number in which the L2 to L1 messages reside
+   * @param _epoch - The epoch in which the L2 to L1 messages reside
    * @param _root - The merkle root of the tree where all the L2 to L1 messages are leaves
    */
-  function insert(uint256 _l2BlockNumber, bytes32 _root) external;
+  function insert(Epoch _epoch, bytes32 _root) external;
   // docs:end:outbox_insert
 
   // docs:start:outbox_consume
@@ -34,37 +32,36 @@ interface IOutbox {
    * @dev Only useable by portals / recipients of messages
    * @dev Emits `MessageConsumed` when consuming messages
    * @param _message - The L2 to L1 message
-   * @param _l2BlockNumber - The block number specifying the block that contains the message we want to consume
-   * @param _leafIndex - The index inside the merkle tree where the message is located
-   * @param _path - The sibling path used to prove inclusion of the message, the _path length directly depends
-   * on the total amount of L2 to L1 messages in the block. i.e. the length of _path is equal to the depth of the
-   * L1 to L2 message tree.
+   * @param _epoch - The epoch that contains the message we want to consume
+   * @param _leafIndex - The index at the level in the wonky tree where the message is located
+   * @param _path - The sibling path used to prove inclusion of the message, the _path length depends
+   * on the location of the L2 to L1 message in the wonky tree.
    */
   function consume(
     DataStructures.L2ToL1Msg calldata _message,
-    uint256 _l2BlockNumber,
+    Epoch _epoch,
     uint256 _leafIndex,
     bytes32[] calldata _path
   ) external;
   // docs:end:outbox_consume
 
   // docs:start:outbox_has_message_been_consumed_at_block_and_index
   /**
-   * @notice Checks to see if an L2 to L1 message in a specific block has been consumed
+   * @notice Checks to see if an L2 to L1 message in a specific epoch has been consumed
    * @dev - This function does not throw. Out-of-bounds access is considered valid, but will always return false
-   * @param _l2BlockNumber - The block number specifying the block that contains the message we want to check
+   * @param _epoch - The epoch that contains the message we want to check
    * @param _leafId - The unique id of the message leaf
    */
-  function hasMessageBeenConsumedAtBlock(uint256 _l2BlockNumber, uint256 _leafId) external view returns (bool);
+  function hasMessageBeenConsumedAtEpoch(Epoch _epoch, uint256 _leafId) external view returns (bool);
   // docs:end:outbox_has_message_been_consumed_at_block_and_index
 
   /**
-   * @notice  Fetch the root data for a given block number
-   *          Returns (0, 0) if the block is not proven
+   * @notice  Fetch the root data for a given epoch
+   *          Returns (0, 0) if the epoch is not proven
    *
-   * @param _l2BlockNumber - The block number to fetch the root data for
+   * @param _epoch - The epoch to fetch the root data for
    *
    * @return bytes32 - The root of the merkle tree containing the L2 to L1 messages
    */
-  function getRootData(uint256 _l2BlockNumber) external view returns (bytes32);
+  function getRootData(Epoch _epoch) external view returns (bytes32);
 }

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

@@ -24,8 +24,7 @@ library Constants {
     14_269_942_583_723_164_841_365_114_274_712_143_548_835_546_030_057_296_325_580_016_468_921_911_294_613;
   uint256 internal constant FEE_JUICE_ADDRESS = 5;
   uint256 internal constant BLS12_POINT_COMPRESSED_BYTES = 48;
-  uint256 internal constant PROPOSED_BLOCK_HEADER_LENGTH_BYTES = 284;
-  uint256 internal constant ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH = 158;
+  uint256 internal constant ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH = 159;
   uint256 internal constant NUM_MSGS_PER_BASE_PARITY = 256;
   uint256 internal constant NUM_BASE_PARITY_PER_ROOT_PARITY = 4;
 }

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

@@ -43,12 +43,9 @@ library Errors {
     uint32 storedDeadline,
     uint32 deadlinePassed
   ); // 0x5e789f34
-  error Outbox__RootAlreadySetAtBlock(uint256 l2BlockNumber); // 0x3eccfd3e
   error Outbox__InvalidRecipient(address expected, address actual); // 0x57aad581
-  error Outbox__AlreadyNullified(uint256 l2BlockNumber, uint256 leafIndex); // 0xfd71c2d4
-  error Outbox__NothingToConsumeAtBlock(uint256 l2BlockNumber); // 0xa4508f22
-  error Outbox__BlockNotProven(uint256 l2BlockNumber); // 0x0e194a6d
-  error Outbox__BlockAlreadyProven(uint256 l2BlockNumber);
+  error Outbox__AlreadyNullified(Epoch epoch, uint256 leafIndex); // 0xfd71c2d4
+  error Outbox__NothingToConsumeAtEpoch(Epoch epoch); // 0xa4508f22
   error Outbox__PathTooLong();
   error Outbox__LeafIndexOutOfBounds(uint256 leafIndex, uint256 pathLength);
 

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

@@ -116,8 +116,18 @@ library EpochProofLib {
     require(verifyEpochRootProof(_args), Errors.Rollup__InvalidProof());
 
     RollupStore storage rollupStore = STFLib.getStorage();
-    rollupStore.tips =
-      rollupStore.tips.updateProvenBlockNumber(Math.max(rollupStore.tips.getProvenBlockNumber(), _args.end));
+
+    // Advance the proven block number and insert the out hash if the chain is extended.
+    if (_args.end > rollupStore.tips.getProvenBlockNumber()) {
+      rollupStore.tips =
+        rollupStore.tips.updateProvenBlockNumber(Math.max(rollupStore.tips.getProvenBlockNumber(), _args.end));
+
+      // Handle L2->L1 message processing:
+      if (_args.args.outHash != bytes32(0)) {
+        // Insert L2->L1 messages root into outbox for consumption.
+        rollupStore.config.outbox.insert(endEpoch, _args.args.outHash);
+      }
+    }
 
     RewardLib.handleRewardsAndFees(_args, endEpoch);
 
@@ -171,30 +181,33 @@ library EpochProofLib {
     // struct RootRollupPublicInputs {
     //   previous_archive_root: Field,
     //   end_archive_root: Field,
+    //   out_hash: Field,
     //   proposedBlockHeaderHashes: [Field; Constants.AZTEC_MAX_EPOCH_DURATION],
     //   fees: [FeeRecipient; Constants.AZTEC_MAX_EPOCH_DURATION],
     //   chain_id: Field,
     //   version: Field,
     //   vk_tree_root: Field,
     //   protocol_contracts_hash: Field,
     //   prover_id: Field,
-    //   blob_public_inputs: FinalBlobAccumulatorPublicInputs,
+    //   blob_public_inputs: FinalBlobAccumulator,
     // }
     {
       // previous_archive.root: the previous archive tree root
       publicInputs[0] = _args.previousArchive;
 
       // end_archive.root: the new archive tree root
       publicInputs[1] = _args.endArchive;
+
+      publicInputs[2] = _args.outHash;
     }
 
     uint256 numBlocks = _end - _start + 1;
 
     for (uint256 i = 0; i < numBlocks; i++) {
-      publicInputs[2 + i] = STFLib.getHeaderHash(_start + i);
+      publicInputs[3 + i] = STFLib.getHeaderHash(_start + i);
     }
 
-    uint256 offset = 2 + Constants.AZTEC_MAX_EPOCH_DURATION;
+    uint256 offset = 3 + Constants.AZTEC_MAX_EPOCH_DURATION;
 
     uint256 feesLength = Constants.AZTEC_MAX_EPOCH_DURATION * 2;
     // fees[2n to 2n + 1]: a fee element, which contains of a recipient and a value
@@ -249,7 +262,6 @@ library EpochProofLib {
     publicInputs[offset] = bytes32(uint256(uint248(bytes31((_blobPublicInputs[96:127])))));
     // c[1]
     publicInputs[offset + 1] = bytes32(uint256(uint136(bytes17((_blobPublicInputs[127:144])))));
-    offset += 2;
 
     return publicInputs;
   }

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

@@ -76,7 +76,7 @@ struct ValidateHeaderArgs {
  *      - Validator selection and proposer verification
  *      - Fee calculation and mana consumption tracking
  *      - State transitions and archive updates
- *      - Message processing between L1 and L2 via the Inbox and Outbox contracts
+ *      - L1 to L2 message processing via the Inbox
  *
  *      The proposal flow operates within Aztec's time-based model where:
  *      - Each slot has a designated proposer selected from the validator set
@@ -123,7 +123,7 @@ library ProposeLib {
    *          Note that some validations and processes are disabled if the chain is configured to run without
    *          transactions, such as during ignition phase:
    *          - No fee header computation or L1 gas fee oracle update
-   *          - No inbox message consumption or outbox message insertion
+   *          - No inbox message consumption
    *
    *          Validations performed:
    *          - Blob commitments against provided blob data: Errors.Rollup__InvalidBlobHash,
@@ -143,7 +143,6 @@ library ProposeLib {
    *          - Store block metadata in circular storage (TempBlockLog)
    *          - Update L1 gas fee oracle (when txs enabled)
    *          - Consume inbox messages (when txs enabled)
-   *          - Insert outbox messages (when txs enabled)
    *          - Setup epoch for validator selection (first block of the epoch)
    *
    * @param _args - The arguments to propose the block
@@ -294,22 +293,16 @@ library ProposeLib {
       })
     );
 
-    // Handle L1<->L2 message processing (only when transactions are enabled)
+    // Handle L1->L2 message processing (only when transactions are enabled)
     if (v.isTxsEnabled) {
-      // Since ignition will have no transactions there will be no method to consume or output message.
+      // Since ignition will have no transactions there will be no method to consume messages.
       // Therefore we can ignore it as long as mana target is zero.
       // Since the inbox is async, it must enforce its own check to not try to insert if ignition.
 
       // Consume pending L1->L2 messages and validate against header commitment
       // @note  The block number here will always be >=1 as the genesis block is at 0
       v.inHash = rollupStore.config.inbox.consume(blockNumber);
-      require(
-        v.header.contentCommitment.inHash == v.inHash,
-        Errors.Rollup__InvalidInHash(v.inHash, v.header.contentCommitment.inHash)
-      );
-
-      // Insert L2->L1 messages into outbox for later consumption
-      rollupStore.config.outbox.insert(blockNumber, v.header.contentCommitment.outHash);
+      require(v.header.inHash == v.inHash, Errors.Rollup__InvalidInHash(v.inHash, v.header.inHash));
     }
 
     // Emit event for external listeners. Nodes rely on this event to update their state.
@@ -363,8 +356,8 @@ library ProposeLib {
     require(timestamp <= currentTime, Errors.Rollup__TimestampInFuture(currentTime, timestamp));
 
     require(
-      _args.flags.ignoreDA || _args.header.contentCommitment.blobsHash == _args.blobsHashesCommitment,
-      Errors.Rollup__UnavailableTxs(_args.header.contentCommitment.blobsHash)
+      _args.flags.ignoreDA || _args.header.blobsHash == _args.blobsHashesCommitment,
+      Errors.Rollup__UnavailableTxs(_args.header.blobsHash)
     );
 
     require(_args.header.gasFees.feePerDaGas == 0, Errors.Rollup__NonZeroDaFee());

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

@@ -29,15 +29,11 @@ struct GasFees {
   uint128 feePerL2Gas;
 }
 
-struct ContentCommitment {
+struct ProposedHeader {
+  bytes32 lastArchiveRoot;
   bytes32 blobsHash;
   bytes32 inHash;
   bytes32 outHash;
-}
-
-struct ProposedHeader {
-  bytes32 lastArchiveRoot;
-  ContentCommitment contentCommitment;
   Slot slotNumber;
   Timestamp timestamp;
   address coinbase;
@@ -67,9 +63,9 @@ library ProposedHeaderLib {
     return Hash.sha256ToField(
       abi.encodePacked(
         _header.lastArchiveRoot,
-        _header.contentCommitment.blobsHash,
-        _header.contentCommitment.inHash,
-        _header.contentCommitment.outHash,
+        _header.blobsHash,
+        _header.inHash,
+        _header.outHash,
         _header.slotNumber,
         Timestamp.unwrap(_header.timestamp).toUint64(),
         _header.coinbase,