@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.0b941701

package/dest/contract/deploy_method.js

@@ -1,17 +1,24 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 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 { computePartialAddress, getContractClassFromArtifact, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { collectOffchainEffects } from '@aztec/stdlib/tx';
+import { mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { publishContractClass } from '../deployment/publish_class.js';
+import { publishInstance } from '../deployment/publish_instance.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!
+import { getGasLimits } from './get_gas_limits.js';
+import { NO_WAIT, toProfileOptions, toSendOptions, toSimulateOptions } from './interaction_options.js';
 /**
- * Contract interaction for deployment. Handles class registration, public instance deployment,
- * and initialization of the contract. Extends the BaseContractInteraction class.
+ * Contract interaction for deployment.
+ * Handles class publication, instance publication, and initialization of the contract.
+ *
+ * Note that for some contracts, a tx is not required as part of its "creation":
+ * If there are no public functions, and if there are no initialization functions,
+ * then technically the contract has already been "created", and all of the contract's
+ * functions (private and utility) can be interacted-with immediately, without any
+ * "deployment tx".
  */ export class DeployMethod extends BaseContractInteraction {
     publicKeys;
     artifact;
@@ -19,99 +26,69 @@ import { DeploySentTx } from './deploy_sent_tx.js';
     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;
+    constructor(publicKeys, wallet, artifact, postDeployCtor, args = [], constructorNameOrArtifact, authWitnesses = [], capsules = []){
+        super(wallet, authWitnesses, capsules), 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}`);
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param options - Configuration options.
+   * @returns The execution payload for this operation
+   */ async request(options) {
+        const publication = await this.getPublicationExecutionPayload(options);
+        if (!options?.skipRegistration) {
+            await this.wallet.registerContract(await this.getInstance(options), this.artifact);
         }
-        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 initialization = await this.getInitializationExecutionPayload(options);
+        const feeExecutionPayload = options?.fee?.paymentMethod ? await options.fee.paymentMethod.getExecutionPayload() : undefined;
+        const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
+            feeExecutionPayload,
+            publication,
+            initialization
+        ]) : mergeExecutionPayloads([
+            publication,
+            initialization
+        ]);
+        if (!finalExecutionPayload.calls.length) {
+            throw new Error(`No transactions are needed to publish or initialize contract ${this.artifact.name}`);
+        }
+        return finalExecutionPayload;
+    }
+    convertDeployOptionsToRequestOptions(options) {
+        return {
+            ...options,
+            deployer: !options?.universalDeploy ? options.from : undefined
         };
-        const fee = await this.getFeeOptions(request);
+    }
+    /**
+   * Converts DeployOptions to SendOptions, stripping out the returnReceipt flag if present.
+   * @param options - Deploy options with wait parameter
+   * @returns Send options with wait parameter
+   */ convertDeployOptionsToSendOptions(options) {
         return {
-            ...request,
-            fee
+            ...toSendOptions({
+                ...options,
+                wait: options.wait
+            })
         };
     }
     /**
-   * Register this contract in the PXE and returns the Contract object.
+   * Adds this contract to the wallet and returns the Contract object.
    * @param options - Deployment options.
-   */ async register(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);
+        await this.wallet.registerContract(instance, this.artifact);
+        return this.postDeployCtor(instance, 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 = {}) {
+   * Returns an execution payload for:
+   * - publication of the contract class and
+   * - publication of the contract instance to enable public execution
+   * depending on the provided options.
+   * @param options - Contract creation options.
+   * @returns An execution payload with potentially calls (and bytecode capsule) to the class registry and instance registry.
+   */ async getPublicationExecutionPayload(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.
@@ -120,88 +97,114 @@ import { DeploySentTx } from './deploy_sent_tx.js';
         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);
+        // Publish the contract class if it hasn't been published already.
+        if (!options?.skipClassPublication) {
+            const classMetadata = await this.wallet.getContractClassMetadata(contractClass.id);
+            if (!classMetadata.isContractClassPubliclyRegistered) {
+                this.log.info(`Creating request for publishing contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`);
+                const registerContractClassInteraction = await publishContractClass(this.wallet, this.artifact);
                 calls.push(await registerContractClassInteraction.request());
-                capsules.push(...registerContractClassInteraction.getCapsules());
+            } else {
+                this.log.debug(`Skipping contract class publication for ${contractClass.id.toString()} as it is already registered`);
             }
         }
-        // Deploy the contract via the instance deployer.
-        if (!options.skipPublicDeployment) {
-            const deploymentInteraction = await deployInstance(this.wallet, instance);
+        // Publish the contract instance:
+        if (!options?.skipInstancePublication) {
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15596):
+            // Read the artifact, and if there are no public functions, warn the caller that publication of the
+            // contract instance is not necessary (until such time as they wish to update the instance (i.e. change its class_id)).
+            const deploymentInteraction = publishInstance(this.wallet, instance);
             calls.push(await deploymentInteraction.request());
-            capsules.push(...deploymentInteraction.getCapsules());
         }
-        return {
-            calls,
-            capsules
-        };
+        return mergeExecutionPayloads(calls);
     }
     /**
    * 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) {
+   */ async getInitializationExecutionPayload(options) {
+        const executionsPayloads = [];
+        if (this.constructorArtifact && !options?.skipInitialization) {
+            const { address } = await this.getInstance(options);
             const constructorCall = new ContractFunctionInteraction(this.wallet, address, this.constructorArtifact, this.args);
-            calls.push(await constructorCall.request());
-            capsules.push(...constructorCall.getCapsules());
+            executionsPayloads.push(await constructorCall.request());
         }
-        return {
-            calls,
-            capsules
-        };
+        return mergeExecutionPayloads(executionsPayloads);
     }
-    /**
-   * 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));
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async send(options) {
+        const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+        const sendOptions = this.convertDeployOptionsToSendOptions(options);
+        if (options.wait === NO_WAIT) {
+            const txHash = await this.wallet.sendTx(executionPayload, sendOptions);
+            this.log.debug(`Sent deployment tx ${txHash.hash} of ${this.artifact.name} contract`);
+            return txHash;
+        }
+        const receipt = await this.wallet.sendTx(executionPayload, sendOptions);
+        this.log.debug(`Deployed ${this.artifact.name} contract in tx ${receipt.txHash}`);
+        // Attach contract instance
+        const instance = await this.getInstance(options);
+        const contract = this.postDeployCtor(instance, this.wallet);
+        // Return full receipt if requested, otherwise just the contract
+        if (options.wait && typeof options.wait === 'object' && options.wait.returnReceipt) {
+            return {
+                ...receipt,
+                contract,
+                instance
+            };
+        }
+        return contract;
     }
     /**
-   * Builds the contract instance to be deployed and returns it.
+   * Builds the contract instance and returns it.
    *
-   * @param options - An object containing various deployment options.
+   * @param options - An object containing various initialization and publication options.
    * @returns An instance object.
-   */ async getInstance(options = {}) {
+   */ async getInstance(options) {
         if (!this.instance) {
-            this.instance = await getContractInstanceFromDeployParams(this.artifact, {
+            this.instance = await getContractInstanceFromInstantiationParams(this.artifact, {
                 constructorArgs: this.args,
-                salt: options.contractAddressSalt,
+                salt: options?.contractAddressSalt ?? Fr.random(),
                 publicKeys: this.publicKeys,
                 constructorArtifact: this.constructorArtifact,
-                deployer: options.universalDeploy ? AztecAddress.ZERO : this.wallet.getAddress()
+                deployer: options?.deployer ? options.deployer : AztecAddress.ZERO
             });
         }
         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));
+   * Simulate the deployment
+   *
+   * @param options - An optional object containing additional configuration for the simulation.
+   * @returns A simulation result object containing metadata of the execution, including gas
+   * estimations (if requested via options), execution statistics and emitted offchain effects
+   */ async simulate(options) {
+        const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+        const simulatedTx = await this.wallet.simulateTx(executionPayload, toSimulateOptions(options));
+        const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
+        this.log.verbose(`Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`);
+        return {
+            stats: simulatedTx.stats,
+            offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+            result: undefined,
+            estimatedGas: {
+                gasLimits,
+                teardownGasLimits
+            }
+        };
     }
     /**
-   * Estimates gas cost for this deployment operation.
-   * @param options - Options.
-   */ estimateGas(options) {
-        return super.estimateGas(options);
+   * Simulate a deployment and profile the gate count for each function in the transaction.
+   * @param options - Same options as `send`, plus extra profiling options.
+   *
+   * @returns An object containing the function return value and profile result.
+   */ async profile(options) {
+        const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+        return await this.wallet.profileTx(executionPayload, {
+            ...toProfileOptions(options),
+            profileMode: options.profileMode,
+            skipProofGeneration: options.skipProofGeneration
+        });
     }
     /** Return this deployment address. */ get address() {
         return this.instance?.address;
@@ -209,4 +212,11 @@ import { DeploySentTx } from './deploy_sent_tx.js';
     /** Returns the partial address for this deployment. */ get partialAddress() {
         return this.instance && computePartialAddress(this.instance);
     }
+    /**
+   * Augments this DeployMethod with additional metadata, such as authWitnesses and capsules.
+   * @param options - An object containing the metadata to add to the interaction
+   * @returns A new DeployMethod with the added metadata, but calling the same original function in the same manner
+   */ with({ authWitnesses = [], capsules = [] }) {
+        return new DeployMethod(this.publicKeys, this.wallet, this.artifact, this.postDeployCtor, this.args, this.constructorArtifact?.name, this.authWitnesses.concat(authWitnesses), this.capsules.concat(capsules));
+    }
 }

package/dest/contract/get_gas_limits.d.ts

@@ -1,18 +1,17 @@
-import type { Gas } from '@aztec/stdlib/gas';
+import { Gas } from '@aztec/stdlib/gas';
 import type { TxSimulationResult } from '@aztec/stdlib/tx';
 /**
  * Returns suggested total and teardown gas limits for a simulated tx.
- * Note that public gas usage is only accounted for if the publicOutput is present.
  * @param pad - Percentage to pad the suggested gas limits by, (as decimal, e.g., 0.10 for 10%).
  */
 export declare function getGasLimits(simulationResult: TxSimulationResult, pad?: number): {
     /**
-     * Total gas used across private and public
+     * Gas limit for the tx, excluding teardown gas
      */
-    totalGas: Gas;
+    gasLimits: Gas;
     /**
-     * Teardown gas used
+     * Gas limit for the teardown phase
      */
-    teardownGas: Gas;
+    teardownGasLimits: Gas;
 };
-//# sourceMappingURL=get_gas_limits.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2dhc19saW1pdHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250cmFjdC9nZXRfZ2FzX2xpbWl0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEMsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUzRDs7O0dBR0c7QUFDSCx3QkFBZ0IsWUFBWSxDQUMxQixnQkFBZ0IsRUFBRSxrQkFBa0IsRUFDcEMsR0FBRyxTQUFNLEdBQ1I7SUFDRDs7T0FFRztJQUNILFNBQVMsRUFBRSxHQUFHLENBQUM7SUFDZjs7T0FFRztJQUNILGlCQUFpQixFQUFFLEdBQUcsQ0FBQztDQUN4QixDQVlBIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"get_gas_limits.d.ts","sourceRoot":"","sources":["../../src/contract/get_gas_limits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,gBAAgB,EAAE,kBAAkB,EACpC,GAAG,SAAM,GACR;IACD;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC;IACd;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC;CAClB,CAKA"}
+{"version":3,"file":"get_gas_limits.d.ts","sourceRoot":"","sources":["../../src/contract/get_gas_limits.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,gBAAgB,EAAE,kBAAkB,EACpC,GAAG,SAAM,GACR;IACD;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;IACf;;OAEG;IACH,iBAAiB,EAAE,GAAG,CAAC;CACxB,CAYA"}

package/dest/contract/get_gas_limits.js

@@ -1,10 +1,16 @@
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 /**
  * Returns suggested total and teardown gas limits for a simulated tx.
- * Note that public gas usage is only accounted for if the publicOutput is present.
  * @param pad - Percentage to pad the suggested gas limits by, (as decimal, e.g., 0.10 for 10%).
  */ export function getGasLimits(simulationResult, pad = 0.1) {
+    // Total gas does not use the teardown gas limit, but the actual total gas used by the tx.
+    const gasLimits = simulationResult.gasUsed.totalGas.mul(1 + pad);
+    const teardownGasLimits = simulationResult.gasUsed.teardownGas.mul(1 + pad);
+    if (gasLimits.l2Gas > AVM_MAX_PROCESSABLE_L2_GAS) {
+        throw new Error('Transaction consumes more gas than the AVM maximum processable gas');
+    }
     return {
-        totalGas: simulationResult.gasUsed.totalGas.mul(1 + pad),
-        teardownGas: simulationResult.gasUsed.teardownGas.mul(1 + pad)
+        gasLimits,
+        teardownGasLimits
     };
 }

package/dest/contract/interaction_options.d.ts

@@ -0,0 +1,151 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { Capsule, OffchainEffect, SimulationStats, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { ProfileOptions, SendOptions, SimulateOptions } from '../wallet/index.js';
+import type { WaitOpts } from './wait_opts.js';
+/**
+ * Options used to tweak the simulation and add gas estimation capabilities
+ */
+export type FeeEstimationOptions = {
+    /** Whether to modify the fee settings of the simulation with high gas limit to figure out actual gas settings. */
+    estimateGas?: boolean;
+    /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
+    estimatedGasPadding?: number;
+};
+/**
+ * Interactions allow configuring a custom fee payment method that gets bundled with the transaction before
+ * sending it to the wallet
+ */
+export type FeePaymentMethodOption = {
+    /** Fee payment method to embed in the interaction */
+    paymentMethod?: FeePaymentMethod;
+};
+/**
+ * User-defined partial gas settings for the interaction. This type is completely optional since
+ * the wallet will fill in the missing options
+ */
+export type GasSettingsOption = {
+    /** The gas settings */
+    gasSettings?: Partial<FieldsOf<GasSettings>>;
+};
+/** Fee options as set by a user. */
+export type InteractionFeeOptions = GasSettingsOption & FeePaymentMethodOption;
+/**  Fee options that can be set for simulation *only* */
+export type SimulationInteractionFeeOptions = InteractionFeeOptions & FeeEstimationOptions;
+/**
+ * Represents the options to configure a request from a contract interaction.
+ * Allows specifying additional auth witnesses and capsules to use during execution
+ */
+export type RequestInteractionOptions = {
+    /** Extra authwits to use during execution */
+    authWitnesses?: AuthWitness[];
+    /** Extra capsules to use during execution */
+    capsules?: Capsule[];
+    /** Fee payment method to embed in the interaction request */
+    fee?: FeePaymentMethodOption;
+};
+/**
+ * Constant for explicitly not waiting for transaction confirmation.
+ * We use this instead of false to avoid confusion with falsy checks.
+ */
+export declare const NO_WAIT: "NO_WAIT";
+/**
+ * Type for the NO_WAIT constant.
+ */
+export type NoWait = typeof NO_WAIT;
+/**
+ * Type for wait options in interactions.
+ * - NO_WAIT symbol: Don't wait for confirmation, return TxHash immediately
+ * - WaitOpts object: Wait with custom options and return receipt/result
+ * - undefined: Wait with default options and return receipt/result
+ */
+export type InteractionWaitOptions = NoWait | WaitOpts | undefined;
+/**
+ * Base options for calling a (constrained) function in a contract, without wait parameter.
+ */
+export type SendInteractionOptionsWithoutWait = RequestInteractionOptions & {
+    /** The sender's Aztec address. */
+    from: AztecAddress;
+    /** The fee options for the transaction. */
+    fee?: InteractionFeeOptions;
+};
+/**
+ * Represents options for calling a (constrained) function in a contract.
+ */
+export type SendInteractionOptions<W extends InteractionWaitOptions = undefined> = SendInteractionOptionsWithoutWait & {
+    /**
+     * Whether to wait for the transaction to be mined.
+     * - undefined (default): wait with default options and return TxReceipt
+     * - WaitOpts object: wait with custom options and return TxReceipt
+     * - NO_WAIT: return txHash immediately without waiting
+     */
+    wait?: W;
+};
+/**
+ * Represents the options for simulating a contract function interaction.
+ * Allows specifying the address from which the method should be called.
+ * Disregarded for simulation of public functions
+ */
+export type SimulateInteractionOptions = Omit<SendInteractionOptions, 'fee'> & {
+    /** The fee options for the transaction. */
+    fee?: SimulationInteractionFeeOptions;
+    /** 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;
+    /** Whether to include metadata such as offchain effects and performance statistics (e.g. timing information of the different circuits and oracles) in
+     * the simulation result, instead of just the return value of the function */
+    includeMetadata?: boolean;
+};
+/**
+ * Represents the options for profiling an interaction.
+ */
+export type ProfileInteractionOptions = SimulateInteractionOptions & {
+    /** Whether to return gates information or the bytecode/witnesses. */
+    profileMode: 'gates' | 'execution-steps' | 'full';
+    /** Whether to generate a Chonk proof or not */
+    skipProofGeneration?: boolean;
+};
+/**
+ * Represents the result type of a simulation.
+ * By default, it will just be the return value of the simulated function
+ * If `includeMetadata` is set to true in `SimulateInteractionOptions` on the input of `simulate(...)`,
+ * it will provide extra information.
+ */
+export type SimulationReturn<T extends boolean | undefined> = T extends true ? {
+    /** Additional stats about the simulation */
+    stats: SimulationStats;
+    /** Offchain effects generated during the simulation */
+    offchainEffects: OffchainEffect[];
+    /**  Return value of the function */
+    result: any;
+    /** Gas estimation results */
+    estimatedGas: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>;
+} : any;
+/**
+ * Represents the result type of sending a transaction.
+ * If `wait` is NO_WAIT, returns TxHash immediately without waiting.
+ * If `wait` is undefined or WaitOpts, returns TReturn (defaults to TxReceipt) after waiting.
+ */
+export type SendReturn<T extends InteractionWaitOptions, TReturn = TxReceipt> = T extends NoWait ? TxHash : TReturn;
+/**
+ * Transforms and cleans up the higher level SendInteractionOptions defined by the interaction into
+ * SendOptions, which are the ones that can be serialized and forwarded to the wallet
+ * @param options - The send interaction options with optional wait parameter
+ * @returns The send options to forward to the wallet
+ */
+export declare function toSendOptions<W extends InteractionWaitOptions = undefined>(options: SendInteractionOptions<W>): SendOptions<W>;
+/**
+ * Transforms and cleans up the higher level SimulateInteractionOptions defined by the interaction into
+ * SimulateOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export declare function toSimulateOptions(options: SimulateInteractionOptions): SimulateOptions;
+/**
+ * Transforms and cleans up the higher level ProfileInteractionOptions defined by the interaction into
+ * ProfileOptions, which are the ones that can be serialized and forwarded to the wallet
+ */
+export declare function toProfileOptions(options: ProfileInteractionOptions): ProfileOptions;
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dest/contract/interaction_options.js

@@ -0,0 +1,53 @@
+/**
+ * Constant for explicitly not waiting for transaction confirmation.
+ * We use this instead of false to avoid confusion with falsy checks.
+ */ export const NO_WAIT = 'NO_WAIT';
+/**
+ * Transforms and cleans up the higher level SendInteractionOptions defined by the interaction into
+ * SendOptions, which are the ones that can be serialized and forwarded to the wallet
+ * @param options - The send interaction options with optional wait parameter
+ * @returns The send options to forward to the wallet
+ */ export function toSendOptions(options) {
+    return {
+        ...options,
+        fee: {
+            // If a payment method that includes gas settings was used,
+            // try to reuse as much as possible while still allowing
+            // manual override. CAREFUL: this can cause mismatches during proving
+            gasSettings: {
+                ...options.fee?.paymentMethod?.getGasSettings(),
+                ...options.fee?.gasSettings
+            }
+        },
+        wait: options.wait
+    };
+}
+/**
+ * Transforms and cleans up the higher level SimulateInteractionOptions defined by the interaction into
+ * SimulateOptions, which are the ones that can be serialized and forwarded to the wallet
+ */ export function toSimulateOptions(options) {
+    return {
+        ...options,
+        fee: {
+            // If a payment method that includes gas settings was used,
+            // try to reuse as much as possible while still allowing
+            // manual override. CAREFUL: this can cause mismatches during proving
+            gasSettings: {
+                ...options.fee?.paymentMethod?.getGasSettings(),
+                ...options.fee?.gasSettings
+            },
+            estimateGas: options.fee?.estimateGas,
+            estimatedGasPadding: options.fee?.estimatedGasPadding
+        }
+    };
+}
+/**
+ * Transforms and cleans up the higher level ProfileInteractionOptions defined by the interaction into
+ * ProfileOptions, which are the ones that can be serialized and forwarded to the wallet
+ */ export function toProfileOptions(options) {
+    return {
+        ...toSimulateOptions(options),
+        profileMode: options.profileMode,
+        skipProofGeneration: options.skipProofGeneration
+    };
+}