@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/contract/interfaces/contract_instance.d.ts

@@ -0,0 +1,138 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { z } from 'zod';
+import type { AztecAddress } from '../../aztec-address/index.js';
+import { PublicKeys } from '../../keys/public_keys.js';
+import { type ZodFor } from '../../schemas/index.js';
+declare const VERSION: 1;
+/**
+ * A contract instance is a concrete deployment of a contract class. It always references a contract class,
+ * which dictates what code it executes when called. It has state (both private and public), as well as an
+ * address that acts as its identifier. It can be called into. It may have encryption and nullifying public keys.
+ */
+export interface ContractInstance {
+    /** Version identifier. Initially one, bumped for any changes to the contract instance struct. */
+    version: typeof VERSION;
+    /** User-generated pseudorandom value for uniqueness. */
+    salt: Fr;
+    /** Optional deployer address or zero if this was a universal deploy. */
+    deployer: AztecAddress;
+    /** Identifier of the contract class for this instance. */
+    currentContractClassId: Fr;
+    /** Identifier of the original (at deployment) contract class for this instance */
+    originalContractClassId: Fr;
+    /** Hash of the selector and arguments to the constructor. */
+    initializationHash: Fr;
+    /** Public keys associated with this instance. */
+    publicKeys: PublicKeys;
+}
+export type ContractInstanceWithAddress = ContractInstance & {
+    address: AztecAddress;
+};
+export declare const ContractInstanceSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    salt: ZodFor<Fr>;
+    deployer: ZodFor<AztecAddress>;
+    currentContractClassId: ZodFor<Fr>;
+    originalContractClassId: ZodFor<Fr>;
+    initializationHash: ZodFor<Fr>;
+    publicKeys: z.ZodEffects<z.ZodObject<{
+        masterNullifierPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        masterIncomingViewingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        masterOutgoingViewingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        masterTaggingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+    }, "strip", z.ZodTypeAny, {
+        masterNullifierPublicKey: import("@aztec/foundation/fields").Point;
+        masterIncomingViewingPublicKey: import("@aztec/foundation/fields").Point;
+        masterOutgoingViewingPublicKey: import("@aztec/foundation/fields").Point;
+        masterTaggingPublicKey: import("@aztec/foundation/fields").Point;
+    }, {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    }>, PublicKeys, {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    salt: Fr;
+    deployer: AztecAddress;
+    currentContractClassId: Fr;
+    originalContractClassId: Fr;
+    initializationHash: Fr;
+    publicKeys: PublicKeys;
+}, {
+    version: 1;
+    publicKeys: {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    };
+    salt?: any;
+    deployer?: any;
+    currentContractClassId?: any;
+    originalContractClassId?: any;
+    initializationHash?: any;
+}>;
+export declare const ContractInstanceWithAddressSchema: z.ZodIntersection<z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    salt: ZodFor<Fr>;
+    deployer: ZodFor<AztecAddress>;
+    currentContractClassId: ZodFor<Fr>;
+    originalContractClassId: ZodFor<Fr>;
+    initializationHash: ZodFor<Fr>;
+    publicKeys: z.ZodEffects<z.ZodObject<{
+        masterNullifierPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        masterIncomingViewingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        masterOutgoingViewingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        masterTaggingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+    }, "strip", z.ZodTypeAny, {
+        masterNullifierPublicKey: import("@aztec/foundation/fields").Point;
+        masterIncomingViewingPublicKey: import("@aztec/foundation/fields").Point;
+        masterOutgoingViewingPublicKey: import("@aztec/foundation/fields").Point;
+        masterTaggingPublicKey: import("@aztec/foundation/fields").Point;
+    }, {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    }>, PublicKeys, {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    salt: Fr;
+    deployer: AztecAddress;
+    currentContractClassId: Fr;
+    originalContractClassId: Fr;
+    initializationHash: Fr;
+    publicKeys: PublicKeys;
+}, {
+    version: 1;
+    publicKeys: {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    };
+    salt?: any;
+    deployer?: any;
+    currentContractClassId?: any;
+    originalContractClassId?: any;
+    initializationHash?: any;
+}>, z.ZodObject<{
+    address: ZodFor<AztecAddress>;
+}, "strip", z.ZodTypeAny, {
+    address: AztecAddress;
+}, {
+    address?: any;
+}>>;
+export {};
+//# sourceMappingURL=contract_instance.d.ts.map

