@aztec-labs/archiver 6.0.0-nightly.20260829

package/src/config.ts

@@ -0,0 +1,133 @@
+import { type BlobClientConfig, blobClientConfigMapping } from '@aztec-labs/blob-client/client/config';
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec-labs/ethereum/config';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec-labs/ethereum/l1-reader';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec-labs/foundation/config';
+import { type ChainConfig, type SequencerConfig, chainConfigMappings } from '@aztec-labs/stdlib/config';
+import type { ArchiverSpecificConfig } from '@aztec-labs/stdlib/interfaces/server';
+import { DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE } from '@aztec-labs/stdlib/timetable';
+
+/**
+ * The archiver configuration.
+ * There are 2 polling intervals used in this configuration. The first is the archiver polling interval, archiverPollingIntervalMS.
+ * This is the interval between successive calls to eth_blockNumber via viem.
+ * Results of calls to eth_blockNumber are cached by viem with this cache being updated periodically at the interval specified by viemPollingIntervalMS.
+ * As a result the maximum observed polling time for new blocks will be viemPollingIntervalMS + archiverPollingIntervalMS.
+ */
+export type ArchiverConfig = ArchiverSpecificConfig &
+  L1ReaderConfig &
+  L1ContractsConfig &
+  BlobClientConfig &
+  ChainConfig &
+  Pick<SequencerConfig, 'blockDurationMs' | 'checkpointProposalSyncGraceSeconds'>;
+
+export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
+  ...blobClientConfigMapping,
+  archiverPollingIntervalMS: {
+    env: 'ARCHIVER_POLLING_INTERVAL_MS',
+    description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',
+    ...numberConfigHelper(500),
+  },
+  archiverBatchSize: {
+    env: 'ARCHIVER_BATCH_SIZE',
+    description: 'The number of L2 blocks the archiver will attempt to download at a time.',
+    ...numberConfigHelper(100),
+  },
+  archiverStoreMapSizeKb: {
+    env: 'ARCHIVER_STORE_MAP_SIZE_KB',
+    ...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.',
+    ...numberConfigHelper(300),
+  },
+  ethereumAllowNoDebugHosts: {
+    env: 'ETHEREUM_ALLOW_NO_DEBUG_HOSTS',
+    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),
+  },
+  testPreloadStandardContracts: {
+    env: 'TEST_PRELOAD_STANDARD_CONTRACTS',
+    description:
+      'Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the contract store at ' +
+      'block 0. For test environments only, and only safe when genesis seeds the matching registration/deployment ' +
+      'nullifiers; otherwise a later onchain publish would collide with the block-0 preload.',
+    ...booleanConfigHelper(false),
+  },
+  ...chainConfigMappings,
+  ...l1ReaderConfigMappings,
+  viemPollingIntervalMS: {
+    env: 'ARCHIVER_VIEM_POLLING_INTERVAL_MS',
+    description: 'The polling interval viem uses in ms',
+    ...numberConfigHelper(1000),
+  },
+  ...l1ContractsConfigMappings,
+};
+
+/**
+ * Returns the archiver configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The archiver configuration.
+ */
+export function getArchiverConfigFromEnv(): ArchiverConfig {
+  return getConfigFromMappings<ArchiverConfig>(archiverConfigMappings);
+}
+
+/** Extracts the archiver-specific configuration from the full ArchiverConfig */
+export function mapArchiverConfig(config: Partial<ArchiverConfig>) {
+  return {
+    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

@@ -0,0 +1,211 @@
+import type { BlockNumber, CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import type { Fr } from '@aztec-labs/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';
+  }
+}
+
+export class InitialCheckpointNumberNotSequentialError extends Error {
+  constructor(
+    public readonly newCheckpointNumber: number,
+    public readonly previousCheckpointNumber: number | undefined,
+  ) {
+    super(
+      `Cannot insert new checkpoint ${newCheckpointNumber} given previous checkpoint number in store is ${
+        previousCheckpointNumber ?? 'undefined'
+      }`,
+    );
+    this.name = 'InitialCheckpointNumberNotSequentialError';
+  }
+}
+
+export class CheckpointNumberNotSequentialError extends Error {
+  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 ${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';
+  }
+}
+
+export class BlockIndexNotSequentialError extends Error {
+  constructor(newBlockIndex: number, previousBlockIndex: number | undefined) {
+    super(
+      `Cannot insert new block at checkpoint index ${newBlockIndex} given previous block index is ${previousBlockIndex ?? 'undefined'}`,
+    );
+    this.name = 'BlockIndexNotSequentialError';
+  }
+}
+
+export class BlockArchiveNotConsistentError extends Error {
+  constructor(
+    newBlockNumber: number,
+    previousBlockNumber: number | undefined,
+    newBlockArchive: Fr,
+    previousBlockArchive: Fr,
+  ) {
+    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';
+  }
+}
+
+/** Thrown when a proposed block matches a block that was already checkpointed. This is expected for late proposals. */
+export class BlockAlreadyCheckpointedError extends Error {
+  constructor(public readonly blockNumber: number) {
+    super(`Block ${blockNumber} has already been checkpointed with the same content`);
+    this.name = 'BlockAlreadyCheckpointedError';
+  }
+}
+
+/**
+ * Thrown when a query names an Inbox bucket this archiver has not synced. Distinguishes "not synced yet, retry once
+ * L1 sync catches up" from a genuinely empty result.
+ */
+export class InboxBucketNotSyncedError extends Error {
+  constructor(public readonly bucketSeq: bigint) {
+    super(`Inbox bucket ${bucketSeq} has not been synced`);
+    this.name = 'InboxBucketNotSyncedError';
+  }
+}
+
+/**
+ * Thrown when a cumulative Inbox message count does not resolve to a bucket boundary this archiver has synced, either
+ * because the count sits inside a bucket or because the bucket is not synced yet.
+ */
+export class InboxBucketBoundaryNotSyncedError extends Error {
+  constructor(public readonly totalMsgCount: bigint) {
+    super(`No synced Inbox bucket ends at cumulative message count ${totalMsgCount}`);
+    this.name = 'InboxBucketBoundaryNotSyncedError';
+  }
+}
+
+/** 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(
+    public readonly blockNumber: number,
+    public readonly lastCheckpointedBlock: number,
+  ) {
+    super(
+      `Cannot add block ${blockNumber}: would overwrite checkpointed data (checkpointed up to block ${lastCheckpointedBlock})`,
+    );
+    this.name = 'CannotOverwriteCheckpointedBlockError';
+  }
+}

package/src/factory.ts

@@ -0,0 +1,262 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { makeL1HttpTransport } from '@aztec-labs/ethereum/client';
+import { InboxContract, OutboxContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { pickL1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import type { ViemPublicDebugClient } from '@aztec-labs/ethereum/types';
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { merge } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { createStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { protocolContractNames } from '@aztec-labs/protocol-contracts';
+import { BundledProtocolContractsProvider } from '@aztec-labs/protocol-contracts/providers/bundle';
+import { getPublishableStandardContracts } from '@aztec-labs/standard-contracts';
+import { FunctionType, decodeFunctionSignature } from '@aztec-labs/stdlib/abi';
+import type { ArchiverEmitter, BlockHash } from '@aztec-labs/stdlib/block';
+import { DEFAULT_BLOCK_DURATION_MS } from '@aztec-labs/stdlib/config';
+import { type ContractClassPublicWithCommitment, computePublicBytecodeCommitment } from '@aztec-labs/stdlib/contract';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+import {
+  DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE,
+  getDefaultCheckpointProposalSyncGrace,
+} from '@aztec-labs/stdlib/timetable';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { EventEmitter } from 'events';
+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, 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'> & 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 createArchiverDataStores(store, genesisBlockHash);
+}
+
+/**
+ * Creates a local archiver.
+ * @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, initialBlockHash);
+  await registerProtocolContracts(archiverStore);
+  if (config.testPreloadStandardContracts) {
+    await registerStandardContracts(archiverStore);
+  }
+
+  // Create Ethereum clients
+  const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+  const httpTimeout = config.l1HttpTimeoutMS;
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: httpTimeout }),
+    pollingInterval: config.viemPollingIntervalMS,
+  });
+
+  // Create debug client using debug RPC URLs if available, otherwise fall back to regular RPC URLs
+  const debugRpcUrls = config.l1DebugRpcUrls.length > 0 ? config.l1DebugRpcUrls : config.l1RpcUrls;
+  const debugClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: makeL1HttpTransport(debugRpcUrls, { timeout: httpTimeout }),
+    pollingInterval: config.viemPollingIntervalMS,
+  }) as ViemPublicDebugClient;
+
+  // 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 [
+    l1StartBlock,
+    l1GenesisTime,
+    proofSubmissionEpochs,
+    genesisArchiveRoot,
+    slashingProposerAddress,
+    targetCommitteeSize,
+    rollupManaLimit,
+  ] = await Promise.all([
+    rollup.getL1StartBlock(),
+    rollup.getL1GenesisTime(),
+    rollup.getProofSubmissionEpochs(),
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getSlashingProposerAddress(),
+    rollup.getTargetCommitteeSize(),
+    rollup.getManaLimit(),
+  ] as const);
+
+  const l1StartBlockHash = await publicClient
+    .getBlock({ blockNumber: l1StartBlock, includeTransactions: false })
+    .then(block => Buffer32.fromString(block.hash));
+
+  const { aztecEpochDuration: epochDuration, aztecSlotDuration: slotDuration, ethereumSlotDuration } = config;
+
+  const l1Constants = {
+    l1StartBlockHash,
+    l1StartBlock,
+    l1GenesisTime,
+    epochDuration,
+    slotDuration,
+    ethereumSlotDuration,
+    proofSubmissionEpochs: Number(proofSubmissionEpochs),
+    targetCommitteeSize,
+    genesisArchiveRoot: Fr.fromString(genesisArchiveRoot.toString()),
+    rollupManaLimit: Number(rollupManaLimit),
+  };
+
+  const archiverConfig = merge(
+    {
+      pollingIntervalMs: 10_000,
+      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.rollupAddress, config, deps));
+  const telemetry = deps.telemetry ?? getTelemetryClient();
+  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. 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(
+    publicClient,
+    debugClient,
+    rollup,
+    inbox,
+    archiverStore,
+    archiverConfig,
+    deps.blobClient,
+    epochCache,
+    deps.dateProvider ?? new DateProvider(),
+    instrumentation,
+    l1Constants,
+    events,
+    instrumentation.tracer,
+    l2TipsCache,
+    undefined, // log (use default)
+  );
+
+  const archiver = new Archiver(
+    publicClient,
+    debugClient,
+    rollup,
+    outbox,
+    { ...pickL1ContractAddresses(config), slashingProposerAddress },
+    archiverStore,
+    archiverConfig,
+    deps.blobClient,
+    instrumentation,
+    l1Constants,
+    synchronizer,
+    events,
+    initialHeader,
+    initialBlockHash,
+    l2TipsCache,
+    deps.dateProvider ?? new DateProvider(),
+  );
+
+  await archiver.start(opts.blockUntilSync);
+  return archiver;
+}
+
+/** 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);
+
+    // 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));
+  }
+}
+
+/**
+ * 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/index.ts

@@ -0,0 +1,29 @@
+export * from './factory.js';
+export * from './interfaces.js';
+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 {
+  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 { retrieveL2ProofVerifiedEvents } from './l1/data_retrieval.js';
+export { CalldataRetriever } from './l1/calldata_retriever.js';

package/src/interfaces.ts

@@ -0,0 +1,9 @@
+import type { L2BlockSource } from '@aztec-labs/stdlib/block';
+import type { ContractDataSource } from '@aztec-labs/stdlib/contract';
+import type { L2LogsSource } from '@aztec-labs/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec-labs/stdlib/messaging';
+
+/**
+ * Helper interface to combine all sources this archiver implementation provides.
+ */
+export type ArchiverDataSource = L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource;