@aztec/archiver 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/dest/modules/data_store_updater.js

@@ -0,0 +1,393 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { filterAsync } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
+import { ContractInstancePublishedEvent, ContractInstanceUpdatedEvent } from '@aztec/protocol-contracts/instance-registry';
+import { validateCheckpoint } from '@aztec/stdlib/checkpoint';
+import { computeContractAddressFromInstance, computeContractClassId } from '@aztec/stdlib/contract';
+/** 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 {
+    stores;
+    l2TipsCache;
+    opts;
+    log;
+    constructor(stores, l2TipsCache, opts = {}){
+        this.stores = stores;
+        this.l2TipsCache = l2TipsCache;
+        this.opts = opts;
+        this.log = createLogger('archiver:store_updater');
+    }
+    /**
+   * Adds a proposed block to the store with contract class/instance extraction from logs.
+   * This is an uncheckpointed block that has been proposed by the sequencer but not yet included in a checkpoint on L1.
+   * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events from the block logs.
+   *
+   * @param block - The proposed L2 block to add.
+   * @param pendingChainValidationStatus - Optional validation status to set.
+   * @returns True if the operation is successful.
+   */ async addProposedBlock(block, pendingChainValidationStatus) {
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.addProposedBlock(block);
+            const opResults = await Promise.all([
+                // Update the pending chain validation status if provided
+                pendingChainValidationStatus && this.stores.blocks.setPendingChainValidationStatus(pendingChainValidationStatus),
+                // Add any logs emitted during the retrieved block
+                this.stores.logs.addLogs([
+                    block
+                ]),
+                // Unroll all logs emitted during the retrieved block and extract any contract classes and instances from it
+                this.addContractDataToDb(block)
+            ]);
+            return opResults.every(Boolean);
+        });
+        await this.l2TipsCache?.refresh();
+        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 from the checkpoint block logs.
+   * If `promoteProposed` is supplied, the proposed-checkpoint promotion runs inside the same transaction
+   * as the added checkpoints so both updates are applied atomically.
+   *
+   * @param checkpoints - The published checkpoints to add (excluding any being promoted from proposed).
+   * @param pendingChainValidationStatus - Optional validation status to set.
+   * @param promoteProposed - Optional promotion of the current proposed checkpoint (fast path when blocks are already local).
+   * @returns Result with information about any pruned blocks.
+   */ async addCheckpoints(checkpoints, pendingChainValidationStatus, promoteProposed, evictProposedFrom) {
+        for (const checkpoint of checkpoints){
+            validateCheckpoint(checkpoint.checkpoint, {
+                rollupManaLimit: this.opts?.rollupManaLimit
+            });
+        }
+        if (promoteProposed) {
+            validateCheckpoint(promoteProposed.checkpoint.checkpoint, {
+                rollupManaLimit: this.opts?.rollupManaLimit
+            });
+        }
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            // Before adding checkpoints, check for conflicts with local blocks if any
+            const { prunedBlocks, lastAlreadyInsertedBlockNumber } = await this.pruneMismatchingLocalBlocks(checkpoints);
+            const insertedCheckpoints = await this.stores.blocks.addCheckpoints(checkpoints);
+            // Skip blocks already inserted via addProposedBlock() and blocks of already-stored checkpoints
+            // re-included by an L1 reorg: their logs/contract data were extracted when first inserted.
+            const newBlocks = insertedCheckpoints.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.stores.blocks.setPendingChainValidationStatus(pendingChainValidationStatus),
+                // Add any logs emitted during the retrieved blocks
+                this.stores.logs.addLogs(newBlocks),
+                // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
+                ...newBlocks.map((block)=>this.addContractDataToDb(block)),
+                // Promote the proposed checkpoint if requested (uses explicit checkpoint number)
+                promoteProposed ? this.stores.blocks.promoteProposedToCheckpointed(promoteProposed.checkpoint.checkpoint.number, promoteProposed.l1, promoteProposed.attestations, promoteProposed.checkpoint.checkpoint.archive.root) : undefined,
+                // Evict pending checkpoints that diverged from what L1 mined
+                evictProposedFrom !== undefined ? this.stores.blocks.evictProposedCheckpointsFrom(evictProposedFrom) : undefined
+            ]);
+            return {
+                prunedBlocks,
+                lastAlreadyInsertedBlockNumber
+            };
+        });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    async addProposedCheckpoint(proposedCheckpoint) {
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.addProposedCheckpoint(proposedCheckpoint);
+        });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    /**
+   * Checks for local proposed blocks that do not match the ones to be checkpointed and prunes them.
+   * Conflict detection is keyed on `blockNumber`: when a local proposed block and an L1
+   * checkpointed block share a block number but live at different slots (e.g. a different proposer
+   * mined the same block number one slot earlier), we still treat them as a conflict and prune.
+   * The trailing per-checkpoint prune that handles "local has extra trailing blocks within the
+   * same slot as the published checkpoint" remains scoped by slot to preserve pipelining: local
+   * blocks that live at a later slot than the checkpoint being processed represent speculation
+   * atop the just-confirmed tip (and may be referenced by a pending proposed checkpoint), so we
+   * leave them in place. 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.stores.blocks.getCheckpointedL2BlockNumber(),
+            this.stores.blocks.getLatestL2BlockNumber()
+        ]);
+        // 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.stores.blocks.getBlocksData({
+            from: BlockNumber.add(lastCheckpointedBlockNumber, 1),
+            limit: lastBlockNumber - lastCheckpointedBlockNumber
+        });
+        let lastAlreadyInsertedBlockNumber;
+        for (const publishedCheckpoint of checkpoints){
+            const checkpointBlocks = publishedCheckpoint.checkpoint.blocks;
+            const slot = publishedCheckpoint.checkpoint.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.
+            // Conflict detection joins on block number only — same block number at a different slot is still a conflict.
+            for (const checkpointBlock of checkpointBlocks){
+                const blockNumber = checkpointBlock.number;
+                const existingBlock = uncheckpointedLocalBlocks.find((b)=>b.header.getBlockNumber() === blockNumber);
+                const blockInfos = {
+                    existingBlock: existingBlock?.header.toInspect(),
+                    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.info(`Conflict detected at block ${blockNumber} between checkpointed and local block`, blockInfos);
+                    const prunedBlocks = await this.removeBlocksAfter(BlockNumber(blockNumber - 1));
+                    await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
+                    return {
+                        prunedBlocks,
+                        lastAlreadyInsertedBlockNumber
+                    };
+                }
+            }
+            // If the sequencer locally proposed extra blocks within this checkpoint's slot (e.g. local has
+            // [N, N+1] but L1 confirmed just [N]), prune the extras. Scoped to the checkpoint's slot so we
+            // do not throw away speculative blocks at later slots that belong to a pending proposed checkpoint.
+            const lastCheckpointBlockNumber = checkpointBlocks.at(-1).number;
+            const localBlocksInSlot = uncheckpointedLocalBlocks.filter((b)=>b.header.getSlot() === slot);
+            const lastLocalBlockNumber = localBlocksInSlot.at(-1)?.header.getBlockNumber();
+            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);
+                await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
+                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.stores.db.transactionAsync(async ()=>{
+            // Verify we're only removing uncheckpointed blocks
+            const lastCheckpointedBlockNumber = await this.stores.blocks.getCheckpointedL2BlockNumber();
+            if (blockNumber < lastCheckpointedBlockNumber) {
+                throw new Error(`Cannot remove blocks after ${blockNumber} because checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`);
+            }
+            const prunedBlocks = await this.removeBlocksAfter(blockNumber);
+            await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
+            return prunedBlocks;
+        });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    /**
+   * Removes all blocks without a proposed checkpoint 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 (proposed or not).
+   * This differs from `removeUncheckpointedBlocksAfter` in that it also checks proposed checkpoints.
+   *
+   * @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 removeBlocksWithoutProposedCheckpointAfter(blockNumber) {
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            // Verify we're only removing uncheckpointed blocks
+            const lastCheckpointedBlockNumber = await this.stores.blocks.getProposedCheckpointL2BlockNumber();
+            if (blockNumber < lastCheckpointedBlockNumber) {
+                throw new Error(`Cannot remove blocks after ${blockNumber} because proposed checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`);
+            }
+            return await this.removeBlocksAfter(blockNumber);
+        });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    /**
+   * Evicts pending proposed checkpoints that referenced any of the just-pruned blocks. Pruned
+   * blocks invalidate all proposed checkpoints from the lowest pruned block's checkpoint number
+   * onwards: those checkpoints either reference the pruned blocks directly or chain off them.
+   */ async evictProposedCheckpointsForPrunedBlocks(prunedBlocks) {
+        if (prunedBlocks.length === 0) {
+            return;
+        }
+        const fromCheckpointNumber = prunedBlocks[0].checkpointNumber;
+        await this.stores.blocks.evictProposedCheckpointsFrom(fromCheckpointNumber);
+    }
+    /**
+   * 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.stores.blocks.removeBlocksAfter(blockNumber);
+        // Clean up contract data and logs for the removed blocks
+        await Promise.all([
+            this.stores.logs.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) {
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            const { blocksRemoved = [] } = await this.stores.blocks.removeCheckpointsAfter(checkpointNumber);
+            const opResults = await Promise.all([
+                // Prune rolls back to the last proven block, which is by definition valid
+                this.stores.blocks.setPendingChainValidationStatus({
+                    valid: true
+                }),
+                // Remove contract data for all blocks being removed
+                ...blocksRemoved.map((block)=>this.removeContractDataFromDb(block)),
+                this.stores.logs.deleteLogs(blocksRemoved)
+            ]);
+            return opResults.every(Boolean);
+        });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    /**
+   * 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.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.setProvenCheckpointNumber(checkpointNumber);
+        });
+        await this.l2TipsCache?.refresh();
+    }
+    /**
+   * Updates the finalized checkpoint number and refreshes the L2 tips cache.
+   * @param checkpointNumber - The checkpoint number to set as finalized.
+   */ async setFinalizedCheckpointNumber(checkpointNumber) {
+        await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.setFinalizedCheckpointNumber(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)
+        ])).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));
+        if (operation == 1) {
+            const contractClasses = contractClassPublishedEvents.map((e)=>e.toContractClassPublic());
+            if (contractClasses.length > 0) {
+                contractClasses.forEach((c)=>this.log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
+                return await this.stores.contractClasses.deleteContractClasses(contractClasses, blockNum);
+            }
+            return true;
+        }
+        // Compute bytecode commitments and validate class IDs in a single pass.
+        const contractClasses = [];
+        for (const event of contractClassPublishedEvents){
+            const contractClass = await event.toContractClassPublicWithBytecodeCommitment();
+            const computedClassId = await computeContractClassId({
+                artifactHash: contractClass.artifactHash,
+                privateFunctionsRoot: contractClass.privateFunctionsRoot,
+                publicBytecodeCommitment: contractClass.publicBytecodeCommitment
+            });
+            if (!computedClassId.equals(contractClass.id)) {
+                this.log.warn(`Skipping contract class with mismatched id at block ${blockNum}. Claimed ${contractClass.id}, computed ${computedClassId}`, {
+                    blockNum,
+                    contractClassId: event.contractClassId.toString()
+                });
+                continue;
+            }
+            contractClasses.push(contractClass);
+        }
+        if (contractClasses.length > 0) {
+            contractClasses.forEach((c)=>this.log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
+            return await this.stores.contractClasses.addContractClasses(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 allInstances = allLogs.filter((log)=>ContractInstancePublishedEvent.isContractInstancePublishedEvent(log)).map((log)=>ContractInstancePublishedEvent.fromLog(log)).map((e)=>e.toContractInstance());
+        // Verify that each instance's address matches the one derived from its fields if we're adding
+        const contractInstances = operation === 1 ? allInstances : await filterAsync(allInstances, async (instance)=>{
+            const computedAddress = await computeContractAddressFromInstance(instance);
+            if (!computedAddress.equals(instance.address)) {
+                this.log.warn(`Found contract instance with mismatched address at block ${blockNum}. Claimed ${instance.address} but computed ${computedAddress}.`, {
+                    instanceAddress: instance.address.toString(),
+                    computedAddress: computedAddress.toString(),
+                    blockNum
+                });
+                return false;
+            }
+            return true;
+        });
+        if (contractInstances.length > 0) {
+            contractInstances.forEach((c)=>this.log.verbose(`${Operation[operation]} contract instance at ${c.address.toString()}`));
+            if (operation == 0) {
+                return await this.stores.contractInstances.addContractInstances(contractInstances, blockNum);
+            } else if (operation == 1) {
+                return await this.stores.contractInstances.deleteContractInstances(contractInstances);
+            }
+        }
+        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.stores.contractInstances.addContractInstanceUpdates(contractUpdates, timestamp);
+            } else if (operation == 1) {
+                return await this.stores.contractInstances.deleteContractInstanceUpdates(contractUpdates, timestamp);
+            }
+        }
+        return true;
+    }
+}

