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

package/dest/{archiver/archive_source_base.js → modules/data_source_base.js}

@@ -1,17 +1,28 @@
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { isDefined } from '@aztec/foundation/types';
 import { CommitteeAttestation, L2Block, PublishedL2Block } from '@aztec/stdlib/block';
 import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 /**
- * Abstract base class implementing ArchiveSource using a KVArchiverDataStore.
+ * 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 ArchiveSourceBase {
+ */ export class ArchiverDataSourceBase {
     store;
-    constructor(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();
     }
-    // Store-delegating methods
     getBlockNumber() {
         return this.store.getLatestBlockNumber();
     }
@@ -29,6 +40,29 @@ import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
     getCheckpointedBlock(number) {
         return this.store.getCheckpointedBlock(number);
     }
+    getCheckpointedBlockNumber() {
+        return this.store.getCheckpointedL2BlockNumber();
+    }
+    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.numBlocks - 1);
+    }
     async getCheckpointedBlocks(from, limit, proven) {
         const blocks = await this.store.getCheckpointedBlocks(from, limit);
         if (proven === true) {
@@ -76,7 +110,6 @@ import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
         }
         return blocks;
     }
-    // L2LogsSource methods
     getPrivateLogsByTags(tags) {
         return this.store.getPrivateLogsByTags(tags);
     }
@@ -89,7 +122,6 @@ import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
     getContractClassLogs(filter) {
         return this.store.getContractClassLogs(filter);
     }
-    // ContractDataSource methods
     getContractClass(id) {
         return this.store.getContractClass(id);
     }
@@ -116,14 +148,12 @@ import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
     registerContractFunctionSignatures(signatures) {
         return this.store.registerContractFunctionSignatures(signatures);
     }
-    // L1ToL2MessageSource methods
     getL1ToL2Messages(checkpointNumber) {
         return this.store.getL1ToL2Messages(checkpointNumber);
     }
     getL1ToL2MessageIndex(l1ToL2Message) {
         return this.store.getL1ToL2MessageIndex(l1ToL2Message);
     }
-    // Published checkpoint methods
     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);
@@ -137,6 +167,76 @@ import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
         }
         return fullCheckpoints;
     }
+    async getBlocksForEpoch(epochNumber) {
+        if (!this.l1Constants) {
+            throw new Error('L1 constants not set');
+        }
+        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
+        const blocks = [];
+        // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
+        // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
+        let checkpoint = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
+        const slot = (b)=>b.header.slotNumber;
+        while(checkpoint && slot(checkpoint) >= start){
+            if (slot(checkpoint) <= end) {
+                // push the blocks on backwards
+                const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
+                for(let i = endBlock; i >= checkpoint.startBlock; i--){
+                    const block = await this.getBlock(BlockNumber(i));
+                    if (block) {
+                        blocks.push(block);
+                    }
+                }
+            }
+            checkpoint = await this.store.getCheckpointData(CheckpointNumber(checkpoint.checkpointNumber - 1));
+        }
+        return blocks.reverse();
+    }
+    async getBlockHeadersForEpoch(epochNumber) {
+        if (!this.l1Constants) {
+            throw new Error('L1 constants not set');
+        }
+        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
+        const blocks = [];
+        // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
+        // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
+        let checkpoint = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
+        const slot = (b)=>b.header.slotNumber;
+        while(checkpoint && slot(checkpoint) >= start){
+            if (slot(checkpoint) <= end) {
+                // push the blocks on backwards
+                const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
+                for(let i = endBlock; i >= checkpoint.startBlock; i--){
+                    const block = await this.getBlockHeader(BlockNumber(i));
+                    if (block) {
+                        blocks.push(block);
+                    }
+                }
+            }
+            checkpoint = await this.store.getCheckpointData(CheckpointNumber(checkpoint.checkpointNumber - 1));
+        }
+        return blocks.reverse();
+    }
+    async getCheckpointsForEpoch(epochNumber) {
+        if (!this.l1Constants) {
+            throw new Error('L1 constants not set');
+        }
+        const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
+        const checkpoints = [];
+        // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
+        // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
+        let checkpointData = await this.store.getCheckpointData(await this.store.getSynchedCheckpointNumber());
+        const slot = (b)=>b.header.slotNumber;
+        while(checkpointData && slot(checkpointData) >= start){
+            if (slot(checkpointData) <= end) {
+                // push the checkpoints on backwards
+                const [checkpoint] = await this.getPublishedCheckpoints(checkpointData.checkpointNumber, 1);
+                checkpoints.push(checkpoint.checkpoint);
+            }
+            checkpointData = await this.store.getCheckpointData(CheckpointNumber(checkpointData.checkpointNumber - 1));
+        }
+        return checkpoints.reverse();
+    }
     async getPublishedBlocks(from, limit, proven) {
         const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
         const provenCheckpointNumber = await this.store.getProvenCheckpointNumber();
@@ -157,7 +257,6 @@ import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
         }
         return olbBlocks;
     }
