@aztec/archiver 0.0.1-commit.e588bc7e5 → 0.0.1-commit.e5a3663dd

package/src/archiver.ts

@@ -11,7 +11,7 @@ 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 { DateProvider, elapsed } from '@aztec/foundation/timer';
 import {
   type ArchiverEmitter,
   L2Block,
@@ -25,18 +25,20 @@ import {
   getEpochAtSlot,
   getSlotAtNextL1Block,
   getSlotRangeForEpoch,
+  getTimestampForSlot,
   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 { BlockAlreadyCheckpointedError, 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 type { ArchiverInstrumentation } from './modules/instrumentation.js';
 import type { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
-import type { KVArchiverDataStore } from './store/kv_archiver_store.js';
+import { type ArchiverDataStores, backupArchiverDataStores, getArchiverSynchPoint } from './store/data_stores.js';
 import { L2TipsCache } from './store/l2_tips_cache.js';
 
 /** Export ArchiverEmitter for use in factory and tests. */
@@ -44,11 +46,20 @@ export type { ArchiverEmitter };
 
 /** Request to add a block to the archiver, queued for processing by the sync loop. */
 type AddBlockRequest = {
+  type: 'block';
   block: L2Block;
   resolve: () => void;
   reject: (err: Error) => void;
 };
 
+/** Request to add a proposed checkpoint to the archiver, queued for processing by the sync loop. */
+type AddProposedCheckpointRequest = {
+  type: 'checkpoint';
+  checkpoint: ProposedCheckpointInput;
+  resolve: () => void;
+  reject: (err: Error) => void;
+};
+
 export type ArchiverDeps = {
   telemetry?: TelemetryClient;
   blobClient: BlobClientInterface;
@@ -74,8 +85,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   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[] = [];
+  /** Queue of blocks and checkpoints to be added to the store, processed by the sync loop. */
+  private inboundQueue: (AddBlockRequest | AddProposedCheckpointRequest)[] = [];
 
   /** Helper to handle updates to the store */
   private readonly updater: ArchiverDataStoreUpdater;
@@ -85,14 +96,16 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
 
   public readonly tracer: Tracer;
 
+  private readonly instrumentation: ArchiverInstrumentation;
+
   /**
    * 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 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 dateProvider - Provider for current date/time.
@@ -106,15 +119,18 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     private readonly rollup: RollupContract,
     private readonly l1Addresses: Pick<
       L1ContractAddresses,
-      'registryAddress' | 'governanceProposerAddress' | 'slashFactoryAddress'
-    > & { slashingProposerAddress: EthAddress },
-    readonly dataStore: KVArchiverDataStore,
+      'rollupAddress' | 'registryAddress' | 'inboxAddress' | 'governanceProposerAddress'
+    > & {
+      slashingProposerAddress: EthAddress;
+    },
+    readonly dataStores: ArchiverDataStores,
     private config: {
       pollingIntervalMs: number;
       batchSize: number;
       skipValidateCheckpointAttestations?: boolean;
       maxAllowedEthClientDriftSeconds: number;
       ethereumAllowNoDebugHosts?: boolean;
+      skipHistoricalLogsCheck?: boolean;
     },
     private readonly blobClient: BlobClientInterface,
     instrumentation: ArchiverInstrumentation,
@@ -127,14 +143,15 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     l2TipsCache?: L2TipsCache,
     private readonly log: Logger = createLogger('archiver'),
   ) {
-    super(dataStore, l1Constants);
+    super(dataStores, l1Constants);
 
     this.tracer = instrumentation.tracer;
+    this.instrumentation = instrumentation;
     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, {
+    this.l2TipsCache = l2TipsCache ?? new L2TipsCache(this.dataStores.blocks);
+    this.updater = new ArchiverDataStoreUpdater(this.dataStores, this.l2TipsCache, {
       rollupManaLimit: l1Constants.rollupManaLimit,
     });
 
@@ -170,10 +187,23 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       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 { blocksSynchedTo = l1StartBlock, messagesSynchedTo = l1StartBlock } = await getArchiverSynchPoint(
+      this.stores,
+    );
     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}`,
@@ -191,6 +221,14 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     return this.runningPromise.trigger();
   }
 
+  public 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.
@@ -199,62 +237,85 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
    * @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}`);
-      });
-    });
+    const promise = promiseWithResolvers<void>();
+    this.inboundQueue.push({ block, ...promise, type: 'block' });
+    this.log.debug(`Queued block ${block.number} for processing`);
+    void this.trySyncImmediate();
+    return promise.promise;
   }
 
-  public async setProposedCheckpoint(pending: ProposedCheckpointInput): Promise<void> {
-    await this.updater.setProposedCheckpoint(pending);
+  /**
+   * 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.
+   */
+  public addProposedCheckpoint(pending: ProposedCheckpointInput): Promise<void> {
+    const promise = promiseWithResolvers<void>();
+    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.
+   * Items are processed in the order they were queued.
    */
-  private async processQueuedBlocks(): Promise<void> {
-    if (this.blockQueue.length === 0) {
+  private async processInboundQueue(): Promise<void> {
+    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) {
+    // Helpers for manipulating blocks and checkpoints in the queue
+    const getSlot: (item: AddBlockRequest | AddProposedCheckpointRequest) => SlotNumber = item =>
+      item.type === 'block' ? item.block.header.globalVariables.slotNumber : item.checkpoint.header.slotNumber;
+    const getNumber: (item: AddBlockRequest | AddProposedCheckpointRequest) => number = 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 block ${block.number} for past slot ${blockSlot} (current is ${slotAtNextL1Block})`,
-          { block: block.toBlockInfo(), l1Timestamp, slotAtNextL1Block },
+          `Rejecting proposed ${type} ${itemNumber} for past slot ${itemSlot} (current ${slotAtNextL1Block})`,
+          { number: itemNumber, type, l1Timestamp, 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.addProposedBlock(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: any) {
         if (err instanceof BlockAlreadyCheckpointedError) {
-          this.log.debug(`Proposed block ${block.number} matches already checkpointed block, ignoring late proposal`);
+          this.log.debug(`Proposed block ${itemNumber} matches already checkpointed block, ignoring late proposal`);
           resolve();
           continue;
         }
-        this.log.error(`Failed to add block ${block.number} to store: ${err.message}`);
+        this.log.error(`Failed to add ${type} ${itemNumber} to store: ${err.message}`, err, {
+          number: itemNumber,
+          type,
+        });
         reject(err);
       }
     }
@@ -270,7 +331,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   @trackSpan('Archiver.sync')
   private async sync() {
     // Process any queued blocks first, before doing L1 sync
-    await this.processQueuedBlocks();
+    await this.processInboundQueue();
     // Now perform L1 sync
     await this.syncFromL1();
   }
@@ -286,7 +347,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       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);
@@ -318,7 +379,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   }
 
   public backupTo(destPath: string): Promise<string> {
-    return this.dataStore.backupTo(destPath);
+    return backupArchiverDataStores(this.dataStores, destPath);
   }
 
   public getL1Constants(): Promise<L1RollupConstants> {
@@ -360,9 +421,9 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     }
 
     let slotFromCheckpoint: SlotNumber | undefined;
-    const latestCheckpointNumber = await this.store.getSynchedCheckpointNumber();
+    const latestCheckpointNumber = await this.stores.blocks.getLatestCheckpointNumber();
     if (latestCheckpointNumber > 0) {
-      const checkpointData = await this.store.getCheckpointData(latestCheckpointNumber);
+      const checkpointData = await this.stores.blocks.getCheckpointData(latestCheckpointNumber);
       if (checkpointData) {
         slotFromCheckpoint = checkpointData.header.slotNumber;
       }
@@ -451,14 +512,14 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     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);
+    const targetL2Block = await this.stores.blocks.getCheckpointedBlock(targetL2BlockNumber);
     if (!targetL2Block) {
       throw new Error(`Target L2 block ${targetL2BlockNumber} not found`);
     }
     const targetCheckpointNumber = targetL2Block.checkpointNumber;
 
     // Rollback operates at checkpoint granularity: the target block must be the last block of its checkpoint.
-    const checkpointData = await this.store.getCheckpointData(targetCheckpointNumber);
+    const checkpointData = await this.stores.blocks.getCheckpointData(targetCheckpointNumber);
     if (checkpointData) {
       const lastBlockInCheckpoint = BlockNumber(checkpointData.startBlock + checkpointData.blockCount - 1);
       if (targetL2BlockNumber !== lastBlockInCheckpoint) {
@@ -487,10 +548,10 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     );
     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.setMessageSyncState(
+    await this.stores.blocks.setSynchedL1BlockNumber(targetL1BlockNumber);
+    await this.stores.messages.setMessageSyncState(
       { l1BlockNumber: targetL1BlockNumber, l1BlockHash: targetL1BlockHash },
       undefined,
     );

package/src/config.ts

@@ -7,6 +7,7 @@ import {
   booleanConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 import {
   type ChainConfig,
@@ -50,13 +51,17 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   },
   archiverStoreMapSizeKb: {
     env: 'ARCHIVER_STORE_MAP_SIZE_KB',
-    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
   skipValidateCheckpointAttestations: {
     description: 'Skip validating checkpoint attestations (for testing purposes only)',
     ...booleanConfigHelper(false),
   },
+  skipPromoteProposedCheckpointDuringL1Sync: {
+    description: 'Skip promoting proposed checkpoints during L1 sync (for testing purposes only)',
+    ...booleanConfigHelper(false),
+  },
   maxAllowedEthClientDriftSeconds: {
     env: 'MAX_ALLOWED_ETH_CLIENT_DRIFT_SECONDS',
     description: 'Maximum allowed drift in seconds between the Ethereum client and current time.',
@@ -67,6 +72,13 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'Whether to allow starting the archiver without debug/trace method support on Ethereum hosts',
     ...booleanConfigHelper(true),
   },
+  archiverSkipHistoricalLogsCheck: {
+    env: 'ARCHIVER_SKIP_HISTORICAL_LOGS_CHECK',
+    description:
+      'Skip the startup check that probes the L1 RPC for historical Rollup contract logs. ' +
+      'Set to true to bypass the check when the connected RPC node is known to prune old logs.',
+    ...booleanConfigHelper(false),
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {
@@ -96,7 +108,9 @@ export function mapArchiverConfig(config: Partial<ArchiverConfig>) {
     pollingIntervalMs: config.archiverPollingIntervalMS,
     batchSize: config.archiverBatchSize,
     skipValidateCheckpointAttestations: config.skipValidateCheckpointAttestations,
+    skipPromoteProposedCheckpointDuringL1Sync: config.skipPromoteProposedCheckpointDuringL1Sync,
     maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
     ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts,
+    skipHistoricalLogsCheck: config.archiverSkipHistoricalLogsCheck,
   };
 }

package/src/errors.ts

@@ -1,14 +1,17 @@
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/schemas';
 
 export class NoBlobBodiesFoundError extends Error {
   constructor(l2BlockNum: number) {
     super(`No blob bodies found for block ${l2BlockNum}`);
+    this.name = 'NoBlobBodiesFoundError';
   }
 }
 
 export class BlockNumberNotSequentialError extends Error {
   constructor(newBlockNumber: number, previous: number | undefined) {
     super(`Cannot insert new block ${newBlockNumber} given previous block number is ${previous ?? 'undefined'}`);
+    this.name = 'BlockNumberNotSequentialError';
   }
 }
 
@@ -22,18 +25,29 @@ export class InitialCheckpointNumberNotSequentialError extends Error {
         previousCheckpointNumber ?? 'undefined'
       }`,
     );
+    this.name = 'InitialCheckpointNumberNotSequentialError';
   }
 }
 
-export class CheckpointNumberNotSequentialError extends Error {
+export class BlockCheckpointNumberNotSequentialError extends Error {
   constructor(
-    newCheckpointNumber: number,
-    previous: number | undefined,
-    source: 'confirmed' | 'proposed' = 'confirmed',
+    blockNumber: BlockNumber,
+    blockCheckpointNumber: CheckpointNumber,
+    previous: CheckpointNumber | undefined,
   ) {
     super(
-      `Cannot insert new checkpoint ${newCheckpointNumber} given previous ${source} checkpoint number is ${previous ?? 'undefined'}`,
+      `Cannot insert new block ${blockNumber} for checkpoint ${blockCheckpointNumber} given previous checkpoint number is ${previous ?? 'undefined'}`,
+    );
+    this.name = 'BlockCheckpointNumberNotSequentialError';
+  }
+}
+
+export class CheckpointNumberNotSequentialError extends Error {
+  constructor(newCheckpointNumber: CheckpointNumber, previous: CheckpointNumber | undefined) {
+    super(
+      `Cannot insert new checkpoint ${newCheckpointNumber} given previous checkpoint number is ${previous ?? 'undefined'}`,
     );
+    this.name = 'CheckpointNumberNotSequentialError';
   }
 }
 
@@ -42,6 +56,7 @@ export class BlockIndexNotSequentialError extends Error {
     super(
       `Cannot insert new block at checkpoint index ${newBlockIndex} given previous block index is ${previousBlockIndex ?? 'undefined'}`,
     );
+    this.name = 'BlockIndexNotSequentialError';
   }
 }
 
@@ -55,18 +70,21 @@ export class BlockArchiveNotConsistentError extends Error {
     super(
       `Cannot insert new block number ${newBlockNumber} with archive ${newBlockArchive.toString()} previous block number is ${previousBlockNumber ?? 'undefined'}, previous archive is ${previousBlockArchive?.toString() ?? 'undefined'}`,
     );
+    this.name = 'BlockArchiveNotConsistentError';
   }
 }
 
 export class CheckpointNotFoundError extends Error {
   constructor(checkpointNumber: number) {
     super(`Failed to find expected checkpoint number ${checkpointNumber}`);
+    this.name = 'CheckpointNotFoundError';
   }
 }
 
 export class BlockNotFoundError extends Error {
   constructor(blockNumber: number) {
     super(`Failed to find expected block number ${blockNumber}`);
+    this.name = 'BlockNotFoundError';
   }
 }
 
@@ -119,19 +137,68 @@ export class ProposedCheckpointStaleError extends Error {
   }
 }
 
-/** Thrown when a proposed checkpoint number is not the expected confirmed + 1. */
+/** Thrown when a proposed checkpoint number is not the expected latestTip + 1. */
 export class ProposedCheckpointNotSequentialError extends Error {
   constructor(
     public readonly proposedCheckpointNumber: number,
-    public readonly confirmedCheckpointNumber: number,
+    public readonly latestTipNumber: number,
   ) {
     super(
-      `Proposed checkpoint ${proposedCheckpointNumber} is not sequential: expected ${confirmedCheckpointNumber + 1} (confirmed + 1)`,
+      `Proposed checkpoint ${proposedCheckpointNumber} is not sequential: expected ${latestTipNumber + 1} (latest tip + 1, where tip is highest of confirmed or pending)`,
     );
     this.name = 'ProposedCheckpointNotSequentialError';
   }
 }
 
+/** Thrown when a proposed checkpoint or block L2 slot has already expired on L1. */
+export class BlockOrCheckpointSlotExpiredError extends Error {
+  constructor(
+    public readonly slot: number,
+    public readonly nextSlotStart: bigint,
+    public readonly l1TimestampSynced: bigint | undefined,
+  ) {
+    super(
+      `Checkpoint or block for slot ${slot} is expired: L1 synced to ${l1TimestampSynced} which is past the next slot start ${nextSlotStart}. ` +
+        `If the checkpoint still lands via a late L1 tx, the archiver will pick it up via normal L1-sync (not the pending-queue shortcut).`,
+    );
+    this.name = 'BlockOrCheckpointSlotExpiredError';
+  }
+}
+
+/** Thrown when attempting to promote a proposed checkpoint but no proposed checkpoint exists in the store. */
+export class NoProposedCheckpointToPromoteError extends Error {
+  constructor() {
+    super('Cannot promote proposed checkpoint: no proposed checkpoint exists');
+    this.name = 'NoProposedCheckpointToPromoteError';
+  }
+}
+
+/** Thrown when the archive root of the proposed checkpoint does not match the expected one. */
+export class ProposedCheckpointArchiveRootMismatchError extends Error {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super(
+      `Cannot promote proposed checkpoint: archive root mismatch (expected ${expectedArchiveRoot}, got ${actualArchiveRoot})`,
+    );
+    this.name = 'ProposedCheckpointArchiveRootMismatchError';
+  }
+}
+
+/** Thrown when the proposed checkpoint does not directly follow the latest confirmed checkpoint. */
+export class ProposedCheckpointPromotionNotSequentialError extends Error {
+  constructor(
+    public readonly proposedCheckpointNumber: number,
+    public readonly latestCheckpointNumber: number,
+  ) {
+    super(
+      `Cannot promote proposed checkpoint: not sequential (latest ${latestCheckpointNumber}, proposed ${proposedCheckpointNumber})`,
+    );
+    this.name = 'ProposedCheckpointPromotionNotSequentialError';
+  }
+}
+
 /** Thrown when a proposed block conflicts with an already checkpointed block (different content). */
 export class CannotOverwriteCheckpointedBlockError extends Error {
   constructor(

package/src/factory.ts

@@ -24,7 +24,7 @@ import { Archiver, type ArchiverDeps } from './archiver.js';
 import { type ArchiverConfig, mapArchiverConfig } from './config.js';
 import { ArchiverInstrumentation } from './modules/instrumentation.js';
 import { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
-import { ARCHIVER_DB_VERSION, KVArchiverDataStore } from './store/kv_archiver_store.js';
+import { ARCHIVER_DB_VERSION, type ArchiverDataStores, createArchiverDataStores } from './store/data_stores.js';
 import { L2TipsCache } from './store/l2_tips_cache.js';
 
 export const ARCHIVER_STORE_NAME = 'archiver';
@@ -32,13 +32,13 @@ export const ARCHIVER_STORE_NAME = 'archiver';
 /** Creates an archiver store. */
 export async function createArchiverStore(
   userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
-) {
+): Promise<ArchiverDataStores> {
   const config = {
     ...userConfig,
     dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
   const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config);
-  return new KVArchiverDataStore(store, config.maxLogs);
+  return createArchiverDataStores(store, { logsMaxPageSize: config.maxLogs });
 }
 
 /**
@@ -121,19 +121,20 @@ export async function createArchiver(
       batchSize: 100,
       maxAllowedEthClientDriftSeconds: 300,
       ethereumAllowNoDebugHosts: false,
+      skipHistoricalLogsCheck: 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());
+  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => archiverStore.db.estimateSize());
 
   // Create the event emitter that will be shared by archiver and synchronizer
   const events = new EventEmitter() as ArchiverEmitter;
 
   // Create L2 tips cache shared by archiver and synchronizer
-  const l2TipsCache = new L2TipsCache(archiverStore.blockStore);
+  const l2TipsCache = new L2TipsCache(archiverStore.blocks);
 
   // Create the L1 synchronizer
   const synchronizer = new ArchiverL1Synchronizer(
@@ -174,14 +175,14 @@ export async function createArchiver(
 }
 
 /** Registers protocol contracts in the archiver store. Idempotent — skips contracts that already exist (e.g. on node restart). */
-export async function registerProtocolContracts(store: KVArchiverDataStore) {
+export async function registerProtocolContracts(stores: ArchiverDataStores) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const provider = new BundledProtocolContractsProvider();
     const contract = await provider.getProtocolContractArtifact(name);
 
     // Skip if already registered (happens on node restart with a persisted store).
-    if (await store.getContractClass(contract.contractClass.id)) {
+    if (await stores.contractClasses.getContractClass(contract.contractClass.id)) {
       continue;
     }
 
@@ -195,8 +196,8 @@ export async function registerProtocolContracts(store: KVArchiverDataStore) {
       .filter(fn => fn.functionType === FunctionType.PUBLIC)
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
-    await store.registerContractFunctionSignatures(publicFunctionSignatures);
-    await store.addContractClasses([contractClassPublic], BlockNumber(blockNumber));
-    await store.addContractInstances([contract.instance], BlockNumber(blockNumber));
+    await stores.functionNames.register(publicFunctionSignatures);
+    await stores.contractClasses.addContractClasses([contractClassPublic], BlockNumber(blockNumber));
+    await stores.contractInstances.addContractInstances([contract.instance], BlockNumber(blockNumber));
   }
 }

package/src/index.ts

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