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

package/dest/archiver/archiver_store_updates.d.ts

@@ -0,0 +1,38 @@
+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 './kv_archiver_store/kv_archiver_store.js';
+/**
+ * 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 store - The archiver data store.
+ * @param blocks - The L2 blocks to add.
+ * @param pendingChainValidationStatus - Optional validation status to set.
+ * @returns True if the operation is successful.
+ */
+export declare function addBlocksWithContractData(store: KVArchiverDataStore, 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 store - The archiver data store.
+ * @param checkpoints - The published checkpoints to add.
+ * @param pendingChainValidationStatus - Optional validation status to set.
+ * @returns True if the operation is successful.
+ */
+export declare function addCheckpointsWithContractData(store: KVArchiverDataStore, 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 store - The archiver data store.
+ * @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.
+ */
+export declare function unwindCheckpointsWithContractData(store: KVArchiverDataStore, from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJjaGl2ZXJfc3RvcmVfdXBkYXRlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FyY2hpdmVyL2FyY2hpdmVyX3N0b3JlX3VwZGF0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQWUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQVlyRixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBYXBFLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFVcEY7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQWdCLHlCQUF5QixDQUN2QyxLQUFLLEVBQUUsbUJBQW1CLEVBQzFCLE1BQU0sRUFBRSxVQUFVLEVBQUUsRUFDcEIsNEJBQTRCLENBQUMsRUFBRSx3QkFBd0IsR0FDdEQsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWVsQjtBQUVEOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FDNUMsS0FBSyxFQUFFLG1CQUFtQixFQUMxQixXQUFXLEVBQUUsbUJBQW1CLEVBQUUsRUFDbEMsNEJBQTRCLENBQUMsRUFBRSx3QkFBd0IsR0FDdEQsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWdCbEI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsaUNBQWlDLENBQ3JELEtBQUssRUFBRSxtQkFBbUIsRUFDMUIsSUFBSSxFQUFFLGdCQUFnQixFQUN0QixtQkFBbUIsRUFBRSxNQUFNLEdBQzFCLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0E0Q2xCIn0=

package/dest/archiver/archiver_store_updates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archiver_store_updates.d.ts","sourceRoot":"","sources":["../../src/archiver/archiver_store_updates.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,0CAA0C,CAAC;AAUpF;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,UAAU,EAAE,EACpB,4BAA4B,CAAC,EAAE,wBAAwB,GACtD,OAAO,CAAC,OAAO,CAAC,CAelB;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,mBAAmB,EAC1B,WAAW,EAAE,mBAAmB,EAAE,EAClC,4BAA4B,CAAC,EAAE,wBAAwB,GACtD,OAAO,CAAC,OAAO,CAAC,CAgBlB;AAED;;;;;;;;;GASG;AACH,wBAAsB,iCAAiC,CACrD,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,gBAAgB,EACtB,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC,CA4ClB"}

package/dest/archiver/archiver_store_updates.js

@@ -0,0 +1,212 @@
+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';
+const log = createLogger('archiver:store-updates');
+/** Operation type for contract data updates. */ var Operation = /*#__PURE__*/ function(Operation) {
+    Operation[Operation["Store"] = 0] = "Store";
+    Operation[Operation["Delete"] = 1] = "Delete";
+    return Operation;
+}(Operation || {});
+/**
+ * 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 store - The archiver data store.
+ * @param blocks - The L2 blocks to add.
+ * @param pendingChainValidationStatus - Optional validation status to set.
+ * @returns True if the operation is successful.
+ */ export function addBlocksWithContractData(store, blocks, pendingChainValidationStatus) {
+    return store.transactionAsync(async ()=>{
+        await store.addBlocks(blocks);
+        const opResults = await Promise.all([
+            // Update the pending chain validation status if provided
+            pendingChainValidationStatus && store.setPendingChainValidationStatus(pendingChainValidationStatus),
+            // Add any logs emitted during the retrieved blocks
+            store.addLogs(blocks),
+            // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
+            ...blocks.map((block)=>addBlockDataToDB(store, 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 store - The archiver data store.
+ * @param checkpoints - The published checkpoints to add.
+ * @param pendingChainValidationStatus - Optional validation status to set.
+ * @returns True if the operation is successful.
+ */ export function addCheckpointsWithContractData(store, checkpoints, pendingChainValidationStatus) {
+    return store.transactionAsync(async ()=>{
+        await 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 && store.setPendingChainValidationStatus(pendingChainValidationStatus),
+            // Add any logs emitted during the retrieved blocks
+            store.addLogs(allBlocks),
+            // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
+            ...allBlocks.map((block)=>addBlockDataToDB(store, 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 store - The archiver data store.
+ * @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.
+ */ export async function unwindCheckpointsWithContractData(store, from, checkpointsToUnwind) {
+    if (checkpointsToUnwind <= 0) {
+        throw new Error(`Cannot unwind ${checkpointsToUnwind} blocks`);
+    }
+    const last = await 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 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
+        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([
+                updatePublishedContractClasses(store, contractClassLogs, block.number, 1),
+                updateDeployedContractInstances(store, privateLogs, block.number, 1),
+                updateUpdatedContractInstances(store, publicLogs, block.header.globalVariables.timestamp, 1)
+            ])).every(Boolean);
+        }),
+        store.deleteLogs(blocks),
+        store.unwindCheckpoints(from, checkpointsToUnwind)
+    ]);
+    return opResults.every(Boolean);
+}
+/**
+ * Extracts and stores contract data from a single block.
+ */ async function addBlockDataToDB(store, 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([
+        updatePublishedContractClasses(store, contractClassLogs, block.number, 0),
+        updateDeployedContractInstances(store, privateLogs, block.number, 0),
+        updateUpdatedContractInstances(store, publicLogs, block.header.globalVariables.timestamp, 0),
+        storeBroadcastedIndividualFunctions(store, contractClassLogs, block.number)
+    ])).every(Boolean);
+}
+/**
+ * Extracts and stores contract classes out of ContractClassPublished events emitted by the class registry contract.
+ */ async function updatePublishedContractClasses(store, 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)=>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 store.addContractClasses(contractClasses, commitments, blockNum);
+        } else if (operation == 1) {
+            return await store.deleteContractClasses(contractClasses, blockNum);
+        }
+    }
+    return true;
+}
+/**
+ * Extracts and stores contract instances out of ContractInstancePublished events emitted by the canonical deployer contract.
+ */ async function updateDeployedContractInstances(store, 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)=>log.verbose(`${Operation[operation]} contract instance at ${c.address.toString()}`));
+        if (operation == 0) {
+            return await store.addContractInstances(contractInstances, blockNum);
+        } else if (operation == 1) {
+            return await store.deleteContractInstances(contractInstances, blockNum);
+        }
+    }
+    return true;
+}
+/**
+ * Extracts and stores contract instance updates out of ContractInstanceUpdated events.
+ */ async function updateUpdatedContractInstances(store, 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)=>log.verbose(`${Operation[operation]} contract instance update at ${c.address.toString()}`));
+        if (operation == 0) {
+            return await store.addContractInstanceUpdates(contractUpdates, timestamp);
+        } else if (operation == 1) {
+            return await 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 function storeBroadcastedIndividualFunctions(store, 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 store.getContractClass(contractClassId);
+        if (!contractClass) {
+            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) {
+            log.warn(`Skipping ${allFns.length - validFnCount} invalid functions`);
+        }
+        // Store the functions in the contract class in a single operation
+        if (validFnCount > 0) {
+            log.verbose(`Storing ${validFnCount} functions for contract class ${contractClassId.toString()}`);
+        }
+        return await store.addFunctions(contractClassId, validPrivateFns, validUtilityFns);
+    }
+    return true;
+}

package/dest/archiver/index.d.ts

@@ -1,7 +1,8 @@
 export * from './archiver.js';
+export * from './archive_source_base.js';
+export * from './archiver_store_updates.js';
 export * from './config.js';
 export { type L1PublishedData } from './structs/published.js';
-export type { ArchiverDataStore } from './archiver_store.js';
 export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './kv_archiver_store/kv_archiver_store.js';
 export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcmNoaXZlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM5RCxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQztBQUNwRyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnREFBZ0QsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcmNoaXZlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxhQUFhLENBQUM7QUFDNUIsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDOUQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLG1CQUFtQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDcEcsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0RBQWdELENBQUMifQ==

package/dest/archiver/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/archiver/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpG,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/archiver/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpG,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC"}

package/dest/archiver/index.js

@@ -1,4 +1,6 @@
 export * from './archiver.js';
+export * from './archive_source_base.js';
+export * from './archiver_store_updates.js';
 export * from './config.js';
 export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './kv_archiver_store/kv_archiver_store.js';
 export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';

package/dest/archiver/kv_archiver_store/block_store.d.ts

@@ -18,7 +18,7 @@ export type CheckpointData = {
     attestations: Buffer[];
 };
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based block storage for the archiver.
  */
 export declare class BlockStore {
     #private;

package/dest/archiver/kv_archiver_store/block_store.js

@@ -13,7 +13,7 @@ import { BlockHeader, TxHash, TxReceipt, deserializeIndexedTxEffect, serializeIn
 import { BlockArchiveNotConsistentError, BlockIndexNotSequentialError, BlockNotFoundError, BlockNumberNotSequentialError, CheckpointNotFoundError, CheckpointNumberNotConsistentError, CheckpointNumberNotSequentialError, InitialBlockNumberNotSequentialError, InitialCheckpointNumberNotSequentialError } from '../errors.js';
 export { TxReceipt } from '@aztec/stdlib/tx';
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based block storage for the archiver.
  */ export class BlockStore {
     db;
     /** Map block number to block data */ #blocks;

package/dest/archiver/kv_archiver_store/contract_class_store.d.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { ContractClassPublic, ExecutablePrivateFunctionWithMembershipProof, UtilityFunctionWithMembershipProof } from '@aztec/stdlib/contract';
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based contract class storage for the archiver.
  */
 export declare class ContractClassStore {
     #private;

package/dest/archiver/kv_archiver_store/contract_class_store.js

@@ -4,7 +4,7 @@ import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/s
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import { Vector } from '@aztec/stdlib/types';
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based contract class storage for the archiver.
  */ export class ContractClassStore {
     db;
     #contractClasses;

package/dest/archiver/kv_archiver_store/contract_instance_store.d.ts

@@ -5,7 +5,7 @@ import { type ContractInstanceUpdateWithAddress, type ContractInstanceWithAddres
 import type { UInt64 } from '@aztec/stdlib/types';
 type ContractInstanceUpdateKey = [string, string] | [string, string, number];
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based contract instance storage for the archiver.
  */
 export declare class ContractInstanceStore {
     #private;

package/dest/archiver/kv_archiver_store/contract_instance_store.js

@@ -1,6 +1,6 @@
 import { SerializableContractInstance, SerializableContractInstanceUpdate } from '@aztec/stdlib/contract';
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based contract instance storage for the archiver.
  */ export class ContractInstanceStore {
     db;
     #contractInstances;