@aztec-labs/aztec.js 6.0.0-nightly.20260829

package/dest/contract/batch_call.js

@@ -0,0 +1,152 @@
+import { FunctionType, decodeFromAbi } from '@aztec-labs/stdlib/abi';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec-labs/stdlib/tx';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+import { NO_FROM, extractOffchainOutput, toSimulateOptions } from './interaction_options.js';
+/** A batch of function calls to be sent as a single transaction through a wallet. */ // docs:start:batch_call_class
+export class BatchCall extends BaseContractInteraction {
+    interactions;
+    extraHashedArgs;
+    constructor(wallet, interactions, extraHashedArgs = []){
+        super(wallet), this.interactions = interactions, this.extraHashedArgs = extraHashedArgs;
+    }
+    // docs:end:batch_call_class
+    /**
+   * Returns an execution request that represents this operation.
+   * @param options - An optional object containing additional configuration for the request generation.
+   * @returns An execution payload wrapped in promise.
+   */ async request(options = {}) {
+        const requests = await this.getExecutionPayloads();
+        const feeExecutionPayload = options.fee?.paymentMethod ? await options.fee.paymentMethod.getExecutionPayload() : undefined;
+        const { authWitnesses, capsules } = options;
+        // Propagates the included authwitnesses, capsules, and extraHashedArgs potentially baked into the interaction
+        const initialExecutionPayload = new ExecutionPayload([], this.authWitnesses.concat(authWitnesses ?? []), this.capsules.concat(capsules ?? []), this.extraHashedArgs);
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            initialExecutionPayload,
+            feeExecutionPayload,
+            ...requests
+        ]) : mergeExecutionPayloads([
+            initialExecutionPayload,
+            ...requests
+        ]);
+        return finalExecutionPayload;
+    }
+    /**
+   * Simulates/executes the batch, supporting private, public and utility functions. Although this is a single
+   * interaction with the wallet, private and public functions will be grouped into a single ExecutionPayload
+   * that the wallet will simulate as a single transaction. Utility function calls will be executed
+   * one by one.
+   * @param options - An optional object containing additional configuration for the interaction.
+   * @returns The results of all the interactions that make up the batch
+   */ async simulate(options) {
+        const feeExecutionPayload = options.fee?.paymentMethod ? await options.fee.paymentMethod.getExecutionPayload() : undefined;
+        // A call-contributing fee payment method prepends its calls in front of the batch (see the merge below). Those
+        // calls shift the return-value indices, and the wallet-side app-call offset does not absorb them: it only counts
+        // the wallet's own fee payment method, not one supplied through options.fee. We offset each app call's result
+        // index by the number of prepended fee calls of the matching type.
+        const feePrivateCallCount = feeExecutionPayload?.calls.filter((c)=>c.type === FunctionType.PRIVATE).length ?? 0;
+        const feePublicCallCount = feeExecutionPayload?.calls.filter((c)=>c.type === FunctionType.PUBLIC).length ?? 0;
+        const { indexedExecutionPayloads, utility } = (await this.getExecutionPayloads()).reduce((acc, current, index)=>{
+            const call = current.calls[0];
+            if (call.type === FunctionType.UTILITY) {
+                acc.utility.push([
+                    call,
+                    index
+                ]);
+            } else {
+                acc.indexedExecutionPayloads.push([
+                    current,
+                    index,
+                    call.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++
+                ]);
+            }
+            return acc;
+        }, {
+            indexedExecutionPayloads: [],
+            utility: [],
+            publicIndex: 0,
+            privateIndex: 0
+        });
+        const batchRequests = [];
+        // Add utility calls to batch
+        for (const [call] of utility){
+            batchRequests.push({
+                name: 'executeUtility',
+                args: [
+                    call,
+                    {
+                        scopes: options.from === NO_FROM ? [] : [
+                            options.from
+                        ],
+                        authWitnesses: options.authWitnesses
+                    }
+                ]
+            });
+        }
+        // Add tx simulation to batch if there are any private/public calls
+        if (indexedExecutionPayloads.length > 0) {
+            const payloads = indexedExecutionPayloads.map(([request])=>request);
+            const combinedPayload = mergeExecutionPayloads(feeExecutionPayload ? [
+                feeExecutionPayload,
+                ...payloads
+            ] : payloads);
+            const executionPayload = new ExecutionPayload(combinedPayload.calls, combinedPayload.authWitnesses.concat(options.authWitnesses ?? []), combinedPayload.capsules.concat(options.capsules ?? []), combinedPayload.extraHashedArgs, combinedPayload.feePayer);
+            batchRequests.push({
+                name: 'simulateTx',
+                args: [
+                    executionPayload,
+                    toSimulateOptions(options)
+                ]
+            });
+        }
+        const batchResults = batchRequests.length > 0 ? await this.wallet.batch(batchRequests) : [];
+        const results = [];
+        // Process utility results (they come first in batch results)
+        for(let i = 0; i < utility.length; i++){
+            const [call, resultIndex] = utility[i];
+            const wrappedResult = batchResults[i];
+            if (wrappedResult.name === 'executeUtility') {
+                const utilityResult = wrappedResult.result;
+                const rawReturnValues = utilityResult.result;
+                const offchainOutput = extractOffchainOutput(utilityResult.offchainEffects, utilityResult.anchorBlockTimestamp);
+                results[resultIndex] = {
+                    result: rawReturnValues ? decodeFromAbi(call.returnType, rawReturnValues) : undefined,
+                    ...offchainOutput
+                };
+            }
+        }
+        // Process tx simulation result (it comes last if present)
+        let simulatedTx;
+        if (indexedExecutionPayloads.length > 0) {
+            const txResultWrapper = batchResults[utility.length];
+            if (txResultWrapper.name === 'simulateTx') {
+                simulatedTx = txResultWrapper.result;
+                indexedExecutionPayloads.forEach(([request, callIndex, resultIndex])=>{
+                    const call = request.calls[0];
+                    // For public functions we retrieve the values directly from the public output. Both indices are offset by
+                    // the fee payment method's own calls, which are prepended ahead of the batch.
+                    const rawReturnValues = call.type == FunctionType.PRIVATE ? simulatedTx.getPrivateReturnValuesOfAppCall(feePrivateCallCount + resultIndex)?.values : simulatedTx.getPublicReturnValues()?.[feePublicCallCount + resultIndex].values;
+                    results[callIndex] = {
+                        result: rawReturnValues ? decodeFromAbi(call.returnType, rawReturnValues) : undefined,
+                        ...extractOffchainOutput(simulatedTx.offchainEffects, simulatedTx.publicInputs.constants.anchorBlockHeader.globalVariables.timestamp)
+                    };
+                });
+            }
+        }
+        if (options.includeMetadata && simulatedTx) {
+            return {
+                result: results,
+                gasUsed: simulatedTx.gasUsed,
+                offchainEffects: [],
+                offchainMessages: []
+            };
+        }
+        return {
+            result: results,
+            offchainEffects: [],
+            offchainMessages: []
+        };
+    }
+    async getExecutionPayloads() {
+        return await Promise.all(this.interactions.map((i)=>i instanceof ExecutionPayload ? i : i.request()));
+    }
+}

