@aztec/archiver 0.86.0 → 0.87.0

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,12 +1,14 @@
+import type { L1BlockId } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, StoreSize } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
 import type {
   ContractClassPublic,
+  ContractDataSource,
   ContractInstanceUpdateWithAddress,
   ContractInstanceWithAddress,
   ExecutablePrivateFunctionWithMembershipProof,
@@ -14,13 +16,12 @@ import type {
 } from '@aztec/stdlib/contract';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import { type LogFilter, PrivateLog, type TxScopedL2Log } from '@aztec/stdlib/logs';
-import type { InboxLeaf } from '@aztec/stdlib/messaging';
 import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
 import { join } from 'path';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
-import type { DataRetrieval } from '../structs/data_retrieval.js';
+import type { InboxMessage } from '../structs/inbox_message.js';
 import type { PublishedL2Block } from '../structs/published.js';
 import { BlockStore } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
@@ -28,12 +29,12 @@ import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
 
-export const ARCHIVER_DB_VERSION = 1;
+export const ARCHIVER_DB_VERSION = 2;
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
-export class KVArchiverDataStore implements ArchiverDataStore {
+export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSource {
   public static readonly SCHEMA_VERSION = ARCHIVER_DB_VERSION;
 
   #blockStore: BlockStore;
@@ -45,7 +46,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   #log = createLogger('archiver:data-store');
 
-  constructor(private db: AztecAsyncKVStore, logsMaxPageSize: number = 1000) {
+  constructor(
+    private db: AztecAsyncKVStore,
+    logsMaxPageSize: number = 1000,
+  ) {
     this.#blockStore = new BlockStore(db);
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#messageStore = new MessageStore(db);
@@ -53,6 +57,21 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     this.#contractInstanceStore = new ContractInstanceStore(db);
   }
 
+  public transactionAsync<T>(callback: () => Promise<T>): Promise<T> {
+    return this.db.transactionAsync(callback);
+  }
+
+  public getBlockNumber(): Promise<number> {
+    return this.getSynchedL2BlockNumber();
+  }
+
+  public async getContract(
+    address: AztecAddress,
+    blockNumber?: number,
+  ): Promise<ContractInstanceWithAddress | undefined> {
+    return this.getContractInstance(address, blockNumber ?? (await this.getBlockNumber()));
+  }
+
   public async backupTo(path: string, compress = true): Promise<string> {
     await this.db.backupTo(path, compress);
     return join(path, 'data.mdb');
@@ -92,6 +111,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#contractInstanceStore.getContractInstance(address, blockNumber);
   }
 
+  getContractInstanceDeploymentBlockNumber(address: AztecAddress): Promise<number | undefined> {
+    return this.#contractInstanceStore.getContractInstanceDeploymentBlockNumber(address);
+  }
+
   async addContractClasses(
     data: ContractClassPublic[],
     bytecodeCommitments: Fr[],
@@ -122,8 +145,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
   }
 
-  async addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
+  async addContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c, blockNumber)))).every(
+      Boolean,
+    );
   }
 
   async deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
@@ -157,8 +182,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
-    return this.#blockStore.addBlocks(blocks);
+  addBlocks(blocks: PublishedL2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
+    return this.#blockStore.addBlocks(blocks, opts);
   }
 
   /**
@@ -172,6 +197,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#blockStore.unwindBlocks(from, blocksToUnwind);
   }
 
+  getPublishedBlock(number: number): Promise<PublishedL2Block | undefined> {
+    return this.#blockStore.getBlock(number);
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    *
@@ -179,7 +208,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlocks(start: number, limit: number): Promise<PublishedL2Block[]> {
+  getPublishedBlocks(start: number, limit: number): Promise<PublishedL2Block[]> {
     return toArray(this.#blockStore.getBlocks(start, limit));
   }
 
@@ -229,12 +258,15 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#messageStore.getTotalL1ToL2MessageCount();
   }
 
+  getLastL1ToL2Message(): Promise<InboxMessage | undefined> {
+    return this.#messageStore.getLastMessage();
+  }
+
   /**
    * Append L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store and the last processed L1 block.
-   * @returns True if the operation is successful.
+   * @param messages - The L1 to L2 messages to be added to the store.
    */
