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

package/dest/test/mock_l2_block_source.js

@@ -1,11 +1,11 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { L2Block, L2BlockHash, PublishedL2Block } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2Block, L2BlockHash, PublishedL2Block } from '@aztec/stdlib/block';
 import { L1PublishedData } from '@aztec/stdlib/checkpoint';
 import { EmptyL1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
@@ -15,6 +15,7 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     l2Blocks = [];
     provenBlockNumber = 0;
     finalizedBlockNumber = 0;
+    checkpointedBlockNumber = 0;
     log = createLogger('archiver:mock_l2_block_source');
     async createBlocks(numBlocks) {
         for(let i = 0; i < numBlocks; i++){
@@ -41,6 +42,9 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         }
         this.finalizedBlockNumber = finalizedBlockNumber;
     }
+    setCheckpointedBlockNumber(checkpointedBlockNumber) {
+        this.checkpointedBlockNumber = checkpointedBlockNumber;
+    }
     /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -62,9 +66,30 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     getProvenBlockNumber() {
         return Promise.resolve(BlockNumber(this.provenBlockNumber));
     }
-    getCheckpointedBlock(_number) {
-        // In this mock, we don't track checkpointed blocks separately
-        return Promise.resolve(undefined);
+    getCheckpointedBlock(number) {
+        if (number > this.checkpointedBlockNumber) {
+            return Promise.resolve(undefined);
+        }
+        const block = this.l2Blocks[number - 1];
+        if (!block) {
+            return Promise.resolve(undefined);
+        }
+        const checkpointedBlock = new CheckpointedL2Block(CheckpointNumber(number), block.toL2Block(), new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`), []);
+        return Promise.resolve(checkpointedBlock);
+    }
+    async getCheckpointedBlocks(from, limit, _proven) {
+        const result = [];
+        for(let i = 0; i < limit; i++){
+            const blockNum = from + i;
+            if (blockNum > this.checkpointedBlockNumber) {
+                break;
+            }
+            const block = await this.getCheckpointedBlock(BlockNumber(blockNum));
+            if (block) {
+                result.push(block);
+            }
+        }
+        return result;
     }
     /**
    * Gets an l2 block.
@@ -105,6 +130,10 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
                 attestations: []
             }));
     }
+    async getL2BlocksNew(from, limit, proven) {
+        const blocks = await this.getBlocks(from, limit, proven);
+        return blocks.map((x)=>x.toL2Block());
+    }
     async getPublishedBlockByHash(blockHash) {
         for (const block of this.l2Blocks){
             const hash = await block.hash();
@@ -199,27 +228,44 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         return undefined;
     }
     async getL2Tips() {
-        const [latest, proven, finalized] = [
+        const [latest, proven, finalized, checkpointed] = [
             await this.getBlockNumber(),
             await this.getProvenBlockNumber(),
-            this.finalizedBlockNumber
+            this.finalizedBlockNumber,
+            this.checkpointedBlockNumber
         ];
         const latestBlock = this.l2Blocks[latest - 1];
         const provenBlock = this.l2Blocks[proven - 1];
         const finalizedBlock = this.l2Blocks[finalized - 1];
+        const checkpointedBlock = this.l2Blocks[checkpointed - 1];
+        const latestBlockId = {
+            number: BlockNumber(latest),
+            hash: (await latestBlock?.hash())?.toString()
+        };
+        const provenBlockId = {
+            number: BlockNumber(proven),
+            hash: (await provenBlock?.hash())?.toString()
+        };
+        const finalizedBlockId = {
+            number: BlockNumber(finalized),
+            hash: (await finalizedBlock?.hash())?.toString()
+        };
+        const checkpointedBlockId = {
+            number: BlockNumber(checkpointed),
+            hash: (await checkpointedBlock?.hash())?.toString()
+        };
+        const makeTipId = (blockId)=>({
+                block: blockId,
+                checkpoint: {
+                    number: CheckpointNumber(blockId.number),
+                    hash: blockId.hash
+                }
+            });
         return {
-            latest: {
-                number: BlockNumber(latest),
-                hash: (await latestBlock?.hash())?.toString()
-            },
-            proven: {
-                number: BlockNumber(proven),
-                hash: (await provenBlock?.hash())?.toString()
-            },
-            finalized: {
-                number: BlockNumber(finalized),
-                hash: (await finalizedBlock?.hash())?.toString()
-            }
+            proposed: latestBlockId,
+            checkpointed: makeTipId(checkpointedBlockId),
+            proven: makeTipId(provenBlockId),
+            finalized: makeTipId(finalizedBlockId)
         };
     }
     getL2EpochNumber() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/archiver",
-  "version": "4.0.0-nightly.20260112",
+  "version": "4.0.0-nightly.20260114",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -66,18 +66,18 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-client": "4.0.0-nightly.20260112",
-    "@aztec/blob-lib": "4.0.0-nightly.20260112",
-    "@aztec/constants": "4.0.0-nightly.20260112",
-    "@aztec/epoch-cache": "4.0.0-nightly.20260112",
-    "@aztec/ethereum": "4.0.0-nightly.20260112",
-    "@aztec/foundation": "4.0.0-nightly.20260112",
-    "@aztec/kv-store": "4.0.0-nightly.20260112",
-    "@aztec/l1-artifacts": "4.0.0-nightly.20260112",
-    "@aztec/noir-protocol-circuits-types": "4.0.0-nightly.20260112",
-    "@aztec/protocol-contracts": "4.0.0-nightly.20260112",
-    "@aztec/stdlib": "4.0.0-nightly.20260112",
-    "@aztec/telemetry-client": "4.0.0-nightly.20260112",
+    "@aztec/blob-client": "4.0.0-nightly.20260114",
+    "@aztec/blob-lib": "4.0.0-nightly.20260114",
+    "@aztec/constants": "4.0.0-nightly.20260114",
+    "@aztec/epoch-cache": "4.0.0-nightly.20260114",
+    "@aztec/ethereum": "4.0.0-nightly.20260114",
+    "@aztec/foundation": "4.0.0-nightly.20260114",
+    "@aztec/kv-store": "4.0.0-nightly.20260114",
+    "@aztec/l1-artifacts": "4.0.0-nightly.20260114",
+    "@aztec/noir-protocol-circuits-types": "4.0.0-nightly.20260114",
+    "@aztec/protocol-contracts": "4.0.0-nightly.20260114",
+    "@aztec/stdlib": "4.0.0-nightly.20260114",
+    "@aztec/telemetry-client": "4.0.0-nightly.20260114",
     "lodash.groupby": "^4.6.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.5.0",

package/src/archiver/archive_source_base.ts

@@ -0,0 +1,339 @@
+import { BlockNumber, CheckpointNumber, type EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { isDefined } from '@aztec/foundation/types';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type CheckpointedL2Block,
+  CommitteeAttestation,
+  L2Block,
+  type L2BlockNew,
+  type L2Tips,
+  PublishedL2Block,
+} from '@aztec/stdlib/block';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
+import type { L2LogsSource } from '@aztec/stdlib/interfaces/server';
+import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { BlockHeader, IndexedTxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import type { ArchiveSource } from './archiver.js';
+import type { KVArchiverDataStore } from './kv_archiver_store/kv_archiver_store.js';
+import type { ValidateCheckpointResult } from './validation.js';
+
+/**
+ * Abstract base class implementing ArchiveSource using a KVArchiverDataStore.
+ * Provides implementations for all store-delegating methods and declares abstract methods
+ * for L1-dependent functionality that subclasses must implement.
+ */
+export abstract class ArchiveSourceBase
+  implements ArchiveSource, L2LogsSource, ContractDataSource, L1ToL2MessageSource
+{
+  protected readonly store: KVArchiverDataStore;
+
+  constructor(store: KVArchiverDataStore) {
+    this.store = store;
+  }
+
+  // Abstract methods that require L1 dependencies
+
+  abstract getRollupAddress(): Promise<EthAddress>;
+
+  abstract getRegistryAddress(): Promise<EthAddress>;
+
+  abstract getL1Constants(): Promise<L1RollupConstants>;
+
+  abstract getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
+
+  abstract getL1Timestamp(): Promise<bigint | undefined>;
+
+  abstract getL2Tips(): Promise<L2Tips>;
+
+  abstract getL2SlotNumber(): Promise<SlotNumber | undefined>;
+
+  abstract getL2EpochNumber(): Promise<EpochNumber | undefined>;
+
+  abstract getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
+
+  abstract getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
+
+  abstract getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
+
+  abstract isEpochComplete(epochNumber: EpochNumber): Promise<boolean>;
+
+  abstract syncImmediate(): Promise<void>;
+
+  // Store-delegating methods
+
+  public getBlockNumber(): Promise<BlockNumber> {
+    return this.store.getLatestBlockNumber();
+  }
+
+  public getProvenBlockNumber(): Promise<BlockNumber> {
+    return this.store.getProvenBlockNumber();
+  }
+
+  public async getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined> {
+    const blockNumber = number === 'latest' ? await this.store.getLatestBlockNumber() : number;
+    if (blockNumber === 0) {
+      return undefined;
+    }
+    const headers = await this.store.getBlockHeaders(blockNumber, 1);
+    return headers.length === 0 ? undefined : headers[0];
+  }
+
+  public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
+    return this.store.getCheckpointedBlock(number);
+  }
+
+  public async getCheckpointedBlocks(
+    from: BlockNumber,
+    limit: number,
+    proven?: boolean,
+  ): Promise<CheckpointedL2Block[]> {
+    const blocks = await this.store.getCheckpointedBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.block.number <= provenBlockNumber);
+    }
+    return blocks;
+  }
+
+  public getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+    return this.store.getBlockHeaderByHash(blockHash);
+  }
+
+  public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    return this.store.getBlockHeaderByArchive(archive);
+  }
+
+  public async getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+    // If the number provided is -ve, then return the latest block.
+    if (number < 0) {
+      number = await this.store.getLatestBlockNumber();
+    }
+    if (number === 0) {
+      return undefined;
+    }
+    const publishedBlock = await this.store.getBlock(number);
+    return publishedBlock;
+  }
+
+  public getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined> {
+    return this.store.getTxEffect(txHash);
+  }
+
+  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    return this.store.getSettledTxReceipt(txHash);
+  }
+
+  public isPendingChainInvalid(): Promise<boolean> {
+    return this.getPendingChainValidationStatus().then(status => !status.valid);
+  }
+
+  public async getPendingChainValidationStatus(): Promise<ValidateCheckpointResult> {
+    return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
+  }
+
+  public async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
+  }
+
+  // L2LogsSource methods
+
+  public getPrivateLogsByTags(tags: SiloedTag[]): Promise<TxScopedL2Log[][]> {
+    return this.store.getPrivateLogsByTags(tags);
+  }
+
+  public getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[]): Promise<TxScopedL2Log[][]> {
+    return this.store.getPublicLogsByTagsFromContract(contractAddress, tags);
+  }
+
+  public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
+    return this.store.getPublicLogs(filter);
+  }
+
+  public getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
+    return this.store.getContractClassLogs(filter);
+  }
+
+  // ContractDataSource methods
+
+  public getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    return this.store.getContractClass(id);
+  }
+
+  public getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
+    return this.store.getBytecodeCommitment(id);
+  }
+
+  public async getContract(
+    address: AztecAddress,
+    maybeTimestamp?: UInt64,
+  ): Promise<ContractInstanceWithAddress | undefined> {
+    let timestamp;
+    if (maybeTimestamp === undefined) {
+      const latestBlockHeader = await this.getBlockHeader('latest');
+      // If we get undefined block header, it means that the archiver has not yet synced any block so we default to 0.
+      timestamp = latestBlockHeader ? latestBlockHeader.globalVariables.timestamp : 0n;
+    } else {
+      timestamp = maybeTimestamp;
+    }
+
+    return this.store.getContractInstance(address, timestamp);
+  }
+
+  public getContractClassIds(): Promise<Fr[]> {
+    return this.store.getContractClassIds();
+  }
+
+  public getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    return this.store.getDebugFunctionName(address, selector);
+  }
+
+  public registerContractFunctionSignatures(signatures: string[]): Promise<void> {
+    return this.store.registerContractFunctionSignatures(signatures);
+  }
+
+  // L1ToL2MessageSource methods
+
+  public getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
+    return this.store.getL1ToL2Messages(checkpointNumber);
+  }
+
+  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
+    return this.store.getL1ToL2MessageIndex(l1ToL2Message);
+  }
+
+  // Published checkpoint methods
+
+  public async getPublishedCheckpoints(
+    checkpointNumber: CheckpointNumber,
+    limit: number,
+  ): Promise<PublishedCheckpoint[]> {
+    const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
+    const blocks = (
+      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
+    ).filter(isDefined);
+
+    const fullCheckpoints: PublishedCheckpoint[] = [];
+    for (let i = 0; i < checkpoints.length; i++) {
+      const blocksForCheckpoint = blocks[i];
+      const checkpoint = checkpoints[i];
+      const fullCheckpoint = new Checkpoint(
+        checkpoint.archive,
+        checkpoint.header,
+        blocksForCheckpoint,
+        checkpoint.checkpointNumber,
+      );
+      const publishedCheckpoint = new PublishedCheckpoint(
+        fullCheckpoint,
+        checkpoint.l1,
+        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
+      );
+      fullCheckpoints.push(publishedCheckpoint);
+    }
+    return fullCheckpoints;
+  }
+
+  public async getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]> {
+    const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
+    const provenCheckpointNumber = await this.store.getProvenCheckpointNumber();
+    const blocks = (
+      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
+    ).filter(isDefined);
+
+    const olbBlocks: PublishedL2Block[] = [];
+    for (let i = 0; i < checkpoints.length; i++) {
+      const blockForCheckpoint = blocks[i][0];
+      const checkpoint = checkpoints[i];
+      if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
+        // this checkpointisn't proven and we only want proven
+        continue;
+      }
+      const oldCheckpoint = new Checkpoint(
+        blockForCheckpoint.archive,
+        checkpoint.header,
+        [blockForCheckpoint],
+        checkpoint.checkpointNumber,
+      );
+      const oldBlock = L2Block.fromCheckpoint(oldCheckpoint);
+      const publishedBlock = new PublishedL2Block(
+        oldBlock,
+        checkpoint.l1,
+        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
+      );
+      olbBlocks.push(publishedBlock);
+    }
+    return olbBlocks;
+  }
+
+  // Legacy APIs
+
+  public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+    // If the number provided is -ve, then return the latest block.
+    if (number < 0) {
+      number = await this.store.getLatestBlockNumber();
+    }
+    if (number === 0) {
+      return undefined;
+    }
+    const publishedBlocks = await this.getPublishedBlocks(number, 1);
+    if (publishedBlocks.length === 0) {
+      return undefined;
+    }
+    return publishedBlocks[0].block;
+  }
+
+  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]> {
+    const publishedBlocks = await this.getPublishedBlocks(from, limit, proven);
+    return publishedBlocks.map(x => x.block);
+  }
+
+  public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
+    return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
+  }
+
+  public async getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
+    return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
+  }
+
+  private async buildOldBlockFromCheckpointedBlock(
+    checkpointedBlock: CheckpointedL2Block | undefined,
+  ): Promise<PublishedL2Block | undefined> {
+    if (!checkpointedBlock) {
+      return undefined;
+    }
+    const checkpoint = await this.store.getCheckpointData(checkpointedBlock.checkpointNumber);
+    if (!checkpoint) {
+      return checkpoint;
+    }
+    const fullCheckpoint = new Checkpoint(
+      checkpointedBlock?.block.archive,
+      checkpoint?.header,
+      [checkpointedBlock.block],
+      checkpoint.checkpointNumber,
+    );
+    const oldBlock = L2Block.fromCheckpoint(fullCheckpoint);
+    const published = new PublishedL2Block(
+      oldBlock,
+      checkpoint.l1,
+      checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
+    );
+    return published;
+  }
+}