@aztec/aztec.js 0.0.0-test.0

package/dest/contract/contract_function_interaction.d.ts

@@ -0,0 +1,68 @@
+import { type FunctionAbi, FunctionCall } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PrivateKernelProverProfileResult } from '@aztec/stdlib/kernel';
+import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { Wallet } from '../account/wallet.js';
+import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+export type { SendMethodOptions };
+/**
+ * Represents the options for simulating a contract function interaction.
+ * Allows specifying the address from which the view method should be called.
+ * Disregarded for simulation of public functions
+ */
+export type SimulateMethodOptions = Pick<SendMethodOptions, 'fee'> & {
+    /** The sender's Aztec address. */
+    from?: AztecAddress;
+    /** Simulate without checking for the validity of the resulting transaction, e.g. whether it emits any existing nullifiers. */
+    skipTxValidation?: boolean;
+    /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
+    skipFeeEnforcement?: boolean;
+};
+/**
+ * The result of a profile() call.
+ */
+export type ProfileResult = PrivateKernelProverProfileResult & {
+    /** The result of the transaction as returned by the contract function. */
+    returnValues: any;
+};
+/**
+ * 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[];
+    constructor(wallet: Wallet, contractAddress: AztecAddress, functionDao: FunctionAbi, args: any[]);
+    /**
+     * Create a transaction execution request that represents this call, 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>;
+    /**
+     * Returns an execution request that represents this operation. Useful as a building
+     * block for constructing batch requests.
+     * @returns An execution request wrapped in promise.
+     */
+    request(): Promise<FunctionCall>;
+    /**
+     * 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>;
+    /**
+     * Simulate a transaction and profile the gate count for each function in the transaction.
+     * @param options - Same options as `simulate`.
+     *
+     * @returns An object containing the function return value and profile result.
+     */
+    simulateWithProfile(options?: SimulateMethodOptions): Promise<ProfileResult>;
+}
+//# sourceMappingURL=contract_function_interaction.d.ts.map

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,EACL,KAAK,WAAW,EAChB,YAAY,EAKb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAEjG,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG;IACnE,kCAAkC;IAClC,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,8HAA8H;IAC9H,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,8FAA8F;IAC9F,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,gCAAgC,GAAG;IAC7D,0EAA0E;IAC1E,YAAY,EAAE,GAAG,CAAC;CACnB,CAAC;AAEF;;;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;gBAHrB,MAAM,EAAE,MAAM,EACJ,eAAe,EAAE,YAAY,EAC7B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,GAAG,EAAE;IASvB;;;;;OAKG;IACU,MAAM,CAAC,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAa9E;;;;OAIG;IACU,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC;IAe7C;;;;;;;;OAQG;IACU,QAAQ,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,GAAG,CAAC;IAkCxE;;;;;OAKG;IACU,mBAAmB,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,aAAa,CAAC;CA0B9F"}

package/dest/contract/contract_function_interaction.js