package/dest/contract/checker.d.ts

@@ -0,0 +1,11 @@
+import { type ContractArtifact } from '@aztec-labs/stdlib/abi';
+/**
+ * Validates the given ContractArtifact object by checking its functions and their parameters.
+ * Ensures that the ABI has at least one function, a constructor, valid bytecode, and correct parameter types.
+ * Throws an error if any inconsistency is detected during the validation process.
+ *
+ * @param artifact - The ContractArtifact object to be validated.
+ * @returns A boolean value indicating whether the artifact is valid or not.
+ */
+export declare function abiChecker(artifact: ContractArtifact): boolean;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NoZWNrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUdMLEtBQUssZ0JBQWdCLEVBR3RCLE1BQU0sd0JBQXdCLENBQUM7QUFRaEM7Ozs7Ozs7R0FPRztBQUNILHdCQUFnQixVQUFVLENBQUMsUUFBUSxFQUFFLGdCQUFnQixXQTZCcEQifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../../src/contract/checker.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EAGtB,MAAM,wBAAwB,CAAC;AAQhC;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,gBAAgB,WA6BpD"}

package/dest/contract/checker.js

@@ -0,0 +1,107 @@
+import { getDefaultInitializer } from '@aztec-labs/stdlib/abi';
+/**
+ * Validates the given ContractArtifact object by checking its functions and their parameters.
+ * Ensures that the ABI has at least one function, a constructor, valid bytecode, and correct parameter types.
+ * Throws an error if any inconsistency is detected during the validation process.
+ *
+ * @param artifact - The ContractArtifact object to be validated.
+ * @returns A boolean value indicating whether the artifact is valid or not.
+ */ export function abiChecker(artifact) {
+    if (!artifact.functions || artifact.functions.length === 0) {
+        throw new Error('artifact has no functions');
+    }
+    artifact.functions.forEach((func)=>{
+        if (!('name' in func && typeof func.name === 'string' && func.name.length > 0)) {
+            throw new Error('ABI function has no name');
+        }
+        // TODO: implement a better check for bytecode (right now only checks if it's > 0)
+        if (!('bytecode' in func && func.bytecode.length > 0)) {
+            throw new Error('ABI function parameter has incorrect bytecode');
+        }
+        func.parameters.forEach((param)=>{
+            if (!param.type) {
+                throw new Error('ABI function parameter has no type');
+            }
+            abiParameterTypeChecker(param.type);
+        });
+    });
+    if (!getDefaultInitializer(artifact)) {
+        throw new Error('ABI has no constructor');
+    }
+    return true;
+}
+/**
+ * Validates the ABI function parameter's type by checking its kind and attributes.
+ * Throws an error if the type has an unrecognized kind or incorrectly formed attributes.
+ * Additionally, checks nested types for array and struct kinds.
+ *
+ * @param type - The AbiType object representing the type of the ABI function parameter.
+ * @returns A boolean value indicating whether the type is valid or not.
+ */ function abiParameterTypeChecker(type) {
+    switch(type.kind){
+        case 'field':
+        case 'boolean':
+            return checkAttributes(type, {});
+        case 'integer':
+            return checkAttributes(type, {
+                sign: 'string',
+                width: 'number'
+            });
+        case 'string':
+            return checkAttributes(type, {
+                length: 'number'
+            });
+        case 'array':
+            return checkAttributes(type, {
+                length: 'number',
+                type: 'object'
+            }) && abiParameterTypeChecker(type.type);
+        case 'struct':
+            return checkAttributes(type, {
+                fields: 'object',
+                path: 'string'
+            }) && checkStruct(type);
+        default:
+            throw new Error('ABI function parameter has an unrecognized type');
+    }
+}
+/**
+ * Check if the structure of the AbiType 'struct' is valid by ensuring field names are strings
+ * and their type attribute passes the abiParameterTypeChecker. Returns true on successful validation,
+ * otherwise throws an error providing insight into the incorrect formation in the struct.
+ *
+ * @param type - The StructType object containing an array of fields to validate.
+ * @returns A boolean value indicating successful validation of the struct's fields.
+ */ function checkStruct(type) {
+    return type.fields.reduce((acc, field)=>{
+        if (!('name' in field && typeof field.name === 'string')) {
+            throw new Error('ABI function parameter has an incorrectly formed struct');
+        }
+        return acc && abiParameterTypeChecker(field.type);
+    }, true);
+}
+/**
+ * Check if a provided ABI type has the correct attributes and their associated types.
+ * This function compares the given 'type' object's keys with the expected attribute types
+ * specified in 'incompleteAttributes', as well as the required 'kind' property.
+ * Throws an error if there are any unrecognized attributes or incorrect attribute types.
+ *
+ * @param type - The ABI type object to be checked for correct attributes.
+ * @param incompleteAttributes - An object representing the expected attribute types without the 'kind' property.
+ * @returns Returns true if the provided ABI type has the correct attributes and their associated types, otherwise throws an error.
+ */ function checkAttributes(type, incompleteAttributes) {
+    const typeKeys = Object.keys(type);
+    const attributes = {
+        ...incompleteAttributes,
+        kind: 'string'
+    };
+    if (typeKeys.length !== Object.keys(attributes).length) {
+        throw new Error(`Unrecognized attribute on type ${type.kind}`);
+    }
+    typeKeys.forEach((element)=>{
+        if (!(element in type && typeof type[element] === attributes[element])) {
+            throw new Error(`ABI function parameter has an incorrectly formed ${type.kind}`);
+        }
+    });
+    return true;
+}

