@aztec/archiver 0.0.0-test.0

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

@@ -0,0 +1,87 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type InBlock, L2Block } from '@aztec/stdlib/block';
+import { BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import type { L1Published } from '../structs/published.js';
+export { type TxEffect, type TxHash, TxReceipt } from '@aztec/stdlib/tx';
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export declare class BlockStore {
+    #private;
+    private db;
+    constructor(db: AztecAsyncKVStore);
+    /**
+     * Append new blocks to the store's list.
+     * @param blocks - The L2 blocks to be added to the store.
+     * @returns True if the operation is successful.
+     */
+    addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean>;
+    /**
+     * Unwinds blocks from the database
+     * @param from -  The tip of the chain, passed for verification purposes,
+     *                ensuring that we don't end up deleting something we did not intend
+     * @param blocksToUnwind - The number of blocks we are to unwind
+     * @returns True if the operation is successful
+     */
+    unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean>;
+    /**
+     * Gets up to `limit` amount of L2 blocks starting from `from`.
+     * @param start - Number of the first block to return (inclusive).
+     * @param limit - The number of blocks to return.
+     * @returns The requested L2 blocks
+     */
+    getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>>;
+    /**
+     * Gets an L2 block.
+     * @param blockNumber - The number of the block to return.
+     * @returns The requested L2 block.
+     */
+    getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined>;
+    /**
+     * Gets the headers for a sequence of L2 blocks.
+     * @param start - Number of the first block to return (inclusive).
+     * @param limit - The number of blocks to return.
+     * @returns The requested L2 block headers
+     */
+    getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader>;
+    private getBlockFromBlockStorage;
+    /**
+     * Gets a tx effect.
+     * @param txHash - The txHash of the tx corresponding to the tx effect.
+     * @returns The requested tx effect (or undefined if not found).
+     */
+    getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined>;
+    /**
+     * Gets a receipt of a settled tx.
+     * @param txHash - The hash of a tx we try to get the receipt for.
+     * @returns The requested tx receipt (or undefined if not found).
+     */
+    getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
+    /**
+     * Looks up which block included the requested tx effect.
+     * @param txHash - The txHash of the tx.
+     * @returns The block number and index of the tx.
+     */
+    getTxLocation(txHash: TxHash): Promise<[blockNumber: number, txIndex: number] | undefined>;
+    /**
+     * Looks up which block deployed a particular contract.
+     * @param contractAddress - The address of the contract to look up.
+     * @returns The block number and index of the contract.
+     */
+    getContractLocation(contractAddress: AztecAddress): Promise<[blockNumber: number, index: number] | undefined>;
+    /**
+     * Gets the number of the latest L2 block processed.
+     * @returns The number of the latest L2 block processed.
+     */
+    getSynchedL2BlockNumber(): Promise<number>;
+    /**
+     * Gets the most recent L1 block processed.
+     * @returns The L1 block that published the latest L2 block
+     */
+    getSynchedL1BlockNumber(): Promise<bigint | undefined>;
+    setSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<boolean>;
+    getProvenL2BlockNumber(): Promise<number>;
+    setProvenL2BlockNumber(blockNumber: number): Promise<boolean>;
+}
+//# sourceMappingURL=block_store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/block_store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAA6C,MAAM,iBAAiB,CAAC;AACpG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAQ,KAAK,OAAO,EAAE,OAAO,EAAe,MAAM,qBAAqB,CAAC;AAE/E,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,yBAAyB,CAAC;AAE5E,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAUzE;;GAEG;AACH,qBAAa,UAAU;;IAwBT,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAUzC;;;;OAIG;IACG,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BjE;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IA0BvD;;;;;OAKG;IACI,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAO3F;;;;OAIG;IACG,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;IAS9E;;;;;OAKG;IACI,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAC,WAAW,CAAC;YAM1E,wBAAwB;IAgBtC;;;;OAIG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IAkBzE;;;;OAIG;IACG,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAmBzE;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAI1F;;;;OAIG;IACH,mBAAmB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAI7G;;;OAGG;IACG,uBAAuB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKhD;;;OAGG;IACH,uBAAuB,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAItD,uBAAuB,CAAC,aAAa,EAAE,MAAM;IAIvC,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI/C,sBAAsB,CAAC,WAAW,EAAE,MAAM;CAe3C"}

package/dest/archiver/kv_archiver_store/block_store.js

@@ -0,0 +1,217 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { toArray } from '@aztec/foundation/iterable';
+import { createLogger } from '@aztec/foundation/log';
+import { Body, L2Block, L2BlockHash } from '@aztec/stdlib/block';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { BlockHeader, TxReceipt } from '@aztec/stdlib/tx';
+export { TxReceipt } from '@aztec/stdlib/tx';
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */ export class BlockStore {
+    db;
+    /** Map block number to block data */ #blocks;
+    /** Map block hash to block body */ #blockBodies;
+    /** Stores L1 block number in which the last processed L2 block was included */ #lastSynchedL1Block;
+    /** Stores l2 block number of the last proven block */ #lastProvenL2Block;
+    /** Stores l2 epoch number of the last proven epoch */ #lastProvenL2Epoch;
+    /** Index mapping transaction hash (as a string) to its location in a block */ #txIndex;
+    /** Index mapping a contract's address (as a string) to its location in a block */ #contractIndex;
+    #log;
+    constructor(db){
+        this.db = db;
+        this.#log = createLogger('archiver:block_store');
+        this.#blocks = db.openMap('archiver_blocks');
+        this.#blockBodies = db.openMap('archiver_block_bodies');
+        this.#txIndex = db.openMap('archiver_tx_index');
+        this.#contractIndex = db.openMap('archiver_contract_index');
+        this.#lastSynchedL1Block = db.openSingleton('archiver_last_synched_l1_block');
+        this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
+        this.#lastProvenL2Epoch = db.openSingleton('archiver_last_proven_l2_epoch');
+    }
+    /**
+   * Append new blocks to the store's list.
+   * @param blocks - The L2 blocks to be added to the store.
+   * @returns True if the operation is successful.
+   */ async addBlocks(blocks) {
+        if (blocks.length === 0) {
+            return true;
+        }
+        return await this.db.transactionAsync(async ()=>{
+            for (const block of blocks){
+                await this.#blocks.set(block.data.number, {
+                    header: block.data.header.toBuffer(),
+                    archive: block.data.archive.toBuffer(),
+                    l1: block.l1
+                });
+                for(let i = 0; i < block.data.body.txEffects.length; i++){
+                    const txEffect = block.data.body.txEffects[i];
+                    await this.#txIndex.set(txEffect.txHash.toString(), [
+                        block.data.number,
+                        i
+                    ]);
+                }
+                await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
+            }
+            await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
+            return true;
+        });
+    }
+    /**
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
+   */ async unwindBlocks(from, blocksToUnwind) {
+        return await this.db.transactionAsync(async ()=>{
+            const last = await this.getSynchedL2BlockNumber();
+            if (from !== last) {
+                throw new Error(`Can only unwind blocks from the tip (requested ${from} but current tip is ${last})`);
+            }
+            for(let i = 0; i < blocksToUnwind; i++){
+                const blockNumber = from - i;
+                const block = await this.getBlock(blockNumber);
+                if (block === undefined) {
+                    this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
+                    continue;
+                }
+                await this.#blocks.delete(block.data.number);
+                await Promise.all(block.data.body.txEffects.map((tx)=>this.#txIndex.delete(tx.txHash.toString())));
+                const blockHash = (await block.data.hash()).toString();
+                await this.#blockBodies.delete(blockHash);
+                this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
+            }
+            return true;
+        });
+    }
+    /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 blocks
+   */ async *getBlocks(start, limit) {
+        for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))){
+            const block = await this.getBlockFromBlockStorage(blockStorage);
+            yield block;
+        }
+    }
+    /**
+   * Gets an L2 block.
+   * @param blockNumber - The number of the block to return.
+   * @returns The requested L2 block.
+   */ async getBlock(blockNumber) {
+        const blockStorage = await this.#blocks.getAsync(blockNumber);
+        if (!blockStorage || !blockStorage.header) {
+            return Promise.resolve(undefined);
+        }
+        return this.getBlockFromBlockStorage(blockStorage);
+    }
+    /**
+   * Gets the headers for a sequence of L2 blocks.
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 block headers
+   */ async *getBlockHeaders(start, limit) {
+        for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))){
+            yield BlockHeader.fromBuffer(blockStorage.header);
+        }
+    }
+    async getBlockFromBlockStorage(blockStorage) {
+        const header = BlockHeader.fromBuffer(blockStorage.header);
+        const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
+        const blockHash = (await header.hash()).toString();
+        const blockBodyBuffer = await this.#blockBodies.getAsync(blockHash);
+        if (blockBodyBuffer === undefined) {
+            throw new Error(`Could not retrieve body for block ${header.globalVariables.blockNumber.toNumber()} ${blockHash}`);
+        }
+        const body = Body.fromBuffer(blockBodyBuffer);
+        const l2Block = new L2Block(archive, header, body);
+        return {
+            data: l2Block,
+            l1: blockStorage.l1
+        };
+    }
+    /**
+   * Gets a tx effect.
+   * @param txHash - The txHash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect (or undefined if not found).
+   */ async getTxEffect(txHash) {
+        const [blockNumber, txIndex] = await this.getTxLocation(txHash) ?? [];
+        if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+            return undefined;
+        }
+        const block = await this.getBlock(blockNumber);
+        if (!block) {
+            return undefined;
+        }
+        return {
+            data: block.data.body.txEffects[txIndex],
+            l2BlockNumber: block.data.number,
+            l2BlockHash: (await block.data.hash()).toString()
+        };
+    }
+    /**
+   * Gets a receipt of a settled tx.
+   * @param txHash - The hash of a tx we try to get the receipt for.
+   * @returns The requested tx receipt (or undefined if not found).
+   */ async getSettledTxReceipt(txHash) {
+        const [blockNumber, txIndex] = await this.getTxLocation(txHash) ?? [];
+        if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+            return undefined;
+        }
+        const block = await this.getBlock(blockNumber);
+        const tx = block.data.body.txEffects[txIndex];
+        return new TxReceipt(txHash, TxReceipt.statusFromRevertCode(tx.revertCode), '', tx.transactionFee.toBigInt(), L2BlockHash.fromField(await block.data.hash()), block.data.number);
+    }
+    /**
+   * Looks up which block included the requested tx effect.
+   * @param txHash - The txHash of the tx.
+   * @returns The block number and index of the tx.
+   */ getTxLocation(txHash) {
+        return this.#txIndex.getAsync(txHash.toString());
+    }
+    /**
+   * Looks up which block deployed a particular contract.
+   * @param contractAddress - The address of the contract to look up.
+   * @returns The block number and index of the contract.
+   */ getContractLocation(contractAddress) {
+        return this.#contractIndex.getAsync(contractAddress.toString());
+    }
+    /**
+   * Gets the number of the latest L2 block processed.
+   * @returns The number of the latest L2 block processed.
+   */ async getSynchedL2BlockNumber() {
+        const [lastBlockNumber] = await toArray(this.#blocks.keysAsync({
+            reverse: true,
+            limit: 1
+        }));
+        return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
+    }
+    /**
+   * Gets the most recent L1 block processed.
+   * @returns The L1 block that published the latest L2 block
+   */ getSynchedL1BlockNumber() {
+        return this.#lastSynchedL1Block.getAsync();
+    }
+    setSynchedL1BlockNumber(l1BlockNumber) {
+        return this.#lastSynchedL1Block.set(l1BlockNumber);
+    }
+    async getProvenL2BlockNumber() {
+        return await this.#lastProvenL2Block.getAsync() ?? 0;
+    }
+    setProvenL2BlockNumber(blockNumber) {
+        return this.#lastProvenL2Block.set(blockNumber);
+    }
+    #computeBlockRange(start, limit) {
+        if (limit < 1) {
+            throw new Error(`Invalid limit: ${limit}`);
+        }
+        if (start < INITIAL_L2_BLOCK_NUM) {
+            throw new Error(`Invalid start: ${start}`);
+        }
+        return {
+            start,
+            limit
+        };
+    }
+}

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

@@ -0,0 +1,18 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { ContractClassPublic, ExecutablePrivateFunctionWithMembershipProof, UnconstrainedFunctionWithMembershipProof } from '@aztec/stdlib/contract';
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export declare class ContractClassStore {
+    #private;
+    private db;
+    constructor(db: AztecAsyncKVStore);
+    addContractClass(contractClass: ContractClassPublic, bytecodeCommitment: Fr, blockNumber: number): Promise<void>;
+    deleteContractClasses(contractClass: ContractClassPublic, blockNumber: number): Promise<void>;
+    getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
+    getBytecodeCommitment(id: Fr): Promise<Fr | undefined>;
+    getContractClassIds(): Promise<Fr[]>;
+    addFunctions(contractClassId: Fr, newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[], newUnconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[]): Promise<boolean>;
+}
+//# sourceMappingURL=contract_class_store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_class_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/contract_class_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AAExE,OAAO,KAAK,EACV,mBAAmB,EAEnB,4CAA4C,EAC5C,wCAAwC,EACzC,MAAM,wBAAwB,CAAC;AAGhC;;GAEG;AACH,qBAAa,kBAAkB;;IAIjB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAKnC,gBAAgB,CACpB,aAAa,EAAE,mBAAmB,EAClC,kBAAkB,EAAE,EAAE,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IAQV,qBAAqB,CAAC,aAAa,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ7F,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAKlE,qBAAqB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAKtD,mBAAmB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAIpC,YAAY,CAChB,eAAe,EAAE,EAAE,EACnB,mBAAmB,EAAE,4CAA4C,EAAE,EACnE,yBAAyB,EAAE,wCAAwC,EAAE,GACpE,OAAO,CAAC,OAAO,CAAC;CA4BpB"}

