@aztec/archiver 4.0.0-nightly.20260114 → 4.0.0-nightly.20260115

package/dest/{archiver/archiver.js → modules/l1_synchronizer.js}

@@ -370,63 +370,41 @@ function applyDecs2203RFactory() {
 function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec, _dec1, _dec2, _dec3, _dec4, _initProto;
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { EpochCache } from '@aztec/epoch-cache';
-import { createEthereumChain } from '@aztec/ethereum/chain';
-import { BlockTagTooOldError, InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+var _dec, _dec1, _dec2, _dec3, _initProto;
 import { maxBigint } from '@aztec/foundation/bigint';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { merge, pick } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/running-promise';
 import { count } from '@aztec/foundation/string';
-import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { Timer, elapsed } from '@aztec/foundation/timer';
 import { isDefined } from '@aztec/foundation/types';
-import { GENESIS_CHECKPOINT_HEADER_HASH, L2BlockSourceEvents } from '@aztec/stdlib/block';
-import { getEpochAtSlot, getEpochNumberAtTimestamp, getSlotAtTimestamp, getSlotRangeForEpoch, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { L2BlockSourceEvents } from '@aztec/stdlib/block';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
-import { execInSpan, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { EventEmitter } from 'events';
-import { createPublicClient, fallback, http } from 'viem';
-import { ArchiveSourceBase } from './archive_source_base.js';
-import { addBlocksWithContractData, addCheckpointsWithContractData, unwindCheckpointsWithContractData } from './archiver_store_updates.js';
-import { InitialCheckpointNumberNotSequentialError, NoBlobBodiesFoundError } from './errors.js';
-import { ArchiverInstrumentation } from './instrumentation.js';
-import { retrieveCheckpointsFromRollup, retrieveL1ToL2Message, retrieveL1ToL2Messages, retrievedToPublishedCheckpoint } from './l1/data_retrieval.js';
-import { validateAndLogTraceAvailability } from './l1/validate_trace.js';
+import { execInSpan, trackSpan } from '@aztec/telemetry-client';
+import { InitialCheckpointNumberNotSequentialError } from '../errors.js';
+import { retrieveCheckpointsFromRollup, retrieveL1ToL2Message, retrieveL1ToL2Messages, retrievedToPublishedCheckpoint } from '../l1/data_retrieval.js';
+import { ArchiverDataStoreUpdater } from './data_store_updater.js';
 import { validateCheckpointAttestations } from './validation.js';
-function mapArchiverConfig(config) {
-    return {
-        pollingIntervalMs: config.archiverPollingIntervalMS,
-        batchSize: config.archiverBatchSize,
-        skipValidateCheckpointAttestations: config.skipValidateCheckpointAttestations,
-        maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
-        ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts
-    };
-}
-_dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _dec2 = trackSpan('Archiver.handleEpochPrune'), _dec3 = trackSpan('Archiver.handleL1ToL2Messages'), _dec4 = trackSpan('Archiver.handleCheckpoints');
+_dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpochPrune'), _dec2 = trackSpan('Archiver.handleL1ToL2Messages'), _dec3 = trackSpan('Archiver.handleCheckpoints');
 /**
- * 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 ArchiveSourceBase {
+ * Handles L1 synchronization for the archiver.
+ * Responsible for fetching checkpoints, L1→L2 messages, and handling L1 reorgs.
+ */ export class ArchiverL1Synchronizer {
     publicClient;
     debugClient;
     rollup;
     inbox;
     l1Addresses;
-    dataStore;
+    store;
     config;
     blobClient;
     epochCache;
     dateProvider;
     instrumentation;
     l1constants;
+    events;
     log;
     static{
         ({ e: [_initProto] } = _apply_decs_2203_r(this, [
@@ -438,197 +416,48 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             [
                 _dec1,
                 2,
-                "sync"
-            ],
-            [
-                _dec2,
-                2,
                 "handleEpochPrune"
             ],
             [
-                _dec3,
+                _dec2,
                 2,
                 "handleL1ToL2Messages"
             ],
             [
-                _dec4,
+                _dec3,
                 2,
                 "handleCheckpoints"
             ]
         ], []));
     }
-    /** Event emitter for archiver events (L2BlockProven, L2PruneDetected, etc). */ events;
-    /** A loop in which we will be continually fetching new checkpoints. */ runningPromise;
     l1BlockNumber;
     l1Timestamp;
-    initialSyncComplete;
-    initialSyncPromise;
-    /** Queue of blocks to be added to the store, processed by the sync loop. */ blockQueue;
+    updater;
     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(publicClient, debugClient, rollup, inbox, l1Addresses, dataStore, config, blobClient, epochCache, dateProvider, instrumentation, l1constants, log = createLogger('archiver')){
-        super(dataStore), this.publicClient = publicClient, this.debugClient = debugClient, this.rollup = rollup, this.inbox = inbox, this.l1Addresses = l1Addresses, this.dataStore = dataStore, this.config = config, this.blobClient = blobClient, this.epochCache = epochCache, this.dateProvider = dateProvider, this.instrumentation = instrumentation, this.l1constants = l1constants, this.log = log, this.events = (_initProto(this), new EventEmitter()), this.initialSyncComplete = false, this.blockQueue = [];
-        this.tracer = instrumentation.tracer;
-        this.initialSyncPromise = promiseWithResolvers();
-        // 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));
-    }
-    /**
-   * Creates a new instance of the Archiver and blocks until it syncs from chain.
-   * @param config - The archiver's desired configuration.
-   * @param archiverStore - The backing store for the archiver.
-   * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
-   * @returns - An instance of the archiver.
-   */ static async createAndSync(config, archiverStore, deps, blockUntilSynced = true) {
-        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
-        });
-        const rollup = new RollupContract(publicClient, config.l1Contracts.rollupAddress);
-        const inbox = new InboxContract(publicClient, config.l1Contracts.inboxAddress);
-        const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, genesisArchiveRoot, slashingProposerAddress] = await Promise.all([
-            rollup.getL1StartBlock(),
-            rollup.getL1GenesisTime(),
-            rollup.getProofSubmissionEpochs(),
-            rollup.getGenesisArchiveTreeRoot(),
-            rollup.getSlashingProposerAddress()
-        ]);
-        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),
-            genesisArchiveRoot: Fr.fromString(genesisArchiveRoot.toString())
-        };
-        const opts = 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 archiver = new Archiver(publicClient, debugClient, rollup, inbox, {
-            ...config.l1Contracts,
-            slashingProposerAddress
-        }, archiverStore, opts, deps.blobClient, epochCache, deps.dateProvider ?? new DateProvider(), await ArchiverInstrumentation.new(telemetry, ()=>archiverStore.estimateSize()), l1Constants);
-        await archiver.start(blockUntilSynced);
-        return archiver;
-    }
-    /** Updates archiver config */ updateConfig(newConfig) {
-        this.config = merge(this.config, mapArchiverConfig(newConfig));
-    }
-    /**
-   * Starts sync process.
-   * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
-   */ async start(blockUntilSynced) {
-        if (this.runningPromise.isRunning()) {
-            throw new Error('Archiver is already running');
-        }
-        await this.blobClient.testSources();
-        await this.testEthereumNodeSynced();
-        await validateAndLogTraceAvailability(this.debugClient, this.config.ethereumAllowNoDebugHosts ?? false);
-        // 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();
-        }
-    }
-    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.
-   */ addBlock(block) {
-        return new Promise((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}`);
-            });
-        });
+    constructor(publicClient, debugClient, rollup, inbox, l1Addresses, store, config, blobClient, epochCache, dateProvider, instrumentation, l1constants, events, tracer, log = createLogger('archiver:l1-sync')){
+        this.publicClient = publicClient;
+        this.debugClient = debugClient;
+        this.rollup = rollup;
+        this.inbox = inbox;
+        this.l1Addresses = l1Addresses;
+        this.store = store;
+        this.config = config;
+        this.blobClient = blobClient;
+        this.epochCache = epochCache;
+        this.dateProvider = dateProvider;
+        this.instrumentation = instrumentation;
+        this.l1constants = l1constants;
+        this.events = events;
+        this.log = log;
+        _initProto(this);
+        this.updater = new ArchiverDataStoreUpdater(this.store);
+        this.tracer = tracer;
     }
-    /**
-   * 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.
-   */ async processQueuedBlocks() {
-        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)`);
-        // Process each block individually to properly resolve/reject each promise
-        for (const { block, resolve, reject } of queuedItems){
-            try {
-                await addBlocksWithContractData(this.store, [
-                    block
-                ]);
-                this.log.debug(`Added block ${block.number} to store`);
-                resolve();
-            } catch (err) {
-                this.log.error(`Failed to add block ${block.number} to store: ${err.message}`);
-                reject(err);
-            }
-        }
+    /** Returns the last L1 block number that was synced. */ getL1BlockNumber() {
+        return this.l1BlockNumber;
     }
-    waitForInitialSync() {
-        return this.initialSyncPromise.promise;
+    /** Returns the last L1 timestamp that was synced. */ getL1Timestamp() {
+        return this.l1Timestamp;
     }
     /** Checks that the ethereum node we are connected to has a latest timestamp no more than the allowed drift. Throw if not. */ async testEthereumNodeSynced() {
         const maxAllowedDelay = this.config.maxAllowedEthClientDriftSeconds;
@@ -643,7 +472,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             throw new Error(`Ethereum node is out of sync (last block synced ${number} at ${l1Timestamp} vs current time ${currentTime})`);
         }
     }
-    async syncFromL1() {
+    async syncFromL1(initialSyncComplete) {
         /**
      * We keep track of three "pointers" to L1 blocks:
      * 1. the last L1 block that published an L2 block
@@ -706,7 +535,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         if (currentL1BlockNumber > blocksSynchedTo) {
             // First we retrieve new checkpoints and L2 blocks and store them in the DB. This will also update the
             // pending chain validation status, proven checkpoint number, and synched L1 block number.
-            const rollupStatus = await this.handleCheckpoints(blocksSynchedTo, currentL1BlockNumber);
+            const rollupStatus = await this.handleCheckpoints(blocksSynchedTo, currentL1BlockNumber, initialSyncComplete);
             // Then we prune the current epoch if it'd reorg on next submission.
             // Note that we don't do this before retrieving checkpoints because we may need to retrieve
             // checkpoints from more than 2 epochs ago, so we want to make sure we have the latest view of
@@ -739,26 +568,6 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             l1TimestampAtStart: currentL1Timestamp,
             l1BlockNumberAtEnd
         });
-        // We resolve the initial sync only once we've caught up with the latest L1 block number (with 1 block grace)
-        // so if the initial sync took too long, we still go for another iteration.
-        if (!this.initialSyncComplete && 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();
-        }
-    }
-    /**
-   * Fetches logs from L1 contracts and processes them.
-   */ async sync() {
-        // Process any queued blocks first, before doing L1 sync
-        await this.processQueuedBlocks();
-        // Now perform L1 sync
-        await this.syncFromL1();
     }
     /** Queries the rollup contract on whether a prune can be executed on the immediate next L1 block. */ async canPrune(currentL1BlockNumber, currentL1Timestamp) {
         const time = (currentL1Timestamp ?? 0n) + BigInt(this.l1constants.ethereumSlotDuration);
@@ -776,7 +585,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
     }
     /** Checks if there'd be a reorg for the next checkpoint submission and start pruning now. */ async handleEpochPrune(provenCheckpointNumber, currentL1BlockNumber, currentL1Timestamp) {
         const rollupCanPrune = await this.canPrune(currentL1BlockNumber, currentL1Timestamp);
-        const localPendingCheckpointNumber = await this.getSynchedCheckpointNumber();
+        const localPendingCheckpointNumber = await this.store.getSynchedCheckpointNumber();
         const canPrune = localPendingCheckpointNumber > provenCheckpointNumber && rollupCanPrune;
         if (canPrune) {
             const timer = new Timer();
@@ -801,8 +610,8 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                 blocks: newBlocks
             });
             this.log.debug(`L2 prune from ${provenCheckpointNumber + 1} to ${localPendingCheckpointNumber} will occur on next checkpoint submission.`);
-            await this.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
-            this.log.warn(`Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` + `to ${provenCheckpointNumber} due to predicted reorg at L1 block ${currentL1BlockNumber}. ` + `Updated latest checkpoint is ${await this.getSynchedCheckpointNumber()}.`);
+            await this.updater.unwindCheckpointsWithContractData(localPendingCheckpointNumber, checkpointsToUnwind);
+            this.log.warn(`Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` + `to ${provenCheckpointNumber} due to predicted reorg at L1 block ${currentL1BlockNumber}. ` + `Updated latest checkpoint is ${await this.store.getSynchedCheckpointNumber()}.`);
             this.instrumentation.processPrune(timer.ms());
         // TODO(palla/reorg): Do we need to set the block synched L1 block number here?
         // Seems like the next iteration should handle this.
@@ -844,7 +653,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             remoteMessagesState
         });
         // Compare message count and rolling hash. If they match, no need to retrieve anything.
-        if (remoteMessagesState.totalMessagesInserted === localMessagesInserted && remoteMessagesState.messagesRollingHash.equals(localLastMessage?.rollingHash ?? Buffer16.ZERO)) {
+        if (remoteMessagesState.totalMessagesInserted === localMessagesInserted && remoteMessagesState.messagesRollingHash.equals(localLastMessage?.rollingHash ?? Buffer32.ZERO)) {
             this.log.trace(`No L1 to L2 messages to query between L1 blocks ${messagesSyncPoint.l1BlockNumber} and ${currentL1BlockNumber}.`);
             return;
         }
@@ -971,8 +780,8 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         }
         return Buffer32.fromString(block.hash);
     }
