@aztec/archiver 0.86.0 → 0.87.0

package/src/archiver/archiver_store.ts

@@ -1,4 +1,6 @@
+import type { L1BlockId } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
+import type { CustomRange } from '@aztec/kv-store';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
@@ -11,10 +13,9 @@ import type {
 } from '@aztec/stdlib/contract';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import type { LogFilter, PrivateLog, TxScopedL2Log } from '@aztec/stdlib/logs';
-import type { InboxLeaf } from '@aztec/stdlib/messaging';
 import { BlockHeader, type IndexedTxEffect, type TxHash, type TxReceipt } from '@aztec/stdlib/tx';
 
-import type { DataRetrieval } from './structs/data_retrieval.js';
+import type { InboxMessage } from './structs/inbox_message.js';
 import type { PublishedL2Block } from './structs/published.js';
 
 /**
@@ -23,10 +24,8 @@ import type { PublishedL2Block } from './structs/published.js';
 export type ArchiverL1SynchPoint = {
   /** Number of the last L1 block that added a new L2 block metadata.  */
   blocksSynchedTo?: bigint;
-  /** Number of the last L1 block that added L1 -> L2 messages from the Inbox. */
-  messagesSynchedTo?: bigint;
-  /** Number of the last L1 block that added a new proven block. */
-  provenLogsSynchedTo?: bigint;
+  /** Last L1 block checked for L1 to L2 messages. */
+  messagesSynchedTo?: L1BlockId;
 };
 
 /**
@@ -34,12 +33,17 @@ export type ArchiverL1SynchPoint = {
  * (blocks, encrypted logs, aztec contract data extended contract data).
  */
 export interface ArchiverDataStore {
+  /** Opens a new transaction to the underlying store and runs all operations within it. */
+  transactionAsync<T>(callback: () => Promise<T>): Promise<T>;
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
+   * @param opts - Options for the operation.
+   * @param opts.force - If true, the blocks will be added even if they have gaps.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: PublishedL2Block[]): Promise<boolean>;
+  addBlocks(blocks: PublishedL2Block[], opts?: { force?: boolean }): Promise<boolean>;
 
   /**
    * Unwinds blocks from the database
@@ -51,12 +55,18 @@ export interface ArchiverDataStore {
   unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean>;
 
   /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * Returns the block for the given number, or undefined if not exists.
+   * @param number - The block number to return.
+   */
+  getPublishedBlock(number: number): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets up to `limit` amount of published L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: number, limit: number): Promise<PublishedL2Block[]>;
+  getPublishedBlocks(from: number, limit: number): Promise<PublishedL2Block[]>;
 
   /**
    * Gets up to `limit` amount of L2 block headers starting from `from`.
@@ -90,10 +100,10 @@ export interface ArchiverDataStore {
 
   /**
    * 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.
+   * @param messages - The L1 to L2 messages to be added to the store.
    * @returns True if the operation is successful.
    */
-  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean>;
+  addL1ToL2Messages(messages: InboxMessage[]): Promise<void>;
 
   /**
    * Gets L1 to L2 message (to be) included in a given block.
@@ -170,10 +180,9 @@ export interface ArchiverDataStore {
   setBlockSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void>;
 
   /**
-   * Stores the l1 block number that messages have been synched until
-   * @param l1BlockNumber  - The l1 block number
+   * Stores the l1 block that messages have been synched until
    */
-  setMessageSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void>;
+  setMessageSynchedL1Block(l1Block: L1BlockId): Promise<void>;
 
   /**
    * Gets the synch point of the archiver
@@ -240,14 +249,24 @@ export interface ArchiverDataStore {
   registerContractFunctionSignatures(address: AztecAddress, signatures: string[]): Promise<void>;
   getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 
-  /**
-   * Estimates the size of the store in bytes.
-   */
-  estimateSize(): Promise<{ mappingSize: number; actualSize: number; numItems: number }>;
+  /** Estimates the size of the store in bytes. */
+  estimateSize(): Promise<{ mappingSize: number; physicalFileSize: number; actualSize: number; numItems: number }>;
 
   /** Backups the archiver db to the target folder. Returns the path to the db file. */
   backupTo(path: string): Promise<string>;
 
   /** Closes the underlying data store. */
   close(): Promise<void>;
