@aztec/aztec.js 0.0.0-test.0

package/dest/contract/base_contract_interaction.js

@@ -0,0 +1,149 @@
+import { createLogger } from '@aztec/foundation/log';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
+import { getGasLimits } from './get_gas_limits.js';
+import { ProvenTx } from './proven_tx.js';
+import { SentTx } from './sent_tx.js';
+/**
+ * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
+ * Implements the sequence create/simulate/send.
+ */ export class BaseContractInteraction {
+    wallet;
+    log;
+    capsules;
+    constructor(wallet){
+        this.wallet = wallet;
+        this.log = createLogger('aztecjs:contract_interaction');
+        this.capsules = [];
+    }
+    /**
+   * Creates a transaction execution request, simulates and proves it. Differs from .prove in
+   * that its result does not include the wallet nor the composed tx object, but only the proving result.
+   * This object can then be used to either create a ProvenTx ready to be sent, or directly send the transaction.
+   * @param options - optional arguments to be used in the creation of the transaction
+   * @returns The proving result.
+   */ async proveInternal(options = {}) {
+        const txRequest = await this.create(options);
+        const txSimulationResult = await this.wallet.simulateTx(txRequest, !options.skipPublicSimulation, undefined, true);
+        return await this.wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
+    }
+    // docs:start:prove
+    /**
+   * Proves a transaction execution request and returns a tx object ready to be sent.
+   * @param options - optional arguments to be used in the creation of the transaction
+   * @returns The resulting transaction
+   */ async prove(options = {}) {
+        // docs:end:prove
+        const txProvingResult = await this.proveInternal(options);
+        return new ProvenTx(this.wallet, txProvingResult.toTx());
+    }
+    // docs:start:send
+    /**
+   * Sends a transaction to the contract function with the specified options.
+   * This function throws an error if called on an unconstrained function.
+   * It creates and signs the transaction if necessary, and returns a SentTx instance,
+   * which can be used to track the transaction status, receipt, and events.
+   * @param options - An optional object containing 'from' property representing
+   * the AztecAddress of the sender. If not provided, the default address is used.
+   * @returns A SentTx instance for tracking the transaction status and information.
+   */ send(options = {}) {
+        // docs:end:send
+        const promise = (async ()=>{
+            const txProvingResult = await this.proveInternal(options);
+            return this.wallet.sendTx(txProvingResult.toTx());
+        })();
+        return new SentTx(this.wallet, promise);
+    }
+    // docs:start:estimateGas
+    /**
+   * Estimates gas for a given tx request and returns gas limits for it.
+   * @param opts - Options.
+   * @param pad - Percentage to pad the suggested gas limits by, if empty, defaults to 10%.
+   * @returns Gas limits.
+   */ async estimateGas(opts) {
+        // docs:end:estimateGas
+        const txRequest = await this.create({
+            ...opts,
+            fee: {
+                ...opts?.fee,
+                estimateGas: false
+            }
+        });
+        const simulationResult = await this.wallet.simulateTx(txRequest, true, undefined /* msgSender */ , undefined /* skipTxValidation */ , true);
+        const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(simulationResult, opts?.fee?.estimatedGasPadding);
+        return {
+            gasLimits,
+            teardownGasLimits
+        };
+    }
+    /**
+   * Returns default fee options based on the user opts without running a simulation for gas estimation.
+   * @param fee - User-provided fee options.
+   */ async getDefaultFeeOptions(fee) {
+        const maxFeesPerGas = fee?.gasSettings?.maxFeesPerGas ?? (await this.wallet.getCurrentBaseFees()).mul(1 + (fee?.baseFeePadding ?? 0.5));
+        const paymentMethod = fee?.paymentMethod ?? new FeeJuicePaymentMethod(this.wallet.getAddress());
+        const gasSettings = GasSettings.default({
+            ...fee?.gasSettings,
+            maxFeesPerGas
+        });
+        this.log.debug(`Using L2 gas settings`, gasSettings);
+        return {
+            gasSettings,
+            paymentMethod
+        };
+    }
+    // docs:start:getFeeOptions
+    /**
+   * Return fee options based on the user opts, estimating tx gas if needed.
+   * @param request - Request to execute for this interaction.
+   * @param pad - Percentage to pad the suggested gas limits by, as decimal (e.g., 0.10 for 10%).
+   * @returns Fee options for the actual transaction.
+   */ async getFeeOptions(request) {
+        // docs:end:getFeeOptions
+        const defaultFeeOptions = await this.getDefaultFeeOptions(request.fee);
+        const paymentMethod = defaultFeeOptions.paymentMethod;
+        const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
+        const maxPriorityFeesPerGas = defaultFeeOptions.gasSettings.maxPriorityFeesPerGas;
+        let gasSettings = defaultFeeOptions.gasSettings;
+        if (request.fee?.estimateGas) {
+            const feeForEstimation = {
+                paymentMethod,
+                gasSettings
+            };
+            const txRequest = await this.wallet.createTxExecutionRequest({
+                ...request,
+                fee: feeForEstimation
+            });
+            const simulationResult = await this.wallet.simulateTx(txRequest, true, undefined /* msgSender */ , undefined /* skipTxValidation */ , true);
+            const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(simulationResult, request.fee?.estimatedGasPadding);
+            gasSettings = GasSettings.from({
+                maxFeesPerGas,
+                maxPriorityFeesPerGas,
+                gasLimits,
+                teardownGasLimits
+            });
+            this.log.verbose(`Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`);
+        }
+        return {
+            gasSettings,
+            paymentMethod
+        };
+    }
+    /**
+   * Add data passed to the oracle calls during this contract interaction.
+   * @param capsule - Data passed to oracle calls.
+   */ addCapsule(capsule) {
+        this.capsules.push(capsule);
+    }
+    /**
+   * Add data passed to the oracle calls during this contract interaction.
+   * @param capsules - Data passed to oracle calls.
+   */ addCapsules(capsules) {
+        this.capsules.push(...capsules);
+    }
+    /**
+   * Return all capsules added for this function interaction.
+   */ getCapsules() {
+        return this.capsules;
+    }
+}

