@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/contract/contract_function_interaction.ts

@@ -1,49 +1,21 @@
-import { ExecutionPayload } from '@aztec/entrypoints/payload';
+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 Capsule,
-  type HashedValues,
-  type OffchainEffect,
-  type SimulationStats,
-  type TxExecutionRequest,
-  type TxProfileResult,
-  collectOffchainEffects,
-} from '@aztec/stdlib/tx';
+import { type Capsule, type HashedValues, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
-import type {
-  ProfileMethodOptions,
-  RequestMethodOptions,
-  SendMethodOptions,
-  SimulateMethodOptions,
+import { getGasLimits } from './get_gas_limits.js';
+import {
+  type ProfileInteractionOptions,
+  type RequestInteractionOptions,
+  type SimulateInteractionOptions,
+  type SimulationReturn,
+  toProfileOptions,
+  toSimulateOptions,
 } from './interaction_options.js';
 
-/**
- * Represents the result type of a simulation.
- * By default, it will just be the return value of the simulated function
- * so contract interfaces behave as plain functions. If `includeMetadata` is set to true in `SimulateMethodOptions` on the input of `simulate(...)`,
- * it will provide extra information.
- */
-type SimulationReturn<T extends boolean | undefined> = T extends true
-  ? {
-      /**
-       * Additional stats about the simulation
-       */
-      stats: SimulationStats;
-      /**
-       * Offchain effects generated during the simulation
-       */
-      offchainEffects: OffchainEffect[];
-      /**
-       * Return value of the function
-       */
-      result: any;
-    }
-  : any;
-
 /**
  * This is the class that is returned when calling e.g. `contract.methods.myMethod(arg0, arg1)`.
  * It contains available interactions one can call on a method, including view.
@@ -64,69 +36,71 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
   }
 
-  // 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 options - 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 override async create(options: Omit<SendMethodOptions, 'from'> = {}): Promise<TxExecutionRequest> {
-    // docs:end:create
-    if (this.functionDao.functionType === FunctionType.UTILITY) {
-      throw new Error("Can't call `create` on a utility  function.");
-    }
-    const requestWithoutFee = await this.request(options);
-
-    const { fee: userFee, txNonce, cancellable } = options;
-    const fee = await this.getFeeOptions(requestWithoutFee, userFee, { txNonce, cancellable });
-
-    return await this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { txNonce, cancellable });
+  public async getFunctionCall() {
+    const args = encodeArguments(this.functionDao, this.args);
+    return {
+      name: this.functionDao.name,
+      args,
+      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 */,
+      returnTypes: this.functionDao.returnTypes,
+    };
   }
 