@@ -0,0 +1,122 @@
+import { FunctionSelector, FunctionType, decodeFromAbi, encodeArguments } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
+import { BaseContractInteraction } from './base_contract_interaction.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 class ContractFunctionInteraction extends BaseContractInteraction {
+    contractAddress;
+    functionDao;
+    args;
+    constructor(wallet, contractAddress, functionDao, args){
+        super(wallet), this.contractAddress = contractAddress, this.functionDao = functionDao, this.args = args;
+        if (args.some((arg)=>arg === undefined || arg === null)) {
+            throw new Error('All function interaction arguments must be defined and not null. Received: ' + args);
+        }
+    }
+    // docs:start:create
+    /**
+   * Create a transaction execution request that represents this call, 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 = {}) {
+        // docs:end:create
+        if (this.functionDao.functionType === FunctionType.UNCONSTRAINED) {
+            throw new Error("Can't call `create` on an unconstrained function.");
+        }
+        const calls = [
+            await this.request()
+        ];
+        const capsules = this.getCapsules();
+        const fee = await this.getFeeOptions({
+            calls,
+            capsules,
+            ...opts
+        });
+        const { nonce, cancellable } = opts;
+        return await this.wallet.createTxExecutionRequest({
+            calls,
+            fee,
+            nonce,
+            cancellable,
+            capsules
+        });
+    }
+    // docs:start:request
+    /**
+   * Returns an execution request that represents this operation. Useful as a building
+   * block for constructing batch requests.
+   * @returns An execution request wrapped in promise.
+   */ async request() {
+        // docs:end:request
+        const args = encodeArguments(this.functionDao, this.args);
+        return {
+            name: this.functionDao.name,
+            args,
+            selector: await FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
+            type: this.functionDao.functionType,
+            to: this.contractAddress,
+            isStatic: this.functionDao.isStatic,
+            returnTypes: this.functionDao.returnTypes
+        };
+    }
+    // docs:start:simulate
+    /**
+   * 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 = {}) {
+        // docs:end:simulate
+        if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
+            return this.wallet.simulateUnconstrained(this.functionDao.name, this.args, this.contractAddress, options?.from);
+        }
+        const fee = options.fee ?? {
+            paymentMethod: new FeeJuicePaymentMethod(AztecAddress.ZERO)
+        };
+        const txRequest = await this.create({
+            fee
+        });
+        const simulatedTx = await this.wallet.simulateTx(txRequest, true, options.from, options.skipTxValidation, options.skipFeeEnforcement ?? true);
+        let rawReturnValues;
+        if (this.functionDao.functionType == FunctionType.PRIVATE) {
+            if (simulatedTx.getPrivateReturnValues().nested.length > 0) {
+                // The function invoked is private and it was called via an account contract
+                // TODO(#10631): There is a bug here: this branch might be triggered when there is no-account contract as well
+                rawReturnValues = simulatedTx.getPrivateReturnValues().nested[0].values;
+            } else {
+                // The function invoked is private and it was called directly (without account contract)
+                rawReturnValues = simulatedTx.getPrivateReturnValues().values;
+            }
+        } else {
+            // For public functions we retrieve the first values directly from the public output.
+            rawReturnValues = simulatedTx.getPublicReturnValues()?.[0].values;
+        }
+        return rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    }
+    /**
+   * Simulate a transaction and profile the gate count for each function in the transaction.
+   * @param options - Same options as `simulate`.
+   *
+   * @returns An object containing the function return value and profile result.
+   */ async simulateWithProfile(options = {}) {
+        if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
+            throw new Error("Can't profile an unconstrained function.");
+        }
+        const txRequest = await this.create({
+            fee: options.fee
+        });
+        const simulatedTx = await this.wallet.simulateTx(txRequest, true, options?.from, options?.skipTxValidation, undefined, true);
+        const rawReturnValues = this.functionDao.functionType == FunctionType.PRIVATE ? simulatedTx.getPrivateReturnValues().nested?.[0].values : simulatedTx.getPublicReturnValues()?.[0].values;
+        const rawReturnValuesDecoded = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+        return {
+            returnValues: rawReturnValuesDecoded,
+            gateCounts: simulatedTx.profileResult.gateCounts
+        };
+    }
+}

package/dest/contract/deploy_method.d.ts

