@aztec/archiver 0.0.1-commit.f2ce05ee → 0.0.1-commit.f81dbcf

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/store/log_store.ts

@@ -1,6 +1,6 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { filterAsync } from '@aztec/foundation/collection';
+import { compactArray, filterAsync } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
@@ -290,18 +290,49 @@ export class LogStore {
 
   deleteLogs(blocks: L2Block[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
-      await Promise.all(
-        blocks.map(async block => {
-          // Delete private logs
-          const privateKeys = (await this.#privateLogKeysByBlock.getAsync(block.number)) ?? [];
-          await Promise.all(privateKeys.map(tag => this.#privateLogsByTag.delete(tag)));
-
-          // Delete public logs
-          const publicKeys = (await this.#publicLogKeysByBlock.getAsync(block.number)) ?? [];
-          await Promise.all(publicKeys.map(key => this.#publicLogsByContractAndTag.delete(key)));
-        }),
+      const blockNumbers = new Set(blocks.map(block => block.number));
+      const firstBlockToDelete = Math.min(...blockNumbers);
+
+      // Collect all unique private tags across all blocks being deleted
+      const allPrivateTags = new Set(
+        compactArray(await Promise.all(blocks.map(block => this.#privateLogKeysByBlock.getAsync(block.number)))).flat(),
       );
 
+      // Trim private logs: for each tag, delete all instances including and after the first block being deleted.
+      // This hinges on the invariant that logs for a given tag are always inserted in order of block number, which is enforced in #addPrivateLogs.
+      for (const tag of allPrivateTags) {
+        const existing = await this.#privateLogsByTag.getAsync(tag);
+        if (existing === undefined || existing.length === 0) {
+          continue;
+        }
+        const lastIndexToKeep = existing.findLastIndex(
+          buf => TxScopedL2Log.getBlockNumberFromBuffer(buf) < firstBlockToDelete,
+        );
+        const remaining = existing.slice(0, lastIndexToKeep + 1);
+        await (remaining.length > 0 ? this.#privateLogsByTag.set(tag, remaining) : this.#privateLogsByTag.delete(tag));
+      }
+
+      // Collect all unique public keys across all blocks being deleted
+      const allPublicKeys = new Set(
+        compactArray(await Promise.all(blocks.map(block => this.#publicLogKeysByBlock.getAsync(block.number)))).flat(),
+      );
+
+      // And do the same as we did with private logs
+      for (const key of allPublicKeys) {
+        const existing = await this.#publicLogsByContractAndTag.getAsync(key);
+        if (existing === undefined || existing.length === 0) {
+          continue;
+        }
+        const lastIndexToKeep = existing.findLastIndex(
+          buf => TxScopedL2Log.getBlockNumberFromBuffer(buf) < firstBlockToDelete,
+        );
+        const remaining = existing.slice(0, lastIndexToKeep + 1);
+        await (remaining.length > 0
+          ? this.#publicLogsByContractAndTag.set(key, remaining)
+          : this.#publicLogsByContractAndTag.delete(key));
+      }
+
+      // After trimming the tagged logs, we can delete the block-level keys that track which tags are in which blocks.
       await Promise.all(
         blocks.map(block =>
           Promise.all([
@@ -588,11 +619,24 @@ export class LogStore {
     txLogs: PublicLog[],
     filter: LogFilter = {},
   ): boolean {
+    if (filter.fromBlock && blockNumber < filter.fromBlock) {
+      return false;
+    }
+    if (filter.toBlock && blockNumber >= filter.toBlock) {
+      return false;
+    }
+    if (filter.txHash && !txHash.equals(filter.txHash)) {
+      return false;
+    }
+
     let maxLogsHit = false;
     let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
     for (; logIndex < txLogs.length; logIndex++) {
       const log = txLogs[logIndex];
-      if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
+      if (
+        (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) &&
+        (!filter.tag || log.fields[0]?.equals(filter.tag))
+      ) {
         results.push(
           new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txHash, txIndex, logIndex), log),
         );
@@ -616,6 +660,16 @@ export class LogStore {
     txLogs: ContractClassLog[],
     filter: LogFilter = {},
   ): boolean {
+    if (filter.fromBlock && blockNumber < filter.fromBlock) {
+      return false;
+    }
+    if (filter.toBlock && blockNumber >= filter.toBlock) {
+      return false;
+    }
+    if (filter.txHash && !txHash.equals(filter.txHash)) {
+      return false;
+    }
+
     let maxLogsHit = false;
     let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
     for (; logIndex < txLogs.length; logIndex++) {

package/src/store/message_store.ts

@@ -137,7 +137,7 @@ export class MessageStore {
           );
         }
 
-        // Check the first message in a block has the correct index.
+        // Check the first message in a checkpoint has the correct index.
         if (
           (!lastMessage || message.checkpointNumber > lastMessage.checkpointNumber) &&
           message.index !== expectedStart

package/src/test/fake_l1_state.ts

@@ -14,6 +14,7 @@ import { CommitteeAttestation, CommitteeAttestationsAndSigners, L2Block } from '
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
 import {
   makeAndSignCommitteeAttestationsAndSigners,
   makeCheckpointAttestationFromCheckpoint,
@@ -22,7 +23,16 @@ import {
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 
 import { type MockProxy, mock } from 'jest-mock-extended';
-import { type FormattedBlock, type Transaction, encodeFunctionData, multicall3Abi, toHex } from 'viem';
+import {
+  type AbiParameter,
+  type FormattedBlock,
+  type Transaction,
+  encodeAbiParameters,
+  encodeFunctionData,
+  keccak256,
+  multicall3Abi,
+  toHex,
+} from 'viem';
 
 import { updateRollingHash } from '../structs/inbox_message.js';
 
@@ -87,6 +97,10 @@ type CheckpointData = {
   blobHashes: `0x${string}`[];
   blobs: Blob[];
   signers: Secp256k1Signer[];
+  /** Hash of the packed attestations, matching what the L1 event emits. */
+  attestationsHash: Buffer32;
+  /** Payload digest, matching what the L1 event emits. */
+  payloadDigest: Buffer32;
   /** If true, archiveAt will ignore it */
   pruned?: boolean;
 };
@@ -131,12 +145,17 @@ 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);
 
+  // The L1 block number reported as "finalized" (defaults to the start block)
+  private finalizedL1BlockNumber: bigint;
+
   constructor(private readonly config: FakeL1StateConfig) {
     this.l1BlockNumber = config.l1StartBlock;
+    this.finalizedL1BlockNumber = config.l1StartBlock;
     this.lastArchive = new AppendOnlyTreeSnapshot(config.genesisArchiveRoot, 1);
   }
 
@@ -193,10 +212,10 @@ export class FakeL1State {
     // Store the messages internally so they match the checkpoint's inHash
     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);
+    // Create the transaction, blobs, and event hashes
+    const { tx, attestationsHash, payloadDigest } = await this.makeRollupTx(checkpoint, signers);
+    const blobHashes = await this.makeVersionedBlobHashes(checkpoint);
+    const blobs = await this.makeBlobsFromCheckpoint(checkpoint);
 
     // Store the checkpoint data
     this.checkpoints.push({
@@ -207,6 +226,8 @@ export class FakeL1State {
       blobHashes,
       blobs,
       signers,
+      attestationsHash,
+      payloadDigest,
     });
 
     // Update last archive for auto-chaining
@@ -266,16 +287,40 @@ export class FakeL1State {
     this.updatePendingCheckpointNumber();
   }
 
+  /** Sets the L1 block number that will be reported as "finalized". */
+  setFinalizedL1BlockNumber(blockNumber: bigint): void {
+    this.finalizedL1BlockNumber = blockNumber;
+  }
+
   /** Marks a checkpoint as proven. Updates provenCheckpointNumber. */
   markCheckpointAsProven(checkpointNumber: CheckpointNumber): void {
     this.provenCheckpointNumber = checkpointNumber;
   }
 
+  /**
+   * Simulates what `rollup.getProvenCheckpointNumber({ blockNumber: atL1Block })` would return.
+   */
+  getProvenCheckpointNumberAtL1Block(atL1Block: bigint): CheckpointNumber {
+    if (this.provenCheckpointNumber === 0) {
+      return CheckpointNumber(0);
+    }
+    const checkpoint = this.checkpoints.find(cp => cp.checkpointNumber === this.provenCheckpointNumber);
+    if (checkpoint && checkpoint.l1BlockNumber <= atL1Block) {
+      return this.provenCheckpointNumber;
+    }
+    return CheckpointNumber(0);
+  }
+
   /** Sets the target committee size for attestation validation. */
   setTargetCommitteeSize(size: number): void {
     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 +429,13 @@ export class FakeL1State {
       });
     });
 
+    mockRollup.getProvenCheckpointNumber.mockImplementation((options?: { blockNumber?: bigint }) => {
+      const atBlock = options?.blockNumber ?? this.l1BlockNumber;
+      return Promise.resolve(this.getProvenCheckpointNumberAtL1Block(atBlock));
+    });
+
+    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)),
@@ -425,10 +477,13 @@ export class FakeL1State {
     publicClient.getChainId.mockResolvedValue(1);
     publicClient.getBlockNumber.mockImplementation(() => Promise.resolve(this.l1BlockNumber));
 
-    // Use async function pattern that existing test uses for getBlock
-
-    publicClient.getBlock.mockImplementation((async (args: { blockNumber?: bigint } = {}) => {
-      const blockNum = args.blockNumber ?? (await publicClient.getBlockNumber());
+    publicClient.getBlock.mockImplementation((async (args: { blockNumber?: bigint; blockTag?: string } = {}) => {
+      let blockNum: bigint;
+      if (args.blockTag === 'finalized') {
+        blockNum = this.finalizedL1BlockNumber;
+      } else {
+        blockNum = args.blockNumber ?? (await publicClient.getBlockNumber());
+      }
       return {
         number: blockNum,
         timestamp: BigInt(blockNum) * BigInt(this.config.ethereumSlotDuration) + this.config.l1GenesisTime,
@@ -502,10 +557,8 @@ export class FakeL1State {
           checkpointNumber: cpData.checkpointNumber,
           archive: cpData.checkpoint.archive.root,
           versionedBlobHashes: cpData.blobHashes.map(h => Buffer.from(h.slice(2), 'hex')),
-          // These are intentionally undefined to skip hash validation in the archiver
-          // (validation is skipped when these fields are falsy)
-          payloadDigest: undefined,
-          attestationsHash: undefined,
+          attestationsHash: cpData.attestationsHash,
+          payloadDigest: cpData.payloadDigest,
         },
       }));
   }
@@ -531,14 +584,17 @@ export class FakeL1State {
       }));
   }
 
-  private makeRollupTx(checkpoint: Checkpoint, signers: Secp256k1Signer[]): Transaction {
+  private async makeRollupTx(
+    checkpoint: Checkpoint,
+    signers: Secp256k1Signer[],
+  ): Promise<{ tx: Transaction; attestationsHash: Buffer32; payloadDigest: Buffer32 }> {
     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)),
@@ -549,6 +605,8 @@ export class FakeL1State {
       signers[0],
     );
 
+    const packedAttestations = attestationsAndSigners.getPackedAttestations();
+
     const rollupInput = encodeFunctionData({
       abi: RollupAbi,
       functionName: 'propose',
@@ -558,7 +616,7 @@ export class FakeL1State {
           archive,
           oracleInput: { feeAssetPriceModifier: 0n },
         },
-        attestationsAndSigners.getPackedAttestations(),
+        packedAttestations,
         attestationsAndSigners.getSigners().map(signer => signer.toString()),
         attestationsAndSignersSignature.toViemSignature(),
         blobInput,
@@ -579,21 +637,52 @@ export class FakeL1State {
       ],
     });
 
-    return {
+    // Compute attestationsHash (same logic as CalldataRetriever)
+    const attestationsHash = Buffer32.fromString(
+      keccak256(encodeAbiParameters([this.getCommitteeAttestationsStructDef()], [packedAttestations])),
+    );
+
+    // Compute payloadDigest (same logic as CalldataRetriever)
+    const consensusPayload = ConsensusPayload.fromCheckpoint(checkpoint);
+    const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
+    const payloadDigest = Buffer32.fromString(keccak256(payloadToSign));
+
+    const tx = {
       input: multiCallInput,
       hash: archive,
       blockHash: archive,
       to: MULTI_CALL_3_ADDRESS as `0x${string}`,
     } as Transaction<bigint, number>;
+
+    return { tx, attestationsHash, payloadDigest };
+  }
+
+  /** Extracts the CommitteeAttestations struct definition from RollupAbi for hash computation. */
+  private getCommitteeAttestationsStructDef(): AbiParameter {
+    const proposeFunction = RollupAbi.find(item => item.type === 'function' && item.name === 'propose') as
+      | { type: 'function'; name: string; inputs: readonly AbiParameter[] }
+      | undefined;
+
+    if (!proposeFunction) {
+      throw new Error('propose function not found in RollupAbi');
+    }
+
+    const attestationsParam = proposeFunction.inputs.find(param => param.name === '_attestations');
+    if (!attestationsParam) {
+      throw new Error('_attestations parameter not found in propose function');
+    }
+
+    const tupleParam = attestationsParam as unknown as { type: 'tuple'; components?: readonly AbiParameter[] };
+    return { type: 'tuple', components: tupleParam.components || [] } as AbiParameter;
   }
 
-  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();
   }
 }