@aztec/archiver 4.0.0-nightly.20260112 → 4.0.0-nightly.20260114

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -6,7 +6,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
@@ -23,7 +23,6 @@ import type { UInt64 } from '@aztec/stdlib/types';
 
 import { join } from 'path';
 
-import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import type { InboxMessage } from '../structs/inbox_message.js';
 import { BlockStore, type CheckpointData } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
@@ -36,9 +35,20 @@ export const MAX_FUNCTION_SIGNATURES = 1000;
 export const MAX_FUNCTION_NAME_LEN = 256;
 
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * Represents the latest L1 block processed by the archiver for various objects in L2.
  */
-export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSource {
+export type ArchiverL1SynchPoint = {
+  /** Number of the last L1 block that added a new L2 checkpoint metadata.  */
+  blocksSynchedTo?: bigint;
+  /** Last L1 block checked for L1 to L2 messages. */
+  messagesSynchedTo?: L1BlockId;
+};
+
+/**
+ * LMDB-based data store for the archiver.
+ * Stores all archiver data including blocks, logs, contract classes/instances, and L1 to L2 messages.
+ */
+export class KVArchiverDataStore implements ContractDataSource {
   public static readonly SCHEMA_VERSION = ARCHIVER_DB_VERSION;
 
   #blockStore: BlockStore;
@@ -62,6 +72,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     this.#contractInstanceStore = new ContractInstanceStore(db);
   }
 
+  /** Opens a new transaction to the underlying store and runs all operations within it. */
   public transactionAsync<T>(callback: () => Promise<T>): Promise<T> {
     return this.db.transactionAsync(callback);
   }
@@ -79,19 +90,23 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.getContractInstance(address, timestamp);
   }
 
+  /** Backups the archiver db to the target folder. Returns the path to the db file. */
   public async backupTo(path: string, compress = true): Promise<string> {
     await this.db.backupTo(path, compress);
     return join(path, 'data.mdb');
   }
 
+  /** Closes the underlying data store. */
   public close() {
     return this.db.close();
   }
 
+  /** Looks up a public function name given a selector. */
   getDebugFunctionName(_address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
     return Promise.resolve(this.functionNames.get(selector.toString()));
   }
 
+  /** Register a public function signature, so it can be looked up by selector. */
   async registerContractFunctionSignatures(signatures: string[]): Promise<void> {
     for (const sig of signatures) {
       if (this.functionNames.size > MAX_FUNCTION_SIGNATURES) {
@@ -106,14 +121,25 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     }
   }
 
+  /**
+   * Returns a contract class given its id, or undefined if not exists.
+   * @param id - Id of the contract class.
+   */
   getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
     return this.#contractClassStore.getContractClass(id);
   }
 
+  /** Returns the list of all class ids known by the archiver. */
   getContractClassIds(): Promise<Fr[]> {
     return this.#contractClassStore.getContractClassIds();
   }
 
+  /**
+   * Returns a contract instance given its address and the given timestamp, or undefined if not exists.
+   * @param address - Address of the contract.
+   * @param timestamp - Timestamp to get the contract instance at. Contract updates might change the instance.
+   * @returns The contract instance or undefined if not found.
+   */
   getContractInstance(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined> {
     return this.#contractInstanceStore.getContractInstance(address, timestamp);
   }
@@ -122,6 +148,13 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#contractInstanceStore.getContractInstanceDeploymentBlockNumber(address);
   }
 
+  /**
+   * Add new contract classes from an L2 block to the store's list.
+   * @param data - List of contract classes to be added.
+   * @param bytecodeCommitments - Bytecode commitments for the contract classes.
+   * @param blockNumber - Number of the L2 block the contracts were registered in.
+   * @returns True if the operation is successful.
+   */
   async addContractClasses(
     data: ContractClassPublic[],
     bytecodeCommitments: Fr[],
@@ -144,6 +177,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#contractClassStore.getBytecodeCommitment(contractClassId);
   }
 
+  /** Adds private functions to a contract class. */
   addFunctions(
     contractClassId: Fr,
     privateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
@@ -152,6 +186,12 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
   }
 