-    // Legacy APIs
     async getBlock(number) {
         // If the number provided is -ve, then return the latest block.
         if (number < 0) {

package/dest/modules/data_store_updater.d.ts

@@ -0,0 +1,46 @@
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { L2BlockNew, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+/** Archiver helper module to handle updates to the data store. */
+export declare class ArchiverDataStoreUpdater {
+    private store;
+    private readonly log;
+    constructor(store: KVArchiverDataStore);
+    /**
+     * Adds blocks to the store with contract class/instance extraction from logs.
+     * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
+     * and individually broadcasted functions from the block logs.
+     *
+     * @param blocks - The L2 blocks to add.
+     * @param pendingChainValidationStatus - Optional validation status to set.
+     * @returns True if the operation is successful.
+     */
+    addBlocksWithContractData(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean>;
+    /**
+     * Adds checkpoints to the store with contract class/instance extraction from logs.
+     * 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 True if the operation is successful.
+     */
+    addCheckpointsWithContractData(checkpoints: PublishedCheckpoint[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean>;
+    /**
+     * Unwinds checkpoints from the store with reverse contract extraction.
+     * Deletes ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated data
+     * that was stored for the unwound checkpoints.
+     *
+     * @param from - The checkpoint number to unwind from (must be the current tip).
+     * @param checkpointsToUnwind - The number of checkpoints to unwind.
+     * @returns True if the operation is successful.
+     */
+    unwindCheckpointsWithContractData(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean>;
+    private addBlockDataToDB;
+    private updatePublishedContractClasses;
+    private updateDeployedContractInstances;
+    private updateUpdatedContractInstances;
+    private storeBroadcastedIndividualFunctions;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YV9zdG9yZV91cGRhdGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kdWxlcy9kYXRhX3N0b3JlX3VwZGF0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQWUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQVlyRixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBYXBFLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFRekUsa0VBQWtFO0FBQ2xFLHFCQUFhLHdCQUF3QjtJQUd2QixPQUFPLENBQUMsS0FBSztJQUZ6QixPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBMEM7SUFFOUQsWUFBb0IsS0FBSyxFQUFFLG1CQUFtQixFQUFJO0lBRWxEOzs7Ozs7OztPQVFHO0lBQ0kseUJBQXlCLENBQzlCLE1BQU0sRUFBRSxVQUFVLEVBQUUsRUFDcEIsNEJBQTRCLENBQUMsRUFBRSx3QkFBd0IsR0FDdEQsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWVsQjtJQUVEOzs7Ozs7OztPQVFHO0lBQ0ksOEJBQThCLENBQ25DLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxFQUNsQyw0QkFBNEIsQ0FBQyxFQUFFLHdCQUF3QixHQUN0RCxPQUFPLENBQUMsT0FBTyxDQUFDLENBZ0JsQjtJQUVEOzs7Ozs7OztPQVFHO0lBQ1UsaUNBQWlDLENBQzVDLElBQUksRUFBRSxnQkFBZ0IsRUFDdEIsbUJBQW1CLEVBQUUsTUFBTSxHQUMxQixPQUFPLENBQUMsT0FBTyxDQUFDLENBNENsQjtZQUthLGdCQUFnQjtZQW1CaEIsOEJBQThCO1lBNEI5QiwrQkFBK0I7WUF5Qi9CLDhCQUE4QjtZQTZCOUIsbUNBQW1DO0NBd0RsRCJ9

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,KAAK,EAAe,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAYrF,OAAO,KAAK,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAapE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAQzE,kEAAkE;AAClE,qBAAa,wBAAwB;IAGvB,OAAO,CAAC,KAAK;IAFzB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA0C;IAE9D,YAAoB,KAAK,EAAE,mBAAmB,EAAI;IAElD;;;;;;;;OAQG;IACI,yBAAyB,CAC9B,MAAM,EAAE,UAAU,EAAE,EACpB,4BAA4B,CAAC,EAAE,wBAAwB,GACtD,OAAO,CAAC,OAAO,CAAC,CAelB;IAED;;;;;;;;OAQG;IACI,8BAA8B,CACnC,WAAW,EAAE,mBAAmB,EAAE,EAClC,4BAA4B,CAAC,EAAE,wBAAwB,GACtD,OAAO,CAAC,OAAO,CAAC,CAgBlB;IAED;;;;;;;;OAQG;IACU,iCAAiC,CAC5C,IAAI,EAAE,gBAAgB,EACtB,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC,CA4ClB;YAKa,gBAAgB;YAmBhB,8BAA8B;YA4B9B,+BAA+B;YAyB/B,8BAA8B;YA6B9B,mCAAmC;CAwDlD"}

package/dest/modules/data_store_updater.js

@@ -0,0 +1,216 @@
+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;
+    log;
+    constructor(store){
+        this.store = store;
+        this.log = createLogger('archiver:store_updater');
+    }
+    /**
+   * Adds blocks to the store with contract class/instance extraction from logs.
+   * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events,
+   * and individually broadcasted functions from the block logs.
+   *
+   * @param blocks - The L2 blocks to add.
+   * @param pendingChainValidationStatus - Optional validation status to set.
+   * @returns True if the operation is successful.
+   */ addBlocksWithContractData(blocks, pendingChainValidationStatus) {
+        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)=>this.addBlockDataToDB(block))
+            ]);
+            return opResults.every(Boolean);
+        });
+    }
+    /**
+   * Adds checkpoints to the store with contract class/instance extraction from logs.
+   * 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 True if the operation is successful.
+   */ addCheckpointsWithContractData(checkpoints, pendingChainValidationStatus) {
+        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)=>this.addBlockDataToDB(block))
+            ]);
+            return opResults.every(Boolean);
+        });
+    }
+    /**
+   * Unwinds checkpoints from the store with reverse contract extraction.
+   * Deletes ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated data
+   * that was stored for the unwound checkpoints.
+   *
+   * @param from - The checkpoint number to unwind from (must be the current tip).
+   * @param checkpointsToUnwind - The number of checkpoints to unwind.
+   * @returns True if the operation is successful.
+   */ async unwindCheckpointsWithContractData(from, checkpointsToUnwind) {
+        if (checkpointsToUnwind <= 0) {
+            throw new Error(`Cannot unwind ${checkpointsToUnwind} blocks`);
+        }
+        const last = await this.store.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);
+    }
+    /**
+   * Extracts and stores contract data from a single block.
+   */ 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);
+    }
+    /**
+   * 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,37 @@
+import type { L2BlockNew } from '@aztec/stdlib/block';
+import { type LmdbStatsCallback, type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+export declare class ArchiverInstrumentation {
+    private telemetry;
+    readonly tracer: Tracer;
+    private blockHeight;
+    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: L2BlockNew[]): void;
+    processNewMessages(count: number, syncPerMessageMs: number): void;
+    processPrune(duration: number): void;
+    updateLastProvenBlock(blockNumber: number): 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kdWxlcy9pbnN0cnVtZW50YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDdEQsT0FBTyxFQUtMLEtBQUssaUJBQWlCLEVBRXRCLEtBQUssZUFBZSxFQUNwQixLQUFLLE1BQU0sRUFFWixNQUFNLHlCQUF5QixDQUFDO0FBRWpDLHFCQUFhLHVCQUF1QjtJQTBCaEMsT0FBTyxDQUFDLFNBQVM7SUF6Qm5CLFNBQWdCLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFFL0IsT0FBTyxDQUFDLFdBQVcsQ0FBUTtJQUMzQixPQUFPLENBQUMsT0FBTyxDQUFnQjtJQUMvQixPQUFPLENBQUMsYUFBYSxDQUFRO0lBQzdCLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBWTtJQUN4QyxPQUFPLENBQUMsb0JBQW9CLENBQWdCO0lBQzVDLE9BQU8sQ0FBQyxTQUFTLENBQWM7SUFFL0IsT0FBTyxDQUFDLGFBQWEsQ0FBWTtJQUNqQyxPQUFPLENBQUMsVUFBVSxDQUFnQjtJQUVsQyxPQUFPLENBQUMsb0JBQW9CLENBQVk7SUFDeEMsT0FBTyxDQUFDLGNBQWMsQ0FBZ0I7SUFDdEMsT0FBTyxDQUFDLFlBQVksQ0FBWTtJQUNoQyxPQUFPLENBQUMsV0FBVyxDQUFZO0lBRS9CLE9BQU8sQ0FBQyxzQkFBc0IsQ0FBWTtJQUMxQyxPQUFPLENBQUMsZ0JBQWdCLENBQWdCO0lBRXhDLE9BQU8sQ0FBQywwQkFBMEIsQ0FBZ0I7SUFFbEQsT0FBTyxDQUFDLEdBQUcsQ0FBNEM7SUFFdkQsT0FBTyxlQTBDTjtJQUVELE9BQW9CLEdBQUcsQ0FBQyxTQUFTLEVBQUUsZUFBZSxFQUFFLFNBQVMsQ0FBQyxFQUFFLGlCQUFpQixvQ0FVaEY7SUFFTSxTQUFTLElBQUksT0FBTyxDQUUxQjtJQUVNLGdCQUFnQixDQUFDLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLFFBVXJFO0lBRU0sa0JBQWtCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFFBTWhFO0lBRU0sWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLFFBR25DO0lBRU0scUJBQXFCLENBQUMsV0FBVyxFQUFFLE1BQU0sUUFFL0M7SUFFTSxxQkFBcUIsQ0FBQyxJQUFJLEVBQUU7UUFBRSxRQUFRLEVBQUUsTUFBTSxDQUFDO1FBQUMsYUFBYSxFQUFFLE1BQU0sQ0FBQztRQUFDLEtBQUssRUFBRSxNQUFNLENBQUE7S0FBRSxFQUFFLFFBVzlGO0lBRU0sbUJBQW1CLENBQUMsV0FBVyxFQUFFLE1BQU0sUUFFN0M7SUFFTSwyQkFBMkIsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLFFBS3BFO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/modules/instrumentation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAKL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,MAAM,EAEZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uBAAuB;IA0BhC,OAAO,CAAC,SAAS;IAzBnB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,WAAW,CAAY;IAE/B,OAAO,CAAC,sBAAsB,CAAY;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IAExC,OAAO,CAAC,0BAA0B,CAAgB;IAElD,OAAO,CAAC,GAAG,CAA4C;IAEvD,OAAO,eA0CN;IAED,OAAoB,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,iBAAiB,oCAUhF;IAEM,SAAS,IAAI,OAAO,CAE1B;IAEM,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAUrE;IAEM,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,QAMhE;IAEM,YAAY,CAAC,QAAQ,EAAE,MAAM,QAGnC;IAEM,qBAAqB,CAAC,WAAW,EAAE,MAAM,QAE/C;IAEM,qBAAqB,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,QAW9F;IAEM,mBAAmB,CAAC,WAAW,EAAE,MAAM,QAE7C;IAEM,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,QAKpE;CACF"}

package/dest/modules/l1_synchronizer.d.ts

@@ -0,0 +1,67 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { EpochCache } from '@aztec/epoch-cache';
+import { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { type ArchiverEmitter } from '@aztec/stdlib/block';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { type Traceable, type Tracer } from '@aztec/telemetry-client';
+import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import type { ArchiverInstrumentation } from './instrumentation.js';
+/**
+ * Handles L1 synchronization for the archiver.
+ * Responsible for fetching checkpoints, L1→L2 messages, and handling L1 reorgs.
+ */
+export declare class ArchiverL1Synchronizer implements Traceable {
+    private readonly publicClient;
+    private readonly debugClient;
+    private readonly rollup;
+    private readonly inbox;
+    private readonly l1Addresses;
+    private readonly store;
+    private readonly config;
+    private readonly blobClient;
+    private readonly epochCache;
+    private readonly dateProvider;
+    private readonly instrumentation;
+    private readonly l1constants;
+    private readonly events;
+    private readonly log;
+    private l1BlockNumber;
+    private l1Timestamp;
+    private readonly updater;
+    readonly tracer: Tracer;
+    constructor(publicClient: ViemPublicClient, debugClient: ViemPublicDebugClient, rollup: RollupContract, inbox: InboxContract, l1Addresses: Pick<L1ContractAddresses, 'registryAddress' | 'governanceProposerAddress' | 'slashFactoryAddress'> & {
+        slashingProposerAddress: EthAddress;
+    }, store: KVArchiverDataStore, config: {
+        batchSize: number;
+        skipValidateCheckpointAttestations?: boolean;
+        maxAllowedEthClientDriftSeconds: number;
+    }, blobClient: BlobClientInterface, epochCache: EpochCache, dateProvider: DateProvider, instrumentation: ArchiverInstrumentation, l1constants: L1RollupConstants & {
+        l1StartBlockHash: Buffer32;
+        genesisArchiveRoot: Fr;
+    }, events: ArchiverEmitter, tracer: Tracer, log?: Logger);
+    /** Returns the last L1 block number that was synced. */
+    getL1BlockNumber(): bigint | undefined;
+    /** Returns the last L1 timestamp that was synced. */
+    getL1Timestamp(): bigint | undefined;
+    /** Checks that the ethereum node we are connected to has a latest timestamp no more than the allowed drift. Throw if not. */
+    testEthereumNodeSynced(): Promise<void>;
+    syncFromL1(initialSyncComplete: boolean): Promise<void>;
+    private canPrune;
+    private handleEpochPrune;
+    private nextRange;
+    private handleL1ToL2Messages;
+    private retrieveL1ToL2Message;
+    private rollbackL1ToL2Messages;
+    private getL1BlockHash;
+    private handleCheckpoints;
+    private checkForNewCheckpointsBeforeL1SyncPoint;
+    private getCheckpointHeader;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"l1_synchronizer.d.ts","sourceRoot":"","sources":["../../src/modules/l1_synchronizer.ts"],"names":[],"mappings":"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"}