@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/contract/complete_address.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { AztecAddress } from '../aztec-address/index.js';
+import { PublicKeys } from '../keys/public_keys.js';
+import { computePartialAddress } from './contract_address.js';
+import type { PartialAddress } from './partial_address.js';
+/**
+ * A complete address is a combination of an Aztec address, a public key and a partial address.
+ *
+ * @remarks We have introduced this type because it is common that these 3 values are used together. They are commonly
+ *          used together because it is the information needed to send user a note.
+ * @remarks See the link below for details about how address is computed:
+ *          https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
+ */
+export declare class CompleteAddress {
+    /** Contract address (typically of an account contract) */
+    address: AztecAddress;
+    /** User public keys */
+    publicKeys: PublicKeys;
+    /** Partial key corresponding to the public key to the address. */
+    partialAddress: PartialAddress;
+    private constructor();
+    static create(address: AztecAddress, publicKeys: PublicKeys, partialAddress: PartialAddress): Promise<CompleteAddress>;
+    /** Size in bytes of an instance */
+    static readonly SIZE_IN_BYTES: number;
+    static get schema(): import("zod").ZodType<never, any, string>;
+    toJSON(): string;
+    static random(): Promise<CompleteAddress>;
+    static fromSecretKeyAndPartialAddress(secretKey: Fr, partialAddress: Fr): Promise<CompleteAddress>;
+    getPreaddress(): Promise<Fr>;
+    static fromSecretKeyAndInstance(secretKey: Fr, instance: Parameters<typeof computePartialAddress>[0]): Promise<CompleteAddress>;
+    /** Throws if the address is not correctly derived from the public key and partial address.*/
+    validate(): Promise<void>;
+    /**
+     * Gets a readable string representation of the complete address.
+     * @returns A readable string representation of the complete address.
+     */
+    toReadableString(): string;
+    /**
+     * Determines if this CompleteAddress instance is equal to the given CompleteAddress instance.
+     * Equality is based on the content of their respective buffers.
+     *
+     * @param other - The CompleteAddress instance to compare against.
+     * @returns True if the buffers of both instances are equal, false otherwise.
+     */
+    equals(other: CompleteAddress): boolean;
+    /**
+     * Converts the CompleteAddress instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the CompleteAddress instance.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Creates an CompleteAddress instance from a given buffer or BufferReader.
+     * If the input is a Buffer, it wraps it in a BufferReader before processing.
+     * Throws an error if the input length is not equal to the expected size.
+     *
+     * @param buffer - The input buffer or BufferReader containing the address data.
+     * @returns - A new CompleteAddress instance with the extracted address data.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): Promise<CompleteAddress>;
+    /**
+     * Create a CompleteAddress instance from a hex-encoded string.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
+     * Throws an error if the input length is invalid or coordinate values are out of range.
+     *
+     * @param address - The hex-encoded string representing the complete address.
+     * @returns A Point instance.
+     */
+    static fromString(address: string): Promise<CompleteAddress>;
+    /**
+     * Convert the CompleteAddress to a hexadecimal string representation, with a "0x" prefix.
+     * The resulting string will have a length of 66 characters (including the prefix).
+     *
+     * @returns A hexadecimal string representation of the CompleteAddress.
+     */
+    toString(): string;
+}
+//# sourceMappingURL=complete_address.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complete_address.d.ts","sourceRoot":"","sources":["../../src/contract/complete_address.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;GAOG;AACH,qBAAa,eAAe;IAExB,0DAA0D;IACnD,OAAO,EAAE,YAAY;IAC5B,uBAAuB;IAChB,UAAU,EAAE,UAAU;IAC7B,kEAAkE;IAC3D,cAAc,EAAE,cAAc;IANvC,OAAO;WASM,MAAM,CACjB,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,cAAc,GAC7B,OAAO,CAAC,eAAe,CAAC;IAM3B,mCAAmC;IACnC,MAAM,CAAC,QAAQ,CAAC,aAAa,SAAW;IAExC,MAAM,KAAK,MAAM,8CAEhB;IAED,MAAM;WAIO,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC;WAIlC,8BAA8B,CAAC,SAAS,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IAOlG,aAAa;WAIN,wBAAwB,CACnC,SAAS,EAAE,EAAE,EACb,QAAQ,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC,CAAC,GACpD,OAAO,CAAC,eAAe,CAAC;IAK3B,6FAA6F;IAChF,QAAQ;IAUrB;;;OAGG;IACI,gBAAgB,IAAI,MAAM;IAIjC;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAQvC;;;;;OAKG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IAQ1E;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAI5D;;;;;OAKG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