package/dest/contract/interfaces/contract_instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_instance.d.ts","sourceRoot":"","sources":["../../../src/contract/interfaces/contract_instance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,wBAAwB,CAAC;AAE9D,QAAA,MAAM,OAAO,GAAa,CAAC;AAE3B;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iGAAiG;IACjG,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,wDAAwD;IACxD,IAAI,EAAE,EAAE,CAAC;IACT,wEAAwE;IACxE,QAAQ,EAAE,YAAY,CAAC;IACvB,0DAA0D;IAC1D,sBAAsB,EAAE,EAAE,CAAC;IAC3B,kFAAkF;IAClF,uBAAuB,EAAE,EAAE,CAAC;IAC5B,6DAA6D;IAC7D,kBAAkB,EAAE,EAAE,CAAC;IACvB,iDAAiD;IACjD,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,MAAM,2BAA2B,GAAG,gBAAgB,GAAG;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AAEvF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQE,CAAC;AAEtC,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEC,CAAC"}

package/dest/contract/interfaces/contract_instance.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { PublicKeys } from '../../keys/public_keys.js';
+import { schemas } from '../../schemas/index.js';
+const VERSION = 1;
+export const ContractInstanceSchema = z.object({
+    version: z.literal(VERSION),
+    salt: schemas.Fr,
+    deployer: schemas.AztecAddress,
+    currentContractClassId: schemas.Fr,
+    originalContractClassId: schemas.Fr,
+    initializationHash: schemas.Fr,
+    publicKeys: PublicKeys.schema
+});
+export const ContractInstanceWithAddressSchema = ContractInstanceSchema.and(z.object({
+    address: schemas.AztecAddress
+}));

package/dest/contract/interfaces/contract_instance_update.d.ts

@@ -0,0 +1,51 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { z } from 'zod';
+import type { AztecAddress } from '../../aztec-address/index.js';
+import { type ZodFor } from '../../schemas/index.js';
+/**
+ * An update to a contract instance, changing its contract class.
+ */
+export interface ContractInstanceUpdate {
+    /** Identifier of the previous contract class for this instance */
+    prevContractClassId: Fr;
+    /** Identifier of the new contract class for this instance. */
+    newContractClassId: Fr;
+    /** The block number where the contract class in use will be the new one */
+    blockOfChange: number;
+}
+export type ContractInstanceUpdateWithAddress = ContractInstanceUpdate & {
+    address: AztecAddress;
+};
+export declare const ContractInstanceUpdateSchema: z.ZodObject<{
+    prevContractClassId: ZodFor<Fr>;
+    newContractClassId: ZodFor<Fr>;
+    blockOfChange: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    prevContractClassId: Fr;
+    newContractClassId: Fr;
+    blockOfChange: number;
+}, {
+    blockOfChange: number;
+    prevContractClassId?: any;
+    newContractClassId?: any;
+}>;
+export declare const ContractInstanceUpdateWithAddressSchema: z.ZodIntersection<z.ZodObject<{
+    prevContractClassId: ZodFor<Fr>;
+    newContractClassId: ZodFor<Fr>;
+    blockOfChange: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    prevContractClassId: Fr;
+    newContractClassId: Fr;
+    blockOfChange: number;
+}, {
+    blockOfChange: number;
+    prevContractClassId?: any;
+    newContractClassId?: any;
+}>, z.ZodObject<{
+    address: ZodFor<AztecAddress>;
+}, "strip", z.ZodTypeAny, {
+    address: AztecAddress;
+}, {
+    address?: any;
+}>>;
+//# sourceMappingURL=contract_instance_update.d.ts.map

package/dest/contract/interfaces/contract_instance_update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_instance_update.d.ts","sourceRoot":"","sources":["../../../src/contract/interfaces/contract_instance_update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,wBAAwB,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,kEAAkE;IAClE,mBAAmB,EAAE,EAAE,CAAC;IACxB,8DAA8D;IAC9D,kBAAkB,EAAE,EAAE,CAAC;IACvB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,iCAAiC,GAAG,sBAAsB,GAAG;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AAEnG,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAIE,CAAC;AAE5C,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;GAEC,CAAC"}