-  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
+  addL1ToL2Messages(messages: InboxMessage[]): Promise<void> {
     return this.#messageStore.addL1ToL2Messages(messages);
   }
 
@@ -326,8 +358,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
-  async setMessageSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    await this.#messageStore.setSynchedL1BlockNumber(l1BlockNumber);
+  async setMessageSynchedL1Block(l1Block: L1BlockId) {
+    await this.#messageStore.setSynchedL1Block(l1Block);
   }
 
   /**
@@ -336,7 +368,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   async getSynchPoint(): Promise<ArchiverL1SynchPoint> {
     const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
       this.#blockStore.getSynchedL1BlockNumber(),
-      this.#messageStore.getSynchedL1BlockNumber(),
+      this.#messageStore.getSynchedL1Block(),
     ]);
     return {
       blocksSynchedTo,
@@ -347,4 +379,16 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   public estimateSize(): Promise<StoreSize> {
     return this.db.estimateSize();
   }
+
+  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number | bigint): Promise<void> {
+    return this.#messageStore.rollbackL1ToL2MessagesToL2Block(BigInt(targetBlockNumber));
+  }
+
+  public iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {
+    return this.#messageStore.iterateL1ToL2Messages(range);
+  }
+
+  public removeL1ToL2Messages(startIndex: bigint): Promise<void> {
+    return this.#messageStore.removeL1ToL2Messages(startIndex);
+  }
 }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -30,7 +30,11 @@ export class LogStore {
   #logsMaxPageSize: number;
   #log = createLogger('archiver:log_store');
 
-  constructor(private db: AztecAsyncKVStore, private blockStore: BlockStore, logsMaxPageSize: number = 1000) {
+  constructor(
+    private db: AztecAsyncKVStore,
+    private blockStore: BlockStore,
+    logsMaxPageSize: number = 1000,
+  ) {
     this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
     this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
     this.#privateLogsByBlock = db.openMap('archiver_private_logs_by_block');
@@ -59,7 +63,7 @@ export class LogStore {
       });
 
       txEffect.publicLogs.forEach((log, logIndex) => {
-        const tag = log.log[0];
+        const tag = log.fields[0];
         this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
 
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,71 +1,172 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import type { L1BlockId } from '@aztec/ethereum';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import {
+  type AztecAsyncKVStore,
+  type AztecAsyncMap,
+  type AztecAsyncSingleton,
+  type CustomRange,
+  mapRange,
+} from '@aztec/kv-store';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
 
-import type { DataRetrieval } from '../structs/data_retrieval.js';
+import {
+  type InboxMessage,
+  deserializeInboxMessage,
+  serializeInboxMessage,
+  updateRollingHash,
+} from '../structs/inbox_message.js';
+
+export class MessageStoreError extends Error {
+  constructor(
+    message: string,
+    public readonly inboxMessage: InboxMessage,
+  ) {
+    super(message);
+    this.name = 'MessageStoreError';
+  }
+}
 
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
 export class MessageStore {
-  #l1ToL2Messages: AztecAsyncMap<string, Buffer>;
+  /** Maps from message index to serialized InboxMessage */
+  #l1ToL2Messages: AztecAsyncMap<number, Buffer>;
+  /** Maps from hex-stringified message leaf to its index */
   #l1ToL2MessageIndices: AztecAsyncMap<string, bigint>;
-  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
+  /** Stores L1 block number and hash of the L1 synchpoint */
+  #lastSynchedL1Block: AztecAsyncSingleton<Buffer>;
+  /** Stores total messages stored */
   #totalMessageCount: AztecAsyncSingleton<bigint>;
 
   #log = createLogger('archiver:message_store');
 
