@aztec/archiver 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/dest/modules/data_source_base.js

@@ -0,0 +1,216 @@
+import { range } from '@aztec/foundation/array';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { isDefined } from '@aztec/foundation/types';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+/**
+ * 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.
+ */ export class ArchiverDataSourceBase {
+    store;
+    l1Constants;
+    constructor(store, l1Constants){
+        this.store = store;
+        this.l1Constants = l1Constants;
+    }
+    getCheckpointNumber() {
+        return this.store.getSynchedCheckpointNumber();
+    }
+    getSynchedCheckpointNumber() {
+        return this.store.getSynchedCheckpointNumber();
+    }
+    getProvenCheckpointNumber() {
+        return this.store.getProvenCheckpointNumber();
+    }
+    getBlockNumber() {
+        return this.store.getLatestBlockNumber();
+    }
+    getProvenBlockNumber() {
+        return this.store.getProvenBlockNumber();
+    }
+    async getBlockHeader(number) {
+        const blockNumber = number === 'latest' ? await this.store.getLatestBlockNumber() : number;
+        if (blockNumber === 0) {
+            return undefined;
+        }
+        const headers = await this.store.getBlockHeaders(blockNumber, 1);
+        return headers.length === 0 ? undefined : headers[0];
+    }
+    getCheckpointedBlock(number) {
+        return this.store.getCheckpointedBlock(number);
+    }
+    getCheckpointedL2BlockNumber() {
+        return this.store.getCheckpointedL2BlockNumber();
+    }
+    getFinalizedL2BlockNumber() {
+        return this.store.getFinalizedL2BlockNumber();
+    }
+    async getCheckpointHeader(number) {
+        if (number === 'latest') {
+            number = await this.store.getSynchedCheckpointNumber();
+        }
+        if (number === 0) {
+            return undefined;
+        }
+        const checkpoint = await this.store.getCheckpointData(number);
+        if (!checkpoint) {
+            return undefined;
+        }
+        return checkpoint.header;
+    }
+    async getLastBlockNumberInCheckpoint(checkpointNumber) {
+        const checkpointData = await this.store.getCheckpointData(checkpointNumber);
+        if (!checkpointData) {
+            return undefined;
+        }
+        return BlockNumber(checkpointData.startBlock + checkpointData.blockCount - 1);
+    }
+    getCheckpointedBlocks(from, limit) {
+        return this.store.getCheckpointedBlocks(from, limit);
+    }
+    getBlockHeaderByHash(blockHash) {
+        return this.store.getBlockHeaderByHash(blockHash);
+    }
+    getBlockHeaderByArchive(archive) {
+        return this.store.getBlockHeaderByArchive(archive);
+    }
+    getBlockData(number) {
+        return this.store.getBlockData(number);
+    }
+    getBlockDataByArchive(archive) {
+        return this.store.getBlockDataByArchive(archive);
+    }
+    async getL2Block(number) {
+        // If the number provided is -ve, then return the latest block.
+        if (number < 0) {
+            number = await this.store.getLatestBlockNumber();
+        }
+        if (number === 0) {
+            return undefined;
+        }
+        const publishedBlock = await this.store.getBlock(number);
+        return publishedBlock;
+    }
+    getTxEffect(txHash) {
+        return this.store.getTxEffect(txHash);
+    }
+    getSettledTxReceipt(txHash) {
+        return this.store.getSettledTxReceipt(txHash);
+    }
+    isPendingChainInvalid() {
+        return this.getPendingChainValidationStatus().then((status)=>!status.valid);
+    }
+    async getPendingChainValidationStatus() {
+        return await this.store.getPendingChainValidationStatus() ?? {
+            valid: true
+        };
+    }
+    getPrivateLogsByTags(tags, page) {
+        return this.store.getPrivateLogsByTags(tags, page);
+    }
+    getPublicLogsByTagsFromContract(contractAddress, tags, page) {
+        return this.store.getPublicLogsByTagsFromContract(contractAddress, tags, page);
+    }
+    getPublicLogs(filter) {
+        return this.store.getPublicLogs(filter);
+    }
+    getContractClassLogs(filter) {
+        return this.store.getContractClassLogs(filter);
+    }
+    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);
+    }
+    getContractClassIds() {
+        return this.store.getContractClassIds();
+    }
+    getDebugFunctionName(address, selector) {
+        return this.store.getDebugFunctionName(address, selector);
+    }
+    registerContractFunctionSignatures(signatures) {
+        return this.store.registerContractFunctionSignatures(signatures);
+    }
+    getL1ToL2Messages(checkpointNumber) {
+        return this.store.getL1ToL2Messages(checkpointNumber);
+    }
+    getL1ToL2MessageIndex(l1ToL2Message) {
+        return this.store.getL1ToL2MessageIndex(l1ToL2Message);
+    }
+    async getCheckpoints(checkpointNumber, limit) {
+        const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
+        return Promise.all(checkpoints.map((ch)=>this.getPublishedCheckpointFromCheckpointData(ch)));
+    }
+    async getPublishedCheckpointFromCheckpointData(checkpoint) {
+        const blocksForCheckpoint = await this.store.getBlocksForCheckpoint(checkpoint.checkpointNumber);
+        if (!blocksForCheckpoint) {
+            throw new Error(`Blocks for checkpoint ${checkpoint.checkpointNumber} not found`);
+        }
+        const fullCheckpoint = new Checkpoint(checkpoint.archive, checkpoint.header, blocksForCheckpoint, checkpoint.checkpointNumber);
+        return new PublishedCheckpoint(fullCheckpoint, checkpoint.l1, checkpoint.attestations);
+    }
+    getBlocksForSlot(slotNumber) {
+        return this.store.getBlocksForSlot(slotNumber);
+    }
+    async getCheckpointedBlocksForEpoch(epochNumber) {
+        const checkpointsData = await this.getCheckpointsDataForEpoch(epochNumber);
+        const blocks = await Promise.all(checkpointsData.flatMap((checkpoint)=>range(checkpoint.blockCount, checkpoint.startBlock).map((blockNumber)=>this.getCheckpointedBlock(BlockNumber(blockNumber)))));
+        return blocks.filter(isDefined);
+    }
+    async getCheckpointedBlockHeadersForEpoch(epochNumber) {
+        const checkpointsData = await this.getCheckpointsDataForEpoch(epochNumber);
+        const blocks = await Promise.all(checkpointsData.flatMap((checkpoint)=>range(checkpoint.blockCount, checkpoint.startBlock).map((blockNumber)=>this.getBlockHeader(BlockNumber(blockNumber)))));
+        return blocks.filter(isDefined);
+    }
+    async getCheckpointsForEpoch(epochNumber) {
+        const checkpointsData = await this.getCheckpointsDataForEpoch(epochNumber);
+        return Promise.all(checkpointsData.map((data)=>this.getPublishedCheckpointFromCheckpointData(data).then((p)=>p.checkpoint)));
+    }
+    /** Returns checkpoint data for all checkpoints whose slot falls within the given epoch. */ getCheckpointsDataForEpoch(epochNumber) {
+        if (!this.l1Constants) {
+            throw new Error('L1 constants not set');
+        }
+        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
+        return this.store.getCheckpointDataForSlotRange(start, end);
+    }
+    async getBlock(number) {
+        // If the number provided is -ve, then return the latest block.
+        if (number < 0) {
+            number = await this.store.getLatestBlockNumber();
+        }
+        if (number === 0) {
+            return undefined;
+        }
+        return this.store.getBlock(number);
+    }
+    getBlocks(from, limit) {
+        return this.store.getBlocks(from, limit);
+    }
+    getCheckpointedBlockByHash(blockHash) {
+        return this.store.getCheckpointedBlockByHash(blockHash);
+    }
+    getCheckpointedBlockByArchive(archive) {
+        return this.store.getCheckpointedBlockByArchive(archive);
+    }
+    async getL2BlockByHash(blockHash) {
+        const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
+        return checkpointedBlock?.block;
+    }
+    async getL2BlockByArchive(archive) {
+        const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
+        return checkpointedBlock?.block;
+    }
+}