-  // 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 request generation.
-   * @returns An execution payload wrapped in promise.
+   * 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: RequestMethodOptions = {}): Promise<ExecutionPayload> {
-    // docs:end:request
-    const args = encodeArguments(this.functionDao, this.args);
-    const calls = [
-      {
-        name: this.functionDao.name,
-        args,
-        selector: await FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
-        type: this.functionDao.functionType,
-        to: this.contractAddress,
-        isStatic: this.functionDao.isStatic,
-        returnTypes: this.functionDao.returnTypes,
-      },
-    ];
+  public override async request(options: RequestInteractionOptions = {}): Promise<ExecutionPayload> {
+    const calls = [await this.getFunctionCall()];
     const { authWitnesses, capsules } = options;
-    return new ExecutionPayload(
+    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
+   * 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<T extends SimulateMethodOptions>(options: T): Promise<SimulationReturn<T['includeMetadata']>>;
+  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: SimulateMethodOptions): Promise<SimulationReturn<typeof options.includeMetadata>> {
+  public async simulate(
+    options: SimulateInteractionOptions,
+  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
     // docs:end:simulate
     if (this.functionDao.functionType == FunctionType.UTILITY) {
       const utilityResult = await this.wallet.simulateUtility(
@@ -146,13 +120,8 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       }
     }
 
-    const txRequest = await this.create(options);
-    const simulatedTx = await this.wallet.simulateTx(
-      txRequest,
-      true /* simulatePublic */,
-      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) {
@@ -171,11 +140,16 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
 
     const returnValue = rawReturnValues ? decodeFromAbi(this.functionDao.returnTypes, rawReturnValues) : [];
 
-    if (options.includeMetadata) {
+    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;
@@ -188,19 +162,13 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    *
    * @returns An object containing the function return value and profile result.
    */
-  public async profile(options: ProfileMethodOptions): Promise<TxProfileResult> {
-    if (options.from !== AztecAddress.ZERO && !options.from.equals(this.wallet.getAddress())) {
-      throw new Error(
-        `The address provided as from does not match the wallet address. Expected ${this.wallet.getAddress().toString()}, got ${options.from.toString()}.`,
-      );
-    }
+  public async profile(options: ProfileInteractionOptions): Promise<TxProfileResult> {
     if (this.functionDao.functionType == FunctionType.UTILITY) {
       throw new Error("Can't profile a utility function.");
     }
-    const { authWitnesses, capsules, fee } = options;
 
-    const txRequest = await this.create({ fee, authWitnesses, capsules });
-    return await this.wallet.profileTx(txRequest, options.profileMode, options.skipProofGeneration, options?.from);
+    const executionPayload = await this.request(options);
+    return await this.wallet.profileTx(executionPayload, await toProfileOptions(options));
   }
 
   /**

package/src/contract/deploy_method.ts

@@ -1,6 +1,5 @@
-import type { ExecutionPayload } from '@aztec/entrypoints/payload';
-import { mergeExecutionPayloads } from '@aztec/entrypoints/payload';
-import type { Fr } from '@aztec/foundation/fields';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
 import { type ContractArtifact, type FunctionAbi, type FunctionArtifact, getInitializer } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -10,9 +9,8 @@ import {
   getContractClassFromArtifact,
   getContractInstanceFromInstantiationParams,
 } from '@aztec/stdlib/contract';
-import type { GasSettings } from '@aztec/stdlib/gas';
 import type { PublicKeys } from '@aztec/stdlib/keys';
-import type { Capsule, TxExecutionRequest, TxProfileResult } from '@aztec/stdlib/tx';
+import { type Capsule, type TxProfileResult, collectOffchainEffects } from '@aztec/stdlib/tx';
 
 import { publishContractClass } from '../deployment/publish_class.js';
 import { publishInstance } from '../deployment/publish_instance.js';
@@ -21,30 +19,71 @@ import { BaseContractInteraction } from './base_contract_interaction.js';
 import type { Contract } from './contract.js';
 import type { ContractBase } from './contract_base.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
-import { DeployProvenTx } from './deploy_proven_tx.js';
 import { DeploySentTx } from './deploy_sent_tx.js';
-import type { ProfileMethodOptions, SendMethodOptions } from './interaction_options.js';
+import { getGasLimits } from './get_gas_limits.js';
+import {
+  type ProfileInteractionOptions,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type SimulationInteractionFeeOptions,
+  type SimulationReturn,
+  toProfileOptions,
+  toSendOptions,
+  toSimulateOptions,
+} from './interaction_options.js';
 
 /**
  * Options for deploying a contract on the Aztec network.
- * Allows specifying a contract address salt, and additional send method options.
+ * Allows specifying a contract address salt and different options to tweak contract publication
+ * and initialization
  */
-// docs:start:deploy_options
-export type DeployOptions = {
+export type RequestDeployOptions = RequestInteractionOptions & {
   /** An optional salt value used to deterministically calculate the contract address. */
   contractAddressSalt?: Fr;
-  /** Set to true to *not* include the sender in the address computation. */
-  universalDeploy?: boolean;
+  /**
+   * Deployer address that will be used for the deployed contract's address computation.
+   * If set to 0, the sender's address won't be mixed in
+   */
+  deployer?: AztecAddress;
   /** Skip contract class publication. */
   skipClassPublication?: boolean;
   /** Skip publication, instead just privately initialize the contract. */
   skipInstancePublication?: boolean;
   /** Skip contract initialization. */
   skipInitialization?: boolean;
-} & SendMethodOptions;
+};
+
+/**
+ * Extends the deployment options with the required parameters to send the transaction
+ */
+export type DeployOptions = 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'>;
 // docs:end:deploy_options
 // TODO(@spalladino): Add unit tests for this class!
 
+/**
+ * Options for simulating the deployment of a contract
+ * Allows skipping certain validations and computing gas estimations
+ */
+export type SimulateDeployOptions = Omit<DeployOptions, 'fee'> & {
+  /** The fee options for the transaction. */
+  fee?: SimulationInteractionFeeOptions;
+  /** Simulate without checking for the validity of the resulting transaction,
+   * e.g. whether it emits any existing nullifiers. */
+  skipTxValidation?: boolean;
+  /** Whether to ensure the fee payer is not empty and has enough balance to pay for the fee. */
+  skipFeeEnforcement?: boolean;
+  /** Whether to include metadata such as offchain effects and performance statistics
+   * (e.g. timing information of the different circuits and oracles) in
+   * the simulation result, instead of just the return value of the function */
+  includeMetadata?: boolean;
+};
+
 /**
  * Contract interaction for deployment.
  * Handles class publication, instance publication, and initialization of the contract.
@@ -67,8 +106,8 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   constructor(
     private publicKeys: PublicKeys,
     wallet: Wallet,
-    private artifact: ContractArtifact,
-    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
+    protected artifact: ContractArtifact,
+    protected postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
     private args: any[] = [],
     constructorNameOrArtifact?: string | FunctionArtifact,
     authWitnesses: AuthWitness[] = [],
@@ -79,78 +118,43 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   }
 
   /**
-   * Prepare a transaction execution request which can optionally (depending on the `options`):
-   * - Publish the contract's class_id
-   * - Publish the contract instance data, to enable execution of its public functions.
-   * - Initialize the contract
-   *
-   * A tx is not necessary if the function has no public functions nor any
-   * initializer function.
-   *
-   * This function internally calls `request()` and `sign()` methods to prepare
-   * the transaction for deployment. The resulting signed transaction can be
-   * later sent using the `send()` method.
-   *
-   * @param options - An object containing optional deployment settings, contractAddressSalt, and from.
-   * @returns A Promise resolving to an object containing the signed transaction data and other relevant information.
-   */
-  public async create(options: DeployOptions): Promise<TxExecutionRequest> {
-    const requestWithoutFee = await this.request(options);
-    const { fee: userFee, txNonce, cancellable } = options;
-    const fee = await this.getFeeOptions(requestWithoutFee, userFee, { txNonce, cancellable });
-    return this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { txNonce, cancellable });
-  }
-
-  // REFACTOR: Having a `request` method with different semantics than the ones in the other
-  // derived ContractInteractions is confusing. We should unify the flow of all ContractInteractions.
-
-  /**
-   * Returns an array of function calls that represent this operation. Useful as a building
-   * block for constructing batch requests.
-   * @param options - Deployment options.
-   * @returns An array of function calls.
-   * @remarks This method does not have the same return type as the `request` in the ContractInteraction object,
-   * it returns a promise for an array instead of a function call directly.
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param options - Configuration options.
+   * @returns The execution payload for this operation
    */
-  public async request(options: DeployOptions): Promise<ExecutionPayload> {
+  public async request(options?: RequestDeployOptions): Promise<ExecutionPayload> {
     const publication = await this.getPublicationExecutionPayload(options);
 
-    // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
-    // Note that we need to run this registerContract here so it's available when computeFeeOptionsFromEstimatedGas
-    // runs, since it needs the contract to have been registered in order to estimate gas for its initialization,
-    // in case the initializer is public. This hints at the need of having "transient" contracts scoped to a
-    // simulation, so we can run the simulation with a set of contracts, but only "commit" them to the wallet
-    // once this tx has gone through.
-    await this.wallet.registerContract({ artifact: this.artifact, instance: await this.getInstance(options) });
+    await this.wallet.registerContract(await this.getInstance(options), this.artifact);
 
     const initialization = await this.getInitializationExecutionPayload(options);
-    const exec = [publication, initialization];
-    const fnCalls = exec.map(exec => exec.calls).flat();
-    if (!fnCalls.length) {
+    const feeExecutionPayload = options?.fee?.paymentMethod
+      ? await options.fee.paymentMethod.getExecutionPayload()
+      : undefined;
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, publication, initialization])
+      : mergeExecutionPayloads([publication, initialization]);
+    if (!finalExecutionPayload.calls.length) {
       throw new Error(`No transactions are needed to publish or initialize contract ${this.artifact.name}`);
     }
 
-    return mergeExecutionPayloads(exec);
+    return finalExecutionPayload;
   }
 
-  /**
-   * Simulate a deployment and profile the gate count for each function in the transaction.
-   * @param options - Same options as `send`, plus extra profiling options.
-   *
-   * @returns An object containing the function return value and profile result.
-   */
-  public async profile(options: DeployOptions & ProfileMethodOptions): Promise<TxProfileResult> {
-    const txRequest = await this.create(options);
-    return await this.wallet.profileTx(txRequest, options.profileMode, options.skipProofGeneration, options?.from);
+  convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
+    return {
+      ...options,
+      deployer: !options?.universalDeploy ? options.from : undefined,
+    };
   }
 
   /**
-   * Adds this contract to the PXE and returns the Contract object.
+   * Adds this contract to the wallet and returns the Contract object.
    * @param options - Deployment options.
    */
-  public async register(options: Omit<DeployOptions, 'from'> = {}): Promise<TContract> {
+  public async register(options?: RequestDeployOptions): Promise<TContract> {
     const instance = await this.getInstance(options);
-    await this.wallet.registerContract({ artifact: this.artifact, instance });
+    await this.wallet.registerContract(instance, this.artifact);
     return this.postDeployCtor(instance.address, this.wallet);
   }
 
@@ -162,7 +166,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Contract creation options.
    * @returns An execution payload with potentially calls (and bytecode capsule) to the class registry and instance registry.
    */
-  protected async getPublicationExecutionPayload(options: Omit<DeployOptions, 'from'> = {}): Promise<ExecutionPayload> {
+  protected async getPublicationExecutionPayload(options?: RequestDeployOptions): Promise<ExecutionPayload> {
     const calls: ExecutionPayload[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
@@ -178,7 +182,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     }
 
     // Publish the contract class if it hasn't been published already.
-    if (!options.skipClassPublication) {
+    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()}`,
@@ -193,7 +197,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     }
 
     // Publish the contract instance:
-    if (!options.skipInstancePublication) {
+    if (!options?.skipInstancePublication) {
       // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15596):
       // Read the artifact, and if there are no public functions, warn the caller that publication of the
       // contract instance is not necessary (until such time as they wish to update the instance (i.e. change its class_id)).
@@ -209,11 +213,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns - An array of function calls.
    */
-  protected async getInitializationExecutionPayload(
-    options: Omit<DeployOptions, 'from'> = {},
-  ): Promise<ExecutionPayload> {
+  protected async getInitializationExecutionPayload(options?: RequestDeployOptions): Promise<ExecutionPayload> {
     const executionsPayloads: ExecutionPayload[] = [];
-    if (this.constructorArtifact && !options.skipInitialization) {
+    if (this.constructorArtifact && !options?.skipInitialization) {
       const { address } = await this.getInstance(options);
       const constructorCall = new ContractFunctionInteraction(
         this.wallet,
@@ -235,7 +237,11 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @returns A SentTx object that returns the receipt and the deployed contract instance.
    */
   public override send(options: DeployOptions): DeploySentTx<TContract> {
-    const sendTx = () => super.send(options).getTxHash();
+    const sendTx = async () => {
+      const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+      const sendOptions = await 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));
   }
@@ -246,43 +252,55 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - An object containing various initialization and publication options.
    * @returns An instance object.
    */
-  public async getInstance(options: Omit<DeployOptions, 'from'> = {}): Promise<ContractInstanceWithAddress> {
+  public async getInstance(options?: RequestDeployOptions): Promise<ContractInstanceWithAddress> {
     if (!this.instance) {
       this.instance = await getContractInstanceFromInstantiationParams(this.artifact, {
         constructorArgs: this.args,
-        salt: options.contractAddressSalt,
+        salt: options?.contractAddressSalt ?? Fr.random(),
         publicKeys: this.publicKeys,
         constructorArtifact: this.constructorArtifact,
-        deployer: options.universalDeploy ? AztecAddress.ZERO : this.wallet.getAddress(),
+        deployer: options?.deployer ? options.deployer : AztecAddress.ZERO,
       });
     }
     return this.instance;
   }
 
   /**
-   * Prove the request.
-   * @param options - initialization and publication options.
-   * @returns The proven tx.
+   * Simulate the deployment
+   *
+   * @param options - An optional object containing additional configuration for the simulation.
+   * @returns A simulation result object containing metadata of the execution, including gas
+   * estimations (if requested via options), execution statistics and emitted offchain effects
    */
-  public override async prove(options: DeployOptions): Promise<DeployProvenTx<TContract>> {
-    const txProvingResult = await this.proveInternal(options);
-    return await DeployProvenTx.fromProvingResult(
-      this.wallet,
-      txProvingResult,
-      this.postDeployCtor,
-      () => this.getInstance(options),
-      txProvingResult.stats,
+  public async simulate(options: SimulateDeployOptions): Promise<SimulationReturn<true>> {
+    const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+    const simulatedTx = await this.wallet.simulateTx(executionPayload, await toSimulateOptions(options));
+
+    const { gasLimits, teardownGasLimits } = getGasLimits(simulatedTx, options.fee?.estimatedGasPadding);
+    this.log.verbose(
+      `Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`,
     );
+    return {
+      stats: simulatedTx.stats!,
+      offchainEffects: collectOffchainEffects(simulatedTx.privateExecutionResult),
+      result: undefined,
+      estimatedGas: { gasLimits, teardownGasLimits },
+    };
   }
 
   /**
-   * Estimates gas cost for this deployment operation.
-   * @param options - Options.
+   * Simulate a deployment and profile the gate count for each function in the transaction.
+   * @param options - Same options as `send`, plus extra profiling options.
+   *
+   * @returns An object containing the function return value and profile result.
    */
-  public override estimateGas(
-    options: Omit<DeployOptions, 'estimateGas'>,
-  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
-    return super.estimateGas(options);
+  public async profile(options: DeployOptions & ProfileInteractionOptions): Promise<TxProfileResult> {
+    const executionPayload = await this.request(this.convertDeployOptionsToRequestOptions(options));
+    return await this.wallet.profileTx(executionPayload, {
+      ...(await toProfileOptions(options)),
+      profileMode: options.profileMode,
+      skipProofGeneration: options.skipProofGeneration,
+    });
   }
 
   /** Return this deployment address. */

package/src/contract/deploy_sent_tx.ts

@@ -2,7 +2,6 @@ import { createLogger } from '@aztec/foundation/log';
 import type { FieldsOf } from '@aztec/foundation/types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
 import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
@@ -57,18 +56,13 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
    */
   public override async wait(opts?: DeployedWaitOpts): Promise<DeployTxReceipt<TContract>> {
     const receipt = await super.wait(opts);
-    const contract = await this.getContractObject(opts?.wallet);
-    return { ...receipt, contract };
-  }
-
-  protected async getContractObject(wallet?: Wallet): Promise<TContract> {
-    const isWallet = (pxeWalletOrNode: Wallet | AztecNode | PXE): pxeWalletOrNode is Wallet =>
-      !!(pxeWalletOrNode as Wallet).createTxExecutionRequest;
-    const contractWallet = wallet ?? (isWallet(this.pxeWalletOrNode) && this.pxeWalletOrNode);
+    // In the case of DeploySentTx we have a guarantee that this.walletOrNode is a Wallet so we can cast it to Wallet.
+    const contractWallet = opts?.wallet ?? (this.walletOrNode as Wallet);
     if (!contractWallet) {
       throw new Error(`A wallet is required for creating a contract instance`);
     }
     const instance = await this.instanceGetter();
-    return this.postDeployCtor(instance.address, contractWallet) as Promise<TContract>;
+    const contract = (await this.postDeployCtor(instance.address, contractWallet)) as TContract;
+    return { ...receipt, contract };
   }
 }