@aztec/archiver 0.56.0 → 0.57.0

package/src/archiver/archiver_store.ts

@@ -1,6 +1,4 @@
 import {
-  type EncryptedL2BlockL2Logs,
-  type EncryptedNoteL2BlockL2Logs,
   type FromLogType,
   type GetUnencryptedLogsResponse,
   type InboxLeaf,
@@ -11,9 +9,8 @@ import {
   type TxEffect,
   type TxHash,
   type TxReceipt,
-  type UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/circuits.js';
+import { type Fr, type Header } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import {
@@ -23,7 +20,7 @@ import {
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/types/contracts';
 
-import { type DataRetrieval, type SingletonDataRetrieval } from './structs/data_retrieval.js';
+import { type DataRetrieval } from './structs/data_retrieval.js';
 import { type L1Published } from './structs/published.js';
 
 /**
@@ -50,6 +47,15 @@ export interface ArchiverDataStore {
    */
   addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean>;
 
+  /**
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
+   */
+  unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean>;
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
@@ -58,6 +64,14 @@ export interface ArchiverDataStore {
    */
   getBlocks(from: number, limit: number): Promise<L1Published<L2Block>[]>;
 
+  /**
+   * Gets up to `limit` amount of L2 block headers 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 block headers.
+   */
+  getBlockHeaders(from: number, limit: number): Promise<Header[]>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The txHash of the tx corresponding to the tx effect.
@@ -74,18 +88,11 @@ export interface ArchiverDataStore {
 
   /**
    * Append new logs to the store's list.
-   * @param noteEncryptedLogs - The note encrypted logs to be added to the store.
-   * @param encryptedLogs - The encrypted logs to be added to the store.
-   * @param unencryptedLogs - The unencrypted logs to be added to the store.
-   * @param blockNumber - The block for which to add the logs.
+   * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(
-    noteEncryptedLogs: EncryptedNoteL2BlockL2Logs | undefined,
-    encryptedLogs: EncryptedL2BlockL2Logs | undefined,
-    unencryptedLogs: UnencryptedL2BlockL2Logs | undefined,
-    blockNumber: number,
-  ): Promise<boolean>;
+  addLogs(blocks: L2Block[]): Promise<boolean>;
+  deleteLogs(blocks: L2Block[]): Promise<boolean>;
 
   /**
    * Append L1 to L2 messages to the store.
@@ -109,6 +116,12 @@ export interface ArchiverDataStore {
    */
   getL1ToL2MessageIndex(l1ToL2Message: Fr, startIndex: bigint): Promise<bigint | undefined>;
 
+  /**
+   * Get the total number of L1 to L2 messages
+   * @returns The number of L1 to L2 messages in the store
+   */
+  getTotalL1ToL2MessageCount(): Promise<bigint>;
+
   /**
    * Gets up to `limit` amount of logs starting from `from`.
    * @param from - Number of the L2 block to which corresponds the first logs to be returned.
@@ -141,11 +154,23 @@ export interface ArchiverDataStore {
    */
   getProvenL2BlockNumber(): Promise<number>;
 
+  /**
+   * Gets the number of the latest proven L2 epoch.
+   * @returns The number of the latest proven L2 epoch.
+   */
+  getProvenL2EpochNumber(): Promise<number | undefined>;
+
   /**
    * Stores the number of the latest proven L2 block processed.
    * @param l2BlockNumber - The number of the latest proven L2 block processed.
    */
-  setProvenL2BlockNumber(l2BlockNumber: SingletonDataRetrieval<number>): Promise<void>;
+  setProvenL2BlockNumber(l2BlockNumber: number): Promise<void>;
+
+  /**
+   * Stores the number of the latest proven L2 epoch.
+   * @param l2EpochNumber - The number of the latest proven L2 epoch.
+   */
+  setProvenL2EpochNumber(l2EpochNumber: number): Promise<void>;
 
   /**
    * Stores the l1 block number that blocks have been synched until
@@ -172,6 +197,8 @@ export interface ArchiverDataStore {
    */
   addContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean>;
 
+  deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean>;
+
   /**
    * Returns a contract class given its id, or undefined if not exists.
    * @param id - Id of the contract class.
@@ -185,6 +212,7 @@ export interface ArchiverDataStore {
    * @returns True if the operation is successful.
    */
   addContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean>;
+  deleteContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean>;
 
   /**
    * Adds private functions to a contract class.

package/src/archiver/archiver_store_test_suite.ts

@@ -52,6 +52,20 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
     });
 
+    describe('unwindBlocks', () => {
+      it('unwinding blocks will remove blocks from the chain', async () => {
+        await store.addBlocks(blocks);
+        const blockNumber = await store.getSynchedL2BlockNumber();
+
+        expect(await store.getBlocks(blockNumber, 1)).toEqual([blocks[blocks.length - 1]]);
+
+        await store.unwindBlocks(blockNumber, 1);
+
+        expect(await store.getSynchedL2BlockNumber()).toBe(blockNumber - 1);
+        expect(await store.getBlocks(blockNumber, 1)).toEqual([]);
+      });
+    });
+
     describe('getBlocks', () => {
       beforeEach(async () => {
         await store.addBlocks(blocks);
@@ -69,8 +83,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
       });
 
-      it('resets `from` to the first block if it is out of range', async () => {
-        await expect(store.getBlocks(INITIAL_L2_BLOCK_NUM - 100, 1)).resolves.toEqual(blocks.slice(0, 1));
+      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');
       });
     });
 
@@ -90,7 +104,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
           messagesSynchedTo: undefined,
-          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
@@ -99,7 +112,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: 19n,
           messagesSynchedTo: undefined,
-          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
@@ -111,16 +123,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
           messagesSynchedTo: 1n,
-          provenLogsSynchedTo: undefined,
-        } satisfies ArchiverL1SynchPoint);
-      });
-
-      it('returns the L1 block number that most recently logged a proven block', async () => {
-        await store.setProvenL2BlockNumber({ lastProcessedL1BlockNumber: 3n, retrievedData: 5 });
-        await expect(store.getSynchPoint()).resolves.toEqual({
-          blocksSynchedTo: undefined,
-          messagesSynchedTo: undefined,
-          provenLogsSynchedTo: 3n,
         } satisfies ArchiverL1SynchPoint);
       });
     });
@@ -128,14 +130,26 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     describe('addLogs', () => {
       it('adds encrypted & unencrypted logs', async () => {
         const block = blocks[0].data;
-        await expect(
-          store.addLogs(
-            block.body.noteEncryptedLogs,
-            block.body.encryptedLogs,
-            block.body.unencryptedLogs,
-            block.number,
-          ),
-        ).resolves.toEqual(true);
+        await expect(store.addLogs([block])).resolves.toEqual(true);
+      });
+    });
+
+    describe('deleteLogs', () => {
+      it('deletes encrypted & unencrypted logs', async () => {
+        const block = blocks[0].data;
+        await store.addBlocks([blocks[0]]);
+        await expect(store.addLogs([block])).resolves.toEqual(true);
+
+        expect((await store.getLogs(1, 1, LogType.NOTEENCRYPTED))[0]).toEqual(block.body.noteEncryptedLogs);
+        expect((await store.getLogs(1, 1, LogType.ENCRYPTED))[0]).toEqual(block.body.encryptedLogs);
+        expect((await store.getLogs(1, 1, LogType.UNENCRYPTED))[0]).toEqual(block.body.unencryptedLogs);
+
+        // This one is a pain for memory as we would never want to just delete memory in the middle.
+        await store.deleteLogs([block]);
+
+        expect((await store.getLogs(1, 1, LogType.NOTEENCRYPTED))[0]).toEqual(undefined);
+        expect((await store.getLogs(1, 1, LogType.ENCRYPTED))[0]).toEqual(undefined);
+        expect((await store.getLogs(1, 1, LogType.UNENCRYPTED))[0]).toEqual(undefined);
       });
     });
 
@@ -145,16 +159,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       ['unencrypted', LogType.UNENCRYPTED],
     ])('getLogs (%s)', (_, logType) => {
       beforeEach(async () => {
-        await Promise.all(
-          blocks.map(block =>
-            store.addLogs(
-              block.data.body.noteEncryptedLogs,
-              block.data.body.encryptedLogs,
-              block.data.body.unencryptedLogs,
-              block.data.number,
-            ),
-          ),
-        );
+        await store.addBlocks(blocks);
+        await store.addLogs(blocks.map(b => b.data));
       });
 
       it.each(blockTests)('retrieves previously stored logs', async (from, limit, getExpectedBlocks) => {
@@ -176,16 +182,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
 
     describe('getTxEffect', () => {
       beforeEach(async () => {
-        await Promise.all(
-          blocks.map(block =>
-            store.addLogs(
-              block.data.body.noteEncryptedLogs,
-              block.data.body.encryptedLogs,
-              block.data.body.unencryptedLogs,
-              block.data.number,
-            ),
-          ),
-        );
+        await store.addLogs(blocks.map(b => b.data));
         await store.addBlocks(blocks);
       });
 
@@ -204,6 +201,24 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('returns undefined if tx is not found', async () => {
         await expect(store.getTxEffect(new TxHash(Fr.random().toBuffer()))).resolves.toBeUndefined();
       });
+
+      it.each([
+        () => blocks[0].data.body.txEffects[0],
+        () => blocks[9].data.body.txEffects[3],
+        () => blocks[3].data.body.txEffects[1],
+        () => blocks[5].data.body.txEffects[2],
+        () => blocks[1].data.body.txEffects[0],
+      ])('tries to retrieves a previously stored transaction after deleted', async getExpectedTx => {
+        await store.unwindBlocks(blocks.length, blocks.length);
+
+        const expectedTx = getExpectedTx();
+        const actualTx = await store.getTxEffect(expectedTx.txHash);
+        expect(actualTx).toEqual(undefined);
+      });
+
+      it('returns undefined if tx is not found', async () => {
+        await expect(store.getTxEffect(new TxHash(Fr.random().toBuffer()))).resolves.toBeUndefined();
+      });
     });
 
     describe('L1 to L2 Messages', () => {
@@ -274,6 +289,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('returns undefined if contract instance is not found', async () => {
         await expect(store.getContractInstance(AztecAddress.random())).resolves.toBeUndefined();
       });
+
+      it('returns undefined if previously stored contract instances was deleted', async () => {
+        await store.deleteContractInstances([contractInstance], blockNum);
+        await expect(store.getContractInstance(contractInstance.address)).resolves.toBeUndefined();
+      });
     });
 
     describe('contractClasses', () => {
@@ -289,6 +309,17 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getContractClass(contractClass.id)).resolves.toMatchObject(contractClass);
       });
 
+      it('returns undefined if the initial deployed contract class was deleted', async () => {
+        await store.deleteContractClasses([contractClass], blockNum);
+        await expect(store.getContractClass(contractClass.id)).resolves.toBeUndefined();
+      });
+
+      it('returns contract class if later "deployment" class was deleted', async () => {
+        await store.addContractClasses([contractClass], blockNum + 1);
+        await store.deleteContractClasses([contractClass], blockNum + 1);
+        await expect(store.getContractClass(contractClass.id)).resolves.toMatchObject(contractClass);
+      });
+
       it('returns undefined if contract class is not found', async () => {
         await expect(store.getContractClass(Fr.random())).resolves.toBeUndefined();
       });
@@ -338,17 +369,25 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         }));
 
         await store.addBlocks(blocks);
+        await store.addLogs(blocks.map(b => b.data));
+      });
 
-        await Promise.all(
-          blocks.map(block =>
-            store.addLogs(
-              block.data.body.noteEncryptedLogs,
-              block.data.body.encryptedLogs,
-              block.data.body.unencryptedLogs,
-              block.data.number,
-            ),
-          ),
-        );
+      it('no logs returned if deleted ("txHash" filter param is respected variant)', async () => {
+        // get random tx
+        const targetBlockIndex = randomInt(numBlocks);
+        const targetTxIndex = randomInt(txsPerBlock);
+        const targetTxHash = blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash;
+
+        await Promise.all([
+          store.unwindBlocks(blocks.length, blocks.length),
+          store.deleteLogs(blocks.map(b => b.data)),
+        ]);
+
+        const response = await store.getUnencryptedLogs({ txHash: targetTxHash });
+        const logs = response.logs;
+
+        expect(response.maxLogsHit).toBeFalsy();
+        expect(logs.length).toEqual(0);
       });
 
       it('"txHash" filter param is respected', async () => {

package/src/archiver/config.ts

@@ -52,11 +52,6 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',
     ...numberConfigHelper(1000),
   },
-  viemPollingIntervalMS: {
-    env: 'ARCHIVER_VIEM_POLLING_INTERVAL_MS',
-    description: 'The polling interval viem uses in ms',
-    ...numberConfigHelper(1000),
-  },
   dataDirectory: {
     env: 'DATA_DIRECTORY',
     description: 'Optional dir to store data. If omitted will store in memory.',
@@ -67,6 +62,11 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     ...numberConfigHelper(1_000),
   },
   ...l1ReaderConfigMappings,
+  viemPollingIntervalMS: {
+    env: 'ARCHIVER_VIEM_POLLING_INTERVAL_MS',
+    description: 'The polling interval viem uses in ms',
+    ...numberConfigHelper(1000),
+  },
 };
 
 /**

package/src/archiver/data_retrieval.ts

@@ -134,7 +134,9 @@ async function getBlockFromRollupTx(
     data,
   });
 
-  if (!(functionName === 'propose')) {
+  const allowedMethods = ['propose', 'proposeAndClaim'];
+
+  if (!allowedMethods.includes(functionName)) {
     throw new Error(`Unexpected method called ${functionName}`);
   }
   const [headerHex, archiveRootHex, , , , bodyHex] = args! as readonly [Hex, Hex, Hex, Hex[], ViemSignature[], Hex];
@@ -237,7 +239,7 @@ export async function retrieveL2ProofsFromRollup(
   const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1)!.l1BlockNumber : searchStartBlock - 1n;
 
   for (const { txHash, proverId, l2BlockNumber } of logs) {
-    const proofData = await getBlockProofFromSubmitProofTx(publicClient, txHash, l2BlockNumber, proverId);
+    const proofData = await getProofFromSubmitProofTx(publicClient, txHash, proverId);
     retrievedData.push({ proof: proofData.proof, proverId: proofData.proverId, l2BlockNumber, txHash });
   }
   return {
@@ -247,7 +249,6 @@ export async function retrieveL2ProofsFromRollup(
 }
 
 export type SubmitBlockProof = {
-  header: Header;
   archiveRoot: Fr;
   proverId: Fr;
   aggregationObject: Buffer;
@@ -263,39 +264,37 @@ export type SubmitBlockProof = {
  * @param l2BlockNum - L2 block number.
  * @returns L2 block metadata (header and archive) from the calldata, deserialized
  */
-export async function getBlockProofFromSubmitProofTx(
+export async function getProofFromSubmitProofTx(
   publicClient: PublicClient,
   txHash: `0x${string}`,
-  l2BlockNum: bigint,
   expectedProverId: Fr,
 ): Promise<SubmitBlockProof> {
   const { input: data } = await publicClient.getTransaction({ hash: txHash });
-  const { functionName, args } = decodeFunctionData({
-    abi: RollupAbi,
-    data,
-  });
-
-  if (!(functionName === 'submitBlockRootProof')) {
-    throw new Error(`Unexpected method called ${functionName}`);
+  const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });
+
+  let proverId: Fr;
+  let archiveRoot: Fr;
+  let aggregationObject: Buffer;
+  let proof: Proof;
+
+  if (functionName === 'submitEpochRootProof') {
+    const [_epochSize, nestedArgs, _fees, aggregationObjectHex, proofHex] = args!;
+    aggregationObject = Buffer.from(hexToBytes(aggregationObjectHex));
+    proverId = Fr.fromString(nestedArgs[6]);
+    archiveRoot = Fr.fromString(nestedArgs[1]);
+    proof = Proof.fromBuffer(Buffer.from(hexToBytes(proofHex)));
+  } else {
+    throw new Error(`Unexpected proof method called ${functionName}`);
   }
-  const [headerHex, archiveHex, proverIdHex, aggregationObjectHex, proofHex] = args!;
-
-  const header = Header.fromBuffer(Buffer.from(hexToBytes(headerHex)));
-  const proverId = Fr.fromString(proverIdHex);
 
-  const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
-  if (blockNumberFromHeader !== l2BlockNum) {
-    throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${blockNumberFromHeader}`);
-  }
   if (!proverId.equals(expectedProverId)) {
     throw new Error(`Prover ID mismatch: expected ${expectedProverId} but got ${proverId}`);
   }
 
   return {
-    header,
     proverId,
-    aggregationObject: Buffer.from(hexToBytes(aggregationObjectHex)),
-    archiveRoot: Fr.fromString(archiveHex),
-    proof: Proof.fromBuffer(Buffer.from(hexToBytes(proofHex))),
+    aggregationObject,
+    archiveRoot,
+    proof,
   };
 }

package/src/archiver/epoch_helpers.ts

@@ -0,0 +1,26 @@
+import { AZTEC_EPOCH_DURATION, AZTEC_SLOT_DURATION } from '@aztec/circuits.js';
+
+/** Returns the slot number for a given timestamp. */
+export function getSlotAtTimestamp(ts: bigint, constants: { l1GenesisTime: bigint }) {
+  return ts < constants.l1GenesisTime ? 0n : (ts - constants.l1GenesisTime) / BigInt(AZTEC_SLOT_DURATION);
+}
+
+/** Returns the epoch number for a given timestamp. */
+export function getEpochNumberAtTimestamp(ts: bigint, constants: { l1GenesisTime: bigint }) {
+  return getSlotAtTimestamp(ts, constants) / BigInt(AZTEC_EPOCH_DURATION);
+}
+
+/** Returns the range of slots (inclusive) for a given epoch number. */
+export function getSlotRangeForEpoch(epochNumber: bigint) {
+  const startSlot = epochNumber * BigInt(AZTEC_EPOCH_DURATION);
+  return [startSlot, startSlot + BigInt(AZTEC_EPOCH_DURATION) - 1n];
+}
+
+/** Returns the range of L1 timestamps (inclusive) for a given epoch number. */
+export function getTimestampRangeForEpoch(epochNumber: bigint, constants: { l1GenesisTime: bigint }) {
+  const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber);
+  return [
+    constants.l1GenesisTime + startSlot * BigInt(AZTEC_SLOT_DURATION),
+    constants.l1GenesisTime + endSlot * BigInt(AZTEC_SLOT_DURATION),
+  ];
+}

package/src/archiver/kv_archiver_store/block_store.ts

@@ -26,6 +26,12 @@ export class BlockStore {
   /** Stores L1 block number in which the last processed L2 block was included */
   #lastSynchedL1Block: AztecSingleton<bigint>;
 
+  /** Stores l2 block number of the last proven block */
+  #lastProvenL2Block: AztecSingleton<number>;
+
+  /** Stores l2 epoch number of the last proven epoch */
+  #lastProvenL2Epoch: AztecSingleton<number>;
+
   /** Index mapping transaction hash (as a string) to its location in a block */
   #txIndex: AztecMap<string, BlockIndexValue>;
 
@@ -40,6 +46,8 @@ export class BlockStore {
     this.#txIndex = db.openMap('archiver_tx_index');
     this.#contractIndex = db.openMap('archiver_contract_index');
     this.#lastSynchedL1Block = db.openSingleton('archiver_last_synched_l1_block');
+    this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
+    this.#lastProvenL2Epoch = db.openSingleton('archiver_last_proven_l2_epoch');
   }
 
   /**
@@ -73,6 +81,38 @@ export class BlockStore {
     });
   }
 
+  /**
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
+   */
+  unwindBlocks(from: number, blocksToUnwind: number) {
+    return this.db.transaction(() => {
+      const last = this.getSynchedL2BlockNumber();
+      if (from != last) {
+        throw new Error(`Can only remove from the tip`);
+      }
+
+      for (let i = 0; i < blocksToUnwind; i++) {
+        const blockNumber = from - i;
+        const block = this.getBlock(blockNumber);
+
+        if (block === undefined) {
+          throw new Error(`Cannot remove block ${blockNumber} from the store, we don't have it`);
+        }
+        void this.#blocks.delete(block.data.number);
+        block.data.body.txEffects.forEach(tx => {
+          void this.#txIndex.delete(tx.txHash.toString());
+        });
+        void this.#blockBodies.delete(block.data.body.getTxsEffectsHash().toString('hex'));
+      }
+
+      return true;
+    });
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param start - Number of the first block to return (inclusive).
@@ -99,6 +139,18 @@ export class BlockStore {
     return this.getBlockFromBlockStorage(blockStorage);
   }
 
+  /**
+   * Gets the headers for a sequence of L2 blocks.
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 block headers
+   */
+  *getBlockHeaders(start: number, limit: number): IterableIterator<Header> {
+    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
+      yield Header.fromBuffer(blockStorage.header);
+    }
+  }
+
   private getBlockFromBlockStorage(blockStorage: BlockStorage) {
     const header = Header.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
@@ -109,7 +161,7 @@ export class BlockStore {
     }
     const body = Body.fromBuffer(blockBodyBuffer);
 
-    const l2Block = L2Block.fromFields({ header, archive, body });
+    const l2Block = new L2Block(archive, header, body);
     return { data: l2Block, l1: blockStorage.l1 };
   }
 
@@ -191,13 +243,29 @@ export class BlockStore {
     void this.#lastSynchedL1Block.set(l1BlockNumber);
   }
 
+  getProvenL2BlockNumber(): number {
+    return this.#lastProvenL2Block.get() ?? 0;
+  }
+
+  setProvenL2BlockNumber(blockNumber: number) {
+    void this.#lastProvenL2Block.set(blockNumber);
+  }
+
+  getProvenL2EpochNumber(): number | undefined {
+    return this.#lastProvenL2Epoch.get();
+  }
+
+  setProvenL2EpochNumber(epochNumber: number) {
+    void this.#lastProvenL2Epoch.set(epochNumber);
+  }
+
   #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {
     if (limit < 1) {
       throw new Error(`Invalid limit: ${limit}`);
     }
 
     if (start < INITIAL_L2_BLOCK_NUM) {
-      start = INITIAL_L2_BLOCK_NUM;
+      throw new Error(`Invalid start: ${start}`);
     }
 
     const end = start + limit;

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -3,6 +3,7 @@ import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/s
 import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
 import {
   type ContractClassPublic,
+  type ContractClassPublicWithBlockNumber,
   type ExecutablePrivateFunctionWithMembershipProof,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/types/contracts';
@@ -17,8 +18,18 @@ export class ContractClassStore {
     this.#contractClasses = db.openMap('archiver_contract_classes');
   }
 
-  addContractClass(contractClass: ContractClassPublic): Promise<void> {
-    return this.#contractClasses.set(contractClass.id.toString(), serializeContractClassPublic(contractClass));
+  async addContractClass(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
+    await this.#contractClasses.setIfNotExists(
+      contractClass.id.toString(),
+      serializeContractClassPublic({ ...contractClass, l2BlockNumber: blockNumber }),
+    );
+  }
+
+  async deleteContractClasses(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
+    const restoredContractClass = this.#contractClasses.get(contractClass.id.toString());
+    if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
+      await this.#contractClasses.delete(contractClass.id.toString());
+    }
   }
 
   getContractClass(id: Fr): ContractClassPublic | undefined {
@@ -44,7 +55,7 @@ export class ContractClassStore {
       const existingClass = deserializeContractClassPublic(existingClassBuffer);
       const { privateFunctions: existingPrivateFns, unconstrainedFunctions: existingUnconstrainedFns } = existingClass;
 
-      const updatedClass: Omit<ContractClassPublic, 'id'> = {
+      const updatedClass: Omit<ContractClassPublicWithBlockNumber, 'id'> = {
         ...existingClass,
         privateFunctions: [
           ...existingPrivateFns,
@@ -63,8 +74,9 @@ export class ContractClassStore {
   }
 }
 
-function serializeContractClassPublic(contractClass: Omit<ContractClassPublic, 'id'>): Buffer {
+function serializeContractClassPublic(contractClass: Omit<ContractClassPublicWithBlockNumber, 'id'>): Buffer {
   return serializeToBuffer(
+    contractClass.l2BlockNumber,
     numToUInt8(contractClass.version),
     contractClass.artifactHash,
     contractClass.publicFunctions.length,
@@ -108,9 +120,10 @@ function serializeUnconstrainedFunction(fn: UnconstrainedFunctionWithMembershipP
   );
 }
 
-function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublic, 'id'> {
+function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublicWithBlockNumber, 'id'> {
   const reader = BufferReader.asReader(buffer);
   return {
+    l2BlockNumber: reader.readNumber(),
     version: reader.readUInt8() as 1,
     artifactHash: reader.readObject(Fr),
     publicFunctions: reader.readVector({