@aztec/archiver 0.51.0 → 0.52.0

package/src/archiver/kv_archiver_store/block_store.ts

@@ -3,7 +3,7 @@ import { AppendOnlyTreeSnapshot, type AztecAddress, Header, INITIAL_L2_BLOCK_NUM
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecMap, type AztecSingleton, type Range } from '@aztec/kv-store';
 
-import { type DataRetrieval } from '../data_retrieval.js';
+import { type L1Published, type L1PublishedData } from '../structs/published.js';
 import { type BlockBodyStore } from './block_body_store.js';
 
 type BlockIndexValue = [blockNumber: number, index: number];
@@ -11,6 +11,7 @@ type BlockIndexValue = [blockNumber: number, index: number];
 type BlockStorage = {
   header: Buffer;
   archive: Buffer;
+  l1: L1PublishedData;
 };
 
 /**
@@ -22,9 +23,6 @@ export class BlockStore {
   /** Stores L1 block number in which the last processed L2 block was included */
   #lastSynchedL1Block: AztecSingleton<bigint>;
 
-  /** Stores last proven L2 block number */
-  #lastProvenL2Block: AztecSingleton<number>;
-
   /** Index mapping transaction hash (as a string) to its location in a block */
   #txIndex: AztecMap<string, BlockIndexValue>;
 
