@aztec/aztec.js 0.0.1-commit.03f7ef2 → 0.0.1-commit.04852196a

package/src/contract/batch_call.ts

@@ -1,20 +1,18 @@
 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';
 import {
   type RequestInteractionOptions,
   type SimulateInteractionOptions,
+  emptyOffchainOutput,
+  extractOffchainOutput,
   toSimulateOptions,
 } from './interaction_options.js';
 
 /** A batch of function calls to be sent as a single transaction through a wallet. */
+// docs:start:batch_call_class
 export class BatchCall extends BaseContractInteraction {
   constructor(
     wallet: Wallet,
@@ -22,6 +20,7 @@ export class BatchCall extends BaseContractInteraction {
   ) {
     super(wallet);
   }
+  // docs:end:batch_call_class
 
   /**
    * Returns an execution request that represents this operation.
@@ -40,9 +39,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
@@ -74,13 +73,13 @@ export class BatchCall extends BaseContractInteraction {
       { indexedExecutionPayloads: [], utility: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const batchRequests: Array<BatchedMethod<'simulateUtility'> | BatchedMethod<'simulateTx'>> = [];
+    const batchRequests: BatchedMethod[] = [];
 
     // Add utility calls to batch
     for (const [call] of utility) {
       batchRequests.push({
-        name: 'simulateUtility' as const,
-        args: [call, options?.authWitnesses] as const,
+        name: 'executeUtility' as const,
+        args: [call, { scope: options.from, authWitnesses: options.authWitnesses }],
       });
     }
 
@@ -109,9 +108,12 @@ 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;
-        results[resultIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+      if (wrappedResult.name === 'executeUtility') {
+        const rawReturnValues = (wrappedResult.result as UtilityExecutionResult).result;
+        results[resultIndex] = {
+          result: rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [],
+          ...emptyOffchainOutput(),
+        };
       }
     }
 
@@ -130,7 +132,10 @@ export class BatchCall extends BaseContractInteraction {
               ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
               : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
 
-          results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+          results[callIndex] = {
+            result: rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [],
+            ...extractOffchainOutput(simulatedTx.offchainEffects),
+          };
         });
       }
     }

package/src/contract/contract_function_interaction.ts

@@ -1,7 +1,18 @@
-import { type FunctionAbi, FunctionSelector, FunctionType, decodeFromAbi, encodeArguments } from '@aztec/stdlib/abi';
+import {
+  type ABIParameter,
+  type AbiType,
+  type FunctionAbi,
+  FunctionCall,
+  FunctionSelector,
+  FunctionType,
+  canBeMappedFromNullOrUndefined,
+  decodeFromAbi,
+  encodeArguments,
+  isOptionStruct,
+} 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';
+import type { Capsule, HashedValues, TxProfileResult } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
@@ -11,7 +22,9 @@ import {
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
   type SimulateInteractionOptions,
-  type SimulationReturn,
+  type SimulationResult,
+  emptyOffchainOutput,
+  extractOffchainOutput,
   toProfileOptions,
   toSimulateOptions,
 } from './interaction_options.js';
@@ -31,11 +44,32 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     private extraHashedArgs: HashedValues[] = [],
   ) {
     super(wallet, authWitnesses, capsules);
-    if (args.some(arg => arg === undefined || arg === null)) {
-      throw new Error(`All function interaction arguments must be defined and not null. Received: ${args}`);
+    // This may feel a bit ad-hoc here, so it warrants a comment. We accept Noir Option<T> parameters, and it's natural
+    // to map JS's null/undefined to Noir Option's None. One possible way to deal with null/undefined arguments at this
+    // point in the codebase is to conclude that they are accepted since at least one Noir type (ie: Option) can be
+    // encoded from them. Then we would let `encode` deal with potential mismatches. I chose not to do that because of
+    // the pervasiveness of null/undefined in JS, and how easy it is to inadvertently pass it around. Having this check
+    // here allows us to fail at a point where the boundaries and intent are clear.
+    if (this.hasInvalidNullOrUndefinedArguments(args)) {
+      const signature = formatFunctionSignature(this.functionDao.name, this.functionDao.parameters);
+      const received = args.map(formatArg).join(', ');
+      throw new Error(
+        `Null or undefined arguments are only allowed for Option<T> parameters in ${signature}. Received: (${received}).`,
+      );
     }
   }
 
+  private hasInvalidNullOrUndefinedArguments(args: any[]) {
+    return args.some((arg, index) => {
+      if (arg !== undefined && arg !== null) {
+        return false;
+      }
+
+      const parameterType = this.functionDao.parameters[index]?.type;
+      return !parameterType || !canBeMappedFromNullOrUndefined(parameterType);
+    });
+  }
+
   /**
    * Returns the encoded function call wrapped by this interaction
    * Useful when generating authwits
@@ -43,16 +77,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,
-    };
+    });
   }
 
   /**
@@ -90,21 +124,16 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    * function or a rich object containing extra metadata, such as estimated gas costs (if requested via options),
    * execution statistics and emitted offchain effects
    */
-  public async simulate<T extends SimulateInteractionOptions>(
-    options: T,
-  ): Promise<SimulationReturn<Exclude<T['fee'], undefined>['estimateGas']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  public async simulate<T extends SimulateInteractionOptions>(
-    options: T,
-  ): Promise<SimulationReturn<T['includeMetadata']>>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
   public async simulate(
-    options: SimulateInteractionOptions,
-  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
+    options: SimulateInteractionOptions = {} as SimulateInteractionOptions,
+  ): Promise<SimulationResult> {
     // 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) : [];
@@ -112,11 +141,11 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       if (options.includeMetadata) {
         return {
           stats: utilityResult.stats,
+          ...emptyOffchainOutput(),
           result: returnValue,
         };
-      } else {
-        return returnValue;
       }
+      return { result: returnValue, ...emptyOffchainOutput() };
     }
 
     const executionPayload = await this.request(options);
@@ -138,6 +167,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
 
     const returnValue = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    const offchainOutput = extractOffchainOutput(simulatedTx.offchainEffects);
 
     if (options.includeMetadata || options.fee?.estimateGas) {
       const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
@@ -146,13 +176,12 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       );
       return {
         stats: simulatedTx.stats,
-        offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+        ...offchainOutput,
         result: returnValue,
         estimatedGas: { gasLimits, teardownGasLimits },
       };
-    } else {
-      return returnValue;
     }
+    return { result: returnValue, ...offchainOutput };
   }
 
   /**
@@ -200,3 +229,62 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     );
   }
 }
+
+/**
+ *  Render an AbiType as a human readable string
+ * */
+function formatAbiType(abiType: AbiType): string {
+  switch (abiType.kind) {
+    case 'field':
+      return 'Field';
+    case 'boolean':
+      return 'bool';
+    case 'integer':
+      return `${abiType.sign === 'signed' ? 'i' : 'u'}${abiType.width}`;
+    case 'string':
+      return `str<${abiType.length}>`;
+    case 'array':
+      return `[${formatAbiType(abiType.type)}; ${abiType.length}]`;
+    case 'struct': {
+      if (isOptionStruct(abiType)) {
+        const innerType = abiType.fields.find(f => f.name === '_value')!.type;
+        return `Option<${formatAbiType(innerType)}>`;
+      }
+      return `(${abiType.fields.map(f => `${f.name}: ${formatAbiType(f.type)}`).join(', ')})`;
+    }
+    case 'tuple':
+      return `(${abiType.fields.map(formatAbiType).join(', ')})`;
+  }
+}
+
+/**
+ * Pretty print a function signature
+ */
+function formatFunctionSignature(name: string, parameters: ABIParameter[]): string {
+  const params = parameters.map(p => `${p.name}: ${formatAbiType(p.type)}`).join(', ');
+  return `${name}(${params})`;
+}
+
+/**
+ * Non-exhaustive pretty print of JS args to display in error messages in this module
+ */
+function formatArg(arg: unknown): string {
+  if (arg === undefined) {
+    return 'undefined';
+  }
+  if (arg === null) {
+    return 'null';
+  }
+  if (typeof arg === 'bigint') {
+    return `${arg}n`;
+  }
+  if (Array.isArray(arg)) {
+    return `[${arg.map(formatArg).join(', ')}]`;
+  }
+  if (typeof arg === 'object') {
+    const entries = Object.entries(arg).map(([k, v]) => `${k}: ${formatArg(v)}`);
+    return `{ ${entries.join(', ')} }`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string
+  return String(arg);
+}

package/src/contract/deploy_method.ts

@@ -9,27 +9,50 @@ 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, type TxProfileResult, type TxReceipt } 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 OffchainOutput,
   type ProfileInteractionOptions,
   type RequestInteractionOptions,
