@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/storage/contract_store/contract_store.js

@@ -0,0 +1,236 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import { FunctionSelector, FunctionType, contractArtifactFromBuffer, contractArtifactToBuffer, encodeArguments, getFunctionDebugMetadata } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { SerializableContractInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { PrivateFunctionsTree } from './private_functions_tree.js';
+/**
+ * ContractStore serves as a data manager and retriever for Aztec.nr contracts.
+ * It provides methods to obtain contract addresses, function ABI, bytecode, and membership witnesses
+ * from a given contract address and function selector. The class maintains a cache of ContractTree instances
+ * to efficiently serve the requested data. It interacts with the ContractDatabase and AztecNode to fetch
+ * the required information and facilitate cryptographic proof generation.
+ */ export class ContractStore {
+    /** Map from contract class id to private function tree. */ // TODO: Update it to be LRU cache so that it doesn't keep all the data all the time.
+    #privateFunctionTrees = new Map();
+    /** Map from contract address to contract class id */ #contractClassIdMap = new Map();
+    #contractArtifacts;
+    #contractInstances;
+    constructor(store){
+        this.#contractArtifacts = store.openMap('contract_artifacts');
+        this.#contractInstances = store.openMap('contracts_instances');
+    }
+    // Setters
+    async addContractArtifact(id, contract) {
+        const privateFunctions = contract.functions.filter((functionArtifact)=>functionArtifact.functionType === FunctionType.PRIVATE);
+        const privateSelectors = await Promise.all(privateFunctions.map(async (privateFunctionArtifact)=>(await FunctionSelector.fromNameAndParameters(privateFunctionArtifact.name, privateFunctionArtifact.parameters)).toString()));
+        if (privateSelectors.length !== new Set(privateSelectors).size) {
+            throw new Error('Repeated function selectors of private functions');
+        }
+        await this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract));
+    }
+    async addContractInstance(contract) {
+        this.#contractClassIdMap.set(contract.address.toString(), contract.currentContractClassId);
+        await this.#contractInstances.set(contract.address.toString(), new SerializableContractInstance(contract).toBuffer());
+    }
+    // Private getters
+    async #getContractClassId(contractAddress) {
+        if (!this.#contractClassIdMap.has(contractAddress.toString())) {
+            const instance = await this.getContractInstance(contractAddress);
+            if (!instance) {
+                return;
+            }
+            this.#contractClassIdMap.set(contractAddress.toString(), instance.currentContractClassId);
+        }
+        return this.#contractClassIdMap.get(contractAddress.toString());
+    }
+    /**
+   * Retrieve or create a ContractTree instance based on the provided class id.
+   * If an existing tree with the same class id is found in the cache, it will be returned.
+   * Otherwise, a new ContractTree instance will be created using the contract data from the database
+   * and added to the cache before returning.
+   *
+   * @param classId - The class id of the contract for which the ContractTree is required.
+   * @returns A ContractTree instance associated with the specified contract address.
+   * @throws An Error if the contract is not found in the ContractDatabase.
+   */ async #getPrivateFunctionTreeForClassId(classId) {
+        if (!this.#privateFunctionTrees.has(classId.toString())) {
+            const artifact = await this.getContractArtifact(classId);
+            if (!artifact) {
+                return;
+            }
+            const tree = await PrivateFunctionsTree.create(artifact);
+            this.#privateFunctionTrees.set(classId.toString(), tree);
+        }
+        return this.#privateFunctionTrees.get(classId.toString());
+    }
+    async #getContractArtifactByAddress(contractAddress) {
+        const contractClassId = await this.#getContractClassId(contractAddress);
+        return contractClassId && this.getContractArtifact(contractClassId);
+    }
+    // Public getters
+    async getContractsAddresses() {
+        const keys = await toArray(this.#contractInstances.keysAsync());
+        return keys.map(AztecAddress.fromString);
+    }
+    /** Returns a contract instance for a given address. Throws if not found. */ async getContractInstance(contractAddress) {
+        const contract = await this.#contractInstances.getAsync(contractAddress.toString());
+        return contract && SerializableContractInstance.fromBuffer(contract).withAddress(contractAddress);
+    }
+    async getContractArtifact(contractClassId) {
+        const contract = await this.#contractArtifacts.getAsync(contractClassId.toString());
+        // TODO(@spalladino): AztecAsyncMap lies and returns Uint8Arrays instead of Buffers, hence the extra Buffer.from.
+        return contract && contractArtifactFromBuffer(Buffer.from(contract));
+    }
+    /** Returns a contract class for a given class id. Throws if not found. */ async getContractClass(contractClassId) {
+        const artifact = await this.getContractArtifact(contractClassId);
+        return artifact && getContractClassFromArtifact(artifact);
+    }
+    async getContract(address) {
+        const instance = await this.getContractInstance(address);
+        if (!instance) {
+            return;
+        }
+        const artifact = await this.getContractArtifact(instance.currentContractClassId);
+        if (!artifact) {
+            return;
+        }
+        return {
+            ...instance,
+            ...artifact
+        };
+    }
+    /**
+   * Retrieves the artifact of a specified function within a given contract.
+   * The function is identified by its selector, which is a unique code generated from the function's signature.
+   * Throws an error if the contract address or function selector are invalid or not found.
+   *
+   * @param contractAddress - The AztecAddress representing the contract containing the function.
+   * @param selector - The function selector.
+   * @returns The corresponding function's artifact as an object.
+   */ async getFunctionArtifact(contractAddress, selector) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        const fnArtifact = artifact && await this.#findFunctionArtifactBySelector(artifact, selector);
+        return fnArtifact && {
+            ...fnArtifact,
+            contractName: artifact.name
+        };
+    }
+    async getFunctionArtifactWithDebugMetadata(contractAddress, selector) {
+        const artifact = await this.getFunctionArtifact(contractAddress, selector);
+        if (!artifact) {
+            throw new Error(`Function artifact not found for contract ${contractAddress} and selector ${selector}.`);
+        }
+        const debug = await this.getFunctionDebugMetadata(contractAddress, selector);
+        return {
+            ...artifact,
+            debug
+        };
+    }
+    async getPublicFunctionArtifact(contractAddress) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        const fnArtifact = artifact && artifact.functions.find((fn)=>fn.functionType === FunctionType.PUBLIC);
+        return fnArtifact && {
+            ...fnArtifact,
+            contractName: artifact.name
+        };
+    }
+    async getFunctionAbi(contractAddress, selector) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        return artifact && await this.#findFunctionAbiBySelector(artifact, selector);
+    }
+    /**
+   * Retrieves the debug metadata of a specified function within a given contract.
+   * The function is identified by its selector, which is a unique code generated from the function's signature.
+   * Returns undefined if the debug metadata for the given function is not found.
+   * Throws if the contract has not been added to the database.
+   *
+   * @param contractAddress - The AztecAddress representing the contract containing the function.
+   * @param selector - The function selector.
+   * @returns The corresponding function's artifact as an object.
+   */ async getFunctionDebugMetadata(contractAddress, selector) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        const fnArtifact = artifact && await this.#findFunctionArtifactBySelector(artifact, selector);
+        return fnArtifact && getFunctionDebugMetadata(artifact, fnArtifact);
+    }
+    async getPublicFunctionDebugMetadata(contractAddress) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        const fnArtifact = artifact && artifact.functions.find((fn)=>fn.functionType === FunctionType.PUBLIC);
+        return fnArtifact && getFunctionDebugMetadata(artifact, fnArtifact);
+    }
+    /**
+   * Retrieve the function membership witness for the given contract class and function selector.
+   * The function membership witness represents a proof that the function belongs to the specified contract.
+   * Throws an error if the contract address or function selector is unknown.
+   *
+   * @param contractClassId - The id of the class.
+   * @param selector - The function selector.
+   * @returns A promise that resolves with the MembershipWitness instance for the specified contract's function.
+   */ async getFunctionMembershipWitness(contractClassId, selector) {
+        const tree = await this.#getPrivateFunctionTreeForClassId(contractClassId);
+        return tree?.getFunctionMembershipWitness(selector);
+    }
+    async getDebugContractName(contractAddress) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        return artifact?.name;
+    }
+    async getDebugFunctionName(contractAddress, selector) {
+        const artifact = await this.#getContractArtifactByAddress(contractAddress);
+        const fnArtifact = artifact && await this.#findFunctionAbiBySelector(artifact, selector);
+        return `${artifact?.name ?? contractAddress}:${fnArtifact?.name ?? selector}`;
+    }
+    async #findFunctionArtifactBySelector(artifact, selector) {
+        const functions = artifact.functions;
+        for(let i = 0; i < functions.length; i++){
+            const fn = functions[i];
+            const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
+            if (fnSelector.equals(selector)) {
+                return fn;
+            }
+        }
+    }
+    async #findFunctionAbiBySelector(artifact, selector) {
+        const functions = [
+            ...artifact.functions,
+            ...artifact.nonDispatchPublicFunctions ?? []
+        ];
+        for(let i = 0; i < functions.length; i++){
+            const fn = functions[i];
+            const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
+            if (fnSelector.equals(selector)) {
+                return fn;
+            }
+        }
+    }
+    async getFunctionCall(functionName, args, to) {
+        const contract = await this.getContract(to);
+        if (!contract) {
+            throw new Error(`Unknown contract ${to}: add it to PXE by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/resources/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`);
+        }
+        const functionDao = contract.functions.find((f)=>f.name === functionName);
+        if (!functionDao) {
+            throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
+        }
+        return {
+            name: functionDao.name,
+            args: encodeArguments(functionDao, args),
+            selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
+            type: functionDao.functionType,
+            to,
+            hideMsgSender: false,
+            isStatic: functionDao.isStatic,
+            returnTypes: functionDao.returnTypes
+        };
+    }
+    // Synchronize target contract data
+    async syncPrivateState(contractAddress, functionToInvokeAfterSync, utilityExecutor) {
+        // Protocol contracts don't have private state to sync
+        if (!isProtocolContract(contractAddress)) {
+            const syncPrivateStateFunctionCall = await this.getFunctionCall('sync_private_state', [], contractAddress);
+            if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncPrivateStateFunctionCall.selector)) {
+                throw new Error('Forbidden `sync_private_state` invocation. `sync_private_state` can only be invoked by PXE, manual execution can lead to inconsistencies.');
+            }
+            return utilityExecutor(syncPrivateStateFunctionCall);
+        }
+    }
+}

