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

package/src/modules/data_source_base.ts

@@ -24,19 +24,19 @@ import type { BlockHeader, IndexedTxEffect, TxHash, TxReceipt } from '@aztec/std
 import type { UInt64 } from '@aztec/stdlib/types';
 
 import type { ArchiverDataSource } from '../interfaces.js';
-import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import type { ArchiverDataStores } from '../store/data_stores.js';
 import type { ValidateCheckpointResult } from './validation.js';
 
 /**
- * Abstract base class implementing ArchiverDataSource using a KVArchiverDataStore.
- * Provides implementations for all store-delegating methods and declares abstract methods
- * for L1-dependent functionality that subclasses must implement.
+ * Abstract base class implementing ArchiverDataSource using a bundle of archiver substores.
+ * Provides implementations for all read-side methods and declares abstract methods for
+ * L1-dependent functionality that subclasses must implement.
  */
 export abstract class ArchiverDataSourceBase
   implements ArchiverDataSource, L2LogsSource, ContractDataSource, L1ToL2MessageSource
 {
   constructor(
-    protected readonly store: KVArchiverDataStore,
+    protected readonly stores: ArchiverDataStores,
     protected readonly l1Constants?: L1RollupConstants,
   ) {}
 
@@ -61,54 +61,54 @@ export abstract class ArchiverDataSourceBase
   abstract syncImmediate(): Promise<void>;
 
   public getCheckpointNumber(): Promise<CheckpointNumber> {
-    return this.store.getSynchedCheckpointNumber();
+    return this.stores.blocks.getLatestCheckpointNumber();
   }
 
   public getSynchedCheckpointNumber(): Promise<CheckpointNumber> {
-    return this.store.getSynchedCheckpointNumber();
+    return this.stores.blocks.getLatestCheckpointNumber();
   }
 
   public getProvenCheckpointNumber(): Promise<CheckpointNumber> {
-    return this.store.getProvenCheckpointNumber();
+    return this.stores.blocks.getProvenCheckpointNumber();
   }
 
   public getBlockNumber(): Promise<BlockNumber> {
-    return this.store.getLatestBlockNumber();
+    return this.stores.blocks.getLatestL2BlockNumber();
   }
 
   public getProvenBlockNumber(): Promise<BlockNumber> {
-    return this.store.getProvenBlockNumber();
+    return this.stores.blocks.getProvenBlockNumber();
   }
 
   public async getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined> {
-    const blockNumber = number === 'latest' ? await this.store.getLatestBlockNumber() : number;
+    const blockNumber = number === 'latest' ? await this.stores.blocks.getLatestL2BlockNumber() : number;
     if (blockNumber === 0) {
       return undefined;
     }
-    const headers = await this.store.getBlockHeaders(blockNumber, 1);
+    const headers = await this.stores.blocks.getBlockHeaders(blockNumber, 1);
     return headers.length === 0 ? undefined : headers[0];
   }
 
   public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
-    return this.store.getCheckpointedBlock(number);
+    return this.stores.blocks.getCheckpointedBlock(number);
   }
 
   public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
-    return this.store.getCheckpointedL2BlockNumber();
+    return this.stores.blocks.getCheckpointedL2BlockNumber();
   }
 
   public getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    return this.store.getFinalizedL2BlockNumber();
+    return this.stores.blocks.getFinalizedL2BlockNumber();
   }
 
   public async getCheckpointHeader(number: CheckpointNumber | 'latest'): Promise<CheckpointHeader | undefined> {
     if (number === 'latest') {
-      number = await this.store.getSynchedCheckpointNumber();
+      number = await this.stores.blocks.getLatestCheckpointNumber();
     }
     if (number === 0) {
       return undefined;
     }
-    const checkpoint = await this.store.getCheckpointData(number);
+    const checkpoint = await this.stores.blocks.getCheckpointData(number);
     if (!checkpoint) {
       return undefined;
     }
@@ -116,7 +116,7 @@ export abstract class ArchiverDataSourceBase
   }
 
   public async getLastBlockNumberInCheckpoint(checkpointNumber: CheckpointNumber): Promise<BlockNumber | undefined> {
-    const checkpointData = await this.store.getCheckpointData(checkpointNumber);
+    const checkpointData = await this.stores.blocks.getCheckpointData(checkpointNumber);
     if (!checkpointData) {
       return undefined;
     }
@@ -124,51 +124,66 @@ export abstract class ArchiverDataSourceBase
   }
 
   public getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