+  /**
+   * Add new contract instances from an L2 block to the store's list.
+   * @param data - List of contract instances to be added.
+   * @param blockNumber - Number of the L2 block the instances were deployed in.
+   * @returns True if the operation is successful.
+   */
   async addContractInstances(data: ContractInstanceWithAddress[], blockNumber: BlockNumber): Promise<boolean> {
     return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c, blockNumber)))).every(
       Boolean,
@@ -162,6 +202,12 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return (await Promise.all(data.map(c => this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
   }
 
+  /**
+   * Add new contract instance updates
+   * @param data - List of contract updates to be added.
+   * @param timestamp - Timestamp at which the updates were scheduled.
+   * @returns True if the operation is successful.
+   */
   async addContractInstanceUpdates(data: ContractInstanceUpdateWithAddress[], timestamp: UInt64): Promise<boolean> {
     return (
       await Promise.all(
@@ -190,9 +236,19 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#blockStore.addBlocks(blocks, opts);
   }
 
+  /**
+   * Returns an array of checkpoint objects
+   * @param from The first checkpoint number to be retrieved
+   * @param limit The maximum number of checkpoints to retrieve
+   * @returns The array of requested checkpoint data objects
+   */
   getRangeOfCheckpoints(from: CheckpointNumber, limit: number): Promise<CheckpointData[]> {
     return this.#blockStore.getRangeOfCheckpoints(from, limit);
   }
+  /**
+   * Returns the number of the latest block
+   * @returns The number of the latest block
+   */
   getLatestBlockNumber(): Promise<BlockNumber> {
     return this.#blockStore.getLatestBlockNumber();
   }
@@ -208,47 +264,100 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#blockStore.unwindCheckpoints(from, checkpointsToUnwind);
   }
 
+  /**
+   * Appends new checkpoints, and their blocks to the store's collection
+   * @param checkpoints The collection of checkpoints to be added
+   * @returns True if the operation is successful
+   */
   addCheckpoints(checkpoints: PublishedCheckpoint[]): Promise<boolean> {
     return this.#blockStore.addCheckpoints(checkpoints);
   }
 
+  /**
+   * Returns the block for the given number, or undefined if not exists.
+   * @param number - The block number to return.
+   */
   getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
     return this.#blockStore.getCheckpointedBlock(number);
   }
+  /**
+   * Returns the block for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */
   getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.#blockStore.getCheckpointedBlockByHash(blockHash);
   }
+  /**
+   * Returns the block for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */
   getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.#blockStore.getCheckpointedBlockByArchive(archive);
   }
+  /**
+   * Returns the block for the given number, or undefined if not exists.
+   * @param number - The block number to return.
+   */
   getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlock(number);
   }
+  /**
+   * Returns the block for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */
   getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
   }
+  /**
+   * Returns the block for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */
   getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByArchive(archive);
   }
-  getBlocks(from: BlockNumber, limit: BlockNumber): Promise<L2BlockNew[]> {
+
+  /**
+   * 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: BlockNumber, limit: number): Promise<L2BlockNew[]> {
     return toArray(this.#blockStore.getBlocks(from, limit));
   }
 
   /**
-   * Gets up to `limit` amount of L2 blocks headers starting from `from`.
-   *
+   * Gets up to `limit` amount of checkpointed 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 checkpointed L2 blocks.
+   */
+  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
+    return toArray(this.#blockStore.getCheckpointedBlocks(from, limit));
+  }
+
+  /**
+   * Gets up to `limit` amount of L2 block headers starting from `from`.
    * @param start - Number of the first block to return (inclusive).
    * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
+   * @returns The requested L2 block headers.
    */
   getBlockHeaders(start: BlockNumber, limit: number): Promise<BlockHeader[]> {
     return toArray(this.#blockStore.getBlockHeaders(start, limit));
   }
 
+  /**
+   * Returns the block header for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */
   getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
     return this.#blockStore.getBlockHeaderByHash(L2BlockHash.fromField(blockHash));
   }
 
+  /**
+   * Returns the block header for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */
   getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
     return this.#blockStore.getBlockHeaderByArchive(archive);
   }
@@ -284,10 +393,15 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#logStore.deleteLogs(blocks);
   }
 
+  /**
+   * Get the total number of L1 to L2 messages
+   * @returns The number of L1 to L2 messages in the store
+   */
   getTotalL1ToL2MessageCount(): Promise<bigint> {
     return this.#messageStore.getTotalL1ToL2MessageCount();
   }
 
+  /** Returns the last L1 to L2 message stored. */
   getLastL1ToL2Message(): Promise<InboxMessage | undefined> {
     return this.#messageStore.getLastMessage();
   }
@@ -295,6 +409,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   /**
    * Append L1 to L2 messages to the store.
    * @param messages - The L1 to L2 messages to be added to the store.
+   * @returns True if the operation is successful.
    */
   addL1ToL2Messages(messages: InboxMessage[]): Promise<void> {
     return this.#messageStore.addL1ToL2Messages(messages);
@@ -318,6 +433,10 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#messageStore.getL1ToL2Messages(checkpointNumber);
   }
 
+  /**
+   * Gets all private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
+   * array implies no logs match that tag.
+   */
   getPrivateLogsByTags(tags: SiloedTag[]): Promise<TxScopedL2Log[][]> {
     try {
       return this.#logStore.getPrivateLogsByTags(tags);
@@ -326,6 +445,10 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     }
   }
 
