@aztec/archiver 0.0.1-commit.4ad48494d → 0.0.1-commit.4eabbdb

package/src/store/block_store.ts

@@ -9,6 +9,7 @@ import { isDefined } from '@aztec/foundation/types';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  type BlockData,
   BlockHash,
   Body,
   CheckpointedL2Block,
@@ -18,7 +19,7 @@ import {
   deserializeValidateCheckpointResult,
   serializeValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { type CheckpointData, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
@@ -61,23 +62,14 @@ type BlockStorage = {
 type CheckpointStorage = {
   header: Buffer;
   archive: Buffer;
+  checkpointOutHash: Buffer;
   checkpointNumber: number;
   startBlock: number;
-  numBlocks: number;
+  blockCount: number;
   l1: Buffer;
   attestations: Buffer[];
 };
 
-export type CheckpointData = {
-  checkpointNumber: CheckpointNumber;
-  header: CheckpointHeader;
-  archive: AppendOnlyTreeSnapshot;
-  startBlock: number;
-  numBlocks: number;
-  l1: L1PublishedData;
-  attestations: Buffer[];
-};
-
 export type RemoveCheckpointsResult = { blocksRemoved: L2Block[] | undefined };
 
 /**
@@ -90,6 +82,9 @@ export class BlockStore {
   /** Map checkpoint number to checkpoint data */
   #checkpoints: AztecAsyncMap<number, CheckpointStorage>;
 
+  /** Map slot number to checkpoint number, for looking up checkpoints by slot range. */
+  #slotToCheckpoint: AztecAsyncMap<number, number>;
+
   /** Map block hash to list of tx hashes */
   #blockTxs: AztecAsyncMap<string, Buffer>;
 
@@ -130,6 +125,7 @@ export class BlockStore {
     this.#lastProvenCheckpoint = db.openSingleton('archiver_last_proven_l2_checkpoint');
     this.#pendingChainValidationStatus = db.openSingleton('archiver_pending_chain_validation_status');
     this.#checkpoints = db.openMap('archiver_checkpoints');
+    this.#slotToCheckpoint = db.openMap('archiver_slot_to_checkpoint');
   }
 
   /**
@@ -273,7 +269,7 @@ export class BlockStore {
 
       // If we have a previous checkpoint then we need to get the previous block number
       if (previousCheckpointData !== undefined) {
-        previousBlockNumber = BlockNumber(previousCheckpointData.startBlock + previousCheckpointData.numBlocks - 1);
+        previousBlockNumber = BlockNumber(previousCheckpointData.startBlock + previousCheckpointData.blockCount - 1);
         previousBlock = await this.getBlock(previousBlockNumber);
         if (previousBlock === undefined) {
           // We should be able to get the required previous block
@@ -337,12 +333,16 @@ export class BlockStore {
         await this.#checkpoints.set(checkpoint.checkpoint.number, {
           header: checkpoint.checkpoint.header.toBuffer(),
           archive: checkpoint.checkpoint.archive.toBuffer(),
+          checkpointOutHash: checkpoint.checkpoint.getCheckpointOutHash().toBuffer(),
           l1: checkpoint.l1.toBuffer(),
           attestations: checkpoint.attestations.map(attestation => attestation.toBuffer()),
           checkpointNumber: checkpoint.checkpoint.number,
           startBlock: checkpoint.checkpoint.blocks[0].number,
-          numBlocks: checkpoint.checkpoint.blocks.length,
+          blockCount: checkpoint.checkpoint.blocks.length,
         });
+
+        // Update slot-to-checkpoint index
+        await this.#slotToCheckpoint.set(checkpoint.checkpoint.header.slotNumber, checkpoint.checkpoint.number);
       }
 
       await this.#lastSynchedL1Block.set(checkpoints[checkpoints.length - 1].l1.blockNumber);
@@ -425,7 +425,7 @@ export class BlockStore {
         if (!targetCheckpoint) {
           throw new Error(`Target checkpoint ${checkpointNumber} not found in store`);
         }
-        lastBlockToKeep = BlockNumber(targetCheckpoint.startBlock + targetCheckpoint.numBlocks - 1);
+        lastBlockToKeep = BlockNumber(targetCheckpoint.startBlock + targetCheckpoint.blockCount - 1);
       }
 
       // Remove all blocks after lastBlockToKeep (both checkpointed and uncheckpointed)
@@ -433,6 +433,11 @@ export class BlockStore {
 
       // Remove all checkpoints after the target
       for (let c = latestCheckpointNumber; c > checkpointNumber; c = CheckpointNumber(c - 1)) {
+        const checkpointStorage = await this.#checkpoints.getAsync(c);
+        if (checkpointStorage) {
+          const slotNumber = CheckpointHeader.fromBuffer(checkpointStorage.header).slotNumber;
+          await this.#slotToCheckpoint.delete(slotNumber);
+        }
         await this.#checkpoints.delete(c);
         this.#log.debug(`Removed checkpoint ${c}`);
       }
@@ -461,17 +466,32 @@ export class BlockStore {
     return checkpoints;
   }
 
-  private checkpointDataFromCheckpointStorage(checkpointStorage: CheckpointStorage) {
-    const data: CheckpointData = {
+  /** Returns checkpoint data for all checkpoints whose slot falls within the given range (inclusive). */
+  async getCheckpointDataForSlotRange(startSlot: SlotNumber, endSlot: SlotNumber): Promise<CheckpointData[]> {
+    const result: CheckpointData[] = [];
+    for await (const [, checkpointNumber] of this.#slotToCheckpoint.entriesAsync({
+      start: startSlot,
+      end: endSlot + 1,
+    })) {
+      const checkpointStorage = await this.#checkpoints.getAsync(checkpointNumber);
+      if (checkpointStorage) {
+        result.push(this.checkpointDataFromCheckpointStorage(checkpointStorage));
+      }
+    }
+    return result;
+  }
+
+  private checkpointDataFromCheckpointStorage(checkpointStorage: CheckpointStorage): CheckpointData {
+    return {
       header: CheckpointHeader.fromBuffer(checkpointStorage.header),
       archive: AppendOnlyTreeSnapshot.fromBuffer(checkpointStorage.archive),
+      checkpointOutHash: Fr.fromBuffer(checkpointStorage.checkpointOutHash),
       checkpointNumber: CheckpointNumber(checkpointStorage.checkpointNumber),
-      startBlock: checkpointStorage.startBlock,
-      numBlocks: checkpointStorage.numBlocks,
+      startBlock: BlockNumber(checkpointStorage.startBlock),
+      blockCount: checkpointStorage.blockCount,
       l1: L1PublishedData.fromBuffer(checkpointStorage.l1),
-      attestations: checkpointStorage.attestations,
+      attestations: checkpointStorage.attestations.map(buf => CommitteeAttestation.fromBuffer(buf)),
     };
-    return data;
   }
 
   async getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2Block[] | undefined> {
@@ -483,7 +503,7 @@ export class BlockStore {
     const blocksForCheckpoint = await toArray(
       this.#blocks.entriesAsync({
         start: checkpoint.startBlock,
-        end: checkpoint.startBlock + checkpoint.numBlocks,
+        end: checkpoint.startBlock + checkpoint.blockCount,
       }),
     );
 
@@ -556,7 +576,7 @@ export class BlockStore {
     if (!checkpointStorage) {
       throw new CheckpointNotFoundError(provenCheckpointNumber);
     } else {
-      return BlockNumber(checkpointStorage.startBlock + checkpointStorage.numBlocks - 1);
+      return BlockNumber(checkpointStorage.startBlock + checkpointStorage.blockCount - 1);
     }
   }
 
@@ -655,6 +675,32 @@ export class BlockStore {
     }
   }
 
