@aztec/aztec.js 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/contract/batch_call.ts

@@ -1,95 +1,127 @@
+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/index.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
-import type { SimulateMethodOptions } from './contract_function_interaction.js';
+import type { Wallet } from '../wallet/wallet.js';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+import {
+  type RequestInteractionOptions,
+  type SimulateInteractionOptions,
+  toSimulateOptions,
+} from './interaction_options.js';
 
 /** A batch of function calls to be sent as a single transaction through a wallet. */
 export class BatchCall extends BaseContractInteraction {
-  constructor(wallet: Wallet, protected calls: FunctionCall[]) {
+  constructor(
+    wallet: Wallet,
+    protected interactions: (BaseContractInteraction | ExecutionPayload)[],
+  ) {
     super(wallet);
   }
 
   /**
-   * Create a transaction execution request that represents this batch, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @param opts - An optional object containing additional configuration for the transaction.
-   * @returns A Promise that resolves to a transaction instance.
+   * Returns an execution request that represents this operation.
+   * @param options - An optional object containing additional configuration for the request generation.
+   * @returns An execution payload wrapped in promise.
    */
-  public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
-    const calls = this.calls;
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...opts });
-    return await this.wallet.createTxExecutionRequest({ calls, capsules, ...opts, fee });
+  public async request(options: RequestInteractionOptions = {}): Promise<ExecutionPayload> {
+    const requests = await this.getExecutionPayloads();
+    const feeExecutionPayload = options.fee?.paymentMethod
+      ? await options.fee.paymentMethod.getExecutionPayload()
+      : undefined;
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, ...requests])
+      : mergeExecutionPayloads([...requests]);
+    return finalExecutionPayload;
   }
 
   /**
    * Simulate a transaction and get its return values
    * Differs from prove in a few important ways:
    * 1. It returns the values of the function execution
-   * 2. It supports `unconstrained`, `private` and `public` functions
+   * 2. It supports `utility`, `private` and `public` functions
    *
    * @param options - An optional object containing additional configuration for the transaction.
    * @returns The result of the transaction as returned by the contract function.
    */