-    return this.store.getCheckpointedBlocks(from, limit);
+    return this.stores.blocks.getCheckpointedBlocks(from, limit);
+  }
+
+  public getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined> {
+    return this.stores.blocks.getCheckpointData(checkpointNumber);
+  }
+
+  public getCheckpointDataRange(from: CheckpointNumber, limit: number): Promise<CheckpointData[]> {
+    return this.stores.blocks.getRangeOfCheckpoints(from, limit);
+  }
+
+  public getCheckpointNumberBySlot(slot: SlotNumber): Promise<CheckpointNumber | undefined> {
+    return this.stores.blocks.getCheckpointNumberBySlot(slot);
+  }
+
+  public getBlockDataWithCheckpointContext(blockNumber: BlockNumber) {
+    return this.stores.blocks.getBlockDataWithCheckpointContext(blockNumber);
   }
 
   public getBlockHeaderByHash(blockHash: BlockHash): Promise<BlockHeader | undefined> {
-    return this.store.getBlockHeaderByHash(blockHash);
+    return this.stores.blocks.getBlockHeaderByHash(blockHash);
   }
 
   public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
-    return this.store.getBlockHeaderByArchive(archive);
+    return this.stores.blocks.getBlockHeaderByArchive(archive);
   }
 
   public getBlockData(number: BlockNumber): Promise<BlockData | undefined> {
-    return this.store.getBlockData(number);
+    return this.stores.blocks.getBlockData(number);
   }
 
   public getBlockDataByArchive(archive: Fr): Promise<BlockData | undefined> {
-    return this.store.getBlockDataByArchive(archive);
+    return this.stores.blocks.getBlockDataByArchive(archive);
   }
 
   public async getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
-      number = await this.store.getLatestBlockNumber();
+      number = await this.stores.blocks.getLatestL2BlockNumber();
     }
     if (number === 0) {
       return undefined;
     }
-    const publishedBlock = await this.store.getBlock(number);
-    return publishedBlock;
+    return this.stores.blocks.getBlock(number);
   }
 
   public getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined> {
-    return this.store.getTxEffect(txHash);
+    return this.stores.blocks.getTxEffect(txHash);
   }
 
   public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    return this.store.getSettledTxReceipt(txHash, this.l1Constants);
+    return this.stores.blocks.getSettledTxReceipt(txHash, this.l1Constants);
   }
 
-  public getProposedCheckpoint(): Promise<CommonCheckpointData | undefined> {
-    return this.store.getProposedCheckpoint();
+  public getLastCheckpoint(): Promise<CommonCheckpointData | undefined> {
+    return this.stores.blocks.getLastCheckpoint();
   }
 
-  public getProposedCheckpointOnly(): Promise<ProposedCheckpointData | undefined> {
-    return this.store.getProposedCheckpointOnly();
+  public getLastProposedCheckpoint(): Promise<ProposedCheckpointData | undefined> {
+    return this.stores.blocks.getLastProposedCheckpoint();
   }
 
   public isPendingChainInvalid(): Promise<boolean> {
@@ -176,7 +191,7 @@ export abstract class ArchiverDataSourceBase
   }
 
   public async getPendingChainValidationStatus(): Promise<ValidateCheckpointResult> {
-    return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
+    return (await this.stores.blocks.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
   public getPrivateLogsByTags(
@@ -184,7 +199,7 @@ export abstract class ArchiverDataSourceBase
     page?: number,
     upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]> {
-    return this.store.getPrivateLogsByTags(tags, page, upToBlockNumber);
+    return this.stores.logs.getPrivateLogsByTags(tags, page, upToBlockNumber);
   }
 
   public getPublicLogsByTagsFromContract(
@@ -193,23 +208,23 @@ export abstract class ArchiverDataSourceBase
     page?: number,
     upToBlockNumber?: BlockNumber,
   ): Promise<TxScopedL2Log[][]> {
-    return this.store.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
+    return this.stores.logs.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
   }
 
   public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
-    return this.store.getPublicLogs(filter);
+    return this.stores.logs.getPublicLogs(filter);
   }
 
   public getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
-    return this.store.getContractClassLogs(filter);
+    return this.stores.logs.getContractClassLogs(filter);
   }
 
   public getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    return this.store.getContractClass(id);
+    return this.stores.contractClasses.getContractClass(id);
   }
 
   public getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
-    return this.store.getBytecodeCommitment(id);
+    return this.stores.contractClasses.getBytecodeCommitment(id);
   }
 
   public async getContract(
@@ -225,36 +240,38 @@ export abstract class ArchiverDataSourceBase
       timestamp = maybeTimestamp;
     }
 
