@aztec/aztec.js 0.40.1 → 0.42.0

package/src/contract/batch_call.ts

@@ -1,7 +1,9 @@
 import { type FunctionCall, type TxExecutionRequest } from '@aztec/circuit-types';
+import { FunctionType, decodeReturnValues } from '@aztec/foundation/abi';
 
 import { type Wallet } from '../account/index.js';
 import { BaseContractInteraction, 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. */
 export class BatchCall extends BaseContractInteraction {
@@ -18,9 +20,83 @@ export class BatchCall extends BaseContractInteraction {
   public async create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
     if (!this.txRequest) {
       const calls = this.calls;
-      const fee = opts?.estimateGas ? await this.getFeeOptions({ calls, fee: opts?.fee }) : opts?.fee;
+      const fee = opts?.estimateGas ? await this.getFeeOptionsFromEstimatedGas({ calls, fee: opts?.fee }) : opts?.fee;
       this.txRequest = await this.wallet.createTxExecutionRequest({ calls, fee });
     }
     return this.txRequest;
   }
+
+  /**
+   * 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
+   *
+   * @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 { calls, 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
+       */
+      publicIndex: 0;
+      /**
+       * The public and private function calls in the batch
+       */
+      calls: [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([
+            current,
+            index,
+            current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
+          ]);
+        }
+        return acc;
+      },
+      { calls: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
+    );
+
+    const txRequest = await this.wallet.createTxExecutionRequest({ calls: calls.map(indexedCall => indexedCall[0]) });
+
+    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]];
+    });
+
+    const [unconstrainedResults, simulatedTx] = await Promise.all([
+      Promise.all(unconstrainedCalls),
+      this.wallet.simulateTx(txRequest, true, options?.from),
+    ]);
+
+    const results: any[] = [];
+
+    unconstrainedResults.forEach(([result, index]) => {
+      results[index] = result;
+    });
+    calls.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.privateReturnValues?.nested?.[resultIndex].values
+          : simulatedTx.publicOutput?.publicReturnValues?.[resultIndex].values;
+
+      results[callIndex] = rawReturnValues ? decodeReturnValues(call.returnTypes, rawReturnValues) : [];
+    });
+    return results;
+  }
 }

package/src/contract/contract_function_interaction.ts