-  #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
-
   constructor(private db: AztecAsyncKVStore) {
     this.#l1ToL2Messages = db.openMap('archiver_l1_to_l2_messages');
     this.#l1ToL2MessageIndices = db.openMap('archiver_l1_to_l2_message_indices');
-    this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_new_messages');
+    this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_id');
     this.#totalMessageCount = db.openSingleton('archiver_l1_to_l2_message_count');
   }
 
-  async getTotalL1ToL2MessageCount(): Promise<bigint> {
+  public async getTotalL1ToL2MessageCount(): Promise<bigint> {
     return (await this.#totalMessageCount.getAsync()) ?? 0n;
   }
 
-  /**
-   * Gets the last L1 block number that emitted new messages.
-   * @returns The last L1 block number processed
-   */
-  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
-    return this.#lastSynchedL1Block.getAsync();
+  /** Gets the last L1 block synced. */
+  public async getSynchedL1Block(): Promise<L1BlockId | undefined> {
+    const buffer = await this.#lastSynchedL1Block.getAsync();
+    if (!buffer) {
+      return undefined;
+    }
+
+    const reader = BufferReader.asReader(buffer);
+    return { l1BlockNumber: reader.readUInt256(), l1BlockHash: Buffer32.fromBuffer(reader.readBytes(Buffer32.SIZE)) };
   }
 
-  async setSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
-    await this.#lastSynchedL1Block.set(l1BlockNumber);
+  /** Sets the last L1 block synced */
+  public async setSynchedL1Block(l1Block: L1BlockId): Promise<void> {
+    const buffer = serializeToBuffer([l1Block.l1BlockNumber, l1Block.l1BlockHash]);
+    await this.#lastSynchedL1Block.set(buffer);
   }
 
   /**
    * Append L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store and the last processed L1 block.
-   * @returns True if the operation is successful.
+   * Requires new messages to be in order and strictly after the last message added.
+   * Throws if out of order messages are added or if the rolling hash is invalid.
    */
-  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
+  public addL1ToL2Messages(messages: InboxMessage[]): Promise<void> {
+    if (messages.length === 0) {
+      return Promise.resolve();
+    }
+
     return this.db.transactionAsync(async () => {
-      const lastL1BlockNumber = (await this.#lastSynchedL1Block.getAsync()) ?? 0n;
-      if (lastL1BlockNumber >= messages.lastProcessedL1BlockNumber) {
-        return false;
-      }
+      let lastMessage = await this.getLastMessage();
+      let messageCount = 0;
+
+      for (const message of messages) {
+        // Check messages are inserted in increasing order, but allow reinserting messages.
+        if (lastMessage && message.index <= lastMessage.index) {
+          const existing = await this.#l1ToL2Messages.getAsync(this.indexToKey(message.index));
+          if (existing && deserializeInboxMessage(existing).rollingHash.equals(message.rollingHash)) {
+            // We reinsert instead of skipping in case the message was re-orged and got added in a different L1 block.
+            this.#log.trace(`Reinserting message with index ${message.index} in the store`);
+            await this.#l1ToL2Messages.set(this.indexToKey(message.index), serializeInboxMessage(message));
+            continue;
+          }
 
-      await this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
+          throw new MessageStoreError(
+            `Cannot insert L1 to L2 message with index ${message.index} before last message with index ${lastMessage.index}`,
+            message,
+          );
+        }
 
-      for (const message of messages.retrievedData) {
-        const key = `${message.index}`;
-        await this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
-        await this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
+        // Check rolling hash is valid.
+        const previousRollingHash = lastMessage?.rollingHash ?? Buffer16.ZERO;
+        const expectedRollingHash = updateRollingHash(previousRollingHash, message.leaf);
+        if (!expectedRollingHash.equals(message.rollingHash)) {
+          throw new MessageStoreError(
+            `Invalid rolling hash for incoming L1 to L2 message ${message.leaf.toString()} ` +
+              `with index ${message.index} ` +
+              `(expected ${expectedRollingHash.toString()} from previous hash ${previousRollingHash} but got ${message.rollingHash.toString()})`,
+            message,
+          );
+        }
+
+        // Check index corresponds to the L2 block number.
+        const [expectedStart, expectedEnd] = InboxLeaf.indexRangeFromL2Block(message.l2BlockNumber);
+        if (message.index < expectedStart || message.index >= expectedEnd) {
+          throw new MessageStoreError(
+            `Invalid index ${message.index} for incoming L1 to L2 message ${message.leaf.toString()} ` +
+              `at block ${message.l2BlockNumber} (expected value in range [${expectedStart}, ${expectedEnd}))`,
+            message,
+          );
+        }
+
+        // Check there are no gaps in the indices within the same block.
+        if (
+          lastMessage &&
+          message.l2BlockNumber === lastMessage.l2BlockNumber &&
+          message.index !== lastMessage.index + 1n
+        ) {
+          throw new MessageStoreError(
+            `Missing prior message for incoming L1 to L2 message ${message.leaf.toString()} ` +
+              `with index ${message.index}`,
+            message,
+          );
+        }
+
+        // Check the first message in a block has the correct index.
+        if (
+          (!lastMessage || message.l2BlockNumber > lastMessage.l2BlockNumber) &&
+          message.index !== InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)
+        ) {
+          throw new MessageStoreError(
+            `Message ${message.leaf.toString()} for L2 block ${message.l2BlockNumber} has wrong index ` +
+              `${message.index} (expected ${InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)})`,
+            message,
+          );
+        }
+
+        // Perform the insertions.
+        await this.#l1ToL2Messages.set(this.indexToKey(message.index), serializeInboxMessage(message));
+        await this.#l1ToL2MessageIndices.set(this.leafToIndexKey(message.leaf), message.index);
+        messageCount++;
+        this.#log.trace(`Inserted L1 to L2 message ${message.leaf} with index ${message.index} into the store`);
+        lastMessage = message;
       }
 
-      const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
-      await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
+      // Update the L1 sync point to that of the last message added.
+      const currentSyncPoint = await this.getSynchedL1Block();
+      if (!currentSyncPoint || currentSyncPoint.l1BlockNumber < lastMessage!.l1BlockNumber) {
+        await this.setSynchedL1Block({
+          l1BlockNumber: lastMessage!.l1BlockNumber,
+          l1BlockHash: lastMessage!.l1BlockHash,
+        });
+      }
 
-      return true;
+      // Update total message count with the number of inserted messages.
+      await this.increaseTotalMessageCount(messageCount);
     });
   }
 
@@ -74,29 +175,84 @@ export class MessageStore {
    * @param l1ToL2Message - The L1 to L2 message.
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return this.#l1ToL2MessageIndices.getAsync(l1ToL2Message.toString());
+  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
+    return this.#l1ToL2MessageIndices.getAsync(this.leafToIndexKey(l1ToL2Message));
+  }
+
+  public async getLastMessage(): Promise<InboxMessage | undefined> {
+    const [msg] = await toArray(this.#l1ToL2Messages.valuesAsync({ reverse: true, limit: 1 }));
+    return msg ? deserializeInboxMessage(msg) : undefined;
   }
 
-  async getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+  public async getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
     const messages: Fr[] = [];
-    let undefinedMessageFound = false;
-    const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
-    for (let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++) {
-      // This is inefficient but probably fine for now.
-      const key = `${i}`;
-      const message = await this.#l1ToL2Messages.getAsync(key);
-      if (message) {
-        if (undefinedMessageFound) {
-          throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
-        }
-        messages.push(Fr.fromBuffer(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.
+
+    const [startIndex, endIndex] = InboxLeaf.indexRangeFromL2Block(blockNumber);
+    let lastIndex = startIndex - 1n;
+
+    for await (const msgBuffer of this.#l1ToL2Messages.valuesAsync({
+      start: this.indexToKey(startIndex),
+      end: this.indexToKey(endIndex),
+    })) {
+      const msg = deserializeInboxMessage(msgBuffer);
+      if (msg.l2BlockNumber !== blockNumber) {
+        throw new Error(`L1 to L2 message with index ${msg.index} has invalid block number ${msg.l2BlockNumber}`);
+      } else if (msg.index !== lastIndex + 1n) {
+        throw new Error(`Expected L1 to L2 message with index ${lastIndex + 1n} but got ${msg.index}`);
       }
+      lastIndex = msg.index;
+      messages.push(msg.leaf);
     }
+
     return messages;
   }
+
+  public async *iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {
+    const entriesRange = mapRange(range, this.indexToKey);
+    for await (const msgBuffer of this.#l1ToL2Messages.valuesAsync(entriesRange)) {
+      yield deserializeInboxMessage(msgBuffer);
+    }
+  }
+
+  public removeL1ToL2Messages(startIndex: bigint): Promise<void> {
+    this.#log.debug(`Deleting L1 to L2 messages from index ${startIndex}`);
+    let deleteCount = 0;
+
+    return this.db.transactionAsync(async () => {
+      for await (const [key, msgBuffer] of this.#l1ToL2Messages.entriesAsync({
+        start: this.indexToKey(startIndex),
+      })) {
+        this.#log.trace(`Deleting L1 to L2 message with index ${key - 1} from the store`);
+        await this.#l1ToL2Messages.delete(key);
+        await this.#l1ToL2MessageIndices.delete(this.leafToIndexKey(deserializeInboxMessage(msgBuffer).leaf));
+        deleteCount++;
+      }
+      await this.increaseTotalMessageCount(-deleteCount);
+      this.#log.warn(`Deleted ${deleteCount} L1 to L2 messages from index ${startIndex} from the store`);
+    });
+  }
+
+  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: bigint): Promise<void> {
+    this.#log.debug(`Deleting L1 to L2 messages up to target L2 block ${targetBlockNumber}`);
+    const startIndex = InboxLeaf.smallestIndexFromL2Block(targetBlockNumber + 1n);
+    return this.removeL1ToL2Messages(startIndex);
+  }
+
+  private indexToKey(index: bigint): number {
+    return Number(index);
+  }
+
+  private leafToIndexKey(leaf: Fr): string {
+    return leaf.toString();
+  }
+
+  private async increaseTotalMessageCount(count: bigint | number): Promise<void> {
+    if (count === 0) {
+      return;
+    }
+    return await this.db.transactionAsync(async () => {
+      const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
+      await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(count));
+    });
+  }
 }

