@aztec/archiver 3.0.0-nightly.20251216 → 3.0.0-nightly.20251217

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -6,7 +6,8 @@ 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 { type L2Block, L2BlockHash, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateBlockResult } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
   ContractDataSource,
@@ -24,8 +25,7 @@ import { join } from 'path';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import type { InboxMessage } from '../structs/inbox_message.js';
-import type { PublishedL2Block } from '../structs/published.js';
-import { BlockStore } from './block_store.js';
+import { BlockStore, type CheckpointData } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
@@ -67,7 +67,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   }
 
   public getBlockNumber(): Promise<BlockNumber> {
-    return this.getSynchedL2BlockNumber();
+    return this.#blockStore.getLatestL2BlockNumber();
   }
 
   public async getContract(
@@ -186,42 +186,52 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @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: PublishedL2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
+  addBlocks(blocks: L2BlockNew[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
     return this.#blockStore.addBlocks(blocks, opts);
   }
 
+  getRangeOfCheckpoints(from: CheckpointNumber, limit: number): Promise<CheckpointData[]> {
+    return this.#blockStore.getRangeOfCheckpoints(from, limit);
+  }
+  getLatestBlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getLatestBlockNumber();
+  }
+
   /**
-   * Unwinds blocks from the database
+   * Unwinds checkpoints 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
+   * @param checkpointsToUnwind - The number of checkpoints we are to unwind
    * @returns True if the operation is successful
    */
-  unwindBlocks(from: BlockNumber, blocksToUnwind: number): Promise<boolean> {
-    return this.#blockStore.unwindBlocks(from, blocksToUnwind);
+  unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
+    return this.#blockStore.unwindCheckpoints(from, checkpointsToUnwind);
   }
 
-  getPublishedBlock(number: BlockNumber): Promise<PublishedL2Block | undefined> {
-    return this.#blockStore.getBlock(number);
+  addCheckpoints(checkpoints: PublishedCheckpoint[]): Promise<boolean> {
+    return this.#blockStore.addCheckpoints(checkpoints);
   }
 
-  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
+    return this.#blockStore.getCheckpointedBlock(number);
+  }
+  getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+    return this.#blockStore.getCheckpointedBlockByHash(blockHash);
+  }
+  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
+    return this.#blockStore.getCheckpointedBlockByArchive(archive);
+  }
+  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
+    return this.#blockStore.getBlock(number);
+  }
+  getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
   }
-
-  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+  getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByArchive(archive);
   }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks 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
-   */
-  getPublishedBlocks(start: BlockNumber, limit: number): Promise<PublishedL2Block[]> {
-    return toArray(this.#blockStore.getBlocks(start, limit));
+  getBlocks(from: BlockNumber, limit: BlockNumber): Promise<L2BlockNew[]> {
+    return toArray(this.#blockStore.getBlocks(from, limit));
   }
 
   /**
@@ -266,11 +276,11 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.addLogs(blocks);
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.deleteLogs(blocks);
   }
 
@@ -349,20 +359,12 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     }
   }
 
-  /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
-   */
-  getSynchedL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getSynchedL2BlockNumber();
-  }
-
-  getProvenL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getProvenL2BlockNumber();
+  getProvenCheckpointNumber(): Promise<CheckpointNumber> {
+    return this.#blockStore.getProvenCheckpointNumber();
   }
 
-  async setProvenL2BlockNumber(blockNumber: BlockNumber) {
-    await this.#blockStore.setProvenL2BlockNumber(blockNumber);
+  async setProvenCheckpointNumber(checkpointNumber: CheckpointNumber) {
+    await this.#blockStore.setProvenCheckpointNumber(checkpointNumber);
   }
 
   async setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
@@ -373,6 +375,10 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     await this.#messageStore.setSynchedL1Block(l1Block);
   }
 
+  getProvenBlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getProvenBlockNumber();
+  }
+
   /**
    * Gets the last L1 block number processed by the archiver
    */
@@ -410,4 +416,22 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   public setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
     return this.#blockStore.setPendingChainValidationStatus(status);
   }
+
+  public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getCheckpointedL2BlockNumber();
+  }
+  public getSynchedCheckpointNumber(): Promise<CheckpointNumber> {
+    return this.#blockStore.getLatestCheckpointNumber();
+  }
+  async setCheckpointSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
+    await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
+  }
+
+  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
+    return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
+  }
+
+  getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined> {
+    return this.#blockStore.getCheckpointData(checkpointNumber);
+  }
 }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -4,7 +4,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { type L2Block, L2BlockHash } from '@aztec/stdlib/block';