-    return this.store.getContractInstance(address, timestamp);
+    return this.stores.contractInstances.getContractInstance(address, timestamp);
   }
 
   public getContractClassIds(): Promise<Fr[]> {
-    return this.store.getContractClassIds();
+    return this.stores.contractClasses.getContractClassIds();
   }
 
-  public getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return this.store.getDebugFunctionName(address, selector);
+  /** Looks up a public function name given a selector. */
+  public getDebugFunctionName(_address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    return Promise.resolve(this.stores.functionNames.get(selector));
   }
 
+  /** Register public function signatures so they can be looked up by selector. */
   public registerContractFunctionSignatures(signatures: string[]): Promise<void> {
-    return this.store.registerContractFunctionSignatures(signatures);
+    return this.stores.functionNames.register(signatures);
   }
 
   public getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
-    return this.store.getL1ToL2Messages(checkpointNumber);
+    return this.stores.messages.getL1ToL2Messages(checkpointNumber);
   }
 
   public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return this.store.getL1ToL2MessageIndex(l1ToL2Message);
+    return this.stores.messages.getL1ToL2MessageIndex(l1ToL2Message);
   }
 
   public async getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]> {
-    const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
+    const checkpoints = await this.stores.blocks.getRangeOfCheckpoints(checkpointNumber, limit);
     return Promise.all(checkpoints.map(ch => this.getPublishedCheckpointFromCheckpointData(ch)));
   }
 
   private async getPublishedCheckpointFromCheckpointData(checkpoint: CheckpointData): Promise<PublishedCheckpoint> {
-    const blocksForCheckpoint = await this.store.getBlocksForCheckpoint(checkpoint.checkpointNumber);
+    const blocksForCheckpoint = await this.stores.blocks.getBlocksForCheckpoint(checkpoint.checkpointNumber);
     if (!blocksForCheckpoint) {
       throw new Error(`Blocks for checkpoint ${checkpoint.checkpointNumber} not found`);
     }
@@ -263,12 +280,13 @@ export abstract class ArchiverDataSourceBase
       checkpoint.header,
       blocksForCheckpoint,
       checkpoint.checkpointNumber,
+      checkpoint.feeAssetPriceModifier,
     );
     return new PublishedCheckpoint(fullCheckpoint, checkpoint.l1, checkpoint.attestations);
   }
 
   public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
-    return this.store.getBlocksForSlot(slotNumber);
+    return this.stores.blocks.getBlocksForSlot(slotNumber);
   }
 
   public async getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
@@ -309,39 +327,39 @@ export abstract class ArchiverDataSourceBase
     }
 
     const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    return this.store.getCheckpointDataForSlotRange(start, end);
+    return this.stores.blocks.getCheckpointDataForSlotRange(start, end);
   }
 
   public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
-      number = await this.store.getLatestBlockNumber();
+      number = await this.stores.blocks.getLatestL2BlockNumber();
     }
     if (number === 0) {
       return undefined;
     }
-    return this.store.getBlock(number);
+    return this.stores.blocks.getBlock(number);
   }
 
   public getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]> {
-    return this.store.getBlocks(from, limit);
+    return this.stores.blocks.getBlocks(from, limit);
   }
 
   public getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined> {
-    return this.store.getCheckpointedBlockByHash(blockHash);
+    return this.stores.blocks.getCheckpointedBlockByHash(blockHash);
   }
 
   public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
-    return this.store.getCheckpointedBlockByArchive(archive);
+    return this.stores.blocks.getCheckpointedBlockByArchive(archive);
   }
 
   public async getL2BlockByHash(blockHash: BlockHash): Promise<L2Block | undefined> {
-    const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
+    const checkpointedBlock = await this.stores.blocks.getCheckpointedBlockByHash(blockHash);
     return checkpointedBlock?.block;
   }
 
   public async getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
-    const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
+    const checkpointedBlock = await this.stores.blocks.getCheckpointedBlockByArchive(archive);
     return checkpointedBlock?.block;
   }
 }

package/src/modules/data_store_updater.ts

@@ -6,8 +6,13 @@ import {
   ContractInstancePublishedEvent,
   ContractInstanceUpdatedEvent,
 } from '@aztec/protocol-contracts/instance-registry';
