@aztec/archiver 0.52.0 → 0.54.0

package/src/archiver/archiver_store_test_suite.ts

@@ -97,12 +97,12 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     });
 
     describe('getSynchPoint', () => {
-      it('returns 0n if no blocks have been added', async () => {
+      it('returns undefined if no blocks have been added', async () => {
         await expect(store.getSynchPoint()).resolves.toEqual({
-          blocksSynchedTo: 0n,
-          messagesSynchedTo: 0n,
-          blockBodiesSynchedTo: 0n,
-          provenLogsSynchedTo: 0n,
+          blocksSynchedTo: undefined,
+          messagesSynchedTo: undefined,
+          blockBodiesSynchedTo: undefined,
+          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
@@ -110,19 +110,19 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await store.addBlocks(blocks);
         await expect(store.getSynchPoint()).resolves.toEqual({
           blocksSynchedTo: 19n,
-          messagesSynchedTo: 0n,
-          blockBodiesSynchedTo: 0n,
-          provenLogsSynchedTo: 0n,
+          messagesSynchedTo: undefined,
+          blockBodiesSynchedTo: undefined,
+          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
       it('returns the L1 block number in which the most recent L2 block body was published', async () => {
         await store.addBlockBodies(blockBodies);
         await expect(store.getSynchPoint()).resolves.toEqual({
-          blocksSynchedTo: 0n,
-          messagesSynchedTo: 0n,
+          blocksSynchedTo: undefined,
+          messagesSynchedTo: undefined,
           blockBodiesSynchedTo: blockBodies.lastProcessedL1BlockNumber,
-          provenLogsSynchedTo: 0n,
+          provenLogsSynchedTo: undefined,
         } satisfies ArchiverL1SynchPoint);
       });
 
@@ -132,19 +132,19 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           retrievedData: [new InboxLeaf(0n, 0n, Fr.ZERO)],
         });
         await expect(store.getSynchPoint()).resolves.toEqual({
-          blocksSynchedTo: 0n,
+          blocksSynchedTo: undefined,
           messagesSynchedTo: 1n,
-          blockBodiesSynchedTo: 0n,
-          provenLogsSynchedTo: 0n,
+          blockBodiesSynchedTo: undefined,
+          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: 0n,
-          messagesSynchedTo: 0n,
-          blockBodiesSynchedTo: 0n,
+          blocksSynchedTo: undefined,
+          messagesSynchedTo: undefined,
+          blockBodiesSynchedTo: undefined,
           provenLogsSynchedTo: 3n,
         } satisfies ArchiverL1SynchPoint);
       });

package/src/archiver/config.ts

@@ -22,6 +22,11 @@ export type ArchiverConfig = {
    */
   archiverPollingIntervalMS?: number;
 
+  /**
+   * The L1 block to start reading from
+   */
+  archiverL1StartBlock: number;
+
   /**
    * The polling interval viem uses in ms
    */
@@ -52,6 +57,11 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',
     ...numberConfigHelper(1000),
   },
+  archiverL1StartBlock: {
+    env: 'ARCHIVER_L1_START_BLOCK',
+    description: 'The L1 block the archiver should start reading logs from',
+    ...numberConfigHelper(0),
+  },
   viemPollingIntervalMS: {
     env: 'ARCHIVER_VIEM_POLLING_INTERVAL_MS',
     description: 'The polling interval viem uses in ms',

package/src/archiver/data_retrieval.ts

@@ -1,12 +1,13 @@
 import { type Body, type InboxLeaf } from '@aztec/circuit-types';
-import { type AppendOnlyTreeSnapshot, Fr, type Header } from '@aztec/circuits.js';
+import { type AppendOnlyTreeSnapshot, Fr, type Header, type Proof } from '@aztec/circuits.js';
 import { type EthAddress } from '@aztec/foundation/eth-address';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
 
-import { type PublicClient, getAbiItem } from 'viem';
+import { type Hex, type PublicClient, getAbiItem } from 'viem';
 
 import {
+  getBlockProofFromSubmitProofTx,
   getL2BlockProposedLogs,
   getMessageSentLogs,
   getTxsPublishedLogs,
@@ -147,7 +148,7 @@ export async function retrieveL2ProofVerifiedEvents(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<{ l1BlockNumber: bigint; l2BlockNumber: bigint; proverId: Fr }[]> {
+): Promise<{ l1BlockNumber: bigint; l2BlockNumber: bigint; proverId: Fr; txHash: Hex }[]> {
   const logs = await publicClient.getLogs({
     address: rollupAddress.toString(),
     fromBlock: searchStartBlock,
@@ -160,5 +161,27 @@ export async function retrieveL2ProofVerifiedEvents(
     l1BlockNumber: log.blockNumber,
     l2BlockNumber: log.args.blockNumber,
     proverId: Fr.fromString(log.args.proverId),
+    txHash: log.transactionHash,
   }));
 }
+
+/** Retrieve submitted proofs from the rollup contract */
+export async function retrieveL2ProofsFromRollup(
+  publicClient: PublicClient,
+  rollupAddress: EthAddress,
+  searchStartBlock: bigint,
+  searchEndBlock?: bigint,
+): Promise<DataRetrieval<{ proof: Proof; proverId: Fr; l2BlockNumber: bigint; txHash: `0x${string}` }>> {
+  const logs = await retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock);
+  const retrievedData: { proof: Proof; proverId: Fr; l2BlockNumber: bigint; txHash: `0x${string}` }[] = [];
+  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);
+    retrievedData.push({ proof: proofData.proof, proverId: proofData.proverId, l2BlockNumber, txHash });
+  }
+  return {
+    retrievedData,
+    lastProcessedL1BlockNumber,
+  };
+}

package/src/archiver/eth_log_handlers.ts

@@ -1,5 +1,5 @@
 import { Body, InboxLeaf } from '@aztec/circuit-types';
-import { AppendOnlyTreeSnapshot, Header } from '@aztec/circuits.js';
+import { AppendOnlyTreeSnapshot, Header, Proof } from '@aztec/circuits.js';
 import { type EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
@@ -257,3 +257,57 @@ export function getMessageSentLogs(
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
   });
 }
+
+export type SubmitBlockProof = {
+  header: Header;
+  archiveRoot: Fr;
+  proverId: Fr;
+  aggregationObject: Buffer;
+  proof: Proof;
+};
+
+/**
+ * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
+ * Assumes that the block was published from an EOA.
+ * TODO: Add retries and error management.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param txHash - Hash of the tx that published it.
+ * @param l2BlockNum - L2 block number.
+ * @returns L2 block metadata (header and archive) from the calldata, deserialized
+ */
+export async function getBlockProofFromSubmitProofTx(
+  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 [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))),
+  };
+}

package/src/archiver/kv_archiver_store/block_body_store.ts

@@ -68,7 +68,7 @@ export class BlockBodyStore {
    * Gets the last L1 block number in which a L2 block body was included
    * @returns The L1 block number
    */
-  getSynchedL1BlockNumber(): bigint {
-    return this.#lastSynchedL1Block.get() ?? 0n;
+  getSynchedL1BlockNumber(): bigint | undefined {
+    return this.#lastSynchedL1Block.get();
   }
 }

package/src/archiver/kv_archiver_store/block_store.ts

@@ -180,8 +180,8 @@ export class BlockStore {
    * Gets the most recent L1 block processed.
    * @returns The L1 block that published the latest L2 block
    */
-  getSynchedL1BlockNumber(): bigint {
-    return this.#lastSynchedL1Block.get() ?? 0n;
+  getSynchedL1BlockNumber(): bigint | undefined {
+    return this.#lastSynchedL1Block.get();
   }
 
   #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {

package/src/archiver/kv_archiver_store/message_store.ts

@@ -32,8 +32,8 @@ export class MessageStore {
    * Gets the last L1 block number that emitted new messages.
    * @returns The last L1 block number processed
    */
-  getSynchedL1BlockNumber(): bigint {
-    return this.#lastL1BlockMessages.get() ?? 0n;
+  getSynchedL1BlockNumber(): bigint | undefined {
+    return this.#lastL1BlockMessages.get();
   }
 
   /**

package/src/archiver/kv_archiver_store/proven_store.ts

@@ -17,8 +17,8 @@ export class ProvenStore {
   /**
    * Gets the most recent L1 block processed.
    */
-  getSynchedL1BlockNumber(): bigint {
-    return this.#lastSynchedL1Block.get() ?? 0n;
+  getSynchedL1BlockNumber(): bigint | undefined {
+    return this.#lastSynchedL1Block.get();
   }
 
   getProvenL2BlockNumber(): number {

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -83,10 +83,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
 
-  private lastL1BlockNewBlocks: bigint = 0n;
-  private lastL1BlockNewBlockBodies: bigint = 0n;
-  private lastL1BlockNewMessages: bigint = 0n;
-  private lastL1BlockNewProvenLogs: bigint = 0n;
+  private lastL1BlockNewBlocks: bigint | undefined = undefined;
+  private lastL1BlockNewBlockBodies: bigint | undefined = undefined;
+  private lastL1BlockNewMessages: bigint | undefined = undefined;
+  private lastL1BlockNewProvenLogs: bigint | undefined = undefined;
 
   private lastProvenL2BlockNumber: number = 0;
 
@@ -225,7 +225,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns True if the operation is successful.
    */
   public addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
-    if (messages.lastProcessedL1BlockNumber <= this.lastL1BlockNewMessages) {
+    if (
+      typeof this.lastL1BlockNewMessages === 'bigint' &&
+      messages.lastProcessedL1BlockNumber <= this.lastL1BlockNewMessages
+    ) {
       return Promise.resolve(false);
     }
 

package/src/factory.ts

@@ -1,4 +1,5 @@
-import { type AztecKVStore } from '@aztec/kv-store';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/utils';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
@@ -7,14 +8,13 @@ import { type ArchiverConfig } from './archiver/config.js';
 import { KVArchiverDataStore } from './archiver/index.js';
 import { createArchiverClient } from './rpc/archiver_client.js';
 
-export function createArchiver(
+export async function createArchiver(
   config: ArchiverConfig,
-  store: AztecKVStore,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
 ) {
   if (!config.archiverUrl) {
-    // first create and sync the archiver
+    const store = await createStore('archiver', config, createDebugLogger('aztec:archiver:lmdb'));
     const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
     return Archiver.createAndSync(config, archiverStore, telemetry, opts.blockUntilSync);
   } else {

package/src/index.ts

@@ -13,8 +13,9 @@ export * from './archiver/index.js';
 export * from './rpc/index.js';
 export * from './factory.js';
 
-// We are not storing the info from these events in the archiver for now (and we don't really need to), so we expose this query directly
-export { retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
+export { retrieveL2ProofVerifiedEvents, retrieveBlockMetadataFromRollup } from './archiver/data_retrieval.js';
+
+export { getL2BlockProposedLogs } from './archiver/eth_log_handlers.js';
 
 const log = createDebugLogger('aztec:archiver');