@@ -42,28 +40,32 @@ 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');
   }
 
   /**
    * 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 blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: DataRetrieval<L2Block>): Promise<boolean> {
+  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+    if (blocks.length === 0) {
+      return Promise.resolve(true);
+    }
+
     return this.db.transaction(() => {
-      for (const block of blocks.retrievedData) {
-        void this.#blocks.set(block.number, {
-          header: block.header.toBuffer(),
-          archive: block.archive.toBuffer(),
+      for (const block of blocks) {
+        void this.#blocks.set(block.data.number, {
+          header: block.data.header.toBuffer(),
+          archive: block.data.archive.toBuffer(),
+          l1: block.l1,
         });
 
-        block.body.txEffects.forEach((tx, i) => {
-          void this.#txIndex.set(tx.txHash.toString(), [block.number, i]);
+        block.data.body.txEffects.forEach((tx, i) => {
+          void this.#txIndex.set(tx.txHash.toString(), [block.data.number, i]);
         });
       }
 
-      void this.#lastSynchedL1Block.set(blocks.lastProcessedL1BlockNumber);
+      void this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
 
       return true;
     });
@@ -75,7 +77,7 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  *getBlocks(start: number, limit: number): IterableIterator<L2Block> {
+  *getBlocks(start: number, limit: number): IterableIterator<L1Published<L2Block>> {
     for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
       yield this.getBlockFromBlockStorage(blockStorage);
     }
@@ -86,7 +88,7 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  getBlock(blockNumber: number): L2Block | undefined {
+  getBlock(blockNumber: number): L1Published<L2Block> | undefined {
     const blockStorage = this.#blocks.get(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return undefined;
@@ -104,11 +106,8 @@ export class BlockStore {
       throw new Error('Body is not able to be retrieved from BodyStore');
     }
 
-    return L2Block.fromFields({
-      header,
-      archive,
-      body,
-    });
+    const l2Block = L2Block.fromFields({ header, archive, body });
+    return { data: l2Block, l1: blockStorage.l1 };
   }
 
   /**
@@ -123,7 +122,7 @@ export class BlockStore {
     }
 
     const block = this.getBlock(blockNumber);
-    return block?.body.txEffects[txIndex];
+    return block?.data.body.txEffects[txIndex];
   }
 
   /**
@@ -138,15 +137,15 @@ export class BlockStore {
     }
 
     const block = this.getBlock(blockNumber)!;
-    const tx = block.body.txEffects[txIndex];
+    const tx = block.data.body.txEffects[txIndex];
 
     return new TxReceipt(
       txHash,
       TxReceipt.statusFromRevertCode(tx.revertCode),
       '',
       tx.transactionFee.toBigInt(),
-      block.hash().toBuffer(),
-      block.number,
+      block.data.hash().toBuffer(),
+      block.data.number,
     );
   }
 
@@ -185,14 +184,6 @@ export class BlockStore {
     return this.#lastSynchedL1Block.get() ?? 0n;
   }
 
-  getProvenL2BlockNumber(): number {
-    return this.#lastProvenL2Block.get() ?? 0;
-  }
-
-  async setProvenL2BlockNumber(blockNumber: number) {
-    await this.#lastProvenL2Block.set(blockNumber);
-  }
-
   #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {
     if (limit < 1) {
       throw new Error(`Invalid limit: ${limit}`);

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -27,7 +27,8 @@ import {
 } from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
-import { type DataRetrieval } from '../data_retrieval.js';
+import { type DataRetrieval, type SingletonDataRetrieval } from '../structs/data_retrieval.js';
+import { type L1Published } from '../structs/published.js';
 import { BlockBodyStore } from './block_body_store.js';
 import { BlockStore } from './block_store.js';
 import { ContractArtifactsStore } from './contract_artifacts_store.js';
@@ -35,13 +36,15 @@ import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
+import { ProvenStore } from './proven_store.js';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class KVArchiverDataStore implements ArchiverDataStore {
-  #blockStore: BlockStore;
   #blockBodyStore: BlockBodyStore;
+  #blockStore: BlockStore;
+  #provenStore: ProvenStore;
   #logStore: LogStore;
   #messageStore: MessageStore;
   #contractClassStore: ContractClassStore;
@@ -53,6 +56,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   constructor(db: AztecKVStore, logsMaxPageSize: number = 1000) {
     this.#blockBodyStore = new BlockBodyStore(db);
     this.#blockStore = new BlockStore(db, this.#blockBodyStore);
+    this.#provenStore = new ProvenStore(db);
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#messageStore = new MessageStore(db);
     this.#contractClassStore = new ContractClassStore(db);
@@ -120,7 +124,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: DataRetrieval<L2Block>): Promise<boolean> {
+  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
     return this.#blockStore.addBlocks(blocks);
   }
 
@@ -131,7 +135,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlocks(start: number, limit: number): Promise<L2Block[]> {
+  getBlocks(start: number, limit: number): Promise<L1Published<L2Block>[]> {
     try {
       return Promise.resolve(Array.from(this.#blockStore.getBlocks(start, limit)));
     } catch (err) {
@@ -247,11 +251,11 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   getProvenL2BlockNumber(): Promise<number> {
-    return Promise.resolve(this.#blockStore.getProvenL2BlockNumber());
+    return Promise.resolve(this.#provenStore.getProvenL2BlockNumber());
   }
 
-  async setProvenL2BlockNumber(blockNumber: number) {
-    await this.#blockStore.setProvenL2BlockNumber(blockNumber);
+  async setProvenL2BlockNumber(blockNumber: SingletonDataRetrieval<number>) {
+    await this.#provenStore.setProvenL2BlockNumber(blockNumber);
   }
 
   /**
@@ -262,6 +266,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
       blocksSynchedTo: this.#blockStore.getSynchedL1BlockNumber(),
       blockBodiesSynchedTo: this.#blockBodyStore.getSynchedL1BlockNumber(),
       messagesSynchedTo: this.#messageStore.getSynchedL1BlockNumber(),
+      provenLogsSynchedTo: this.#provenStore.getSynchedL1BlockNumber(),
     });
   }
 }

package/src/archiver/kv_archiver_store/message_store.ts

@@ -8,7 +8,7 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecMap, type AztecSingleton } from '@aztec/kv-store';
 
-import { type DataRetrieval } from '../data_retrieval.js';
+import { type DataRetrieval } from '../structs/data_retrieval.js';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.

package/src/archiver/kv_archiver_store/proven_store.ts

@@ -0,0 +1,34 @@
+import { type AztecKVStore, type AztecSingleton } from '@aztec/kv-store';
+
+import { type SingletonDataRetrieval } from '../structs/data_retrieval.js';
+
+export class ProvenStore {
+  /** Stores L1 block number in which the last processed L2 block was included */
+  #lastSynchedL1Block: AztecSingleton<bigint>;
+
+  /** Stores last proven L2 block number */
+  #lastProvenL2Block: AztecSingleton<number>;
+
+  constructor(private db: AztecKVStore) {
+    this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_proven_logs');
+    this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
+  }
+
+  /**
+   * Gets the most recent L1 block processed.
+   */
+  getSynchedL1BlockNumber(): bigint {
+    return this.#lastSynchedL1Block.get() ?? 0n;
+  }
+
+  getProvenL2BlockNumber(): number {
+    return this.#lastProvenL2Block.get() ?? 0;
+  }
+
+  async setProvenL2BlockNumber(blockNumber: SingletonDataRetrieval<number>) {
+    await this.db.transaction(() => {
+      void this.#lastProvenL2Block.set(blockNumber.retrievedData);
+      void this.#lastSynchedL1Block.set(blockNumber.lastProcessedL1BlockNumber);
+    });
+  }
+}

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -27,7 +27,8 @@ import {
 } from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