@@ -0,0 +1,113 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { type ContractArtifact, type FunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { Wallet } from '../account/index.js';
+import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
+import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+import type { Contract } from './contract.js';
+import type { ContractBase } from './contract_base.js';
+import { DeployProvenTx } from './deploy_proven_tx.js';
+import { DeploySentTx } from './deploy_sent_tx.js';
+/**
+ * Options for deploying a contract on the Aztec network.
+ * Allows specifying a contract address salt, and additional send method options.
+ */
+export type DeployOptions = {
+    /** An optional salt value used to deterministically calculate the contract address. */
+    contractAddressSalt?: Fr;
+    /** Set to true to *not* include the sender in the address computation. */
+    universalDeploy?: boolean;
+    /** Skip contract class registration. */
+    skipClassRegistration?: boolean;
+    /** Skip public deployment, instead just privately initialize the contract. */
+    skipPublicDeployment?: boolean;
+    /** Skip contract initialization. */
+    skipInitialization?: boolean;
+} & SendMethodOptions;
+/**
+ * Contract interaction for deployment. Handles class registration, public instance deployment,
+ * and initialization of the contract. Extends the BaseContractInteraction class.
+ */
+export declare class DeployMethod<TContract extends ContractBase = Contract> extends BaseContractInteraction {
+    private publicKeys;
+    private artifact;
+    private postDeployCtor;
+    private args;
+    /** The contract instance to be deployed. */
+    private instance?;
+    /** Constructor function to call. */
+    private constructorArtifact;
+    constructor(publicKeys: PublicKeys, wallet: Wallet, artifact: ContractArtifact, postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>, args?: any[], constructorNameOrArtifact?: string | FunctionArtifact);
+    /**
+     * Create a contract deployment transaction, given the deployment options.
+     * This function internally calls `request()` and `sign()` methods to prepare
+     * the transaction for deployment. The resulting signed transaction can be
+     * later sent using the `send()` method.
+     *
+     * @param options - An object containing optional deployment settings, contractAddressSalt, and from.
+     * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
+     */
+    create(options?: DeployOptions): Promise<TxExecutionRequest>;
+    /**
+     * Returns an array of function calls that represent this operation. Useful as a building
+     * block for constructing batch requests.
+     * @param options - Deployment options.
+     * @returns An array of function calls.
+     * @remarks This method does not have the same return type as the `request` in the ContractInteraction object,
+     * it returns a promise for an array instead of a function call directly.
+     */
+    request(options?: DeployOptions): Promise<ExecutionRequestInit>;
+    /**
+     * Register this contract in the PXE and returns the Contract object.
+     * @param options - Deployment options.
+     */
+    register(options?: DeployOptions): Promise<TContract>;
+    /**
+     * Returns calls for registration of the class and deployment of the instance, depending on the provided options.
+     * @param options - Deployment options.
+     * @returns A function call array with potentially requests to the class registerer and instance deployer.
+     */
+    protected getDeploymentFunctionCalls(options?: DeployOptions): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>>;
+    /**
+     * Returns the calls necessary to initialize the contract.
+     * @param options - Deployment options.
+     * @returns - An array of function calls.
+     */
+    protected getInitializeFunctionCalls(options: DeployOptions): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments' | 'capsules'>>;
+    /**
+     * Send the contract deployment transaction using the provided options.
+     * This function extends the 'send' method from the ContractFunctionInteraction class,
+     * allowing us to send a transaction specifically for contract deployment.
+     *
+     * @param options - An object containing various deployment options such as contractAddressSalt and from.
+     * @returns A SentTx object that returns the receipt and the deployed contract instance.
+     */
+    send(options?: DeployOptions): DeploySentTx<TContract>;
+    /**
+     * Builds the contract instance to be deployed and returns it.
+     *
+     * @param options - An object containing various deployment options.
+     * @returns An instance object.
+     */
+    getInstance(options?: DeployOptions): Promise<ContractInstanceWithAddress>;
+    /**
+     * Prove the request.
+     * @param options - Deployment options.
+     * @returns The proven tx.
+     */
+    prove(options: DeployOptions): Promise<DeployProvenTx<TContract>>;
+    /**
+     * Estimates gas cost for this deployment operation.
+     * @param options - Options.
+     */
+    estimateGas(options?: Omit<DeployOptions, 'estimateGas' | 'skipPublicSimulation'>): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>>;
+    /** Return this deployment address. */
+    get address(): AztecAddress | undefined;
+    /** Returns the partial address for this deployment. */
+    get partialAddress(): Promise<Fr> | undefined;
+}
+//# sourceMappingURL=deploy_method.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_method.d.ts","sourceRoot":"","sources":["../../src/contract/deploy_method.ts"],"names":[],"mappings":"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"}

package/dest/contract/deploy_method.js

@@ -0,0 +1,212 @@
+import { getInitializer } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computePartialAddress, getContractClassFromArtifact, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+import { deployInstance } from '../deployment/deploy_instance.js';
+import { registerContractClass } from '../deployment/register_class.js';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+import { ContractFunctionInteraction } from './contract_function_interaction.js';
+import { DeployProvenTx } from './deploy_proven_tx.js';
+import { DeploySentTx } from './deploy_sent_tx.js';
+// docs:end:deploy_options
+// TODO(@spalladino): Add unit tests for this class!
+/**
+ * Contract interaction for deployment. Handles class registration, public instance deployment,
+ * and initialization of the contract. Extends the BaseContractInteraction class.
+ */ export class DeployMethod extends BaseContractInteraction {
+    publicKeys;
+    artifact;
+    postDeployCtor;
+    args;
+    /** The contract instance to be deployed. */ instance;
+    /** Constructor function to call. */ constructorArtifact;
+    constructor(publicKeys, wallet, artifact, postDeployCtor, args = [], constructorNameOrArtifact){
+        super(wallet), this.publicKeys = publicKeys, this.artifact = artifact, this.postDeployCtor = postDeployCtor, this.args = args, this.instance = undefined;
+        this.constructorArtifact = getInitializer(artifact, constructorNameOrArtifact);
+    }
+    /**
+   * Create a contract deployment transaction, given the deployment options.
+   * This function internally calls `request()` and `sign()` methods to prepare
+   * the transaction for deployment. The resulting signed transaction can be
+   * later sent using the `send()` method.
+   *
+   * @param options - An object containing optional deployment settings, contractAddressSalt, and from.
+   * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
+   */ async create(options = {}) {
+        return this.wallet.createTxExecutionRequest(await this.request(options));
+    }
+    // REFACTOR: Having a `request` method with different semantics than the ones in the other
+    // derived ContractInteractions is confusing. We should unify the flow of all ContractInteractions.
+    /**
+   * Returns an array of function calls that represent this operation. Useful as a building
+   * block for constructing batch requests.
+   * @param options - Deployment options.
+   * @returns An array of function calls.
+   * @remarks This method does not have the same return type as the `request` in the ContractInteraction object,
+   * it returns a promise for an array instead of a function call directly.
+   */ async request(options = {}) {
+        const deployment = await this.getDeploymentFunctionCalls(options);
+        // NOTE: MEGA HACK. Remove with #10007
+        // register the contract after generating deployment function calls in order to publicly register the class and (optioanlly) emit its bytecode
+        //
+        // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
+        // Note that we need to run this registerContract here so it's available when computeFeeOptionsFromEstimatedGas
+        // runs, since it needs the contract to have been registered in order to estimate gas for its initialization,
+        // in case the initializer is public. This hints at the need of having "transient" contracts scoped to a
+        // simulation, so we can run the simulation with a set of contracts, but only "commit" them to the wallet
+        // once this tx has gone through.
+        await this.wallet.registerContract({
+            artifact: this.artifact,
+            instance: await this.getInstance(options)
+        });
+        const bootstrap = await this.getInitializeFunctionCalls(options);
+        if (deployment.calls.length + bootstrap.calls.length === 0) {
+            throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
+        }
+        const calls = [
+            ...deployment.calls,
+            ...bootstrap.calls
+        ];
+        const authWitnesses = [
+            ...deployment.authWitnesses ?? [],
+            ...bootstrap.authWitnesses ?? []
+        ];
+        const hashedArguments = [
+            ...deployment.hashedArguments ?? [],
+            ...bootstrap.hashedArguments ?? []
+        ];
+        const capsules = [
+            ...deployment.capsules ?? [],
+            ...bootstrap.capsules ?? []
+        ];
+        const { cancellable, nonce, fee: userFee } = options;
+        const request = {
+            calls,
+            authWitnesses,
+            hashedArguments,
+            capsules,
+            cancellable,
+            fee: userFee,
+            nonce
+        };
+        const fee = await this.getFeeOptions(request);
+        return {
+            ...request,
+            fee
+        };
+    }
+    /**
+   * Register this contract in the PXE and returns the Contract object.
+   * @param options - Deployment options.
+   */ async register(options = {}) {
+        const instance = await this.getInstance(options);
+        await this.wallet.registerContract({
+            artifact: this.artifact,
+            instance
+        });
+        return this.postDeployCtor(instance.address, this.wallet);
+    }
+    /**
+   * Returns calls for registration of the class and deployment of the instance, depending on the provided options.
+   * @param options - Deployment options.
+   * @returns A function call array with potentially requests to the class registerer and instance deployer.
+   */ async getDeploymentFunctionCalls(options = {}) {
+        const calls = [];
+        const capsules = [];
+        // Set contract instance object so it's available for populating the DeploySendTx object
+        const instance = await this.getInstance(options);
+        // Obtain contract class from artifact and check it matches the reported one by the instance.
+        // TODO(@spalladino): We're unnecessarily calculating the contract class multiple times here.
+        const contractClass = await getContractClassFromArtifact(this.artifact);
+        if (!instance.currentContractClassId.equals(contractClass.id)) {
+            throw new Error(`Contract class mismatch when deploying contract: got ${instance.currentContractClassId.toString()} from instance and ${contractClass.id.toString()} from artifact`);
+        }
+        // Register the contract class if it hasn't been published already.
+        if (!options.skipClassRegistration) {
+            if ((await this.wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+                this.log.debug(`Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`);
+            } else {
+                this.log.info(`Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`);
+                const registerContractClassInteraction = await registerContractClass(this.wallet, this.artifact);
+                calls.push(await registerContractClassInteraction.request());
+                capsules.push(...registerContractClassInteraction.getCapsules());
+            }
+        }
+        // Deploy the contract via the instance deployer.
+        if (!options.skipPublicDeployment) {
+            const deploymentInteraction = await deployInstance(this.wallet, instance);
+            calls.push(await deploymentInteraction.request());
+            capsules.push(...deploymentInteraction.getCapsules());
+        }
+        return {
+            calls,
+            capsules
+        };
+    }
+    /**
+   * Returns the calls necessary to initialize the contract.
+   * @param options - Deployment options.
+   * @returns - An array of function calls.
+   */ async getInitializeFunctionCalls(options) {
+        const { address } = await this.getInstance(options);
+        const calls = [];
+        const capsules = [];
+        if (this.constructorArtifact && !options.skipInitialization) {
+            const constructorCall = new ContractFunctionInteraction(this.wallet, address, this.constructorArtifact, this.args);
+            calls.push(await constructorCall.request());
+            capsules.push(...constructorCall.getCapsules());
+        }
+        return {
+            calls,
+            capsules
+        };
+    }
+    /**
+   * Send the contract deployment transaction using the provided options.
+   * This function extends the 'send' method from the ContractFunctionInteraction class,
+   * allowing us to send a transaction specifically for contract deployment.
+   *
+   * @param options - An object containing various deployment options such as contractAddressSalt and from.
+   * @returns A SentTx object that returns the receipt and the deployed contract instance.
+   */ send(options = {}) {
+        const txHashPromise = super.send(options).getTxHash();
+        this.log.debug(`Sent deployment tx of ${this.artifact.name} contract`);
+        return new DeploySentTx(this.wallet, txHashPromise, this.postDeployCtor, ()=>this.getInstance(options));
+    }
+    /**
+   * Builds the contract instance to be deployed and returns it.
+   *
+   * @param options - An object containing various deployment options.
+   * @returns An instance object.
+   */ async getInstance(options = {}) {
+        if (!this.instance) {
+            this.instance = await getContractInstanceFromDeployParams(this.artifact, {
+                constructorArgs: this.args,
+                salt: options.contractAddressSalt,
+                publicKeys: this.publicKeys,
+                constructorArtifact: this.constructorArtifact,
+                deployer: options.universalDeploy ? AztecAddress.ZERO : this.wallet.getAddress()
+            });
+        }
+        return this.instance;
+    }
+    /**
+   * Prove the request.
+   * @param options - Deployment options.
+   * @returns The proven tx.
+   */ async prove(options) {
+        const txProvingResult = await this.proveInternal(options);
+        return new DeployProvenTx(this.wallet, txProvingResult.toTx(), this.postDeployCtor, ()=>this.getInstance(options));
+    }
+    /**
+   * Estimates gas cost for this deployment operation.
+   * @param options - Options.
+   */ estimateGas(options) {
+        return super.estimateGas(options);
+    }
+    /** Return this deployment address. */ get address() {
+        return this.instance?.address;
+    }
+    /** Returns the partial address for this deployment. */ get partialAddress() {
+        return this.instance && computePartialAddress(this.instance);
+    }
+}

package/dest/contract/deploy_proven_tx.d.ts

@@ -0,0 +1,21 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { Tx } from '@aztec/stdlib/tx';
+import type { Wallet } from '../account/index.js';
+import type { Contract } from './contract.js';
+import { DeploySentTx } from './deploy_sent_tx.js';
+import { ProvenTx } from './proven_tx.js';
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract deployment.
+ */
+export declare class DeployProvenTx<TContract extends Contract = Contract> extends ProvenTx {
+    private postDeployCtor;
+    private instanceGetter;
+    constructor(wallet: PXE | Wallet, tx: Tx, postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>, instanceGetter: () => Promise<ContractInstanceWithAddress>);
+    /**
+     * Sends the transaction to the network via the provided wallet.
+     */
+    send(): DeploySentTx<TContract>;
+}
+//# sourceMappingURL=deploy_proven_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_proven_tx.d.ts","sourceRoot":"","sources":["../../src/contract/deploy_proven_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;GAEG;AACH,qBAAa,cAAc,CAAC,SAAS,SAAS,QAAQ,GAAG,QAAQ,CAAE,SAAQ,QAAQ;IAI/E,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,cAAc;gBAHtB,MAAM,EAAE,GAAG,GAAG,MAAM,EACpB,EAAE,EAAE,EAAE,EACE,cAAc,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,EAC7E,cAAc,EAAE,MAAM,OAAO,CAAC,2BAA2B,CAAC;IAKpE;;OAEG;IACa,IAAI,IAAI,YAAY,CAAC,SAAS,CAAC;CAOhD"}

package/dest/contract/deploy_proven_tx.js

@@ -0,0 +1,19 @@
+import { DeploySentTx } from './deploy_sent_tx.js';
+import { ProvenTx } from './proven_tx.js';
+/**
+ * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract deployment.
+ */ export class DeployProvenTx extends ProvenTx {
+    postDeployCtor;
+    instanceGetter;
+    constructor(wallet, tx, postDeployCtor, instanceGetter){
+        super(wallet, tx), this.postDeployCtor = postDeployCtor, this.instanceGetter = instanceGetter;
+    }
+    /**
+   * Sends the transaction to the network via the provided wallet.
+   */ send() {
+        const promise = (()=>{
+            return this.wallet.sendTx(this.getPlainDataTx());
+        })();
+        return new DeploySentTx(this.wallet, promise, this.postDeployCtor, this.instanceGetter);
+    }
+}

package/dest/contract/deploy_sent_tx.d.ts

@@ -0,0 +1,45 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import type { Wallet } from '../account/index.js';
+import type { Contract } from './contract.js';
+import type { ContractBase } from './contract_base.js';
+import { SentTx, type WaitOpts } from './sent_tx.js';
+/** Options related to waiting for a deployment tx. */
+export type DeployedWaitOpts = WaitOpts & {
+    /** Wallet to use for creating a contract instance. Uses the one set in the deployer constructor if not set. */
+    wallet?: Wallet;
+};
+/** Extends a transaction receipt with a contract instance that represents the newly deployed contract. */
+export type DeployTxReceipt<TContract extends ContractBase = Contract> = FieldsOf<TxReceipt> & {
+    /** Instance of the newly deployed contract. */
+    contract: TContract;
+};
+/**
+ * A contract deployment transaction sent to the network, extending SentTx with methods to create a contract instance.
+ */
+export declare class DeploySentTx<TContract extends Contract = Contract> extends SentTx {
+    private postDeployCtor;
+    /** A getter for the deployed contract instance */
+    instanceGetter: () => Promise<ContractInstanceWithAddress>;
+    private log;
+    constructor(pxeOrWallet: PXE | Wallet, txHashPromise: Promise<TxHash>, postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>, 
+    /** A getter for the deployed contract instance */
+    instanceGetter: () => Promise<ContractInstanceWithAddress>);
+    /**
+     * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
+     * @param opts - Options for configuring the waiting for the tx to be mined.
+     * @returns The deployed contract instance.
+     */
+    deployed(opts?: DeployedWaitOpts): Promise<TContract>;
+    /**
+     * Awaits for the tx to be mined and returns the receipt along with a contract instance. Throws if tx is not mined.
+     * @param opts - Options for configuring the waiting for the tx to be mined.
+     * @returns The transaction receipt with the deployed contract instance.
+     */
+    wait(opts?: DeployedWaitOpts): Promise<DeployTxReceipt<TContract>>;
+    protected getContractObject(wallet?: Wallet): Promise<TContract>;
+}
+//# sourceMappingURL=deploy_sent_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_sent_tx.d.ts","sourceRoot":"","sources":["../../src/contract/deploy_sent_tx.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAa,GAAG,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD,sDAAsD;AACtD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG;IACxC,+GAA+G;IAC/G,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,0GAA0G;AAC1G,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,YAAY,GAAG,QAAQ,IAAI,QAAQ,CAAC,SAAS,CAAC,GAAG;IAC7F,+CAA+C;IAC/C,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAY,CAAC,SAAS,SAAS,QAAQ,GAAG,QAAQ,CAAE,SAAQ,MAAM;IAM3E,OAAO,CAAC,cAAc;IACtB,kDAAkD;IAC3C,cAAc,EAAE,MAAM,OAAO,CAAC,2BAA2B,CAAC;IAPnE,OAAO,CAAC,GAAG,CAA0C;gBAGnD,WAAW,EAAE,GAAG,GAAG,MAAM,EACzB,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,EACtB,cAAc,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC;IACrF,kDAAkD;IAC3C,cAAc,EAAE,MAAM,OAAO,CAAC,2BAA2B,CAAC;IAKnE;;;;OAIG;IACU,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC;IAOlE;;;;OAIG;IACmB,IAAI,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;cAMxE,iBAAiB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;CAUvE"}