package/dest/contract/complete_address.js

@@ -0,0 +1,117 @@
+import { Fr } from '@aztec/foundation/fields';
+import { hexSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex } from '@aztec/foundation/string';
+import { AztecAddress } from '../aztec-address/index.js';
+import { computeAddress, computePreaddress, deriveKeys } from '../keys/index.js';
+import { PublicKeys } from '../keys/public_keys.js';
+import { computePartialAddress } from './contract_address.js';
+/**
+ * A complete address is a combination of an Aztec address, a public key and a partial address.
+ *
+ * @remarks We have introduced this type because it is common that these 3 values are used together. They are commonly
+ *          used together because it is the information needed to send user a note.
+ * @remarks See the link below for details about how address is computed:
+ *          https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
+ */ export class CompleteAddress {
+    address;
+    publicKeys;
+    partialAddress;
+    constructor(/** Contract address (typically of an account contract) */ address, /** User public keys */ publicKeys, /** Partial key corresponding to the public key to the address. */ partialAddress){
+        this.address = address;
+        this.publicKeys = publicKeys;
+        this.partialAddress = partialAddress;
+    }
+    static async create(address, publicKeys, partialAddress) {
+        const completeAddress = new CompleteAddress(address, publicKeys, partialAddress);
+        await completeAddress.validate();
+        return completeAddress;
+    }
+    /** Size in bytes of an instance */ static SIZE_IN_BYTES = 32 * 10;
+    static get schema() {
+        return hexSchemaFor(CompleteAddress);
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static async random() {
+        return await this.fromSecretKeyAndPartialAddress(Fr.random(), Fr.random());
+    }
+    static async fromSecretKeyAndPartialAddress(secretKey, partialAddress) {
+        const { publicKeys } = await deriveKeys(secretKey);
+        const address = await computeAddress(publicKeys, partialAddress);
+        return new CompleteAddress(address, publicKeys, partialAddress);
+    }
+    async getPreaddress() {
+        return computePreaddress(await this.publicKeys.hash(), this.partialAddress);
+    }
+    static async fromSecretKeyAndInstance(secretKey, instance) {
+        const partialAddress = await computePartialAddress(instance);
+        return CompleteAddress.fromSecretKeyAndPartialAddress(secretKey, partialAddress);
+    }
+    /** Throws if the address is not correctly derived from the public key and partial address.*/ async validate() {
+        const expectedAddress = await computeAddress(this.publicKeys, this.partialAddress);
+        if (!expectedAddress.equals(this.address)) {
+            throw new Error(`Address cannot be derived from public keys and partial address (received ${this.address.toString()}, derived ${expectedAddress.toString()})`);
+        }
+    }
+    /**
+   * Gets a readable string representation of the complete address.
+   * @returns A readable string representation of the complete address.
+   */ toReadableString() {
+        return `Address: ${this.address.toString()}\nMaster Nullifier Public Key: ${this.publicKeys.masterNullifierPublicKey.toString()}\nMaster Incoming Viewing Public Key: ${this.publicKeys.masterIncomingViewingPublicKey.toString()}\nMaster Outgoing Viewing Public Key: ${this.publicKeys.masterOutgoingViewingPublicKey.toString()}\nMaster Tagging Public Key: ${this.publicKeys.masterTaggingPublicKey.toString()}\nPartial Address: ${this.partialAddress.toString()}\n`;
+    }
+    /**
+   * Determines if this CompleteAddress instance is equal to the given CompleteAddress instance.
+   * Equality is based on the content of their respective buffers.
+   *
+   * @param other - The CompleteAddress instance to compare against.
+   * @returns True if the buffers of both instances are equal, false otherwise.
+   */ equals(other) {
+        return this.address.equals(other.address) && this.publicKeys.equals(other.publicKeys) && this.partialAddress.equals(other.partialAddress);
+    }
+    /**
+   * Converts the CompleteAddress instance into a Buffer.
+   * This method should be used when encoding the address for storage, transmission or serialization purposes.
+   *
+   * @returns A Buffer representation of the CompleteAddress instance.
+   */ toBuffer() {
+        return serializeToBuffer([
+            this.address,
+            this.publicKeys,
+            this.partialAddress
+        ]);
+    }
+    /**
+   * Creates an CompleteAddress instance from a given buffer or BufferReader.
+   * If the input is a Buffer, it wraps it in a BufferReader before processing.
+   * Throws an error if the input length is not equal to the expected size.
+   *
+   * @param buffer - The input buffer or BufferReader containing the address data.
+   * @returns - A new CompleteAddress instance with the extracted address data.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const address = reader.readObject(AztecAddress);
+        const publicKeys = reader.readObject(PublicKeys);
+        const partialAddress = reader.readObject(Fr);
+        return CompleteAddress.create(address, publicKeys, partialAddress);
+    }
+    /**
+   * Create a CompleteAddress instance from a hex-encoded string.
+   * The input 'address' should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
+   * Throws an error if the input length is invalid or coordinate values are out of range.
+   *
+   * @param address - The hex-encoded string representing the complete address.
+   * @returns A Point instance.
+   */ static fromString(address) {
+        return CompleteAddress.fromBuffer(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+    }
+    /**
+   * Convert the CompleteAddress to a hexadecimal string representation, with a "0x" prefix.
+   * The resulting string will have a length of 66 characters (including the prefix).
+   *
+   * @returns A hexadecimal string representation of the CompleteAddress.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+}

package/dest/contract/contract_address.d.ts

@@ -0,0 +1,45 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type FunctionAbi, FunctionSelector } from '../abi/index.js';
+import type { AztecAddress } from '../aztec-address/index.js';
+import type { ContractInstance } from './interfaces/contract_instance.js';
+/**
+ * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * ```
+ * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
+ * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)
+ * address = ((poseidon2Hash([public_keys_hash, partial_address, GENERATOR__CONTRACT_ADDRESS_V1]) * G) + ivpk_m).x <- the x-coordinate of the address point
+ * ```
+ * @param instance - A contract instance for which to calculate the deployment address.
+ */
+export declare function computeContractAddressFromInstance(instance: ContractInstance | ({
+    originalContractClassId: Fr;
+    saltedInitializationHash: Fr;
+} & Pick<ContractInstance, 'publicKeys'>)): Promise<AztecAddress>;
+/**
+ * Computes the partial address defined as the hash of the contract class id and salted initialization hash.
+ * @param instance - Contract instance for which to calculate the partial address.
+ */
+export declare function computePartialAddress(instance: Pick<ContractInstance, 'originalContractClassId' | 'initializationHash' | 'salt' | 'deployer'> | {
+    originalContractClassId: Fr;
+    saltedInitializationHash: Fr;
+}): Promise<Fr>;
+/**
+ * Computes the salted initialization hash for an address, defined as the hash of the salt and initialization hash.
+ * @param instance - Contract instance for which to compute the salted initialization hash.
+ */
+export declare function computeSaltedInitializationHash(instance: Pick<ContractInstance, 'initializationHash' | 'salt' | 'deployer'>): Promise<Fr>;
+/**
+ * Computes the initialization hash for an instance given its constructor function and arguments.
+ * @param initFn - Constructor function or empty if no initialization is expected.
+ * @param args - Unencoded arguments, will be encoded as fields according to the constructor function abi.
+ * @returns The hash, or zero if no initialization function is provided.
+ */
+export declare function computeInitializationHash(initFn: FunctionAbi | undefined, args: any[]): Promise<Fr>;
+/**
+ * Computes the initialization hash for an instance given its constructor function selector and encoded arguments.
+ * @param initFn - Constructor function selector.
+ * @param args - Encoded arguments.
+ * @returns The hash.
+ */
+export declare function computeInitializationHashFromEncodedArgs(initFn: FunctionSelector, encodedArgs: Fr[]): Promise<Fr>;
+//# sourceMappingURL=contract_address.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_address.d.ts","sourceRoot":"","sources":["../../src/contract/contract_address.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,WAAW,EAAE,gBAAgB,EAAmB,MAAM,iBAAiB,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAI1E;;;;;;;;GAQG;AACH,wBAAsB,kCAAkC,CACtD,QAAQ,EACJ,gBAAgB,GAChB,CAAC;IAAE,uBAAuB,EAAE,EAAE,CAAC;IAAC,wBAAwB,EAAE,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC,GACzG,OAAO,CAAC,YAAY,CAAC,CAGvB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EACJ,IAAI,CAAC,gBAAgB,EAAE,yBAAyB,GAAG,oBAAoB,GAAG,MAAM,GAAG,UAAU,CAAC,GAC9F;IAAE,uBAAuB,EAAE,EAAE,CAAC;IAAC,wBAAwB,EAAE,EAAE,CAAA;CAAE,GAChE,OAAO,CAAC,EAAE,CAAC,CAUb;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,oBAAoB,GAAG,MAAM,GAAG,UAAU,CAAC,GAC3E,OAAO,CAAC,EAAE,CAAC,CAKb;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAOzG;AAED;;;;;GAKG;AACH,wBAAsB,wCAAwC,CAC5D,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,EAAE,EAAE,GAChB,OAAO,CAAC,EAAE,CAAC,CAGb"}

package/dest/contract/contract_address.js

@@ -0,0 +1,64 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { FunctionSelector, encodeArguments } from '../abi/index.js';
+import { computeVarArgsHash } from '../hash/hash.js';
+import { computeAddress } from '../keys/index.js';
+// TODO(@spalladino): Review all generator indices in this file
+/**
+ * Returns the deployment address for a given contract instance as defined on the [Protocol Specs](../../../../docs/docs/protocol-specs/addresses-and-keys/specification.md).
+ * ```
+ * salted_initialization_hash = pedersen([salt, initialization_hash, deployer], GENERATOR__SALTED_INITIALIZATION_HASH)
+ * partial_address = pedersen([contract_class_id, salted_initialization_hash], GENERATOR__CONTRACT_PARTIAL_ADDRESS_V1)
+ * address = ((poseidon2Hash([public_keys_hash, partial_address, GENERATOR__CONTRACT_ADDRESS_V1]) * G) + ivpk_m).x <- the x-coordinate of the address point
+ * ```
+ * @param instance - A contract instance for which to calculate the deployment address.
+ */ export async function computeContractAddressFromInstance(instance) {
+    const partialAddress = await computePartialAddress(instance);
+    return computeAddress(instance.publicKeys, partialAddress);
+}
+/**
+ * Computes the partial address defined as the hash of the contract class id and salted initialization hash.
+ * @param instance - Contract instance for which to calculate the partial address.
+ */ export async function computePartialAddress(instance) {
+    const saltedInitializationHash = 'saltedInitializationHash' in instance ? instance.saltedInitializationHash : await computeSaltedInitializationHash(instance);
+    return poseidon2HashWithSeparator([
+        instance.originalContractClassId,
+        saltedInitializationHash
+    ], GeneratorIndex.PARTIAL_ADDRESS);
+}
+/**
+ * Computes the salted initialization hash for an address, defined as the hash of the salt and initialization hash.
+ * @param instance - Contract instance for which to compute the salted initialization hash.
+ */ export function computeSaltedInitializationHash(instance) {
+    return poseidon2HashWithSeparator([
+        instance.salt,
+        instance.initializationHash,
+        instance.deployer
+    ], GeneratorIndex.PARTIAL_ADDRESS);
+}
+/**
+ * Computes the initialization hash for an instance given its constructor function and arguments.
+ * @param initFn - Constructor function or empty if no initialization is expected.
+ * @param args - Unencoded arguments, will be encoded as fields according to the constructor function abi.
+ * @returns The hash, or zero if no initialization function is provided.
+ */ export async function computeInitializationHash(initFn, args) {
+    if (!initFn) {
+        return Fr.ZERO;
+    }
+    const selector = await FunctionSelector.fromNameAndParameters(initFn.name, initFn.parameters);
+    const flatArgs = encodeArguments(initFn, args);
+    return computeInitializationHashFromEncodedArgs(selector, flatArgs);
+}
+/**
+ * Computes the initialization hash for an instance given its constructor function selector and encoded arguments.
+ * @param initFn - Constructor function selector.
+ * @param args - Encoded arguments.
+ * @returns The hash.
+ */ export async function computeInitializationHashFromEncodedArgs(initFn, encodedArgs) {
+    const argsHash = await computeVarArgsHash(encodedArgs);
+    return poseidon2HashWithSeparator([
+        initFn,
+        argsHash
+    ], GeneratorIndex.CONSTRUCTOR);
+}

package/dest/contract/contract_class.d.ts

@@ -0,0 +1,17 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type ContractArtifact, type FunctionArtifact } from '../abi/index.js';
+import { type ContractClassIdPreimage } from './contract_class_id.js';
+import type { ContractClass, ContractClassWithId } from './interfaces/index.js';
+/** Contract artifact including its artifact hash */
+type ContractArtifactWithHash = ContractArtifact & {
+    artifactHash: Fr;
+};
+/** Creates a ContractClass from a contract compilation artifact. */
+export declare function getContractClassFromArtifact(artifact: ContractArtifact | ContractArtifactWithHash): Promise<ContractClassWithId & ContractClassIdPreimage>;
+export declare function getContractClassPrivateFunctionFromArtifact(f: FunctionArtifact): Promise<ContractClass['privateFunctions'][number]>;
+/**
+ * For a given private function, computes the hash of its vk.
+ */
+export declare function computeVerificationKeyHash(f: FunctionArtifact): Promise<Fr>;
+export {};
+//# sourceMappingURL=contract_class.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_class.d.ts","sourceRoot":"","sources":["../../src/contract/contract_class.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAkC,MAAM,iBAAiB,CAAC;AAG/G,OAAO,EAAE,KAAK,uBAAuB,EAAsC,MAAM,wBAAwB,CAAC;AAC1G,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAkB,MAAM,uBAAuB,CAAC;AAEhG,oDAAoD;AACpD,KAAK,wBAAwB,GAAG,gBAAgB,GAAG;IAAE,YAAY,EAAE,EAAE,CAAA;CAAE,CAAC;AAKxE,oEAAoE;AACpE,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GACpD,OAAO,CAAC,mBAAmB,GAAG,uBAAuB,CAAC,CA0CxD;AAED,wBAAsB,2CAA2C,CAC/D,CAAC,EAAE,gBAAgB,GAClB,OAAO,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,CAKpD;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAAC,CAAC,EAAE,gBAAgB,eAKnE"}

package/dest/contract/contract_class.js

@@ -0,0 +1,57 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { FunctionSelector, FunctionType } from '../abi/index.js';
+import { hashVK } from '../hash/hash.js';
+import { computeArtifactHash } from './artifact_hash.js';
+import { computeContractClassIdWithPreimage } from './contract_class_id.js';
+const cmpFunctionArtifacts = (a, b)=>a.selector.toField().cmp(b.selector.toField());
+/** Creates a ContractClass from a contract compilation artifact. */ export async function getContractClassFromArtifact(artifact) {
+    const artifactHash = 'artifactHash' in artifact ? artifact.artifactHash : await computeArtifactHash(artifact);
+    const publicFunctions = artifact.functions.filter((f)=>f.functionType === FunctionType.PUBLIC);
+    const artifactPublicFunctions = await Promise.all(publicFunctions.map(async (f)=>({
+            selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+            bytecode: f.bytecode
+        })));
+    artifactPublicFunctions.sort(cmpFunctionArtifacts);
+    let packedBytecode = Buffer.alloc(0);
+    let dispatchFunction = undefined;
+    if (artifactPublicFunctions.length > 0) {
+        dispatchFunction = artifactPublicFunctions.find((f)=>f.selector.equals(FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR))));
+        if (!dispatchFunction) {
+            throw new Error(`A contract with public functions should define a public_dispatch(Field) function as its public entrypoint. Contract: ${artifact.name}`);
+        }
+        packedBytecode = dispatchFunction.bytecode;
+    }
+    const privateFunctions = artifact.functions.filter((f)=>f.functionType === FunctionType.PRIVATE);
+    const privateArtifactFunctions = await Promise.all(privateFunctions.map(getContractClassPrivateFunctionFromArtifact));
+    privateArtifactFunctions.sort(cmpFunctionArtifacts);
+    const contractClass = {
+        version: 1,
+        artifactHash,
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
+        publicFunctions: dispatchFunction ? [
+            dispatchFunction
+        ] : [],
+        packedBytecode,
+        privateFunctions: privateArtifactFunctions
+    };
+    return {
+        ...contractClass,
+        ...await computeContractClassIdWithPreimage(contractClass)
+    };
+}
+export async function getContractClassPrivateFunctionFromArtifact(f) {
+    return {
+        selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+        vkHash: await computeVerificationKeyHash(f)
+    };
+}
+/**
+ * For a given private function, computes the hash of its vk.
+ */ export async function computeVerificationKeyHash(f) {
+    if (!f.verificationKey) {
+        throw new Error(`Private function ${f.name} must have a verification key`);
+    }
+    return hashVK(await vkAsFieldsMegaHonk(Buffer.from(f.verificationKey, 'base64')));
+}