package/dest/contract/contract.d.ts

@@ -0,0 +1,33 @@
+import type { ContractArtifact } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Wallet } from '../wallet/wallet.js';
+import { ContractBase } from './contract_base.js';
+import { type DeployInstantiationOptions, DeployMethod } from './deploy_method.js';
+/**
+ * The Contract class represents a contract and provides utility methods for interacting with it.
+ * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
+ * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
+ * to attach the contract instance to a deployed contract onchain through the PXE, which facilitates
+ * interaction with Aztec's privacy protocol.
+ */
+export declare class Contract extends ContractBase {
+    /**
+     * Gets a contract instance.
+     * @param address - The address of the contract instance.
+     * @param artifact - Build artifact of the contract.
+     * @param wallet - The wallet to use when interacting with the contract.
+     * @returns A promise that resolves to a new Contract instance.
+     */
+    static at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Contract;
+    /**
+     * Creates a tx to deploy (initialize and/or publish) a new instance of a contract.
+     *
+     * @param wallet - The wallet for executing the deployment.
+     * @param artifact - Build artifact of the contract to deploy
+     * @param args - Arguments for the constructor.
+     * @param constructorName - The name of the constructor function to call.
+     * @param instantiation - Other address-affecting parameters (salt, deployer / universalDeploy, publicKeys).
+     */
+    static deploy(wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string, instantiation?: DeployInstantiationOptions): DeployMethod<Contract>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250cmFjdC9jb250cmFjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQy9ELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBR3JFLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsS0FBSywwQkFBMEIsRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVuRjs7Ozs7O0dBTUc7QUFDSCxxQkFBYSxRQUFTLFNBQVEsWUFBWTtJQUN4Qzs7Ozs7O09BTUc7SUFDSCxPQUFjLEVBQUUsQ0FBQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLEVBQUUsTUFBTSxHQUFHLFFBQVEsQ0FFNUY7SUFFRDs7Ozs7Ozs7T0FRRztJQUNILE9BQWMsTUFBTSxDQUNsQixNQUFNLEVBQUUsTUFBTSxFQUNkLFFBQVEsRUFBRSxnQkFBZ0IsRUFDMUIsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUNYLGVBQWUsQ0FBQyxFQUFFLE1BQU0sRUFDeEIsYUFBYSxDQUFDLEVBQUUsMEJBQTBCLDBCQVMzQztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/contract/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,KAAK,0BAA0B,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEnF;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,YAAY;IACxC;;;;;;OAMG;IACH,OAAc,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAE5F;IAED;;;;;;;;OAQG;IACH,OAAc,MAAM,CAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,GAAG,EAAE,EACX,eAAe,CAAC,EAAE,MAAM,EACxB,aAAa,CAAC,EAAE,0BAA0B,0BAS3C;CACF"}

package/dest/contract/contract.js

@@ -0,0 +1,36 @@
+import { ContractBase } from './contract_base.js';
+import { DeployMethod } from './deploy_method.js';
+/**
+ * The Contract class represents a contract and provides utility methods for interacting with it.
+ * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
+ * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
+ * to attach the contract instance to a deployed contract onchain through the PXE, which facilitates
+ * interaction with Aztec's privacy protocol.
+ */ export class Contract extends ContractBase {
+    /**
+   * Gets a contract instance.
+   * @param address - The address of the contract instance.
+   * @param artifact - Build artifact of the contract.
+   * @param wallet - The wallet to use when interacting with the contract.
+   * @returns A promise that resolves to a new Contract instance.
+   */ static at(address, artifact, wallet) {
+        return new Contract(address, artifact, wallet);
+    }
+    /**
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract.
+   *
+   * @param wallet - The wallet for executing the deployment.
+   * @param artifact - Build artifact of the contract to deploy
+   * @param args - Arguments for the constructor.
+   * @param constructorName - The name of the constructor function to call.
+   * @param instantiation - Other address-affecting parameters (salt, deployer / universalDeploy, publicKeys).
+   */ static deploy(wallet, artifact, args, constructorName, instantiation) {
+        const postDeployCtor = (instance, wallet)=>Contract.at(instance.address, artifact, wallet);
+        return DeployMethod.create(wallet, {
+            artifact,
+            postDeployCtor,
+            args,
+            constructorNameOrArtifact: constructorName
+        }, instantiation);
+    }
+}

package/dest/contract/contract_base.d.ts

@@ -0,0 +1,51 @@
+import { type ContractArtifact, type FieldLayout, FunctionSelector } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Wallet } from '../wallet/wallet.js';
+import { ContractFunctionInteraction } from './contract_function_interaction.js';
+/**
+ * Type representing a contract method that returns a ContractFunctionInteraction instance
+ * and has a readonly 'selector' property of type Buffer. Takes any number of arguments.
+ */
+export type ContractMethod = ((...args: any[]) => ContractFunctionInteraction) & {
+    /**
+     * The unique identifier for a contract function in bytecode.
+     */
+    selector: () => Promise<FunctionSelector>;
+};
+/**
+ * Type representing the storage layout of a contract.
+ */
+export type ContractStorageLayout<T extends string> = {
+    [K in T]: FieldLayout;
+};
+/**
+ * Abstract implementation of a contract extended by the Contract class and generated contract types.
+ */
+export declare class ContractBase {
+    /** The contract's address. */
+    readonly address: AztecAddress;
+    /** The Application Binary Interface for the contract. */
+    readonly artifact: ContractArtifact;
+    /** The wallet used for interacting with this contract. */
+    wallet: Wallet;
+    /**
+     * An object containing contract methods mapped to their respective names.
+     */
+    methods: {
+        [name: string]: ContractMethod;
+    };
+    protected constructor(
+    /** The contract's address. */
+    address: AztecAddress, 
+    /** The Application Binary Interface for the contract. */
+    artifact: ContractArtifact, 
+    /** The wallet used for interacting with this contract. */
+    wallet: Wallet);
+    /**
+     * Creates a new instance of the contract wrapper attached to a different wallet.
+     * @param wallet - Wallet to use for sending txs.
+     * @returns A new contract instance.
+     */
+    withWallet(wallet: Wallet): this;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfYmFzZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0L2NvbnRyYWN0X2Jhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssV0FBVyxFQUVoQixnQkFBZ0IsRUFFakIsTUFBTSx3QkFBd0IsQ0FBQztBQUNoQyxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUVyRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUVqRjs7O0dBR0c7QUFDSCxNQUFNLE1BQU0sY0FBYyxHQUFHLENBQUMsQ0FBQyxHQUFHLElBQUksRUFBRSxHQUFHLEVBQUUsS0FBSywyQkFBMkIsQ0FBQyxHQUFHO0lBQy9FOztPQUVHO0lBQ0gsUUFBUSxFQUFFLE1BQU0sT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBQUM7Q0FDM0MsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxNQUFNLHFCQUFxQixDQUFDLENBQUMsU0FBUyxNQUFNLElBQUk7S0FDbkQsQ0FBQyxJQUFJLENBQUMsR0FBRyxXQUFXO0NBQ3RCLENBQUM7QUFFRjs7R0FFRztBQUNILHFCQUFhLFlBQVk7SUFPckIsOEJBQThCO2FBQ2QsT0FBTyxFQUFFLFlBQVk7SUFDckMseURBQXlEO2FBQ3pDLFFBQVEsRUFBRSxnQkFBZ0I7SUFDMUMsMERBQTBEO0lBQ25ELE1BQU0sRUFBRSxNQUFNO0lBWHZCOztPQUVHO0lBQ0ksT0FBTyxFQUFFO1FBQUUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLGNBQWMsQ0FBQTtLQUFFLENBQU07SUFFeEQsU0FBUztJQUNQLDhCQUE4QjtJQUNkLE9BQU8sRUFBRSxZQUFZO0lBQ3JDLHlEQUF5RDtJQUN6QyxRQUFRLEVBQUUsZ0JBQWdCO0lBQzFDLDBEQUEwRDtJQUNuRCxNQUFNLEVBQUUsTUFBTSxFQWlCdEI7SUFFRDs7OztPQUlHO0lBQ0ksVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUV0QztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_base.d.ts","sourceRoot":"","sources":["../../src/contract/contract_base.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEhB,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEjF;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,2BAA2B,CAAC,GAAG;IAC/E;;OAEG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC3C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,MAAM,IAAI;KACnD,CAAC,IAAI,CAAC,GAAG,WAAW;CACtB,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY;IAOrB,8BAA8B;aACd,OAAO,EAAE,YAAY;IACrC,yDAAyD;aACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM;IAXvB;;OAEG;IACI,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAM;IAExD,SAAS;IACP,8BAA8B;IACd,OAAO,EAAE,YAAY;IACrC,yDAAyD;IACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM,EAiBtB;IAED;;;;OAIG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEtC;CACF"}

package/dest/contract/contract_base.js

@@ -0,0 +1,38 @@
+import { FunctionSelector, getAllFunctionAbis } from '@aztec-labs/stdlib/abi';
+import { ContractFunctionInteraction } from './contract_function_interaction.js';
+/**
+ * Abstract implementation of a contract extended by the Contract class and generated contract types.
+ */ export class ContractBase {
+    address;
+    artifact;
+    wallet;
+    /**
+   * An object containing contract methods mapped to their respective names.
+   */ methods;
+    constructor(/** The contract's address. */ address, /** The Application Binary Interface for the contract. */ artifact, /** The wallet used for interacting with this contract. */ wallet){
+        this.address = address;
+        this.artifact = artifact;
+        this.wallet = wallet;
+        this.methods = {};
+        getAllFunctionAbis(artifact).forEach((f)=>{
+            const interactionFunction = (...args)=>{
+                return new ContractFunctionInteraction(this.wallet, this.address, f, args);
+            };
+            this.methods[f.name] = Object.assign(interactionFunction, {
+                /**
+         * A getter for users to fetch the function selector.
+         * @returns Selector of the function.
+         */ selector () {
+                    return FunctionSelector.fromNameAndParameters(f.name, f.parameters);
+                }
+            });
+        });
+    }
+    /**
+   * Creates a new instance of the contract wrapper attached to a different wallet.
+   * @param wallet - Wallet to use for sending txs.
+   * @returns A new contract instance.
+   */ withWallet(wallet) {
+        return new ContractBase(this.address, this.artifact, wallet);
+    }
+}

package/dest/contract/contract_function_interaction.d.ts

@@ -0,0 +1,67 @@
+import { type FunctionAbi, FunctionCall } from '@aztec-labs/stdlib/abi';
+import type { AuthWitness } from '@aztec-labs/stdlib/auth-witness';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Capsule, HashedValues, TxProfileResult } from '@aztec-labs/stdlib/tx';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+import type { Wallet } from '../wallet/wallet.js';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+import { type ProfileInteractionOptions, type RequestInteractionOptions, type SimulateInteractionOptions, type SimulationResult } from './interaction_options.js';
+/**
+ * This is the class that is returned when calling e.g. `contract.methods.myMethod(arg0, arg1)`.
+ * It contains available interactions one can call on a method, including view.
+ */
+export declare class ContractFunctionInteraction extends BaseContractInteraction {
+    protected contractAddress: AztecAddress;
+    protected functionDao: FunctionAbi;
+    protected args: any[];
+    private extraHashedArgs;
+    constructor(wallet: Wallet, contractAddress: AztecAddress, functionDao: FunctionAbi, args: any[], authWitnesses?: AuthWitness[], capsules?: Capsule[], extraHashedArgs?: HashedValues[]);
+    private hasInvalidNullOrUndefinedArguments;
+    /**
+     * Returns the encoded function call wrapped by this interaction
+     * Useful when generating authwits
+     * @returns An encoded function call
+     */
+    getFunctionCall(): Promise<FunctionCall>;
+    /**
+     * Returns the execution payload that allows this operation to happen on chain.
+     * @param options - Configuration options.
+     * @returns The execution payload for this operation
+     */
+    request(options?: RequestInteractionOptions): Promise<ExecutionPayload>;
+    /**
+     * Simulate a transaction and get information from its execution.
+     * Differs from prove in a few important ways:
+     * 1. It returns the values of the function execution, plus additional metadata if requested
+     * 2. It supports `utility`, `private` and `public` functions
+     *
+     * @param options - An optional object containing additional configuration for the simulation.
+     * @returns Depending on the simulation options, this method directly returns the result value of the executed
+     * function or a rich object containing extra metadata, such as estimated gas costs (if requested via options),
+     * execution statistics and emitted offchain effects
+     */
+    simulate(options?: SimulateInteractionOptions): Promise<SimulationResult>;
+    /**
+     * Simulate a transaction and profile the gate count for each function in the transaction.
+     * @param options - Same options as `simulate`, plus profiling method
+     *
+     * @returns An object containing the function return value and profile result.
+     */
+    profile(options: ProfileInteractionOptions): Promise<TxProfileResult>;
+    /**
+     * Augments this ContractFunctionInteraction with additional metadata, such as authWitnesses, capsules, and extraHashedArgs.
+     * This is useful when creating a "batteries included" interaction, such as registering a contract class with its associated
+     * capsule instead of having the user provide them externally.
+     * @param options - An object containing the metadata to add to the interaction
+     * @returns A new ContractFunctionInteraction with the added metadata, but calling the same original function in the same manner
+     */
+    with({ authWitnesses, capsules, extraHashedArgs }: {
+        /** The authWitnesses to add to the interaction */
+        authWitnesses?: AuthWitness[];
+        /** The capsules to add to the interaction */
+        capsules?: Capsule[];
+        /** The extra hashed args to add to the interaction */
+        extraHashedArgs?: HashedValues[];
+    }): ContractFunctionInteraction;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_function_interaction.d.ts","sourceRoot":"","sources":["../../src/contract/contract_function_interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,YAAY,EAQb,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAA0B,MAAM,uBAAuB,CAAC;AAEjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EAItB,MAAM,0BAA0B,CAAC;AAElC;;;GAGG;AACH,qBAAa,2BAA4B,SAAQ,uBAAuB;IAGpE,SAAS,CAAC,eAAe,EAAE,YAAY;IACvC,SAAS,CAAC,WAAW,EAAE,WAAW;IAClC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE;IAGrB,OAAO,CAAC,eAAe;IAPzB,YACE,MAAM,EAAE,MAAM,EACJ,eAAe,EAAE,YAAY,EAC7B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,GAAG,EAAE,EACrB,aAAa,GAAE,WAAW,EAAO,EACjC,QAAQ,GAAE,OAAO,EAAO,EAChB,eAAe,GAAE,YAAY,EAAO,EAgB7C;IAED,OAAO,CAAC,kCAAkC;IAW1C;;;;OAIG;IACU,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC,CAYpD;IAED;;;;OAIG;IACmB,OAAO,CAAC,OAAO,GAAE,yBAA8B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAgBhG;IAGD;;;;;;;;;;OAUG;IACU,QAAQ,CACnB,OAAO,GAAE,0BAA6D,GACrE,OAAO,CAAC,gBAAgB,CAAC,CA+D3B;IAED;;;;;OAKG;IACU,OAAO,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,eAAe,CAAC,CAOjF;IAED;;;;;;OAMG;IACI,IAAI,CAAC,EACV,aAAkB,EAClB,QAAa,EACb,eAAoB,EACrB,EAAE;QACD,kDAAkD;QAClD,aAAa,CAAC,EAAE,WAAW,EAAE,CAAC;QAC9B,6CAA6C;QAC7C,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;QACrB,sDAAsD;QACtD,eAAe,CAAC,EAAE,YAAY,EAAE,CAAC;KAClC,GAAG,2BAA2B,CAU9B;CACF"}