package/src/archiver/structs/inbox_message.ts

@@ -0,0 +1,40 @@
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, bigintToUInt64BE, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+
+export type InboxMessage = {
+  index: bigint;
+  leaf: Fr;
+  l2BlockNumber: bigint;
+  l1BlockNumber: bigint;
+  l1BlockHash: Buffer32;
+  rollingHash: Buffer16;
+};
+
+export function updateRollingHash(currentRollingHash: Buffer16, leaf: Fr): Buffer16 {
+  const input = Buffer.concat([currentRollingHash.toBuffer(), leaf.toBuffer()]);
+  return Buffer16.fromBuffer(keccak256(input));
+}
+
+export function serializeInboxMessage(message: InboxMessage): Buffer {
+  return serializeToBuffer([
+    bigintToUInt64BE(message.index),
+    message.leaf,
+    message.l1BlockHash,
+    numToUInt32BE(Number(message.l1BlockNumber)),
+    numToUInt32BE(Number(message.l2BlockNumber)),
+    message.rollingHash,
+  ]);
+}
+
+export function deserializeInboxMessage(buffer: Buffer): InboxMessage {
+  const reader = BufferReader.asReader(buffer);
+  const index = reader.readUInt64();
+  const leaf = reader.readObject(Fr);
+  const l1BlockHash = reader.readObject(Buffer32);
+  const l1BlockNumber = BigInt(reader.readNumber());
+  const l2BlockNumber = BigInt(reader.readNumber());
+  const rollingHash = reader.readObject(Buffer16);
+  return { index, leaf, l1BlockHash, l1BlockNumber, l2BlockNumber, rollingHash };
+}