package/dest/contract/contract_class_id.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractClass } from './interfaces/contract_class.js';
+/**
+ * Returns the id of a contract class computed as its hash.
+ *
+ * ```
+ * version = 1
+ * private_function_leaves = private_functions.map(fn => pedersen([fn.function_selector as Field, fn.vk_hash], GENERATOR__FUNCTION_LEAF))
+ * private_functions_root = merkleize(private_function_leaves)
+ * bytecode_commitment = calculate_commitment(packed_bytecode)
+ * contract_class_id = pedersen([version, artifact_hash, private_functions_root, bytecode_commitment], GENERATOR__CLASS_IDENTIFIER)
+ * ```
+ * @param contractClass - Contract class.
+ * @returns The identifier.
+ */
+export declare function computeContractClassId(contractClass: ContractClass | ContractClassIdPreimage): Promise<Fr>;
+/** Computes a contract class id and returns it along with its preimage. */
+export declare function computeContractClassIdWithPreimage(contractClass: ContractClass | ContractClassIdPreimage): Promise<ContractClassIdPreimage & {
+    id: Fr;
+}>;
+/** Returns the preimage of a contract class id given a contract class. */
+export declare function computeContractClassIdPreimage(contractClass: ContractClass): Promise<ContractClassIdPreimage>;
+/** Preimage of a contract class id. */
+export type ContractClassIdPreimage = {
+    artifactHash: Fr;
+    privateFunctionsRoot: Fr;
+    publicBytecodeCommitment: Fr;
+};
+export declare function computePublicBytecodeCommitment(packedBytecode: Buffer): Promise<Fr>;
+//# sourceMappingURL=contract_class_id.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_class_id.d.ts","sourceRoot":"","sources":["../../src/contract/contract_class_id.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAK9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAGpE;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAAC,aAAa,EAAE,aAAa,GAAG,uBAAuB,GAAG,OAAO,CAAC,EAAE,CAAC,CAEhH;AAED,2EAA2E;AAC3E,wBAAsB,kCAAkC,CACtD,aAAa,EAAE,aAAa,GAAG,uBAAuB,GACrD,OAAO,CAAC,uBAAuB,GAAG;IAAE,EAAE,EAAE,EAAE,CAAA;CAAE,CAAC,CAe/C;AAED,0EAA0E;AAC1E,wBAAsB,8BAA8B,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAInH;AAED,uCAAuC;AACvC,MAAM,MAAM,uBAAuB,GAAG;IACpC,YAAY,EAAE,EAAE,CAAC;IACjB,oBAAoB,EAAE,EAAE,CAAC;IACzB,wBAAwB,EAAE,EAAE,CAAC;CAC9B,CAAC;AAEF,wBAAsB,+BAA+B,CAAC,cAAc,EAAE,MAAM,eAQ3E"}

