@aztec/archiver 0.26.6 → 0.27.0

package/src/archiver/data_retrieval.ts

@@ -1,18 +1,18 @@
-import { Body, ExtendedContractData, L1ToL2Message } from '@aztec/circuit-types';
+import { Body, L1ToL2Message, NewInboxLeaf } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, Fr, Header } from '@aztec/circuits.js';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { PublicClient } from 'viem';
 
 import {
-  getContractDeploymentLogs,
   getL1ToL2MessageCancelledLogs,
   getL2BlockProcessedLogs,
+  getLeafInsertedLogs,
   getPendingL1ToL2MessageLogs,
   getTxsPublishedLogs,
   processCancelledL1ToL2MessagesLogs,
-  processContractDeploymentLogs,
   processL2BlockProcessedLogs,
+  processLeafInsertedLogs,
   processPendingL1ToL2MessageAddedLogs,
   processTxsPublishedLogs,
 } from './eth_log_handlers.js';
@@ -116,78 +116,72 @@ export async function retrieveBlockBodiesFromAvailabilityOracle(
 }
 
 /**
- * Fetches new contract data.
+ * Fetch new pending L1 to L2 messages.
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param contractDeploymentEmitterAddress - The address of the contract deployment emitter contract.
+ * @param inboxAddress - The address of the inbox contract to fetch messages from.
  * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @param blockNumberToBodyHash - A mapping from block number to relevant body hash.
- * @returns An array of ExtendedContractData and their equivalent L2 Block number along with the next eth block to search from..
+ * @returns An array of L1ToL2Message and next eth block to search from.
  */