+import { L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import {
   ContractClassLog,
@@ -42,7 +42,7 @@ export class LogStore {
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  async #extractTaggedLogs(block: L2Block) {
+  async #extractTaggedLogs(block: L2BlockNew) {
     const blockHash = L2BlockHash.fromField(await block.hash());
     const taggedLogs = new Map<string, Buffer[]>();
     const dataStartIndexForBlock =
@@ -82,7 +82,7 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  async addLogs(blocks: L2Block[]): Promise<boolean> {
+  async addLogs(blocks: L2BlockNew[]): Promise<boolean> {
     const taggedLogsInBlocks = await Promise.all(blocks.map(block => this.#extractTaggedLogs(block)));
     const taggedLogsToAdd = taggedLogsInBlocks.reduce((acc, taggedLogs) => {
       for (const [tag, logs] of taggedLogs.entries()) {
@@ -160,7 +160,7 @@ export class LogStore {
     return L2BlockHash.fromField(blockHash);
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
       const tagsToDelete = (
         await Promise.all(

package/src/archiver/l1/data_retrieval.ts

@@ -16,7 +16,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { Body, CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
-import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { Proof } from '@aztec/stdlib/proofs';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
@@ -35,7 +35,6 @@ import { NoBlobBodiesFoundError } from '../errors.js';
 import type { ArchiverInstrumentation } from '../instrumentation.js';
 import type { DataRetrieval } from '../structs/data_retrieval.js';
 import type { InboxMessage } from '../structs/inbox_message.js';
-import type { L1PublishedData } from '../structs/published.js';
 import { CalldataRetriever } from './calldata_retriever.js';
 
 export type RetrievedCheckpoint = {
@@ -138,13 +137,17 @@ export async function retrievedToPublishedCheckpoint({
 
 /**
  * Fetches new checkpoints.
+ * @param rollup - The rollup contract instance.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
- * @param rollupAddress - The address of the rollup contract.
+ * @param blobSinkClient - The blob sink client for fetching blob data.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
  */
 export async function retrieveCheckpointsFromRollup(
   rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
@@ -160,6 +163,7 @@ export async function retrieveCheckpointsFromRollup(
   },
   instrumentation: ArchiverInstrumentation,
   logger: Logger = createLogger('archiver'),
+  isHistoricalSync: boolean = false,
 ): Promise<RetrievedCheckpoint[]> {
   const retrievedCheckpoints: RetrievedCheckpoint[] = [];
 
@@ -211,6 +215,7 @@ export async function retrieveCheckpointsFromRollup(
       contractAddresses,
       instrumentation,
       logger,
+      isHistoricalSync,
     );
     retrievedCheckpoints.push(...newCheckpoints);
     searchStartBlock = lastLog.blockNumber! + 1n;
@@ -222,11 +227,17 @@ export async function retrieveCheckpointsFromRollup(
 
 /**
  * Processes newly received CheckpointProposed logs.
- * @param rollup - The rollup contract
+ * @param rollup - The rollup contract instance.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param blobSinkClient - The blob sink client for fetching blob data.
  * @param logs - CheckpointProposed logs.
- * @returns - An array of checkpoints.
+ * @param rollupConstants - The rollup constants (chainId, version, targetCommitteeSize).
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
  */
 async function processCheckpointProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
@@ -242,6 +253,7 @@ async function processCheckpointProposedLogs(
   },
   instrumentation: ArchiverInstrumentation,
   logger: Logger,
+  isHistoricalSync: boolean,
 ): Promise<RetrievedCheckpoint[]> {
   const retrievedCheckpoints: RetrievedCheckpoint[] = [];
   const calldataRetriever = new CalldataRetriever(
@@ -279,13 +291,14 @@ async function processCheckpointProposedLogs(
         blobHashes,
         checkpointNumber,
         logger,
+        isHistoricalSync,
       );
 
-      const l1: L1PublishedData = {
-        blockNumber: log.blockNumber,
-        blockHash: log.blockHash,
-        timestamp: await getL1BlockTime(publicClient, log.blockNumber),
-      };
+      const l1 = new L1PublishedData(
+        log.blockNumber,
+        await getL1BlockTime(publicClient, log.blockNumber),
+        log.blockHash,
+      );
 
       retrievedCheckpoints.push({ ...checkpoint, checkpointBlobData, l1, chainId, version });
       logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.transactionHash}`, {
@@ -316,8 +329,9 @@ export async function getCheckpointBlobDataFromBlobs(
   blobHashes: Buffer<ArrayBufferLike>[],
   checkpointNumber: CheckpointNumber,
   logger: Logger,
+  isHistoricalSync: boolean,
 ): Promise<CheckpointBlobData> {
-  const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
+  const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes, undefined, { isHistoricalSync });
   if (blobBodies.length === 0) {
     throw new NoBlobBodiesFoundError(checkpointNumber);
   }

package/src/archiver/structs/published.ts

@@ -1,2 +1 @@
-export type { PublishedL2Block } from '@aztec/stdlib/block';
 export type { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';

package/src/test/mock_l2_block_source.ts

@@ -15,7 +15,7 @@ import {
   PublishedL2Block,
   type ValidateBlockResult,
 } from '@aztec/stdlib/block';
-import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { type Checkpoint, L1PublishedData } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
@@ -91,6 +91,11 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(BlockNumber(this.provenBlockNumber));
   }
 
+  public getCheckpointedBlock(_number: BlockNumber) {
+    // In this mock, we don't track checkpointed blocks separately
+    return Promise.resolve(undefined);
+  }
+
   /**
    * Gets an l2 block.
    * @param number - The block number to return (inclusive).
@@ -129,11 +134,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return blocks.map(block =>
       PublishedL2Block.fromFields({
         block,
-        l1: {
-          blockNumber: BigInt(block.number),
-          blockHash: Buffer32.random().toString(),
-          timestamp: BigInt(block.number),
-        },
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
         attestations: [],
       }),
     );
@@ -145,11 +146,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
       if (hash.equals(blockHash)) {
         return PublishedL2Block.fromFields({
           block,
-          l1: {
-            blockNumber: BigInt(block.number),
-            blockHash: Buffer32.random().toString(),
-            timestamp: BigInt(block.number),
-          },
+          l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
           attestations: [],
         });
       }
@@ -165,11 +162,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(
       PublishedL2Block.fromFields({
         block,
-        l1: {
-          blockNumber: BigInt(block.number),
-          blockHash: Buffer32.random().toString(),
-          timestamp: BigInt(block.number),
-        },
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
         attestations: [],
       }),
     );