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

package/dest/archiver/archiver.js

@@ -371,7 +371,7 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec, _dec1, _dec2, _dec3, _dec4, _initProto;
-import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { BlockTagTooOldError, InboxContract, RollupContract } from '@aztec/ethereum/contracts';
@@ -380,23 +380,21 @@ import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { merge, pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/running-promise';
 import { count } from '@aztec/foundation/string';
 import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
 import { isDefined } from '@aztec/foundation/types';
-import { ContractClassPublishedEvent, PrivateFunctionBroadcastedEvent, UtilityFunctionBroadcastedEvent } from '@aztec/protocol-contracts/class-registry';
-import { ContractInstancePublishedEvent, ContractInstanceUpdatedEvent } from '@aztec/protocol-contracts/instance-registry';
-import { CommitteeAttestation, L2Block, L2BlockSourceEvents, PublishedL2Block } from '@aztec/stdlib/block';
-import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import { computePublicBytecodeCommitment, isValidPrivateFunctionMembershipProof, isValidUtilityFunctionMembershipProof } from '@aztec/stdlib/contract';
+import { GENESIS_CHECKPOINT_HEADER_HASH, L2BlockSourceEvents } from '@aztec/stdlib/block';
 import { getEpochAtSlot, getEpochNumberAtTimestamp, getSlotAtTimestamp, getSlotRangeForEpoch, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { execInSpan, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { EventEmitter } from 'events';
-import groupBy from 'lodash.groupby';
 import { createPublicClient, fallback, http } from 'viem';
+import { ArchiveSourceBase } from './archive_source_base.js';
+import { addBlocksWithContractData, addCheckpointsWithContractData, unwindCheckpointsWithContractData } from './archiver_store_updates.js';
 import { InitialCheckpointNumberNotSequentialError, NoBlobBodiesFoundError } from './errors.js';
 import { ArchiverInstrumentation } from './instrumentation.js';
 import { retrieveCheckpointsFromRollup, retrieveL1ToL2Message, retrieveL1ToL2Messages, retrievedToPublishedCheckpoint } from './l1/data_retrieval.js';
@@ -406,7 +404,7 @@ function mapArchiverConfig(config) {
     return {
         pollingIntervalMs: config.archiverPollingIntervalMS,
         batchSize: config.archiverBatchSize,
-        skipValidateBlockAttestations: config.skipValidateBlockAttestations,
+        skipValidateCheckpointAttestations: config.skipValidateCheckpointAttestations,
         maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
         ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts
     };
@@ -416,9 +414,11 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
  * Pulls checkpoints in a non-blocking manner and provides interface for their retrieval.
  * Responsible for handling robust L1 polling so that other components do not need to
  * concern themselves with it.
- */ export class Archiver extends EventEmitter {
+ */ export class Archiver extends ArchiveSourceBase {
     publicClient;
     debugClient;
+    rollup;
+    inbox;
     l1Addresses;
     dataStore;
     config;
@@ -457,10 +457,8 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             ]
         ], []));
     }
+    /** Event emitter for archiver events (L2BlockProven, L2PruneDetected, etc). */ events;
     /** A loop in which we will be continually fetching new checkpoints. */ runningPromise;
-    rollup;
-    inbox;
-    store;
     l1BlockNumber;
     l1Timestamp;
     initialSyncComplete;
@@ -471,18 +469,20 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
    * 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 rollupAddress - Ethereum address of the rollup contract.
-   * @param inboxAddress - Ethereum address of the inbox contract.
-   * @param registryAddress - Ethereum address of the registry contract.
-   * @param pollingIntervalMs - The interval for polling for L1 logs (in milliseconds).
-   * @param store - An archiver data store for storage & retrieval of blocks, encrypted logs & contract data.
+   * @param rollup - Rollup contract instance.
+   * @param inbox - Inbox contract instance.
+   * @param l1Addresses - L1 contract addresses (registry, governance proposer, slash factory, slashing proposer).
+   * @param dataStore - An archiver data store for storage & retrieval of blocks, encrypted logs & contract data.
+   * @param config - Archiver configuration options.
+   * @param blobClient - Client for retrieving blob data.
+   * @param epochCache - Cache for epoch-related data.
+   * @param dateProvider - Provider for current date/time.
+   * @param instrumentation - Instrumentation for metrics and tracing.
+   * @param l1constants - L1 rollup constants.
    * @param log - A logger.
-   */ constructor(publicClient, debugClient, l1Addresses, dataStore, config, blobClient, epochCache, dateProvider, instrumentation, l1constants, log = createLogger('archiver')){
-        super(), this.publicClient = publicClient, this.debugClient = debugClient, this.l1Addresses = l1Addresses, this.dataStore = dataStore, this.config = config, this.blobClient = blobClient, this.epochCache = epochCache, this.dateProvider = dateProvider, this.instrumentation = instrumentation, this.l1constants = l1constants, this.log = log, this.initialSyncComplete = (_initProto(this), false), this.blockQueue = [];
+   */ constructor(publicClient, debugClient, rollup, inbox, l1Addresses, dataStore, config, blobClient, epochCache, dateProvider, instrumentation, l1constants, log = createLogger('archiver')){
+        super(dataStore), this.publicClient = publicClient, this.debugClient = debugClient, this.rollup = rollup, this.inbox = inbox, this.l1Addresses = l1Addresses, this.dataStore = dataStore, this.config = config, this.blobClient = blobClient, this.epochCache = epochCache, this.dateProvider = dateProvider, this.instrumentation = instrumentation, this.l1constants = l1constants, this.log = log, this.events = (_initProto(this), new EventEmitter()), this.initialSyncComplete = false, this.blockQueue = [];
         this.tracer = instrumentation.tracer;
-        this.store = new ArchiverStoreHelper(dataStore);
-        this.rollup = new RollupContract(publicClient, l1Addresses.rollupAddress);
-        this.inbox = new InboxContract(publicClient, l1Addresses.inboxAddress);
         this.initialSyncPromise = promiseWithResolvers();
         // Running promise starts with a small interval inbetween runs, so all iterations needed for the initial sync
         // are done as fast as possible. This then gets updated once the initial sync completes.
@@ -513,6 +513,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             pollingInterval: config.viemPollingIntervalMS
         });
         const rollup = new RollupContract(publicClient, config.l1Contracts.rollupAddress);
+        const inbox = new InboxContract(publicClient, config.l1Contracts.inboxAddress);
         const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, genesisArchiveRoot, slashingProposerAddress] = await Promise.all([
             rollup.getL1StartBlock(),
             rollup.getL1GenesisTime(),
@@ -543,7 +544,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         }, mapArchiverConfig(config));
         const epochCache = deps.epochCache ?? await EpochCache.create(config.l1Contracts.rollupAddress, config, deps);
         const telemetry = deps.telemetry ?? getTelemetryClient();