-  type SendInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
   type SimulationInteractionFeeOptions,
-  type SimulationReturn,
+  type SimulationResult,
+  type TxSendResultImmediate,
+  type TxSendResultMined,
+  extractOffchainOutput,
   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 +78,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 +119,41 @@ 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;
+};
+
+/** Wait options that request a full receipt instead of just the contract instance. */
+type WaitWithReturnReceipt = {
+  /** Request the full receipt instead of just the contract instance. */
+  returnReceipt: true;
+};
+
+/**
+ * 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.
+ */
+/** Result of deploying a contract when waiting for mining (default case). */
+export type DeployResultMined<TContract extends ContractBase> = {
+  /** The deployed contract instance. */
+  contract: TContract;
+  /** The deploy transaction receipt. */
+  receipt: DeployTxReceipt<TContract>;
+} & OffchainOutput;
+
+/** Conditional return type for deploy based on wait options. */
+export type DeployReturn<TContract extends ContractBase, W extends DeployInteractionWaitOptions> = W extends NoWait
+  ? TxSendResultImmediate
+  : W extends WaitWithReturnReceipt
+    ? TxSendResultMined<DeployTxReceipt<TContract>>
+    : DeployResultMined<TContract>;
+
 /**
  * Contract interaction for deployment.
  * Handles class publication, instance publication, and initialization of the contract.
@@ -92,8 +163,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 +180,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 +191,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 +221,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.
@@ -184,16 +298,17 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
 
     // Publish the contract class if it hasn't been published already.
     if (!options?.skipClassPublication) {
-      if ((await this.wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
-        this.log.debug(
-          `Skipping publication of already-registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
-        );
-      } else {
+      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());
+      } else {
+        this.log.debug(
+          `Skipping contract class publication for ${contractClass.id.toString()} as it is already registered`,
+        );
       }
     }
 
@@ -202,7 +317,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
       // 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 = await publishInstance(this.wallet, instance);
+      const deploymentInteraction = publishInstance(this.wallet, instance);
       calls.push(await deploymentInteraction.request());
     }
 
@@ -231,20 +346,44 @@ 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<DeployResultMined<TContract>>;
+  // 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 result = await this.wallet.sendTx(executionPayload, sendOptions as SendOptions<NoWait>);
+      this.log.debug(`Sent deployment tx ${result.txHash.hash} of ${this.artifact.name} contract`);
+      return result;
+    }
+
+    const { receipt, ...offchainOutput } = 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: { ...receipt, contract, instance }, ...offchainOutput };
+    }
+
+    return { contract, receipt, ...offchainOutput };
   }
 
   /**
@@ -273,9 +412,12 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
    * @returns A simulation result object containing metadata of the execution, including gas
    * estimations (if requested via options), execution statistics and emitted offchain effects
    */
-  public async simulate(options: SimulateDeployOptions): Promise<SimulationReturn<true>> {
+  public async simulate(options: SimulateDeployOptions): Promise<SimulationResult> {
     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(
@@ -283,7 +425,7 @@ export class DeployMethod<TContract extends ContractBase = ContractBase> extends
     );
     return {
       stats: simulatedTx.stats!,
-      offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+      ...extractOffchainOutput(simulatedTx.offchainEffects),
       result: undefined,
       estimatedGas: { gasLimits, teardownGasLimits },
     };
@@ -295,13 +437,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. */