@aztec/archiver 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/src/archiver.ts

@@ -0,0 +1,443 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { EpochCache } from '@aztec/epoch-cache';
+import { BlockTagTooOldError, RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { merge } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type PromiseWithResolvers, promiseWithResolvers } from '@aztec/foundation/promise';
+import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/running-promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import {
+  type ArchiverEmitter,
+  L2Block,
+  type L2BlockSink,
+  type L2Tips,
+  type ValidateCheckpointResult,
+} from '@aztec/stdlib/block';
+import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import {
+  type L1RollupConstants,
+  getEpochNumberAtTimestamp,
+  getSlotAtNextL1Block,
+  getSlotAtTimestamp,
+  getSlotRangeForEpoch,
+  getTimestampRangeForEpoch,
+} from '@aztec/stdlib/epoch-helpers';
+import { type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+
+import { type ArchiverConfig, mapArchiverConfig } from './config.js';
+import { NoBlobBodiesFoundError } from './errors.js';
+import { validateAndLogTraceAvailability } from './l1/validate_trace.js';
+import { ArchiverDataSourceBase } from './modules/data_source_base.js';
+import { ArchiverDataStoreUpdater } from './modules/data_store_updater.js';
+import type { ArchiverInstrumentation } from './modules/instrumentation.js';
+import type { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
+import type { KVArchiverDataStore } from './store/kv_archiver_store.js';
+import { L2TipsCache } from './store/l2_tips_cache.js';
+
+/** Export ArchiverEmitter for use in factory and tests. */
+export type { ArchiverEmitter };
+
+/** Request to add a block to the archiver, queued for processing by the sync loop. */
+type AddBlockRequest = {
+  block: L2Block;
+  resolve: () => void;
+  reject: (err: Error) => void;
+};
+
+export type ArchiverDeps = {
+  telemetry?: TelemetryClient;
+  blobClient: BlobClientInterface;
+  epochCache?: EpochCache;
+  dateProvider?: DateProvider;
+};
+
+/**
+ * Pulls checkpoints in a non-blocking manner and provides interface for their retrieval.
+ * Responsible for handling robust L1 polling so that other components do not need to
+ * concern themselves with it.
+ */
+export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Traceable {
+  /** Event emitter for archiver events (L2BlockProven, L2PruneUnproven, L2PruneUncheckpointed, etc). */
+  public readonly events: ArchiverEmitter;
+
+  /** A loop in which we will be continually fetching new checkpoints. */
+  protected runningPromise: RunningPromise;
+
+  /** L1 synchronizer that handles fetching checkpoints and messages from L1. */
+  private readonly synchronizer: ArchiverL1Synchronizer;
+
+  private initialSyncComplete: boolean = false;
+  private initialSyncPromise: PromiseWithResolvers<void>;
+
+  /** Queue of blocks to be added to the store, processed by the sync loop. */
+  private blockQueue: AddBlockRequest[] = [];
+
+  /** Helper to handle updates to the store */
+  private readonly updater: ArchiverDataStoreUpdater;
+
+  /** In-memory cache for L2 chain tips. */
+  private readonly l2TipsCache: L2TipsCache;
+
+  public readonly tracer: Tracer;
+
+  /**
+   * Creates a new instance of the Archiver.
+   * @param publicClient - A client for interacting with the Ethereum node.
+   * @param debugClient - A client for interacting with the Ethereum node for debug/trace methods.
+   * @param rollup - Rollup contract instance.
+   * @param inbox - Inbox contract instance.
+   * @param l1Addresses - L1 contract addresses (registry, governance proposer, slash factory, slashing proposer).
+   * @param dataStore - An archiver data store for storage & retrieval of blocks, encrypted logs & contract data.
+   * @param config - Archiver configuration options.
+   * @param blobClient - Client for retrieving blob data.
+   * @param epochCache - Cache for epoch-related data.
+   * @param dateProvider - Provider for current date/time.
+   * @param instrumentation - Instrumentation for metrics and tracing.
+   * @param l1Constants - L1 rollup constants.
+   * @param log - A logger.
+   */
+  constructor(
+    private readonly publicClient: ViemPublicClient,
+    private readonly debugClient: ViemPublicDebugClient,
+    private readonly rollup: RollupContract,
+    private readonly l1Addresses: Pick<
+      L1ContractAddresses,
+      'registryAddress' | 'governanceProposerAddress' | 'slashFactoryAddress'
+    > & { slashingProposerAddress: EthAddress },
+    readonly dataStore: KVArchiverDataStore,
+    private config: {
+      pollingIntervalMs: number;
+      batchSize: number;
+      skipValidateCheckpointAttestations?: boolean;
+      maxAllowedEthClientDriftSeconds: number;
+      ethereumAllowNoDebugHosts?: boolean;
+    },
+    private readonly blobClient: BlobClientInterface,
+    instrumentation: ArchiverInstrumentation,
+    protected override readonly l1Constants: L1RollupConstants & { l1StartBlockHash: Buffer32; genesisArchiveRoot: Fr },
+    synchronizer: ArchiverL1Synchronizer,
+    events: ArchiverEmitter,
+    l2TipsCache?: L2TipsCache,
+    private readonly log: Logger = createLogger('archiver'),
+  ) {
+    super(dataStore, l1Constants);
+
+    this.tracer = instrumentation.tracer;
+    this.initialSyncPromise = promiseWithResolvers();
+    this.synchronizer = synchronizer;
+    this.events = events;
+    this.l2TipsCache = l2TipsCache ?? new L2TipsCache(this.dataStore.blockStore);
+    this.updater = new ArchiverDataStoreUpdater(this.dataStore, this.l2TipsCache);
+
+    // Running promise starts with a small interval inbetween runs, so all iterations needed for the initial sync
+    // are done as fast as possible. This then gets updated once the initial sync completes.
+    this.runningPromise = new RunningPromise(
+      () => this.sync(),
+      this.log,
+      this.config.pollingIntervalMs / 10,
+      makeLoggingErrorHandler(this.log, NoBlobBodiesFoundError, BlockTagTooOldError),
+    );
+  }
+
+  /** Updates archiver config */
+  public updateConfig(newConfig: Partial<ArchiverConfig>) {
+    this.config = merge(this.config, mapArchiverConfig(newConfig));
+    this.synchronizer.setConfig(this.config);
+  }
+
+  /**
+   * Starts sync process.
+   * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
+   */
+  public async start(blockUntilSynced: boolean): Promise<void> {
+    if (this.runningPromise.isRunning()) {
+      throw new Error('Archiver is already running');
+    }
+
+    await this.blobClient.testSources();
+    await this.synchronizer.testEthereumNodeSynced();
+    await validateAndLogTraceAvailability(
+      this.debugClient,
+      this.config.ethereumAllowNoDebugHosts ?? false,
+      this.log.getBindings(),
+    );
+
+    // Log initial state for the archiver
+    const { l1StartBlock } = this.l1Constants;
+    const { blocksSynchedTo = l1StartBlock, messagesSynchedTo = l1StartBlock } = await this.store.getSynchPoint();
+    const currentL2Checkpoint = await this.getSynchedCheckpointNumber();
+    this.log.info(
+      `Starting archiver sync to rollup contract ${this.rollup.address} from L1 block ${blocksSynchedTo} and L2 checkpoint ${currentL2Checkpoint}`,
+      { blocksSynchedTo, messagesSynchedTo, currentL2Checkpoint },
+    );
+
+    // Start sync loop, and return the wait for initial sync if we are asked to block until synced
+    this.runningPromise.start();
+    if (blockUntilSynced) {
+      return this.waitForInitialSync();
+    }
+  }
+
+  public syncImmediate() {
+    return this.runningPromise.trigger();
+  }
+
+  /**
+   * Queues a block to be added to the archiver store and triggers processing.
+   * The block will be processed by the sync loop.
+   * Implements the L2BlockSink interface.
+   * @param block - The L2 block to add.
+   * @returns A promise that resolves when the block has been added to the store, or rejects on error.
+   */
+  public addBlock(block: L2Block): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.blockQueue.push({ block, resolve, reject });
+      this.log.debug(`Queued block ${block.number} for processing`);
+      // Trigger an immediate sync, but don't wait for it - the promise resolves when the block is processed
+      this.syncImmediate().catch(err => {
+        this.log.error(`Sync immediate call failed: ${err}`);
+      });
+    });
+  }
+
+  /**
+   * Processes all queued blocks, adding them to the store.
+   * Called at the beginning of each sync iteration.
+   * Blocks are processed in the order they were queued.
+   */
+  private async processQueuedBlocks(): Promise<void> {
+    if (this.blockQueue.length === 0) {
+      return;
+    }
+
+    // Take all blocks from the queue
+    const queuedItems = this.blockQueue.splice(0, this.blockQueue.length);
+    this.log.debug(`Processing ${queuedItems.length} queued block(s)`);
+
+    // Calculate slot threshold for validation
+    const l1Timestamp = this.synchronizer.getL1Timestamp();
+    const slotAtNextL1Block =
+      l1Timestamp === undefined ? undefined : getSlotAtNextL1Block(l1Timestamp, this.l1Constants);
+
+    // Process each block individually to properly resolve/reject each promise
+    for (const { block, resolve, reject } of queuedItems) {
+      const blockSlot = block.header.globalVariables.slotNumber;
+      if (slotAtNextL1Block !== undefined && blockSlot < slotAtNextL1Block) {
+        this.log.warn(
+          `Rejecting proposed block ${block.number} for past slot ${blockSlot} (current is ${slotAtNextL1Block})`,
+          { block: block.toBlockInfo(), l1Timestamp, slotAtNextL1Block },
+        );
+        reject(new Error(`Block ${block.number} is for past slot ${blockSlot} (current is ${slotAtNextL1Block})`));
+        continue;
+      }
+
+      try {
+        await this.updater.addProposedBlocks([block]);
+        this.log.debug(`Added block ${block.number} to store`);
+        resolve();
+      } catch (err: any) {
+        this.log.error(`Failed to add block ${block.number} to store: ${err.message}`);
+        reject(err);
+      }
+    }
+  }
+
+  public waitForInitialSync() {
+    return this.initialSyncPromise.promise;
+  }
+
+  /**
+   * Fetches logs from L1 contracts and processes them.
+   */
+  @trackSpan('Archiver.sync')
+  private async sync() {
+    // Process any queued blocks first, before doing L1 sync
+    await this.processQueuedBlocks();
+    // Now perform L1 sync
+    await this.syncFromL1();
+  }
+
+  private async syncFromL1() {
+    // Delegate to the L1 synchronizer
+    await this.synchronizer.syncFromL1(this.initialSyncComplete);
+
+    // Check if we've completed initial sync
+    const currentL1BlockNumber = this.synchronizer.getL1BlockNumber();
+    if (currentL1BlockNumber !== undefined && !this.initialSyncComplete) {
+      const l1BlockNumberAtEnd = await this.publicClient.getBlockNumber();
+      if (currentL1BlockNumber + 1n >= l1BlockNumberAtEnd) {
+        this.log.info(`Initial archiver sync to L1 block ${currentL1BlockNumber} complete`, {
+          l1BlockNumber: currentL1BlockNumber,
+          syncPoint: await this.store.getSynchPoint(),
+          ...(await this.getL2Tips()),
+        });
+        this.runningPromise.setPollingIntervalMS(this.config.pollingIntervalMs);
+        this.initialSyncComplete = true;
+        this.initialSyncPromise.resolve();
+      }
+    }
+  }
+
+  /** Resumes the archiver after a stop. */
+  public resume() {
+    if (this.runningPromise.isRunning()) {
+      this.log.warn(`Archiver already running`);
+    }
+    this.log.info(`Restarting archiver`);
+    this.runningPromise.start();
+  }
+
+  /**
+   * Stops the archiver.
+   * @returns A promise signalling completion of the stop process.
+   */
+  public async stop(): Promise<void> {
+    this.log.debug('Stopping...');
+    await this.runningPromise.stop();
+
+    this.log.info('Stopped.');
+    return Promise.resolve();
+  }
+
+  public backupTo(destPath: string): Promise<string> {
+    return this.dataStore.backupTo(destPath);
+  }
+
+  public getL1Constants(): Promise<L1RollupConstants> {
+    return Promise.resolve(this.l1Constants);
+  }
+
+  public getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
+    return Promise.resolve({ genesisArchiveRoot: this.l1Constants.genesisArchiveRoot });
+  }
+
+  public getRollupAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.fromString(this.rollup.address));
+  }
+
+  public getRegistryAddress(): Promise<EthAddress> {
+    return Promise.resolve(this.l1Addresses.registryAddress);
+  }
+
+  public getL1BlockNumber(): bigint | undefined {
+    return this.synchronizer.getL1BlockNumber();
+  }
+
+  public getL1Timestamp(): Promise<bigint | undefined> {
+    return Promise.resolve(this.synchronizer.getL1Timestamp());
+  }
+
+  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
+    const l1Timestamp = this.synchronizer.getL1Timestamp();
+    return Promise.resolve(l1Timestamp === undefined ? undefined : getSlotAtTimestamp(l1Timestamp, this.l1Constants));
+  }
+
+  public getL2EpochNumber(): Promise<EpochNumber | undefined> {
+    const l1Timestamp = this.synchronizer.getL1Timestamp();
+    return Promise.resolve(
+      l1Timestamp === undefined ? undefined : getEpochNumberAtTimestamp(l1Timestamp, this.l1Constants),
+    );
+  }
+
+  public async isEpochComplete(epochNumber: EpochNumber): Promise<boolean> {
+    // The epoch is complete if the current checkpointed L2 block is the last one in the epoch (or later).
+    // We use the checkpointed block number (synced from L1) instead of 'latest' to avoid returning true
+    // prematurely when proposed blocks have been pushed to the archiver but not yet checkpointed on L1.
+    const checkpointedBlockNumber = await this.getCheckpointedL2BlockNumber();
+    const header = checkpointedBlockNumber > 0 ? await this.getBlockHeader(checkpointedBlockNumber) : undefined;
+    const slot = header ? header.globalVariables.slotNumber : undefined;
+    const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
+    if (slot && slot >= endSlot) {
+      return true;
+    }
+
+    // If we haven't run an initial sync, just return false.
+    const l1Timestamp = this.synchronizer.getL1Timestamp();
+    if (l1Timestamp === undefined) {
+      return false;
+    }
+
+    // If not, the epoch may also be complete if the L2 slot has passed without a block
+    // We compute this based on the end timestamp for the given epoch and the timestamp of the last L1 block
+    const [_startTimestamp, endTimestamp] = getTimestampRangeForEpoch(epochNumber, this.l1Constants);
+
+    // For this computation, we throw in a few extra seconds just for good measure,
+    // since we know the next L1 block won't be mined within this range. Remember that
+    // l1timestamp is the timestamp of the last l1 block we've seen, so this relies on
+    // the fact that L1 won't mine two blocks within this time of each other.
+    // TODO(palla/reorg): Is the above a safe assumption?
+    const leeway = 1n;
+    return l1Timestamp + leeway >= endTimestamp;
+  }
+
+  /** Returns whether the archiver has completed an initial sync run successfully. */
+  public isInitialSyncComplete(): boolean {
+    return this.initialSyncComplete;
+  }
+
+  public removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
+    return this.updater.removeCheckpointsAfter(checkpointNumber);
+  }
+
+  /** Used by TXE to add checkpoints directly without syncing from L1. */
+  public async addCheckpoints(
+    checkpoints: PublishedCheckpoint[],
+    pendingChainValidationStatus?: ValidateCheckpointResult,
+  ): Promise<boolean> {
+    await this.updater.addCheckpoints(checkpoints, pendingChainValidationStatus);
+    return true;
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    return this.l2TipsCache.getL2Tips();
+  }
+
+  public async rollbackTo(targetL2BlockNumber: BlockNumber): Promise<void> {
+    // TODO(pw/mbps): This still assumes 1 block per checkpoint
+    const currentBlocks = await this.getL2Tips();
+    const currentL2Block = currentBlocks.proposed.number;
+    const currentProvenBlock = currentBlocks.proven.block.number;
+
+    if (targetL2BlockNumber >= currentL2Block) {
+      throw new Error(`Target L2 block ${targetL2BlockNumber} must be less than current L2 block ${currentL2Block}`);
+    }
+    const targetL2Block = await this.store.getCheckpointedBlock(targetL2BlockNumber);
+    if (!targetL2Block) {
+      throw new Error(`Target L2 block ${targetL2BlockNumber} not found`);
+    }
+    const targetL1BlockNumber = targetL2Block.l1.blockNumber;
+    const targetCheckpointNumber = targetL2Block.checkpointNumber;
+    const targetL1Block = await this.publicClient.getBlock({
+      blockNumber: targetL1BlockNumber,
+      includeTransactions: false,
+    });
+    if (!targetL1Block) {
+      throw new Error(`Missing L1 block ${targetL1BlockNumber}`);
+    }
+    const targetL1BlockHash = Buffer32.fromString(targetL1Block.hash);
+    this.log.info(
+      `Removing checkpoints after checkpoint ${targetCheckpointNumber} (target block ${targetL2BlockNumber})`,
+    );
+    await this.updater.removeCheckpointsAfter(targetCheckpointNumber);
+    this.log.info(`Rolling back L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
+    await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
+    this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
+    await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);
+    await this.store.setMessageSynchedL1Block({ l1BlockNumber: targetL1BlockNumber, l1BlockHash: targetL1BlockHash });
+    if (targetL2BlockNumber < currentProvenBlock) {
+      this.log.info(`Clearing proven L2 block number`);
+      await this.updater.setProvenCheckpointNumber(CheckpointNumber.ZERO);
+    }
+    // TODO(palla/reorg): Set the finalized block when we add support for it.
+    // if (targetL2BlockNumber < currentFinalizedBlock) {
+    //   this.log.info(`Clearing finalized L2 block number`);
+    //   await this.store.setFinalizedL2BlockNumber(0);
+    // }
+  }
+}

package/src/{archiver/config.ts → config.ts}

@@ -46,8 +46,8 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
     description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
-  skipValidateBlockAttestations: {
-    description: 'Whether to skip validating block attestations (use only for testing).',
+  skipValidateCheckpointAttestations: {
+    description: 'Skip validating checkpoint attestations (for testing purposes only)',
     ...booleanConfigHelper(false),
   },
   maxAllowedEthClientDriftSeconds: {
@@ -82,3 +82,14 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
 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,
+    maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
+    ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts,
+  };
+}

package/src/{archiver/errors.ts → errors.ts}

@@ -88,3 +88,15 @@ export class BlockNotFoundError extends Error {
     super(`Failed to find expected block number ${blockNumber}`);
   }
 }
+
+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

@@ -1,36 +1,52 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { merge } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { DateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 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 { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { getTelemetryClient } from '@aztec/telemetry-client';
 
-import { Archiver, type ArchiverDeps } from './archiver/archiver.js';
-import type { ArchiverConfig } from './archiver/config.js';
-import { ARCHIVER_DB_VERSION, KVArchiverDataStore } from './archiver/kv_archiver_store/kv_archiver_store.js';
+import { EventEmitter } from 'events';
+import { createPublicClient, fallback, http } 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 { 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,
+  l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
 ) {
   const config = {
     ...userConfig,
     dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
-  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config, createLogger('archiver:lmdb'));
-  return new KVArchiverDataStore(store, config.maxLogs);
+  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config);
+  return new KVArchiverDataStore(store, config.maxLogs, l1Constants);
 }
 
 /**
  * Creates a local archiver.
  * @param config - The archiver configuration.
- * @param blobClient - The blob client client.
+ * @param deps - The archiver dependencies (blobClient, epochCache, dateProvider, telemetry).
  * @param opts - The options.
- * @param telemetry - The telemetry client.
  * @returns The local archiver.
  */
 export async function createArchiver(
@@ -38,12 +54,125 @@ export async function createArchiver(
   deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
 ): Promise<Archiver> {
-  const archiverStore = await createArchiverStore(config);
+  const archiverStore = await createArchiverStore(config, { epochDuration: config.aztecEpochDuration });
   await registerProtocolContracts(archiverStore);
-  return Archiver.createAndSync(config, archiverStore, deps, opts.blockUntilSync);
+
+  // Create Ethereum clients
+  const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(config.l1RpcUrls.map(url => http(url, { batch: false }))),
+    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: fallback(debugRpcUrls.map(url => http(url, { batch: false }))),
+    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);
+
+  // Fetch L1 constants from rollup contract
+  const [
+    l1StartBlock,
+    l1GenesisTime,
+    proofSubmissionEpochs,
+    genesisArchiveRoot,
+    slashingProposerAddress,
+    targetCommitteeSize,
+  ] = await Promise.all([
+    rollup.getL1StartBlock(),
+    rollup.getL1GenesisTime(),
+    rollup.getProofSubmissionEpochs(),
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getSlashingProposerAddress(),
+    rollup.getTargetCommitteeSize(),
+  ] 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()),
+  };
+
+  const archiverConfig = merge(
+    {
+      pollingIntervalMs: 10_000,
+      batchSize: 100,
+      maxAllowedEthClientDriftSeconds: 300,
+      ethereumAllowNoDebugHosts: false,
+    },
+    mapArchiverConfig(config),
+  );
+
+  const epochCache = deps.epochCache ?? (await EpochCache.create(config.l1Contracts.rollupAddress, config, deps));
+  const telemetry = deps.telemetry ?? getTelemetryClient();
+  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => archiverStore.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 the L1 synchronizer
+  const synchronizer = new ArchiverL1Synchronizer(
+    publicClient,
+    debugClient,
+    rollup,
+    inbox,
+    { ...config.l1Contracts, slashingProposerAddress },
+    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,
+    { ...config.l1Contracts, slashingProposerAddress },
+    archiverStore,
+    archiverConfig,
+    deps.blobClient,
+    instrumentation,
+    l1Constants,
+    synchronizer,
+    events,
+    l2TipsCache,
+  );
+
+  await archiver.start(opts.blockUntilSync);
+  return archiver;
 }
 
-async function registerProtocolContracts(store: KVArchiverDataStore) {
+/** Registers protocol contracts in the archiver store. */
+export async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const provider = new BundledProtocolContractsProvider();