package/dest/archiver/kv_archiver_store/contract_class_store.js

@@ -0,0 +1,126 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
+import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { Vector } from '@aztec/stdlib/types';
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */ export class ContractClassStore {
+    db;
+    #contractClasses;
+    #bytecodeCommitments;
+    constructor(db){
+        this.db = db;
+        this.#contractClasses = db.openMap('archiver_contract_classes');
+        this.#bytecodeCommitments = db.openMap('archiver_bytecode_commitments');
+    }
+    async addContractClass(contractClass, bytecodeCommitment, blockNumber) {
+        await this.#contractClasses.setIfNotExists(contractClass.id.toString(), serializeContractClassPublic({
+            ...contractClass,
+            l2BlockNumber: blockNumber
+        }));
+        await this.#bytecodeCommitments.setIfNotExists(contractClass.id.toString(), bytecodeCommitment.toBuffer());
+    }
+    async deleteContractClasses(contractClass, blockNumber) {
+        const restoredContractClass = await this.#contractClasses.getAsync(contractClass.id.toString());
+        if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
+            await this.#contractClasses.delete(contractClass.id.toString());
+            await this.#bytecodeCommitments.delete(contractClass.id.toString());
+        }
+    }
+    async getContractClass(id) {
+        const contractClass = await this.#contractClasses.getAsync(id.toString());
+        return contractClass && {
+            ...deserializeContractClassPublic(contractClass),
+            id
+        };
+    }
+    async getBytecodeCommitment(id) {
+        const value = await this.#bytecodeCommitments.getAsync(id.toString());
+        return value === undefined ? undefined : Fr.fromBuffer(value);
+    }
+    async getContractClassIds() {
+        return (await toArray(this.#contractClasses.keysAsync())).map((key)=>Fr.fromHexString(key));
+    }
+    async addFunctions(contractClassId, newPrivateFunctions, newUnconstrainedFunctions) {
+        await this.db.transactionAsync(async ()=>{
+            const existingClassBuffer = await this.#contractClasses.getAsync(contractClassId.toString());
+            if (!existingClassBuffer) {
+                throw new Error(`Unknown contract class ${contractClassId} when adding private functions to store`);
+            }
+            const existingClass = deserializeContractClassPublic(existingClassBuffer);
+            const { privateFunctions: existingPrivateFns, unconstrainedFunctions: existingUnconstrainedFns } = existingClass;
+            const updatedClass = {
+                ...existingClass,
+                privateFunctions: [
+                    ...existingPrivateFns,
+                    ...newPrivateFunctions.filter((newFn)=>!existingPrivateFns.some((f)=>f.selector.equals(newFn.selector)))
+                ],
+                unconstrainedFunctions: [
+                    ...existingUnconstrainedFns,
+                    ...newUnconstrainedFunctions.filter((newFn)=>!existingUnconstrainedFns.some((f)=>f.selector.equals(newFn.selector)))
+                ]
+            };
+            await this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
+        });
+        return true;
+    }
+}
+function serializeContractClassPublic(contractClass) {
+    return serializeToBuffer(contractClass.l2BlockNumber, numToUInt8(contractClass.version), contractClass.artifactHash, contractClass.publicFunctions.length, contractClass.publicFunctions?.map((f)=>serializeToBuffer(f.selector, f.bytecode.length, f.bytecode)) ?? [], contractClass.privateFunctions.length, contractClass.privateFunctions.map(serializePrivateFunction), contractClass.unconstrainedFunctions.length, contractClass.unconstrainedFunctions.map(serializeUnconstrainedFunction), contractClass.packedBytecode.length, contractClass.packedBytecode, contractClass.privateFunctionsRoot);
+}
+function serializePrivateFunction(fn) {
+    return serializeToBuffer(fn.selector, fn.vkHash, fn.bytecode.length, fn.bytecode, fn.functionMetadataHash, fn.artifactMetadataHash, fn.unconstrainedFunctionsArtifactTreeRoot, new Vector(fn.privateFunctionTreeSiblingPath), fn.privateFunctionTreeLeafIndex, new Vector(fn.artifactTreeSiblingPath), fn.artifactTreeLeafIndex);
+}
+function serializeUnconstrainedFunction(fn) {
+    return serializeToBuffer(fn.selector, fn.bytecode.length, fn.bytecode, fn.functionMetadataHash, fn.artifactMetadataHash, fn.privateFunctionsArtifactTreeRoot, new Vector(fn.artifactTreeSiblingPath), fn.artifactTreeLeafIndex);
+}
+function deserializeContractClassPublic(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return {
+        l2BlockNumber: reader.readNumber(),
+        version: reader.readUInt8(),
+        artifactHash: reader.readObject(Fr),
+        publicFunctions: reader.readVector({
+            fromBuffer: (reader)=>({
+                    selector: reader.readObject(FunctionSelector),
+                    bytecode: reader.readBuffer()
+                })
+        }),
+        privateFunctions: reader.readVector({
+            fromBuffer: deserializePrivateFunction
+        }),
+        unconstrainedFunctions: reader.readVector({
+            fromBuffer: deserializeUnconstrainedFunction
+        }),
+        packedBytecode: reader.readBuffer(),
+        privateFunctionsRoot: reader.readObject(Fr)
+    };
+}
+function deserializePrivateFunction(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return {
+        selector: reader.readObject(FunctionSelector),
+        vkHash: reader.readObject(Fr),
+        bytecode: reader.readBuffer(),
+        functionMetadataHash: reader.readObject(Fr),
+        artifactMetadataHash: reader.readObject(Fr),
+        unconstrainedFunctionsArtifactTreeRoot: reader.readObject(Fr),
+        privateFunctionTreeSiblingPath: reader.readVector(Fr),
+        privateFunctionTreeLeafIndex: reader.readNumber(),
+        artifactTreeSiblingPath: reader.readVector(Fr),
+        artifactTreeLeafIndex: reader.readNumber()
+    };
+}
+function deserializeUnconstrainedFunction(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return {
+        selector: reader.readObject(FunctionSelector),
+        bytecode: reader.readBuffer(),
+        functionMetadataHash: reader.readObject(Fr),
+        artifactMetadataHash: reader.readObject(Fr),
+        privateFunctionsArtifactTreeRoot: reader.readObject(Fr),
+        artifactTreeSiblingPath: reader.readVector(Fr),
+        artifactTreeLeafIndex: reader.readNumber()
+    };
+}

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

@@ -0,0 +1,21 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractInstanceUpdateWithAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+type ContractInstanceUpdateKey = [string, number] | [string, number, number];
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export declare class ContractInstanceStore {
+    #private;
+    constructor(db: AztecAsyncKVStore);
+    addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void>;
+    deleteContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void>;
+    getUpdateKey(contractAddress: AztecAddress, blockNumber: number, logIndex?: number): ContractInstanceUpdateKey;
+    addContractInstanceUpdate(contractInstanceUpdate: ContractInstanceUpdateWithAddress, blockNumber: number, logIndex: number): Promise<void>;
+    deleteContractInstanceUpdate(contractInstanceUpdate: ContractInstanceUpdateWithAddress, blockNumber: number, logIndex: number): Promise<void>;
+    getCurrentContractInstanceClassId(address: AztecAddress, blockNumber: number, originalClassId: Fr): Promise<Fr>;
+    getContractInstance(address: AztecAddress, blockNumber: number): Promise<ContractInstanceWithAddress | undefined>;
+}
+export {};
+//# sourceMappingURL=contract_instance_store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_instance_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/contract_instance_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,2BAA2B,EAGjC,MAAM,wBAAwB,CAAC;AAEhC,KAAK,yBAAyB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7E;;GAEG;AACH,qBAAa,qBAAqB;;gBAIpB,EAAE,EAAE,iBAAiB;IAKjC,mBAAmB,CAAC,gBAAgB,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjF,sBAAsB,CAAC,gBAAgB,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpF,YAAY,CAAC,eAAe,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,yBAAyB;IAQ9G,yBAAyB,CACvB,sBAAsB,EAAE,iCAAiC,EACzD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAOhB,4BAA4B,CAC1B,sBAAsB,EAAE,iCAAiC,EACzD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAMV,iCAAiC,CACrC,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,EAAE,GAClB,OAAO,CAAC,EAAE,CAAC;IAqBR,mBAAmB,CACvB,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;CAcpD"}

package/dest/archiver/kv_archiver_store/contract_instance_store.js

@@ -0,0 +1,63 @@
+import { SerializableContractInstance, SerializableContractInstanceUpdate } from '@aztec/stdlib/contract';
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */ export class ContractInstanceStore {
+    #contractInstances;
+    #contractInstanceUpdates;
+    constructor(db){
+        this.#contractInstances = db.openMap('archiver_contract_instances');
+        this.#contractInstanceUpdates = db.openMap('archiver_contract_instance_updates');
+    }
+    addContractInstance(contractInstance) {
+        return this.#contractInstances.set(contractInstance.address.toString(), new SerializableContractInstance(contractInstance).toBuffer());
+    }
+    deleteContractInstance(contractInstance) {
+        return this.#contractInstances.delete(contractInstance.address.toString());
+    }
+    getUpdateKey(contractAddress, blockNumber, logIndex) {
+        if (logIndex === undefined) {
+            return [
+                contractAddress.toString(),
+                blockNumber
+            ];
+        } else {
+            return [
+                contractAddress.toString(),
+                blockNumber,
+                logIndex
+            ];
+        }
+    }
+    addContractInstanceUpdate(contractInstanceUpdate, blockNumber, logIndex) {
+        return this.#contractInstanceUpdates.set(this.getUpdateKey(contractInstanceUpdate.address, blockNumber, logIndex), new SerializableContractInstanceUpdate(contractInstanceUpdate).toBuffer());
+    }
+    deleteContractInstanceUpdate(contractInstanceUpdate, blockNumber, logIndex) {
+        return this.#contractInstanceUpdates.delete(this.getUpdateKey(contractInstanceUpdate.address, blockNumber, logIndex));
+    }
+    async getCurrentContractInstanceClassId(address, blockNumber, originalClassId) {
+        // We need to find the last update before the given block number
+        const queryResult = await this.#contractInstanceUpdates.valuesAsync({
+            reverse: true,
+            end: this.getUpdateKey(address, blockNumber + 1),
+            limit: 1
+        }).next();
+        if (queryResult.done) {
+            return originalClassId;
+        }
+        const serializedUpdate = queryResult.value;
+        const update = SerializableContractInstanceUpdate.fromBuffer(serializedUpdate);
+        if (blockNumber < update.blockOfChange) {
+            return update.prevContractClassId.isZero() ? originalClassId : update.prevContractClassId;
+        }
+        return update.newContractClassId;
+    }
+    async getContractInstance(address, blockNumber) {
+        const contractInstance = await this.#contractInstances.getAsync(address.toString());
+        if (!contractInstance) {
+            return undefined;
+        }
+        const instance = SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);
+        instance.currentContractClassId = await this.getCurrentContractInstanceClassId(address, blockNumber, instance.originalContractClassId);
+        return instance;
+    }
+}