@aztec/aztec.js 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/src/api/wallet.ts

@@ -1,6 +1,7 @@
 export {
   type Aliased,
   type SimulateOptions,
+  type ExecuteUtilityOptions,
   type ProfileOptions,
   type SendOptions,
   type BatchableMethods,
@@ -11,10 +12,16 @@ export {
   type Wallet,
   type PrivateEvent,
   type PrivateEventFilter,
-  FunctionCallSchema,
+  type PublicEvent,
+  type PublicEventFilter,
+  type ContractMetadata,
+  type ContractClassMetadata,
+  AppCapabilitiesSchema,
+  WalletCapabilitiesSchema,
   ExecutionPayloadSchema,
   GasSettingsOptionSchema,
   WalletSimulationFeeOptionSchema,
+  WaitOptsSchema,
   SendOptionsSchema,
   SimulateOptionsSchema,
   ProfileOptionsSchema,
@@ -23,9 +30,49 @@ export {
   EventMetadataDefinitionSchema,
   PrivateEventSchema,
   PrivateEventFilterSchema,
+  PublicEventSchema,
+  PublicEventFilterSchema,
+  ContractClassMetadataSchema,
+  ContractMetadataSchema,
   WalletSchema,
+  ContractFunctionPatternSchema,
+  AccountsCapabilitySchema,
+  GrantedAccountsCapabilitySchema,
+  ContractsCapabilitySchema,
+  GrantedContractsCapabilitySchema,
+  ContractClassesCapabilitySchema,
+  GrantedContractClassesCapabilitySchema,
+  SimulationCapabilitySchema,
+  GrantedSimulationCapabilitySchema,
+  TransactionCapabilitySchema,
+  GrantedTransactionCapabilitySchema,
+  DataCapabilitySchema,
+  GrantedDataCapabilitySchema,
+  CapabilitySchema,
+  GrantedCapabilitySchema,
 } from '../wallet/wallet.js';
 
+export {
+  type AppCapabilities,
+  type WalletCapabilities,
+  CAPABILITY_VERSION,
+  type Capability,
+  type GrantedCapability,
+  type ContractFunctionPattern,
+  type AccountsCapability,
+  type GrantedAccountsCapability,
+  type ContractsCapability,
+  type GrantedContractsCapability,
+  type ContractClassesCapability,
+  type GrantedContractClassesCapability,
+  type SimulationCapability,
+  type GrantedSimulationCapability,
+  type TransactionCapability,
+  type GrantedTransactionCapability,
+  type DataCapability,
+  type GrantedDataCapability,
+} from '../wallet/capabilities.js';
+
 export { AccountManager } from '../wallet/account_manager.js';
 
 export { type DeployAccountOptions, DeployAccountMethod } from '../wallet/deploy_account_method.js';

package/src/contract/base_contract_interaction.ts

@@ -1,10 +1,16 @@
 import { createLogger } from '@aztec/foundation/log';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { Capsule, ExecutionPayload } from '@aztec/stdlib/tx';
+import type { Capsule, ExecutionPayload, TxReceipt } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
-import { type RequestInteractionOptions, type SendInteractionOptions, toSendOptions } from './interaction_options.js';
-import { SentTx } from './sent_tx.js';
+import {
+  type InteractionWaitOptions,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
+  type SendReturn,
+  toSendOptions,
+} from './interaction_options.js';
 
 /**
  * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
@@ -30,20 +36,26 @@ export abstract class BaseContractInteraction {
   // docs:start:send
   /**
    * Sends a transaction to the contract function with the specified options.
-   * This function throws an error if called on a utility 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.
+   * By default, waits for the transaction to be mined and returns the receipt (or custom type).
    * @param options - An object containing 'from' property representing
-   * the AztecAddress of the sender and optional fee configuration
-   * @returns A SentTx instance for tracking the transaction status and information.
+   * the AztecAddress of the sender, optional fee configuration, and optional wait settings
+   * @returns TReturn (if wait is undefined/WaitOpts) or TxHash (if wait is NO_WAIT)
    */
-  public send(options: SendInteractionOptions): SentTx {
+  // Overload for when wait is not specified at all - returns TReturn
+  public send<TReturn = TxReceipt>(options: SendInteractionOptionsWithoutWait): Promise<TReturn>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public send<TReturn = TxReceipt, W extends InteractionWaitOptions = undefined>(
+    options: SendInteractionOptions<W>,
+  ): Promise<SendReturn<W, TReturn>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public async send<TReturn = TxReceipt>(
+    options: SendInteractionOptions<InteractionWaitOptions>,
+  ): Promise<SendReturn<typeof options.wait, TReturn>> {
     // docs:end:send
-    const sendTx = async () => {
-      const executionPayload = await this.request(options);
-      const sendOptions = toSendOptions(options);
-      return this.wallet.sendTx(executionPayload, sendOptions);
-    };
-    return new SentTx(this.wallet, sendTx);
+    const executionPayload = await this.request(options);
+    const sendOptions = toSendOptions(options);
+
+    return (await this.wallet.sendTx(executionPayload, sendOptions as any)) as SendReturn<typeof options.wait, TReturn>;
   }
 }

package/src/contract/batch_call.ts

@@ -1,10 +1,5 @@
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
-import {
-  ExecutionPayload,
-  TxSimulationResult,
-  UtilitySimulationResult,
-  mergeExecutionPayloads,
-} from '@aztec/stdlib/tx';
+import { ExecutionPayload, TxSimulationResult, UtilityExecutionResult, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import type { BatchedMethod, Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
@@ -42,9 +37,9 @@ export class BatchCall extends BaseContractInteraction {
   }
 
   /**
-   * Simulates the batch, supporting private, public and utility functions. Although this is a single
+   * Simulates/executes the batch, supporting private, public and utility functions. Although this is a single
    * interaction with the wallet, private and public functions will be grouped into a single ExecutionPayload
-   * that the wallet will simulate as a single transaction. Utility function calls will simply be executed
+   * that the wallet will simulate as a single transaction. Utility function calls will be executed
    * one by one.
    * @param options - An optional object containing additional configuration for the interaction.
    * @returns The results of all the interactions that make up the batch
@@ -81,8 +76,8 @@ export class BatchCall extends BaseContractInteraction {
     // Add utility calls to batch
     for (const [call] of utility) {
       batchRequests.push({
-        name: 'simulateUtility' as const,
-        args: [call, options?.authWitnesses],
+        name: 'executeUtility' as const,
+        args: [call, { scope: options.from, authWitnesses: options.authWitnesses }],
       });
     }
 
@@ -111,8 +106,8 @@ export class BatchCall extends BaseContractInteraction {
     for (let i = 0; i < utility.length; i++) {
       const [call, resultIndex] = utility[i];
       const wrappedResult = batchResults[i];
-      if (wrappedResult.name === 'simulateUtility') {
-        const rawReturnValues = (wrappedResult.result as UtilitySimulationResult).result;
+      if (wrappedResult.name === 'executeUtility') {
+        const rawReturnValues = (wrappedResult.result as UtilityExecutionResult).result;
         results[resultIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
       }
     }

package/src/contract/contract_function_interaction.ts

@@ -1,4 +1,11 @@
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi, encodeArguments } from '@aztec/stdlib/abi';
+import {
+  type FunctionAbi,
+  FunctionCall,
+  FunctionSelector,
+  FunctionType,
+  decodeFromAbi,
+  encodeArguments,
+} from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type Capsule, type HashedValues, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
@@ -43,16 +50,16 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    */
   public async getFunctionCall() {
     const args = encodeArguments(this.functionDao, this.args);
-    return {
+    return FunctionCall.from({
       name: this.functionDao.name,
-      args,
+      to: this.contractAddress,
       selector: await FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
       type: this.functionDao.functionType,
-      to: this.contractAddress,
-      isStatic: this.functionDao.isStatic,
       hideMsgSender: false /** Only set to `true` for enqueued public function calls */,
+      isStatic: this.functionDao.isStatic,
+      args,
       returnTypes: this.functionDao.returnTypes,
-    };
+    });
   }
 
   /**
@@ -104,7 +111,10 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     // docs:end:simulate
     if (this.functionDao.functionType == FunctionType.UTILITY) {
       const call = await this.getFunctionCall();
-      const utilityResult = await this.wallet.simulateUtility(call, options.authWitnesses ?? []);
+      const utilityResult = await this.wallet.executeUtility(call, {
+        scope: options.from,
+        authWitnesses: options.authWitnesses,
+      });
 
       // Decode the raw field elements to the actual return type
       const returnValue = utilityResult.result ? decodeFromAbi(this.functionDao.returnTypes, utilityResult.result) : [];

package/src/contract/deploy_method.ts

@@ -9,27 +9,53 @@ import {
   getContractInstanceFromInstantiationParams,
 } from '@aztec/stdlib/contract';
 import type { PublicKeys } from '@aztec/stdlib/keys';
-import { type Capsule, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
+import {
+  type Capsule,
+  HashedValues,
+  TxHash,
+  type TxProfileResult,
+  type TxReceipt,
+  collectOffchainEffects,
+} from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import { publishContractClass } from '../deployment/publish_class.js';
 import { publishInstance } from '../deployment/publish_instance.js';
-import type { Wallet } from '../wallet/wallet.js';
+import type { ProfileOptions, SendOptions, SimulateOptions, Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
 import type { ContractBase } from './contract_base.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
-import { DeploySentTx } from './deploy_sent_tx.js';
 import { getGasLimits } from './get_gas_limits.js';
 import {
+  NO_WAIT,
+  type NoWait,
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
-  type SendInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
   type SimulationInteractionFeeOptions,
   type SimulationReturn,
   toProfileOptions,
   toSendOptions,
   toSimulateOptions,
 } from './interaction_options.js';
+import type { WaitOpts } from './wait_opts.js';
+
+/**
+ * Wait options specific to deployment transactions.
+ * Extends WaitOpts with a flag to return the full receipt instead of just the contract.
+ */
+export type DeployWaitOptions = WaitOpts & {
+  /** If true, return the full DeployTxReceipt instead of just the contract. Defaults to false. */
+  returnReceipt?: boolean;
+};
+
+/**
+ * Type for wait options in deployment interactions.
+ * - NO_WAIT symbol: Don't wait, return TxHash immediately
+ * - DeployWaitOptions: Wait with custom options
+ * - undefined: Wait with default options
+ */
+export type DeployInteractionWaitOptions = NoWait | DeployWaitOptions | undefined;
 
 /**
  * Options for deploying a contract on the Aztec network.
@@ -55,21 +81,34 @@ export type RequestDeployOptions = RequestInteractionOptions & {
 };
 
 /**
- * Extends the deployment options with the required parameters to send the transaction
+ * Base deployment options without wait parameter.
  */
-export type DeployOptions = Omit<RequestDeployOptions, 'deployer'> & {
+export type DeployOptionsWithoutWait = Omit<RequestDeployOptions, 'deployer'> & {
   /**
    * Set to true to *not* include the sender in the address computation. This option
    * is mutually exclusive with "deployer"
    */
   universalDeploy?: boolean;
-} & Pick<SendInteractionOptions, 'from' | 'fee'>;
+} & Pick<SendInteractionOptionsWithoutWait, 'from' | 'fee' | 'additionalScopes'>;
+
+/**
+ * Extends the deployment options with the required parameters to send the transaction.
+ */
+export type DeployOptions<W extends DeployInteractionWaitOptions = undefined> = DeployOptionsWithoutWait & {
+  /**
+   * Options for waiting for the transaction to be mined.
+   * - undefined (default): wait with default options and return the contract instance
+   * - DeployWaitOptions: wait with custom options and return contract or receipt based on returnReceipt flag
+   * - NO_WAIT: return TxHash immediately without waiting
+   */
+  wait?: W;
+};
 
 /**
  * Options for simulating the deployment of a contract
  * Allows skipping certain validations and computing gas estimations
  */
-export type SimulateDeployOptions = Omit<DeployOptions, 'fee'> & {
+export type SimulateDeployOptions = Omit<DeployOptionsWithoutWait, 'fee'> & {
   /** The fee options for the transaction. */
   fee?: SimulationInteractionFeeOptions;
   /** Simulate without checking for the validity of the resulting transaction,
@@ -83,6 +122,29 @@ export type SimulateDeployOptions = Omit<DeployOptions, 'fee'> & {
   includeMetadata?: boolean;
 };
 
+/** Receipt for a deployment transaction with the deployed contract instance. */
+export type DeployTxReceipt<TContract extends ContractBase = ContractBase> = TxReceipt & {
+  /** Type-safe wrapper around the deployed contract instance, linked to the deployment wallet */
+  contract: TContract;
+  /** The deployed contract instance with address and metadata. */
+  instance: ContractInstanceWithAddress;
+};
+
+/**
+ * Represents the result type of deploying a contract.
+ * - If wait is NO_WAIT, returns TxHash immediately.
+ * - If wait has returnReceipt: true, returns DeployTxReceipt after waiting.
+ * - Otherwise (undefined or DeployWaitOptions without returnReceipt), returns TContract after waiting.
+ */
+export type DeployReturn<TContract extends ContractBase, W extends DeployInteractionWaitOptions> = W extends NoWait
+  ? TxHash
+  : W extends {
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        returnReceipt: true;
+      }
+    ? DeployTxReceipt<TContract>
+    : TContract;
+
 /**
  * Contract interaction for deployment.
  * Handles class publication, instance publication, and initialization of the contract.
@@ -92,8 +154,6 @@ export type SimulateDeployOptions = Omit<DeployOptions, 'fee'> & {
  * 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".
- *
- * Extends the BaseContractInteraction class.
  */
 export class DeployMethod<TContract extends ContractBase = ContractBase> extends BaseContractInteraction {
   /** The contract instance to be deployed. */
@@ -111,6 +171,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     constructorNameOrArtifact?: string | FunctionArtifact,
     authWitnesses: AuthWitness[] = [],
     capsules: Capsule[] = [],
+    private extraHashedArgs: HashedValues[] = [],
   ) {
     super(wallet, authWitnesses, capsules);
     this.constructorArtifact = getInitializer(artifact, constructorNameOrArtifact);
@@ -121,20 +182,29 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @param options - Configuration options.
    * @returns The execution payload for this operation
    */
-  public async request(options?: RequestDeployOptions): Promise<ExecutionPayload> {
+  public async request(options: RequestDeployOptions = {}): Promise<ExecutionPayload> {
     const publication = await this.getPublicationExecutionPayload(options);
 
     if (!options?.skipRegistration) {
       await this.wallet.registerContract(await this.getInstance(options), this.artifact);
     }
+    const { authWitnesses, capsules } = options;
 
+    // Propagates the included authwitnesses, capsules, and extraHashedArgs
+    // potentially baked into the interaction
+    const initialExecutionPayload = new ExecutionPayload(
+      [],
+      this.authWitnesses.concat(authWitnesses ?? []),
+      this.capsules.concat(capsules ?? []),
+      this.extraHashedArgs,
+    );
     const 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]);
+      ? mergeExecutionPayloads([initialExecutionPayload, feeExecutionPayload, publication, initialization])
+      : mergeExecutionPayloads([initialExecutionPayload, publication, initialization]);
     if (!finalExecutionPayload.calls.length) {
       throw new Error(`No transactions are needed to publish or initialize contract ${this.artifact.name}`);
     }
@@ -142,13 +212,48 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     return finalExecutionPayload;
   }
 
-  convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
+  convertDeployOptionsToRequestOptions(options: DeployOptionsWithoutWait): RequestDeployOptions {
     return {
       ...options,
       deployer: !options?.universalDeploy ? options.from : undefined,
     };
   }
 
+  /**
+   * Converts DeployOptions to SendOptions, stripping out the returnReceipt flag if present.
+   * @param options - Deploy options with wait parameter
+   * @returns Send options with wait parameter
+   */
+  protected convertDeployOptionsToSendOptions<W extends DeployInteractionWaitOptions>(
+    options: DeployOptions<W>,
+    // eslint-disable-next-line jsdoc/require-jsdoc
+  ): SendOptions<W extends { returnReceipt: true } ? WaitOpts : W> {
+    return {
+      ...toSendOptions({
+        ...options,
+        wait: options.wait as any,
+      }),
+    } as any;
+  }
+
+  /**
+   * Converts deploy simulation options into wallet-level simulate options.
+   * @param options - The deploy simulation options to convert.
+   */
+  protected convertDeployOptionsToSimulateOptions(options: SimulateDeployOptions): SimulateOptions {
+    return toSimulateOptions(options);
+  }
+
+  /**
+   * Converts deploy profile options into wallet-level profile options.
+   * @param options - The deploy profile options to convert.
+   */
+  protected convertDeployOptionsToProfileOptions(
+    options: DeployOptionsWithoutWait & ProfileInteractionOptions,
+  ): ProfileOptions {
+    return toProfileOptions(options);
+  }
+
   /**
    * Adds this contract to the wallet and returns the Contract object.
    * @param options - Deployment options.
@@ -232,20 +337,42 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
 
   /**
    * Send a contract deployment transaction (initialize and/or publish) using the provided options.
-   * This function extends the 'send' method from the ContractFunctionInteraction class,
-   * allowing us to send a transaction specifically for contract deployment.
+   * By default, waits for the transaction to be mined and returns the deployed contract instance.
    *
    * @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.
+   * @returns TxHash (if wait is NO_WAIT), TContract (if wait is undefined or doesn't have returnReceipt), or DeployTxReceipt (if wait.returnReceipt is true)
    */
-  public override send(options: DeployOptions): DeploySentTx<TContract> {
-    const sendTx = async () => {
-      const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
-      const sendOptions = toSendOptions(options);
-      return this.wallet.sendTx(executionPayload, sendOptions);
-    };
-    this.log.debug(`Sent deployment tx of ${this.artifact.name} contract`);
-    return new DeploySentTx(this.wallet, sendTx, this.postDeployCtor, () => this.getInstance(options));
+  // Overload for when wait is not specified at all - returns the contract
+  public override send(options: DeployOptionsWithoutWait): Promise<TContract>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override send<W extends DeployInteractionWaitOptions>(
+    options: DeployOptions<W>,
+  ): Promise<DeployReturn<TContract, W>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override async send(options: DeployOptions<DeployInteractionWaitOptions>): Promise<any> {
+    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 as SendOptions<NoWait>);
+      this.log.debug(`Sent deployment tx ${txHash.hash} of ${this.artifact.name} contract`);
+      return txHash;
+    }
+
+    const receipt = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<WaitOpts | undefined>);
+    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) as TContract;
+
+    // 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;
   }
 
   /**
@@ -276,7 +403,10 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    */
   public async simulate(options: SimulateDeployOptions): Promise<SimulationReturn<true>> {
     const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
-    const simulatedTx = await this.wallet.simulateTx(executionPayload, toSimulateOptions(options));
+    const simulatedTx = await this.wallet.simulateTx(
+      executionPayload,
+      this.convertDeployOptionsToSimulateOptions(options),
+    );
 
     const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
     this.log.verbose(
@@ -296,13 +426,9 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    *
    * @returns An object containing the function return value and profile result.
    */
-  public async profile(options: DeployOptions & ProfileInteractionOptions): Promise<TxProfileResult> {
+  public async profile(options: DeployOptionsWithoutWait & ProfileInteractionOptions): Promise<TxProfileResult> {
     const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
-    return await this.wallet.profileTx(executionPayload, {
-      ...toProfileOptions(options),
-      profileMode: options.profileMode,
-      skipProofGeneration: options.skipProofGeneration,
-    });
+    return await this.wallet.profileTx(executionPayload, this.convertDeployOptionsToProfileOptions(options));
   }
 
   /** Return this deployment address. */

package/src/contract/get_gas_limits.ts

@@ -1,4 +1,4 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 import { Gas } from '@aztec/stdlib/gas';
 import type { TxSimulationResult } from '@aztec/stdlib/tx';
 
@@ -23,8 +23,8 @@ export function getGasLimits(
   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');
+  if (gasLimits.l2Gas > MAX_PROCESSABLE_L2_GAS) {
+    throw new Error('Transaction consumes more l2 gas than the maximum processable gas');
   }
   return {
     gasLimits,

package/src/contract/interaction_options.ts

@@ -2,10 +2,11 @@ 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 } from '@aztec/stdlib/tx';
+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
@@ -55,13 +56,52 @@ export type RequestInteractionOptions = {
 };
 
 /**
- * Represents options for calling a (constrained) function in a contract.
+ * 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' as const;
+
+/**
+ * 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 SendInteractionOptions = RequestInteractionOptions & {
+export type SendInteractionOptionsWithoutWait = RequestInteractionOptions & {
   /** The sender's Aztec address. */
   from: AztecAddress;
   /** The fee options for the transaction. */
   fee?: InteractionFeeOptions;
+  /**
+   * Additional addresses whose private state and keys should be accessible during execution,
+   * beyond the sender's. Required when the transaction needs to access private state or keys
+   * belonging to an address other than `from`, e.g. withdrawing from an escrow that holds
+   * its own private notes.
+   */
+  additionalScopes?: AztecAddress[];
+};
+
+/**
+ * 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;
 };
 
 /**
@@ -110,11 +150,22 @@ export type SimulationReturn<T extends boolean | undefined> = T extends true
     }
   : 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 function toSendOptions(options: SendInteractionOptions): SendOptions {
+export function toSendOptions<W extends InteractionWaitOptions = undefined>(
+  options: SendInteractionOptions<W>,
+): SendOptions<W> {
   return {
     ...options,
     fee: {
@@ -126,6 +177,7 @@ export function toSendOptions(options: SendInteractionOptions): SendOptions {
         ...options.fee?.gasSettings,
       },
     },
+    wait: options.wait, // Pass through wait option
   };
 }