+
+  /** Deletes all L1 to L2 messages up until (excluding) the target L2 block number. */
+  rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number | bigint): Promise<void>;
+
+  /** Returns an async iterator to all L1 to L2 messages on the range. */
+  iterateL1ToL2Messages(range?: CustomRange<bigint>): AsyncIterableIterator<InboxMessage>;
+
+  /** Removes all L1 to L2 messages starting from the given index (inclusive). */
+  removeL1ToL2Messages(startIndex: bigint): Promise<void>;
+
+  /** Returns the last L1 to L2 message stored. */
+  getLastL1ToL2Message(): Promise<InboxMessage | undefined>;
 }

package/src/archiver/archiver_store_test_suite.ts

@@ -1,13 +1,16 @@
 import {
   INITIAL_L2_BLOCK_NUM,
-  L1_TO_L2_MSG_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   PRIVATE_LOG_SIZE_IN_FIELDS,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomInt } from '@aztec/foundation/crypto';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
 import { sleep } from '@aztec/foundation/sleep';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { L2Block, wrapInBlock } from '@aztec/stdlib/block';
@@ -27,7 +30,11 @@ import {
 import '@aztec/stdlib/testing/jest';
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 
+import { makeInboxMessage, makeInboxMessages } from '../test/mock_structs.js';
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from './archiver_store.js';
+import { BlockNumberNotSequentialError, InitialBlockNumberNotSequentialError } from './errors.js';
+import { MessageStoreError } from './kv_archiver_store/message_store.js';
+import type { InboxMessage } from './structs/inbox_message.js';
 import type { PublishedL2Block } from './structs/published.js';
 
 /**
@@ -85,6 +92,18 @@ export function describeArchiverDataStore(
         await store.addBlocks(blocks);
         await expect(store.addBlocks(blocks)).resolves.toBe(true);
       });
+
+      it('throws an error if the previous block does not exist in the store', async () => {
+        const block = makePublished(await L2Block.random(2), 2);
+        await expect(store.addBlocks([block])).rejects.toThrow(InitialBlockNumberNotSequentialError);
+        await expect(store.getPublishedBlocks(1, 10)).resolves.toEqual([]);
+      });
+
+      it('throws an error if there is a gap in the blocks being added', async () => {
+        const blocks = [makePublished(await L2Block.random(1), 1), makePublished(await L2Block.random(3), 3)];
+        await expect(store.addBlocks(blocks)).rejects.toThrow(BlockNumberNotSequentialError);
+        await expect(store.getPublishedBlocks(1, 10)).resolves.toEqual([]);
+      });
     });
 
     describe('unwindBlocks', () => {
@@ -92,12 +111,12 @@ export function describeArchiverDataStore(
         await store.addBlocks(blocks);
         const blockNumber = await store.getSynchedL2BlockNumber();
 
-        expectBlocksEqual(await store.getBlocks(blockNumber, 1), [blocks[blocks.length - 1]]);
+        expectBlocksEqual(await store.getPublishedBlocks(blockNumber, 1), [blocks[blocks.length - 1]]);
 
         await store.unwindBlocks(blockNumber, 1);
 
         expect(await store.getSynchedL2BlockNumber()).toBe(blockNumber - 1);
-        expect(await store.getBlocks(blockNumber, 1)).toEqual([]);
+        expect(await store.getPublishedBlocks(blockNumber, 1)).toEqual([]);
       });
 
       it('can unwind multiple empty blocks', async () => {
@@ -107,7 +126,7 @@ export function describeArchiverDataStore(
 
         await store.unwindBlocks(10, 3);
         expect(await store.getSynchedL2BlockNumber()).toBe(7);
-        expect((await store.getBlocks(1, 10)).map(b => b.block.number)).toEqual([1, 2, 3, 4, 5, 6, 7]);
+        expect((await store.getPublishedBlocks(1, 10)).map(b => b.block.number)).toEqual([1, 2, 3, 4, 5, 6, 7]);
       });
 
       it('refuses to unwind blocks if the tip is not the last block', async () => {
@@ -122,19 +141,32 @@ export function describeArchiverDataStore(
       });
 
       it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks) => {
-        expectBlocksEqual(await store.getBlocks(start, limit), getExpectedBlocks());
+        expectBlocksEqual(await store.getPublishedBlocks(start, limit), getExpectedBlocks());
       });
 
       it('returns an empty array if no blocks are found', async () => {
-        await expect(store.getBlocks(12, 1)).resolves.toEqual([]);
+        await expect(store.getPublishedBlocks(12, 1)).resolves.toEqual([]);
       });
 
       it('throws an error if limit is invalid', async () => {
-        await expect(store.getBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
+        await expect(store.getPublishedBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
       });
 
       it('throws an error if `from` it is out of range', async () => {
-        await expect(store.getBlocks(INITIAL_L2_BLOCK_NUM - 100, 1)).rejects.toThrow('Invalid start: -99');
+        await expect(store.getPublishedBlocks(INITIAL_L2_BLOCK_NUM - 100, 1)).rejects.toThrow('Invalid start: -99');
+      });
+
+      it('throws an error if unexpected initial block number is found', async () => {
+        await store.addBlocks([makePublished(await L2Block.random(21), 31)], { force: true });
+        await expect(store.getPublishedBlocks(20, 1)).rejects.toThrow(`mismatch`);
+      });
+
+      it('throws an error if a gap is found', async () => {
+        await store.addBlocks(
+          [makePublished(await L2Block.random(20), 30), makePublished(await L2Block.random(22), 32)],
+          { force: true },
+        );
+        await expect(store.getPublishedBlocks(20, 2)).rejects.toThrow(`mismatch`);
       });
     });
 
@@ -166,13 +198,25 @@ export function describeArchiverDataStore(
       });
 
       it('returns the L1 block number that most recently added messages from inbox', async () => {
-        await store.addL1ToL2Messages({
-          lastProcessedL1BlockNumber: 1n,
-          retrievedData: [new InboxLeaf(1n, Fr.ZERO)],
-        });
+        const l1BlockHash = Buffer32.random();
+        const l1BlockNumber = 10n;
+        await store.setMessageSynchedL1Block({ l1BlockNumber: 5n, l1BlockHash: Buffer32.random() });
+        await store.addL1ToL2Messages([makeInboxMessage(Buffer16.ZERO, { l1BlockNumber, l1BlockHash })]);
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
-          messagesSynchedTo: 1n,
+          messagesSynchedTo: { l1BlockHash, l1BlockNumber },
+        } satisfies ArchiverL1SynchPoint);
+      });
+
+      it('returns the latest syncpoint if latest message is behind', async () => {
+        const l1BlockHash = Buffer32.random();
+        const l1BlockNumber = 10n;
+        await store.setMessageSynchedL1Block({ l1BlockNumber, l1BlockHash });
+        const msg = makeInboxMessage(Buffer16.ZERO, { l1BlockNumber: 5n, l1BlockHash: Buffer32.random() });
+        await store.addL1ToL2Messages([msg]);
+        await expect(store.getSynchPoint()).resolves.toEqual({
+          blocksSynchedTo: undefined,
+          messagesSynchedTo: { l1BlockHash, l1BlockNumber },
         } satisfies ArchiverL1SynchPoint);
       });
     });
@@ -278,36 +322,196 @@ export function describeArchiverDataStore(
     });
 
     describe('L1 to L2 Messages', () => {
-      const l2BlockNumber = 13n;
-      const l1ToL2MessageSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
+      const initialL2BlockNumber = 13n;
+
+      const checkMessages = async (msgs: InboxMessage[]) => {
+        expect(await store.getLastL1ToL2Message()).toEqual(msgs.at(-1));
+        expect(await toArray(store.iterateL1ToL2Messages())).toEqual(msgs);
+        expect(await store.getTotalL1ToL2MessageCount()).toEqual(BigInt(msgs.length));
+      };
+
+      const makeInboxMessagesWithFullBlocks = (blockCount: number, opts: { initialL2BlockNumber?: bigint } = {}) =>
+        makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
+          overrideFn: (msg, i) => {
+            const l2BlockNumber =
+              (opts.initialL2BlockNumber ?? initialL2BlockNumber) +
+              BigInt(Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+            const index =
+              InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+            return { ...msg, l2BlockNumber, index };
+          },
+        });
+
+      it('stores first message ever', async () => {
+        const msg = makeInboxMessage(Buffer16.ZERO, { index: 0n, l2BlockNumber: 1n });
+        await store.addL1ToL2Messages([msg]);
+
+        await checkMessages([msg]);
+        expect(await store.getL1ToL2Messages(1n)).toEqual([msg.leaf]);
+      });
+
+      it('stores single message', async () => {
+        const msg = makeInboxMessage(Buffer16.ZERO, { l2BlockNumber: 2n });
+        await store.addL1ToL2Messages([msg]);
+
+        await checkMessages([msg]);
+        expect(await store.getL1ToL2Messages(2n)).toEqual([msg.leaf]);
+      });
 
-      const generateBlockMessages = (blockNumber: bigint, numMessages: number) =>
-        Array.from(
-          { length: numMessages },
-          (_, i) => new InboxLeaf(InboxLeaf.smallestIndexFromL2Block(blockNumber) + BigInt(i), Fr.random()),
+      it('stores and returns messages across different blocks', async () => {
+        const msgs = makeInboxMessages(5, { initialL2BlockNumber });
+        await store.addL1ToL2Messages(msgs);
+
+        await checkMessages(msgs);
+        expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2n)).toEqual([msgs[2]].map(m => m.leaf));
+      });
+
+      it('stores the same messages again', async () => {
+        const msgs = makeInboxMessages(5, { initialL2BlockNumber });
+        await store.addL1ToL2Messages(msgs);
+        await store.addL1ToL2Messages(msgs.slice(2));
+
+        await checkMessages(msgs);
+      });
+
+      it('stores and returns messages across different blocks with gaps', async () => {
+        const msgs1 = makeInboxMessages(3, { initialL2BlockNumber: 1n });
+        const msgs2 = makeInboxMessages(3, { initialL2BlockNumber: 20n, initialHash: msgs1.at(-1)!.rollingHash });
+
+        await store.addL1ToL2Messages(msgs1);
+        await store.addL1ToL2Messages(msgs2);
+
+        await checkMessages([...msgs1, ...msgs2]);
+
+        expect(await store.getL1ToL2Messages(1n)).toEqual([msgs1[0].leaf]);
+        expect(await store.getL1ToL2Messages(4n)).toEqual([]);
+        expect(await store.getL1ToL2Messages(20n)).toEqual([msgs2[0].leaf]);
+        expect(await store.getL1ToL2Messages(24n)).toEqual([]);
+      });
+
+      it('stores and returns messages with block numbers larger than a byte', async () => {
+        const msgs = makeInboxMessages(5, { initialL2BlockNumber: 1000n });
+        await store.addL1ToL2Messages(msgs);
+
+        await checkMessages(msgs);
+        expect(await store.getL1ToL2Messages(1002n)).toEqual([msgs[2]].map(m => m.leaf));
+      });
+
+      it('stores and returns multiple messages per block', async () => {
+        const msgs = makeInboxMessagesWithFullBlocks(4);
+        await store.addL1ToL2Messages(msgs);
+
+        await checkMessages(msgs);
+        const blockMessages = await store.getL1ToL2Messages(initialL2BlockNumber + 1n);
+        expect(blockMessages).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(blockMessages).toEqual(
+          msgs.slice(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2).map(m => m.leaf),
         );
+      });
+
+      it('stores messages in multiple operations', async () => {
+        const msgs = makeInboxMessages(20, { initialL2BlockNumber });
+        await store.addL1ToL2Messages(msgs.slice(0, 10));
+        await store.addL1ToL2Messages(msgs.slice(10, 20));
+
+        expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2n)).toEqual([msgs[2]].map(m => m.leaf));
+        expect(await store.getL1ToL2Messages(initialL2BlockNumber + 12n)).toEqual([msgs[12]].map(m => m.leaf));
+        await checkMessages(msgs);
+      });
 
-      it('returns messages in correct order', async () => {
-        const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize);
-        const shuffledMessages = msgs.slice().sort(() => randomInt(1) - 0.5);
-        await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: shuffledMessages });
-        const retrievedMessages = await store.getL1ToL2Messages(l2BlockNumber);
+      it('iterates over messages from start index', async () => {
+        const msgs = makeInboxMessages(10, { initialL2BlockNumber });
+        await store.addL1ToL2Messages(msgs);
 
-        const expectedLeavesOrder = msgs.map(msg => msg.leaf);
-        expect(expectedLeavesOrder).toEqual(retrievedMessages);
+        const iterated = await toArray(store.iterateL1ToL2Messages({ start: msgs[3].index }));
+        expect(iterated).toEqual(msgs.slice(3));
       });
 
-      it('throws if it is impossible to sequence messages correctly', async () => {
-        const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize - 1);
-        // We replace a message with index 4 with a message with index at the end of the tree
-        // --> with that there will be a gap and it will be impossible to sequence the
-        // end of tree = start of next tree/block - 1
-        msgs[4] = new InboxLeaf(InboxLeaf.smallestIndexFromL2Block(l2BlockNumber + 1n) - 1n, Fr.random());
+      it('iterates over messages in reverse', async () => {
+        const msgs = makeInboxMessages(10, { initialL2BlockNumber });
+        await store.addL1ToL2Messages(msgs);
+
+        const iterated = await toArray(store.iterateL1ToL2Messages({ reverse: true, end: msgs[3].index }));
+        expect(iterated).toEqual(msgs.slice(0, 4).reverse());
+      });
+
+      it('throws if messages are added out of order', async () => {
+        const msgs = makeInboxMessages(5, { overrideFn: (msg, i) => ({ ...msg, index: BigInt(10 - i) }) });
+        await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+      });
+
+      it('throws if block number for the first message is out of order', async () => {
+        const msgs = makeInboxMessages(4, { initialL2BlockNumber });
+        msgs[2].l2BlockNumber = initialL2BlockNumber - 1n;
+        await store.addL1ToL2Messages(msgs.slice(0, 2));
+        await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
+      });
 
-        await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: msgs });
-        await expect(async () => {
-          await store.getL1ToL2Messages(l2BlockNumber);
-        }).rejects.toThrow(`L1 to L2 message gap found in block ${l2BlockNumber}`);
+      it('throws if rolling hash is not correct', async () => {
+        const msgs = makeInboxMessages(5);
+        msgs[1].rollingHash = Buffer16.random();
+        await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+      });
+
+      it('throws if rolling hash for first message is not correct', async () => {
+        const msgs = makeInboxMessages(4);
+        msgs[2].rollingHash = Buffer16.random();
+        await store.addL1ToL2Messages(msgs.slice(0, 2));
+        await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
+      });
+
+      it('throws if index is not in the correct range', async () => {
+        const msgs = makeInboxMessages(5, { initialL2BlockNumber });
+        msgs.at(-1)!.index += 100n;
+        await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+      });
+
+      it('throws if first index in block has gaps', async () => {
+        const msgs = makeInboxMessages(4, { initialL2BlockNumber });
+        msgs[2].index++;
+        await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+      });
+
+      it('throws if index does not follow previous one', async () => {
+        const msgs = makeInboxMessages(2, {
+          initialL2BlockNumber,
+          overrideFn: (msg, i) => ({
+            ...msg,
+            l2BlockNumber: 2n,
+            index: BigInt(i + NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2),
+          }),
+        });
+        msgs[1].index++;
+        await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+      });
+
+      it('removes messages up to the given block number', async () => {
+        const msgs = makeInboxMessagesWithFullBlocks(4, { initialL2BlockNumber: 1n });
+
+        await store.addL1ToL2Messages(msgs);
+        await checkMessages(msgs);
+
+        expect(await store.getL1ToL2Messages(1n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(2n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(3n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(4n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+
+        await store.rollbackL1ToL2MessagesToL2Block(2n);
+
+        expect(await store.getL1ToL2Messages(1n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(2n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(3n)).toHaveLength(0);
+        expect(await store.getL1ToL2Messages(4n)).toHaveLength(0);
+
+        await checkMessages(msgs.slice(0, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2));
+      });
+
+      it('removes messages starting with the given index', async () => {
+        const msgs = makeInboxMessagesWithFullBlocks(4, { initialL2BlockNumber: 1n });
+        await store.addL1ToL2Messages(msgs);
+
+        await store.removeL1ToL2Messages(msgs[13].index);
+        await checkMessages(msgs.slice(0, 13));
       });
     });
 
@@ -386,6 +590,52 @@ export function describeArchiverDataStore(
         expect(fetchedInstance?.originalContractClassId).toEqual(classId);
         expect(fetchedInstance?.currentContractClassId).toEqual(nextClassId);
       });
+
+      it('ignores updates for the wrong contract', async () => {
+        const otherClassId = Fr.random();
+        const randomInstance = await SerializableContractInstance.random({
+          currentContractClassId: otherClassId,
+          originalContractClassId: otherClassId,
+        });
+        const otherContractInstance = {
+          ...randomInstance,
+          address: await AztecAddress.random(),
+        };
+        await store.addContractInstances([otherContractInstance], 1);
+
+        const fetchedInstance = await store.getContractInstance(otherContractInstance.address, blockOfChange + 1);
+        expect(fetchedInstance?.originalContractClassId).toEqual(otherClassId);
+        expect(fetchedInstance?.currentContractClassId).toEqual(otherClassId);
+      });
+
+      it('bounds its search to the right contract if more than than one update exists', async () => {
+        const otherClassId = Fr.random();
+        const otherNextClassId = Fr.random();
+        const randomInstance = await SerializableContractInstance.random({
+          currentContractClassId: otherClassId,
+          originalContractClassId: otherNextClassId,
+        });
+        const otherContractInstance = {
+          ...randomInstance,
+          address: await AztecAddress.random(),
+        };
+        await store.addContractInstances([otherContractInstance], 1);
+        await store.addContractInstanceUpdates(
+          [
+            {
+              prevContractClassId: otherClassId,
+              newContractClassId: otherNextClassId,
+              blockOfChange,
+              address: otherContractInstance.address,
+            },
+          ],
+          blockOfChange - 1,
+        );
+
+        const fetchedInstance = await store.getContractInstance(contractInstance.address, blockOfChange + 1);
+        expect(fetchedInstance?.originalContractClassId).toEqual(classId);
+        expect(fetchedInstance?.currentContractClassId).toEqual(nextClassId);
+      });
     });
 
     describe('contractClasses', () => {
@@ -464,17 +714,22 @@ export function describeArchiverDataStore(
       let blocks: PublishedL2Block[];
 
       const makeTag = (blockNumber: number, txIndex: number, logIndex: number, isPublic = false) =>
-        new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
+        blockNumber === 1 && txIndex === 0 && logIndex === 0
+          ? Fr.ZERO // Shared tag
+          : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
 
       const makePrivateLog = (tag: Fr) =>
-        PrivateLog.fromFields([tag, ...times(PRIVATE_LOG_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i))]);
+        PrivateLog.from({
+          fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, i => (!i ? tag : new Fr(tag.toNumber() + i))),
+          emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS,
+        });
 
       const makePublicLog = (tag: Fr) =>
-        PublicLog.fromFields([
-          AztecAddress.fromNumber(1).toField(), // log address
-          tag, // field 0
-          ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)), // fields 1 to end
-        ]);
+        PublicLog.from({
+          contractAddress: AztecAddress.fromNumber(1),
+          fields: makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, i => (!i ? tag : new Fr(tag.toNumber() + i))),
+          emittedLength: PUBLIC_LOG_SIZE_IN_FIELDS,
+        });
 
       const mockPrivateLogs = (blockNumber: number, txIndex: number) => {
         return times(numPrivateLogsPerTx, (logIndex: number) => {
@@ -509,28 +764,28 @@ export function describeArchiverDataStore(
       };
 
       beforeEach(async () => {
-        blocks = await timesParallel(numBlocks, (index: number) => mockBlockWithLogs(index));
+        blocks = await timesParallel(numBlocks, (index: number) => mockBlockWithLogs(index + 1));
 
         await store.addBlocks(blocks);
         await store.addLogs(blocks.map(b => b.block));
       });
 
       it('is possible to batch request private logs via tags', async () => {
-        const tags = [makeTag(1, 1, 2), makeTag(0, 2, 0)];
+        const tags = [makeTag(2, 1, 2), makeTag(1, 2, 0)];
 
         const logsByTags = await store.getLogsByTags(tags);
 
         expect(logsByTags).toEqual([
           [
             expect.objectContaining({
-              blockNumber: 1,
+              blockNumber: 2,
               log: makePrivateLog(tags[0]),
               isFromPublic: false,
             }),
           ],
           [
             expect.objectContaining({
-              blockNumber: 0,
+              blockNumber: 1,
               log: makePrivateLog(tags[1]),
               isFromPublic: false,
             }),
@@ -539,20 +794,20 @@ export function describeArchiverDataStore(
       });
 
       it('is possible to batch request all logs (private and public) via tags', async () => {
-        // Tag(0, 0, 0) is shared with the first private log and the first public log.
-        const tags = [makeTag(0, 0, 0)];
+        // Tag(1, 0, 0) is shared with the first private log and the first public log.
+        const tags = [makeTag(1, 0, 0)];
 
         const logsByTags = await store.getLogsByTags(tags);
 
         expect(logsByTags).toEqual([
           [
             expect.objectContaining({
-              blockNumber: 0,
+              blockNumber: 1,
               log: makePrivateLog(tags[0]),
               isFromPublic: false,
             }),
             expect.objectContaining({
-              blockNumber: 0,
+              blockNumber: 1,
               log: makePublicLog(tags[0]),
               isFromPublic: true,
             }),