+  /**
+   * Gets block metadata (without tx data) by block number.
+   * @param blockNumber - The number of the block to return.
+   * @returns The requested block data.
+   */
+  async getBlockData(blockNumber: BlockNumber): Promise<BlockData | undefined> {
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
+    if (!blockStorage || !blockStorage.header) {
+      return undefined;
+    }
+    return this.getBlockDataFromBlockStorage(blockStorage);
+  }
+
+  /**
+   * Gets block metadata (without tx data) by archive root.
+   * @param archive - The archive root of the block to return.
+   * @returns The requested block data.
+   */
+  async getBlockDataByArchive(archive: Fr): Promise<BlockData | undefined> {
+    const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    return this.getBlockData(BlockNumber(blockNumber));
+  }
+
   /**
    * Gets an L2 block.
    * @param blockNumber - The number of the block to return.
@@ -759,15 +805,24 @@ export class BlockStore {
     }
   }
 
+  private getBlockDataFromBlockStorage(blockStorage: BlockStorage): BlockData {
+    return {
+      header: BlockHeader.fromBuffer(blockStorage.header),
+      archive: AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive),
+      blockHash: Fr.fromBuffer(blockStorage.blockHash),
+      checkpointNumber: CheckpointNumber(blockStorage.checkpointNumber),
+      indexWithinCheckpoint: IndexWithinCheckpoint(blockStorage.indexWithinCheckpoint),
+    };
+  }
+
   private async getBlockFromBlockStorage(
     blockNumber: number,
     blockStorage: BlockStorage,
   ): Promise<L2Block | undefined> {
-    const header = BlockHeader.fromBuffer(blockStorage.header);
-    const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
-    const blockHash = blockStorage.blockHash;
-    header.setHash(Fr.fromBuffer(blockHash));
-    const blockHashString = bufferToHex(blockHash);
+    const { header, archive, blockHash, checkpointNumber, indexWithinCheckpoint } =
+      this.getBlockDataFromBlockStorage(blockStorage);
+    header.setHash(blockHash);
+    const blockHashString = bufferToHex(blockStorage.blockHash);
     const blockTxsBuffer = await this.#blockTxs.getAsync(blockHashString);
     if (blockTxsBuffer === undefined) {
       this.#log.warn(`Could not find body for block ${header.globalVariables.blockNumber} ${blockHash}`);
@@ -786,13 +841,7 @@ export class BlockStore {
       txEffects.push(deserializeIndexedTxEffect(txEffect).data);
     }
     const body = new Body(txEffects);
-    const block = new L2Block(
-      archive,
-      header,
-      body,
-      CheckpointNumber(blockStorage.checkpointNumber!),
-      IndexWithinCheckpoint(blockStorage.indexWithinCheckpoint),
-    );
+    const block = new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
 
     if (block.number !== blockNumber) {
       throw new Error(
@@ -892,7 +941,7 @@ export class BlockStore {
     if (!checkpoint) {
       return BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
     }
-    return BlockNumber(checkpoint.startBlock + checkpoint.numBlocks - 1);
+    return BlockNumber(checkpoint.startBlock + checkpoint.blockCount - 1);
   }
 
   async getLatestL2BlockNumber(): Promise<BlockNumber> {

package/src/store/kv_archiver_store.ts

@@ -6,8 +6,14 @@ 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 { BlockHash, CheckpointedL2Block, L2Block, type ValidateCheckpointResult } from '@aztec/stdlib/block';
-import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import {
+  type BlockData,
+  BlockHash,
+  CheckpointedL2Block,
+  L2Block,
+  type ValidateCheckpointResult,
+} from '@aztec/stdlib/block';
+import type { CheckpointData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
   ContractDataSource,
@@ -25,7 +31,7 @@ import type { UInt64 } from '@aztec/stdlib/types';
 import { join } from 'path';
 
 import type { InboxMessage } from '../structs/inbox_message.js';
-import { BlockStore, type CheckpointData, type RemoveCheckpointsResult } from './block_store.js';
+import { BlockStore, type RemoveCheckpointsResult } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
@@ -74,6 +80,11 @@ export class KVArchiverDataStore implements ContractDataSource {
     this.#contractInstanceStore = new ContractInstanceStore(db);
   }
 
+  /** Returns the underlying block store. Used by L2TipsCache. */
+  get blockStore(): BlockStore {
+    return this.#blockStore;
+  }
+
   /** 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);
@@ -369,6 +380,22 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.#blockStore.getBlockHeaderByArchive(archive);
   }
 
+  /**
+   * Gets block metadata (without tx data) by block number.
+   * @param blockNumber - The block number to return.
+   */
+  getBlockData(blockNumber: BlockNumber): Promise<BlockData | undefined> {
+    return this.#blockStore.getBlockData(blockNumber);
+  }
+
+  /**
+   * Gets block metadata (without tx data) by archive root.
+   * @param archive - The archive root to return.
+   */
+  getBlockDataByArchive(archive: Fr): Promise<BlockData | undefined> {
+    return this.#blockStore.getBlockDataByArchive(archive);
+  }
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.
@@ -618,6 +645,11 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.#blockStore.getCheckpointData(checkpointNumber);
   }
 