package/dest/contract/contract_class_id.js

@@ -0,0 +1,54 @@
+import { GeneratorIndex, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS } from '@aztec/constants';
+import { poseidon2HashAccumulate, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { strict as assert } from 'assert';
+import { bufferAsFields } from '../abi/index.js';
+import { computePrivateFunctionsRoot } from './private_function.js';
+/**
+ * Returns the id of a contract class computed as its hash.
+ *
+ * ```
+ * version = 1
+ * private_function_leaves = private_functions.map(fn => pedersen([fn.function_selector as Field, fn.vk_hash], GENERATOR__FUNCTION_LEAF))
+ * private_functions_root = merkleize(private_function_leaves)
+ * bytecode_commitment = calculate_commitment(packed_bytecode)
+ * contract_class_id = pedersen([version, artifact_hash, private_functions_root, bytecode_commitment], GENERATOR__CLASS_IDENTIFIER)
+ * ```
+ * @param contractClass - Contract class.
+ * @returns The identifier.
+ */ export async function computeContractClassId(contractClass) {
+    return (await computeContractClassIdWithPreimage(contractClass)).id;
+}
+/** Computes a contract class id and returns it along with its preimage. */ export async function computeContractClassIdWithPreimage(contractClass) {
+    const artifactHash = contractClass.artifactHash;
+    const privateFunctionsRoot = 'privateFunctionsRoot' in contractClass ? contractClass.privateFunctionsRoot : await computePrivateFunctionsRoot(contractClass.privateFunctions);
+    const publicBytecodeCommitment = 'publicBytecodeCommitment' in contractClass ? contractClass.publicBytecodeCommitment : await computePublicBytecodeCommitment(contractClass.packedBytecode);
+    const id = await poseidon2HashWithSeparator([
+        artifactHash,
+        privateFunctionsRoot,
+        publicBytecodeCommitment
+    ], GeneratorIndex.CONTRACT_LEAF);
+    return {
+        id,
+        artifactHash,
+        privateFunctionsRoot,
+        publicBytecodeCommitment
+    };
+}
+/** Returns the preimage of a contract class id given a contract class. */ export async function computeContractClassIdPreimage(contractClass) {
+    const privateFunctionsRoot = await computePrivateFunctionsRoot(contractClass.privateFunctions);
+    const publicBytecodeCommitment = await computePublicBytecodeCommitment(contractClass.packedBytecode);
+    return {
+        artifactHash: contractClass.artifactHash,
+        privateFunctionsRoot,
+        publicBytecodeCommitment
+    };
+}
+export async function computePublicBytecodeCommitment(packedBytecode) {
+    // Encode the buffer into field elements (chunked into 32 bytes each)
+    const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
+    // The first element is the length of the bytecode (in bytes)
+    const bytecodeLength = Math.ceil(encodedBytecode[0].toNumber() / (Fr.SIZE_IN_BYTES - 1));
+    assert(bytecodeLength < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, 'Bytecode exceeds maximum deployable size');
+    return bytecodeLength == 0 ? new Fr(0) : await poseidon2HashAccumulate(encodedBytecode.slice(0, bytecodeLength + 1));
+}

package/dest/contract/contract_function_dao.d.ts

@@ -0,0 +1,13 @@
+import type { FunctionArtifact, FunctionSelector } from '../abi/index.js';
+/**
+ * A contract function Data Access Object (DAO).
+ * Extends the FunctionArtifact interface, adding a 'selector' property.
+ * The 'selector' is a unique identifier for the function within the contract.
+ */
+export interface ContractFunctionDao extends FunctionArtifact {
+    /**
+     * Unique identifier for a contract function.
+     */
+    selector: FunctionSelector;
+}
+//# sourceMappingURL=contract_function_dao.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_function_dao.d.ts","sourceRoot":"","sources":["../../src/contract/contract_function_dao.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE1E;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;CAC5B"}

package/dest/contract/contract_function_dao.js

@@ -0,0 +1,5 @@
+/**
+ * A contract function Data Access Object (DAO).
+ * Extends the FunctionArtifact interface, adding a 'selector' property.
+ * The 'selector' is a unique identifier for the function within the contract.
+ */ export { };

package/dest/contract/contract_instance.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { type ContractArtifact, type FunctionArtifact } from '../abi/index.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { PublicKeys } from '../keys/public_keys.js';
+import type { ContractInstance, ContractInstanceWithAddress } from './interfaces/contract_instance.js';
+export declare class SerializableContractInstance {
+    readonly version: 1;
+    readonly salt: Fr;
+    readonly deployer: AztecAddress;
+    readonly currentContractClassId: Fr;
+    readonly originalContractClassId: Fr;
+    readonly initializationHash: Fr;
+    readonly publicKeys: PublicKeys;
+    constructor(instance: ContractInstance);
+    toBuffer(): Buffer;
+    /** Returns a copy of this object with its address included. */
+    withAddress(address: AztecAddress): ContractInstanceWithAddress;
+    static fromBuffer(bufferOrReader: Buffer | BufferReader): SerializableContractInstance;
+    static random(opts?: Partial<FieldsOf<ContractInstance>>): Promise<SerializableContractInstance>;
+    static default(): SerializableContractInstance;
+}
+/**
+ * Generates a Contract Instance from the deployment params.
+ * @param artifact - The account contract build artifact.
+ * @param opts - Options for the deployment.
+ * @returns - The contract instance
+ */
+export declare function getContractInstanceFromDeployParams(artifact: ContractArtifact, opts: {
+    constructorArtifact?: FunctionArtifact | string;
+    constructorArgs?: any[];
+    skipArgsDecoding?: boolean;
+    salt?: Fr;
+    publicKeys?: PublicKeys;
+    deployer?: AztecAddress;
+}): Promise<ContractInstanceWithAddress>;
+//# sourceMappingURL=contract_instance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_instance.d.ts","sourceRoot":"","sources":["../../src/contract/contract_instance.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAiC,MAAM,6BAA6B,CAAC;AAC1F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAA2C,MAAM,iBAAiB,CAAC;AACxH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAMpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAIvG,qBAAa,4BAA4B;IACvC,SAAgB,OAAO,IAAW;IAClC,SAAgB,IAAI,EAAE,EAAE,CAAC;IACzB,SAAgB,QAAQ,EAAE,YAAY,CAAC;IACvC,SAAgB,sBAAsB,EAAE,EAAE,CAAC;IAC3C,SAAgB,uBAAuB,EAAE,EAAE,CAAC;IAC5C,SAAgB,kBAAkB,EAAE,EAAE,CAAC;IACvC,SAAgB,UAAU,EAAE,UAAU,CAAC;gBAE3B,QAAQ,EAAE,gBAAgB;IAY/B,QAAQ;IAYf,+DAA+D;IAC/D,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,2BAA2B;IAI/D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY;WAa1C,MAAM,CAAC,IAAI,GAAE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAM;IAalE,MAAM,CAAC,OAAO;CAWf;AAED;;;;;GAKG;AACH,wBAAsB,mCAAmC,CACvD,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE;IACJ,mBAAmB,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IAChD,eAAe,CAAC,EAAE,GAAG,EAAE,CAAC;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,IAAI,CAAC,EAAE,EAAE,CAAC;IACV,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB,GACA,OAAO,CAAC,2BAA2B,CAAC,CA0BtC"}