@aztec/archiver 0.56.0 → 0.58.0

package/src/archiver/archiver_store.ts

@@ -1,6 +1,4 @@
 import {
-  type EncryptedL2BlockL2Logs,
-  type EncryptedNoteL2BlockL2Logs,
   type FromLogType,
   type GetUnencryptedLogsResponse,
   type InboxLeaf,
@@ -11,19 +9,19 @@ import {
   type TxEffect,
   type TxHash,
   type TxReceipt,
-  type UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import {
   type ContractClassPublic,
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
+  type Fr,
+  type Header,
   type UnconstrainedFunctionWithMembershipProof,
-} from '@aztec/types/contracts';
+} from '@aztec/circuits.js';
+import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
 
-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 +48,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 +65,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 +89,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 +117,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 +155,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 +198,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 +213,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

@@ -1,6 +1,14 @@
 import { InboxLeaf, L2Block, LogId, LogType, TxHash } from '@aztec/circuit-types';
 import '@aztec/circuit-types/jest';
-import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
+import {
+  AztecAddress,
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
+  Fr,
+  INITIAL_L2_BLOCK_NUM,
+  L1_TO_L2_MSG_SUBTREE_HEIGHT,
+  SerializableContractInstance,
+} from '@aztec/circuits.js';
 import {
   makeContractClassPublic,
   makeExecutablePrivateFunctionWithMembershipProof,
@@ -8,11 +16,6 @@ import {
 } from '@aztec/circuits.js/testing';
 import { times } from '@aztec/foundation/collection';
 import { randomBytes, randomInt } from '@aztec/foundation/crypto';
-import {
-  type ContractClassPublic,
-  type ContractInstanceWithAddress,
-  SerializableContractInstance,
-} from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from './archiver_store.js';
 import { type L1Published } from './structs/published.js';
@@ -52,6 +55,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 +86,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 +107,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: undefined,
           messagesSynchedTo: undefined,
-          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
@@ -99,28 +115,17 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: 19n,
           messagesSynchedTo: undefined,
-          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
       it('returns the L1 block number that most recently added messages from inbox', async () => {
         await store.addL1ToL2Messages({
           lastProcessedL1BlockNumber: 1n,
-          retrievedData: [new InboxLeaf(0n, 0n, Fr.ZERO)],
+          retrievedData: [new InboxLeaf(1n, Fr.ZERO)],
         });
         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 +133,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 +162,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 +185,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 +204,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', () => {
@@ -211,7 +229,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const l1ToL2MessageSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
 
       const generateBlockMessages = (blockNumber: bigint, numMessages: number) =>
-        Array.from({ length: numMessages }, (_, i) => new InboxLeaf(blockNumber, BigInt(i), Fr.random()));
+        Array.from(
+          { length: numMessages },
+          (_, i) => new InboxLeaf(InboxLeaf.smallestIndexFromL2Block(blockNumber) + BigInt(i), Fr.random()),
+        );
 
       it('returns messages in correct order', async () => {
         const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize);
@@ -226,8 +247,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       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 messages
-        msgs[4] = new InboxLeaf(l2BlockNumber, BigInt(l1ToL2MessageSubtreeSize - 1), Fr.random());
+        // --> 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());
 
         await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: msgs });
         await expect(async () => {
@@ -235,26 +257,18 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         }).rejects.toThrow(`L1 to L2 message gap found in block ${l2BlockNumber}`);
       });
 
-      it('throws if adding more messages than fits into a block', async () => {
-        const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize + 1);
-
-        await expect(async () => {
-          await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: msgs });
-        }).rejects.toThrow(`Message index ${l1ToL2MessageSubtreeSize} out of subtree range`);
-      });
-
       it('correctly handles duplicate messages', async () => {
         const messageHash = Fr.random();
-
-        const msgs = [new InboxLeaf(1n, 0n, messageHash), new InboxLeaf(2n, 0n, messageHash)];
+        const msgs = [new InboxLeaf(0n, messageHash), new InboxLeaf(16n, messageHash)];
 
         await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: msgs });
 
         const index1 = (await store.getL1ToL2MessageIndex(messageHash, 0n))!;
+        expect(index1).toBe(0n);
         const index2 = await store.getL1ToL2MessageIndex(messageHash, index1 + 1n);
-
         expect(index2).toBeDefined();
         expect(index2).toBeGreaterThan(index1);
+        expect(index2).toBe(16n);
       });
     });
 
@@ -274,6 +288,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 +308,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 +368,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];
@@ -192,8 +194,8 @@ export async function retrieveL1ToL2Messages(
     }
 
     for (const log of messageSentLogs) {
-      const { l2BlockNumber, index, hash } = log.args;
-      retrievedL1ToL2Messages.push(new InboxLeaf(l2BlockNumber!, index!, Fr.fromString(hash!)));
+      const { index, hash } = log.args;
+      retrievedL1ToL2Messages.push(new InboxLeaf(index!, Fr.fromString(hash!)));
     }
 
     // handles the case when there are no new messages:
@@ -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),
+  ];
+}