+  /** Returns checkpoint data for all checkpoints whose slot falls within the given range (inclusive). */
+  getCheckpointDataForSlotRange(startSlot: SlotNumber, endSlot: SlotNumber): Promise<CheckpointData[]> {
+    return this.#blockStore.getCheckpointDataForSlotRange(startSlot, endSlot);
+  }
+
   /**
    * Gets all blocks that have the given slot number.
    * @param slotNumber - The slot number to search for.

package/src/store/l2_tips_cache.ts

@@ -0,0 +1,89 @@
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { type BlockData, type CheckpointId, GENESIS_CHECKPOINT_HEADER_HASH, type L2Tips } from '@aztec/stdlib/block';
+
+import type { BlockStore } from './block_store.js';
+
+/**
+ * In-memory cache for L2 chain tips (proposed, checkpointed, proven, finalized).
+ * Populated from the BlockStore on first access, then kept up-to-date by the ArchiverDataStoreUpdater.
+ * Refresh calls should happen within the store transaction that mutates block data to ensure consistency.
+ */
+export class L2TipsCache {
+  #tipsPromise: Promise<L2Tips> | undefined;
+
+  constructor(private blockStore: BlockStore) {}
+
+  /** Returns the cached L2 tips. Loads from the block store on first call. */
+  public getL2Tips(): Promise<L2Tips> {
+    return (this.#tipsPromise ??= this.loadFromStore());
+  }
+
+  /** Reloads the L2 tips from the block store. Should be called within the store transaction that mutates data. */
+  public async refresh(): Promise<void> {
+    this.#tipsPromise = this.loadFromStore();
+    await this.#tipsPromise;
+  }
+
+  private async loadFromStore(): Promise<L2Tips> {
+    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
+      this.blockStore.getLatestBlockNumber(),
+      this.blockStore.getProvenBlockNumber(),
+      this.blockStore.getCheckpointedL2BlockNumber(),
+      this.blockStore.getFinalizedL2BlockNumber(),
+    ]);
+
+    const genesisBlockHeader = {
+      blockHash: GENESIS_BLOCK_HEADER_HASH,
+      checkpointNumber: CheckpointNumber.ZERO,
+    } as const;
+    const beforeInitialBlockNumber = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
+
+    const getBlockData = (blockNumber: BlockNumber) =>
+      blockNumber > beforeInitialBlockNumber ? this.blockStore.getBlockData(blockNumber) : genesisBlockHeader;
+
+    const [latestBlockData, provenBlockData, checkpointedBlockData, finalizedBlockData] = await Promise.all(
+      [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber].map(getBlockData),
+    );
+
+    if (!latestBlockData || !provenBlockData || !finalizedBlockData || !checkpointedBlockData) {
+      throw new Error('Failed to load block data for L2 tips');
+    }
+
+    const [provenCheckpointId, finalizedCheckpointId, checkpointedCheckpointId] = await Promise.all([
+      this.getCheckpointIdForBlock(provenBlockData),
+      this.getCheckpointIdForBlock(finalizedBlockData),
+      this.getCheckpointIdForBlock(checkpointedBlockData),
+    ]);
+
+    return {
+      proposed: { number: latestBlockNumber, hash: latestBlockData.blockHash.toString() },
+      proven: {
+        block: { number: provenBlockNumber, hash: provenBlockData.blockHash.toString() },
+        checkpoint: provenCheckpointId,
+      },
+      finalized: {
+        block: { number: finalizedBlockNumber, hash: finalizedBlockData.blockHash.toString() },
+        checkpoint: finalizedCheckpointId,
+      },
+      checkpointed: {
+        block: { number: checkpointedBlockNumber, hash: checkpointedBlockData.blockHash.toString() },
+        checkpoint: checkpointedCheckpointId,
+      },
+    };
+  }
+
+  private async getCheckpointIdForBlock(blockData: Pick<BlockData, 'checkpointNumber'>): Promise<CheckpointId> {
+    const checkpointData = await this.blockStore.getCheckpointData(blockData.checkpointNumber);
+    if (!checkpointData) {
+      return {
+        number: CheckpointNumber.ZERO,
+        hash: GENESIS_CHECKPOINT_HEADER_HASH.toString(),
+      };
+    }
+    return {
+      number: checkpointData.checkpointNumber,
+      hash: checkpointData.header.hash().toString(),
+    };
+  }
+}