package/dest/modules/data_store_updater.d.ts

@@ -0,0 +1,80 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import type { L2TipsCache } from '../store/l2_tips_cache.js';
+/** Result of adding checkpoints with information about any pruned blocks. */
+type ReconcileCheckpointsResult = {
+    /** Blocks that were pruned due to conflict with L1 checkpoints. */
+    prunedBlocks: L2Block[] | undefined;
+    /** Last block number that was already inserted locally, or undefined if none. */
+    lastAlreadyInsertedBlockNumber: BlockNumber | undefined;
+};
+/** Archiver helper module to handle updates to the data store. */
+export declare class ArchiverDataStoreUpdater {
+    private store;
+    private l2TipsCache?;
+    private readonly log;
+    constructor(store: KVArchiverDataStore, l2TipsCache?: L2TipsCache | undefined);
+    /**
+     * Adds proposed blocks to the store with contract class/instance extraction from logs.
+     * These are uncheckpointed blocks that have been proposed by the sequencer but not yet included in a checkpoint on L1.
+     * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
+     * and individually broadcasted functions from the block logs.
+     *
+     * @param blocks - The proposed L2 blocks to add.
+     * @param pendingChainValidationStatus - Optional validation status to set.
+     * @returns True if the operation is successful.
+     */
+    addProposedBlocks(blocks: L2Block[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean>;
+    /**
+     * Reconciles local blocks with incoming checkpoints from L1.
+     * 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,
+     * and individually broadcasted functions from the checkpoint block logs.
+     *
+     * @param checkpoints - The published checkpoints to add.
+     * @param pendingChainValidationStatus - Optional validation status to set.
+     * @returns Result with information about any pruned blocks.
+     */
+    addCheckpoints(checkpoints: PublishedCheckpoint[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<ReconcileCheckpointsResult>;
+    private pruneMismatchingLocalBlocks;
+    /**
+     * Removes all uncheckpointed blocks strictly after the specified block number and cleans up associated contract data.
+     * This handles removal of provisionally added blocks along with their contract classes/instances.
+     * Verifies that each block being removed is not part of a stored checkpoint.
+     *
+     * @param blockNumber - Remove all blocks with number greater than this.
+     * @returns The removed blocks.
+     * @throws Error if any block to be removed is checkpointed.
+     */
+    removeUncheckpointedBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]>;
+    private removeBlocksAfter;
+    /**
+     * Removes all checkpoints after the given checkpoint number.
+     * Deletes ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated data
+     * that was stored for the removed checkpoints. Also removes ALL blocks (both checkpointed
+     * and uncheckpointed) after the last block of the given checkpoint.
+     *
+     * @param checkpointNumber - Remove all checkpoints strictly after this one.
+     * @returns True if the operation is successful.
+     */
+    removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean>;
+    /**
+     * Updates the proven checkpoint number and refreshes the L2 tips cache.
+     * @param checkpointNumber - The checkpoint number to set as proven.
+     */
+    setProvenCheckpointNumber(checkpointNumber: CheckpointNumber): Promise<void>;
+    /** Extracts and stores contract data from a single block. */
+    private addContractDataToDb;
+    /** Removes contract data associated with a block. */
+    private removeContractDataFromDb;
+    private updateContractDataOnDb;
+    private updatePublishedContractClasses;
+    private updateDeployedContractInstances;
+    private updateUpdatedContractInstances;
+    private storeBroadcastedIndividualFunctions;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YV9zdG9yZV91cGRhdGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kdWxlcy9kYXRhX3N0b3JlX3VwZGF0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBWWhGLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzdFLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFhcEUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQVE3RCw2RUFBNkU7QUFDN0UsS0FBSywwQkFBMEIsR0FBRztJQUNoQyxtRUFBbUU7SUFDbkUsWUFBWSxFQUFFLE9BQU8sRUFBRSxHQUFHLFNBQVMsQ0FBQztJQUNwQyxpRkFBaUY7SUFDakYsOEJBQThCLEVBQUUsV0FBVyxHQUFHLFNBQVMsQ0FBQztDQUN6RCxDQUFDO0FBRUYsa0VBQWtFO0FBQ2xFLHFCQUFhLHdCQUF3QjtJQUlqQyxPQUFPLENBQUMsS0FBSztJQUNiLE9BQU8sQ0FBQyxXQUFXLENBQUM7SUFKdEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQTBDO0lBRTlELFlBQ1UsS0FBSyxFQUFFLG1CQUFtQixFQUMxQixXQUFXLENBQUMseUJBQWEsRUFDL0I7SUFFSjs7Ozs7Ozs7O09BU0c7SUFDVSxpQkFBaUIsQ0FDNUIsTUFBTSxFQUFFLE9BQU8sRUFBRSxFQUNqQiw0QkFBNEIsQ0FBQyxFQUFFLHdCQUF3QixHQUN0RCxPQUFPLENBQUMsT0FBTyxDQUFDLENBaUJsQjtJQUVEOzs7Ozs7Ozs7O09BVUc7SUFDVSxjQUFjLENBQ3pCLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxFQUNsQyw0QkFBNEIsQ0FBQyxFQUFFLHdCQUF3QixHQUN0RCxPQUFPLENBQUMsMEJBQTBCLENBQUMsQ0F5QnJDO1lBUWEsMkJBQTJCO0lBbUV6Qzs7Ozs7Ozs7T0FRRztJQUNVLCtCQUErQixDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBZXpGO1lBTWEsaUJBQWlCO0lBYS9COzs7Ozs7OztPQVFHO0lBQ1Usc0JBQXNCLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWV4RjtJQUVEOzs7T0FHRztJQUNVLHlCQUF5QixDQUFDLGdCQUFnQixFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FLeEY7SUFFRCw2REFBNkQ7SUFDN0QsT0FBTyxDQUFDLG1CQUFtQjtJQUkzQixxREFBcUQ7SUFDckQsT0FBTyxDQUFDLHdCQUF3QjtZQUtsQixzQkFBc0I7WUFvQnRCLDhCQUE4QjtZQTRCOUIsK0JBQStCO1lBeUIvQiw4QkFBOEI7WUE2QjlCLG1DQUFtQztDQXdEbEQifQ==

package/dest/modules/data_store_updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_store_updater.d.ts","sourceRoot":"","sources":["../../src/modules/data_store_updater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAYhF,OAAO,KAAK,EAAE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAapE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAQ7D,6EAA6E;AAC7E,KAAK,0BAA0B,GAAG;IAChC,mEAAmE;IACnE,YAAY,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;IACpC,iFAAiF;IACjF,8BAA8B,EAAE,WAAW,GAAG,SAAS,CAAC;CACzD,CAAC;AAEF,kEAAkE;AAClE,qBAAa,wBAAwB;IAIjC,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,WAAW,CAAC;IAJtB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA0C;IAE9D,YACU,KAAK,EAAE,mBAAmB,EAC1B,WAAW,CAAC,yBAAa,EAC/B;IAEJ;;;;;;;;;OASG;IACU,iBAAiB,CAC5B,MAAM,EAAE,OAAO,EAAE,EACjB,4BAA4B,CAAC,EAAE,wBAAwB,GACtD,OAAO,CAAC,OAAO,CAAC,CAiBlB;IAED;;;;;;;;;;OAUG;IACU,cAAc,CACzB,WAAW,EAAE,mBAAmB,EAAE,EAClC,4BAA4B,CAAC,EAAE,wBAAwB,GACtD,OAAO,CAAC,0BAA0B,CAAC,CAyBrC;YAQa,2BAA2B;IAmEzC;;;;;;;;OAQG;IACU,+BAA+B,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAezF;YAMa,iBAAiB;IAa/B;;;;;;;;OAQG;IACU,sBAAsB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAexF;IAED;;;OAGG;IACU,yBAAyB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKxF;IAED,6DAA6D;IAC7D,OAAO,CAAC,mBAAmB;IAI3B,qDAAqD;IACrD,OAAO,CAAC,wBAAwB;YAKlB,sBAAsB;YAoBtB,8BAA8B;YA4B9B,+BAA+B;YAyB/B,8BAA8B;YA6B9B,mCAAmC;CAwDlD"}

package/dest/modules/data_store_updater.js

@@ -0,0 +1,323 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { ContractClassPublishedEvent, PrivateFunctionBroadcastedEvent, UtilityFunctionBroadcastedEvent } from '@aztec/protocol-contracts/class-registry';
+import { ContractInstancePublishedEvent, ContractInstanceUpdatedEvent } from '@aztec/protocol-contracts/instance-registry';
+import { computePublicBytecodeCommitment, isValidPrivateFunctionMembershipProof, isValidUtilityFunctionMembershipProof } from '@aztec/stdlib/contract';
+import groupBy from 'lodash.groupby';
+/** Operation type for contract data updates. */ var Operation = /*#__PURE__*/ function(Operation) {
+    Operation[Operation["Store"] = 0] = "Store";
+    Operation[Operation["Delete"] = 1] = "Delete";
+    return Operation;
+}(Operation || {});
+/** Archiver helper module to handle updates to the data store. */ export class ArchiverDataStoreUpdater {
+    store;
+    l2TipsCache;
+    log;
+    constructor(store, l2TipsCache){
+        this.store = store;
+        this.l2TipsCache = l2TipsCache;
+        this.log = createLogger('archiver:store_updater');
+    }
+    /**
+   * Adds proposed blocks to the store with contract class/instance extraction from logs.
+   * These are uncheckpointed blocks that have been proposed by the sequencer but not yet included in a checkpoint on L1.
+   * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
+   * and individually broadcasted functions from the block logs.
+   *
+   * @param blocks - The proposed L2 blocks to add.
+   * @param pendingChainValidationStatus - Optional validation status to set.
+   * @returns True if the operation is successful.
+   */ async addProposedBlocks(blocks, pendingChainValidationStatus) {
+        const result = await this.store.transactionAsync(async ()=>{
+            await this.store.addProposedBlocks(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)=>this.addContractDataToDb(block))
+            ]);
+            await this.l2TipsCache?.refresh();
+            return opResults.every(Boolean);
+        });
+        return result;
+    }
+    /**
+   * Reconciles local blocks with incoming checkpoints from L1.
+   * 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,
+   * and individually broadcasted functions from the checkpoint block logs.
+   *
+   * @param checkpoints - The published checkpoints to add.
+   * @param pendingChainValidationStatus - Optional validation status to set.
+   * @returns Result with information about any pruned blocks.
+   */ async addCheckpoints(checkpoints, pendingChainValidationStatus) {
+        const result = await this.store.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);
+            // Filter out blocks that were already inserted via addProposedBlocks() to avoid duplicating logs/contract data
+            const newBlocks = checkpoints.flatMap((ch)=>ch.checkpoint.blocks).filter((b)=>lastAlreadyInsertedBlockNumber === undefined || b.number > lastAlreadyInsertedBlockNumber);
+            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(newBlocks),
+                // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
+                ...newBlocks.map((block)=>this.addContractDataToDb(block))
+            ]);
+            await this.l2TipsCache?.refresh();
+            return {
+                prunedBlocks,
+                lastAlreadyInsertedBlockNumber
+            };
+        });
+        return result;
+    }
+    /**
+   * Checks for local proposed blocks that do not match the ones to be checkpointed and prunes them.
+   * This method handles multiple checkpoints but returns after pruning the first conflict found.
+   * This is correct because pruning from the first conflict point removes all subsequent blocks,
+   * and when checkpoints are added afterward, they include all the correct blocks.
+   */ async pruneMismatchingLocalBlocks(checkpoints) {
+        const [lastCheckpointedBlockNumber, lastBlockNumber] = await Promise.all([
+            this.store.getCheckpointedL2BlockNumber(),
+            this.store.getLatestBlockNumber()
+        ]);
+        // Exit early if there are no local uncheckpointed blocks
+        if (lastBlockNumber === lastCheckpointedBlockNumber) {
+            return {
+                prunedBlocks: undefined,
+                lastAlreadyInsertedBlockNumber: undefined
+            };
+        }
+        // Get all uncheckpointed local blocks
+        const uncheckpointedLocalBlocks = await this.store.getBlocks(BlockNumber.add(lastCheckpointedBlockNumber, 1), lastBlockNumber - lastCheckpointedBlockNumber);
+        let lastAlreadyInsertedBlockNumber;
+        for (const publishedCheckpoint of checkpoints){
+            const checkpointBlocks = publishedCheckpoint.checkpoint.blocks;
+            const slot = publishedCheckpoint.checkpoint.slot;
+            const localBlocksInSlot = uncheckpointedLocalBlocks.filter((b)=>b.slot === slot);
+            if (checkpointBlocks.length === 0) {
+                this.log.warn(`Checkpoint ${publishedCheckpoint.checkpoint.number} for slot ${slot} has no blocks`);
+                continue;
+            }
+            // Find the first checkpoint block that conflicts with an existing local block and prune local afterwards
+            for (const checkpointBlock of checkpointBlocks){
+                const blockNumber = checkpointBlock.number;
+                const existingBlock = localBlocksInSlot.find((b)=>b.number === blockNumber);
+                const blockInfos = {
+                    existingBlock: existingBlock?.toBlockInfo(),
+                    checkpointBlock: checkpointBlock.toBlockInfo()
+                };
+                if (!existingBlock) {
+                    this.log.verbose(`No local block found for checkpointed block number ${blockNumber}`, blockInfos);
+                } else if (existingBlock.archive.root.equals(checkpointBlock.archive.root)) {
+                    this.log.verbose(`Block number ${blockNumber} already inserted and matches checkpoint`, blockInfos);
+                    lastAlreadyInsertedBlockNumber = blockNumber;
+                } else {
+                    this.log.warn(`Conflict detected at block ${blockNumber} between checkpointed and local block`, blockInfos);
+                    const prunedBlocks = await this.removeBlocksAfter(BlockNumber(blockNumber - 1));
+                    return {
+                        prunedBlocks,
+                        lastAlreadyInsertedBlockNumber
+                    };
+                }
+            }
+            // If local has more blocks than the checkpoint (e.g., local has [2,3,4] but checkpoint has [2,3]),
+            // we need to prune the extra local blocks so they match what was checkpointed
+            const lastCheckpointBlockNumber = checkpointBlocks.at(-1).number;
+            const lastLocalBlockNumber = localBlocksInSlot.at(-1)?.number;
+            if (lastLocalBlockNumber !== undefined && lastLocalBlockNumber > lastCheckpointBlockNumber) {
+                this.log.warn(`Local chain for slot ${slot} ends at block ${lastLocalBlockNumber} but checkpoint ends at ${lastCheckpointBlockNumber}. Pruning blocks after block ${lastCheckpointBlockNumber}.`);
+                const prunedBlocks = await this.removeBlocksAfter(lastCheckpointBlockNumber);
+                return {
+                    prunedBlocks,
+                    lastAlreadyInsertedBlockNumber
+                };
+            }
+        }
+        return {
+            prunedBlocks: undefined,
+            lastAlreadyInsertedBlockNumber
+        };
+    }
+    /**
+   * Removes all uncheckpointed blocks strictly after the specified block number and cleans up associated contract data.
+   * This handles removal of provisionally added blocks along with their contract classes/instances.
+   * Verifies that each block being removed is not part of a stored checkpoint.
+   *
+   * @param blockNumber - Remove all blocks with number greater than this.
+   * @returns The removed blocks.
+   * @throws Error if any block to be removed is checkpointed.
+   */ async removeUncheckpointedBlocksAfter(blockNumber) {
+        const result = await this.store.transactionAsync(async ()=>{
+            // Verify we're only removing uncheckpointed blocks
+            const lastCheckpointedBlockNumber = await this.store.getCheckpointedL2BlockNumber();
+            if (blockNumber < lastCheckpointedBlockNumber) {
+                throw new Error(`Cannot remove blocks after ${blockNumber} because checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`);
+            }
+            const result = await this.removeBlocksAfter(blockNumber);
+            await this.l2TipsCache?.refresh();
+            return result;
+        });
+        return result;
+    }
+    /**
+   * Removes all blocks strictly after the given block number along with any logs and contract data.
+   * Does not remove their checkpoints.
+   */ async removeBlocksAfter(blockNumber) {
+        // First get the blocks to be removed so we can clean up contract data
+        const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
+        // Clean up contract data and logs for the removed blocks
+        await Promise.all([
+            this.store.deleteLogs(removedBlocks),
+            ...removedBlocks.map((block)=>this.removeContractDataFromDb(block))
+        ]);
+        return removedBlocks;
+    }
+    /**
+   * Removes all checkpoints after the given checkpoint number.
+   * Deletes ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated data
+   * that was stored for the removed checkpoints. Also removes ALL blocks (both checkpointed
+   * and uncheckpointed) after the last block of the given checkpoint.
+   *
+   * @param checkpointNumber - Remove all checkpoints strictly after this one.
+   * @returns True if the operation is successful.
+   */ async removeCheckpointsAfter(checkpointNumber) {
+        return await this.store.transactionAsync(async ()=>{
+            const { blocksRemoved = [] } = await this.store.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
+                }),
+                // Remove contract data for all blocks being removed
+                ...blocksRemoved.map((block)=>this.removeContractDataFromDb(block)),
+                this.store.deleteLogs(blocksRemoved)
+            ]);
+            await this.l2TipsCache?.refresh();
+            return opResults.every(Boolean);
+        });
+    }
+    /**
+   * Updates the proven checkpoint number and refreshes the L2 tips cache.
+   * @param checkpointNumber - The checkpoint number to set as proven.
+   */ async setProvenCheckpointNumber(checkpointNumber) {
+        await this.store.transactionAsync(async ()=>{
+            await this.store.setProvenCheckpointNumber(checkpointNumber);
+            await this.l2TipsCache?.refresh();
+        });
+    }
+    /** Extracts and stores contract data from a single block. */ addContractDataToDb(block) {
+        return this.updateContractDataOnDb(block, 0);
+    }
+    /** Removes contract data associated with a block. */ removeContractDataFromDb(block) {
+        return this.updateContractDataOnDb(block, 1);
+    }
+    /** Adds or remove contract data associated with a block. */ async updateContractDataOnDb(block, operation) {
+        const contractClassLogs = block.body.txEffects.flatMap((txEffect)=>txEffect.contractClassLogs);
+        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, operation),
+            this.updateDeployedContractInstances(privateLogs, block.number, operation),
+            this.updateUpdatedContractInstances(publicLogs, block.header.globalVariables.timestamp, operation),
+            operation === 0 ? this.storeBroadcastedIndividualFunctions(contractClassLogs, block.number) : Promise.resolve(true)
+        ])).every(Boolean);
+    }
+    /**
+   * Extracts and stores contract classes out of ContractClassPublished events emitted by the class registry contract.
+   */ 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.
+   */ 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 instance updates out of ContractInstanceUpdated events.
+   */ 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.
+   */ 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.store.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;
+    }
+}