-        const archiver = new Archiver(publicClient, debugClient, {
+        const archiver = new Archiver(publicClient, debugClient, rollup, inbox, {
             ...config.l1Contracts,
             slashingProposerAddress
         }, archiverStore, opts, deps.blobClient, epochCache, deps.dateProvider ?? new DateProvider(), await ArchiverInstrumentation.new(telemetry, ()=>archiverStore.estimateSize()), l1Constants);
@@ -567,7 +568,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         const { l1StartBlock } = this.l1constants;
         const { blocksSynchedTo = l1StartBlock, messagesSynchedTo = l1StartBlock } = await this.store.getSynchPoint();
         const currentL2Checkpoint = await this.getSynchedCheckpointNumber();
-        this.log.info(`Starting archiver sync to rollup contract ${this.l1Addresses.rollupAddress.toString()} from L1 block ${blocksSynchedTo} and L2 checkpoint ${currentL2Checkpoint}`, {
+        this.log.info(`Starting archiver sync to rollup contract ${this.rollup.address} from L1 block ${blocksSynchedTo} and L2 checkpoint ${currentL2Checkpoint}`, {
             blocksSynchedTo,
             messagesSynchedTo,
             currentL2Checkpoint
@@ -615,7 +616,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         // Process each block individually to properly resolve/reject each promise
         for (const { block, resolve, reject } of queuedItems){
             try {
-                await this.store.addBlocks([
+                await addBlocksWithContractData(this.store, [
                     block
                 ]);
                 this.log.debug(`Added block ${block.number} to store`);
@@ -732,9 +733,15 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         // but the corresponding blocks have not been processed (see #12631).
         this.l1Timestamp = currentL1Timestamp;
         this.l1BlockNumber = currentL1BlockNumber;
+        const l1BlockNumberAtEnd = await this.publicClient.getBlockNumber();
+        this.log.trace(`Archiver sync iteration complete`, {
+            l1BlockNumberAtStart: currentL1BlockNumber,
+            l1TimestampAtStart: currentL1Timestamp,
+            l1BlockNumberAtEnd
+        });
         // We resolve the initial sync only once we've caught up with the latest L1 block number (with 1 block grace)
         // so if the initial sync took too long, we still go for another iteration.
-        if (!this.initialSyncComplete && currentL1BlockNumber + 1n >= await this.publicClient.getBlockNumber()) {
+        if (!this.initialSyncComplete && currentL1BlockNumber + 1n >= l1BlockNumberAtEnd) {
             this.log.info(`Initial archiver sync to L1 block ${currentL1BlockNumber} complete`, {
                 l1BlockNumber: currentL1BlockNumber,
                 syncPoint: await this.store.getSynchPoint(),
@@ -787,13 +794,11 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             const checkpoints = await Promise.all(checkpointPromises);
             const blockPromises = await Promise.all(checkpoints.filter(isDefined).map((cp)=>this.store.getBlocksForCheckpoint(CheckpointNumber(cp.checkpointNumber))));
             const newBlocks = blockPromises.filter(isDefined).flat();
-            // TODO(pw/mbps): Don't convert to legacy blocks here
-            const blocks = (await Promise.all(newBlocks.map((x)=>this.getBlock(x.number)))).filter(isDefined);
             // Emit an event for listening services to react to the chain prune
-            this.emit(L2BlockSourceEvents.L2PruneDetected, {
+            this.events.emit(L2BlockSourceEvents.L2PruneDetected, {
                 type: L2BlockSourceEvents.L2PruneDetected,
                 epochNumber: pruneFromEpochNumber,
-                blocks
+                blocks: newBlocks
             });
             this.log.debug(`L2 prune from ${provenCheckpointNumber + 1} to ${localPendingCheckpointNumber} will occur on next checkpoint submission.`);
             await this.unwindCheckpoints(localPendingCheckpointNumber, checkpointsToUnwind);
@@ -801,7 +806,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             this.instrumentation.processPrune(timer.ms());
         // TODO(palla/reorg): Do we need to set the block synched L1 block number here?
         // Seems like the next iteration should handle this.
-        // await this.store.setBlockSynchedL1BlockNumber(currentL1BlockNumber);
+        // await this.store.setCheckpointSynchedL1BlockNumber(currentL1BlockNumber);
         }
         return {
             rollupCanPrune
@@ -872,7 +877,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         do {
             [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
             this.log.trace(`Retrieving L1 to L2 messages between L1 blocks ${searchStartBlock} and ${searchEndBlock}.`);
-            const messages = await retrieveL1ToL2Messages(this.inbox.getContract(), searchStartBlock, searchEndBlock);
+            const messages = await retrieveL1ToL2Messages(this.inbox, searchStartBlock, searchEndBlock);
             this.log.verbose(`Retrieved ${messages.length} new L1 to L2 messages between L1 blocks ${searchStartBlock} and ${searchEndBlock}.`);
             const timer = new Timer();
             await this.store.addL1ToL2Messages(messages);
@@ -908,7 +913,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         let searchEndBlock = this.l1constants.l1StartBlock - 1n;
         do {
             [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
-            const message = await retrieveL1ToL2Message(this.inbox.getContract(), leaf, searchStartBlock, searchEndBlock);
+            const message = await retrieveL1ToL2Message(this.inbox, leaf, searchStartBlock, searchEndBlock);
             if (message) {
                 return message;
             }
@@ -1017,7 +1022,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                     const provenSlotNumber = localCheckpointForDestinationProvenCheckpointNumber.header.slotNumber;
                     const provenEpochNumber = getEpochAtSlot(provenSlotNumber, this.l1constants);
                     const lastBlockNumberInCheckpoint = localCheckpointForDestinationProvenCheckpointNumber.startBlock + localCheckpointForDestinationProvenCheckpointNumber.numBlocks - 1;
-                    this.emit(L2BlockSourceEvents.L2BlockProven, {
+                    this.events.emit(L2BlockSourceEvents.L2BlockProven, {
                         type: L2BlockSourceEvents.L2BlockProven,
                         blockNumber: BlockNumber(lastBlockNumberInCheckpoint),
                         slotNumber: provenSlotNumber,
@@ -1055,7 +1060,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                 // However, in the re-org scenario, our L1 node is temporarily lying to us and we end up potentially missing checkpoints.
                 // We must only set this block number based on actually retrieved logs.
                 // TODO(#8621): Tackle this properly when we handle L1 Re-orgs.
-                // await this.store.setBlockSynchedL1BlockNumber(currentL1BlockNumber);
+                // await this.store.setCheckpointSynchedL1BlockNumber(currentL1BlockNumber);
                 this.log.debug(`No checkpoints to retrieve from ${blocksSynchedTo + 1n} to ${currentL1BlockNumber}`);
                 return rollupStatus;
             }
@@ -1101,7 +1106,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
             this.log.trace(`Retrieving checkpoints from L1 block ${searchStartBlock} to ${searchEndBlock}`);
             // TODO(md): Retrieve from blob client then from consensus client, then from peers
-            const retrievedCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointsFromRollup', ()=>retrieveCheckpointsFromRollup(this.rollup.getContract(), this.publicClient, this.debugClient, this.blobClient, searchStartBlock, searchEndBlock, this.l1Addresses, this.instrumentation, this.log, !this.initialSyncComplete));
+            const retrievedCheckpoints = await execInSpan(this.tracer, 'Archiver.retrieveCheckpointsFromRollup', ()=>retrieveCheckpointsFromRollup(this.rollup, this.publicClient, this.debugClient, this.blobClient, searchStartBlock, searchEndBlock, this.l1Addresses, this.instrumentation, this.log, !this.initialSyncComplete));
             if (retrievedCheckpoints.length === 0) {
                 // We are not calling `setBlockSynchedL1BlockNumber` because it may cause sync issues if based off infura.
                 // See further details in earlier comments.
@@ -1116,7 +1121,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
             const publishedCheckpoints = await Promise.all(retrievedCheckpoints.map((b)=>retrievedToPublishedCheckpoint(b)));
             const validCheckpoints = [];
             for (const published of publishedCheckpoints){
-                const validationResult = this.config.skipValidateBlockAttestations ? {
+                const validationResult = this.config.skipValidateCheckpointAttestations ? {
                     valid: true
                 } : await validateCheckpointAttestations(published, this.epochCache, this.l1constants, this.log);
                 // Only update the validation result if it has changed, so we can keep track of the first invalid checkpoint
@@ -1124,7 +1129,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                 // There is an exception though: if a checkpoint is invalidated and replaced with another invalid checkpoint,
                 // we need to update the validation result, since we need to be able to invalidate the new one.
                 // See test 'chain progresses if an invalid checkpoint is invalidated with an invalid one' for more info.
-                if (rollupStatus.validationResult?.valid !== validationResult.valid || !rollupStatus.validationResult.valid && !validationResult.valid && rollupStatus.validationResult.block.blockNumber === validationResult.block.blockNumber) {
+                if (rollupStatus.validationResult?.valid !== validationResult.valid || !rollupStatus.validationResult.valid && !validationResult.valid && rollupStatus.validationResult.checkpoint.checkpointNumber === validationResult.checkpoint.checkpointNumber) {
                     rollupStatus.validationResult = validationResult;
                 }
                 if (!validationResult.valid) {
@@ -1133,9 +1138,9 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                         l1BlockNumber: published.l1.blockNumber,
                         ...pick(validationResult, 'reason')
                     });
-                    // Emit event for invalid block detection
-                    this.emit(L2BlockSourceEvents.InvalidAttestationsBlockDetected, {
-                        type: L2BlockSourceEvents.InvalidAttestationsBlockDetected,
+                    // Emit event for invalid checkpoint detection
+                    this.events.emit(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, {
+                        type: L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
                         validationResult
                     });
                     continue;
@@ -1173,7 +1178,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                     const { previousCheckpointNumber, newCheckpointNumber } = err;
                     const previousCheckpoint = previousCheckpointNumber ? await this.store.getCheckpointData(CheckpointNumber(previousCheckpointNumber)) : undefined;
                     const updatedL1SyncPoint = previousCheckpoint?.l1.blockNumber ?? this.l1constants.l1StartBlock;
-                    await this.store.setBlockSynchedL1BlockNumber(updatedL1SyncPoint);
+                    await this.store.setCheckpointSynchedL1BlockNumber(updatedL1SyncPoint);
                     this.log.warn(`Attempting to insert checkpoint ${newCheckpointNumber} with previous block ${previousCheckpointNumber}. Rolling back L1 sync point to ${updatedL1SyncPoint} to try and fetch the missing blocks.`, {
                         previousCheckpointNumber,
                         newCheckpointNumber,
@@ -1232,7 +1237,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
                 currentL1BlockNumber,
                 ...status
             });
-            await this.store.setBlockSynchedL1BlockNumber(targetL1BlockNumber);
+            await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);
         } else {
             this.log.trace(`No new checkpoints behind L1 sync point to retrieve.`, {
                 latestLocalCheckpointNumber,
@@ -1268,7 +1273,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         });
     }
     getRollupAddress() {
-        return Promise.resolve(this.l1Addresses.rollupAddress);
+        return Promise.resolve(EthAddress.fromString(this.rollup.address));
     }
     getRegistryAddress() {
         return Promise.resolve(this.l1Addresses.registryAddress);
@@ -1382,7 +1387,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         return this.store.setProvenCheckpointNumber(checkpointNumber);
     }
     unwindCheckpoints(from, checkpointsToUnwind) {
-        return this.store.unwindCheckpoints(from, checkpointsToUnwind);
+        return unwindCheckpointsWithContractData(this.store, from, checkpointsToUnwind);
     }
     async getLastBlockNumberInCheckpoint(checkpointNumber) {
         const checkpointData = await this.store.getCheckpointData(checkpointNumber);
@@ -1392,178 +1397,105 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         return BlockNumber(checkpointData.startBlock + checkpointData.numBlocks - 1);
     }
     addCheckpoints(checkpoints, pendingChainValidationStatus) {
-        return this.store.addCheckpoints(checkpoints, pendingChainValidationStatus);
-    }
-    getBlockHeaderByHash(blockHash) {
-        return this.store.getBlockHeaderByHash(blockHash);
-    }
-    getBlockHeaderByArchive(archive) {
-        return this.store.getBlockHeaderByArchive(archive);
-    }
-    /**
-   * Gets an l2 block.
-   * @param number - The block number to return.
-   * @returns The requested L2 block.
-   */ async getL2BlockNew(number) {
-        // If the number provided is -ve, then return the latest block.
-        if (number < 0) {
-            number = await this.store.getSynchedL2BlockNumber();
-        }
-        if (number === 0) {
-            return undefined;
-        }
-        const publishedBlock = await this.store.store.getBlock(number);
-        return publishedBlock;
-    }
-    async getBlockHeader(number) {
-        if (number === 'latest') {
-            number = await this.store.getSynchedL2BlockNumber();
-        }
-        if (number === 0) {
-            return undefined;
-        }
-        const headers = await this.store.getBlockHeaders(number, 1);
-        return headers.length === 0 ? undefined : headers[0];
-    }
-    getCheckpointedBlock(number) {
-        return this.store.getCheckpointedBlock(number);
-    }
-    getCheckpointedBlockByHash(blockHash) {
-        return this.store.getCheckpointedBlockByHash(blockHash);
-    }
-    getProvenBlockNumber() {
-        return this.store.getProvenBlockNumber();
-    }
-    getCheckpointedBlockByArchive(archive) {
-        return this.store.getCheckpointedBlockByArchive(archive);
-    }
-    getTxEffect(txHash) {
-        return this.store.getTxEffect(txHash);
-    }
-    getSettledTxReceipt(txHash) {
-        return this.store.getSettledTxReceipt(txHash);
-    }
-    getPrivateLogsByTags(tags) {
-        return this.store.getPrivateLogsByTags(tags);
-    }
-    getPublicLogsByTagsFromContract(contractAddress, tags) {
-        return this.store.getPublicLogsByTagsFromContract(contractAddress, tags);
-    }
-    /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getPublicLogs(filter) {
-        return this.store.getPublicLogs(filter);
-    }
-    /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getContractClassLogs(filter) {
-        return this.store.getContractClassLogs(filter);
-    }
-    /**
-   * Gets the number of the latest L2 block processed by the block source implementation.
-   * This includes both checkpointed and uncheckpointed blocks.
-   * @returns The number of the latest L2 block processed by the block source implementation.
-   */ getBlockNumber() {
-        return this.store.getLatestBlockNumber();
-    }
-    getContractClass(id) {
-        return this.store.getContractClass(id);
-    }
-    getBytecodeCommitment(id) {
-        return this.store.getBytecodeCommitment(id);
-    }
-    async getContract(address, maybeTimestamp) {
-        let timestamp;
-        if (maybeTimestamp === undefined) {
-            const latestBlockHeader = await this.getBlockHeader('latest');
-            // If we get undefined block header, it means that the archiver has not yet synced any block so we default to 0.
-            timestamp = latestBlockHeader ? latestBlockHeader.globalVariables.timestamp : 0n;
-        } else {
-            timestamp = maybeTimestamp;
-        }
-        return this.store.getContractInstance(address, timestamp);
-    }
-    /**
-   * Gets L1 to L2 message (to be) included in a given checkpoint.
-   * @param checkpointNumber - Checkpoint number to get messages for.
-   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
-   */ getL1ToL2Messages(checkpointNumber) {
-        return this.store.getL1ToL2Messages(checkpointNumber);
-    }
-    /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
-   * @param l1ToL2Message - The L1 to L2 message.
-   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-   */ getL1ToL2MessageIndex(l1ToL2Message) {
-        return this.store.getL1ToL2MessageIndex(l1ToL2Message);
-    }
-    getContractClassIds() {
-        return this.store.getContractClassIds();
+        return addCheckpointsWithContractData(this.store, checkpoints, pendingChainValidationStatus);
     }
-    registerContractFunctionSignatures(signatures) {
-        return this.store.registerContractFunctionSignatures(signatures);
-    }
-    getDebugFunctionName(address, selector) {
-        return this.store.getDebugFunctionName(address, selector);
-    }
-    async getPendingChainValidationStatus() {
-        return await this.store.getPendingChainValidationStatus() ?? {
-            valid: true
-        };
-    }
-    isPendingChainInvalid() {
-        return this.getPendingChainValidationStatus().then((status)=>!status.valid);
+    getCheckpointedBlockNumber() {
+        return this.store.getCheckpointedL2BlockNumber();
     }
     async getL2Tips() {
-        const [latestBlockNumber, provenBlockNumber] = await Promise.all([
+        const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
             this.getBlockNumber(),
-            this.getProvenBlockNumber()
+            this.getProvenBlockNumber(),
+            this.getCheckpointedBlockNumber()
         ]);
         // TODO(#13569): Compute proper finalized block number based on L1 finalized block.
         // We just force it 2 epochs worth of proven data for now.
         // NOTE: update end-to-end/src/e2e_epochs/epochs_empty_blocks.test.ts as that uses finalized blocks in computations
         const finalizedBlockNumber = BlockNumber(Math.max(provenBlockNumber - this.l1constants.epochDuration * 2, 0));
-        const [latestBlockHeader, provenBlockHeader, finalizedBlockHeader] = await Promise.all([
-            latestBlockNumber > 0 ? this.getBlockHeader(latestBlockNumber) : undefined,
-            provenBlockNumber > 0 ? this.getBlockHeader(provenBlockNumber) : undefined,
-            finalizedBlockNumber > 0 ? this.getBlockHeader(finalizedBlockNumber) : undefined
+        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 > 0 && !latestBlockHeader) {
+        if (latestBlockNumber > beforeInitialblockNumber && !latestBlockHeader) {
             throw new Error(`Failed to retrieve latest block header for block ${latestBlockNumber}`);
         }
-        if (provenBlockNumber > 0 && !provenBlockHeader) {
-            throw new Error(`Failed to retrieve proven block header for block ${provenBlockNumber} (latest block is ${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 > 0 && !finalizedBlockHeader) {
+        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 provenBlockHeader?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
-        const finalizedBlockHeaderHash = await finalizedBlockHeader?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
-        return {
-            latest: {
+        const provenBlockHeaderHash = await provenCheckpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        const finalizedBlockHeaderHash = await finalizedCheckpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        const checkpointedBlockHeaderHash = await checkpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        // Now attempt to retrieve checkpoints for proven, finalised and checkpointed blocks
+        const [[provenBlockCheckpoint], [finalizedBlockCheckpoint], [checkpointedBlockCheckpoint]] = await Promise.all([
+            provenCheckpointedBlock !== undefined ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1) : [
+                undefined
+            ],
+            finalizedCheckpointedBlock !== undefined ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1) : [
+                undefined
+            ],
+            checkpointedBlock !== undefined ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1) : [
+                undefined
+            ]
+        ]);
+        const initialcheckpointId = {
+            number: CheckpointNumber.ZERO,
+            hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
+        };
+        const makeCheckpointId = (checkpoint)=>{
+            if (checkpoint === undefined) {
+                return initialcheckpointId;
+            }
+            return {
+                number: checkpoint.checkpoint.number,
+                hash: checkpoint.checkpoint.hash().toString()
+            };
+        };
+        const l2Tips = {
+            proposed: {
                 number: latestBlockNumber,
                 hash: latestBlockHeaderHash.toString()
             },
             proven: {
-                number: provenBlockNumber,
-                hash: provenBlockHeaderHash.toString()
+                block: {
+                    number: provenBlockNumber,
+                    hash: provenBlockHeaderHash.toString()
+                },
+                checkpoint: makeCheckpointId(provenBlockCheckpoint)
             },
             finalized: {
-                number: finalizedBlockNumber,
-                hash: finalizedBlockHeaderHash.toString()
+                block: {
+                    number: finalizedBlockNumber,
+                    hash: finalizedBlockHeaderHash.toString()
+                },
+                checkpoint: makeCheckpointId(finalizedBlockCheckpoint)
+            },
+            checkpointed: {
+                block: {
+                    number: checkpointedBlockNumber,
+                    hash: checkpointedBlockHeaderHash.toString()
+                },
+                checkpoint: makeCheckpointId(checkpointedBlockCheckpoint)
             }
         };
+        return l2Tips;
     }
     async rollbackTo(targetL2BlockNumber) {
         // TODO(pw/mbps): This still assumes 1 block per checkpoint
         const currentBlocks = await this.getL2Tips();
-        const currentL2Block = currentBlocks.latest.number;
-        const currentProvenBlock = currentBlocks.proven.number;
+        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}`);
         }
@@ -1576,11 +1508,11 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         const targetCheckpointNumber = CheckpointNumber.fromBlockNumber(targetL2BlockNumber);
         const targetL1BlockHash = await this.getL1BlockHash(targetL1BlockNumber);
         this.log.info(`Unwinding ${blocksToUnwind} checkpoints from L2 block ${currentL2Block}`);
-        await this.store.unwindCheckpoints(CheckpointNumber(currentL2Block), blocksToUnwind);
+        await unwindCheckpointsWithContractData(this.store, CheckpointNumber(currentL2Block), blocksToUnwind);
         this.log.info(`Unwinding L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
         await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
         this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
-        await this.store.setBlockSynchedL1BlockNumber(targetL1BlockNumber);
+        await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);
         await this.store.setMessageSynchedL1Block({
             l1BlockNumber: targetL1BlockNumber,
             l1BlockHash: targetL1BlockHash
@@ -1595,19 +1527,6 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
     //   await this.store.setFinalizedL2BlockNumber(0);
     // }
     }
-    async getPublishedCheckpoints(checkpointNumber, limit) {
-        const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
-        const blocks = (await Promise.all(checkpoints.map((ch)=>this.store.getBlocksForCheckpoint(ch.checkpointNumber)))).filter(isDefined);
-        const fullCheckpoints = [];
-        for(let i = 0; i < checkpoints.length; i++){
-            const blocksForCheckpoint = blocks[i];
-            const checkpoint = checkpoints[i];
-            const fullCheckpoint = new Checkpoint(checkpoint.archive, checkpoint.header, blocksForCheckpoint, checkpoint.checkpointNumber);
-            const publishedCheckpoint = new PublishedCheckpoint(fullCheckpoint, checkpoint.l1, checkpoint.attestations.map((x)=>CommitteeAttestation.fromBuffer(x)));
-            fullCheckpoints.push(publishedCheckpoint);
-        }
-        return fullCheckpoints;
-    }
     async getCheckpointsForEpoch(epochNumber) {
         const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1constants);
         const checkpoints = [];
@@ -1625,413 +1544,4 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.sync'), _de
         }
         return checkpoints.reverse();
     }
-    /* Legacy APIs */ async getPublishedBlockByHash(blockHash) {
-        const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
-        return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
-    }
-    async getPublishedBlockByArchive(archive) {
-        const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
-        return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
-    }
-    /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @param proven - If true, only return blocks that have been proven.
-   * @returns The requested L2 blocks.
-   */ async getBlocks(from, limit, proven) {
-        const publishedBlocks = await this.getPublishedBlocks(from, limit, proven);
-        return publishedBlocks.map((x)=>x.block);
-    }
-    async getPublishedBlocks(from, limit, proven) {
-        const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
-        const provenCheckpointNumber = await this.getProvenCheckpointNumber();
-        const blocks = (await Promise.all(checkpoints.map((ch)=>this.store.getBlocksForCheckpoint(ch.checkpointNumber)))).filter(isDefined);
-        const olbBlocks = [];
-        for(let i = 0; i < checkpoints.length; i++){
-            const blockForCheckpoint = blocks[i][0];
-            const checkpoint = checkpoints[i];
-            if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
-                continue;
-            }
-            const oldCheckpoint = new Checkpoint(blockForCheckpoint.archive, checkpoint.header, [
-                blockForCheckpoint
-            ], checkpoint.checkpointNumber);
-            const oldBlock = L2Block.fromCheckpoint(oldCheckpoint);
-            const publishedBlock = new PublishedL2Block(oldBlock, checkpoint.l1, checkpoint.attestations.map((x)=>CommitteeAttestation.fromBuffer(x)));
-            olbBlocks.push(publishedBlock);
-        }
-        return olbBlocks;
-    }
-    async buildOldBlockFromCheckpointedBlock(checkpointedBlock) {
-        if (!checkpointedBlock) {
-            return undefined;
-        }
-        const checkpoint = await this.store.getCheckpointData(checkpointedBlock.checkpointNumber);
-        if (!checkpoint) {
-            return checkpoint;
-        }
-        const fullCheckpoint = new Checkpoint(checkpointedBlock?.block.archive, checkpoint?.header, [
-            checkpointedBlock.block
-        ], checkpoint.checkpointNumber);
-        const oldBlock = L2Block.fromCheckpoint(fullCheckpoint);
-        const published = new PublishedL2Block(oldBlock, checkpoint.l1, checkpoint.attestations.map((x)=>CommitteeAttestation.fromBuffer(x)));
-        return published;
-    }
-    async getBlock(number) {
-        // If the number provided is -ve, then return the latest block.
-        if (number < 0) {
-            number = await this.store.getSynchedL2BlockNumber();
-        }
-        if (number === 0) {
-            return undefined;
-        }
-        const publishedBlocks = await this.getPublishedBlocks(number, 1);
-        if (publishedBlocks.length === 0) {
-            return undefined;
-        }
-        return publishedBlocks[0].block;
-    }
-}
-var Operation = /*#__PURE__*/ function(Operation) {
-    Operation[Operation["Store"] = 0] = "Store";
-    Operation[Operation["Delete"] = 1] = "Delete";
-    return Operation;
-}(Operation || {});
-/**
- * A helper class that we use to deal with some of the logic needed when adding blocks.
- *
- * I would have preferred to not have this type. But it is useful for handling the logic that any
- * store would need to include otherwise while exposing fewer functions and logic directly to the archiver.
- */ export class ArchiverStoreHelper {
-    store;
-    #log;
-    constructor(store){
-        this.store = store;
-        this.#log = createLogger('archiver:block-helper');
-    }
-    /**
-   * Extracts and stores contract classes out of ContractClassPublished events emitted by the class registry contract.
-   * @param allLogs - All logs emitted in a bunch of blocks.
-   */ async #updatePublishedContractClasses(allLogs, blockNum, operation) {
-        const contractClassPublishedEvents = allLogs.filter((log)=>ContractClassPublishedEvent.isContractClassPublishedEvent(log)).map((log)=>ContractClassPublishedEvent.fromLog(log));
-        const contractClasses = await Promise.all(contractClassPublishedEvents.map((e)=>e.toContractClassPublic()));
-        if (contractClasses.length > 0) {
-            contractClasses.forEach((c)=>this.#log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
-            if (operation == 0) {
-                // TODO: Will probably want to create some worker threads to compute these bytecode commitments as they are expensive
-                const commitments = await Promise.all(contractClasses.map((c)=>computePublicBytecodeCommitment(c.packedBytecode)));
-                return await this.store.addContractClasses(contractClasses, commitments, blockNum);
-            } else if (operation == 1) {
-                return await this.store.deleteContractClasses(contractClasses, blockNum);
-            }
-        }
-        return true;
-    }
-    /**
-   * Extracts and stores contract instances out of ContractInstancePublished events emitted by the canonical deployer contract.
-   * @param allLogs - All logs emitted in a bunch of blocks.
-   */ async #updateDeployedContractInstances(allLogs, blockNum, operation) {
-        const contractInstances = allLogs.filter((log)=>ContractInstancePublishedEvent.isContractInstancePublishedEvent(log)).map((log)=>ContractInstancePublishedEvent.fromLog(log)).map((e)=>e.toContractInstance());
-        if (contractInstances.length > 0) {
-            contractInstances.forEach((c)=>this.#log.verbose(`${Operation[operation]} contract instance at ${c.address.toString()}`));
-            if (operation == 0) {
-                return await this.store.addContractInstances(contractInstances, blockNum);
-            } else if (operation == 1) {
-                return await this.store.deleteContractInstances(contractInstances, blockNum);
-            }
-        }
-        return true;
-    }
-    /**
-   * Extracts and stores contract instances out of ContractInstancePublished events emitted by the canonical deployer contract.
-   * @param allLogs - All logs emitted in a bunch of blocks.
-   * @param timestamp - Timestamp at which the updates were scheduled.
-   * @param operation - The operation to perform on the contract instance updates (Store or Delete).
-   */ async #updateUpdatedContractInstances(allLogs, timestamp, operation) {
-        const contractUpdates = allLogs.filter((log)=>ContractInstanceUpdatedEvent.isContractInstanceUpdatedEvent(log)).map((log)=>ContractInstanceUpdatedEvent.fromLog(log)).map((e)=>e.toContractInstanceUpdate());
-        if (contractUpdates.length > 0) {
-            contractUpdates.forEach((c)=>this.#log.verbose(`${Operation[operation]} contract instance update at ${c.address.toString()}`));
-            if (operation == 0) {
-                return await this.store.addContractInstanceUpdates(contractUpdates, timestamp);
-            } else if (operation == 1) {
-                return await this.store.deleteContractInstanceUpdates(contractUpdates, timestamp);
-            }
-        }
-        return true;
-    }
-    /**
-   * Stores the functions that were broadcasted individually
-   *
-   * @dev   Beware that there is not a delete variant of this, since they are added to contract classes
-   *        and will be deleted as part of the class if needed.
-   *
-   * @param allLogs - The logs from the block
-   * @param _blockNum - The block number
-   * @returns
-   */ async #storeBroadcastedIndividualFunctions(allLogs, _blockNum) {
-        // Filter out private and utility function broadcast events
-        const privateFnEvents = allLogs.filter((log)=>PrivateFunctionBroadcastedEvent.isPrivateFunctionBroadcastedEvent(log)).map((log)=>PrivateFunctionBroadcastedEvent.fromLog(log));
-        const utilityFnEvents = allLogs.filter((log)=>UtilityFunctionBroadcastedEvent.isUtilityFunctionBroadcastedEvent(log)).map((log)=>UtilityFunctionBroadcastedEvent.fromLog(log));
-        // Group all events by contract class id
-        for (const [classIdString, classEvents] of Object.entries(groupBy([
-            ...privateFnEvents,
-            ...utilityFnEvents
-        ], (e)=>e.contractClassId.toString()))){
-            const contractClassId = Fr.fromHexString(classIdString);
-            const contractClass = await this.getContractClass(contractClassId);
-            if (!contractClass) {
-                this.#log.warn(`Skipping broadcasted functions as contract class ${contractClassId.toString()} was not found`);
-                continue;
-            }
-            // Split private and utility functions, and filter out invalid ones
-            const allFns = classEvents.map((e)=>e.toFunctionWithMembershipProof());
-            const privateFns = allFns.filter((fn)=>'utilityFunctionsTreeRoot' in fn);
-            const utilityFns = allFns.filter((fn)=>'privateFunctionsArtifactTreeRoot' in fn);
-            const privateFunctionsWithValidity = await Promise.all(privateFns.map(async (fn)=>({
-                    fn,
-                    valid: await isValidPrivateFunctionMembershipProof(fn, contractClass)
-                })));
-            const validPrivateFns = privateFunctionsWithValidity.filter(({ valid })=>valid).map(({ fn })=>fn);
-            const utilityFunctionsWithValidity = await Promise.all(utilityFns.map(async (fn)=>({
-                    fn,
-                    valid: await isValidUtilityFunctionMembershipProof(fn, contractClass)
-                })));
-            const validUtilityFns = utilityFunctionsWithValidity.filter(({ valid })=>valid).map(({ fn })=>fn);
-            const validFnCount = validPrivateFns.length + validUtilityFns.length;
-            if (validFnCount !== allFns.length) {
-                this.#log.warn(`Skipping ${allFns.length - validFnCount} invalid functions`);
-            }
-            // Store the functions in the contract class in a single operation
-            if (validFnCount > 0) {
-                this.#log.verbose(`Storing ${validFnCount} functions for contract class ${contractClassId.toString()}`);
-            }
-            return await this.store.addFunctions(contractClassId, validPrivateFns, validUtilityFns);
-        }
-        return true;
-    }
-    async addBlockDataToDB(block) {
-        const contractClassLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.contractClassLogs);
-        // ContractInstancePublished event logs are broadcast in privateLogs.
-        const privateLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.privateLogs);
-        const publicLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.publicLogs);
-        return (await Promise.all([
-            this.#updatePublishedContractClasses(contractClassLogs, block.number, 0),
-            this.#updateDeployedContractInstances(privateLogs, block.number, 0),
-            this.#updateUpdatedContractInstances(publicLogs, block.header.globalVariables.timestamp, 0),
-            this.#storeBroadcastedIndividualFunctions(contractClassLogs, block.number)
-        ])).every(Boolean);
-    }
-    addBlocks(blocks, pendingChainValidationStatus) {
-        // Add the blocks to the store. Store will throw if the blocks are not in order, there are gaps,
-        // or if the previous block is not in the store.
-        return this.store.transactionAsync(async ()=>{
-            await this.store.addBlocks(blocks);
-            const opResults = await Promise.all([
-                // Update the pending chain validation status if provided
-                pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
-                // Add any logs emitted during the retrieved blocks
-                this.store.addLogs(blocks),
-                // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-                ...blocks.map((block)=>{
-                    return this.addBlockDataToDB(block);
-                })
-            ]);
-            return opResults.every(Boolean);
-        });
-    }
-    addCheckpoints(checkpoints, pendingChainValidationStatus) {
-        // Add the blocks to the store. Store will throw if the blocks are not in order, there are gaps,
-        // or if the previous block is not in the store.
-        return this.store.transactionAsync(async ()=>{
-            await this.store.addCheckpoints(checkpoints);
-            const allBlocks = checkpoints.flatMap((ch)=>ch.checkpoint.blocks);
-            const opResults = await Promise.all([
-                // Update the pending chain validation status if provided
-                pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
-                // Add any logs emitted during the retrieved blocks
-                this.store.addLogs(allBlocks),
-                // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-                ...allBlocks.map((block)=>{
-                    return this.addBlockDataToDB(block);
-                })
-            ]);
-            return opResults.every(Boolean);
-        });
-    }
-    async unwindCheckpoints(from, checkpointsToUnwind) {
-        if (checkpointsToUnwind <= 0) {
-            throw new Error(`Cannot unwind ${checkpointsToUnwind} blocks`);
-        }
-        const last = await this.getSynchedCheckpointNumber();
-        if (from != last) {
-            throw new Error(`Cannot unwind checkpoints from checkpoint ${from} when the last checkpoint is ${last}`);
-        }
-        const blocks = [];
-        const lastCheckpointNumber = from + checkpointsToUnwind - 1;
-        for(let checkpointNumber = from; checkpointNumber <= lastCheckpointNumber; checkpointNumber++){
-            const blocksForCheckpoint = await this.store.getBlocksForCheckpoint(checkpointNumber);
-            if (!blocksForCheckpoint) {
-                continue;
-            }
-            blocks.push(...blocksForCheckpoint);
-        }
-        const opResults = await Promise.all([
-            // Prune rolls back to the last proven block, which is by definition valid
-            this.store.setPendingChainValidationStatus({
-                valid: true
-            }),
-            // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-            ...blocks.map(async (block)=>{
-                const contractClassLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.contractClassLogs);
-                // ContractInstancePublished event logs are broadcast in privateLogs.
-                const privateLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.privateLogs);
-                const publicLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.publicLogs);
-                return (await Promise.all([
-                    this.#updatePublishedContractClasses(contractClassLogs, block.number, 1),
-                    this.#updateDeployedContractInstances(privateLogs, block.number, 1),
-                    this.#updateUpdatedContractInstances(publicLogs, block.header.globalVariables.timestamp, 1)
-                ])).every(Boolean);
-            }),
-            this.store.deleteLogs(blocks),
-            this.store.unwindCheckpoints(from, checkpointsToUnwind)
-        ]);
-        return opResults.every(Boolean);
-    }
-    getCheckpointData(checkpointNumber) {
-        return this.store.getCheckpointData(checkpointNumber);
-    }
-    getRangeOfCheckpoints(from, limit) {
-        return this.store.getRangeOfCheckpoints(from, limit);
-    }
-    getCheckpointedL2BlockNumber() {
-        return this.store.getCheckpointedL2BlockNumber();
-    }
-    getSynchedCheckpointNumber() {
-        return this.store.getSynchedCheckpointNumber();
-    }
-    setCheckpointSynchedL1BlockNumber(l1BlockNumber) {
-        return this.store.setCheckpointSynchedL1BlockNumber(l1BlockNumber);
-    }
-    getCheckpointedBlock(number) {
-        return this.store.getCheckpointedBlock(number);
-    }
-    getCheckpointedBlockByHash(blockHash) {
-        return this.store.getCheckpointedBlockByHash(blockHash);
-    }
-    getCheckpointedBlockByArchive(archive) {
-        return this.store.getCheckpointedBlockByArchive(archive);
-    }
-    getBlockHeaders(from, limit) {
-        return this.store.getBlockHeaders(from, limit);
-    }
-    getBlockHeaderByHash(blockHash) {
-        return this.store.getBlockHeaderByHash(blockHash);
-    }
-    getBlockHeaderByArchive(archive) {
-        return this.store.getBlockHeaderByArchive(archive);
-    }
-    getBlockByHash(blockHash) {
-        return this.store.getBlockByHash(blockHash);
-    }
-    getBlockByArchive(archive) {
-        return this.store.getBlockByArchive(archive);
-    }
-    getLatestBlockNumber() {
-        return this.store.getLatestBlockNumber();
-    }
-    getBlocksForCheckpoint(checkpointNumber) {
-        return this.store.getBlocksForCheckpoint(checkpointNumber);
-    }
-    getTxEffect(txHash) {
-        return this.store.getTxEffect(txHash);
-    }
-    getSettledTxReceipt(txHash) {
-        return this.store.getSettledTxReceipt(txHash);
-    }
-    addL1ToL2Messages(messages) {
-        return this.store.addL1ToL2Messages(messages);
-    }
-    getL1ToL2Messages(checkpointNumber) {
-        return this.store.getL1ToL2Messages(checkpointNumber);
-    }
-    getL1ToL2MessageIndex(l1ToL2Message) {
-        return this.store.getL1ToL2MessageIndex(l1ToL2Message);
-    }
-    getPrivateLogsByTags(tags) {
-        return this.store.getPrivateLogsByTags(tags);
-    }
-    getPublicLogsByTagsFromContract(contractAddress, tags) {
-        return this.store.getPublicLogsByTagsFromContract(contractAddress, tags);
-    }
-    getPublicLogs(filter) {
-        return this.store.getPublicLogs(filter);
-    }
-    getContractClassLogs(filter) {
-        return this.store.getContractClassLogs(filter);
-    }
-    getSynchedL2BlockNumber() {
-        return this.store.getCheckpointedL2BlockNumber();
-    }
-    getProvenCheckpointNumber() {
-        return this.store.getProvenCheckpointNumber();
-    }
-    getProvenBlockNumber() {
-        return this.store.getProvenBlockNumber();
-    }
-    setProvenCheckpointNumber(checkpointNumber) {
-        return this.store.setProvenCheckpointNumber(checkpointNumber);
-    }
-    setBlockSynchedL1BlockNumber(l1BlockNumber) {
-        return this.store.setCheckpointSynchedL1BlockNumber(l1BlockNumber);
-    }
-    setMessageSynchedL1Block(l1Block) {
-        return this.store.setMessageSynchedL1Block(l1Block);
-    }
-    getSynchPoint() {
-        return this.store.getSynchPoint();
-    }
-    getContractClass(id) {
-        return this.store.getContractClass(id);
-    }
-    getBytecodeCommitment(contractClassId) {
-        return this.store.getBytecodeCommitment(contractClassId);
-    }
-    getContractInstance(address, timestamp) {
-        return this.store.getContractInstance(address, timestamp);
-    }
-    getContractClassIds() {
-        return this.store.getContractClassIds();
-    }
-    registerContractFunctionSignatures(signatures) {
-        return this.store.registerContractFunctionSignatures(signatures);
-    }
-    getDebugFunctionName(address, selector) {
-        return this.store.getDebugFunctionName(address, selector);
-    }
-    getTotalL1ToL2MessageCount() {
-        return this.store.getTotalL1ToL2MessageCount();
-    }
-    estimateSize() {
-        return this.store.estimateSize();
-    }
-    rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber) {
-        return this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
-    }
-    iterateL1ToL2Messages(range = {}) {
-        return this.store.iterateL1ToL2Messages(range);
-    }
-    removeL1ToL2Messages(startIndex) {
-        return this.store.removeL1ToL2Messages(startIndex);
-    }
-    getLastL1ToL2Message() {
-        return this.store.getLastL1ToL2Message();
-    }
-    getPendingChainValidationStatus() {
-        return this.store.getPendingChainValidationStatus();
-    }
-    setPendingChainValidationStatus(status) {
-        this.#log.debug(`Setting pending chain validation status to valid ${status?.valid}`, status);
-        return this.store.setPendingChainValidationStatus(status);
-    }
 }