package/dest/modules/instrumentation.d.ts

@@ -0,0 +1,63 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { CheckpointData } from '@aztec/stdlib/checkpoint';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+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 syncDurationPerCheckpoint;
+    private syncBlockCount;
+    private manaPerBlock;
+    private txsPerBlock;
+    private syncDurationPerMessage;
+    private syncMessageCount;
+    private blockProposalTxTargetCount;
+    private checkpointL1InclusionDelay;
+    private checkpointPromotedCount;
+    private log;
+    private constructor();
+    static new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback): Promise<ArchiverInstrumentation>;
+    isEnabled(): boolean;
+    processNewProposedBlock(syncTimePerBlock: number, block: L2Block): void;
+    processNewCheckpointedBlocks(syncTimePerCheckpoint: number, blocks: L2Block[]): void;
+    processNewMessages(count: number, syncPerMessageMs: number): void;
+    processPrune(duration: number): void;
+    /**
+     * Records a pending-chain reorg, where the archiver dropped proposed blocks (and world-state follows by pruning). The
+     * type distinguishes the cause: 'uncheckpointed' (slot ended without a checkpoint), 'l1_conflict' (proposed blocks
+     * conflicting with an L1 checkpoint), 'orphan' (no matching proposed checkpoint arrived before the deadline), or
+     * 'l1_mismatch' (the local checkpointed tip diverged from L1 — an L1 reorg or a pruned/missed-proof checkpoint — so
+     * already-checkpointed blocks were rewound).
+     */
+    recordPrune(pruneType: 'uncheckpointed' | 'l1_conflict' | 'orphan' | 'l1_mismatch'): void;
+    updateLastProvenCheckpoint(checkpoint: CheckpointData): void;
+    processProofsVerified(logs: {
+        proverId: string;
+        l2BlockNumber: bigint;
+        delay: bigint;
+    }[]): void;
+    updateL1BlockHeight(blockNumber: bigint): void;
+    recordBlockProposalTxTarget(target: string, usedTrace: boolean): void;
+    /** Records a checkpoint promoted from proposed (blob fetch skipped). */
+    processCheckpointPromoted(): void;
+    /**
+     * Records L1 inclusion timing for a checkpoint observed on L1 (seconds into the L2 slot).
+     */
+    processCheckpointL1Timing(data: {
+        slotNumber: SlotNumber;
+        l1Timestamp: bigint;
+        l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>;
+    }): void;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/modules/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAKL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uBAAuB;IA+BhC,OAAO,CAAC,SAAS;IA9BnB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,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,yBAAyB,CAAY;IAC7C,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,0BAA0B,CAAY;IAC9C,OAAO,CAAC,uBAAuB,CAAgB;IAE/C,OAAO,CAAC,GAAG,CAA4C;IAEvD,OAAO,eA4DN;IAED,OAAoB,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,iBAAiB,oCAMhF;IAEM,SAAS,IAAI,OAAO,CAE1B;IAEM,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,QAStE;IAEM,4BAA4B,CAAC,qBAAqB,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QASnF;IAEM,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,QAMhE;IAEM,YAAY,CAAC,QAAQ,EAAE,MAAM,QAGnC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,SAAS,EAAE,gBAAgB,GAAG,aAAa,GAAG,QAAQ,GAAG,aAAa,QAExF;IAEM,0BAA0B,CAAC,UAAU,EAAE,cAAc,QAI3D;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;IAED,wEAAwE;IACjE,yBAAyB,SAE/B;IAED;;OAEG;IACI,yBAAyB,CAAC,IAAI,EAAE;QACrC,UAAU,EAAE,UAAU,CAAC;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,CAAC;KACxE,GAAG,IAAI,CAIP;CACF"}

