chore(fast-inbox): remove legacy 128-bit inbox rolling hash (A-1386)

Author: spalladino

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

@@ -16,11 +16,6 @@ uint256 constant MAX_MSGS_PER_BUCKET = 256;
  */
 interface IInbox {
   struct InboxState {
-    // 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;
     // 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;
@@ -50,13 +45,10 @@ interface IInbox {
    * @notice Emitted when a message is sent
    * @param index - The compact cumulative index of the message in the Inbox insertion order
    * @param hash - The hash of the message
-   * @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 index, bytes32 indexed hash, bytes16 rollingHash, bytes32 inboxRollingHash, uint256 bucketSeq
-  );
+  event MessageSent(uint256 index, bytes32 indexed hash, bytes32 inboxRollingHash, uint256 bucketSeq);
 
   // docs:start:send_l1_to_l2_message
   /**

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

@@ -37,11 +37,6 @@ contract Inbox is IInbox {
 
   uint256 public immutable BUCKET_RING_SIZE;
 
-  // 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;
-
   // 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;
@@ -106,11 +101,9 @@ contract Inbox is IInbox {
 
     bytes32 leaf = message.sha256ToField();
 
-    messagesRollingHash = bytes16(keccak256(abi.encodePacked(messagesRollingHash, leaf)));
-
     (uint64 bucketSeq, bytes32 inboxRollingHash) = _absorbIntoBucket(leaf);
 
-    emit MessageSent(index, leaf, messagesRollingHash, inboxRollingHash, bucketSeq);
+    emit MessageSent(index, leaf, inboxRollingHash, bucketSeq);
 
     return (leaf, index);
   }
@@ -120,7 +113,7 @@ contract Inbox is IInbox {
   }
 
   function getState() external view override(IInbox) returns (InboxState memory) {
-    return InboxState({rollingHash: messagesRollingHash, totalMessagesInserted: _totalMessagesInserted()});
+    return InboxState({totalMessagesInserted: _totalMessagesInserted()});
   }
 
   function getTotalMessagesInserted() external view override(IInbox) returns (uint64) {

l1-contracts/test/Inbox.t.sol

@@ -66,11 +66,10 @@ contract InboxTest is Test {
     DataStructures.L1ToL2Msg memory message = _boundMessage(_message, globalLeafIndex);
 
     bytes32 leaf = message.sha256ToField();
-    bytes16 expectedRollingHash = bytes16(keccak256(abi.encodePacked(stateBefore.rollingHash, leaf)));
     bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), leaf);
     vm.expectEmit(true, true, true, true);
     // event we expect
-    emit IInbox.MessageSent(globalLeafIndex, leaf, expectedRollingHash, expectedInboxRollingHash, 1);
+    emit IInbox.MessageSent(globalLeafIndex, leaf, expectedInboxRollingHash, 1);
     // event we will get
     (bytes32 insertedLeaf, uint256 insertedIndex) =
       inbox.sendL2Message(message.recipient, message.content, message.secretHash);
@@ -80,7 +79,6 @@ contract InboxTest is Test {
 
     Inbox.InboxState memory stateAfter = inbox.getState();
     assertEq(stateBefore.totalMessagesInserted + 1, stateAfter.totalMessagesInserted);
-    assertEq(expectedRollingHash, stateAfter.rollingHash);
   }
 
   function testSendDuplicateL2Messages() public {

l1-contracts/test/InboxBuckets.t.sol

@@ -132,11 +132,10 @@ contract InboxBucketsTest is Test {
       index: inbox.getState().totalMessagesInserted
     });
     bytes32 leaf = Hash.sha256ToField(message);
-    bytes16 legacyHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, leaf)));
     bytes32 inboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), leaf);
 
     vm.expectEmit(true, true, true, true, address(inbox));
-    emit IInbox.MessageSent(message.index, leaf, legacyHash, inboxRollingHash, 1);
+    emit IInbox.MessageSent(message.index, leaf, inboxRollingHash, 1);
     inbox.sendL2Message(recipient, content, secretHash);
   }
 

l1-contracts/test/fee_portal/depositToAztecPublic.t.sol

@@ -86,10 +86,9 @@ contract DepositToAztecPublic is Test {
 
     assertEq(inbox.getTotalMessagesInserted(), 0);
 
-    bytes16 expectedHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, expectedKey)));
     bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), expectedKey);
     vm.expectEmit(true, true, true, true, address(inbox));
-    emit IInbox.MessageSent(expectedIndex, expectedKey, expectedHash, expectedInboxRollingHash, 1);
+    emit IInbox.MessageSent(expectedIndex, expectedKey, expectedInboxRollingHash, 1);
     vm.expectEmit(true, true, true, true, address(feeJuicePortal));
     emit IFeeJuicePortal.DepositToAztecPublic(to, amount, secretHash, expectedKey, expectedIndex);
 

l1-contracts/test/portals/TokenPortal.t.sol

@@ -120,12 +120,11 @@ contract TokenPortalTest is Test {
     DataStructures.L1ToL2Msg memory expectedMessage = _createExpectedMintPrivateL1ToL2Message(expectedIndex);
 
     bytes32 expectedLeaf = expectedMessage.sha256ToField();
-    bytes16 expectedHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, expectedLeaf)));
     bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), expectedLeaf);
     // Check the event was emitted
     vm.expectEmit(true, true, true, true);
     // event we expect
-    emit IInbox.MessageSent(expectedIndex, expectedLeaf, expectedHash, expectedInboxRollingHash, 1);
+    emit IInbox.MessageSent(expectedIndex, expectedLeaf, expectedInboxRollingHash, 1);
     // event we will get
 
     // Perform op
@@ -148,13 +147,12 @@ contract TokenPortalTest is Test {
     uint256 expectedIndex = 0;
     DataStructures.L1ToL2Msg memory expectedMessage = _createExpectedMintPublicL1ToL2Message(expectedIndex);
     bytes32 expectedLeaf = expectedMessage.sha256ToField();
-    bytes16 expectedHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, expectedLeaf)));
     bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), expectedLeaf);
 
     // Check the event was emitted
     vm.expectEmit(true, true, true, true);
     // event we expect
-    emit IInbox.MessageSent(expectedIndex, expectedLeaf, expectedHash, expectedInboxRollingHash, 1);
+    emit IInbox.MessageSent(expectedIndex, expectedLeaf, expectedInboxRollingHash, 1);
 
     // Perform op
     (bytes32 leaf, uint256 index) = tokenPortal.depositToAztecPublic(to, amount, secretHashForL2MessageConsumption);