@aztec/aztec.js 0.80.0 → 0.82.0

package/src/api/contract.ts

@@ -36,12 +36,11 @@
  * @packageDocumentation
  */
 export { Contract } from '../contract/contract.js';
-export {
-  ContractFunctionInteraction,
-  type ProfileResult,
-  type SendMethodOptions,
-} from '../contract/contract_function_interaction.js';
+export { ContractFunctionInteraction, type SendMethodOptions } from '../contract/contract_function_interaction.js';
+
+export { TxProfileResult } from '@aztec/stdlib/tx';
 export { DefaultWaitOpts, SentTx, type WaitOpts } from '../contract/sent_tx.js';
+export { ProvenTx } from '../contract/proven_tx.js';
 export {
   ContractBase,
   type ContractMethod,
@@ -51,6 +50,7 @@ export {
 export { BatchCall } from '../contract/batch_call.js';
 export { type DeployOptions, DeployMethod } from '../contract/deploy_method.js';
 export { DeploySentTx } from '../contract/deploy_sent_tx.js';
+export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
 
 export {
   type PartialAddress,

package/src/api/fee.ts

@@ -1,4 +1,4 @@
-export type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+export type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
 export { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
 export { PrivateFeePaymentMethod } from '../fee/private_fee_payment_method.js';
 export { PublicFeePaymentMethod } from '../fee/public_fee_payment_method.js';

package/src/api/utils.ts

@@ -10,11 +10,11 @@ export {
 } from '../utils/abi_types.js';
 export {
   computeAuthWitMessageHash,
-  computeInnerAuthWitHash,
   computeInnerAuthWitHashFromAction,
   type IntentAction,
   type IntentInnerHash,
 } from '../utils/authwit.js';
+export { computeInnerAuthWitHash } from '@aztec/stdlib/auth-witness';
 export { waitForPXE } from '../utils/pxe.js';
 export { waitForNode, createAztecNodeClient, type AztecNode } from '../utils/node.js';
 export { getFeeJuiceBalance } from '../utils/fee_juice.js';

package/src/api/wallet.ts

@@ -1 +1,7 @@
-export { AccountWallet, AccountWalletWithSecretKey, SignerlessWallet, getWallet } from '../wallet/index.js';
+export {
+  AccountWallet,
+  AccountWalletWithSecretKey,
+  SignerlessWallet,
+  getWallet,
+  type Wallet,
+} from '../wallet/index.js';

package/src/contract/base_contract_interaction.ts

@@ -1,22 +1,32 @@
+import type { FeeOptions, TxExecutionOptions, UserFeeOptions } from '@aztec/entrypoints/interfaces';
+import type { ExecutionPayload } from '@aztec/entrypoints/payload';
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { GasSettings } from '@aztec/stdlib/gas';
-import type { Capsule, HashedValues, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
+import type { Capsule, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import type { FeeOptions, UserFeeOptions } from '../entrypoint/payload.js';
 import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { getGasLimits } from './get_gas_limits.js';
 import { ProvenTx } from './proven_tx.js';
 import { SentTx } from './sent_tx.js';
 
+/**
+ * Represents the options to configure a request from a contract interaction.
+ * Allows specifying additional auth witnesses and capsules to use during execution
+ */
+export type RequestMethodOptions = {
+  /** Extra authwits to use during execution */
+  authWitnesses?: AuthWitness[];
+  /** Extra capsules to use during execution */
+  capsules?: Capsule[];
+};
+
 /**
  * Represents options for calling a (constrained) function in a contract.
- * Allows the user to specify the sender address and nonce for a transaction.
  */
-export type SendMethodOptions = {
+export type SendMethodOptions = RequestMethodOptions & {
   /** Wether to skip the simulation of the public part of the transaction. */
   skipPublicSimulation?: boolean;
   /** The fee options for the transaction. */
@@ -34,11 +44,11 @@ export type SendMethodOptions = {
 export abstract class BaseContractInteraction {
   protected log = createLogger('aztecjs:contract_interaction');
 
-  protected authWitnesses: AuthWitness[] = [];
-  protected hashedArguments: HashedValues[] = [];
-  protected capsules: Capsule[] = [];
-
-  constructor(protected wallet: Wallet) {}
+  constructor(
+    protected wallet: Wallet,
+    protected authWitnesses: AuthWitness[] = [],
+    protected capsules: Capsule[] = [],
+  ) {}
 
   /**
    * Create a transaction execution request ready to be simulated.
@@ -53,7 +63,7 @@ export abstract class BaseContractInteraction {
    * @param options - An optional object containing additional configuration for the transaction.
    * @returns An execution request wrapped in promise.
    */
-  public abstract request(options?: SendMethodOptions): Promise<Omit<ExecutionRequestInit, 'fee'>>;
+  public abstract request(options?: RequestMethodOptions): Promise<ExecutionPayload>;
 
   /**
    * Creates a transaction execution request, simulates and proves it. Differs from .prove in
@@ -141,23 +151,26 @@ export abstract class BaseContractInteraction {
   // docs:start:getFeeOptions
   /**
    * Return fee options based on the user opts, estimating tx gas if needed.
-   * @param request - Request to execute for this interaction.
-   * @param pad - Percentage to pad the suggested gas limits by, as decimal (e.g., 0.10 for 10%).
+   * @param executionPayload - Execution payload to get the fee for
+   * @param fee - User-provided fee options.
+   * @param options - Additional options for the transaction. They must faithfully represent the tx to get accurate fee estimates
    * @returns Fee options for the actual transaction.
    */
   protected async getFeeOptions(
-    request: Omit<ExecutionRequestInit, 'fee'> & { /** User-provided fee options */ fee?: UserFeeOptions },
+    executionPayload: ExecutionPayload,
+    fee: UserFeeOptions = {},
+    options: TxExecutionOptions,
   ): Promise<FeeOptions> {
     // docs:end:getFeeOptions
-    const defaultFeeOptions = await this.getDefaultFeeOptions(request.fee);
+    const defaultFeeOptions = await this.getDefaultFeeOptions(fee);
     const paymentMethod = defaultFeeOptions.paymentMethod;
     const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
     const maxPriorityFeesPerGas = defaultFeeOptions.gasSettings.maxPriorityFeesPerGas;
 
     let gasSettings = defaultFeeOptions.gasSettings;
-    if (request.fee?.estimateGas) {
+    if (fee?.estimateGas) {
       const feeForEstimation: FeeOptions = { paymentMethod, gasSettings };
-      const txRequest = await this.wallet.createTxExecutionRequest({ ...request, fee: feeForEstimation });
+      const txRequest = await this.wallet.createTxExecutionRequest(executionPayload, feeForEstimation, options);
       const simulationResult = await this.wallet.simulateTx(
         txRequest,
         true /*simulatePublic*/,
@@ -167,7 +180,7 @@ export abstract class BaseContractInteraction {
       );
       const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
         simulationResult,
-        request.fee?.estimatedGasPadding,
+        fee?.estimatedGasPadding,
       );
       gasSettings = GasSettings.from({ maxFeesPerGas, maxPriorityFeesPerGas, gasLimits, teardownGasLimits });
       this.log.verbose(
@@ -177,73 +190,4 @@ export abstract class BaseContractInteraction {
 
     return { gasSettings, paymentMethod };
   }
-
-  /**
-   * Add authWitness used in this contract interaction.
-   * @param authWitness - authWitness used in the contract interaction.
-   */
-  public addAuthWitness(authWitness: AuthWitness) {
-    this.authWitnesses.push(authWitness);
-  }
-
-  /**
-   * Add authWitness used in this contract interaction.
-   * @param authWitnesses - authWitnesses used in the contract interaction.
-   */
-  public addAuthWitnesses(authWitnesses: AuthWitness[]) {
-    this.authWitnesses.push(...authWitnesses);
-  }
-
-  /**
-   * Return all authWitnesses added for this interaction.
-   */
-  public getAuthWitnesses() {
-    return this.authWitnesses;
-  }
-
-  /**
-   * Add hashedArgument used in this contract interaction.
-   * @param hashedArgument - hashedArgument used in the contract interaction.
-   */
-  public addHashedArgument(hashedArgument: HashedValues) {
-    this.hashedArguments.push(hashedArgument);
-  }
-
-  /**
-   * Add hashedArguments used in this contract interaction.
-   * @param hashedArguments - hashedArguments used in the contract interaction.
-   */
-  public addHashedArguments(hashedArguments: HashedValues[]) {
-    this.hashedArguments.push(...hashedArguments);
-  }
-
-  /**
-   * Return all hashedArguments added for this interaction.
-   */
-  public getHashedArguments() {
-    return this.hashedArguments;
-  }
-
-  /**
-   * Add data passed to the oracle calls during this contract interaction.
-   * @param capsule - Data passed to oracle calls.
-   */
-  public addCapsule(capsule: Capsule) {
-    this.capsules.push(capsule);
-  }
-
-  /**
-   * Add data passed to the oracle calls during this contract interaction.
-   * @param capsules - Data passed to oracle calls.
-   */
-  public addCapsules(capsules: Capsule[]) {
-    this.capsules.push(...capsules);
-  }
-
-  /**
-   * Return all capsules added for this contract interaction.
-   */
-  public getCapsules() {
-    return this.capsules;
-  }
 }

package/src/contract/batch_call.ts

@@ -1,9 +1,13 @@
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
 import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
-import { type ExecutionRequestInit, mergeExecutionRequestInits } from '../entrypoint/entrypoint.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+import type { Wallet } from '../wallet/wallet.js';
+import {
+  BaseContractInteraction,
+  type RequestMethodOptions,
+  type SendMethodOptions,
+} from './base_contract_interaction.js';
 import type { SimulateMethodOptions } from './contract_function_interaction.js';
 
 /** A batch of function calls to be sent as a single transaction through a wallet. */
@@ -21,21 +25,26 @@ export class BatchCall extends BaseContractInteraction {
   public async create(options: SendMethodOptions = {}): Promise<TxExecutionRequest> {
     const requestWithoutFee = await this.request(options);
 
-    const { fee: userFee } = options;
-    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: userFee });
+    const { fee: userFee, nonce, cancellable } = options;
+    const fee = await this.getFeeOptions(requestWithoutFee, userFee, { nonce, cancellable });
 
-    return await this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
+    return await this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { nonce, cancellable });
   }
 
   /**
    * Returns an execution request that represents this operation.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns An execution request wrapped in promise.
+   * @param options - An optional object containing additional configuration for the request generation.
+   * @returns An execution payload wrapped in promise.
    */
-  public async request(options: SendMethodOptions = {}): Promise<Omit<ExecutionRequestInit, 'fee'>> {
+  public async request(options: RequestMethodOptions = {}): Promise<ExecutionPayload> {
     const requests = await this.getRequests();
-    const { nonce, cancellable } = options;
-    return mergeExecutionRequestInits(requests, { nonce, cancellable });
+    const combinedPayload = mergeExecutionPayloads(requests);
+    return new ExecutionPayload(
+      combinedPayload.calls,
+      combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
+      combinedPayload.capsules.concat(options.capsules ?? []),
+      combinedPayload.extraHashedArgs,
+    );
   }
 
   /**
@@ -48,13 +57,13 @@ export class BatchCall extends BaseContractInteraction {
    * @returns The result of the transaction as returned by the contract function.
    */
   public async simulate(options: SimulateMethodOptions = {}): Promise<any> {
-    const { indexedRequests, unconstrained } = (await this.getRequests()).reduce<{
+    const { indexedExecutionPayloads, unconstrained } = (await this.getRequests()).reduce<{
       /** Keep track of the number of private calls to retrieve the return values */
       privateIndex: 0;
       /** Keep track of the number of public calls to retrieve the return values */
       publicIndex: 0;
       /** The public and private function execution requests in the batch */
-      indexedRequests: [Omit<ExecutionRequestInit, 'fee'>, number, number][];
+      indexedExecutionPayloads: [ExecutionPayload, number, number][];
       /** The unconstrained function calls in the batch. */
       unconstrained: [FunctionCall, number][];
     }>(
@@ -63,7 +72,7 @@ export class BatchCall extends BaseContractInteraction {
         if (call.type === FunctionType.UNCONSTRAINED) {
           acc.unconstrained.push([call, index]);
         } else {
-          acc.indexedRequests.push([
+          acc.indexedExecutionPayloads.push([
             current,
             index,
             call.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
@@ -71,18 +80,27 @@ export class BatchCall extends BaseContractInteraction {
         }
         return acc;
       },
-      { indexedRequests: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
+      { indexedExecutionPayloads: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const requests = indexedRequests.map(([request]) => request);
-    const requestWithoutFee = mergeExecutionRequestInits(requests);
-    const { fee: userFee } = options;
-    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: userFee });
-    const txRequest = await this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
+    const payloads = indexedExecutionPayloads.map(([request]) => request);
+    const combinedPayload = mergeExecutionPayloads(payloads);
+    const requestWithoutFee = new ExecutionPayload(
+      combinedPayload.calls,
+      combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
+      combinedPayload.capsules.concat(options.capsules ?? []),
+      combinedPayload.extraHashedArgs,
+    );
+    const { fee: userFee, nonce, cancellable } = options;
+    const fee = await this.getFeeOptions(requestWithoutFee, userFee, {});
+    const txRequest = await this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { nonce, cancellable });
 
     const unconstrainedCalls = unconstrained.map(
       async ([call, index]) =>
-        [await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from), index] as const,
+        [
+          await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.authWitnesses, options?.from),
+          index,
+        ] as const,
     );
 
     const [unconstrainedResults, simulatedTx] = await Promise.all([
@@ -95,7 +113,7 @@ export class BatchCall extends BaseContractInteraction {
     unconstrainedResults.forEach(([result, index]) => {
       results[index] = result;
     });
-    indexedRequests.forEach(([request, callIndex, resultIndex]) => {
+    indexedExecutionPayloads.forEach(([request, callIndex, resultIndex]) => {
       const call = request.calls[0];
       // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
       // since we're interested in the first set of values AFTER the account entrypoint
@@ -110,27 +128,6 @@ export class BatchCall extends BaseContractInteraction {
     return results;
   }
 
-  /**
-   * Return all authWitnesses added for this interaction.
-   */
-  public override getAuthWitnesses() {
-    return [this.authWitnesses, ...this.calls.map(c => c.getAuthWitnesses())].flat();
-  }
-
-  /**
-   * Return all hashedArguments added for this interaction.
-   */
-  public override getHashedArguments() {
-    return [this.hashedArguments, ...this.calls.map(c => c.getHashedArguments())].flat();
-  }
-
-  /**
-   * Return all capsules added for this interaction.
-   */
-  public override getCapsules() {
-    return [this.capsules, ...this.calls.map(c => c.getCapsules())].flat();
-  }
-
   private async getRequests() {
     return await Promise.all(this.calls.map(c => c.request()));
   }

package/src/contract/contract.ts

@@ -3,7 +3,7 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/wallet.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractBase } from './contract_base.js';
 import { DeployMethod } from './deploy_method.js';
 

package/src/contract/contract_base.ts

@@ -8,7 +8,7 @@ import {
 } from '@aztec/stdlib/abi';
 import { type ContractInstanceWithAddress, computePartialAddress } from '@aztec/stdlib/contract';
 
-import type { Wallet } from '../account/wallet.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 
 /**

package/src/contract/contract_function_interaction.ts

@@ -1,12 +1,15 @@
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { type FunctionAbi, 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 { PrivateKernelProverProfileResult } from '@aztec/stdlib/kernel';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { Capsule, HashedValues, TxExecutionRequest, TxProfileResult } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
+import type { Wallet } from '../wallet/wallet.js';
+import {
+  BaseContractInteraction,
+  type RequestMethodOptions,
+  type SendMethodOptions,
+} from './base_contract_interaction.js';
 
 export type { SendMethodOptions };
 
@@ -15,21 +18,31 @@ export type { SendMethodOptions };
  * Allows specifying the address from which the view method should be called.
  * Disregarded for simulation of public functions
  */
-export type SimulateMethodOptions = Pick<SendMethodOptions, 'fee'> & {
+export type ProfileMethodOptions = Pick<
+  SendMethodOptions,
+  'authWitnesses' | 'capsules' | 'fee' | 'nonce' | 'cancellable'
+> & {
+  /** Whether to return gates information or the bytecode/witnesses. */
+  profileMode: 'gates' | 'execution-steps' | 'full';
   /** The sender's Aztec address. */
   from?: AztecAddress;
-  /** Simulate without checking for the validity of the resulting transaction, e.g. whether it emits any existing nullifiers. */
-  skipTxValidation?: boolean;
-  /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
-  skipFeeEnforcement?: boolean;
 };
 
 /**
- * The result of a profile() call.
+ * 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 ProfileResult = PrivateKernelProverProfileResult & {
-  /** The result of the transaction as returned by the contract function. */
-  returnValues: any;
+export type SimulateMethodOptions = Pick<
+  SendMethodOptions,
+  'authWitnesses' | 'capsules' | 'fee' | 'nonce' | 'cancellable'
+> & {
+  /** The sender's Aztec address. */
+  from?: AztecAddress;
+  /** Simulate without checking for the validity of the resulting transaction, e.g. whether it emits any existing nullifiers. */
+  skipTxValidation?: boolean;
+  /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
+  skipFeeEnforcement?: boolean;
 };
 
 /**
@@ -42,8 +55,11 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     protected contractAddress: AztecAddress,
     protected functionDao: FunctionAbi,
     protected args: any[],
+    authWitnesses: AuthWitness[] = [],
+    capsules: Capsule[] = [],
+    private extraHashedArgs: HashedValues[] = [],
   ) {
-    super(wallet);
+    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);
     }
@@ -63,20 +79,20 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
     const requestWithoutFee = await this.request(options);
 
-    const { fee: userFee } = options;
-    const fee = await this.getFeeOptions({ ...requestWithoutFee, fee: userFee });
+    const { fee: userFee, nonce, cancellable } = options;
+    const fee = await this.getFeeOptions(requestWithoutFee, userFee, { nonce, cancellable });
 
-    return await this.wallet.createTxExecutionRequest({ ...requestWithoutFee, fee });
+    return await this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { nonce, cancellable });
   }
 
   // docs:start:request
   /**
    * Returns an execution request that represents this operation.
    * Can be used as a building block for constructing batch requests.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns An execution request wrapped in promise.
+   * @param options - An optional object containing additional configuration for the request generation.
+   * @returns An execution payload wrapped in promise.
    */
-  public async request(options: SendMethodOptions = {}): Promise<Omit<ExecutionRequestInit, 'fee'>> {
+  public async request(options: RequestMethodOptions = {}): Promise<ExecutionPayload> {
     // docs:end:request
     const args = encodeArguments(this.functionDao, this.args);
     const calls = [
@@ -90,18 +106,13 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
         returnTypes: this.functionDao.returnTypes,
       },
     ];
-    const authWitnesses = this.getAuthWitnesses();
-    const hashedArguments = this.getHashedArguments();
-    const capsules = this.getCapsules();
-    const { nonce, cancellable } = options;
-    return {
+    const { authWitnesses, capsules } = options;
+    return new ExecutionPayload(
       calls,
-      authWitnesses,
-      hashedArguments,
-      capsules,
-      nonce,
-      cancellable,
-    };
+      this.authWitnesses.concat(authWitnesses ?? []),
+      this.capsules.concat(capsules ?? []),
+      this.extraHashedArgs,
+    );
   }
 
   // docs:start:simulate
@@ -117,11 +128,16 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
   public async simulate(options: SimulateMethodOptions = {}): Promise<any> {
     // docs:end:simulate
     if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
-      return this.wallet.simulateUnconstrained(this.functionDao.name, this.args, this.contractAddress, options?.from);
+      return this.wallet.simulateUnconstrained(
+        this.functionDao.name,
+        this.args,
+        this.contractAddress,
+        options.authWitnesses ?? [],
+        options?.from,
+      );
     }
 
-    const fee = options.fee ?? { paymentMethod: new FeeJuicePaymentMethod(AztecAddress.ZERO) };
-    const txRequest = await this.create({ fee });
+    const txRequest = await this.create(options);
     const simulatedTx = await this.wallet.simulateTx(
       txRequest,
       true /* simulatePublic */,
@@ -154,30 +170,43 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    *
    * @returns An object containing the function return value and profile result.
    */
-  public async simulateWithProfile(options: SimulateMethodOptions = {}): Promise<ProfileResult> {
+  public async profile(options: ProfileMethodOptions = { profileMode: 'gates' }): Promise<TxProfileResult> {
     if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
       throw new Error("Can't profile an unconstrained function.");
     }
+    const { authWitnesses, capsules, fee } = options;
 
-    const txRequest = await this.create({ fee: options.fee });
-    const simulatedTx = await this.wallet.simulateTx(
-      txRequest,
-      true,
-      options?.from,
-      options?.skipTxValidation,
-      undefined,
-      true,
-    );
-
-    const rawReturnValues =
-      this.functionDao.functionType == FunctionType.PRIVATE
-        ? simulatedTx.getPrivateReturnValues().nested?.[0].values
-        : simulatedTx.getPublicReturnValues()?.[0].values;
-    const rawReturnValuesDecoded = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    const txRequest = await this.create({ fee, authWitnesses, capsules });
+    return await this.wallet.profileTx(txRequest, options.profileMode, options?.from);
+  }
 
-    return {
-      returnValues: rawReturnValuesDecoded,
-      gateCounts: simulatedTx.profileResult!.gateCounts,
-    };
+  /**
+   * Augments this ContractFunctionInteraction with additional metadata, such as authWitnesses, capsules, and extraHashedArgs.
+   * This is useful when creating a "batteries included" interaction, such as registering a contract class with its associated
+   * capsule instead of having the user provide them externally.
+   * @param options - An object containing the metadata to add to the interaction
+   * @returns A new ContractFunctionInteraction with the added metadata, but calling the same original function in the same manner
+   */
+  public with({
+    authWitnesses = [],
+    capsules = [],
+    extraHashedArgs = [],
+  }: {
+    /** The authWitnesses to add to the interaction */
+    authWitnesses?: AuthWitness[];
+    /** The capsules to add to the interaction */
+    capsules?: Capsule[];
+    /** The extra hashed args to add to the interaction */
+    extraHashedArgs?: HashedValues[];
+  }): ContractFunctionInteraction {
+    return new ContractFunctionInteraction(
+      this.wallet,
+      this.contractAddress,
+      this.functionDao,
+      this.args,
+      this.authWitnesses.concat(authWitnesses),
+      this.capsules.concat(capsules),
+      this.extraHashedArgs.concat(extraHashedArgs),
+    );
   }
 }