package/dest/contract/batch_call.d.ts

@@ -0,0 +1,28 @@
+import { type FunctionCall } from '@aztec/stdlib/abi';
+import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { Wallet } from '../account/index.js';
+import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+import type { SimulateMethodOptions } from './contract_function_interaction.js';
+/** A batch of function calls to be sent as a single transaction through a wallet. */
+export declare class BatchCall extends BaseContractInteraction {
+    protected calls: FunctionCall[];
+    constructor(wallet: Wallet, calls: FunctionCall[]);
+    /**
+     * Create a transaction execution request that represents this batch, encoded and authenticated by the
+     * user's wallet, ready to be simulated.
+     * @param opts - An optional object containing additional configuration for the transaction.
+     * @returns A Promise that resolves to a transaction instance.
+     */
+    create(opts?: SendMethodOptions): Promise<TxExecutionRequest>;
+    /**
+     * Simulate a transaction and get its return values
+     * Differs from prove in a few important ways:
+     * 1. It returns the values of the function execution
+     * 2. It supports `unconstrained`, `private` and `public` functions
+     *
+     * @param options - An optional object containing additional configuration for the transaction.
+     * @returns The result of the transaction as returned by the contract function.
+     */
+    simulate(options?: SimulateMethodOptions): Promise<any>;
+}
+//# sourceMappingURL=batch_call.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batch_call.d.ts","sourceRoot":"","sources":["../../src/contract/batch_call.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAA+B,MAAM,mBAAmB,CAAC;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACjG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,qFAAqF;AACrF,qBAAa,SAAU,SAAQ,uBAAuB;IACxB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE;gBAA/C,MAAM,EAAE,MAAM,EAAY,KAAK,EAAE,YAAY,EAAE;IAI3D;;;;;OAKG;IACU,MAAM,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAO1E;;;;;;;;OAQG;IACU,QAAQ,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,GAAG,CAAC;CA2DzE"}

package/dest/contract/batch_call.js