-  public async simulate(options: SimulateMethodOptions = {}): Promise<any> {
-    const { indexedCalls, unconstrained } = this.calls.reduce<{
+  public async simulate(options: SimulateInteractionOptions): Promise<any> {
+    const { indexedExecutionPayloads, utility } = (await this.getExecutionPayloads()).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 calls in the batch */
-      indexedCalls: [FunctionCall, number, number][];
-      /** The unconstrained function calls in the batch. */
-      unconstrained: [FunctionCall, number][];
+      /** The public and private function execution requests in the batch */
+      indexedExecutionPayloads: [ExecutionPayload, number, number][];
+      /** The utility function calls in the batch. */
+      utility: [FunctionCall, number][];
     }>(
       (acc, current, index) => {
-        if (current.type === FunctionType.UNCONSTRAINED) {
-          acc.unconstrained.push([current, index]);
+        const call = current.calls[0];
+        if (call.type === FunctionType.UTILITY) {
+          acc.utility.push([call, index]);
         } else {
-          acc.indexedCalls.push([
+          acc.indexedExecutionPayloads.push([
             current,
             index,
-            current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
+            call.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
           ]);
         }
         return acc;
       },
-      { indexedCalls: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
+      { indexedExecutionPayloads: [], utility: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const calls = indexedCalls.map(([call]) => call);
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...options });
-    const txRequest = await this.wallet.createTxExecutionRequest({ calls, capsules, ...options, fee });
-
-    const unconstrainedCalls = unconstrained.map(
-      async ([call, index]) =>
-        [await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from), index] as const,
+    const payloads = indexedExecutionPayloads.map(([request]) => request);
+    const combinedPayload = mergeExecutionPayloads(payloads);
+    const executionPayload = new ExecutionPayload(
+      combinedPayload.calls,
+      combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
+      combinedPayload.capsules.concat(options.capsules ?? []),
+      combinedPayload.extraHashedArgs,
     );
 
-    const [unconstrainedResults, simulatedTx] = await Promise.all([
-      Promise.all(unconstrainedCalls),
-      this.wallet.simulateTx(txRequest, true, options?.from, options?.skipTxValidation),
+    const utilityBatchPromise =
+      utility.length > 0
+        ? this.wallet.batch(
+            utility.map(([call]) => ({
+              name: 'simulateUtility' as const,
+              args: [call.name, call.args, call.to, options?.authWitnesses] as const,
+            })),
+          )
+        : Promise.resolve([]);
+
+    const [utilityBatchResults, simulatedTx] = await Promise.all([
+      utilityBatchPromise,
+      indexedExecutionPayloads.length > 0
+        ? this.wallet.simulateTx(executionPayload, await toSimulateOptions(options))
+        : Promise.resolve(),
     ]);
 
     const results: any[] = [];
 
-    unconstrainedResults.forEach(([result, index]) => {
-      results[index] = result;
+    utilityBatchResults.forEach((wrappedResult, utilityIndex) => {
+      const [, originalIndex] = utility[utilityIndex];
+      results[originalIndex] = wrappedResult.result.result;
     });
-    indexedCalls.forEach(([call, callIndex, resultIndex]) => {
-      // 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
-      // For public functions we retrieve the first values directly from the public output.
-      const rawReturnValues =
-        call.type == FunctionType.PRIVATE
-          ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
-          : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
 
-      results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
-    });
+    if (simulatedTx) {
+      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
+        // For public functions we retrieve the first values directly from the public output.
+        const rawReturnValues =
+          call.type == FunctionType.PRIVATE
+            ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
+            : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
+
+        results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+      });
+    }
+
     return results;
   }
+
+  protected async getExecutionPayloads(): Promise<ExecutionPayload[]> {
+    return await Promise.all(this.interactions.map(i => (i instanceof ExecutionPayload ? i : i.request())));
+  }
 }

package/src/contract/checker.ts

@@ -1,4 +1,10 @@
-import type { AbiType, BasicType, ContractArtifact, StructType } from '@aztec/stdlib/abi';
+import {
+  type AbiType,
+  type BasicType,
+  type ContractArtifact,
+  type StructType,
+  getDefaultInitializer,
+} from '@aztec/stdlib/abi';
 
 /**
  * Represents a type derived from input type T with the 'kind' property removed.
@@ -38,8 +44,7 @@ export function abiChecker(artifact: ContractArtifact) {
     });
   });
 
-  // TODO: implement a better check for constructor (right now only checks if it has it or not)
-  if (!artifact.functions.find(func => func.name === 'constructor')) {
+  if (!getDefaultInitializer(artifact)) {
     throw new Error('ABI has no constructor');
   }
 

package/src/contract/contract.ts

@@ -1,9 +1,8 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 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/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractBase } from './contract_base.js';
 import { DeployMethod } from './deploy_method.js';
 
@@ -11,33 +10,24 @@ import { DeployMethod } from './deploy_method.js';
  * The Contract class represents a contract and provides utility methods for interacting with it.
  * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
  * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
- * to attach the contract instance to a deployed contract on-chain through the PXE, which facilitates
+ * to attach the contract instance to a deployed contract onchain through the PXE, which facilitates
  * interaction with Aztec's privacy protocol.
  */
 export class Contract extends ContractBase {
   /**
-   * Creates a contract instance.
-   * @param address - The deployed contract's address.
+   * Gets a contract instance.
+   * @param address - The address of the contract instance.
    * @param artifact - Build artifact of the contract.
    * @param wallet - The wallet to use when interacting with the contract.
    * @returns A promise that resolves to a new Contract instance.
    */
   public static async at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Promise<Contract> {
-    const instance = (await wallet.getContractMetadata(address)).contractInstance;
-    if (instance === undefined) {
-      throw new Error(`Contract instance at ${address.toString()} has not been registered in the wallet's PXE`);
-    }
-    const thisContractClass = await getContractClassFromArtifact(artifact);
-    if (!thisContractClass.id.equals(instance.currentContractClassId)) {
-      // wallet holds an outdated version of this contract
-      await wallet.updateContract(address, artifact);
-      instance.currentContractClassId = thisContractClass.id;
-    }
+    const instance = await wallet.registerContract(address, artifact);
     return new Contract(instance, artifact, wallet);
   }
 
   /**
-   * Creates a tx to deploy a new instance of a contract.
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract.
    * @param wallet - The wallet for executing the deployment.
    * @param artifact - Build artifact of the contract to deploy
    * @param args - Arguments for the constructor.
@@ -49,7 +39,8 @@ export class Contract extends ContractBase {
   }
 
   /**
-   * Creates a tx to deploy a new instance of a contract using the specified public keys hash to derive the address.
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract
+   * using the specified public keys hash to derive the address.
    * @param publicKeys - Hash of public keys to use for deriving the address.
    * @param wallet - The wallet for executing the deployment.
    * @param artifact - Build artifact of the contract.

package/src/contract/contract_base.ts

@@ -1,13 +1,13 @@
 import {
   type ContractArtifact,
-  type ContractNote,
   type FieldLayout,
-  type FunctionArtifact,
+  type FunctionAbi,
   FunctionSelector,
+  getAllFunctionAbis,
 } from '@aztec/stdlib/abi';
 import { type ContractInstanceWithAddress, computePartialAddress } from '@aztec/stdlib/contract';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 
 /**
@@ -28,13 +28,6 @@ export type ContractStorageLayout<T extends string> = {
   [K in T]: FieldLayout;
 };
 
-/**
- * Type representing the notes used in a contract.
- */
-export type ContractNotes<T extends string> = {
-  [K in T]: ContractNote;
-};
-
 /**
  * Abstract implementation of a contract extended by the Contract class and generated contract types.
  */
@@ -52,7 +45,7 @@ export class ContractBase {
     /** The wallet used for interacting with this contract. */
     public wallet: Wallet,
   ) {
-    artifact.functions.forEach((f: FunctionArtifact) => {
+    getAllFunctionAbis(artifact).forEach((f: FunctionAbi) => {
       const interactionFunction = (...args: any[]) => {
         return new ContractFunctionInteraction(this.wallet, this.instance.address, f, args);
       };

package/src/contract/contract_function_interaction.ts

@@ -1,42 +1,20 @@
-import {
-  type FunctionAbi,
-  FunctionCall,
-  FunctionSelector,
-  FunctionType,
-  decodeFromAbi,
-  encodeArguments,
-} from '@aztec/stdlib/abi';
+import { ExecutionPayload, mergeExecutionPayloads } 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 { Wallet } from '../account/wallet.js';
-import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
-
-export type { SendMethodOptions };
+import { type Capsule, type HashedValues, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
 
-/**
- * Represents the options for simulating a contract function interaction.
- * Allows specifying the address from which the view method should be called.
- * Disregarded for simulation of public functions
- */
-export type SimulateMethodOptions = Pick<SendMethodOptions, 'fee'> & {
-  /** The sender's Aztec address. */
-  from?: AztecAddress;
-  /** Simulate without checking for the validity of the resulting transaction, e.g. whether it emits any existing nullifiers. */
-  skipTxValidation?: boolean;
-  /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
-  skipFeeEnforcement?: boolean;
-};
-
-/**
- * The result of a profile() call.
- */
-export type ProfileResult = PrivateKernelProverProfileResult & {
-  /** The result of the transaction as returned by the contract function. */
-  returnValues: any;
-};
+import type { Wallet } from '../wallet/wallet.js';
+import { BaseContractInteraction } from './base_contract_interaction.js';
+import { getGasLimits } from './get_gas_limits.js';
+import {
+  type ProfileInteractionOptions,
+  type RequestInteractionOptions,
+  type SimulateInteractionOptions,
+  type SimulationReturn,
+  toProfileOptions,
+  toSimulateOptions,
+} from './interaction_options.js';
 
 /**
  * This is the class that is returned when calling e.g. `contract.methods.myMethod(arg0, arg1)`.
@@ -48,40 +26,22 @@ 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);
+      throw new Error(`All function interaction arguments must be defined and not null. Received: ${args}`);
     }
   }
 
-  // docs:start:create
   /**
-   * Create a transaction execution request that represents this call, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @param opts - An optional object containing additional configuration for the transaction.
-   * @returns A Promise that resolves to a transaction instance.
+   * Returns the encoded function call wrapped by this interaction
+   * Useful when generating authwits
+   * @returns An encoded function call
    */
-  public async create(opts: SendMethodOptions = {}): Promise<TxExecutionRequest> {
-    // docs:end:create
-    if (this.functionDao.functionType === FunctionType.UNCONSTRAINED) {
-      throw new Error("Can't call `create` on an unconstrained function.");
-    }
-    const calls = [await this.request()];
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...opts });
-    const { nonce, cancellable } = opts;
-    return await this.wallet.createTxExecutionRequest({ calls, fee, nonce, cancellable, capsules });
-  }
-
-  // docs:start:request
-  /**
-   * Returns an execution request that represents this operation. Useful as a building
-   * block for constructing batch requests.
-   * @returns An execution request wrapped in promise.
-   */
-  public async request(): Promise<FunctionCall> {
-    // docs:end:request
+  public async getFunctionCall() {
     const args = encodeArguments(this.functionDao, this.args);
     return {
       name: this.functionDao.name,
@@ -90,35 +50,78 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       type: this.functionDao.functionType,
       to: this.contractAddress,
       isStatic: this.functionDao.isStatic,
+      hideMsgSender: false /** Only set to `true` for enqueued public function calls */,
       returnTypes: this.functionDao.returnTypes,
     };
   }
 
+  /**
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param options - Configuration options.
+   * @returns The execution payload for this operation
+   */
+  public override async request(options: RequestInteractionOptions = {}): Promise<ExecutionPayload> {
+    const calls = [await this.getFunctionCall()];
+    const { authWitnesses, capsules } = options;
+    const feeExecutionPayload = options.fee?.paymentMethod
+      ? await options.fee.paymentMethod.getExecutionPayload()
+      : undefined;
+    const functionExecutionPayload = new ExecutionPayload(
+      calls,
+      this.authWitnesses.concat(authWitnesses ?? []),
+      this.capsules.concat(capsules ?? []),
+      this.extraHashedArgs,
+    );
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, functionExecutionPayload])
+      : functionExecutionPayload;
+    return finalExecutionPayload;
+  }
+
   // docs:start:simulate
   /**
-   * Simulate a transaction and get its return values
+   * Simulate a transaction and get information from its execution.
    * Differs from prove in a few important ways:
-   * 1. It returns the values of the function execution
-   * 2. It supports `unconstrained`, `private` and `public` functions
+   * 1. It returns the values of the function execution, plus additional metadata if requested
+   * 2. It supports `utility`, `private` and `public` functions
    *
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns The result of the transaction as returned by the contract function.
+   * @param options - An optional object containing additional configuration for the simulation.
+   * @returns Depending on the simulation options, this method directly returns the result value of the executed
+   * 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(options: SimulateMethodOptions = {}): Promise<any> {
+  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>> {
     // docs:end:simulate
-    if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
-      return this.wallet.simulateUnconstrained(this.functionDao.name, this.args, this.contractAddress, options?.from);
+    if (this.functionDao.functionType == FunctionType.UTILITY) {
+      const utilityResult = await this.wallet.simulateUtility(
+        this.functionDao.name,
+        this.args,
+        this.contractAddress,
+        options.authWitnesses ?? [],
+      );
+
+      if (options.includeMetadata) {
+        return {
+          stats: utilityResult.stats,
+          result: utilityResult.result,
+        };
+      } else {
+        return utilityResult.result;
+      }
     }
 
-    const fee = options.fee ?? { paymentMethod: new FeeJuicePaymentMethod(AztecAddress.ZERO) };
-    const txRequest = await this.create({ fee });
-    const simulatedTx = await this.wallet.simulateTx(
-      txRequest,
-      true /* simulatePublic */,
-      options.from,
-      options.skipTxValidation,
-      options.skipFeeEnforcement ?? true,
-    );
+    const executionPayload = await this.request(options);
+    const simulatedTx = await this.wallet.simulateTx(executionPayload, await toSimulateOptions(options));
 
     let rawReturnValues;
     if (this.functionDao.functionType == FunctionType.PRIVATE) {
@@ -132,42 +135,69 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       }
     } else {
       // For public functions we retrieve the first values directly from the public output.
-      rawReturnValues = simulatedTx.getPublicReturnValues()?.[0].values;
+      rawReturnValues = simulatedTx.getPublicReturnValues()?.[0]?.values;
     }
 
-    return rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    const returnValue = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+
+    if (options.includeMetadata || options.fee?.estimateGas) {
+      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: returnValue,
+        estimatedGas: { gasLimits, teardownGasLimits },
+      };
+    } else {
+      return returnValue;
+    }
   }
 
   /**
    * Simulate a transaction and profile the gate count for each function in the transaction.
-   * @param options - Same options as `simulate`.
+   * @param options - Same options as `simulate`, plus profiling method
    *
    * @returns An object containing the function return value and profile result.
    */
-  public async simulateWithProfile(options: SimulateMethodOptions = {}): Promise<ProfileResult> {
-    if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
-      throw new Error("Can't profile an unconstrained function.");
+  public async profile(options: ProfileInteractionOptions): Promise<TxProfileResult> {
+    if (this.functionDao.functionType == FunctionType.UTILITY) {
+      throw new Error("Can't profile a utility function.");
     }
 
-    const txRequest = await this.create({ fee: options.fee });
-    const simulatedTx = await this.wallet.simulateTx(
-      txRequest,
-      true,
-      options?.from,
-      options?.skipTxValidation,
-      undefined,
-      true,
-    );
-
-    const rawReturnValues =
-      this.functionDao.functionType == FunctionType.PRIVATE
-        ? simulatedTx.getPrivateReturnValues().nested?.[0].values
-        : simulatedTx.getPublicReturnValues()?.[0].values;
-    const rawReturnValuesDecoded = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
+    const executionPayload = await this.request(options);
+    return await this.wallet.profileTx(executionPayload, await toProfileOptions(options));
+  }
 
-    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),
+    );
   }
 }