@aztec/archiver 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/factory.ts

@@ -1,7 +1,7 @@
 import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { makeL1HttpTransport } from '@aztec/ethereum/client';
-import { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import { InboxContract, OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
 import { pickL1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import type { ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { BlockNumber } from '@aztec/foundation/branded-types';
@@ -12,11 +12,16 @@ import { DateProvider } from '@aztec/foundation/timer';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { getPublishableStandardContracts } from '@aztec/standard-contracts';
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter, BlockHash } from '@aztec/stdlib/block';
+import { DEFAULT_BLOCK_DURATION_MS } from '@aztec/stdlib/config';
 import { type ContractClassPublicWithCommitment, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
-import { MIN_EXECUTION_TIME } from '@aztec/stdlib/timetable';
+import {
+  DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE,
+  getDefaultCheckpointProposalSyncGrace,
+} from '@aztec/stdlib/timetable';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
@@ -64,6 +69,9 @@ export async function createArchiver(
 ): Promise<Archiver> {
   const archiverStore = await createArchiverStore(config, initialBlockHash);
   await registerProtocolContracts(archiverStore);
+  if (config.testPreloadStandardContracts) {
+    await registerStandardContracts(archiverStore);
+  }
 
   // Create Ethereum clients
   const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
@@ -85,6 +93,7 @@ export async function createArchiver(
   // Create L1 contract instances
   const rollup = new RollupContract(publicClient, config.rollupAddress);
   const inbox = new InboxContract(publicClient, config.inboxAddress);
+  const outbox = new OutboxContract(publicClient, config.outboxAddress);
 
   // Fetch L1 constants from rollup contract
   const [
@@ -131,7 +140,12 @@ export async function createArchiver(
       maxAllowedEthClientDriftSeconds: 300,
       ethereumAllowNoDebugHosts: false,
       skipHistoricalLogsCheck: false,
-      orphanProposedBlockPruneGraceSeconds: MIN_EXECUTION_TIME,
+      checkpointProposalSyncGrace:
+        config.checkpointProposalSyncGraceSeconds ??
+        getDefaultCheckpointProposalSyncGrace((config.blockDurationMs ?? DEFAULT_BLOCK_DURATION_MS) / 1000),
+      orphanPruneNoProposalTolerance: DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE,
+      skipOrphanProposedBlockPruning: false,
+      blockDuration: (config.blockDurationMs ?? DEFAULT_BLOCK_DURATION_MS) / 1000,
     },
     mapArchiverConfig(config),
   );
@@ -171,6 +185,7 @@ export async function createArchiver(
     publicClient,
     debugClient,
     rollup,
+    outbox,
     { ...pickL1ContractAddresses(config), slashingProposerAddress },
     archiverStore,
     archiverConfig,
@@ -182,7 +197,6 @@ export async function createArchiver(
     initialHeader,
     initialBlockHash,
     l2TipsCache,
-    epochCache,
     deps.dateProvider ?? new DateProvider(),
   );
 
@@ -217,3 +231,33 @@ export async function registerProtocolContracts(stores: ArchiverDataStores) {
     await stores.contractInstances.addContractInstances([contract.instance], BlockNumber(blockNumber));
   }
 }
+
+/**
+ * Preloads the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the archiver store at block 0,
+ * mirroring {@link registerProtocolContracts}. Only invoked for test environments (via `testPreloadStandardContracts`),
+ * which also seed the matching registration/deployment nullifiers into the genesis nullifier tree so the store and tree
+ * stay consistent. Idempotent — skips contracts that already exist (e.g. on node restart).
+ */
+export async function registerStandardContracts(stores: ArchiverDataStores) {
+  const blockNumber = 0;
+  for (const contract of await getPublishableStandardContracts()) {
+    // Skip if already registered (happens on node restart with a persisted store).
+    if (await stores.contractClasses.getContractClass(contract.contractClass.id)) {
+      continue;
+    }
+
+    const publicBytecodeCommitment = await computePublicBytecodeCommitment(contract.contractClass.packedBytecode);
+    const contractClassPublic: ContractClassPublicWithCommitment = {
+      ...contract.contractClass,
+      publicBytecodeCommitment,
+    };
+
+    const publicFunctionSignatures = contract.artifact.functions
+      .filter(fn => fn.functionType === FunctionType.PUBLIC)
+      .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
+
+    await stores.functionNames.register(publicFunctionSignatures);
+    await stores.contractClasses.addContractClasses([contractClassPublic], BlockNumber(blockNumber));
+    await stores.contractInstances.addContractInstances([contract.instance], BlockNumber(blockNumber));
+  }
+}

package/src/l1/calldata_retriever.ts

@@ -34,6 +34,12 @@ type CheckpointData = {
   archiveRoot: Fr;
   header: CheckpointHeader;
   attestations: CommitteeAttestation[];
+  /**
+   * The exact packed `CommitteeAttestations` tuple as it appears in the propose calldata, preserved
+   * verbatim (never re-derived from {@link attestations}) so invalidation evidence stays byte-faithful to
+   * the on-chain `attestationsHash`.
+   */
+  verbatimAttestations: ViemCommitteeAttestations;
   blockHash: string;
   feeAssetPriceModifier: bigint;
 };
@@ -406,14 +412,14 @@ export class CalldataRetriever {
         return undefined;
       }
 
-      const [decodedArgs, packedAttestations] = args! as readonly [
+      const [decodedArgs, verbatimAttestations] = args! as readonly [
         { archive: Hex; oracleInput: { feeAssetPriceModifier: bigint }; header: ViemHeader },
         ViemCommitteeAttestations,
         ...unknown[],
       ];
 
       // Verify attestationsHash
-      const computedAttestationsHash = this.computeAttestationsHash(packedAttestations);
+      const computedAttestationsHash = this.computeAttestationsHash(verbatimAttestations);
       if (
         !Buffer.from(hexToBytes(computedAttestationsHash)).equals(
           Buffer.from(hexToBytes(expectedHashes.attestationsHash)),
@@ -441,7 +447,7 @@ export class CalldataRetriever {
         return undefined;
       }
 
-      const attestations = CommitteeAttestation.fromPacked(packedAttestations, this.targetCommitteeSize);
+      const attestations = CommitteeAttestation.fromPacked(verbatimAttestations, this.targetCommitteeSize);
 
       this.logger.trace(`Validated and decoded propose calldata for checkpoint ${checkpointNumber}`, {
         checkpointNumber,
@@ -449,7 +455,7 @@ export class CalldataRetriever {
         header: decodedArgs.header,
         l1BlockHash: blockHash,
         attestations,
-        packedAttestations,
+        verbatimAttestations,
         targetCommitteeSize: this.targetCommitteeSize,
       });
 
@@ -458,6 +464,7 @@ export class CalldataRetriever {
         archiveRoot,
         header,
         attestations,
+        verbatimAttestations,
         blockHash,
         feeAssetPriceModifier,
       };
@@ -467,8 +474,8 @@ export class CalldataRetriever {
   }
 
   /** Computes the keccak256 hash of ABI-encoded CommitteeAttestations. */
-  private computeAttestationsHash(packedAttestations: ViemCommitteeAttestations): Hex {
-    return keccak256(encodeAbiParameters([this.getCommitteeAttestationsStructDef()], [packedAttestations]));
+  private computeAttestationsHash(verbatimAttestations: ViemCommitteeAttestations): Hex {
+    return keccak256(encodeAbiParameters([this.getCommitteeAttestationsStructDef()], [verbatimAttestations]));
   }
 
   /** Computes the keccak256 payload digest from the checkpoint header, archive root, and fee asset price modifier. */

package/src/l1/data_retrieval.ts

@@ -12,6 +12,8 @@ import type {
   InboxContract,
   MessageSentLog,
   RollupContract,
+  ViemCommitteeAttestations,
+  ViemHeader,
 } from '@aztec/ethereum/contracts';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { asyncPool } from '@aztec/foundation/async-pool';
@@ -55,6 +57,11 @@ export type RetrievedCheckpointFromCalldata = RetrievedCheckpointBase & {
   blobHashes: Buffer[];
   /** Parent beacon block root from the L1 block, used for blob fetching. */
   parentBeaconBlockRoot: string | undefined;
+  /**
+   * The exact packed `CommitteeAttestations` tuple from the propose calldata, carried verbatim so that
+   * attestation validation can attach byte-faithful invalidation evidence to a negative result.
+   */
+  verbatimAttestations: ViemCommitteeAttestations;
 };
 
 export async function retrievedToPublishedCheckpoint({
@@ -460,7 +467,7 @@ export async function getProofFromSubmitProofTx(
         start: bigint;
         end: bigint;
         args: EpochProofPublicInputArgs;
-        fees: readonly Hex[];
+        headers: readonly ViemHeader[];
         proof: Hex;
       },
     ];

package/src/modules/contract_data_source_adapter.ts

@@ -28,16 +28,7 @@ export class ArchiverContractDataSourceAdapter implements ContractDataSource {
     return this.stores.contractClasses.getBytecodeCommitment(id);
   }
 
-  public async getContract(
-    address: AztecAddress,
-    maybeTimestamp?: UInt64,
-  ): Promise<ContractInstanceWithAddress | undefined> {
-    let timestamp = maybeTimestamp;
-    if (timestamp === undefined) {
-      const latest = await this.stores.blocks.getLatestL2BlockNumber();
-      const blockData = latest > 0 ? await this.stores.blocks.getBlockData({ number: latest }) : undefined;
-      timestamp = blockData ? blockData.header.globalVariables.timestamp : 0n;
-    }
+  public getContract(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined> {
     return this.stores.contractInstances.getContractInstance(address, timestamp);
   }
 

package/src/modules/data_source_base.ts

@@ -40,9 +40,9 @@ import {
 } from '@aztec/stdlib/epoch-helpers';
 import type { L2LogsSource } from '@aztec/stdlib/interfaces/server';
 import type { LogResult, PrivateLogsQuery, PublicLogsQuery } from '@aztec/stdlib/logs';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { L1ToL2MessageSource, L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import type { BlockHeader, IndexedTxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import type { BlockHeader, IndexedTxEffect, TxHash } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
 import type { ArchiverDataSource } from '../interfaces.js';
@@ -149,6 +149,12 @@ export abstract class ArchiverDataSourceBase
 
   abstract syncImmediate(): Promise<void>;
 
+  abstract getL2ToL1MembershipWitness(
+    txHash: TxHash,
+    message: Fr,
+    messageIndexInTx?: number,
+  ): Promise<L2ToL1MembershipWitness | undefined>;
+
   public async isPruneDueAtSlot(slot: SlotNumber): Promise<boolean> {
     if (!this.l1Constants) {
       throw new Error('isPruneDueAtSlot requires l1Constants');
@@ -218,23 +224,6 @@ export abstract class ArchiverDataSourceBase
     }
   }
 
-  /**
-   * Resolves a {@link CheckpointsQuery} to a concrete `{from, limit}` pair used by BlockStore,
-   * or undefined when the epoch has no checkpoints.
-   */
-  private async resolveCheckpointsQuery(
-    query: CheckpointsQuery,
-  ): Promise<{ from: CheckpointNumber; limit: number } | undefined> {
-    if ('from' in query) {
-      return query;
-    }
-    const numbers = await this.getCheckpointNumbersForEpoch(query.epoch);
-    if (numbers.length === 0) {
-      return undefined;
-    }
-    return { from: numbers[0], limit: numbers.length };
-  }
-
   public async getCheckpoint(query: CheckpointQuery): Promise<PublishedCheckpoint | undefined> {
     const number = await this.resolveCheckpointQuery(query);
     if (number === undefined || number === 0) {
@@ -248,11 +237,7 @@ export abstract class ArchiverDataSourceBase
   }
 
   public async getCheckpoints(query: CheckpointsQuery): Promise<PublishedCheckpoint[]> {
-    const resolved = await this.resolveCheckpointsQuery(query);
-    if (!resolved) {
-      return [];
-    }
-    const checkpoints = await this.stores.blocks.getRangeOfCheckpoints(resolved.from, resolved.limit);
+    const checkpoints = await this.getCheckpointsData(query);
     return Promise.all(checkpoints.map(ch => this.getPublishedCheckpointFromCheckpointData(ch)));
   }
 
@@ -265,11 +250,14 @@ export abstract class ArchiverDataSourceBase
   }
 
   public async getCheckpointsData(query: CheckpointsQuery): Promise<CheckpointData[]> {
-    const resolved = await this.resolveCheckpointsQuery(query);
-    if (!resolved) {
-      return [];
+    if ('fromSlot' in query) {
+      return this.stores.blocks.getCheckpointsBySlot(query.fromSlot, query.limit, query.reverse ?? false);
     }
-    return this.stores.blocks.getRangeOfCheckpoints(resolved.from, resolved.limit);
+    if ('from' in query) {
+      return this.stores.blocks.getRangeOfCheckpoints(query.from, query.limit);
+    }
+    const numbers = await this.getCheckpointNumbersForEpoch(query.epoch);
+    return numbers.length > 0 ? this.stores.blocks.getRangeOfCheckpoints(numbers[0], numbers.length) : [];
   }
 
   public getProposedCheckpointData(query?: ProposedCheckpointQuery): Promise<ProposedCheckpointData | undefined> {
@@ -286,10 +274,6 @@ export abstract class ArchiverDataSourceBase
     return this.stores.blocks.getTxEffect(txHash);
   }
 
-  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    return this.stores.blocks.getSettledTxReceipt(txHash, this.l1Constants);
-  }
-
   public isPendingChainInvalid(): Promise<boolean> {
     return this.getPendingChainValidationStatus().then(status => !status.valid);
   }
@@ -314,18 +298,7 @@ export abstract class ArchiverDataSourceBase
     return this.stores.contractClasses.getBytecodeCommitment(id);
   }
 
-  public async getContract(
-    address: AztecAddress,
-    maybeTimestamp?: UInt64,
-  ): Promise<ContractInstanceWithAddress | undefined> {
-    let timestamp;
-    if (maybeTimestamp === undefined) {
-      const latestBlockData = await this.getBlockData({ tag: 'proposed' });
-      timestamp = latestBlockData ? latestBlockData.header.globalVariables.timestamp : 0n;
-    } else {
-      timestamp = maybeTimestamp;
-    }
-
+  public getContract(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined> {
     return this.stores.contractInstances.getContractInstance(address, timestamp);
   }
 

package/src/modules/data_store_updater.ts

@@ -114,10 +114,11 @@ export class ArchiverDataStoreUpdater {
       // Before adding checkpoints, check for conflicts with local blocks if any
       const { prunedBlocks, lastAlreadyInsertedBlockNumber } = await this.pruneMismatchingLocalBlocks(checkpoints);
 
-      await this.stores.blocks.addCheckpoints(checkpoints);
+      const insertedCheckpoints = await this.stores.blocks.addCheckpoints(checkpoints);
 
-      // Filter out blocks that were already inserted via addProposedBlock() to avoid duplicating logs/contract data
-      const newBlocks = checkpoints
+      // Skip blocks already inserted via addProposedBlock() and blocks of already-stored checkpoints
+      // re-included by an L1 reorg: their logs/contract data were extracted when first inserted.
+      const newBlocks = insertedCheckpoints
         .flatMap((ch: PublishedCheckpoint) => ch.checkpoint.blocks)
         .filter(b => lastAlreadyInsertedBlockNumber === undefined || b.number > lastAlreadyInsertedBlockNumber);
 

package/src/modules/instrumentation.ts

@@ -84,7 +84,9 @@ export class ArchiverInstrumentation {
 
     this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION);
 
-    this.pruneCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_PRUNE_COUNT);
+    this.pruneCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_PRUNE_COUNT, {
+      [Attributes.PRUNE_TYPE]: ['unproven', 'uncheckpointed', 'l1_conflict', 'orphan', 'l1_mismatch'],
+    });
 
     this.blockProposalTxTargetCount = createUpDownCounterWithDefault(
       meter,
@@ -150,10 +152,21 @@ export class ArchiverInstrumentation {
   }
 
   public processPrune(duration: number) {
-    this.pruneCount.add(1);
+    this.pruneCount.add(1, { [Attributes.PRUNE_TYPE]: 'unproven' });
     this.pruneDuration.record(Math.ceil(duration));
   }
 
+  /**
+   * Records a pending-chain reorg, where the archiver dropped proposed blocks (and world-state follows by pruning). The
+   * type distinguishes the cause: 'uncheckpointed' (slot ended without a checkpoint), 'l1_conflict' (proposed blocks
+   * conflicting with an L1 checkpoint), 'orphan' (no matching proposed checkpoint arrived before the deadline), or
+   * 'l1_mismatch' (the local checkpointed tip diverged from L1 — an L1 reorg or a pruned/missed-proof checkpoint — so
+   * already-checkpointed blocks were rewound).
+   */
+  public recordPrune(pruneType: 'uncheckpointed' | 'l1_conflict' | 'orphan' | 'l1_mismatch') {
+    this.pruneCount.add(1, { [Attributes.PRUNE_TYPE]: pruneType });
+  }
+
   public updateLastProvenCheckpoint(checkpoint: CheckpointData) {
     const lastBlockNumberInCheckpoint = checkpoint.startBlock + checkpoint.blockCount - 1;
     this.blockHeight.record(lastBlockNumberInCheckpoint, { [Attributes.STATUS]: 'proven' });