package/dest/contract/interfaces/contract_instance_update.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { schemas } from '../../schemas/index.js';
+export const ContractInstanceUpdateSchema = z.object({
+    prevContractClassId: schemas.Fr,
+    newContractClassId: schemas.Fr,
+    blockOfChange: z.number()
+});
+export const ContractInstanceUpdateWithAddressSchema = ContractInstanceUpdateSchema.and(z.object({
+    address: schemas.AztecAddress
+}));

package/dest/contract/interfaces/index.d.ts

@@ -0,0 +1,7 @@
+export * from './contract_class.js';
+export * from './contract_data_source.js';
+export * from './contract_instance.js';
+export * from './contract_instance_update.js';
+export * from './node-info.js';
+export * from './protocol_contract_addresses.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/contract/interfaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contract/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kCAAkC,CAAC"}

package/dest/contract/interfaces/index.js

@@ -0,0 +1,6 @@
+export * from './contract_class.js';
+export * from './contract_data_source.js';
+export * from './contract_instance.js';
+export * from './contract_instance_update.js';
+export * from './node-info.js';
+export * from './protocol_contract_addresses.js';

package/dest/contract/interfaces/node-info.d.ts

@@ -0,0 +1,20 @@
+import { type L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { type ProtocolContractAddresses } from './protocol_contract_addresses.js';
+/** Provides basic information about the running node. */
+export interface NodeInfo {
+    /** Version as tracked in the aztec-packages repository. */
+    nodeVersion: string;
+    /** L1 chain id. */
+    l1ChainId: number;
+    /** Protocol version. */
+    protocolVersion: number;
+    /** The node's ENR. */
+    enr: string | undefined;
+    /** The deployed l1 contract addresses */
+    l1ContractAddresses: L1ContractAddresses;
+    /** Protocol contract addresses */
+    protocolContractAddresses: ProtocolContractAddresses;
+}
+export declare const NodeInfoSchema: ZodFor<NodeInfo>;
+//# sourceMappingURL=node-info.d.ts.map

package/dest/contract/interfaces/node-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-info.d.ts","sourceRoot":"","sources":["../../../src/contract/interfaces/node-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAA6B,MAAM,uCAAuC,CAAC;AAC5G,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAIxD,OAAO,EAAE,KAAK,yBAAyB,EAAmC,MAAM,kCAAkC,CAAC;AAEnH,yDAAyD;AACzD,MAAM,WAAW,QAAQ;IACvB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,sBAAsB;IACtB,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,yCAAyC;IACzC,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,kCAAkC;IAClC,yBAAyB,EAAE,yBAAyB,CAAC;CACtD;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,QAAQ,CASK,CAAC"}

package/dest/contract/interfaces/node-info.js

@@ -0,0 +1,14 @@
+import { L1ContractAddressesSchema } from '@aztec/ethereum/l1-contract-addresses';
+import { z } from 'zod';
+import { ProtocolContractAddressesSchema } from './protocol_contract_addresses.js';
+export const NodeInfoSchema = z.object({
+    nodeVersion: z.string(),
+    l1ChainId: z.number(),
+    protocolVersion: z.number(),
+    enr: z.string().optional(),
+    l1ContractAddresses: L1ContractAddressesSchema,
+    protocolContractAddresses: ProtocolContractAddressesSchema
+}).transform((obj)=>({
+        enr: undefined,
+        ...obj
+    }));

package/dest/contract/interfaces/protocol_contract_addresses.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { AztecAddress } from '../../aztec-address/index.js';
+export declare const ProtocolContractsNames: readonly ["classRegisterer", "feeJuice", "instanceDeployer", "multiCallEntrypoint"];
+export type ProtocolContractAddresses = {
+    classRegisterer: AztecAddress;
+    feeJuice: AztecAddress;
+    instanceDeployer: AztecAddress;
+    multiCallEntrypoint: AztecAddress;
+};
+export declare const ProtocolContractAddressesSchema: z.ZodObject<{
+    classRegisterer: import("../../schemas/index.js").ZodFor<AztecAddress>;
+    feeJuice: import("../../schemas/index.js").ZodFor<AztecAddress>;
+    instanceDeployer: import("../../schemas/index.js").ZodFor<AztecAddress>;
+    multiCallEntrypoint: import("../../schemas/index.js").ZodFor<AztecAddress>;
+}, "strip", z.ZodTypeAny, {
+    classRegisterer: AztecAddress;
+    feeJuice: AztecAddress;
+    instanceDeployer: AztecAddress;
+    multiCallEntrypoint: AztecAddress;
+}, {
+    classRegisterer?: any;
+    feeJuice?: any;
+    instanceDeployer?: any;
+    multiCallEntrypoint?: any;
+}>;
+//# sourceMappingURL=protocol_contract_addresses.d.ts.map

package/dest/contract/interfaces/protocol_contract_addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol_contract_addresses.d.ts","sourceRoot":"","sources":["../../../src/contract/interfaces/protocol_contract_addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAGjE,eAAO,MAAM,sBAAsB,qFAKzB,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG;IACtC,eAAe,EAAE,YAAY,CAAC;IAC9B,QAAQ,EAAE,YAAY,CAAC;IACvB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,mBAAmB,EAAE,YAAY,CAAC;CACnC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;EAK1C,CAAC"}

package/dest/contract/interfaces/protocol_contract_addresses.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { schemas } from '../../schemas/index.js';
+export const ProtocolContractsNames = [
+    'classRegisterer',
+    'feeJuice',
+    'instanceDeployer',
+    'multiCallEntrypoint'
+];
+export const ProtocolContractAddressesSchema = z.object({
+    classRegisterer: schemas.AztecAddress,
+    feeJuice: schemas.AztecAddress,
+    instanceDeployer: schemas.AztecAddress,
+    multiCallEntrypoint: schemas.AztecAddress
+});

package/dest/contract/partial_address.d.ts

@@ -0,0 +1,7 @@
+import type { Fr } from '@aztec/foundation/fields';
+/**
+ * A type which along with public key forms a preimage of a contract address. See the link below for more details
+ * https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
+ */
+export type PartialAddress = Fr;
+//# sourceMappingURL=partial_address.d.ts.map

package/dest/contract/partial_address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial_address.d.ts","sourceRoot":"","sources":["../../src/contract/partial_address.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,EAAE,CAAC"}

package/dest/contract/partial_address.js

@@ -0,0 +1,4 @@
+/**
+ * A type which along with public key forms a preimage of a contract address. See the link below for more details
+ * https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
+ */ export { };

package/dest/contract/private_function.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { type MerkleTree } from '@aztec/foundation/trees';
+import type { PrivateFunction } from './interfaces/contract_class.js';
+/** Returns a Merkle tree for the set of private functions in a contract. */
+export declare function computePrivateFunctionsTree(fns: PrivateFunction[]): Promise<MerkleTree>;
+/** Returns the Merkle tree root for the set of private functions in a contract. */
+export declare function computePrivateFunctionsRoot(fns: PrivateFunction[]): Promise<Fr>;
+/** Returns the leaf for a given private function. */
+export declare function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<Buffer>;
+//# sourceMappingURL=private_function.d.ts.map

package/dest/contract/private_function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_function.d.ts","sourceRoot":"","sources":["../../src/contract/private_function.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAwB,MAAM,yBAAyB,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAOtE,4EAA4E;AAC5E,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAI7F;AAED,mFAAmF;AACnF,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAIrF;AAOD,qDAAqD;AACrD,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAErF"}

package/dest/contract/private_function.js

@@ -0,0 +1,39 @@
+import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '@aztec/constants';
+import { pedersenHash, poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { MerkleTreeCalculator } from '@aztec/foundation/trees';
+// Memoize the merkle tree calculators to avoid re-computing the zero-hash for each level in each call
+let privateFunctionTreeCalculator;
+const PRIVATE_FUNCTION_SIZE = 2;
+/** Returns a Merkle tree for the set of private functions in a contract. */ export async function computePrivateFunctionsTree(fns) {
+    const calculator = await getPrivateFunctionTreeCalculator();
+    const leaves = await computePrivateFunctionLeaves(fns);
+    return calculator.computeTree(leaves);
+}
+/** Returns the Merkle tree root for the set of private functions in a contract. */ export async function computePrivateFunctionsRoot(fns) {
+    const calculator = await getPrivateFunctionTreeCalculator();
+    const leaves = await computePrivateFunctionLeaves(fns);
+    return Fr.fromBuffer(await calculator.computeTreeRoot(leaves));
+}
+function computePrivateFunctionLeaves(fns) {
+    const leaves = [
+        ...fns
+    ].sort((a, b)=>a.selector.value - b.selector.value);
+    return Promise.all(leaves.map(computePrivateFunctionLeaf));
+}
+/** Returns the leaf for a given private function. */ export async function computePrivateFunctionLeaf(fn) {
+    return (await poseidon2HashWithSeparator([
+        fn.selector,
+        fn.vkHash
+    ], GeneratorIndex.FUNCTION_LEAF)).toBuffer();
+}
+async function getPrivateFunctionTreeCalculator() {
+    if (!privateFunctionTreeCalculator) {
+        const functionTreeZeroLeaf = (await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))).toBuffer();
+        privateFunctionTreeCalculator = await MerkleTreeCalculator.create(FUNCTION_TREE_HEIGHT, functionTreeZeroLeaf, async (left, right)=>(await poseidon2Hash([
+                left,
+                right
+            ])).toBuffer());
+    }
+    return privateFunctionTreeCalculator;
+}

