@aztec/archiver 0.0.1-commit.343b43af6 → 0.0.1-commit.350e0a4d

package/src/config.ts

@@ -1,15 +1,16 @@
 import { type BlobClientConfig, blobClientConfigMapping } from '@aztec/blob-client/client/config';
 import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
-import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
 import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
-import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import { type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec/stdlib/config';
 import type { ArchiverSpecificConfig } from '@aztec/stdlib/interfaces/server';
+import { DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE } from '@aztec/stdlib/timetable';
 
 /**
  * The archiver configuration.
@@ -22,7 +23,8 @@ export type ArchiverConfig = ArchiverSpecificConfig &
   L1ReaderConfig &
   L1ContractsConfig &
   BlobClientConfig &
-  ChainConfig;
+  ChainConfig &
+  Pick<SequencerConfig, 'blockDurationMs' | 'checkpointProposalSyncGraceSeconds'>;
 
 export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   ...blobClientConfigMapping,
@@ -36,20 +38,31 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'The number of L2 blocks the archiver will attempt to download at a time.',
     ...numberConfigHelper(100),
   },
-  maxLogs: {
-    env: 'ARCHIVER_MAX_LOGS',
-    description: 'The max number of logs that can be obtained in 1 "getPublicLogs" call.',
-    ...numberConfigHelper(1_000),
-  },
   archiverStoreMapSizeKb: {
     env: 'ARCHIVER_STORE_MAP_SIZE_KB',
-    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
+  blockDurationMs: {
+    env: 'SEQ_BLOCK_DURATION_MS',
+    description:
+      'Duration per block in milliseconds when building multiple blocks per slot. Used to derive orphan proposed block pruning timing.',
+    ...optionalNumberConfigHelper(),
+  },
+  checkpointProposalSyncGraceSeconds: {
+    env: 'CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS',
+    description:
+      'Consensus grace in seconds for a received checkpoint proposal to materialize into local proposed state.',
+    ...optionalNumberConfigHelper(),
+  },
   skipValidateCheckpointAttestations: {
     description: 'Skip validating checkpoint attestations (for testing purposes only)',
     ...booleanConfigHelper(false),
   },
+  skipPromoteProposedCheckpointDuringL1Sync: {
+    description: 'Skip promoting proposed checkpoints during L1 sync (for testing purposes only)',
+    ...booleanConfigHelper(false),
+  },
   maxAllowedEthClientDriftSeconds: {
     env: 'MAX_ALLOWED_ETH_CLIENT_DRIFT_SECONDS',
     description: 'Maximum allowed drift in seconds between the Ethereum client and current time.',
@@ -60,6 +73,23 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'Whether to allow starting the archiver without debug/trace method support on Ethereum hosts',
     ...booleanConfigHelper(true),
   },
+  archiverSkipHistoricalLogsCheck: {
+    env: 'ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK',
+    description:
+      'Skip the startup check that probes the L1 RPC for historical Rollup contract logs. ' +
+      'Set to true to bypass the check when the connected RPC node is known to prune old logs.',
+    ...booleanConfigHelper(false),
+  },
+  orphanPruneNoProposalTolerance: {
+    env: 'ARCHIVER_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE',
+    description: 'Local tolerance in seconds before pruning an orphan block when no checkpoint proposal was received.',
+    ...numberConfigHelper(DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE),
+  },
+  skipOrphanProposedBlockPruning: {
+    env: 'ARCHIVER_SKIP_ORPHAN_PROPOSED_BLOCK_PRUNING',
+    description: 'Skip pruning orphan proposed blocks that have no matching proposed checkpoint.',
+    ...booleanConfigHelper(false),
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {
@@ -68,10 +98,6 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     ...numberConfigHelper(1000),
   },
   ...l1ContractsConfigMappings,
-  l1Contracts: {
-    description: 'The deployed L1 contract addresses',
-    nested: l1ContractAddressesMapping,
-  },
 };
 
 /**
@@ -89,7 +115,11 @@ export function mapArchiverConfig(config: Partial<ArchiverConfig>) {
     pollingIntervalMs: config.archiverPollingIntervalMS,
     batchSize: config.archiverBatchSize,
     skipValidateCheckpointAttestations: config.skipValidateCheckpointAttestations,
+    skipPromoteProposedCheckpointDuringL1Sync: config.skipPromoteProposedCheckpointDuringL1Sync,
     maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
     ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts,
+    skipHistoricalLogsCheck: config.archiverSkipHistoricalLogsCheck,
+    orphanPruneNoProposalTolerance: config.orphanPruneNoProposalTolerance,
+    skipOrphanProposedBlockPruning: config.skipOrphanProposedBlockPruning,
   };
 }

package/src/errors.ts

@@ -1,14 +1,17 @@
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/schemas';
 
 export class NoBlobBodiesFoundError extends Error {
   constructor(l2BlockNum: number) {
     super(`No blob bodies found for block ${l2BlockNum}`);
+    this.name = 'NoBlobBodiesFoundError';
   }
 }
 
 export class BlockNumberNotSequentialError extends Error {
   constructor(newBlockNumber: number, previous: number | undefined) {
     super(`Cannot insert new block ${newBlockNumber} given previous block number is ${previous ?? 'undefined'}`);
+    this.name = 'BlockNumberNotSequentialError';
   }
 }
 
@@ -22,14 +25,35 @@ export class InitialCheckpointNumberNotSequentialError extends Error {
         previousCheckpointNumber ?? 'undefined'
       }`,
     );
+    this.name = 'InitialCheckpointNumberNotSequentialError';
   }
 }
 
 export class CheckpointNumberNotSequentialError extends Error {
-  constructor(newCheckpointNumber: number, previous: number | undefined) {
+  constructor(
+    public readonly newCheckpointNumber: CheckpointNumber,
+    public readonly previousCheckpointNumber: CheckpointNumber | undefined,
+    source?: 'proposed' | 'confirmed',
+  ) {
+    const qualifier = source ? `${source} ` : '';
     super(
-      `Cannot insert new checkpoint ${newCheckpointNumber} given previous checkpoint number in batch is ${previous ?? 'undefined'}`,
+      `Cannot insert new checkpoint ${newCheckpointNumber} given previous ${qualifier}checkpoint number is ${previousCheckpointNumber ?? 'undefined'}`,
     );
+    this.name = 'CheckpointNumberNotSequentialError';
+  }
+}
+
+/** Thrown when a proposed block carries a checkpoint number that does not follow the latest one. */
+export class BlockCheckpointNumberNotSequentialError extends Error {
+  constructor(
+    blockNumber: BlockNumber,
+    blockCheckpointNumber: CheckpointNumber,
+    previous: CheckpointNumber | undefined,
+  ) {
+    super(
+      `Cannot insert new block ${blockNumber} for checkpoint ${blockCheckpointNumber} given previous checkpoint number is ${previous ?? 'undefined'}`,
+    );
+    this.name = 'BlockCheckpointNumberNotSequentialError';
   }
 }
 
@@ -38,6 +62,7 @@ export class BlockIndexNotSequentialError extends Error {
     super(
       `Cannot insert new block at checkpoint index ${newBlockIndex} given previous block index is ${previousBlockIndex ?? 'undefined'}`,
     );
+    this.name = 'BlockIndexNotSequentialError';
   }
 }
 