@@ -1,6 +1,12 @@
-import { type FunctionCall, PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData, GasSettings, TxContext } from '@aztec/circuits.js';
-import { type FunctionAbi, FunctionType, decodeReturnValues, encodeArguments } from '@aztec/foundation/abi';
+import type { FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
+import { type AztecAddress, type GasSettings } from '@aztec/circuits.js';
+import {
+  type FunctionAbi,
+  FunctionSelector,
+  FunctionType,
+  decodeReturnValues,
+  encodeArguments,
+} from '@aztec/foundation/abi';
 
 import { type Wallet } from '../account/wallet.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
@@ -48,7 +54,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
     if (!this.txRequest) {
       const calls = [this.request()];
-      const fee = opts?.estimateGas ? await this.getFeeOptions({ calls, fee: opts?.fee }) : opts?.fee;
+      const fee = opts?.estimateGas ? await this.getFeeOptionsFromEstimatedGas({ calls, fee: opts?.fee }) : opts?.fee;
       this.txRequest = await this.wallet.createTxExecutionRequest({ calls, fee });
     }
     return this.txRequest;
@@ -61,8 +67,15 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    */
   public request(): FunctionCall {
     const args = encodeArguments(this.functionDao, this.args);
-    const functionData = FunctionData.fromAbi(this.functionDao);
-    return { args, functionData, to: this.contractAddress };
+    return {
+      name: this.functionDao.name,
+      args,
+      selector: FunctionSelector.fromNameAndParameters(this.functionDao.name, this.functionDao.parameters),
+      type: this.functionDao.functionType,
+      to: this.contractAddress,
+      isStatic: this.functionDao.isStatic,
+      returnTypes: this.functionDao.returnTypes,
+    };
   }
 
   /**
@@ -70,42 +83,26 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
    * 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
-   * 3. For `private` execution it:
-   * 3.a SKIPS the entrypoint and starts directly at the function
-   * 4. For `public` execution it:
-   * 4.a Removes the `txRequest` value after ended simulation
-   * 4.b Ignores the `from` in the options
    *
    * @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> {
     if (this.functionDao.functionType == FunctionType.UNCONSTRAINED) {
-      return this.wallet.viewTx(this.functionDao.name, this.args, this.contractAddress, options.from);
+      return this.wallet.simulateUnconstrained(this.functionDao.name, this.args, this.contractAddress, options?.from);
     }
 
-    if (this.functionDao.functionType == FunctionType.SECRET) {
-      const nodeInfo = await this.wallet.getNodeInfo();
-      const packedArgs = PackedValues.fromValues(encodeArguments(this.functionDao, this.args));
-      const gasSettings = options.gasSettings ?? GasSettings.simulation();
+    const txRequest = await this.create();
+    const simulatedTx = await this.wallet.simulateTx(txRequest, true, options?.from);
 
-      const txRequest = TxExecutionRequest.from({
-        firstCallArgsHash: packedArgs.hash,
-        origin: this.contractAddress,
-        functionData: FunctionData.fromAbi(this.functionDao),
-        txContext: new TxContext(nodeInfo.chainId, nodeInfo.protocolVersion, gasSettings),
-        argsOfCalls: [packedArgs],
-        authWitnesses: [],
-      });
-      const simulatedTx = await this.wallet.simulateTx(txRequest, true, options.from ?? this.wallet.getAddress());
-      const flattened = simulatedTx.privateReturnValues;
-      return flattened ? decodeReturnValues(this.functionDao, flattened) : [];
-    } else {
-      const txRequest = await this.create();
-      const simulatedTx = await this.wallet.simulateTx(txRequest, true);
-      this.txRequest = undefined;
-      const flattened = simulatedTx.publicOutput?.publicReturnValues;
-      return flattened ? decodeReturnValues(this.functionDao, flattened) : [];
-    }
+    // 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 =
+      this.functionDao.functionType == FunctionType.PRIVATE
+        ? simulatedTx.privateReturnValues?.nested?.[0].values
+        : simulatedTx.publicOutput?.publicReturnValues?.[0].values;
+
+    return rawReturnValues ? decodeReturnValues(this.functionDao.returnTypes, rawReturnValues) : [];
   }
 }

package/src/contract/deploy_method.ts

@@ -7,7 +7,6 @@ import {
 } from '@aztec/circuits.js';
 import { type ContractArtifact, type FunctionArtifact, getInitializer } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { type Wallet } from '../account/index.js';
@@ -53,8 +52,6 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   /** Cached call to request() */
   private functionCalls?: ExecutionRequestInit;
 
-  private log = createDebugLogger('aztec:js:deploy_method');
-
   constructor(
     private publicKeysHash: Fr,
     wallet: Wallet,
@@ -79,8 +76,6 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
     if (!this.txRequest) {
       this.txRequest = await this.wallet.createTxExecutionRequest(await this.request(options));
-      // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
-      await this.wallet.registerContract({ artifact: this.artifact, instance: this.instance! });
     }
     return this.txRequest;
   }
@@ -98,6 +93,14 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public async request(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
     if (!this.functionCalls) {
+      // 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: this.getInstance(options) });
+
       const deployment = await this.getDeploymentFunctionCalls(options);
       const bootstrap = await this.getInitializeFunctionCalls(options);
 
@@ -113,7 +116,13 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       };
 
       if (options.estimateGas) {
-        request.fee = await this.getFeeOptions(request);
+        // Why do we call this seemingly idempotent getter method here, without using its return value?
+        // This call pushes a capsule required for contract class registration under the hood. And since
+        // capsules are a stack, when we run the simulation for estimating gas, we consume the capsule
+        // that was meant for the actual call. So we need to push it again here. Hopefully this design
+        // will go away soon.
+        await this.getDeploymentFunctionCalls(options);
+        request.fee = await this.getFeeOptionsFromEstimatedGas(request);
       }
 
       this.functionCalls = request;
@@ -233,6 +242,14 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     return super.prove(options);
   }
 
+  /**
+   * Estimates gas cost for this deployment operation.
+   * @param options - Options.
+   */
+  public override estimateGas(options?: Omit<DeployOptions, 'estimateGas' | 'skipPublicSimulation'>) {
+    return super.estimateGas(options);
+  }
+
   /** Return this deployment address. */
   public get address() {
     return this.instance?.address;

package/src/contract/get_gas_limits.ts

@@ -6,8 +6,10 @@ import { Gas } from '@aztec/circuits.js';
  * Note that public gas usage is only accounted for if the publicOutput is present.
  * @param pad - Percentage to pad the suggested gas limits by, defaults to 10%.
  */
-export function getGasLimits(simulatedTx: SimulatedTx, pad = 0.1) {
-  const privateGasUsed = simulatedTx.tx.data.publicInputs.end.gasUsed;
+export function getGasLimits(simulatedTx: SimulatedTx, simulationTeardownGasLimits: Gas, pad = 0.1) {
+  const privateGasUsed = simulatedTx.tx.data.publicInputs.end.gasUsed
+    .sub(simulationTeardownGasLimits)
+    .add(simulatedTx.tx.data.forPublic?.endNonRevertibleData.gasUsed ?? Gas.empty());
   if (simulatedTx.publicOutput) {
     const publicGasUsed = Object.values(simulatedTx.publicOutput.gasUsed)
       .filter(Boolean)
@@ -19,6 +21,5 @@ export function getGasLimits(simulatedTx: SimulatedTx, pad = 0.1) {
       teardownGas: teardownGas.mul(1 + pad),
     };
   }
-
   return { totalGas: privateGasUsed.mul(1 + pad), teardownGas: Gas.empty() };
 }

package/src/contract/sent_tx.ts

@@ -72,7 +72,7 @@ export class SentTx {
       throw new Error('Cannot set debug to true if waitForNotesSync is false');
     }
     const receipt = await this.waitForReceipt(opts);
-    if (!(receipt.status === TxStatus.MINED || (receipt.status === TxStatus.REVERTED && opts?.dontThrowOnRevert))) {
+    if (receipt.status !== TxStatus.SUCCESS && !opts?.dontThrowOnRevert) {
       throw new Error(
         `Transaction ${await this.getTxHash()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
       );

package/src/entrypoint/default_entrypoint.ts

@@ -1,5 +1,6 @@
 import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
 import { GasSettings, TxContext } from '@aztec/circuits.js';
+import { FunctionType } from '@aztec/foundation/abi';
 
 import { type EntrypointInterface, type ExecutionRequestInit } from './entrypoint.js';
 
@@ -17,13 +18,18 @@ export class DefaultEntrypoint implements EntrypointInterface {
     }
 
     const call = calls[0];
+
+    if (call.type !== FunctionType.PRIVATE) {
+      throw new Error('Public entrypoints are not allowed');
+    }
+
     const entrypointPackedValues = PackedValues.fromValues(call.args);
     const gasSettings = exec.fee?.gasSettings ?? GasSettings.default();
     const txContext = new TxContext(this.chainId, this.protocolVersion, gasSettings);
     return Promise.resolve(
       new TxExecutionRequest(
         call.to,
-        call.functionData,
+        call.selector,
         entrypointPackedValues.hash,
         txContext,
         [...packedArguments, entrypointPackedValues],

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -1,7 +1,7 @@
 import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
 import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData, GasSettings, TxContext } from '@aztec/circuits.js';
-import { type FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
+import { type AztecAddress, GasSettings, TxContext } from '@aztec/circuits.js';
+import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
 import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
 
 /**
@@ -24,7 +24,7 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
     const txRequest = TxExecutionRequest.from({
       firstCallArgsHash: entrypointPackedArgs.hash,
       origin: this.address,
-      functionData: FunctionData.fromAbi(abi),
+      functionSelector: FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
       txContext: new TxContext(this.chainId, this.version, gasSettings),
       argsOfCalls: [...payload.packedArguments, ...packedArguments, entrypointPackedArgs],
       authWitnesses,
@@ -37,8 +37,9 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
     return {
       name: 'entrypoint',
       isInitializer: false,
-      functionType: 'secret',
+      functionType: 'private',
       isInternal: false,
+      isStatic: false,
       parameters: [
         {
           name: 'app_payload',
@@ -73,6 +74,7 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
                         },
                       },
                       { name: 'is_public', type: { kind: 'boolean' } },
+                      { name: 'is_static', type: { kind: 'boolean' } },
                     ],
                   },
                 },

package/src/entrypoint/payload.ts

@@ -1,5 +1,6 @@
-import { type FunctionCall, PackedValues, emptyFunctionCall } from '@aztec/circuit-types';
-import { Fr, type GasSettings, GeneratorIndex } from '@aztec/circuits.js';
+import { FunctionCall, PackedValues } from '@aztec/circuit-types';
+import { type AztecAddress, Fr, type GasSettings, GeneratorIndex } from '@aztec/circuits.js';
+import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import { type Tuple } from '@aztec/foundation/serialize';
@@ -33,17 +34,19 @@ type EncodedFunctionCall = {
   target_address: Fr;
   /** Whether the function is public or private */
   is_public: boolean;
+  /** Whether the function can alter state */
+  is_static: boolean;
 };
 /* eslint-enable camelcase */
 
 /** Assembles an entrypoint payload */
-export class EntrypointPayload {
+export abstract class EntrypointPayload {
   #packedArguments: PackedValues[] = [];
   #functionCalls: EncodedFunctionCall[] = [];
   #nonce = Fr.random();
   #generatorIndex: number;
 
-  private constructor(functionCalls: FunctionCall[], generatorIndex: number) {
+  protected constructor(functionCalls: FunctionCall[], generatorIndex: number) {
     for (const call of functionCalls) {
       this.#packedArguments.push(PackedValues.fromValues(call.args));
     }
@@ -51,9 +54,10 @@ export class EntrypointPayload {
     /* eslint-disable camelcase */
     this.#functionCalls = functionCalls.map((call, index) => ({
       args_hash: this.#packedArguments[index].hash,
-      function_selector: call.functionData.selector.toField(),
+      function_selector: call.selector.toField(),
       target_address: call.to.toField(),
-      is_public: !call.functionData.isPrivate,
+      is_public: call.type == FunctionType.PUBLIC,
+      is_static: call.isStatic,
     }));
     /* eslint-enable camelcase */
 
@@ -89,17 +93,7 @@ export class EntrypointPayload {
    * Serializes the payload to an array of fields
    * @returns The fields of the payload
    */
-  toFields(): Fr[] {
-    return [
-      ...this.#functionCalls.flatMap(call => [
-        call.args_hash,
-        call.function_selector,
-        call.target_address,
-        new Fr(call.is_public),
-      ]),
-      this.#nonce,
-    ];
-  }
+  abstract toFields(): Fr[];
 
   /**
    * Hashes the payload
@@ -109,13 +103,24 @@ export class EntrypointPayload {
     return pedersenHash(this.toFields(), this.#generatorIndex);
   }
 
+  /** Serializes the function calls to an array of fields. */
+  protected functionCallsToFields() {
+    return this.#functionCalls.flatMap(call => [
+      call.args_hash,
+      call.function_selector,
+      call.target_address,
+      new Fr(call.is_public),
+      new Fr(call.is_static),
+    ]);
+  }
+
   /**
-   * Creates an execution payload from a set of function calls
+   * Creates an execution payload for a dapp from a set of function calls
    * @param functionCalls - The function calls to execute
    * @returns The execution payload
    */
   static fromFunctionCalls(functionCalls: FunctionCall[]) {
-    return new EntrypointPayload(functionCalls, 0);
+    return new AppEntrypointPayload(functionCalls, 0);
   }
 
   /**
@@ -127,18 +132,49 @@ export class EntrypointPayload {
     if (functionCalls.length > APP_MAX_CALLS) {
       throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
     }
-    const paddedCalls = padArrayEnd(functionCalls, emptyFunctionCall(), APP_MAX_CALLS);
-    return new EntrypointPayload(paddedCalls, GeneratorIndex.SIGNATURE_PAYLOAD);
+    const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
+    return new AppEntrypointPayload(paddedCalls, GeneratorIndex.SIGNATURE_PAYLOAD);
   }
 
   /**
    * Creates an execution payload to pay the fee for a transaction
+   * @param sender - The address sending this payload
    * @param feeOpts - The fee payment options
    * @returns The execution payload
    */
-  static async fromFeeOptions(feeOpts?: FeeOptions) {
-    const calls = feeOpts ? await feeOpts.paymentMethod.getFunctionCalls(feeOpts?.gasSettings) : [];
-    const paddedCalls = padArrayEnd(calls, emptyFunctionCall(), FEE_MAX_CALLS);
-    return new EntrypointPayload(paddedCalls, GeneratorIndex.FEE_PAYLOAD);
+  static async fromFeeOptions(sender: AztecAddress, feeOpts?: FeeOptions) {
+    const calls = (await feeOpts?.paymentMethod.getFunctionCalls(feeOpts?.gasSettings)) ?? [];
+    const feePayer = await feeOpts?.paymentMethod.getFeePayer(feeOpts?.gasSettings);
+    const isFeePayer = !!feePayer && feePayer.equals(sender);
+    const paddedCalls = padArrayEnd(calls, FunctionCall.empty(), FEE_MAX_CALLS);
+    return new FeeEntrypointPayload(paddedCalls, GeneratorIndex.FEE_PAYLOAD, isFeePayer);
+  }
+}
+
+/** Entrypoint payload for app phase execution. */
+class AppEntrypointPayload extends EntrypointPayload {
+  override toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.nonce];
+  }
+}
+
+/** Entrypoint payload for fee payment to be run during setup phase. */
+class FeeEntrypointPayload extends EntrypointPayload {
+  #isFeePayer: boolean;
+
+  constructor(functionCalls: FunctionCall[], generatorIndex: number, isFeePayer: boolean) {
+    super(functionCalls, generatorIndex);
+    this.#isFeePayer = isFeePayer;
+  }
+
+  override toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.nonce, new Fr(this.#isFeePayer)];
   }
+
+  /* eslint-disable camelcase */
+  /** Whether the sender should be appointed as fee payer. */
+  get is_fee_payer() {
+    return this.#isFeePayer;
+  }
+  /* eslint-enable camelcase */
 }

package/src/fee/fee_payment_method.ts

@@ -6,19 +6,17 @@ import { type AztecAddress } from '@aztec/foundation/aztec-address';
  * Holds information about how the fee for a transaction is to be paid.
  */
 export interface FeePaymentMethod {
-  /**
-   * The asset used to pay the fee.
-   */
+  /** The asset used to pay the fee. */
   getAsset(): AztecAddress;
-  /**
-   * Address which will hold the fee payment.
-   */
-  getPaymentContract(): AztecAddress;
-
   /**
    * Creates a function call to pay the fee in the given asset.
    * @param gasSettings - The gas limits and max fees.
    * @returns The function call to pay the fee.
    */
   getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]>;
+  /**
+   * The expected fee payer for this tx.
+   * @param gasSettings - The gas limits and max fees.
+   */
+  getFeePayer(gasSettings: GasSettings): Promise<AztecAddress>;
 }

package/src/fee/native_fee_payment_method.ts

@@ -1,62 +1,24 @@
 import { type FunctionCall } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData, type GasSettings } from '@aztec/circuits.js';
-import { FunctionSelector } from '@aztec/foundation/abi';
-import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+import { type AztecAddress } from '@aztec/circuits.js';
+import { GasTokenAddress } from '@aztec/protocol-contracts/gas-token';
 
-import { type Wallet } from '../account/wallet.js';
 import { type FeePaymentMethod } from './fee_payment_method.js';
 
 /**
  * Pay fee directly in the native gas token.
  */
 export class NativeFeePaymentMethod implements FeePaymentMethod {
-  #gasTokenAddress: AztecAddress;
+  constructor(protected sender: AztecAddress) {}
 
-  private constructor(canonicalGasTokenAddress: AztecAddress) {
-    this.#gasTokenAddress = canonicalGasTokenAddress;
-  }
-
-  static async create(wallet: Wallet): Promise<NativeFeePaymentMethod> {
-    const nodeInfo = await wallet.getNodeInfo();
-    return new NativeFeePaymentMethod(getCanonicalGasTokenAddress(nodeInfo.l1ContractAddresses.gasPortalAddress));
-  }
-
-  /**
-   * Gets the native gas asset used to pay the fee.
-   * @returns The asset used to pay the fee.
-   */
   getAsset() {
-    return this.#gasTokenAddress;
-  }
-
-  /**
-   * The contract responsible for fee payment. This will be the same as the asset.
-   * @returns The contract address responsible for holding the fee payment.
-   */
-  getPaymentContract() {
-    return this.#gasTokenAddress;
+    return GasTokenAddress;
   }
 
-  /**
-   * Fee payments in the native gas token are always public.
-   * @returns false
-   */
-  isPrivateFeePayment(): boolean {
-    return false;
+  getFunctionCalls(): Promise<FunctionCall[]> {
+    return Promise.resolve([]);
   }
 
-  /**
-   * Creates a function call to pay the fee in gas token.
-   * @param gasSettings - The gas settings.
-   * @returns A function call
-   */
-  getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
-    return Promise.resolve([
-      {
-        to: this.#gasTokenAddress,
-        functionData: new FunctionData(FunctionSelector.fromSignature('pay_fee(Field)'), false),
-        args: [gasSettings.getFeeLimit()],
-      },
-    ]);
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.sender);
   }
 }

package/src/fee/native_fee_payment_method_with_claim.ts

@@ -0,0 +1,33 @@
+import { type FunctionCall } from '@aztec/circuit-types';
+import { type AztecAddress, Fr, FunctionSelector } from '@aztec/circuits.js';
+import { FunctionType } from '@aztec/foundation/abi';
+import { GasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+
+import { NativeFeePaymentMethod } from './native_fee_payment_method.js';
+
+/**
+ * Pay fee directly with native gas token claimed on the same tx.
+ */
+export class NativeFeePaymentMethodWithClaim extends NativeFeePaymentMethod {
+  constructor(sender: AztecAddress, private claimAmount: bigint | Fr, private claimSecret: Fr) {
+    super(sender);
+  }
+
+  /**
+   * Creates a function call to pay the fee in gas token.
+   * @returns A function call
+   */
+  override getFunctionCalls(): Promise<FunctionCall[]> {
+    return Promise.resolve([
+      {
+        to: GasTokenAddress,
+        name: 'claim',
+        selector: FunctionSelector.fromSignature('claim((Field),Field,Field)'),
+        isStatic: false,
+        args: [this.sender, new Fr(this.claimAmount), this.claimSecret],
+        returnTypes: [],
+        type: FunctionType.PRIVATE,
+      },
+    ]);
+  }
+}

package/src/fee/no_fee_payment_method.ts

@@ -0,0 +1,23 @@
+import { type FunctionCall } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+
+import { type FeePaymentMethod } from './fee_payment_method.js';
+
+/**
+ * Does not pay fees. Will work until we enforce fee payment for all txs.
+ */
+export class NoFeePaymentMethod implements FeePaymentMethod {
+  constructor() {}
+
+  getAsset() {
+    return AztecAddress.ZERO;
+  }
+
+  getFunctionCalls(): Promise<FunctionCall[]> {
+    return Promise.resolve([]);
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(AztecAddress.ZERO);
+  }
+}