package/dest/modules/instrumentation.d.ts

@@ -0,0 +1,39 @@
+import type { L2Block } from '@aztec/stdlib/block';
+import type { CheckpointData } from '@aztec/stdlib/checkpoint';
+import { type LmdbStatsCallback, type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+export declare class ArchiverInstrumentation {
+    private telemetry;
+    readonly tracer: Tracer;
+    private blockHeight;
+    private checkpointHeight;
+    private txCount;
+    private l1BlockHeight;
+    private proofsSubmittedDelay;
+    private proofsSubmittedCount;
+    private dbMetrics;
+    private pruneDuration;
+    private pruneCount;
+    private syncDurationPerBlock;
+    private syncBlockCount;
+    private manaPerBlock;
+    private txsPerBlock;
+    private syncDurationPerMessage;
+    private syncMessageCount;
+    private blockProposalTxTargetCount;
+    private log;
+    private constructor();
+    static new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback): Promise<ArchiverInstrumentation>;
+    isEnabled(): boolean;
+    processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]): void;
+    processNewMessages(count: number, syncPerMessageMs: number): void;
+    processPrune(duration: number): void;
+    updateLastProvenCheckpoint(checkpoint: CheckpointData): void;
+    processProofsVerified(logs: {
+        proverId: string;
+        l2BlockNumber: bigint;
+        delay: bigint;
+    }[]): void;
+    updateL1BlockHeight(blockNumber: bigint): void;
+    recordBlockProposalTxTarget(target: string, usedTrace: boolean): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kdWxlcy9pbnN0cnVtZW50YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDL0QsT0FBTyxFQUtMLEtBQUssaUJBQWlCLEVBRXRCLEtBQUssZUFBZSxFQUNwQixLQUFLLE1BQU0sRUFHWixNQUFNLHlCQUF5QixDQUFDO0FBRWpDLHFCQUFhLHVCQUF1QjtJQTJCaEMsT0FBTyxDQUFDLFNBQVM7SUExQm5CLFNBQWdCLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFFL0IsT0FBTyxDQUFDLFdBQVcsQ0FBUTtJQUMzQixPQUFPLENBQUMsZ0JBQWdCLENBQVE7SUFDaEMsT0FBTyxDQUFDLE9BQU8sQ0FBZ0I7SUFDL0IsT0FBTyxDQUFDLGFBQWEsQ0FBUTtJQUM3QixPQUFPLENBQUMsb0JBQW9CLENBQVk7SUFDeEMsT0FBTyxDQUFDLG9CQUFvQixDQUFnQjtJQUM1QyxPQUFPLENBQUMsU0FBUyxDQUFjO0lBRS9CLE9BQU8sQ0FBQyxhQUFhLENBQVk7SUFDakMsT0FBTyxDQUFDLFVBQVUsQ0FBZ0I7SUFFbEMsT0FBTyxDQUFDLG9CQUFvQixDQUFZO0lBQ3hDLE9BQU8sQ0FBQyxjQUFjLENBQWdCO0lBQ3RDLE9BQU8sQ0FBQyxZQUFZLENBQVk7SUFDaEMsT0FBTyxDQUFDLFdBQVcsQ0FBWTtJQUUvQixPQUFPLENBQUMsc0JBQXNCLENBQVk7SUFDMUMsT0FBTyxDQUFDLGdCQUFnQixDQUFnQjtJQUV4QyxPQUFPLENBQUMsMEJBQTBCLENBQWdCO0lBRWxELE9BQU8sQ0FBQyxHQUFHLENBQTRDO0lBRXZELE9BQU8sZUFvRE47SUFFRCxPQUFvQixHQUFHLENBQUMsU0FBUyxFQUFFLGVBQWUsRUFBRSxTQUFTLENBQUMsRUFBRSxpQkFBaUIsb0NBTWhGO0lBRU0sU0FBUyxJQUFJLE9BQU8sQ0FFMUI7SUFFTSxnQkFBZ0IsQ0FBQyxnQkFBZ0IsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxRQVdsRTtJQUVNLGtCQUFrQixDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxRQU1oRTtJQUVNLFlBQVksQ0FBQyxRQUFRLEVBQUUsTUFBTSxRQUduQztJQUVNLDBCQUEwQixDQUFDLFVBQVUsRUFBRSxjQUFjLFFBSTNEO0lBRU0scUJBQXFCLENBQUMsSUFBSSxFQUFFO1FBQUUsUUFBUSxFQUFFLE1BQU0sQ0FBQztRQUFDLGFBQWEsRUFBRSxNQUFNLENBQUM7UUFBQyxLQUFLLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFBRSxRQVc5RjtJQUVNLG1CQUFtQixDQUFDLFdBQVcsRUFBRSxNQUFNLFFBRTdDO0lBRU0sMkJBQTJCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsT0FBTyxRQUtwRTtDQUNGIn0=