-import type { L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
-import { type ProposedCheckpointInput, type PublishedCheckpoint, validateCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { CommitteeAttestation, L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import {
+  type L1PublishedData,
+  type ProposedCheckpointInput,
+  type PublishedCheckpoint,
+  validateCheckpoint,
+} from '@aztec/stdlib/checkpoint';
 import {
   type ContractClassPublicWithCommitment,
   computeContractAddressFromInstance,
@@ -16,7 +21,7 @@ import {
 import type { ContractClassLog, PrivateLog, PublicLog } from '@aztec/stdlib/logs';
 import type { UInt64 } from '@aztec/stdlib/types';
 
-import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import type { ArchiverDataStores } from '../store/data_stores.js';
 import type { L2TipsCache } from '../store/l2_tips_cache.js';
 
 /** Operation type for contract data updates. */
@@ -38,7 +43,7 @@ export class ArchiverDataStoreUpdater {
   private readonly log = createLogger('archiver:store_updater');
 
   constructor(
-    private store: KVArchiverDataStore,
+    private stores: ArchiverDataStores,
     private l2TipsCache?: L2TipsCache,
     private opts: { rollupManaLimit?: number } = {},
   ) {}
@@ -56,14 +61,15 @@ export class ArchiverDataStoreUpdater {
     block: L2Block,
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
-    const result = await this.store.transactionAsync(async () => {
-      await this.store.addProposedBlock(block);
+    const result = await this.stores.db.transactionAsync(async () => {
+      await this.stores.blocks.addProposedBlock(block);
 
       const opResults = await Promise.all([
         // Update the pending chain validation status if provided
-        pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
+        pendingChainValidationStatus &&
+          this.stores.blocks.setPendingChainValidationStatus(pendingChainValidationStatus),
         // Add any logs emitted during the retrieved block
-        this.store.addLogs([block]),
+        this.stores.logs.addLogs([block]),
         // Unroll all logs emitted during the retrieved block and extract any contract classes and instances from it
         this.addContractDataToDb(block),
       ]);
@@ -79,24 +85,36 @@ export class ArchiverDataStoreUpdater {
    * Adds new checkpoints to the store with contract class/instance extraction from logs.
    * Prunes any local blocks that conflict with checkpoint data (by comparing archive roots).
    * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events from the checkpoint block logs.
+   * If `promoteProposed` is supplied, the proposed-checkpoint promotion runs inside the same transaction
+   * as the added checkpoints so both updates are applied atomically.
    *
-   * @param checkpoints - The published checkpoints to add.
+   * @param checkpoints - The published checkpoints to add (excluding any being promoted from proposed).
    * @param pendingChainValidationStatus - Optional validation status to set.
+   * @param promoteProposed - Optional promotion of the current proposed checkpoint (fast path when blocks are already local).
    * @returns Result with information about any pruned blocks.
    */
   public async addCheckpoints(
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
+    promoteProposed?: {
+      l1: L1PublishedData;
+      attestations: CommitteeAttestation[];
+      checkpoint: PublishedCheckpoint;
+    },
+    evictProposedFrom?: CheckpointNumber,
   ): Promise<ReconcileCheckpointsResult> {
     for (const checkpoint of checkpoints) {
       validateCheckpoint(checkpoint.checkpoint, { rollupManaLimit: this.opts?.rollupManaLimit });
     }
+    if (promoteProposed) {
+      validateCheckpoint(promoteProposed.checkpoint.checkpoint, { rollupManaLimit: this.opts?.rollupManaLimit });
+    }
 
-    const result = await this.store.transactionAsync(async () => {
+    const result = await this.stores.db.transactionAsync(async () => {
       // Before adding checkpoints, check for conflicts with local blocks if any
       const { prunedBlocks, lastAlreadyInsertedBlockNumber } = await this.pruneMismatchingLocalBlocks(checkpoints);
 
-      await this.store.addCheckpoints(checkpoints);
+      await this.stores.blocks.addCheckpoints(checkpoints);
 
       // Filter out blocks that were already inserted via addProposedBlock() to avoid duplicating logs/contract data
       const newBlocks = checkpoints
@@ -105,11 +123,25 @@ export class ArchiverDataStoreUpdater {
 
       await Promise.all([
         // Update the pending chain validation status if provided
-        pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
+        pendingChainValidationStatus &&
+          this.stores.blocks.setPendingChainValidationStatus(pendingChainValidationStatus),
         // Add any logs emitted during the retrieved blocks
-        this.store.addLogs(newBlocks),
+        this.stores.logs.addLogs(newBlocks),
         // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
         ...newBlocks.map(block => this.addContractDataToDb(block)),
+        // Promote the proposed checkpoint if requested (uses explicit checkpoint number)
+        promoteProposed
+          ? this.stores.blocks.promoteProposedToCheckpointed(
+              promoteProposed.checkpoint.checkpoint.number,
+              promoteProposed.l1,
+              promoteProposed.attestations,
+              promoteProposed.checkpoint.checkpoint.archive.root,
+            )
+          : undefined,
+        // Evict pending checkpoints that diverged from what L1 mined
+        evictProposedFrom !== undefined
+          ? this.stores.blocks.evictProposedCheckpointsFrom(evictProposedFrom)
+          : undefined,
       ]);
 
       await this.l2TipsCache?.refresh();
@@ -118,9 +150,9 @@ export class ArchiverDataStoreUpdater {
     return result;
   }
 
-  public async setProposedCheckpoint(proposedCheckpoint: ProposedCheckpointInput) {
-    const result = await this.store.transactionAsync(async () => {
-      await this.store.setProposedCheckpoint(proposedCheckpoint);
+  public async addProposedCheckpoint(proposedCheckpoint: ProposedCheckpointInput) {
+    const result = await this.stores.db.transactionAsync(async () => {
+      await this.stores.blocks.addProposedCheckpoint(proposedCheckpoint);
       await this.l2TipsCache?.refresh();
     });
 
@@ -135,8 +167,8 @@ export class ArchiverDataStoreUpdater {
    */
   private async pruneMismatchingLocalBlocks(checkpoints: PublishedCheckpoint[]): Promise<ReconcileCheckpointsResult> {
     const [lastCheckpointedBlockNumber, lastBlockNumber] = await Promise.all([
-      this.store.getCheckpointedL2BlockNumber(),
-      this.store.getLatestBlockNumber(),
+      this.stores.blocks.getCheckpointedL2BlockNumber(),
+      this.stores.blocks.getLatestL2BlockNumber(),
     ]);
 
     // Exit early if there are no local uncheckpointed blocks
@@ -145,7 +177,7 @@ export class ArchiverDataStoreUpdater {
     }
 
     // Get all uncheckpointed local blocks
-    const uncheckpointedLocalBlocks = await this.store.getBlocks(
+    const uncheckpointedLocalBlocks = await this.stores.blocks.getBlocks(
       BlockNumber.add(lastCheckpointedBlockNumber, 1),
       lastBlockNumber - lastCheckpointedBlockNumber,
     );
@@ -210,9 +242,9 @@ export class ArchiverDataStoreUpdater {
    * @throws Error if any block to be removed is checkpointed.
    */
   public async removeUncheckpointedBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
-    const result = await this.store.transactionAsync(async () => {
+    const result = await this.stores.db.transactionAsync(async () => {
       // Verify we're only removing uncheckpointed blocks
-      const lastCheckpointedBlockNumber = await this.store.getCheckpointedL2BlockNumber();
+      const lastCheckpointedBlockNumber = await this.stores.blocks.getCheckpointedL2BlockNumber();
       if (blockNumber < lastCheckpointedBlockNumber) {
         throw new Error(
           `Cannot remove blocks after ${blockNumber} because checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`,
@@ -221,8 +253,8 @@ export class ArchiverDataStoreUpdater {
 
       const result = await this.removeBlocksAfter(blockNumber);
 
-      // Clear the proposed checkpoint if it exists, since its blocks have been pruned
-      await this.store.deleteProposedCheckpoint();
+      // Clear all pending proposed checkpoints since their blocks have been pruned
+      await this.stores.blocks.deleteProposedCheckpoints();
 
       await this.l2TipsCache?.refresh();
       return result;
@@ -236,11 +268,11 @@ export class ArchiverDataStoreUpdater {
    */
   private async removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
     // First get the blocks to be removed so we can clean up contract data
-    const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
+    const removedBlocks = await this.stores.blocks.removeBlocksAfter(blockNumber);
 
     // Clean up contract data and logs for the removed blocks
     await Promise.all([
-      this.store.deleteLogs(removedBlocks),
+      this.stores.logs.deleteLogs(removedBlocks),
       ...removedBlocks.map(block => this.removeContractDataFromDb(block)),
     ]);
 
@@ -257,15 +289,15 @@ export class ArchiverDataStoreUpdater {
    * @returns True if the operation is successful.
    */
   public async removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
-    return await this.store.transactionAsync(async () => {
-      const { blocksRemoved = [] } = await this.store.removeCheckpointsAfter(checkpointNumber);
+    return await this.stores.db.transactionAsync(async () => {
+      const { blocksRemoved = [] } = await this.stores.blocks.removeCheckpointsAfter(checkpointNumber);
 
       const opResults = await Promise.all([
         // Prune rolls back to the last proven block, which is by definition valid
-        this.store.setPendingChainValidationStatus({ valid: true }),
+        this.stores.blocks.setPendingChainValidationStatus({ valid: true }),
         // Remove contract data for all blocks being removed
         ...blocksRemoved.map(block => this.removeContractDataFromDb(block)),
-        this.store.deleteLogs(blocksRemoved),
+        this.stores.logs.deleteLogs(blocksRemoved),
       ]);
 
       await this.l2TipsCache?.refresh();
@@ -278,8 +310,8 @@ export class ArchiverDataStoreUpdater {
    * @param checkpointNumber - The checkpoint number to set as proven.
    */
   public async setProvenCheckpointNumber(checkpointNumber: CheckpointNumber): Promise<void> {
-    await this.store.transactionAsync(async () => {
-      await this.store.setProvenCheckpointNumber(checkpointNumber);
+    await this.stores.db.transactionAsync(async () => {
+      await this.stores.blocks.setProvenCheckpointNumber(checkpointNumber);
       await this.l2TipsCache?.refresh();
     });
   }
@@ -289,8 +321,8 @@ export class ArchiverDataStoreUpdater {
    * @param checkpointNumber - The checkpoint number to set as finalized.
    */
   public async setFinalizedCheckpointNumber(checkpointNumber: CheckpointNumber): Promise<void> {
-    await this.store.transactionAsync(async () => {
-      await this.store.setFinalizedCheckpointNumber(checkpointNumber);
+    await this.stores.db.transactionAsync(async () => {
+      await this.stores.blocks.setFinalizedCheckpointNumber(checkpointNumber);
       await this.l2TipsCache?.refresh();
     });
   }
@@ -336,7 +368,7 @@ export class ArchiverDataStoreUpdater {
       const contractClasses = contractClassPublishedEvents.map(e => e.toContractClassPublic());
       if (contractClasses.length > 0) {
         contractClasses.forEach(c => this.log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
-        return await this.store.deleteContractClasses(contractClasses, blockNum);
+        return await this.stores.contractClasses.deleteContractClasses(contractClasses, blockNum);
       }
       return true;
     }
@@ -362,7 +394,7 @@ export class ArchiverDataStoreUpdater {
 
     if (contractClasses.length > 0) {
       contractClasses.forEach(c => this.log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
-      return await this.store.addContractClasses(contractClasses, blockNum);
+      return await this.stores.contractClasses.addContractClasses(contractClasses, blockNum);
     }
     return true;
   }
@@ -401,9 +433,9 @@ export class ArchiverDataStoreUpdater {
         this.log.verbose(`${Operation[operation]} contract instance at ${c.address.toString()}`),
       );
       if (operation == Operation.Store) {
-        return await this.store.addContractInstances(contractInstances, blockNum);
+        return await this.stores.contractInstances.addContractInstances(contractInstances, blockNum);
       } else if (operation == Operation.Delete) {
-        return await this.store.deleteContractInstances(contractInstances, blockNum);
+        return await this.stores.contractInstances.deleteContractInstances(contractInstances);
       }
     }
     return true;
@@ -427,9 +459,9 @@ export class ArchiverDataStoreUpdater {
         this.log.verbose(`${Operation[operation]} contract instance update at ${c.address.toString()}`),
       );
       if (operation == Operation.Store) {
-        return await this.store.addContractInstanceUpdates(contractUpdates, timestamp);
+        return await this.stores.contractInstances.addContractInstanceUpdates(contractUpdates, timestamp);
       } else if (operation == Operation.Delete) {
-        return await this.store.deleteContractInstanceUpdates(contractUpdates, timestamp);
+        return await this.stores.contractInstances.deleteContractInstanceUpdates(contractUpdates, timestamp);
       }
     }
     return true;