@@ -51,18 +76,21 @@ export class BlockArchiveNotConsistentError extends Error {
     super(
       `Cannot insert new block number ${newBlockNumber} with archive ${newBlockArchive.toString()} previous block number is ${previousBlockNumber ?? 'undefined'}, previous archive is ${previousBlockArchive?.toString() ?? 'undefined'}`,
     );
+    this.name = 'BlockArchiveNotConsistentError';
   }
 }
 
 export class CheckpointNotFoundError extends Error {
   constructor(checkpointNumber: number) {
     super(`Failed to find expected checkpoint number ${checkpointNumber}`);
+    this.name = 'CheckpointNotFoundError';
   }
 }
 
 export class BlockNotFoundError extends Error {
   constructor(blockNumber: number) {
     super(`Failed to find expected block number ${blockNumber}`);
+    this.name = 'BlockNotFoundError';
   }
 }
 
@@ -74,6 +102,93 @@ export class BlockAlreadyCheckpointedError extends Error {
   }
 }
 
+/** Thrown when L1 to L2 messages are requested for a checkpoint whose message tree hasn't been sealed yet. */
+export class L1ToL2MessagesNotReadyError extends Error {
+  constructor(
+    public readonly checkpointNumber: number,
+    public readonly inboxTreeInProgress: bigint,
+  ) {
+    super(
+      `Cannot get L1 to L2 messages for checkpoint ${checkpointNumber}: ` +
+        `inbox tree in progress is ${inboxTreeInProgress}, messages not yet sealed`,
+    );
+    this.name = 'L1ToL2MessagesNotReadyError';
+  }
+}
+
+/** Thrown when a proposed checkpoint number is stale (already processed). */
+export class ProposedCheckpointStaleError extends Error {
+  constructor(
+    public readonly proposedCheckpointNumber: number,
+    public readonly currentProposedNumber: number,
+  ) {
+    super(`Stale proposed checkpoint ${proposedCheckpointNumber}: current proposed is ${currentProposedNumber}`);
+    this.name = 'ProposedCheckpointStaleError';
+  }
+}
+
+/** Thrown when a proposed checkpoint number is not the expected latestTip + 1. */
+export class ProposedCheckpointNotSequentialError extends Error {
+  constructor(
+    public readonly proposedCheckpointNumber: number,
+    public readonly latestTipNumber: number,
+  ) {
+    super(
+      `Proposed checkpoint ${proposedCheckpointNumber} is not sequential: expected ${latestTipNumber + 1} (latest tip + 1, where tip is highest of confirmed or pending)`,
+    );
+    this.name = 'ProposedCheckpointNotSequentialError';
+  }
+}
+
+/** Thrown when a proposed checkpoint or block L2 slot has already expired on L1. */
+export class BlockOrCheckpointSlotExpiredError extends Error {
+  constructor(
+    public readonly slot: number,
+    public readonly nextSlotStart: bigint,
+    public readonly l1TimestampSynced: bigint | undefined,
+  ) {
+    super(
+      `Checkpoint or block for slot ${slot} is expired: L1 synced to ${l1TimestampSynced} which is past the next slot start ${nextSlotStart}. ` +
+        `If the checkpoint still lands via a late L1 tx, the archiver will pick it up via normal L1-sync (not the pending-queue shortcut).`,
+    );
+    this.name = 'BlockOrCheckpointSlotExpiredError';
+  }
+}
+
+/** Thrown when attempting to promote a proposed checkpoint but no proposed checkpoint exists in the store. */
+export class NoProposedCheckpointToPromoteError extends Error {
+  constructor() {
+    super('Cannot promote proposed checkpoint: no proposed checkpoint exists');
+    this.name = 'NoProposedCheckpointToPromoteError';
+  }
+}
+
+/** Thrown when the archive root of the proposed checkpoint does not match the expected one. */
+export class ProposedCheckpointArchiveRootMismatchError extends Error {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super(
+      `Cannot promote proposed checkpoint: archive root mismatch (expected ${expectedArchiveRoot}, got ${actualArchiveRoot})`,
+    );
+    this.name = 'ProposedCheckpointArchiveRootMismatchError';
+  }
+}
+
+/** Thrown when the proposed checkpoint does not directly follow the latest confirmed checkpoint. */
+export class ProposedCheckpointPromotionNotSequentialError extends Error {
+  constructor(
+    public readonly proposedCheckpointNumber: number,
+    public readonly latestCheckpointNumber: number,
+  ) {
+    super(
+      `Cannot promote proposed checkpoint: not sequential (latest ${latestCheckpointNumber}, proposed ${proposedCheckpointNumber})`,
+    );
+    this.name = 'ProposedCheckpointPromotionNotSequentialError';
+  }
+}
+
 /** Thrown when a proposed block conflicts with an already checkpointed block (different content). */
 export class CannotOverwriteCheckpointedBlockError extends Error {
   constructor(

package/src/factory.ts

@@ -1,6 +1,8 @@
 import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
-import { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import { makeL1HttpTransport } from '@aztec/ethereum/client';
+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';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -11,33 +13,40 @@ import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
-import type { ArchiverEmitter } from '@aztec/stdlib/block';
-import { type ContractClassPublic, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+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 {
+  DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE,
+  getDefaultCheckpointProposalSyncGrace,
+} from '@aztec/stdlib/timetable';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { EventEmitter } from 'events';
-import { createPublicClient, fallback, http } from 'viem';
+import { createPublicClient } from 'viem';
 
 import { Archiver, type ArchiverDeps } from './archiver.js';
 import { type ArchiverConfig, mapArchiverConfig } from './config.js';
 import { ArchiverInstrumentation } from './modules/instrumentation.js';
 import { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
-import { ARCHIVER_DB_VERSION, KVArchiverDataStore } from './store/kv_archiver_store.js';
+import { ARCHIVER_DB_VERSION, type ArchiverDataStores, createArchiverDataStores } from './store/data_stores.js';
 import { L2TipsCache } from './store/l2_tips_cache.js';
 
 export const ARCHIVER_STORE_NAME = 'archiver';
 
 /** Creates an archiver store. */
 export async function createArchiverStore(
-  userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
-) {
+  userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb'> & DataStoreConfig,
+  genesisBlockHash: BlockHash,
+): Promise<ArchiverDataStores> {
   const config = {
     ...userConfig,
     dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
   const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config);
-  return new KVArchiverDataStore(store, config.maxLogs);
+  return createArchiverDataStores(store, genesisBlockHash);
 }
 
 /**
@@ -45,21 +54,27 @@ export async function createArchiverStore(
  * @param config - The archiver configuration.
  * @param deps - The archiver dependencies (blobClient, epochCache, dateProvider, telemetry).
  * @param opts - The options.
+ * @param initialHeader - The genesis block header from world-state, used to answer block-0 queries.
+ * @param initialBlockHash - Precomputed hash of `initialHeader`. Hoisted to the caller so the archiver
+ * can expose `getGenesisBlockHash()` synchronously.
  * @returns The local archiver.
  */
 export async function createArchiver(
   config: ArchiverConfig & DataStoreConfig,
   deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
+  initialHeader: BlockHeader,
+  initialBlockHash: BlockHash,
 ): Promise<Archiver> {
-  const archiverStore = await createArchiverStore(config);
+  const archiverStore = await createArchiverStore(config, initialBlockHash);
   await registerProtocolContracts(archiverStore);
 
   // Create Ethereum clients
   const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+  const httpTimeout = config.l1HttpTimeoutMS;
   const publicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(config.l1RpcUrls.map(url => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: httpTimeout }),
     pollingInterval: config.viemPollingIntervalMS,
   });
 
@@ -67,13 +82,14 @@ export async function createArchiver(
   const debugRpcUrls = config.l1DebugRpcUrls.length > 0 ? config.l1DebugRpcUrls : config.l1RpcUrls;
   const debugClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(debugRpcUrls.map(url => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(debugRpcUrls, { timeout: httpTimeout }),
     pollingInterval: config.viemPollingIntervalMS,
   }) as ViemPublicDebugClient;
 
   // Create L1 contract instances
-  const rollup = new RollupContract(publicClient, config.l1Contracts.rollupAddress);
-  const inbox = new InboxContract(publicClient, config.l1Contracts.inboxAddress);
+  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 [
@@ -119,19 +135,28 @@ export async function createArchiver(
       batchSize: 100,
       maxAllowedEthClientDriftSeconds: 300,
       ethereumAllowNoDebugHosts: false,
+      skipHistoricalLogsCheck: false,
+      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),
   );
 
-  const epochCache = deps.epochCache ?? (await EpochCache.create(config.l1Contracts.rollupAddress, config, deps));
+  const epochCache = deps.epochCache ?? (await EpochCache.create(config.rollupAddress, config, deps));
   const telemetry = deps.telemetry ?? getTelemetryClient();
-  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => archiverStore.estimateSize());
+  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => archiverStore.db.estimateSize());
 
   // Create the event emitter that will be shared by archiver and synchronizer
   const events = new EventEmitter() as ArchiverEmitter;
 
-  // Create L2 tips cache shared by archiver and synchronizer
-  const l2TipsCache = new L2TipsCache(archiverStore.blockStore);
+  // Create L2 tips cache shared by archiver and synchronizer. The genesis block hash is dynamic —
+  // it depends on the injected initial header (genesisTimestamp + prefilled state). Hoisted to the
+  // caller so we can pass the same value to the archiver and expose it via `getGenesisBlockHash()`.
+  const l2TipsCache = new L2TipsCache(archiverStore.blocks, initialBlockHash);
 
   // Create the L1 synchronizer
   const synchronizer = new ArchiverL1Synchronizer(
@@ -156,7 +181,8 @@ export async function createArchiver(
     publicClient,
     debugClient,
     rollup,
-    { ...config.l1Contracts, slashingProposerAddress },
+    outbox,
+    { ...pickL1ContractAddresses(config), slashingProposerAddress },
     archiverStore,
     archiverConfig,
     deps.blobClient,
@@ -164,32 +190,40 @@ export async function createArchiver(
     l1Constants,
     synchronizer,
     events,
+    initialHeader,
+    initialBlockHash,
     l2TipsCache,
+    deps.dateProvider ?? new DateProvider(),
   );
 
   await archiver.start(opts.blockUntilSync);
   return archiver;
 }
 
-/** Registers protocol contracts in the archiver store. */
-export async function registerProtocolContracts(store: KVArchiverDataStore) {
+/** Registers protocol contracts in the archiver store. Idempotent — skips contracts that already exist (e.g. on node restart). */
+export async function registerProtocolContracts(stores: ArchiverDataStores) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const provider = new BundledProtocolContractsProvider();
     const contract = await provider.getProtocolContractArtifact(name);
-    const contractClassPublic: ContractClassPublic = {
+
+    // 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,
-      privateFunctions: [],
-      utilityFunctions: [],
+      publicBytecodeCommitment,
     };
 
     const publicFunctionSignatures = contract.artifact.functions
       .filter(fn => fn.functionType === FunctionType.PUBLIC)
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
-    await store.registerContractFunctionSignatures(publicFunctionSignatures);
-    const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
-    await store.addContractClasses([contractClassPublic], [bytecodeCommitment], BlockNumber(blockNumber));
-    await store.addContractInstances([contract.instance], BlockNumber(blockNumber));
+    await stores.functionNames.register(publicFunctionSignatures);
+    await stores.contractClasses.addContractClasses([contractClassPublic], BlockNumber(blockNumber));
+    await stores.contractInstances.addContractInstances([contract.instance], BlockNumber(blockNumber));
   }
 }

package/src/index.ts

@@ -4,10 +4,26 @@ export * from './archiver.js';
 export * from './modules/data_source_base.js';
 export * from './modules/data_store_updater.js';
 export * from './config.js';
+export * from './errors.js';
 
 export { type L1PublishedData } from './structs/published.js';
-export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './store/kv_archiver_store.js';
+export {
+  ARCHIVER_DB_VERSION,
+  type ArchiverDataStores,
+  type ArchiverL1SynchPoint,
+  backupArchiverDataStores,
+  createArchiverDataStores,
+  createContractDataSource,
+  getArchiverSynchPoint,
+} from './store/data_stores.js';
+export { FunctionNamesCache } from './store/function_names_cache.js';
+export { ArchiverContractDataSourceAdapter } from './modules/contract_data_source_adapter.js';
+export { BlockStore } from './store/block_store.js';
+export { LogStore } from './store/log_store.js';
+export { MessageStore } from './store/message_store.js';
+export { ContractClassStore } from './store/contract_class_store.js';
 export { ContractInstanceStore } from './store/contract_instance_store.js';
 export { L2TipsCache } from './store/l2_tips_cache.js';
 
-export { retrieveCheckpointsFromRollup, retrieveL2ProofVerifiedEvents } from './l1/data_retrieval.js';
+export { retrieveL2ProofVerifiedEvents } from './l1/data_retrieval.js';
+export { CalldataRetriever } from './l1/calldata_retriever.js';

package/src/l1/calldata_retriever.ts

@@ -1,12 +1,13 @@
 import { MULTI_CALL_3_ADDRESS, type ViemCommitteeAttestations, type ViemHeader } from '@aztec/ethereum/contracts';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { LruSet } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
 import { CommitteeAttestation } from '@aztec/stdlib/block';
-import { ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
+import { computeCheckpointPayloadDigest } from '@aztec/stdlib/checkpoint';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 
 import {
@@ -33,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;
 };
@@ -44,7 +51,7 @@ type CheckpointData = {
  */
 export class CalldataRetriever {
   /** Tx hashes we've already logged for trace+debug failure (log once per tx per process). */
-  private static readonly traceFailureWarnedTxHashes = new Set<string>();
+  private static readonly traceFailureWarnedTxHashes = new LruSet<string>(1000);
 
   /** Clears the trace-failure warned set. For testing only. */
   static resetTraceFailureWarnedForTesting(): void {
@@ -60,6 +67,13 @@ export class CalldataRetriever {
     private readonly rollupAddress: EthAddress,
   ) {}
 
+  private getSignatureContext() {
+    return {
+      chainId: this.publicClient.chain.id,
+      rollupAddress: this.rollupAddress,
+    };
+  }
+
   /**
    * Gets checkpoint header and metadata from the calldata of an L1 transaction.
    * Tries multicall3 decoding, falls back to trace-based extraction.
@@ -398,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)),
@@ -433,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,
@@ -441,7 +455,7 @@ export class CalldataRetriever {
         header: decodedArgs.header,
         l1BlockHash: blockHash,
         attestations,
-        packedAttestations,
+        verbatimAttestations,
         targetCommitteeSize: this.targetCommitteeSize,
       });
 
@@ -450,6 +464,7 @@ export class CalldataRetriever {
         archiveRoot,
         header,
         attestations,
+        verbatimAttestations,
         blockHash,
         feeAssetPriceModifier,
       };
@@ -459,15 +474,18 @@ 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. */
   private computePayloadDigest(header: CheckpointHeader, archiveRoot: Fr, feeAssetPriceModifier: bigint): Hex {
-    const consensusPayload = new ConsensusPayload(header, archiveRoot, feeAssetPriceModifier);
-    const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
-    return keccak256(payloadToSign);
+    return computeCheckpointPayloadDigest({
+      header,
+      archiveRoot,
+      feeAssetPriceModifier,
+      signatureContext: this.getSignatureContext(),
+    }).toString();
   }
 
   /**