package/src/test/mock_l2_block_source.ts

@@ -17,6 +17,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   protected l2Blocks: L2Block[] = [];
 
   private provenBlockNumber: number = 0;
+  private finalizedBlockNumber: number = 0;
 
   private log = createLogger('archiver:mock_l2_block_source');
 
@@ -44,6 +45,13 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     this.provenBlockNumber = provenBlockNumber;
   }
 
+  public setFinalizedBlockNumber(finalizedBlockNumber: number) {
+    if (finalizedBlockNumber > this.provenBlockNumber) {
+      this.provenBlockNumber = finalizedBlockNumber;
+    }
+    this.finalizedBlockNumber = finalizedBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -174,7 +182,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     const [latest, proven, finalized] = [
       await this.getBlockNumber(),
       await this.getProvenBlockNumber(),
-      await this.getProvenBlockNumber(),
+      this.finalizedBlockNumber,
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];

package/src/test/mock_structs.ts

@@ -0,0 +1,49 @@
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+
+import { type InboxMessage, updateRollingHash } from '../archiver/structs/inbox_message.js';
+
+export function makeInboxMessage(
+  previousRollingHash = Buffer16.ZERO,
+  overrides: Partial<InboxMessage> = {},
+): InboxMessage {
+  const { l2BlockNumber = randomBigInt(100n) + 1n } = overrides;
+  const { l1BlockNumber = l2BlockNumber } = overrides;
+  const { l1BlockHash = Buffer32.random() } = overrides;
+  const { leaf = Fr.random() } = overrides;
+  const { rollingHash = updateRollingHash(previousRollingHash, leaf) } = overrides;
+  const { index = InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) } = overrides;
+
+  return {
+    index,
+    leaf,
+    l2BlockNumber,
+    l1BlockNumber,
+    l1BlockHash,
+    rollingHash,
+  };
+}
+
+export function makeInboxMessages(
+  count: number,
+  opts: {
+    initialHash?: Buffer16;
+    initialL2BlockNumber?: bigint;
+    overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
+  } = {},
+): InboxMessage[] {
+  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialL2BlockNumber = 1n } = opts;
+  const messages: InboxMessage[] = [];
+  let rollingHash = initialHash;
+  for (let i = 0; i < count; i++) {
+    const leaf = Fr.random();
+    const l2BlockNumber = BigInt(i) + initialL2BlockNumber;
+    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, l2BlockNumber }), i);
+    rollingHash = message.rollingHash;
+    messages.push(message);
+  }
+
+  return messages;
+}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts

@@ -1,23 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-/**
- * A simple in-memory implementation of an L1 to L2 message store.
- */
-export declare class L1ToL2MessageStore {
-    #private;
-    /**
-     * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
-     */
-    protected store: Map<string, Fr>;
-    constructor();
-    getTotalL1ToL2MessageCount(): bigint;
-    addMessage(message: InboxLeaf): void;
-    getMessages(blockNumber: bigint): Fr[];
-    /**
-     * Gets the L1 to L2 message index in the L1 to L2 message tree.
-     * @param l1ToL2Message - The L1 to L2 message.
-     * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-     */
-    getMessageIndex(l1ToL2Message: Fr): bigint | undefined;
-}
-//# sourceMappingURL=l1_to_l2_message_store.d.ts.map

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l1_to_l2_message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/memory_archiver_store/l1_to_l2_message_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;GAEG;AACH,qBAAa,kBAAkB;;IAC7B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAa;;IAM7C,0BAA0B,IAAI,MAAM;IAIpC,UAAU,CAAC,OAAO,EAAE,SAAS;IAI7B,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,EAAE,EAAE;IAsBtC;;;;OAIG;IACH,eAAe,CAAC,aAAa,EAAE,EAAE,GAAG,MAAM,GAAG,SAAS;CAQvD"}