package/dest/storage/contract_store/index.d.ts

@@ -0,0 +1,2 @@
+export { ContractStore } from './contract_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL2NvbnRyYWN0X3N0b3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQyJ9

package/dest/storage/contract_store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/contract_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dest/storage/contract_store/index.js

@@ -0,0 +1 @@
+export { ContractStore } from './contract_store.js';

package/dest/storage/contract_store/private_functions_tree.d.ts

@@ -0,0 +1,27 @@
+import { FUNCTION_TREE_HEIGHT } from '@aztec/constants';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+/**
+ * Represents a Merkle tree of functions for a particular Contract Class.
+ * It manages the construction of the function tree, computes its root, and generates membership witnesses
+ * for constrained functions. This class also enables lookup of specific function artifact using selectors.
+ * It is used in combination with the AztecNode to compute various data for executing private transactions.
+ */
+export declare class PrivateFunctionsTree {
+    private readonly privateFunctions;
+    private tree?;
+    private constructor();
+    static create(artifact: ContractArtifact): Promise<PrivateFunctionsTree>;
+    /**
+     * Retrieve the membership witness of a function within a contract's function tree.
+     * A membership witness represents the position and authentication path of a target function
+     * in the Merkle tree of constrained functions. It is required to prove the existence of the
+     * function within the contract during execution. Throws if fn does not exist or is not private.
+     *
+     * @param selector - The function selector.
+     * @returns A MembershipWitness instance representing the position and authentication path of the function in the function tree.
+     */
+    getFunctionMembershipWitness(selector: FunctionSelector): Promise<MembershipWitness<typeof FUNCTION_TREE_HEIGHT>>;
+    private getTree;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9mdW5jdGlvbnNfdHJlZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvY29udHJhY3Rfc3RvcmUvcHJpdmF0ZV9mdW5jdGlvbnNfdHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUd4RCxPQUFPLEVBQUUsaUJBQWlCLEVBQW1CLE1BQU0seUJBQXlCLENBQUM7QUFDN0UsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQWdCLE1BQU0sbUJBQW1CLENBQUM7QUFRMUY7Ozs7O0dBS0c7QUFDSCxxQkFBYSxvQkFBb0I7SUFHWCxPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQjtJQUZyRCxPQUFPLENBQUMsSUFBSSxDQUFDLENBQWE7SUFFMUIsT0FBTyxlQUFxRTtJQUU1RSxPQUFhLE1BQU0sQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLGlDQU83QztJQUVEOzs7Ozs7OztPQVFHO0lBQ1UsNEJBQTRCLENBQ3ZDLFFBQVEsRUFBRSxnQkFBZ0IsR0FDekIsT0FBTyxDQUFDLGlCQUFpQixDQUFDLE9BQU8sb0JBQW9CLENBQUMsQ0FBQyxDQWV6RDtZQUVhLE9BQU87Q0FNdEIifQ==

package/dest/storage/contract_store/private_functions_tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_functions_tree.d.ts","sourceRoot":"","sources":["../../../src/storage/contract_store/private_functions_tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,EAAE,iBAAiB,EAAmB,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AAQ1F;;;;;GAKG;AACH,qBAAa,oBAAoB;IAGX,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAFrD,OAAO,CAAC,IAAI,CAAC,CAAa;IAE1B,OAAO,eAAqE;IAE5E,OAAa,MAAM,CAAC,QAAQ,EAAE,gBAAgB,iCAO7C;IAED;;;;;;;;OAQG;IACU,4BAA4B,CACvC,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,iBAAiB,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAezD;YAEa,OAAO;CAMtB"}

package/dest/storage/contract_store/private_functions_tree.js

@@ -0,0 +1,47 @@
+import { FUNCTION_TREE_HEIGHT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { assertLength } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import { FunctionType } from '@aztec/stdlib/abi';
+import { computePrivateFunctionLeaf, computePrivateFunctionsTree, getContractClassPrivateFunctionFromArtifact } from '@aztec/stdlib/contract';
+/**
+ * Represents a Merkle tree of functions for a particular Contract Class.
+ * It manages the construction of the function tree, computes its root, and generates membership witnesses
+ * for constrained functions. This class also enables lookup of specific function artifact using selectors.
+ * It is used in combination with the AztecNode to compute various data for executing private transactions.
+ */ export class PrivateFunctionsTree {
+    privateFunctions;
+    tree;
+    constructor(privateFunctions){
+        this.privateFunctions = privateFunctions;
+    }
+    static async create(artifact) {
+        const privateFunctions = await Promise.all(artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE).map(getContractClassPrivateFunctionFromArtifact));
+        return new PrivateFunctionsTree(privateFunctions);
+    }
+    /**
+   * Retrieve the membership witness of a function within a contract's function tree.
+   * A membership witness represents the position and authentication path of a target function
+   * in the Merkle tree of constrained functions. It is required to prove the existence of the
+   * function within the contract during execution. Throws if fn does not exist or is not private.
+   *
+   * @param selector - The function selector.
+   * @returns A MembershipWitness instance representing the position and authentication path of the function in the function tree.
+   */ async getFunctionMembershipWitness(selector) {
+        const fn = this.privateFunctions.find((f)=>f.selector.equals(selector));
+        if (!fn) {
+            throw new Error(`Private function with selector ${selector.toString()} not found in contract class.`);
+        }
+        const leaf = await computePrivateFunctionLeaf(fn);
+        const tree = await this.getTree();
+        const index = tree.getIndex(leaf);
+        const path = tree.getSiblingPath(index);
+        return new MembershipWitness(FUNCTION_TREE_HEIGHT, BigInt(index), assertLength(path.map(Fr.fromBuffer), FUNCTION_TREE_HEIGHT));
+    }
+    async getTree() {
+        if (!this.tree) {
+            this.tree = await computePrivateFunctionsTree(this.privateFunctions);
+        }
+        return this.tree;
+    }
+}

package/dest/storage/index.d.ts

@@ -1,10 +1,9 @@
-export * from './address_data_provider/index.js';
-export * from './auth_witness_data_provider/index.js';
-export * from './capsule_data_provider/index.js';
-export * from './contract_data_provider/index.js';
-export * from './note_data_provider/index.js';
-export * from './sync_data_provider/index.js';
-export * from './tagging_data_provider/index.js';
-export * from './data_provider.js';
-export declare const PXE_DATA_SCHEMA_VERSION = 2;
-//# sourceMappingURL=index.d.ts.map
+export * from './address_store/index.js';
+export * from './capsule_store/index.js';
+export * from './contract_store/index.js';
+export * from './note_store/index.js';
+export * from './anchor_block_store/index.js';
+export * from './tagging_store/index.js';
+export * from './metadata.js';
+export * from './private_event_store/private_event_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsOENBQThDLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,oBAAoB,CAAC;AAEnC,eAAO,MAAM,uBAAuB,IAAI,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,eAAe,CAAC;AAC9B,cAAc,8CAA8C,CAAC"}

package/dest/storage/index.js

@@ -1,9 +1,8 @@
-export * from './address_data_provider/index.js';
-export * from './auth_witness_data_provider/index.js';
-export * from './capsule_data_provider/index.js';
-export * from './contract_data_provider/index.js';
-export * from './note_data_provider/index.js';
-export * from './sync_data_provider/index.js';
-export * from './tagging_data_provider/index.js';
-export * from './data_provider.js';
-export const PXE_DATA_SCHEMA_VERSION = 2;
+export * from './address_store/index.js';
+export * from './capsule_store/index.js';
+export * from './contract_store/index.js';
+export * from './note_store/index.js';
+export * from './anchor_block_store/index.js';
+export * from './tagging_store/index.js';
+export * from './metadata.js';
+export * from './private_event_store/private_event_store.js';

package/dest/storage/metadata.d.ts

@@ -0,0 +1,2 @@
+export declare const PXE_DATA_SCHEMA_VERSION = 2;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdG9yYWdlL21ldGFkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQU8sTUFBTSx1QkFBdUIsSUFBSSxDQUFDIn0=

package/dest/storage/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/storage/metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,IAAI,CAAC"}

package/dest/storage/metadata.js

@@ -0,0 +1 @@
+export const PXE_DATA_SCHEMA_VERSION = 2;

package/dest/storage/note_store/index.d.ts

@@ -0,0 +1,3 @@
+export { NoteDao } from '@aztec/stdlib/note';
+export { NoteStore } from './note_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL25vdGVfc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dest/storage/note_store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/note_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dest/storage/note_store/index.js

@@ -0,0 +1,2 @@
+export { NoteDao } from '@aztec/stdlib/note';
+export { NoteStore } from './note_store.js';

package/dest/storage/note_store/note_store.d.ts

@@ -0,0 +1,84 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { DataInBlock } from '@aztec/stdlib/block';
+import { type NotesFilter } from '@aztec/stdlib/note';
+import { NoteDao } from '@aztec/stdlib/note';
+/**
+ * NoteStore manages the storage and retrieval of notes.
+ *
+ * Notes can be active or nullified. This class processes new notes, nullifications,
+ * and performs rollback handling in the case of a reorg.
+ **/
+export declare class NoteStore {
+    #private;
+    private constructor();
+    /**
+     * Creates and initializes a new NoteStore instance.
+     *
+     * This factory method creates a NoteStore and restores any existing
+     * scope-specific indexes from the database.
+     *
+     * @param store - The key-value store to use for persistence
+     * @returns Promise resolving to a fully initialized NoteStore instance
+     */
+    static create(store: AztecAsyncKVStore): Promise<NoteStore>;
+    /**
+     * Adds a new scope to the note data provider.
+     *
+     * Scopes provide privacy isolation by creating separate indexes for each user.
+     * Each scope gets its own set of indexes for efficient note retrieval by various criteria.
+     *
+     * @param scope - The AztecAddress representing the scope/user to add
+     * @returns Promise resolving to true if scope was added, false if it already existed
+     */
+    addScope(scope: AztecAddress): Promise<boolean>;
+    /**
+     * Adds multiple notes to the data provider under the specified scope.
+     *
+     * Notes are stored using their index from the notes hash tree as the key, which provides
+     * uniqueness and maintains creation order. Each note is indexed by multiple criteria
+     * for efficient retrieval.
+     *
+     * @param notes - Notes to store
+     * @param scope - The scope (user/account) under which to store the notes
+     */
+    addNotes(notes: NoteDao[], scope: AztecAddress): Promise<void>;
+    /**
+     * Synchronizes notes and nullifiers to a specific block number.
+     *
+     * This method ensures that the state of notes and nullifiers is consistent with the
+     * specified block number. It restores any notes that were nullified after the given block
+     * and deletes any active notes created after that block.
+     *
+     * @param blockNumber - The new chain tip after a reorg
+     * @param synchedBlockNumber - The block number up to which PXE managed to sync before the reorg happened.
+     */
+    rollbackNotesAndNullifiers(blockNumber: number, synchedBlockNumber: number): Promise<void>;
+    /**
+     * Retrieves notes based on the provided filter criteria.
+     *
+     * This method queries both active and optionally nullified notes based on the filter
+     * parameters.
+     *
+     * @param filter - Filter criteria including contractAddress (required), and optional
+     *                 owner, storageSlot, status, scopes, and siloedNullifier.
+     * @returns Filtered and deduplicated notes (a note might be present in multiple scopes - we ensure it is only
+     * returned once if this is the case)
+     * @throws If filtering by an empty scopes array. Scopes have to be set to undefined or to a non-empty array.
+     */
+    getNotes(filter: NotesFilter): Promise<NoteDao[]>;
+    /**
+     * Transitions notes from "active" to "nullified" state.
+     *
+     * This operation processes a batch of nullifiers to mark the corresponding notes
+     * as spent/nullified.  The operation is atomic - if any nullifier is not found,
+     * the entire operation fails and no notes are modified.
+     *
+     * @param nullifiers - Array of nullifiers with their block numbers to process
+     * @returns Promise resolving to array of nullified NoteDao objects
+     * @throws Error if any nullifier is not found in the active notes
+     */
+    applyNullifiers(nullifiers: DataInBlock<Fr>[]): Promise<NoteDao[]>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2Uvbm90ZV9zdG9yZS9ub3RlX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFxQyxNQUFNLGlCQUFpQixDQUFDO0FBQzVGLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEVBQWMsS0FBSyxXQUFXLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFN0M7Ozs7O0lBS0k7QUFDSixxQkFBYSxTQUFTOztJQWlCcEIsT0FBTyxlQWdCTjtJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsT0FBb0IsTUFBTSxDQUFDLEtBQUssRUFBRSxpQkFBaUIsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBT3ZFO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDVSxRQUFRLENBQUMsS0FBSyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBWTNEO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsUUFBUSxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FnQjdEO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ1UsMEJBQTBCLENBQUMsV0FBVyxFQUFFLE1BQU0sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUd0RztJQXVGRDs7Ozs7Ozs7Ozs7T0FXRztJQUNHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQXdHdEQ7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0gsZUFBZSxDQUFDLFVBQVUsRUFBRSxXQUFXLENBQUMsRUFBRSxDQUFDLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0E4RGpFO0NBQ0YifQ==

package/dest/storage/note_store/note_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"note_store.d.ts","sourceRoot":"","sources":["../../../src/storage/note_store/note_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C;;;;;IAKI;AACJ,qBAAa,SAAS;;IAiBpB,OAAO,eAgBN;IAED;;;;;;;;OAQG;IACH,OAAoB,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,SAAS,CAAC,CAOvE;IAED;;;;;;;;OAQG;IACU,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAY3D;IAED;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;IAED;;;;;;;;;OASG;IACU,0BAA0B,CAAC,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGtG;IAuFD;;;;;;;;;;;OAWG;IACG,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAwGtD;IAED;;;;;;;;;;OAUG;IACH,eAAe,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CA8DjE;CACF"}