@aztec/archiver 0.0.1-commit.e558bd1c → 0.0.1-commit.e57c76e

package/dest/archiver.js

@@ -371,23 +371,27 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec, _initProto;
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
 import { BlockTagTooOldError } from '@aztec/ethereum/contracts';
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { merge } from '@aztec/foundation/collection';
+import { merge, pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/running-promise';
-import { GENESIS_CHECKPOINT_HEADER_HASH } from '@aztec/stdlib/block';
-import { getEpochNumberAtTimestamp, getSlotAtNextL1Block, getSlotAtTimestamp, getSlotRangeForEpoch, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { elapsed } from '@aztec/foundation/timer';
+import { L2BlockSourceEvents } from '@aztec/stdlib/block';
+import { getEpochAtSlot, getSlotAtNextL1Block, getSlotRangeForEpoch, getTimestampForSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { trackSpan } from '@aztec/telemetry-client';
 import { mapArchiverConfig } from './config.js';
-import { NoBlobBodiesFoundError } from './errors.js';
+import { BlockAlreadyCheckpointedError, BlockOrCheckpointSlotExpiredError, NoBlobBodiesFoundError } from './errors.js';
+import { validateAndLogHistoricalLogsAvailability } from './l1/validate_historical_logs.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 { OutboxTreesResolver } from './modules/outbox_trees_resolver.js';
+import { backupArchiverDataStores, getArchiverSynchPoint } from './store/data_stores.js';
 _dec = trackSpan('Archiver.sync');
 /**
  * Pulls checkpoints in a non-blocking manner and provides interface for their retrieval.
@@ -397,11 +401,13 @@ _dec = trackSpan('Archiver.sync');
     publicClient;
     debugClient;
     rollup;
+    outbox;
     l1Addresses;
-    dataStore;
+    dataStores;
     config;
     blobClient;
     l1Constants;
+    dateProvider;
     log;
     static{
         ({ e: [_initProto] } = _apply_decs_2203_r(this, [
@@ -415,37 +421,67 @@ _dec = trackSpan('Archiver.sync');
     /** Event emitter for archiver events (L2BlockProven, L2PruneUnproven, L2PruneUncheckpointed, etc). */ events;
     /** A loop in which we will be continually fetching new checkpoints. */ runningPromise;
     /** L1 synchronizer that handles fetching checkpoints and messages from L1. */ synchronizer;
+    /** Resolver for L2-to-L1 message membership witnesses, built over this archiver's read view. */ outboxTreesResolver;
     initialSyncComplete;
     initialSyncPromise;
-    /** Queue of blocks to be added to the store, processed by the sync loop. */ blockQueue;
+    /** Queue of blocks and checkpoints to be added to the store, processed by the sync loop. */ inboundQueue;
     /** Helper to handle updates to the store */ updater;
+    /** In-memory cache for L2 chain tips. */ l2TipsCache;
     tracer;
+    instrumentation;
     /**
    * 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 outbox - Outbox contract instance, used to read per-epoch L2-to-L1 message roots.
    * @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 l1Addresses - L1 contract addresses (registry, governance proposer, slashing proposer).
+   * @param dataStores - Archiver substores 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 synchronizer - L1 synchronizer that handles fetching checkpoints and messages from L1.
+   * @param events - Event emitter shared with the synchronizer.
+   * @param initialHeader - Genesis block header.
+   * @param initialBlockHash - Precomputed hash of the genesis block header.
+   * @param l2TipsCache - In-memory cache for L2 chain tips.
+   * @param dateProvider - Provider for current date/time, used for wall-clock orphan-block pruning.
    * @param log - A logger.
-   */ constructor(publicClient, debugClient, rollup, l1Addresses, dataStore, config, blobClient, instrumentation, l1Constants, synchronizer, events, log = createLogger('archiver')){
-        super(dataStore, l1Constants), this.publicClient = publicClient, this.debugClient = debugClient, this.rollup = rollup, this.l1Addresses = l1Addresses, this.dataStore = dataStore, this.config = config, this.blobClient = blobClient, this.l1Constants = l1Constants, this.log = log, this.initialSyncComplete = (_initProto(this), false), this.blockQueue = [];
+   */ constructor(publicClient, debugClient, rollup, outbox, l1Addresses, dataStores, config, blobClient, instrumentation, l1Constants, synchronizer, events, initialHeader, initialBlockHash, l2TipsCache, dateProvider, log = createLogger('archiver')){
+        super(dataStores, l1Constants, initialHeader, initialBlockHash, l1Constants.genesisArchiveRoot), this.publicClient = publicClient, this.debugClient = debugClient, this.rollup = rollup, this.outbox = outbox, this.l1Addresses = l1Addresses, this.dataStores = dataStores, this.config = config, this.blobClient = blobClient, this.l1Constants = l1Constants, this.dateProvider = dateProvider, this.log = log, this.initialSyncComplete = (_initProto(this), false), this.inboundQueue = [];
         this.tracer = instrumentation.tracer;
+        this.instrumentation = instrumentation;
         this.initialSyncPromise = promiseWithResolvers();
         this.synchronizer = synchronizer;
         this.events = events;
-        this.updater = new ArchiverDataStoreUpdater(this.dataStore);
+        this.l2TipsCache = l2TipsCache;
+        this.updater = new ArchiverDataStoreUpdater(this.dataStores, this.l2TipsCache, {
+            rollupManaLimit: l1Constants.rollupManaLimit
+        });
+        // The resolver reads its witness data from this archiver and pins its lazy Outbox-root fetches
+        // to the archiver's synced L1 block. No method on `this` is invoked during construction.
+        this.outboxTreesResolver = new OutboxTreesResolver(this.outbox, this, ()=>Promise.resolve(this.getL1BlockNumber()), l1Constants.epochDuration);
         // 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));
     }
+    /**
+   * Returns the L2-to-L1 membership witness for `message` emitted by tx `txHash`. The node selects
+   * the smallest partial-proof root on the Outbox that covers the tx's checkpoint and builds the
+   * witness against it.
+   *
+   * The node reads the Outbox roots lazily, pinned to its synced L1 block, so the witness reflects
+   * the node's synced view. Returns `undefined` if the tx isn't yet in a block/epoch or no covering
+   * root has landed on L1 as of the synced block.
+   *
+   * Caveat: roots are cached only for the current synced L1 block and re-fetched once the node
+   * advances, so a reorg is picked up on the next synced-block advance rather than re-validated per
+   * request.
+   */ getL2ToL1MembershipWitness(txHash, message, messageIndexInTx) {
+        return this.outboxTreesResolver.getL2ToL1MembershipWitness(txHash, message, messageIndexInTx);
+    }
     /** Updates archiver config */ updateConfig(newConfig) {
         this.config = merge(this.config, mapArchiverConfig(newConfig));
         this.synchronizer.setConfig(this.config);
@@ -460,10 +496,16 @@ _dec = trackSpan('Archiver.sync');
         await this.blobClient.testSources();
         await this.synchronizer.testEthereumNodeSynced();
         await validateAndLogTraceAvailability(this.debugClient, this.config.ethereumAllowNoDebugHosts ?? false, this.log.getBindings());
+        await validateAndLogHistoricalLogsAvailability(this.publicClient, {
+            rollupAddress: this.l1Addresses.rollupAddress,
+            inboxAddress: this.l1Addresses.inboxAddress,
+            registryAddress: this.l1Addresses.registryAddress,
+            governanceProposerAddress: this.l1Addresses.governanceProposerAddress
+        }, this.config.skipHistoricalLogsCheck ?? 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();
+        const { blocksSynchedTo = l1StartBlock, messagesSynchedTo = l1StartBlock } = await getArchiverSynchPoint(this.stores);
+        const currentL2Checkpoint = await this.getCheckpointNumber();
         this.log.info(`Starting archiver sync to rollup contract ${this.rollup.address} from L1 block ${blocksSynchedTo} and L2 checkpoint ${currentL2Checkpoint}`, {
             blocksSynchedTo,
             messagesSynchedTo,
@@ -478,6 +520,13 @@ _dec = trackSpan('Archiver.sync');
     syncImmediate() {
         return this.runningPromise.trigger();
     }
+    trySyncImmediate() {
+        try {
+            return this.syncImmediate();
+        } catch (err) {
+            this.log.error(`Failed to trigger immediate archiver sync: ${err}`, err);
+        }
+    }
     /**
    * Queues a block to be added to the archiver store and triggers processing.
    * The block will be processed by the sync loop.
@@ -485,53 +534,84 @@ _dec = trackSpan('Archiver.sync');
    * @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}`);
-            });
+        const promise = promiseWithResolvers();
+        this.inboundQueue.push({
+            block,
+            ...promise,
+            type: 'block'
+        });
+        this.log.debug(`Queued block ${block.number} for processing`);
+        void this.trySyncImmediate();
+        return promise.promise;
+    }
+    /**
+   * Queues a new proposed checkpoint into the archiver store.
+   * Checks that the checkpoint is not for an L2 slot already synced from L1.
+   * Resolves once the checkpoint has been processed.
+   */ addProposedCheckpoint(pending) {
+        const promise = promiseWithResolvers();
+        this.inboundQueue.push({
+            checkpoint: pending,
+            ...promise,
+            type: 'checkpoint'
         });
+        this.log.debug(`Queued checkpoint ${pending.checkpointNumber} for processing`);
+        void this.trySyncImmediate();
+        return promise.promise;
     }
     /**
-   * Processes all queued blocks, adding them to the store.
+   * Processes all queued blocks and checkpoints, 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) {
+   * Items are processed in the order they were queued.
+   */ async processInboundQueue() {
+        if (this.inboundQueue.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)`);
+        // Take all items from the queue
+        const queuedItems = this.inboundQueue.splice(0, this.inboundQueue.length);
+        this.log.debug(`Processing ${queuedItems.length} queued inbound items`);
         // 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(),
+        // Helpers for manipulating blocks and checkpoints in the queue
+        const getSlot = (item)=>item.type === 'block' ? item.block.header.globalVariables.slotNumber : item.checkpoint.header.slotNumber;
+        const getNumber = (item)=>item.type === 'block' ? item.block.number : item.checkpoint.checkpointNumber;
+        // Process each item individually to properly resolve/reject each promise
+        for (const item of queuedItems){
+            const { resolve, reject, type } = item;
+            const itemSlot = getSlot(item);
+            const itemNumber = getNumber(item);
+            if (slotAtNextL1Block !== undefined && itemSlot < slotAtNextL1Block) {
+                const nextSlotTimestamp = getTimestampForSlot(slotAtNextL1Block, this.l1Constants);
+                this.log.warn(`Rejecting proposed ${type} ${itemNumber} for past slot ${itemSlot} (current ${slotAtNextL1Block})`, {
+                    number: itemNumber,
+                    type,
                     l1Timestamp,
-                    slotAtNextL1Block
+                    slotAtNextL1Block,
+                    nextSlotTimestamp
                 });
-                reject(new Error(`Block ${block.number} is for past slot ${blockSlot} (current is ${slotAtNextL1Block})`));
+                reject(new BlockOrCheckpointSlotExpiredError(itemSlot, nextSlotTimestamp, l1Timestamp));
                 continue;
             }
             try {
-                await this.updater.addProposedBlocks([
-                    block
-                ]);
-                this.log.debug(`Added block ${block.number} to store`);
+                if (type === 'block') {
+                    const [durationMs] = await elapsed(()=>this.updater.addProposedBlock(item.block));
+                    this.instrumentation.processNewProposedBlock(durationMs, item.block);
+                } else {
+                    await this.updater.addProposedCheckpoint(item.checkpoint);
+                }
+                this.log.debug(`Added ${type} ${itemNumber} to store`);
                 resolve();
             } catch (err) {
-                this.log.error(`Failed to add block ${block.number} to store: ${err.message}`);
+                if (err instanceof BlockAlreadyCheckpointedError) {
+                    this.log.debug(`Proposed block ${itemNumber} matches already checkpointed block, ignoring late proposal`);
+                    resolve();
+                    continue;
+                }
+                this.log.error(`Failed to add ${type} ${itemNumber} to store: ${err.message}`, err, {
+                    number: itemNumber,
+                    type
+                });
                 reject(err);
             }
         }
@@ -543,9 +623,88 @@ _dec = trackSpan('Archiver.sync');
    * Fetches logs from L1 contracts and processes them.
    */ async sync() {
         // Process any queued blocks first, before doing L1 sync
-        await this.processQueuedBlocks();
+        await this.processInboundQueue();
         // Now perform L1 sync
         await this.syncFromL1();
+        // Prune proposed blocks with no corresponding proposed checkpoint by the end of their build slot.
+        await this.pruneOrphanProposedBlocks();
+    }
+    /**
+   * Prunes a block-only local tip that was built atop a checkpoint that was never itself proposed.
+   *
+   * Under pipelining, a proposer publishes the blocks for a checkpoint (block-only proposals) before
+   * assembling and publishing the enclosing proposed checkpoint at the end of the build slot. A node
+   * that received those blocks but never the proposed checkpoint is left with an orphan tip it must
+   * not build on. We prune it once enough wall-clock time has elapsed that the proposed checkpoint
+   * should have arrived. This runs on wall-clock time (not L1 block advancement) so it fires during
+   * quiet L1 periods, and is the liveness counterpart to the sequencer's checkSync guard.
+   *
+   * The uncheckpointed suffix is scanned in order. Blocks covered by proposed checkpoints are left in
+   * place; the first block not covered by a proposed checkpoint starts the orphan suffix to prune.
+   */ async pruneOrphanProposedBlocks() {
+        // Orphan pruning is a pipelining-only liveness mechanism: it cleans up block-only proposals
+        // whose enclosing checkpoint never arrived over gossip. The test-only automine sequencer is
+        // non-pipelined — it publishes each checkpoint synchronously in the slot it builds — so it
+        // never produces orphan proposed blocks. Running the prune there would race its two-step local
+        // push (addBlock then addProposedCheckpoint) and delete the block before its checkpoint attaches.
+        if (!this.config.enableOrphanProposedBlockPruning) {
+            return;
+        }
+        const tips = await this.getL2Tips();
+        const now = BigInt(this.dateProvider.nowInSeconds());
+        const pipeliningOffset = PROPOSER_PIPELINING_SLOT_OFFSET;
+        // The proposed tip is a proposed-checkpointed block, so there are no orphan proposed blocks to prune
+        if (tips.proposedCheckpoint.block.number === tips.proposed.number) {
+            this.log.trace(`No orphan proposed blocks to prune: proposed tip ${tips.proposed.number} is checkpointed`, pick(tips, 'proposed', 'proposedCheckpoint'));
+            return;
+        }
+        // Load the blocks that are candidates for pruning (ie blocks without a proposed checkpoint covering them)
+        const blocksWithoutProposedCheckpoint = await this.stores.blocks.getBlocksData({
+            from: BlockNumber(tips.proposedCheckpoint.block.number + 1),
+            limit: tips.proposed.number - tips.proposedCheckpoint.block.number
+        });
+        // Iterate through them in order, the first one with a slot that should have received a proposed checkpoint
+        // is the first orphan block, and all blocks after it are also orphaned and should be pruned.
+        let lastSlotChecked = undefined;
+        for (const blockData of blocksWithoutProposedCheckpoint){
+            // No need to recheck if this block had the same slot as the previous one.
+            const blockSlot = blockData.header.getSlot();
+            const blockNumber = blockData.header.getBlockNumber();
+            if (lastSlotChecked !== undefined && blockSlot === lastSlotChecked) {
+                continue;
+            }
+            lastSlotChecked = blockSlot;
+            // The proposed checkpoint should have landed by the start of the slot after the block's build slot
+            // (build slot = blockSlot - pipeliningOffset). Wait a grace period beyond that to tolerate propagation.
+            const expectedCheckpointedBySlot = SlotNumber(Number(blockSlot) - pipeliningOffset + 1);
+            const expectedCheckpointedByTime = getTimestampForSlot(expectedCheckpointedBySlot, this.l1Constants) + BigInt(this.config.orphanProposedBlockPruneGraceSeconds);
+            // If it's not checkpointed by the expected time, prune it along with all blocks after it.
+            if (now >= expectedCheckpointedByTime) {
+                const pruneAfterBlockNumber = BlockNumber(blockNumber - 1);
+                this.log.warn(`Pruning orphan blocks after block ${pruneAfterBlockNumber}: block at slot ${blockSlot} belongs to ` + `checkpoint ${blockData.checkpointNumber} which has no matching proposed checkpoint`, {
+                    firstUncheckpointedBlockHeader: blockData.header.toInspect(),
+                    blockCheckpointNumber: blockData.checkpointNumber,
+                    blockNumber,
+                    blockSlot,
+                    pipeliningOffset,
+                    expectedCheckpointedBySlot,
+                    expectedCheckpointedByTime,
+                    now
+                });
+                const prunedBlocks = await this.updater.removeBlocksWithoutProposedCheckpointAfter(pruneAfterBlockNumber);
+                if (prunedBlocks.length > 0) {
+                    this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
+                        type: L2BlockSourceEvents.L2PruneUncheckpointed,
+                        slotNumber: blockSlot,
+                        blocks: prunedBlocks
+                    });
+                }
+                return;
+            }
+        }
+        this.log.trace('No orphan proposed blocks to prune: all uncheckpointed blocks are still within the grace period', {
+            blocksWithoutProposedCheckpoint: blocksWithoutProposedCheckpoint.map((b)=>b.header.toInspect())
+        });
     }
     async syncFromL1() {
         // Delegate to the L1 synchronizer
@@ -557,7 +716,7 @@ _dec = trackSpan('Archiver.sync');
             if (currentL1BlockNumber + 1n >= l1BlockNumberAtEnd) {
                 this.log.info(`Initial archiver sync to L1 block ${currentL1BlockNumber} complete`, {
                     l1BlockNumber: currentL1BlockNumber,
-                    syncPoint: await this.store.getSynchPoint(),
+                    syncPoint: await getArchiverSynchPoint(this.stores),
                     ...await this.getL2Tips()
                 });
                 this.runningPromise.setPollingIntervalMS(this.config.pollingIntervalMs);
@@ -583,7 +742,7 @@ _dec = trackSpan('Archiver.sync');
         return Promise.resolve();
     }
     backupTo(destPath) {
-        return this.dataStore.backupTo(destPath);
+        return backupArchiverDataStores(this.dataStores, destPath);
     }
     getL1Constants() {
         return Promise.resolve(this.l1Constants);
@@ -605,20 +764,53 @@ _dec = trackSpan('Archiver.sync');
     getL1Timestamp() {
         return Promise.resolve(this.synchronizer.getL1Timestamp());
     }
-    getL2SlotNumber() {
+    async getSyncedL2SlotNumber() {
+        // The synced L2 slot is the latest slot for which we have all L1 data,
+        // either because we have seen all L1 blocks for that slot, or because
+        // we have seen the corresponding checkpoint.
+        let slotFromL1Sync;
         const l1Timestamp = this.synchronizer.getL1Timestamp();
-        return Promise.resolve(l1Timestamp === undefined ? undefined : getSlotAtTimestamp(l1Timestamp, this.l1Constants));
+        if (l1Timestamp !== undefined) {
+            const nextL1BlockSlot = getSlotAtNextL1Block(l1Timestamp, this.l1Constants);
+            if (Number(nextL1BlockSlot) > 0) {
+                slotFromL1Sync = SlotNumber.add(nextL1BlockSlot, -1);
+            }
+        }
+        let slotFromCheckpoint;
+        const latestCheckpointNumber = await this.stores.blocks.getLatestCheckpointNumber();
+        if (latestCheckpointNumber > 0) {
+            const checkpointData = await this.stores.blocks.getCheckpointData(latestCheckpointNumber);
+            if (checkpointData) {
+                slotFromCheckpoint = checkpointData.header.slotNumber;
+            }
+        }
+        if (slotFromL1Sync === undefined && slotFromCheckpoint === undefined) {
+            return undefined;
+        }
+        return SlotNumber(Math.max(slotFromL1Sync ?? 0, slotFromCheckpoint ?? 0));
     }
-    getL2EpochNumber() {
-        const l1Timestamp = this.synchronizer.getL1Timestamp();
-        return Promise.resolve(l1Timestamp === undefined ? undefined : getEpochNumberAtTimestamp(l1Timestamp, this.l1Constants));
+    async getSyncedL2EpochNumber() {
+        const syncedSlot = await this.getSyncedL2SlotNumber();
+        if (syncedSlot === undefined) {
+            return undefined;
+        }
+        // An epoch is fully synced when all its slots are synced.
+        // We check if syncedSlot is the last slot of its epoch; if so, that epoch is fully synced.
+        // Otherwise, only the previous epoch is fully synced.
+        const epoch = getEpochAtSlot(syncedSlot, this.l1Constants);
+        const [, endSlot] = getSlotRangeForEpoch(epoch, this.l1Constants);
+        if (syncedSlot >= endSlot) {
+            return epoch;
+        }
+        return Number(epoch) > 0 ? EpochNumber(Number(epoch) - 1) : undefined;
     }
     async isEpochComplete(epochNumber) {
         // 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 header = (await this.getBlockData({
+            tag: 'checkpointed'
+        }))?.header;
         const slot = header ? header.globalVariables.slotNumber : undefined;
         const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
         if (slot && slot >= endSlot) {
@@ -650,106 +842,38 @@ _dec = trackSpan('Archiver.sync');
         await this.updater.addCheckpoints(checkpoints, pendingChainValidationStatus);
         return true;
     }
-    async getL2Tips() {
-        const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
-            this.getBlockNumber(),
-            this.getProvenBlockNumber(),
-            this.getCheckpointedL2BlockNumber(),
-            this.getFinalizedL2BlockNumber()
-        ]);
-        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.getCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1) : [
-                undefined
-            ],
-            finalizedCheckpointedBlock !== undefined ? await this.getCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1) : [
-                undefined
-            ],
-            checkpointedBlock !== undefined ? await this.getCheckpoints(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;
+    getL2Tips() {
+        return this.l2TipsCache.getL2Tips();
     }
     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 targetL2Block = await this.store.getCheckpointedBlock(targetL2BlockNumber);
-        if (!targetL2Block) {
+        const checkpointedTip = await this.stores.blocks.getCheckpointedL2BlockNumber();
+        if (targetL2BlockNumber > checkpointedTip) {
+            throw new Error(`Target L2 block ${targetL2BlockNumber} is not checkpointed yet`);
+        }
+        const targetBlockData = await this.stores.blocks.getBlockData({
+            number: targetL2BlockNumber
+        });
+        if (!targetBlockData) {
             throw new Error(`Target L2 block ${targetL2BlockNumber} not found`);
         }
-        const targetL1BlockNumber = targetL2Block.l1.blockNumber;
-        const targetCheckpointNumber = targetL2Block.checkpointNumber;
+        const targetCheckpointNumber = targetBlockData.checkpointNumber;
+        // Rollback operates at checkpoint granularity: the target block must be the last block of its checkpoint.
+        const checkpointData = await this.stores.blocks.getCheckpointData(targetCheckpointNumber);
+        if (!checkpointData) {
+            throw new Error(`Checkpoint ${targetCheckpointNumber} not found for block ${targetL2BlockNumber}`);
+        }
+        const lastBlockInCheckpoint = BlockNumber(checkpointData.startBlock + checkpointData.blockCount - 1);
+        if (targetL2BlockNumber !== lastBlockInCheckpoint) {
+            const previousCheckpointBoundary = checkpointData.startBlock > 1 ? BlockNumber(checkpointData.startBlock - 1) : BlockNumber(0);
+            throw new Error(`Target L2 block ${targetL2BlockNumber} is not at a checkpoint boundary. ` + `Checkpoint ${targetCheckpointNumber} spans blocks ${checkpointData.startBlock} to ${lastBlockInCheckpoint}. ` + `Use block ${lastBlockInCheckpoint} to roll back to this checkpoint, ` + `or block ${previousCheckpointBoundary} to roll back to the previous one.`);
+        }
+        const targetL1BlockNumber = checkpointData.l1.blockNumber;
         const targetL1Block = await this.publicClient.getBlock({
             blockNumber: targetL1BlockNumber,
             includeTransactions: false
@@ -761,21 +885,21 @@ _dec = trackSpan('Archiver.sync');
         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);
+        await this.stores.messages.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
         this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
-        await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);
-        await this.store.setMessageSynchedL1Block({
+        await this.stores.blocks.setSynchedL1BlockNumber(targetL1BlockNumber);
+        await this.stores.messages.setMessageSyncState({
             l1BlockNumber: targetL1BlockNumber,
             l1BlockHash: targetL1BlockHash
-        });
+        }, undefined);
         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);
-    // }
+            this.log.info(`Rolling back proven L2 checkpoint to ${targetCheckpointNumber}`);
+            await this.updater.setProvenCheckpointNumber(targetCheckpointNumber);
+        }
+        const currentFinalizedBlock = currentBlocks.finalized.block.number;
+        if (targetL2BlockNumber < currentFinalizedBlock) {
+            this.log.info(`Rolling back finalized L2 checkpoint to ${targetCheckpointNumber}`);
+            await this.updater.setFinalizedCheckpointNumber(targetCheckpointNumber);
+        }
     }
 }

package/dest/config.d.ts

@@ -24,7 +24,10 @@ export declare function mapArchiverConfig(config: Partial<ArchiverConfig>): {
     pollingIntervalMs: number | undefined;
     batchSize: number | undefined;
     skipValidateCheckpointAttestations: boolean | undefined;
+    skipPromoteProposedCheckpointDuringL1Sync: boolean | undefined;
     maxAllowedEthClientDriftSeconds: number | undefined;
     ethereumAllowNoDebugHosts: boolean | undefined;
+    skipHistoricalLogsCheck: boolean | undefined;
+    orphanProposedBlockPruneGraceSeconds: number | undefined;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUEyQixNQUFNLGtDQUFrQyxDQUFDO0FBQ2xHLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUE2QixNQUFNLHdCQUF3QixDQUFDO0FBRTNGLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSwyQkFBMkIsQ0FBQztBQUN4RixPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFJeEIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsQyxPQUFPLEVBQUUsS0FBSyxXQUFXLEVBQXVCLE1BQU0sc0JBQXNCLENBQUM7QUFDN0UsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RTs7Ozs7O0dBTUc7QUFDSCxNQUFNLE1BQU0sY0FBYyxHQUFHLHNCQUFzQixHQUNqRCxjQUFjLEdBQ2QsaUJBQWlCLEdBQ2pCLGdCQUFnQixHQUNoQixXQUFXLENBQUM7QUFFZCxlQUFPLE1BQU0sc0JBQXNCLEVBQUUsa0JBQWtCLENBQUMsY0FBYyxDQWdEckUsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0Isd0JBQXdCLElBQUksY0FBYyxDQUV6RDtBQUVELGdGQUFnRjtBQUNoRix3QkFBZ0IsaUJBQWlCLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxjQUFjLENBQUM7Ozs7OztFQVFoRSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUEyQixNQUFNLGtDQUFrQyxDQUFDO0FBQ2xHLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUE2QixNQUFNLHdCQUF3QixDQUFDO0FBQzNGLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSwyQkFBMkIsQ0FBQztBQUN4RixPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFLeEIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsQyxPQUFPLEVBQUUsS0FBSyxXQUFXLEVBQXVCLE1BQU0sc0JBQXNCLENBQUM7QUFDN0UsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RTs7Ozs7O0dBTUc7QUFDSCxNQUFNLE1BQU0sY0FBYyxHQUFHLHNCQUFzQixHQUNqRCxjQUFjLEdBQ2QsaUJBQWlCLEdBQ2pCLGdCQUFnQixHQUNoQixXQUFXLENBQUM7QUFFZCxlQUFPLE1BQU0sc0JBQXNCLEVBQUUsa0JBQWtCLENBQUMsY0FBYyxDQTBEckUsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0Isd0JBQXdCLElBQUksY0FBYyxDQUV6RDtBQUVELGdGQUFnRjtBQUNoRix3QkFBZ0IsaUJBQWlCLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxjQUFjLENBQUM7Ozs7Ozs7OztFQVdoRSJ9

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAA2B,MAAM,kCAAkC,CAAC;AAClG,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,wBAAwB,CAAC;AAE3F,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,2BAA2B,CAAC;AACxF,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,sBAAsB,GACjD,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,WAAW,CAAC;AAEd,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CAgDrE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,CAEzD;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC;;;;;;EAQhE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAA2B,MAAM,kCAAkC,CAAC;AAClG,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,2BAA2B,CAAC;AACxF,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,sBAAsB,GACjD,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,WAAW,CAAC;AAEd,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CA0DrE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,CAEzD;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC;;;;;;;;;EAWhE"}