@@ -0,0 +1,91 @@
+import { FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+/** A batch of function calls to be sent as a single transaction through a wallet. */ export class BatchCall extends BaseContractInteraction {
+    calls;
+    constructor(wallet, calls){
+        super(wallet), this.calls = calls;
+    }
+    /**
+   * Create a transaction execution request that represents this batch, encoded and authenticated by the
+   * user's wallet, ready to be simulated.
+   * @param opts - An optional object containing additional configuration for the transaction.
+   * @returns A Promise that resolves to a transaction instance.
+   */ async create(opts) {
+        const calls = this.calls;
+        const capsules = this.getCapsules();
+        const fee = await this.getFeeOptions({
+            calls,
+            capsules,
+            ...opts
+        });
+        return await this.wallet.createTxExecutionRequest({
+            calls,
+            capsules,
+            ...opts,
+            fee
+        });
+    }
+    /**
+   * Simulate a transaction and get its return values
+   * Differs from prove in a few important ways:
+   * 1. It returns the values of the function execution
+   * 2. It supports `unconstrained`, `private` and `public` functions
+   *
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns The result of the transaction as returned by the contract function.
+   */ async simulate(options = {}) {
+        const { indexedCalls, unconstrained } = this.calls.reduce((acc, current, index)=>{
+            if (current.type === FunctionType.UNCONSTRAINED) {
+                acc.unconstrained.push([
+                    current,
+                    index
+                ]);
+            } else {
+                acc.indexedCalls.push([
+                    current,
+                    index,
+                    current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++
+                ]);
+            }
+            return acc;
+        }, {
+            indexedCalls: [],
+            unconstrained: [],
+            publicIndex: 0,
+            privateIndex: 0
+        });
+        const calls = indexedCalls.map(([call])=>call);
+        const capsules = this.getCapsules();
+        const fee = await this.getFeeOptions({
+            calls,
+            capsules,
+            ...options
+        });
+        const txRequest = await this.wallet.createTxExecutionRequest({
+            calls,
+            capsules,
+            ...options,
+            fee
+        });
+        const unconstrainedCalls = unconstrained.map(async ([call, index])=>[
+                await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from),
+                index
+            ]);
+        const [unconstrainedResults, simulatedTx] = await Promise.all([
+            Promise.all(unconstrainedCalls),
+            this.wallet.simulateTx(txRequest, true, options?.from, options?.skipTxValidation)
+        ]);
+        const results = [];
+        unconstrainedResults.forEach(([result, index])=>{
+            results[index] = result;
+        });
+        indexedCalls.forEach(([call, callIndex, resultIndex])=>{
+            // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
+            // since we're interested in the first set of values AFTER the account entrypoint
+            // For public functions we retrieve the first values directly from the public output.
+            const rawReturnValues = call.type == FunctionType.PRIVATE ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
+            results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+        });
+        return results;
+    }
+}

package/dest/contract/checker.d.ts

@@ -0,0 +1,11 @@
+import type { ContractArtifact } from '@aztec/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=checker.d.ts.map

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,KAAK,EAAsB,gBAAgB,EAAc,MAAM,mBAAmB,CAAC;AAQ1F;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,gBAAgB,WA8BpD"}

package/dest/contract/checker.js

@@ -0,0 +1,107 @@
+/**
+ * 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);
+        });
+    });
+    // TODO: implement a better check for constructor (right now only checks if it has it or not)
+    if (!artifact.functions.find((func)=>func.name === 'constructor')) {
+        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,41 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import type { Wallet } from '../account/index.js';
+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 on-chain through the PXE, which facilitates
+ * interaction with Aztec's privacy protocol.
+ */
+export declare class Contract extends ContractBase {
+    /**
+     * Creates a contract instance.
+     * @param address - The deployed contract's address.
+     * @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): Promise<Contract>;
+    /**
+     * Creates a tx to deploy 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.
+     */
+    static deploy(wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string): DeployMethod<Contract>;
+    /**
+     * Creates a tx to deploy a new instance of a contract using the specified public keys hash to derive the address.
+     * @param publicKeys - Hash of public keys to use for deriving the address.
+     * @param wallet - The wallet for executing the deployment.
+     * @param artifact - Build artifact of the contract.
+     * @param args - Arguments for the constructor.
+     * @param constructorName - The name of the constructor function to call.
+     */
+    static deployWithPublicKeys(publicKeys: PublicKeys, wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string): DeployMethod<Contract>;
+}
+//# sourceMappingURL=contract.d.ts.map

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,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,YAAY;IACxC;;;;;;OAMG;WACiB,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAc5G;;;;;;OAMG;WACW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM;IAKtG;;;;;;;OAOG;WACW,oBAAoB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,GAAG,EAAE,EACX,eAAe,CAAC,EAAE,MAAM;CAK3B"}

package/dest/contract/contract.js