package/dest/contract/private_function_membership_proof.d.ts

@@ -0,0 +1,32 @@
+import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
+import type { ContractClassPublic, ExecutablePrivateFunctionWithMembershipProof, PrivateFunctionMembershipProof } from './interfaces/index.js';
+/**
+ * Creates a membership proof for a private function in a contract class, to be verified via `isValidPrivateFunctionMembershipProof`.
+ * @param selector - Selector of the function to create the proof for.
+ * @param artifact - Artifact of the contract class where the function is defined.
+ */
+export declare function createPrivateFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<PrivateFunctionMembershipProof>;
+/**
+ * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * as defined in the protocol specs at contract-deployment/classes:
+ *
+ * ```
+ * // Load contract class from local db
+ * contract_class = db.get_contract_class(contract_class_id)
+ *
+ * // Compute function leaf and assert it belongs to the private functions tree
+ * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
+ * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
+ * assert computed_private_function_tree_root == contract_class.private_function_root
+ *
+ * // Compute artifact leaf and assert it belongs to the artifact
+ * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
+ * computed_artifact_private_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path)
+ * computed_artifact_hash = sha256(computed_artifact_private_function_tree_root, unconstrained_functions_artifact_tree_root, artifact_metadata_hash)
+ * assert computed_artifact_hash == contract_class.artifact_hash
+ * ```
+ * @param fn - Function to check membership proof for.
+ * @param contractClass - In which contract class the function is expected to be.
+ */
+export declare function isValidPrivateFunctionMembershipProof(fn: ExecutablePrivateFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'privateFunctionsRoot' | 'artifactHash'>): Promise<boolean>;
+//# sourceMappingURL=private_function_membership_proof.d.ts.map