-export async function retrieveNewContractData(
+export async function retrieveNewPendingL1ToL2Messages(
   publicClient: PublicClient,
-  contractDeploymentEmitterAddress: EthAddress,
+  inboxAddress: EthAddress,
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-  blockNumberToBodyHash: { [key: number]: Buffer | undefined },
-): Promise<DataRetrieval<[ExtendedContractData[], number]>> {
-  let retrievedNewContracts: [ExtendedContractData[], number][] = [];
+): Promise<DataRetrieval<[L1ToL2Message, bigint]>> {
+  const retrievedNewL1ToL2Messages: [L1ToL2Message, bigint][] = [];
   do {
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const contractDataLogs = await getContractDeploymentLogs(
+    const newL1ToL2MessageLogs = await getPendingL1ToL2MessageLogs(
       publicClient,
-      contractDeploymentEmitterAddress,
+      inboxAddress,
       searchStartBlock,
       searchEndBlock,
     );
-    if (contractDataLogs.length === 0) {
+    if (newL1ToL2MessageLogs.length === 0) {
       break;
     }
-    const newContracts = processContractDeploymentLogs(blockNumberToBodyHash, contractDataLogs);
-    retrievedNewContracts = retrievedNewContracts.concat(newContracts);
-    searchStartBlock = (contractDataLogs.findLast(cd => !!cd)?.blockNumber || searchStartBlock) + 1n;
+    const newL1ToL2Messages = processPendingL1ToL2MessageAddedLogs(newL1ToL2MessageLogs);
+    retrievedNewL1ToL2Messages.push(...newL1ToL2Messages);
+    // handles the case when there are no new messages:
+    searchStartBlock = (newL1ToL2MessageLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
-  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedNewContracts };
+  return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedNewL1ToL2Messages };
 }
 
 /**
- * Fetch new pending L1 to L2 messages.
+ * Fetch new L1 to L2 messages.
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
+ * @param newInboxAddress - The address of the inbox contract to fetch messages from.
  * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @returns An array of L1ToL2Message and next eth block to search from.
+ * @returns An array of NewInboxLeaf and next eth block to search from.
  */
-export async function retrieveNewPendingL1ToL2Messages(
+export async function retrieveNewL1ToL2Messages(
   publicClient: PublicClient,
-  inboxAddress: EthAddress,
+  newInboxAddress: EthAddress,
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-): Promise<DataRetrieval<[L1ToL2Message, bigint]>> {
-  const retrievedNewL1ToL2Messages: [L1ToL2Message, bigint][] = [];
+): Promise<DataRetrieval<NewInboxLeaf>> {
+  const retrievedNewL1ToL2Messages: NewInboxLeaf[] = [];
   do {
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const newL1ToL2MessageLogs = await getPendingL1ToL2MessageLogs(
-      publicClient,
-      inboxAddress,
-      searchStartBlock,
-      searchEndBlock,
-    );
-    if (newL1ToL2MessageLogs.length === 0) {
+    const leafInsertedLogs = await getLeafInsertedLogs(publicClient, newInboxAddress, searchStartBlock, searchEndBlock);
+    if (leafInsertedLogs.length === 0) {
       break;
     }
-    const newL1ToL2Messages = processPendingL1ToL2MessageAddedLogs(newL1ToL2MessageLogs);
+    const newL1ToL2Messages = processLeafInsertedLogs(leafInsertedLogs);
     retrievedNewL1ToL2Messages.push(...newL1ToL2Messages);
     // handles the case when there are no new messages:
-    searchStartBlock = (newL1ToL2MessageLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
+    searchStartBlock = (leafInsertedLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
   return { nextEthBlockNumber: searchStartBlock, retrievedData: retrievedNewL1ToL2Messages };
 }
@@ -200,6 +194,7 @@ export async function retrieveNewPendingL1ToL2Messages(
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
  * @returns An array of entry keys that were cancelled and next eth block to search from.
+ * TODO(#4492): Nuke the following when purging the old inbox
  */
 export async function retrieveNewCancelledL1ToL2Messages(
   publicClient: PublicClient,

package/src/archiver/eth_log_handlers.ts

@@ -1,21 +1,29 @@
-import {
-  Body,
-  ContractData,
-  EncodedContractFunction,
-  ExtendedContractData,
-  L1Actor,
-  L1ToL2Message,
-  L2Actor,
-} from '@aztec/circuit-types';
+import { Body, L1Actor, L1ToL2Message, L2Actor, NewInboxLeaf } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, Header } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
-import { AvailabilityOracleAbi, ContractDeploymentEmitterAbi, InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { numToUInt32BE } from '@aztec/foundation/serialize';
+import { AvailabilityOracleAbi, InboxAbi, NewInboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hexToBytes } from 'viem';
 
+/**
+ * Processes newly received LeafInserted (L1 to L2) logs.
+ * @param logs - LeafInserted logs.
+ * @returns Array of all processed LeafInserted logs
+ */
+export function processLeafInsertedLogs(
+  logs: Log<bigint, number, false, undefined, true, typeof NewInboxAbi, 'LeafInserted'>[],
+): NewInboxLeaf[] {
+  const leaves: NewInboxLeaf[] = [];
+  for (const log of logs) {
+    const { blockNumber, index, value } = log.args;
+    leaves.push(new NewInboxLeaf(blockNumber, index, Buffer.from(hexToBytes(value))));
+  }
+  return leaves;
+}
+
 /**
  * Processes newly received MessageAdded (L1 to L2) logs.
  * @param logs - MessageAdded logs.
@@ -227,24 +235,24 @@ export function getTxsPublishedLogs(
 }
 
 /**
- * Gets relevant `ContractDeployment` logs from chain.
+ * Get relevant `MessageAdded` logs emitted by Inbox on chain.
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param contractDeploymentEmitterAddress - The address of the L2 contract deployment emitter contract.
+ * @param inboxAddress - The address of the inbox contract.
  * @param fromBlock - First block to get logs from (inclusive).
  * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `ContractDeployment` logs.
+ * @returns An array of `MessageAdded` logs.
  */
-export function getContractDeploymentLogs(
+export function getPendingL1ToL2MessageLogs(
   publicClient: PublicClient,
-  contractDeploymentEmitterAddress: EthAddress,
+  inboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[]> {
+): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageAdded'>[]> {
   return publicClient.getLogs({
-    address: getAddress(contractDeploymentEmitterAddress.toString()),
+    address: getAddress(inboxAddress.toString()),
     event: getAbiItem({
-      abi: ContractDeploymentEmitterAbi,
-      name: 'ContractDeployment',
+      abi: InboxAbi,
+      name: 'MessageAdded',
     }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
@@ -252,64 +260,24 @@ export function getContractDeploymentLogs(
 }
 
 /**
- * Processes newly received ContractDeployment logs.
- * @param blockNumberToBodyHash - A mapping from block number to relevant body hash.
- * @param logs - ContractDeployment logs.
- * @returns The set of retrieved extended contract data items.
- */
-export function processContractDeploymentLogs(
-  blockNumberToBodyHash: { [key: number]: Buffer | undefined },
-  logs: Log<bigint, number, false, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[],
-): [ExtendedContractData[], number][] {
-  const extendedContractData: [ExtendedContractData[], number][] = [];
-  for (let i = 0; i < logs.length; i++) {
-    const log = logs[i];
-    const l2BlockNum = Number(log.args.l2BlockNum);
-    const blockHash = Buffer.from(hexToBytes(log.args.l2BlockHash));
-    const expectedBlockHash = blockNumberToBodyHash[l2BlockNum];
-    if (expectedBlockHash === undefined || !blockHash.equals(expectedBlockHash)) {
-      continue;
-    }
-    const publicFnsReader = BufferReader.asReader(Buffer.from(log.args.acir.slice(2), 'hex'));
-    const contractClassId = Fr.fromBuffer(Buffer.from(hexToBytes(log.args.contractClassId)));
-    const saltedInitializationHash = Fr.fromBuffer(Buffer.from(hexToBytes(log.args.saltedInitializationHash)));
-    const publicKeyHash = Fr.fromBuffer(Buffer.from(hexToBytes(log.args.publicKeyHash)));
-
-    const contractData = new ExtendedContractData(
-      new ContractData(AztecAddress.fromString(log.args.aztecAddress), EthAddress.fromString(log.args.portalAddress)),
-      publicFnsReader.readVector(EncodedContractFunction),
-      contractClassId,
-      saltedInitializationHash,
-      publicKeyHash,
-    );
-    if (extendedContractData[i]) {
-      extendedContractData[i][0].push(contractData);
-    } else {
-      extendedContractData[i] = [[contractData], l2BlockNum];
-    }
-  }
-  return extendedContractData;
-}
-
-/**
- * Get relevant `MessageAdded` logs emitted by Inbox on chain.
+ * Get relevant `L1ToL2MessageCancelled` logs emitted by Inbox on chain when pending messages are cancelled
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param inboxAddress - The address of the inbox contract.
  * @param fromBlock - First block to get logs from (inclusive).
  * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `MessageAdded` logs.
+ * @returns An array of `L1ToL2MessageCancelled` logs.
  */
-export function getPendingL1ToL2MessageLogs(
+export function getL1ToL2MessageCancelledLogs(
   publicClient: PublicClient,
   inboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageAdded'>[]> {
+): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[]> {
   return publicClient.getLogs({
     address: getAddress(inboxAddress.toString()),
     event: getAbiItem({
       abi: InboxAbi,
-      name: 'MessageAdded',
+      name: 'L1ToL2MessageCancelled',
     }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
@@ -317,24 +285,24 @@ export function getPendingL1ToL2MessageLogs(
 }
 
 /**
- * Get relevant `L1ToL2MessageCancelled` logs emitted by Inbox on chain when pending messages are cancelled
+ * Get relevant `LeafInserted` logs emitted by NewInbox on chain.
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract.
+ * @param newInboxAddress - The address of the new inbox contract.
  * @param fromBlock - First block to get logs from (inclusive).
  * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `L1ToL2MessageCancelled` logs.
+ * @returns An array of `LeafInserted` logs.
  */
-export function getL1ToL2MessageCancelledLogs(
+export function getLeafInsertedLogs(
   publicClient: PublicClient,
-  inboxAddress: EthAddress,
+  newInboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[]> {
+): Promise<Log<bigint, number, false, undefined, true, typeof NewInboxAbi, 'LeafInserted'>[]> {
   return publicClient.getLogs({
-    address: getAddress(inboxAddress.toString()),
+    address: getAddress(newInboxAddress.toString()),
     event: getAbiItem({
-      abi: InboxAbi,
-      name: 'L1ToL2MessageCancelled',
+      abi: NewInboxAbi,
+      name: 'LeafInserted',
     }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive

package/src/archiver/kv_archiver_store/block_store.ts

@@ -55,16 +55,6 @@ export class BlockStore {
         block.getTxs().forEach((tx, i) => {
           void this.#txIndex.set(tx.txHash.toString(), [block.number, i]);
         });
-
-        block.body.txEffects
-          .flatMap(txEffect => txEffect.contractData)
-          .forEach((contractData, i) => {
-            if (contractData.contractAddress.isZero()) {
-              return;
-            }
-
-            void this.#contractIndex.set(contractData.contractAddress.toString(), [block.number, i]);
-          });
       }
 
       return true;

package/src/archiver/kv_archiver_store/contract_store.ts

@@ -1,4 +1,4 @@
-import { ContractData, ExtendedContractData } from '@aztec/circuit-types';
+import { ExtendedContractData } from '@aztec/circuit-types';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecKVStore, AztecMap } from '@aztec/kv-store';
@@ -52,47 +52,4 @@ export class ContractStore {
 
     return undefined;
   }
-
-  /**
-   * Lookup all extended contract data in an L2 block.
-   * @param blockNumber - The block number to get all contract data from.
-   * @returns All extended contract data in the block (if found).
-   */
-  getExtendedContractDataInBlock(blockNumber: number): Array<ExtendedContractData> {
-    return (this.#extendedContractData.get(blockNumber) ?? []).map(contract =>
-      ExtendedContractData.fromBuffer(contract),
-    );
-  }
-
-  /**
-   * Get basic info for an L2 contract.
-   * Contains contract address & the ethereum portal address.
-   * @param contractAddress - The contract data address.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  getContractData(contractAddress: AztecAddress): ContractData | undefined {
-    const [blockNumber, index] = this.#blockStore.getContractLocation(contractAddress) ?? [];
-    if (typeof blockNumber !== 'number' || typeof index !== 'number') {
-      return undefined;
-    }
-
-    const block = this.#blockStore.getBlock(blockNumber);
-
-    if (block?.body.txEffects[index].contractData.length !== 1) {
-      throw new Error(`Contract data at block: ${blockNumber}, tx: ${index} does not have length of 1`);
-    }
-
-    return block?.body.txEffects[index].contractData[0];
-  }
-
-  /**
-   * Get basic info for an all L2 contracts deployed in a block.
-   * Contains contract address & the ethereum portal address.
-   * @param blockNumber - Number of the L2 block where contracts were deployed.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  getContractDataInBlock(blockNumber: number): ContractData[] {
-    const block = this.#blockStore.getBlock(blockNumber);
-    return block?.body.txEffects.flatMap(txEffect => txEffect.contractData) ?? [];
-  }
 }

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,6 +1,5 @@
 import {
   Body,
-  ContractData,
   ExtendedContractData,
   GetUnencryptedLogsResponse,
   L1ToL2Message,
@@ -8,6 +7,7 @@ import {
   L2BlockL2Logs,
   LogFilter,
   LogType,
+  NewInboxLeaf,
   TxEffect,
   TxHash,
   TxReceipt,
@@ -148,6 +148,16 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#logStore.addLogs(encryptedLogs, unencryptedLogs, blockNumber);
   }
 
+  /**
+   * Append new L1 to L2 messages to the store.
+   * @param messages - The L1 to L2 messages to be added to the store.
+   * @param lastMessageL1BlockNumber - The L1 block number in which the last message was emitted.
+   * @returns True if the operation is successful.
+   */
+  addNewL1ToL2Messages(messages: NewInboxLeaf[], lastMessageL1BlockNumber: bigint): Promise<boolean> {
+    return Promise.resolve(this.#messageStore.addNewL1ToL2Messages(messages, lastMessageL1BlockNumber));
+  }
+
   /**
    * Append new pending L1 to L2 messages to the store.
    * @param messages - The L1 to L2 messages to be added to the store.
@@ -201,6 +211,19 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     }
   }
 
+  /**
+   * Gets new L1 to L2 message (to be) included in a given block.
+   * @param blockNumber - L2 block number to get messages for.
+   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
+   */
+  getNewL1ToL2Messages(blockNumber: bigint): Promise<Buffer[]> {
+    try {
+      return Promise.resolve(this.#messageStore.getNewL1ToL2Messages(blockNumber));
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+
   /**
    * Gets up to `limit` amount of logs starting from `from`.
    * @param start - Number of the L2 block to which corresponds the first logs to be returned.
@@ -248,35 +271,6 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return Promise.resolve(this.#contractStore.getExtendedContractData(contractAddress));
   }
 
-  /**
-   * Lookup all extended contract data in an L2 block.
-   * @param blockNumber - The block number to get all contract data from.
-   * @returns All extended contract data in the block (if found).
-   */
-  getExtendedContractDataInBlock(blockNumber: number): Promise<ExtendedContractData[]> {
-    return Promise.resolve(Array.from(this.#contractStore.getExtendedContractDataInBlock(blockNumber)));
-  }
-
-  /**
-   * Get basic info for an L2 contract.
-   * Contains contract address & the ethereum portal address.
-   * @param contractAddress - The contract data address.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    return Promise.resolve(this.#contractStore.getContractData(contractAddress));
-  }
-
-  /**
-   * Get basic info for an all L2 contracts deployed in a block.
-   * Contains contract address & the ethereum portal address.
-   * @param blockNumber - Number of the L2 block where contracts were deployed.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  getContractDataInBlock(blockNumber: number): Promise<ContractData[]> {
-    return Promise.resolve(Array.from(this.#contractStore.getContractDataInBlock(blockNumber)));
-  }
-
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
@@ -290,10 +284,11 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    */
   getL1BlockNumber(): Promise<ArchiverL1SynchPoint> {
     const addedBlock = this.#blockStore.getL1BlockNumber();
-    const { addedMessages, cancelledMessages } = this.#messageStore.getL1BlockNumber();
+    const { addedMessages, cancelledMessages, newMessages } = this.#messageStore.getL1BlockNumber();
     return Promise.resolve({
       addedBlock,
       addedMessages,
+      newMessages,
       cancelledMessages,
     });
   }

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,5 +1,5 @@
-import { L1ToL2Message } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
+import { L1ToL2Message, NewInboxLeaf } from '@aztec/circuit-types';
+import { Fr, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecCounter, AztecKVStore, AztecMap, AztecSingleton } from '@aztec/kv-store';
 
@@ -19,16 +19,23 @@ type Message = {
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class MessageStore {
-  #messages: AztecMap<string, Message>;
+  #newMessages: AztecMap<string, Buffer>;
+  #lastL1BlockNewMessages: AztecSingleton<bigint>;
+  // TODO(#4492): Nuke the following when purging the old inbox
   #pendingMessagesByFee: AztecCounter<[number, string]>;
+  #messages: AztecMap<string, Message>;
   #lastL1BlockAddingMessages: AztecSingleton<bigint>;
   #lastL1BlockCancellingMessages: AztecSingleton<bigint>;
 
   #log = createDebugLogger('aztec:archiver:message_store');
 
+  #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
+
   constructor(private db: AztecKVStore) {
+    this.#newMessages = db.openMap('archiver_l1_to_l2_new_messages');
     this.#messages = db.openMap('archiver_l1_to_l2_messages');
     this.#pendingMessagesByFee = db.openCounter('archiver_messages_by_fee');
+    this.#lastL1BlockNewMessages = db.openSingleton('archiver_last_l1_block_new_messages');
     this.#lastL1BlockAddingMessages = db.openSingleton('archiver_last_l1_block_adding_messages');
     this.#lastL1BlockCancellingMessages = db.openSingleton('archiver_last_l1_block_cancelling_messages');
   }
@@ -39,11 +46,40 @@ export class MessageStore {
    */
   getL1BlockNumber() {
     return {
+      newMessages: this.#lastL1BlockNewMessages.get() ?? 0n,
+      // TODO(#4492): Nuke the following when purging the old inbox
       addedMessages: this.#lastL1BlockAddingMessages.get() ?? 0n,
       cancelledMessages: this.#lastL1BlockCancellingMessages.get() ?? 0n,
     };
   }
 
+  /**
+   * Append new L1 to L2 messages to the store.
+   * @param messages - The L1 to L2 messages to be added to the store.
+   * @param lastMessageL1BlockNumber - The L1 block number in which the last message was emitted.
+   * @returns True if the operation is successful.
+   */
+  addNewL1ToL2Messages(messages: NewInboxLeaf[], lastMessageL1BlockNumber: bigint): Promise<boolean> {
+    return this.db.transaction(() => {
+      const lastL1BlockNumber = this.#lastL1BlockNewMessages.get() ?? 0n;
+      if (lastL1BlockNumber >= lastMessageL1BlockNumber) {
+        return false;
+      }
+
+      void this.#lastL1BlockNewMessages.set(lastMessageL1BlockNumber);
+
+      for (const message of messages) {
+        if (message.index >= this.#l1ToL2MessagesSubtreeSize) {
+          throw new Error(`Message index ${message.index} out of subtree range`);
+        }
+        const key = `${message.blockNumber}-${message.index}`;
+        void this.#newMessages.setIfNotExists(key, message.leaf);
+      }
+
+      return true;
+    });
+  }
+
   /**
    * Append new pending L1 to L2 messages to the store.
    * @param messages - The L1 to L2 messages to be added to the store.
@@ -171,4 +207,25 @@ export class MessageStore {
 
     return entryKeys;
   }
+
+  getNewL1ToL2Messages(blockNumber: bigint): Buffer[] {
+    const messages: Buffer[] = [];
+    let undefinedMessageFound = false;
+    for (let messageIndex = 0; messageIndex < this.#l1ToL2MessagesSubtreeSize; messageIndex++) {
+      // This is inefficient but probably fine for now.
+      const key = `${blockNumber}-${messageIndex}`;
+      const message = this.#newMessages.get(key);
+      if (message) {
+        if (undefinedMessageFound) {
+          throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
+        }
+        messages.push(message);
+      } else {
+        undefinedMessageFound = true;
+        // We continue iterating over messages here to verify that there are no more messages after the undefined one.
+        // --> If this was the case this would imply there is some issue with log fetching.
+      }
+    }
+    return messages;
+  }
 }

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -1,6 +1,53 @@
-import { L1ToL2Message } from '@aztec/circuit-types';
+import { L1ToL2Message, NewInboxLeaf } from '@aztec/circuit-types';
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js/constants';
 import { Fr } from '@aztec/foundation/fields';
 
+/**
+ * A simple in-memory implementation of an L1 to L2 message store
+ * that handles message duplication.
+ * TODO(#4492): Clean this up
+ */
+export class NewL1ToL2MessageStore {
+  /**
+   * A map containing the entry key to the corresponding L1 to L2
+   * messages (and the number of times the message has been seen).
+   */
+  protected store: Map<string, Buffer> = new Map();
+
+  #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
+
+  constructor() {}
+
+  addMessage(message: NewInboxLeaf) {
+    if (message.index >= this.#l1ToL2MessagesSubtreeSize) {
+      throw new Error(`Message index ${message.index} out of subtree range`);
+    }
+    const key = `${message.blockNumber}-${message.index}`;
+    this.store.set(key, message.leaf);
+  }
+
+  getMessages(blockNumber: bigint): Buffer[] {
+    const messages: Buffer[] = [];
+    let undefinedMessageFound = false;
+    for (let messageIndex = 0; messageIndex < this.#l1ToL2MessagesSubtreeSize; messageIndex++) {
+      // This is inefficient but probably fine for now.
+      const key = `${blockNumber}-${messageIndex}`;
+      const message = this.store.get(key);
+      if (message) {
+        if (undefinedMessageFound) {
+          throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
+        }
+        messages.push(message);
+      } else {
+        undefinedMessageFound = true;
+        // We continue iterating over messages here to verify that there are no more messages after the undefined one.
+        // --> If this was the case this would imply there is some issue with log fetching.
+      }
+    }
+    return messages;
+  }
+}
+
 /**
  * A simple in-memory implementation of an L1 to L2 message store
  * that handles message duplication.