-    async handleCheckpoints(blocksSynchedTo, currentL1BlockNumber) {
-        const localPendingCheckpointNumber = await this.getSynchedCheckpointNumber();
+    async handleCheckpoints(blocksSynchedTo, currentL1BlockNumber, initialSyncComplete) {
+        const localPendingCheckpointNumber = await this.store.getSynchedCheckpointNumber();
         const initialValidationResult = await this.store.getPendingChainValidationStatus();
         const { provenCheckpointNumber, provenArchive, pendingCheckpointNumber, pendingArchive, archiveOfMyCheckpoint: archiveForLocalPendingCheckpointNumber } = await execInSpan(this.tracer, 'Archiver.getRollupStatus', ()=>this.rollup.status(localPendingCheckpointNumber, {
                 blockNumber: currentL1BlockNumber
@@ -996,9 +805,9 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             // we need to set it to zero. This is an edge case because we dont have a checkpoint zero (initial checkpoint is one),
             // so localCheckpointForDestinationProvenCheckpointNumber would not be found below.
             if (provenCheckpointNumber === 0) {
-                const localProvenCheckpointNumber = await this.getProvenCheckpointNumber();
+                const localProvenCheckpointNumber = await this.store.getProvenCheckpointNumber();
                 if (localProvenCheckpointNumber !== provenCheckpointNumber) {
-                    await this.setProvenCheckpointNumber(provenCheckpointNumber);
+                    await this.store.setProvenCheckpointNumber(provenCheckpointNumber);
                     this.log.info(`Rolled back proven chain to checkpoint ${provenCheckpointNumber}`, {
                         provenCheckpointNumber
                     });
@@ -1007,15 +816,15 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             const localCheckpointForDestinationProvenCheckpointNumber = await this.store.getCheckpointData(provenCheckpointNumber);
             // Sanity check. I've hit what seems to be a state where the proven checkpoint is set to a value greater than the latest
             // synched checkpoint when requesting L2Tips from the archiver. This is the only place where the proven checkpoint is set.
-            const synched = await this.getSynchedCheckpointNumber();
+            const synched = await this.store.getSynchedCheckpointNumber();
             if (localCheckpointForDestinationProvenCheckpointNumber && synched < localCheckpointForDestinationProvenCheckpointNumber.checkpointNumber) {
                 this.log.error(`Hit local checkpoint greater than last synched checkpoint: ${localCheckpointForDestinationProvenCheckpointNumber.checkpointNumber} > ${synched}`);
             }
             this.log.trace(`Local checkpoint for remote proven checkpoint ${provenCheckpointNumber} is ${localCheckpointForDestinationProvenCheckpointNumber?.archive.root.toString() ?? 'undefined'}`);
             if (localCheckpointForDestinationProvenCheckpointNumber && provenArchive.equals(localCheckpointForDestinationProvenCheckpointNumber.archive.root)) {
-                const localProvenCheckpointNumber = await this.getProvenCheckpointNumber();
+                const localProvenCheckpointNumber = await this.store.getProvenCheckpointNumber();
                 if (localProvenCheckpointNumber !== provenCheckpointNumber) {
-                    await this.setProvenCheckpointNumber(provenCheckpointNumber);
+                    await this.store.setProvenCheckpointNumber(provenCheckpointNumber);
                     this.log.info(`Updated proven chain to checkpoint ${provenCheckpointNumber}`, {
                         provenCheckpointNumber
                     });
@@ -1092,8 +901,8 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                     tipAfterUnwind--;
                 }
                 const checkpointsToUnwind = localPendingCheckpointNumber - tipAfterUnwind;
-                await this.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
-                this.log.warn(`Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` + `due to mismatched checkpoint hashes at L1 block ${currentL1BlockNumber}. ` + `Updated L2 latest checkpoint is ${await this.getSynchedCheckpointNumber()}.`);
+                await this.updater.unwindCheckpointsWithContractData(localPendingCheckpointNumber, checkpointsToUnwind);
+                this.log.warn(`Unwound ${count(checkpointsToUnwind, 'checkpoint')} from checkpoint ${localPendingCheckpointNumber} ` + `due to mismatched checkpoint hashes at L1 block ${currentL1BlockNumber}. ` + `Updated L2 latest checkpoint is ${await this.store.getSynchedCheckpointNumber()}.`);
             }
         }
         // Retrieve checkpoints in batches. Each batch is estimated to accommodate up to 'blockBatchSize' L1 blocks,
@@ -1106,7 +915,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
             this.log.trace(`Retrieving checkpoints from L1 block ${searchStartBlock} to ${searchEndBlock}`);
             // TODO(md): Retrieve from blob client then from consensus client, then from peers
-            const retrievedCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointsFromRollup', ()=>retrieveCheckpointsFromRollup(this.rollup, this.publicClient, this.debugClient, this.blobClient, searchStartBlock, searchEndBlock, this.l1Addresses, this.instrumentation, this.log, !this.initialSyncComplete));
+            const retrievedCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointsFromRollup', ()=>retrieveCheckpointsFromRollup(this.rollup, this.publicClient, this.debugClient, this.blobClient, searchStartBlock, searchEndBlock, this.l1Addresses, this.instrumentation, this.log, !initialSyncComplete));
             if (retrievedCheckpoints.length === 0) {
                 // We are not calling `setBlockSynchedL1BlockNumber` because it may cause sync issues if based off infura.
                 // See further details in earlier comments.
@@ -1148,7 +957,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                 // Check the inHash of the checkpoint against the l1->l2 messages.
                 // The messages should've been synced up to the currentL1BlockNumber and must be available for the published
                 // checkpoints we just retrieved.
-                const l1ToL2Messages = await this.getL1ToL2Messages(published.checkpoint.number);
+                const l1ToL2Messages = await this.store.getL1ToL2Messages(published.checkpoint.number);
                 const computedInHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
                 const publishedInHash = published.checkpoint.header.inHash;
                 if (!computedInHash.equals(publishedInHash)) {
@@ -1171,7 +980,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             }
             try {
                 const updatedValidationResult = rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
-                const [processDuration] = await elapsed(()=>execInSpan(this.tracer, 'Archiver.addCheckpoints', ()=>this.addCheckpoints(validCheckpoints, updatedValidationResult)));
+                const [processDuration] = await elapsed(()=>execInSpan(this.tracer, 'Archiver.addCheckpoints', ()=>this.updater.addCheckpointsWithContractData(validCheckpoints, updatedValidationResult)));
                 this.instrumentation.processNewBlocks(processDuration / validCheckpoints.length, validCheckpoints.flatMap((c)=>c.checkpoint.blocks));
             } catch (err) {
                 if (err instanceof InitialCheckpointNumberNotSequentialError) {
@@ -1213,7 +1022,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         const { lastRetrievedCheckpoint, pendingCheckpointNumber } = status;
         // Compare the last checkpoint we have (either retrieved in this round or loaded from store) with what the
         // rollup contract told us was the latest one (pinned at the currentL1BlockNumber).
-        const latestLocalCheckpointNumber = lastRetrievedCheckpoint?.checkpoint.number ?? await this.getSynchedCheckpointNumber();
+        const latestLocalCheckpointNumber = lastRetrievedCheckpoint?.checkpoint.number ?? await this.store.getSynchedCheckpointNumber();
         if (latestLocalCheckpointNumber < pendingCheckpointNumber) {
             // Here we have consumed all logs until the `currentL1Block` we pinned at the beginning of the archiver loop,
             // but still haven't reached the pending checkpoint according to the call to the rollup contract.
@@ -1245,303 +1054,11 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             });
         }
     }
-    /** Resumes the archiver after a stop. */ 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.
-   */ async stop() {
-        this.log.debug('Stopping...');
-        await this.runningPromise.stop();
-        this.log.info('Stopped.');
-        return Promise.resolve();
-    }
-    backupTo(destPath) {
-        return this.dataStore.backupTo(destPath);
-    }
-    getL1Constants() {
-        return Promise.resolve(this.l1constants);
-    }
-    getGenesisValues() {
-        return Promise.resolve({
-            genesisArchiveRoot: this.l1constants.genesisArchiveRoot
-        });
-    }
-    getRollupAddress() {
-        return Promise.resolve(EthAddress.fromString(this.rollup.address));
-    }
-    getRegistryAddress() {
-        return Promise.resolve(this.l1Addresses.registryAddress);
-    }
-    getL1BlockNumber() {
-        return this.l1BlockNumber;
-    }
-    getL1Timestamp() {
-        return Promise.resolve(this.l1Timestamp);
-    }
-    getL2SlotNumber() {
-        return Promise.resolve(this.l1Timestamp === undefined ? undefined : getSlotAtTimestamp(this.l1Timestamp, this.l1constants));
-    }
-    getL2EpochNumber() {
-        return Promise.resolve(this.l1Timestamp === undefined ? undefined : getEpochNumberAtTimestamp(this.l1Timestamp, this.l1constants));
-    }
-    async getBlocksForEpoch(epochNumber) {
-        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1constants);
-        const blocks = [];
-        // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
-        // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
-        let checkpoint = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
-        const slot = (b)=>b.header.slotNumber;
-        while(checkpoint && slot(checkpoint) >= start){
-            if (slot(checkpoint) <= end) {
-                // push the blocks on backwards
-                const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
-                for(let i = endBlock; i >= checkpoint.startBlock; i--){
-                    const block = await this.getBlock(BlockNumber(i));
-                    if (block) {
-                        blocks.push(block);
-                    }
-                }
-            }
-            checkpoint = await this.store.getCheckpointData(CheckpointNumber(checkpoint.checkpointNumber - 1));
-        }
-        return blocks.reverse();
-    }
-    async getBlockHeadersForEpoch(epochNumber) {
-        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1constants);
-        const blocks = [];
-        // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
-        // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
-        let checkpoint = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
-        const slot = (b)=>b.header.slotNumber;
-        while(checkpoint && slot(checkpoint) >= start){
-            if (slot(checkpoint) <= end) {
-                // push the blocks on backwards
-                const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
-                for(let i = endBlock; i >= checkpoint.startBlock; i--){
-                    const block = await this.getBlockHeader(BlockNumber(i));
-                    if (block) {
-                        blocks.push(block);
-                    }
-                }
-            }
-            checkpoint = await this.store.getCheckpointData(CheckpointNumber(checkpoint.checkpointNumber - 1));
-        }
-        return blocks.reverse();
-    }
-    async isEpochComplete(epochNumber) {
-        // The epoch is complete if the current L2 block is the last one in the epoch (or later)
-        const header = await this.getBlockHeader('latest');
-        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.l1Timestamp;
-        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. */ isInitialSyncComplete() {
-        return this.initialSyncComplete;
-    }
     async getCheckpointHeader(number) {
-        if (number === 'latest') {
-            number = await this.getSynchedCheckpointNumber();
-        }
-        if (number === 0) {
-            return undefined;
-        }
         const checkpoint = await this.store.getCheckpointData(number);
         if (!checkpoint) {
             return undefined;
         }
         return checkpoint.header;
     }
-    getCheckpointNumber() {
-        return this.getSynchedCheckpointNumber();
-    }
-    getSynchedCheckpointNumber() {
-        return this.store.getSynchedCheckpointNumber();
-    }
-    getProvenCheckpointNumber() {
-        return this.store.getProvenCheckpointNumber();
-    }
-    setProvenCheckpointNumber(checkpointNumber) {
-        return this.store.setProvenCheckpointNumber(checkpointNumber);
-    }
-    unwindCheckpoints(from, checkpointsToUnwind) {
-        return unwindCheckpointsWithContractData(this.store, from, checkpointsToUnwind);
-    }
-    async getLastBlockNumberInCheckpoint(checkpointNumber) {
-        const checkpointData = await this.store.getCheckpointData(checkpointNumber);
-        if (!checkpointData) {
-            return undefined;
-        }
-        return BlockNumber(checkpointData.startBlock + checkpointData.numBlocks - 1);
-    }
-    addCheckpoints(checkpoints, pendingChainValidationStatus) {
-        return addCheckpointsWithContractData(this.store, checkpoints, pendingChainValidationStatus);
-    }
-    getCheckpointedBlockNumber() {
-        return this.store.getCheckpointedL2BlockNumber();
-    }
-    async getL2Tips() {
-        const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
-            this.getBlockNumber(),
-            this.getProvenBlockNumber(),
-            this.getCheckpointedBlockNumber()
-        ]);
-        // TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-        // We just force it 2 epochs worth of proven data for now.
-        // NOTE: update end-to-end/src/e2e_epochs/epochs_empty_blocks.test.ts as that uses finalized blocks in computations
-        const finalizedBlockNumber = BlockNumber(Math.max(provenBlockNumber - this.l1constants.epochDuration * 2, 0));
-        const beforeInitialblockNumber = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
-        // Get the latest block header and checkpointed blocks for proven, finalised and checkpointed blocks
-        const [latestBlockHeader, provenCheckpointedBlock, finalizedCheckpointedBlock, checkpointedBlock] = await Promise.all([
-            latestBlockNumber > beforeInitialblockNumber ? this.getBlockHeader(latestBlockNumber) : undefined,
-            provenBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(provenBlockNumber) : undefined,
-            finalizedBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(finalizedBlockNumber) : undefined,
-            checkpointedBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(checkpointedBlockNumber) : undefined
-        ]);
-        if (latestBlockNumber > beforeInitialblockNumber && !latestBlockHeader) {
-            throw new Error(`Failed to retrieve latest block header for block ${latestBlockNumber}`);
-        }
-        // Checkpointed blocks must exist for proven, finalized and checkpointed tips if they are beyond the initial block number.
-        if (checkpointedBlockNumber > beforeInitialblockNumber && !checkpointedBlock?.block.header) {
-            throw new Error(`Failed to retrieve checkpointed block header for block ${checkpointedBlockNumber} (latest block is ${latestBlockNumber})`);
-        }
-        if (provenBlockNumber > beforeInitialblockNumber && !provenCheckpointedBlock?.block.header) {
-            throw new Error(`Failed to retrieve proven checkpointed for block ${provenBlockNumber} (latest block is ${latestBlockNumber})`);
-        }
-        if (finalizedBlockNumber > beforeInitialblockNumber && !finalizedCheckpointedBlock?.block.header) {
-            throw new Error(`Failed to retrieve finalized block header for block ${finalizedBlockNumber} (latest block is ${latestBlockNumber})`);
-        }
-        const latestBlockHeaderHash = await latestBlockHeader?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
-        const provenBlockHeaderHash = await provenCheckpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
-        const finalizedBlockHeaderHash = await finalizedCheckpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
-        const checkpointedBlockHeaderHash = await checkpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
-        // Now attempt to retrieve checkpoints for proven, finalised and checkpointed blocks
-        const [[provenBlockCheckpoint], [finalizedBlockCheckpoint], [checkpointedBlockCheckpoint]] = await Promise.all([
-            provenCheckpointedBlock !== undefined ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1) : [
-                undefined
-            ],
-            finalizedCheckpointedBlock !== undefined ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1) : [
-                undefined
-            ],
-            checkpointedBlock !== undefined ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1) : [
-                undefined
-            ]
-        ]);
-        const initialcheckpointId = {
-            number: CheckpointNumber.ZERO,
-            hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
-        };
-        const makeCheckpointId = (checkpoint)=>{
-            if (checkpoint === undefined) {
-                return initialcheckpointId;
-            }
-            return {
-                number: checkpoint.checkpoint.number,
-                hash: checkpoint.checkpoint.hash().toString()
-            };
-        };
-        const l2Tips = {
-            proposed: {
-                number: latestBlockNumber,
-                hash: latestBlockHeaderHash.toString()
-            },
-            proven: {
-                block: {
-                    number: provenBlockNumber,
-                    hash: provenBlockHeaderHash.toString()
-                },
-                checkpoint: makeCheckpointId(provenBlockCheckpoint)
-            },
-            finalized: {
-                block: {
-                    number: finalizedBlockNumber,
-                    hash: finalizedBlockHeaderHash.toString()
-                },
-                checkpoint: makeCheckpointId(finalizedBlockCheckpoint)
-            },
-            checkpointed: {
-                block: {
-                    number: checkpointedBlockNumber,
-                    hash: checkpointedBlockHeaderHash.toString()
-                },
-                checkpoint: makeCheckpointId(checkpointedBlockCheckpoint)
-            }
-        };
-        return l2Tips;
-    }
-    async rollbackTo(targetL2BlockNumber) {
-        // 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 blocksToUnwind = currentL2Block - targetL2BlockNumber;
-        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 = CheckpointNumber.fromBlockNumber(targetL2BlockNumber);
-        const targetL1BlockHash = await this.getL1BlockHash(targetL1BlockNumber);
-        this.log.info(`Unwinding ${blocksToUnwind} checkpoints from L2 block ${currentL2Block}`);
-        await unwindCheckpointsWithContractData(this.store, CheckpointNumber(currentL2Block), blocksToUnwind);
-        this.log.info(`Unwinding 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.store.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);
-    // }
-    }
-    async getCheckpointsForEpoch(epochNumber) {
-        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1constants);
-        const checkpoints = [];
-        // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
-        // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
-        let checkpointData = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
-        const slot = (b)=>b.header.slotNumber;
-        while(checkpointData && slot(checkpointData) >= start){
-            if (slot(checkpointData) <= end) {
-                // push the checkpoints on backwards
-                const [checkpoint] = await this.getPublishedCheckpoints(checkpointData.checkpointNumber, 1);
-                checkpoints.push(checkpoint.checkpoint);
-            }
-            checkpointData = await this.store.getCheckpointData(CheckpointNumber(checkpointData.checkpointNumber - 1));
-        }
-        return checkpoints.reverse();
-    }
 }