package/dest/contract/private_function_membership_proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/private_function_membership_proof.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AAUxF,OAAO,KAAK,EACV,mBAAmB,EACnB,4CAA4C,EAC5C,8BAA8B,EAC/B,MAAM,uBAAuB,CAAC;AAG/B;;;;GAIG;AACH,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CA4DzC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,qCAAqC,CACzD,EAAE,EAAE,4CAA4C,EAChD,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,sBAAsB,GAAG,cAAc,CAAC,oBAkDlF"}

package/dest/contract/private_function_membership_proof.js

@@ -0,0 +1,124 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
+import { FunctionSelector, FunctionType } from '../abi/index.js';
+import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPreimage, computeFunctionArtifactHash, computeFunctionMetadataHash, getArtifactMerkleTreeHasher } from './artifact_hash.js';
+import { getContractClassPrivateFunctionFromArtifact } from './contract_class.js';
+import { computePrivateFunctionLeaf, computePrivateFunctionsTree } from './private_function.js';
+/**
+ * Creates a membership proof for a private function in a contract class, to be verified via `isValidPrivateFunctionMembershipProof`.
+ * @param selector - Selector of the function to create the proof for.
+ * @param artifact - Artifact of the contract class where the function is defined.
+ */ export async function createPrivateFunctionMembershipProof(selector, artifact) {
+    const log = createLogger('circuits:function_membership_proof');
+    // Locate private function definition and artifact
+    const privateFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE);
+    const privateFunctionsFromArtifact = await Promise.all(privateFunctions.map(getContractClassPrivateFunctionFromArtifact));
+    const privateFunction = privateFunctionsFromArtifact.find((fn)=>fn.selector.equals(selector));
+    const privateFunctionsAndSelectors = await Promise.all(privateFunctions.map(async (fn)=>({
+            fn,
+            selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
+        })));
+    const privateFunctionArtifact = privateFunctionsAndSelectors.find((fnAndSelector)=>selector.equals(fnAndSelector.selector))?.fn;
+    if (!privateFunction || !privateFunctionArtifact) {
+        throw new Error(`Private function with selector ${selector.toString()} not found`);
+    }
+    // Compute preimage for the artifact hash
+    const { unconstrainedFunctionRoot: unconstrainedFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } = await computeArtifactHashPreimage(artifact);
+    // We need two sibling paths because private function information is split across two trees:
+    // The "private function tree" captures the selectors and verification keys, and is used in the kernel circuit for verifying the proof generated by the app circuit.
+    const functionLeaf = await computePrivateFunctionLeaf(privateFunction);
+    const functionsTree = await computePrivateFunctionsTree(privateFunctionsFromArtifact);
+    const functionsTreeLeafIndex = functionsTree.getIndex(functionLeaf);
+    const functionsTreeSiblingPath = functionsTree.getSiblingPath(functionsTreeLeafIndex).map(Fr.fromBuffer);
+    // And the "artifact tree" captures function bytecode and metadata, and is used by the pxe to check that its executing the code it's supposed to be executing, but it never goes into circuits.
+    const functionMetadataHash = computeFunctionMetadataHash(privateFunctionArtifact);
+    const functionArtifactHash = await computeFunctionArtifactHash({
+        ...privateFunctionArtifact,
+        functionMetadataHash
+    });
+    const artifactTree = await computeArtifactFunctionTree(artifact, FunctionType.PRIVATE);
+    const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
+    const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
+    log.debug(`Computed proof for private function with selector ${selector.toString()}`, {
+        functionArtifactHash,
+        functionMetadataHash,
+        functionLeaf: '0x' + functionLeaf.toString('hex'),
+        artifactMetadataHash,
+        privateFunctionsTreeRoot: '0x' + functionsTree.root.toString('hex'),
+        unconstrainedFunctionsArtifactTreeRoot,
+        artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map((fr)=>fr.toString()).join(','),
+        privateFunctionTreeSiblingPath: functionsTreeSiblingPath.map((fr)=>fr.toString()).join(',')
+    });
+    return {
+        artifactTreeSiblingPath,
+        artifactTreeLeafIndex,
+        artifactMetadataHash,
+        functionMetadataHash,
+        unconstrainedFunctionsArtifactTreeRoot,
+        privateFunctionTreeSiblingPath: functionsTreeSiblingPath,
+        privateFunctionTreeLeafIndex: functionsTreeLeafIndex
+    };
+}
+/**
+ * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * as defined in the protocol specs at contract-deployment/classes:
+ *
+ * ```
+ * // Load contract class from local db
+ * contract_class = db.get_contract_class(contract_class_id)
+ *
+ * // Compute function leaf and assert it belongs to the private functions tree
+ * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
+ * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
+ * assert computed_private_function_tree_root == contract_class.private_function_root
+ *
+ * // Compute artifact leaf and assert it belongs to the artifact
+ * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
+ * computed_artifact_private_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path)
+ * computed_artifact_hash = sha256(computed_artifact_private_function_tree_root, unconstrained_functions_artifact_tree_root, artifact_metadata_hash)
+ * assert computed_artifact_hash == contract_class.artifact_hash
+ * ```
+ * @param fn - Function to check membership proof for.
+ * @param contractClass - In which contract class the function is expected to be.
+ */ export async function isValidPrivateFunctionMembershipProof(fn, contractClass) {
+    const log = createLogger('circuits:function_membership_proof');
+    // Check private function tree membership
+    const functionLeaf = await computePrivateFunctionLeaf(fn);
+    const rootBuffer = await computeRootFromSiblingPath(functionLeaf, fn.privateFunctionTreeSiblingPath.map((fr)=>fr.toBuffer()), fn.privateFunctionTreeLeafIndex, async (left, right)=>(await poseidon2Hash([
+            left,
+            right
+        ])).toBuffer());
+    const computedPrivateFunctionTreeRoot = Fr.fromBuffer(rootBuffer);
+    if (!contractClass.privateFunctionsRoot.equals(computedPrivateFunctionTreeRoot)) {
+        log.debug(`Private function tree root mismatch`, {
+            expectedPrivateFunctionTreeRoot: contractClass.privateFunctionsRoot,
+            computedPrivateFunctionTreeRoot: computedPrivateFunctionTreeRoot,
+            computedFunctionLeaf: '0x' + functionLeaf.toString('hex')
+        });
+        return false;
+    }
+    // Check artifact hash
+    const functionArtifactHash = await computeFunctionArtifactHash(fn);
+    const computedArtifactPrivateFunctionTreeRootBuffer = await computeRootFromSiblingPath(functionArtifactHash.toBuffer(), fn.artifactTreeSiblingPath.map((fr)=>fr.toBuffer()), fn.artifactTreeLeafIndex, getArtifactMerkleTreeHasher());
+    const computedArtifactPrivateFunctionTreeRoot = Fr.fromBuffer(computedArtifactPrivateFunctionTreeRootBuffer);
+    const computedArtifactHash = await computeArtifactHash({
+        privateFunctionRoot: computedArtifactPrivateFunctionTreeRoot,
+        unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
+        metadataHash: fn.artifactMetadataHash
+    });
+    if (!contractClass.artifactHash.equals(computedArtifactHash)) {
+        log.debug(`Artifact hash mismatch`, {
+            expected: contractClass.artifactHash,
+            computedArtifactHash,
+            computedFunctionArtifactHash: functionArtifactHash,
+            computedArtifactPrivateFunctionTreeRoot,
+            unconstrainedFunctionRoot: fn.unconstrainedFunctionsArtifactTreeRoot,
+            metadataHash: fn.artifactMetadataHash,
+            artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map((fr)=>fr.toString()).join(',')
+        });
+        return false;
+    }
+    return true;
+}

