@aztec/aztec.js 0.65.1 → 0.65.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/aztec.js",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/aztec.js",
-  "version": "0.65.1",
+  "version": "0.65.2",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -76,13 +76,13 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.65.1",
-    "@aztec/circuits.js": "0.65.1",
-    "@aztec/ethereum": "0.65.1",
-    "@aztec/foundation": "0.65.1",
-    "@aztec/l1-artifacts": "0.65.1",
-    "@aztec/protocol-contracts": "0.65.1",
-    "@aztec/types": "0.65.1",
+    "@aztec/circuit-types": "0.65.2",
+    "@aztec/circuits.js": "0.65.2",
+    "@aztec/ethereum": "0.65.2",
+    "@aztec/foundation": "0.65.2",
+    "@aztec/l1-artifacts": "0.65.2",
+    "@aztec/protocol-contracts": "0.65.2",
+    "@aztec/types": "0.65.2",
     "axios": "^1.7.2",
     "tslib": "^2.4.0",
     "viem": "^2.7.15"

package/src/account_manager/deploy_account_method.ts

@@ -46,13 +46,16 @@ export class DeployAccountMethod extends DeployMethod {
         : feePaymentNameOrArtifact;
   }
 
-  protected override async getInitializeFunctionCalls(options: DeployOptions): Promise<ExecutionRequestInit> {
+  protected override async getInitializeFunctionCalls(
+    options: DeployOptions,
+  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'packedArguments'>> {
     const exec = await super.getInitializeFunctionCalls(options);
 
     if (options.fee && this.#feePaymentArtifact) {
       const { address } = this.getInstance();
       const emptyAppPayload = EntrypointPayload.fromAppExecution([]);
-      const feePayload = await EntrypointPayload.fromFeeOptions(address, options?.fee);
+      const fee = await this.getDefaultFeeOptions(options.fee);
+      const feePayload = await EntrypointPayload.fromFeeOptions(address, fee);
 
       exec.calls.push({
         name: this.#feePaymentArtifact.name,

package/src/account_manager/index.ts

@@ -17,7 +17,7 @@ import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
  */
 export type DeployAccountOptions = Pick<
   DeployOptions,
-  'fee' | 'skipClassRegistration' | 'skipPublicDeployment' | 'estimateGas' | 'skipInitialization'
+  'fee' | 'skipClassRegistration' | 'skipPublicDeployment' | 'skipInitialization'
 >;
 
 /**
@@ -166,7 +166,6 @@ export class AccountManager {
           skipInitialization: opts?.skipInitialization ?? false,
           universalDeploy: true,
           fee: opts?.fee,
-          estimateGas: opts?.estimateGas,
         }),
       )
       .then(tx => tx.getTxHash());

package/src/contract/base_contract_interaction.ts

@@ -3,7 +3,9 @@ import { type Fr, GasSettings } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { type Wallet } from '../account/wallet.js';
-import { type ExecutionRequestInit, type FeeOptions } from '../entrypoint/entrypoint.js';
+import { type ExecutionRequestInit } from '../entrypoint/entrypoint.js';
+import { type FeeOptions, type UserFeeOptions } from '../entrypoint/payload.js';
+import { NoFeePaymentMethod } from '../fee/no_fee_payment_method.js';
 import { getGasLimits } from './get_gas_limits.js';
 import { ProvenTx } from './proven_tx.js';
 import { SentTx } from './sent_tx.js';
@@ -16,11 +18,7 @@ export type SendMethodOptions = {
   /** Wether to skip the simulation of the public part of the transaction. */
   skipPublicSimulation?: boolean;
   /** The fee options for the transaction. */
-  fee?: FeeOptions;
-  /** Whether to run an initial simulation of the tx with high gas limit to figure out actual gas settings (will default to true later down the road). */
-  estimateGas?: boolean;
-  /** Percentage to pad the suggested gas limits by, if empty, defaults to 10%. */
-  estimatedGasPad?: number;
+  fee?: UserFeeOptions;
   /** Custom nonce to inject into the app payload of the transaction. Useful when trying to cancel an ongoing transaction by creating a new one with a higher fee */
   nonce?: Fr;
   /** Whether the transaction can be cancelled. If true, an extra nullifier will be emitted: H(nonce, GENERATOR_INDEX__TX_NULLIFIER) */
@@ -92,33 +90,54 @@ export abstract class BaseContractInteraction {
   public async estimateGas(
     opts?: Omit<SendMethodOptions, 'estimateGas' | 'skipPublicSimulation'>,
   ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
-    const txRequest = await this.create({ ...opts, estimateGas: false });
+    const txRequest = await this.create({ ...opts, fee: { ...opts?.fee, estimateGas: false } });
     const simulationResult = await this.wallet.simulateTx(txRequest, true);
     const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
       simulationResult,
-      opts?.estimatedGasPad,
+      opts?.fee?.estimatedGasPadding,
     );
     return { gasLimits, teardownGasLimits };
   }
 
   /**
-   * Helper method to return fee options based on the user opts, estimating tx gas if needed.
+   * Returns default fee options based on the user opts without running a simulation for gas estimation.
+   * @param fee - User-provided fee options.
+   */
+  protected async getDefaultFeeOptions(fee: UserFeeOptions | undefined): Promise<FeeOptions> {
+    const maxFeesPerGas = fee?.gasSettings?.maxFeesPerGas ?? (await this.wallet.getCurrentBaseFees());
+    const paymentMethod = fee?.paymentMethod ?? new NoFeePaymentMethod();
+    const gasSettings: GasSettings = GasSettings.default({ ...fee?.gasSettings, maxFeesPerGas });
+    return { gasSettings, paymentMethod };
+  }
+
+  /**
+   * 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%).
    * @returns Fee options for the actual transaction.
    */
-  protected async getFeeOptionsFromEstimatedGas(request: ExecutionRequestInit, pad?: number) {
-    const fee = request.fee;
-    if (fee) {
-      const txRequest = await this.wallet.createTxExecutionRequest(request);
+  protected async getFeeOptions(
+    request: Omit<ExecutionRequestInit, 'fee'> & { /** User-provided fee options */ fee?: UserFeeOptions },
+  ): Promise<FeeOptions> {
+    const defaultFeeOptions = await this.getDefaultFeeOptions(request.fee);
+    const paymentMethod = defaultFeeOptions.paymentMethod;
+    const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
+
+    let gasSettings = defaultFeeOptions.gasSettings;
+    if (request.fee?.estimateGas) {
+      const feeForEstimation: FeeOptions = { paymentMethod, gasSettings };
+      const txRequest = await this.wallet.createTxExecutionRequest({ ...request, fee: feeForEstimation });
       const simulationResult = await this.wallet.simulateTx(txRequest, true);
-      const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(simulationResult, pad);
-      this.log.debug(
+      const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
+        simulationResult,
+        request.fee?.estimatedGasPadding,
+      );
+      gasSettings = GasSettings.from({ maxFeesPerGas, gasLimits, teardownGasLimits });
+      this.log.verbose(
         `Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`,
       );
-      const gasSettings = GasSettings.default({ ...fee.gasSettings, gasLimits, teardownGasLimits });
-      return { ...fee, gasSettings };
     }
-    return fee;
+
+    return { gasSettings, paymentMethod };
   }
 }

package/src/contract/batch_call.ts

@@ -19,10 +19,8 @@ export class BatchCall extends BaseContractInteraction {
    */
   public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
     const calls = this.calls;
-    const fee = opts?.estimateGas
-      ? await this.getFeeOptionsFromEstimatedGas({ calls, fee: opts?.fee }, opts?.estimatedGasPad)
-      : opts?.fee;
-    return await this.wallet.createTxExecutionRequest({ calls, fee });
+    const fee = await this.getFeeOptions({ calls, ...opts });
+    return await this.wallet.createTxExecutionRequest({ calls, ...opts, fee });
   }
 
   /**
@@ -35,29 +33,21 @@ 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 { calls, unconstrained } = this.calls.reduce<{
-      /**
-       * Keep track of the number of private calls to retrieve the return values
-       */
+    const { indexedCalls, unconstrained } = this.calls.reduce<{
+      /** Keep track of the number of private calls to retrieve the return values */
       privateIndex: 0;
-      /**
-       * Keep track of the number of private calls to retrieve the return values
-       */
+      /** Keep track of the number of public calls to retrieve the return values */
       publicIndex: 0;
-      /**
-       * The public and private function calls in the batch
-       */
-      calls: [FunctionCall, number, number][];
-      /**
-       * The unconstrained function calls in the batch.
-       */
+      /** The public and private function calls in the batch */
+      indexedCalls: [FunctionCall, number, number][];
+      /** The unconstrained function calls in the batch. */
       unconstrained: [FunctionCall, number][];
     }>(
       (acc, current, index) => {
         if (current.type === FunctionType.UNCONSTRAINED) {
           acc.unconstrained.push([current, index]);
         } else {
-          acc.calls.push([
+          acc.indexedCalls.push([
             current,
             index,
             current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
@@ -65,18 +55,17 @@ export class BatchCall extends BaseContractInteraction {
         }
         return acc;
       },
-      { calls: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
+      { indexedCalls: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const txRequest = await this.wallet.createTxExecutionRequest({ calls: calls.map(indexedCall => indexedCall[0]) });
+    const calls = indexedCalls.map(([call]) => call);
+    const fee = await this.getFeeOptions({ calls, ...options });
+    const txRequest = await this.wallet.createTxExecutionRequest({ calls, ...options, fee });
 
-    const unconstrainedCalls = unconstrained.map(async indexedCall => {
-      const call = indexedCall[0];
-      return [
-        await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from),
-        indexedCall[1],
-      ] as const;
-    });
+    const unconstrainedCalls = unconstrained.map(
+      async ([call, index]) =>
+        [await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from), index] as const,
+    );
 
     const [unconstrainedResults, simulatedTx] = await Promise.all([
       Promise.all(unconstrainedCalls),
@@ -88,7 +77,7 @@ export class BatchCall extends BaseContractInteraction {
     unconstrainedResults.forEach(([result, index]) => {
       results[index] = result;
     });
-    calls.forEach(([call, callIndex, resultIndex]) => {
+    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.

package/src/contract/contract_function_interaction.ts

@@ -58,21 +58,14 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    * @param opts - An optional object containing additional configuration for the transaction.
    * @returns A Promise that resolves to a transaction instance.
    */
-  public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
+  public async create(opts: SendMethodOptions = {}): Promise<TxExecutionRequest> {
     if (this.functionDao.functionType === FunctionType.UNCONSTRAINED) {
       throw new Error("Can't call `create` on an unconstrained function.");
     }
     const calls = [this.request()];
-    const fee = opts?.estimateGas
-      ? await this.getFeeOptionsFromEstimatedGas({ calls, fee: opts?.fee }, opts?.estimatedGasPad)
-      : opts?.fee;
-    const txRequest = await this.wallet.createTxExecutionRequest({
-      calls,
-      fee,
-      nonce: opts?.nonce,
-      cancellable: opts?.cancellable,
-    });
-    return txRequest;
+    const fee = await this.getFeeOptions({ calls, ...opts });
+    const { nonce, cancellable } = opts;
+    return await this.wallet.createTxExecutionRequest({ calls, fee, nonce, cancellable });
   }
 
   /**

package/src/contract/deploy_method.ts

@@ -104,18 +104,15 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
     }
 
-    const request = {
-      calls: [...deployment.calls, ...bootstrap.calls],
-      authWitnesses: [...(deployment.authWitnesses ?? []), ...(bootstrap.authWitnesses ?? [])],
-      packedArguments: [...(deployment.packedArguments ?? []), ...(bootstrap.packedArguments ?? [])],
-      fee: options.fee,
-    };
+    const calls = [...deployment.calls, ...bootstrap.calls];
+    const authWitnesses = [...(deployment.authWitnesses ?? []), ...(bootstrap.authWitnesses ?? [])];
+    const packedArguments = [...(deployment.packedArguments ?? []), ...(bootstrap.packedArguments ?? [])];
+    const { cancellable, nonce, fee: userFee } = options;
 
-    if (options.estimateGas) {
-      request.fee = await this.getFeeOptionsFromEstimatedGas(request, options.estimatedGasPad);
-    }
+    const request = { calls, authWitnesses, packedArguments, cancellable, fee: userFee, nonce };
 
-    return request;
+    const fee = await this.getFeeOptions(request);
+    return { ...request, fee };
   }
 
   /**
@@ -133,7 +130,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns A function call array with potentially requests to the class registerer and instance deployer.
    */
-  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
+  protected async getDeploymentFunctionCalls(
+    options: DeployOptions = {},
+  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'packedArguments'>> {
     const calls: FunctionCall[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
@@ -167,9 +166,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       calls.push(deployInstance(this.wallet, instance).request());
     }
 
-    return {
-      calls,
-    };
+    return { calls };
   }
 
   /**
@@ -177,7 +174,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns - An array of function calls.
    */
-  protected getInitializeFunctionCalls(options: DeployOptions): Promise<ExecutionRequestInit> {
+  protected getInitializeFunctionCalls(
+    options: DeployOptions,
+  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'packedArguments'>> {
     const { address } = this.getInstance(options);
     const calls: FunctionCall[] = [];
     if (this.constructorArtifact && !options.skipInitialization) {
@@ -189,9 +188,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       );
       calls.push(constructorCall.request());
     }
-    return Promise.resolve({
-      calls,
-    });
+    return Promise.resolve({ calls });
   }
 
   /**

package/src/entrypoint/default_entrypoint.ts

@@ -1,5 +1,5 @@
 import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
-import { GasSettings, TxContext } from '@aztec/circuits.js';
+import { TxContext } from '@aztec/circuits.js';
 import { FunctionType } from '@aztec/foundation/abi';
 
 import { type EntrypointInterface, type ExecutionRequestInit } from './entrypoint.js';
@@ -11,7 +11,7 @@ export class DefaultEntrypoint implements EntrypointInterface {
   constructor(private chainId: number, private protocolVersion: number) {}
 
   createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { calls, authWitnesses = [], packedArguments = [] } = exec;
+    const { fee, calls, authWitnesses = [], packedArguments = [] } = exec;
 
     if (calls.length > 1) {
       throw new Error(`Expected a single call, got ${calls.length}`);
@@ -24,8 +24,7 @@ export class DefaultEntrypoint implements EntrypointInterface {
     }
 
     const entrypointPackedValues = PackedValues.fromValues(call.args);
-    const gasSettings = exec.fee?.gasSettings ?? GasSettings.default();
-    const txContext = new TxContext(this.chainId, this.protocolVersion, gasSettings);
+    const txContext = new TxContext(this.chainId, this.protocolVersion, fee.gasSettings);
     return Promise.resolve(
       new TxExecutionRequest(
         call.to,

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -1,6 +1,6 @@
 import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
 import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
-import { type AztecAddress, GasSettings, TxContext } from '@aztec/circuits.js';
+import { type AztecAddress, TxContext } from '@aztec/circuits.js';
 import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 
@@ -15,17 +15,16 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
   ) {}
 
   createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { calls, authWitnesses = [], packedArguments = [] } = executions;
+    const { fee, calls, authWitnesses = [], packedArguments = [] } = executions;
     const payload = EntrypointPayload.fromAppExecution(calls);
     const abi = this.getEntrypointAbi();
     const entrypointPackedArgs = PackedValues.fromValues(encodeArguments(abi, [payload]));
-    const gasSettings = executions.fee?.gasSettings ?? GasSettings.default();
 
     const txRequest = TxExecutionRequest.from({
       firstCallArgsHash: entrypointPackedArgs.hash,
       origin: this.address,
       functionSelector: FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
-      txContext: new TxContext(this.chainId, this.version, gasSettings),
+      txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
       argsOfCalls: [...payload.packedArguments, ...packedArguments, entrypointPackedArgs],
       authWitnesses,
     });

package/src/entrypoint/entrypoint.ts

@@ -17,7 +17,7 @@ export type ExecutionRequestInit = {
   /** Any transient packed arguments for this execution */
   packedArguments?: PackedValues[];
   /** How the fee is going to be payed */
-  fee?: FeeOptions;
+  fee: FeeOptions;
   /** An optional nonce. Used to repeat a previous tx with a higher fee so that the first one is cancelled */
   nonce?: Fr;
   /** Whether the transaction can be cancelled. If true, an extra nullifier will be emitted: H(nonce, GENERATOR_INDEX__TX_NULLIFIER) */

package/src/entrypoint/payload.ts

@@ -4,6 +4,7 @@ import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { type Tuple } from '@aztec/foundation/serialize';
+import { type FieldsOf } from '@aztec/foundation/types';
 
 import { type FeePaymentMethod } from '../fee/fee_payment_method.js';
 
@@ -17,6 +18,18 @@ export type FeeOptions = {
   gasSettings: GasSettings;
 };
 
+/** Fee options as set by a user. */
+export type UserFeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod?: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+  /** Whether to run an initial simulation of the tx with high gas limit to figure out actual gas settings. */
+  estimateGas?: boolean;
+  /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
+  estimatedGasPadding?: number;
+};
+
 // These must match the values defined in:
 // - noir-projects/aztec-nr/aztec/src/entrypoint/app.nr
 const APP_MAX_CALLS = 4;