package/dest/modules/instrumentation.js

@@ -0,0 +1,166 @@
+import { createLogger } from '@aztec/foundation/log';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { Attributes, LmdbMetrics, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
+export class ArchiverInstrumentation {
+    telemetry;
+    tracer;
+    blockHeight;
+    checkpointHeight;
+    txCount;
+    l1BlockHeight;
+    proofsSubmittedDelay;
+    proofsSubmittedCount;
+    dbMetrics;
+    pruneDuration;
+    pruneCount;
+    syncDurationPerBlock;
+    syncDurationPerCheckpoint;
+    syncBlockCount;
+    manaPerBlock;
+    txsPerBlock;
+    syncDurationPerMessage;
+    syncMessageCount;
+    blockProposalTxTargetCount;
+    checkpointL1InclusionDelay;
+    checkpointPromotedCount;
+    log;
+    constructor(telemetry, lmdbStats){
+        this.telemetry = telemetry;
+        this.log = createLogger('archiver:instrumentation');
+        this.tracer = telemetry.getTracer('Archiver');
+        const meter = telemetry.getMeter('Archiver');
+        this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT);
+        this.checkpointHeight = meter.createGauge(Metrics.ARCHIVER_CHECKPOINT_HEIGHT);
+        this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT);
+        this.txCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_TOTAL_TXS);
+        this.proofsSubmittedCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_ROLLUP_PROOF_COUNT, {
+            [Attributes.PROOF_TIMED_OUT]: [
+                true,
+                false
+            ]
+        });
+        this.proofsSubmittedDelay = meter.createHistogram(Metrics.ARCHIVER_ROLLUP_PROOF_DELAY);
+        this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK);
+        this.syncDurationPerCheckpoint = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_CHECKPOINT);
+        this.syncBlockCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_SYNC_BLOCK_COUNT);
+        this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK);
+        this.txsPerBlock = meter.createHistogram(Metrics.ARCHIVER_TXS_PER_BLOCK);
+        this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE);
+        this.syncMessageCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_SYNC_MESSAGE_COUNT);
+        this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION);
+        this.pruneCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_PRUNE_COUNT, {
+            [Attributes.PRUNE_TYPE]: [
+                'unproven',
+                'uncheckpointed',
+                'l1_conflict',
+                'orphan',
+                'l1_mismatch'
+            ]
+        });
+        this.blockProposalTxTargetCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT, {
+            [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: [
+                true,
+                false
+            ]
+        });
+        this.checkpointL1InclusionDelay = meter.createHistogram(Metrics.ARCHIVER_CHECKPOINT_L1_INCLUSION_DELAY);
+        this.checkpointPromotedCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_CHECKPOINT_PROMOTED_COUNT);
+        this.dbMetrics = new LmdbMetrics(meter, {
+            [Attributes.DB_DATA_TYPE]: 'archiver'
+        }, lmdbStats);
+    }
+    static async new(telemetry, lmdbStats) {
+        const instance = new ArchiverInstrumentation(telemetry, lmdbStats);
+        await instance.telemetry.flush();
+        return instance;
+    }
+    isEnabled() {
+        return this.telemetry.isEnabled();
+    }
+    processNewProposedBlock(syncTimePerBlock, block) {
+        const attrs = {
+            [Attributes.STATUS]: 'proposed'
+        };
+        this.blockHeight.record(block.number, attrs);
+        this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
+        // Per block metrics
+        this.txCount.add(block.body.txEffects.length);
+        this.txsPerBlock.record(block.body.txEffects.length);
+        this.manaPerBlock.record(block.header.totalManaUsed.toNumber() / 1e6);
+    }
+    processNewCheckpointedBlocks(syncTimePerCheckpoint, blocks) {
+        if (blocks.length === 0) {
+            return;
+        }
+        this.syncDurationPerCheckpoint.record(Math.ceil(syncTimePerCheckpoint));
+        this.blockHeight.record(Math.max(...blocks.map((b)=>b.number)), {
+            [Attributes.STATUS]: 'checkpointed'
+        });
+        this.checkpointHeight.record(Math.max(...blocks.map((b)=>b.checkpointNumber)));
+        this.syncBlockCount.add(blocks.length);
+    }
+    processNewMessages(count, syncPerMessageMs) {
+        if (count === 0) {
+            return;
+        }
+        this.syncMessageCount.add(count);
+        this.syncDurationPerMessage.record(Math.ceil(syncPerMessageMs));
+    }
+    processPrune(duration) {
+        this.pruneCount.add(1, {
+            [Attributes.PRUNE_TYPE]: 'unproven'
+        });
+        this.pruneDuration.record(Math.ceil(duration));
+    }
+    /**
+   * Records a pending-chain reorg, where the archiver dropped proposed blocks (and world-state follows by pruning). The
+   * type distinguishes the cause: 'uncheckpointed' (slot ended without a checkpoint), 'l1_conflict' (proposed blocks
+   * conflicting with an L1 checkpoint), 'orphan' (no matching proposed checkpoint arrived before the deadline), or
+   * 'l1_mismatch' (the local checkpointed tip diverged from L1 — an L1 reorg or a pruned/missed-proof checkpoint — so
+   * already-checkpointed blocks were rewound).
+   */ recordPrune(pruneType) {
+        this.pruneCount.add(1, {
+            [Attributes.PRUNE_TYPE]: pruneType
+        });
+    }
+    updateLastProvenCheckpoint(checkpoint) {
+        const lastBlockNumberInCheckpoint = checkpoint.startBlock + checkpoint.blockCount - 1;
+        this.blockHeight.record(lastBlockNumberInCheckpoint, {
+            [Attributes.STATUS]: 'proven'
+        });
+        this.checkpointHeight.record(checkpoint.checkpointNumber, {
+            [Attributes.STATUS]: 'proven'
+        });
+    }
+    processProofsVerified(logs) {
+        for (const log of logs){
+            this.log.debug('Recording proof verified event', log);
+            this.proofsSubmittedCount.add(1, {
+                [Attributes.ROLLUP_PROVER_ID]: log.proverId,
+                [Attributes.PROOF_TIMED_OUT]: log.delay > 20n * 60n * 1000n
+            });
+            this.proofsSubmittedDelay.record(Math.ceil(Number(log.delay)), {
+                [Attributes.ROLLUP_PROVER_ID]: log.proverId
+            });
+        }
+    }
+    updateL1BlockHeight(blockNumber) {
+        this.l1BlockHeight.record(Number(blockNumber));
+    }
+    recordBlockProposalTxTarget(target, usedTrace) {
+        this.blockProposalTxTargetCount.add(1, {
+            [Attributes.L1_BLOCK_PROPOSAL_TX_TARGET]: target.toLowerCase(),
+            [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: usedTrace
+        });
+    }
+    /** Records a checkpoint promoted from proposed (blob fetch skipped). */ processCheckpointPromoted() {
+        this.checkpointPromotedCount.add(1);
+    }
+    /**
+   * Records L1 inclusion timing for a checkpoint observed on L1 (seconds into the L2 slot).
+   */ processCheckpointL1Timing(data) {
+        const slotStartTs = getTimestampForSlot(data.slotNumber, data.l1Constants);
+        const inclusionDelaySeconds = Number(data.l1Timestamp - slotStartTs);
+        this.checkpointL1InclusionDelay.record(inclusionDelaySeconds);
+    }
+}