package/dest/contract/unconstrained_function_membership_proof.d.ts

@@ -0,0 +1,27 @@
+import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
+import type { ContractClassPublic, UnconstrainedFunctionMembershipProof, UnconstrainedFunctionWithMembershipProof } from './interfaces/index.js';
+/**
+ * Creates a membership proof for an unconstrained function in a contract class, to be verified via `isValidUnconstrainedFunctionMembershipProof`.
+ * @param selector - Selector of the function to create the proof for.
+ * @param artifact - Artifact of the contract class where the function is defined.
+ */
+export declare function createUnconstrainedFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<UnconstrainedFunctionMembershipProof>;
+/**
+ * Verifies that an unconstrained function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * as defined in the protocol specs at contract-deployment/classes:
+ *
+ * ```
+ * // Load contract class from local db
+ * contract_class = db.get_contract_class(contract_class_id)
+ *
+ * // Compute artifact leaf and assert it belongs to the artifact
+ * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
+ * computed_artifact_unconstrained_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
+ * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_unconstrained_function_tree_root, artifact_metadata_hash)
+ * assert computed_artifact_hash == contract_class.artifact_hash
+ * ```
+ * @param fn - Function to check membership proof for.
+ * @param contractClass - In which contract class the function is expected to be.
+ */
+export declare function isValidUnconstrainedFunctionMembershipProof(fn: UnconstrainedFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'artifactHash'>): Promise<boolean>;
+//# sourceMappingURL=unconstrained_function_membership_proof.d.ts.map

package/dest/contract/unconstrained_function_membership_proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unconstrained_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/unconstrained_function_membership_proof.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AASxF,OAAO,KAAK,EACV,mBAAmB,EACnB,oCAAoC,EACpC,wCAAwC,EACzC,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,wBAAsB,0CAA0C,CAC9D,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,oCAAoC,CAAC,CAsC/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,2CAA2C,CAC/D,EAAE,EAAE,wCAAwC,EAC5C,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,oBA+BzD"}