+  /**
+   * Gets all public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
+   * logs is returned. An empty array implies no logs match that tag.
+   */
   getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[]): Promise<TxScopedL2Log[][]> {
     try {
       return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, tags);
@@ -360,10 +483,18 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     }
   }
 
+  /**
+   * Gets the number of the latest proven checkpoint processed.
+   * @returns The number of the latest proven checkpoint processed.
+   */
   getProvenCheckpointNumber(): Promise<CheckpointNumber> {
     return this.#blockStore.getProvenCheckpointNumber();
   }
 
+  /**
+   * Stores the number of the latest proven checkpoint processed.
+   * @param checkpointNumber - The number of the latest proven checkpoint processed.
+   */
   async setProvenCheckpointNumber(checkpointNumber: CheckpointNumber) {
     await this.#blockStore.setProvenCheckpointNumber(checkpointNumber);
   }
@@ -372,16 +503,23 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
+  /**
+   * Stores the l1 block that messages have been synched until
+   */
   async setMessageSynchedL1Block(l1Block: L1BlockId) {
     await this.#messageStore.setSynchedL1Block(l1Block);
   }
 
+  /**
+   * Returns the number of the most recent proven block
+   * @returns The number of the most recent proven block
+   */
   getProvenBlockNumber(): Promise<BlockNumber> {
     return this.#blockStore.getProvenBlockNumber();
   }
 
   /**
-   * Gets the last L1 block number processed by the archiver
+   * Gets the synch point of the archiver
    */
   async getSynchPoint(): Promise<ArchiverL1SynchPoint> {
     const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
@@ -394,44 +532,72 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     };
   }
 
+  /** Estimates the size of the store in bytes. */
   public estimateSize(): Promise<StoreSize> {
     return this.db.estimateSize();
   }
 
+  /** Deletes all L1 to L2 messages up until (excluding) the target checkpoint number. */
   public rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber: CheckpointNumber): Promise<void> {
     return this.#messageStore.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
   }
 
+  /** Returns an async iterator to all L1 to L2 messages on the range. */
   public iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {
     return this.#messageStore.iterateL1ToL2Messages(range);
   }
 
+  /** Removes all L1 to L2 messages starting from the given index (inclusive). */
   public removeL1ToL2Messages(startIndex: bigint): Promise<void> {
     return this.#messageStore.removeL1ToL2Messages(startIndex);
   }
 
-  public getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
+  /** Returns the last synced validation status of the pending chain. */
+  public getPendingChainValidationStatus(): Promise<ValidateCheckpointResult | undefined> {
     return this.#blockStore.getPendingChainValidationStatus();
   }
 
-  public setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
+  /** Sets the last synced validation status of the pending chain. */
+  public setPendingChainValidationStatus(status: ValidateCheckpointResult | undefined): Promise<void> {
     return this.#blockStore.setPendingChainValidationStatus(status);
   }
 
+  /**
+   * Gets the number of the latest L2 block processed.
+   * @returns The number of the latest L2 block processed.
+   */
   public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
     return this.#blockStore.getCheckpointedL2BlockNumber();
   }
+  /**
+   * Gets the number of the latest published checkpoint processed.
+   * @returns The number of the latest published checkpoint processed
+   */
   public getSynchedCheckpointNumber(): Promise<CheckpointNumber> {
     return this.#blockStore.getLatestCheckpointNumber();
   }
+  /**
+   * Stores the l1 block number that checkpoints have been synched until
+   * @param l1BlockNumber  - The l1 block number
+   */
   async setCheckpointSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
     await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
   }
 
+  /**
+   * Retrieves all blocks for the requested checkpoint
+   * @param checkpointNumber Retrieves all blocks for the given checkpoint
+   * @returns The collection of blocks for the requested checkpoint if available (undefined otherwise)
+   */
   getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
     return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
   }
 
+  /**
+   * Returns checkpoint data for the requested checkpoint number
+   * @param checkpointNumber - The checkpoint requested
+   * @returns The checkpoint data or undefined if not found
+   */
   getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined> {
     return this.#blockStore.getCheckpointData(checkpointNumber);
   }

package/src/archiver/l1/calldata_retriever.ts

@@ -72,7 +72,7 @@ export class CalldataRetriever {
    */
   async getCheckpointFromRollupTx(
     txHash: `0x${string}`,
-    blobHashes: Buffer[],
+    _blobHashes: Buffer[],
     checkpointNumber: CheckpointNumber,
     expectedHashes: {
       attestationsHash?: Hex;
@@ -459,7 +459,7 @@ export class CalldataRetriever {
       // Use ConsensusPayload to compute the digest - this ensures we match the exact logic
       // used by the network for signing and verification
       const consensusPayload = new ConsensusPayload(header, archiveRoot);
-      const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
+      const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
       const computedPayloadDigest = keccak256(payloadToSign);
 
       // Compare as buffers to avoid case-sensitivity and string comparison issues