package/src/test/fake_l1_state.ts

@@ -131,6 +131,7 @@ export class FakeL1State {
   private provenCheckpointNumber: CheckpointNumber = CheckpointNumber(0);
   private targetCommitteeSize: number = 0;
   private version: bigint = 1n;
+  private canPruneResult: boolean = false;
 
   // Computed from checkpoints based on L1 block visibility
   private pendingCheckpointNumber: CheckpointNumber = CheckpointNumber(0);
@@ -194,9 +195,9 @@ export class FakeL1State {
     this.addMessages(checkpointNumber, messagesL1BlockNumber, messages);
 
     // Create the transaction and blobs
-    const tx = this.makeRollupTx(checkpoint, signers);
-    const blobHashes = this.makeVersionedBlobHashes(checkpoint);
-    const blobs = this.makeBlobsFromCheckpoint(checkpoint);
+    const tx = await this.makeRollupTx(checkpoint, signers);
+    const blobHashes = await this.makeVersionedBlobHashes(checkpoint);
+    const blobs = await this.makeBlobsFromCheckpoint(checkpoint);
 
     // Store the checkpoint data
     this.checkpoints.push({
@@ -276,6 +277,11 @@ export class FakeL1State {
     this.targetCommitteeSize = size;
   }
 
+  /** Sets whether the rollup contract would allow pruning at the next block. */
+  setCanPrune(value: boolean): void {
+    this.canPruneResult = value;
+  }
+
   /**
    * Removes all entries for a checkpoint number (simulates L1 reorg or prune).
    * Note: Does NOT remove messages for this checkpoint (use numL1ToL2Messages: 0 when re-adding).
@@ -384,6 +390,8 @@ export class FakeL1State {
       });
     });
 
+    mockRollup.canPruneAtTime.mockImplementation(() => Promise.resolve(this.canPruneResult));
+
     // Mock the wrapper method for fetching checkpoint events
     mockRollup.getCheckpointProposedEvents.mockImplementation((fromBlock: bigint, toBlock: bigint) =>
       Promise.resolve(this.getCheckpointProposedLogs(fromBlock, toBlock)),
@@ -531,14 +539,14 @@ export class FakeL1State {
       }));
   }
 
-  private makeRollupTx(checkpoint: Checkpoint, signers: Secp256k1Signer[]): Transaction {
+  private async makeRollupTx(checkpoint: Checkpoint, signers: Secp256k1Signer[]): Promise<Transaction> {
     const attestations = signers
       .map(signer => makeCheckpointAttestationFromCheckpoint(checkpoint, signer))
       .map(attestation => CommitteeAttestation.fromSignature(attestation.signature))
       .map(committeeAttestation => committeeAttestation.toViem());
 
     const header = checkpoint.header.toViem();
-    const blobInput = getPrefixedEthBlobCommitments(getBlobsPerL1Block(checkpoint.toBlobFields()));
+    const blobInput = getPrefixedEthBlobCommitments(await getBlobsPerL1Block(checkpoint.toBlobFields()));
     const archive = toHex(checkpoint.archive.root.toBuffer());
     const attestationsAndSigners = new CommitteeAttestationsAndSigners(
       attestations.map(attestation => CommitteeAttestation.fromViem(attestation)),
@@ -587,13 +595,13 @@ export class FakeL1State {
     } as Transaction<bigint, number>;
   }
 
-  private makeVersionedBlobHashes(checkpoint: Checkpoint): `0x${string}`[] {
-    return getBlobsPerL1Block(checkpoint.toBlobFields()).map(
+  private async makeVersionedBlobHashes(checkpoint: Checkpoint): Promise<`0x${string}`[]> {
+    return (await getBlobsPerL1Block(checkpoint.toBlobFields())).map(
       b => `0x${b.getEthVersionedBlobHash().toString('hex')}` as `0x${string}`,
     );
   }
 
-  private makeBlobsFromCheckpoint(checkpoint: Checkpoint): Blob[] {
-    return getBlobsPerL1Block(checkpoint.toBlobFields());
+  private async makeBlobsFromCheckpoint(checkpoint: Checkpoint): Promise<Blob[]> {
+    return await getBlobsPerL1Block(checkpoint.toBlobFields());
   }
 }

package/src/test/mock_archiver.ts

@@ -56,8 +56,9 @@ export class MockPrefilledArchiver extends MockArchiver {
     }
 
     const fromBlock = this.l2Blocks.length;
-    // TODO: Add L2 blocks and checkpoints separately once archiver has the apis for that.
-    this.addProposedBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).flatMap(c => c.blocks));
+    const checkpointsToAdd = this.prefilled.slice(fromBlock, fromBlock + numBlocks);
+    this.addProposedBlocks(checkpointsToAdd.flatMap(c => c.blocks));
+    this.checkpointList.push(...checkpointsToAdd);
     return Promise.resolve();
   }
 }