@@ -0,0 +1,52 @@
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { PublicKeys } from '@aztec/stdlib/keys';
+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 on-chain through the PXE, which facilitates
+ * interaction with Aztec's privacy protocol.
+ */ export class Contract extends ContractBase {
+    /**
+   * Creates a contract instance.
+   * @param address - The deployed contract's address.
+   * @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 async at(address, artifact, wallet) {
+        const instance = (await wallet.getContractMetadata(address)).contractInstance;
+        if (instance === undefined) {
+            throw new Error(`Contract instance at ${address.toString()} has not been registered in the wallet's PXE`);
+        }
+        const thisContractClass = await getContractClassFromArtifact(artifact);
+        if (!thisContractClass.id.equals(instance.currentContractClassId)) {
+            // wallet holds an outdated version of this contract
+            await wallet.updateContract(address, artifact);
+            instance.currentContractClassId = thisContractClass.id;
+        }
+        return new Contract(instance, artifact, wallet);
+    }
+    /**
+   * Creates a tx to deploy 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.
+   */ static deploy(wallet, artifact, args, constructorName) {
+        const postDeployCtor = (address, wallet)=>Contract.at(address, artifact, wallet);
+        return new DeployMethod(PublicKeys.default(), wallet, artifact, postDeployCtor, args, constructorName);
+    }
+    /**
+   * Creates a tx to deploy a new instance of a contract using the specified public keys hash to derive the address.
+   * @param publicKeys - Hash of public keys to use for deriving the address.
+   * @param wallet - The wallet for executing the deployment.
+   * @param artifact - Build artifact of the contract.
+   * @param args - Arguments for the constructor.
+   * @param constructorName - The name of the constructor function to call.
+   */ static deployWithPublicKeys(publicKeys, wallet, artifact, args, constructorName) {
+        const postDeployCtor = (address, wallet)=>Contract.at(address, artifact, wallet);
+        return new DeployMethod(publicKeys, wallet, artifact, postDeployCtor, args, constructorName);
+    }
+}

package/dest/contract/contract_base.d.ts

@@ -0,0 +1,61 @@
+import { type ContractArtifact, type ContractNote, type FieldLayout, FunctionSelector } from '@aztec/stdlib/abi';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { Wallet } from '../account/index.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;
+};
+/**
+ * Type representing the notes used in a contract.
+ */
+export type ContractNotes<T extends string> = {
+    [K in T]: ContractNote;
+};
+/**
+ * Abstract implementation of a contract extended by the Contract class and generated contract types.
+ */
+export declare class ContractBase {
+    /** The deployed contract instance definition. */
+    readonly instance: ContractInstanceWithAddress;
+    /** 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 deployed contract instance definition. */
+    instance: ContractInstanceWithAddress, 
+    /** The Application Binary Interface for the contract. */
+    artifact: ContractArtifact, 
+    /** The wallet used for interacting with this contract. */
+    wallet: Wallet);
+    /** Address of the contract. */
+    get address(): import("@aztec/stdlib/aztec-address").AztecAddress;
+    /** Partial address of the contract. */
+    get partialAddress(): Promise<import("@aztec/foundation/schemas").Fr>;
+    /**
+     * 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=contract_base.d.ts.map

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,YAAY,EACjB,KAAK,WAAW,EAEhB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,2BAA2B,EAAyB,MAAM,wBAAwB,CAAC;AAEjG,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,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;KAC3C,CAAC,IAAI,CAAC,GAAG,YAAY;CACvB,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY;IAOrB,iDAAiD;aACjC,QAAQ,EAAE,2BAA2B;IACrD,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,iDAAiD;IACjC,QAAQ,EAAE,2BAA2B;IACrD,yDAAyD;IACzC,QAAQ,EAAE,gBAAgB;IAC1C,0DAA0D;IACnD,MAAM,EAAE,MAAM;IAmBvB,+BAA+B;IAC/B,IAAW,OAAO,uDAEjB;IAED,uCAAuC;IACvC,IAAW,cAAc,oDAExB;IAED;;;;OAIG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGxC"}

package/dest/contract/contract_base.js

@@ -0,0 +1,45 @@
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { computePartialAddress } from '@aztec/stdlib/contract';
+import { ContractFunctionInteraction } from './contract_function_interaction.js';
+/**
+ * Abstract implementation of a contract extended by the Contract class and generated contract types.
+ */ export class ContractBase {
+    instance;
+    artifact;
+    wallet;
+    /**
+   * An object containing contract methods mapped to their respective names.
+   */ methods;
+    constructor(/** The deployed contract instance definition. */ instance, /** The Application Binary Interface for the contract. */ artifact, /** The wallet used for interacting with this contract. */ wallet){
+        this.instance = instance;
+        this.artifact = artifact;
+        this.wallet = wallet;
+        this.methods = {};
+        artifact.functions.forEach((f)=>{
+            const interactionFunction = (...args)=>{
+                return new ContractFunctionInteraction(this.wallet, this.instance.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);
+                }
+            });
+        });
+    }
+    /** Address of the contract. */ get address() {
+        return this.instance.address;
+    }
+    /** Partial address of the contract. */ get partialAddress() {
+        return computePartialAddress(this.instance);
+    }
+    /**
+   * 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.instance, this.artifact, wallet);
+    }
+}