-import { type DataRetrieval } from '../data_retrieval.js';
+import { type DataRetrieval, type SingletonDataRetrieval } from '../structs/data_retrieval.js';
+import { type L1Published } from '../structs/published.js';
 import { L1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
 /**
@@ -37,7 +38,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   /**
    * An array containing all the L2 blocks that have been fetched so far.
    */
-  private l2Blocks: L2Block[] = [];
+  private l2Blocks: L1Published<L2Block>[] = [];
 
   /**
    * A mapping of body hash to body
@@ -85,6 +86,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   private lastL1BlockNewBlocks: bigint = 0n;
   private lastL1BlockNewBlockBodies: bigint = 0n;
   private lastL1BlockNewMessages: bigint = 0n;
+  private lastL1BlockNewProvenLogs: bigint = 0n;
+
   private lastProvenL2BlockNumber: number = 0;
 
   constructor(
@@ -152,10 +155,14 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  public addBlocks(blocks: DataRetrieval<L2Block>): Promise<boolean> {
-    this.lastL1BlockNewBlocks = blocks.lastProcessedL1BlockNumber;
-    this.l2Blocks.push(...blocks.retrievedData);
-    this.txEffects.push(...blocks.retrievedData.flatMap(b => b.body.txEffects));
+  public addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+    if (blocks.length === 0) {
+      return Promise.resolve(true);
+    }
+
+    this.lastL1BlockNewBlocks = blocks[blocks.length - 1].l1.blockNumber;
+    this.l2Blocks.push(...blocks);
+    this.txEffects.push(...blocks.flatMap(b => b.data.body.txEffects));
     return Promise.resolve(true);
   }
 
@@ -246,7 +253,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns The requested L2 blocks.
    * @remarks When "from" is smaller than genesis block number, blocks from the beginning are returned.
    */
-  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
+  public getBlocks(from: number, limit: number): Promise<L1Published<L2Block>[]> {
     // Return an empty array if we are outside of range
     if (limit < 1) {
       return Promise.reject(new Error(`Invalid limit: ${limit}`));
@@ -278,7 +285,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
     for (const block of this.l2Blocks) {
-      for (const txEffect of block.body.txEffects) {
+      for (const txEffect of block.data.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
           return Promise.resolve(
             new TxReceipt(
@@ -286,8 +293,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
               TxReceipt.statusFromRevertCode(txEffect.revertCode),
               '',
               txEffect.transactionFee.toBigInt(),
-              block.hash().toBuffer(),
-              block.number,
+              block.data.hash().toBuffer(),
+              block.data.number,
             ),
           );
         }
@@ -397,10 +404,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
         for (; logIndexInTx < txLogs.length; logIndexInTx++) {
           const log = txLogs[logIndexInTx];
           if (
-            (!txHash || block.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
+            (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
             (!contractAddress || log.contractAddress.equals(contractAddress))
           ) {
-            logs.push(new ExtendedUnencryptedL2Log(new LogId(block.number, txIndexInBlock, logIndexInTx), log));
+            logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
             if (logs.length === this.maxLogs) {
               return Promise.resolve({
                 logs,
@@ -428,15 +435,16 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     if (this.l2Blocks.length === 0) {
       return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
     }
-    return Promise.resolve(this.l2Blocks[this.l2Blocks.length - 1].number);
+    return Promise.resolve(this.l2Blocks[this.l2Blocks.length - 1].data.number);
   }
 
   public getProvenL2BlockNumber(): Promise<number> {
     return Promise.resolve(this.lastProvenL2BlockNumber);
   }
 
-  public setProvenL2BlockNumber(l2BlockNumber: number): Promise<void> {
-    this.lastProvenL2BlockNumber = l2BlockNumber;
+  public setProvenL2BlockNumber(l2BlockNumber: SingletonDataRetrieval<number>): Promise<void> {
+    this.lastProvenL2BlockNumber = l2BlockNumber.retrievedData;
+    this.lastL1BlockNewProvenLogs = l2BlockNumber.lastProcessedL1BlockNumber;
     return Promise.resolve();
   }
 
@@ -445,6 +453,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       blocksSynchedTo: this.lastL1BlockNewBlocks,
       messagesSynchedTo: this.lastL1BlockNewMessages,
       blockBodiesSynchedTo: this.lastL1BlockNewBlockBodies,
+      provenLogsSynchedTo: this.lastL1BlockNewProvenLogs,
     });
   }
 

package/src/archiver/structs/data_retrieval.ts

@@ -0,0 +1,27 @@
+/**
+ * Data retrieved from logs
+ */
+export type DataRetrieval<T> = {
+  /**
+   * Blocknumber of the last L1 block from which we obtained data.
+   */
+  lastProcessedL1BlockNumber: bigint;
+  /**
+   * The data returned.
+   */
+  retrievedData: T[];
+};
+
+/**
+ * Data retrieved from logs
+ */
+export type SingletonDataRetrieval<T> = {
+  /**
+   * Blocknumber of the last L1 block from which we obtained data.
+   */
+  lastProcessedL1BlockNumber: bigint;
+  /**
+   * The data returned.
+   */
+  retrievedData: T;
+};

package/src/archiver/structs/published.ts

@@ -0,0 +1,11 @@
+/** Extends a type with L1 published info (block number, hash, and timestamp) */
+export type L1Published<T> = {
+  data: T;
+  l1: L1PublishedData;
+};
+
+export type L1PublishedData = {
+  blockNumber: bigint;
+  timestamp: bigint;
+  blockHash: string;
+};

package/src/index.ts

@@ -6,6 +6,7 @@ import { createPublicClient, http } from 'viem';
 import { localhost } from 'viem/chains';
 
 import { Archiver, getArchiverConfigFromEnv } from './archiver/index.js';
+import { ArchiverInstrumentation } from './archiver/instrumentation.js';
 import { MemoryArchiverStore } from './archiver/memory_archiver_store/memory_archiver_store.js';
 
 export * from './archiver/index.js';
@@ -40,7 +41,7 @@ async function main() {
     l1Contracts.registryAddress,
     archiverStore,
     1000,
-    new NoopTelemetryClient(),
+    new ArchiverInstrumentation(new NoopTelemetryClient()),
   );
 
   const shutdown = async () => {