@aztec/aztec.js 0.41.0 → 0.43.0

package/src/contract/base_contract_interaction.ts

@@ -1,5 +1,6 @@
 import { type Tx, type TxExecutionRequest } from '@aztec/circuit-types';
 import { 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';
@@ -27,6 +28,8 @@ export abstract class BaseContractInteraction {
   protected tx?: Tx;
   protected txRequest?: TxExecutionRequest;
 
+  protected log = createDebugLogger('aztec:js:contract_interaction');
+
   constructor(protected wallet: Wallet) {}
 
   /**
@@ -66,14 +69,28 @@ export abstract class BaseContractInteraction {
   }
 
   /**
-   * Estimates gas for a given tx request and returns defaults gas settings for it.
-   * @param txRequest - Transaction execution request to process.
-   * @returns Gas settings.
+   * Estimates gas for a given tx request and returns gas limits for it.
+   * @param opts - Options.
+   * @returns Gas limits.
    */
-  protected async estimateGas(txRequest: TxExecutionRequest) {
+  public async estimateGas(
+    opts?: Omit<SendMethodOptions, 'estimateGas' | 'skipPublicSimulation'>,
+  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
+    // REFACTOR: both `this.txRequest = undefined` below are horrible, we should not be caching stuff that doesn't need to be.
+    // This also hints at a weird interface for create/request/estimate/send etc.
+
+    // Ensure we don't accidentally use a version of tx request that has estimateGas set to true, leading to an infinite loop.
+    this.txRequest = undefined;
+    const txRequest = await this.create({ ...opts, estimateGas: false });
+    // Ensure we don't accidentally cache a version of tx request that has estimateGas forcefully set to false.
+    this.txRequest = undefined;
+
     const simulationResult = await this.wallet.simulateTx(txRequest, true);
-    const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(simulationResult);
-    return GasSettings.default({ gasLimits, teardownGasLimits });
+    const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
+      simulationResult,
+      (opts?.fee?.gasSettings ?? GasSettings.default()).teardownGasLimits,
+    );
+    return { gasLimits, teardownGasLimits };
   }
 
   /**
@@ -81,11 +98,18 @@ export abstract class BaseContractInteraction {
    * @param request - Request to execute for this interaction.
    * @returns Fee options for the actual transaction.
    */
-  protected async getFeeOptions(request: ExecutionRequestInit) {
+  protected async getFeeOptionsFromEstimatedGas(request: ExecutionRequestInit) {
     const fee = request.fee;
     if (fee) {
       const txRequest = await this.wallet.createTxExecutionRequest(request);
-      const { gasLimits, teardownGasLimits } = await this.estimateGas(txRequest);
+      const simulationResult = await this.wallet.simulateTx(txRequest, true);
+      const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
+        simulationResult,
+        fee.gasSettings.teardownGasLimits,
+      );
+      this.log.debug(
+        `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 };
     }

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, TxExecutionRequest } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData, type GasSettings } from '@aztec/circuits.js';
-import { type FunctionAbi, FunctionType, decodeReturnValues, encodeArguments } from '@aztec/foundation/abi';
+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, isStatic: this.functionDao.isStatic };
+    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,
+    };
   }
 
   /**
@@ -80,9 +93,6 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     }
 
     const txRequest = await this.create();
-    // const from =
-    //   this.functionDao.functionType == FunctionType.PRIVATE ? options.from ?? this.wallet.getAddress() : undefined;
-
     const simulatedTx = await this.wallet.simulateTx(txRequest, true, options?.from);
 
     // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
@@ -91,8 +101,8 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
     const rawReturnValues =
       this.functionDao.functionType == FunctionType.PRIVATE
         ? simulatedTx.privateReturnValues?.nested?.[0].values
-        : simulatedTx.publicOutput?.publicReturnValues?.values;
+        : simulatedTx.publicOutput?.publicReturnValues?.[0].values;
 
-    return rawReturnValues ? decodeReturnValues(this.functionDao, rawReturnValues) : [];
+    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'}`,
       );
@@ -80,13 +80,15 @@ export class SentTx {
     if (opts?.debug) {
       const txHash = await this.getTxHash();
       const tx = (await this.pxe.getTxEffect(txHash))!;
-      const visibleNotes = await this.pxe.getNotes({ txHash });
+      const visibleIncomingNotes = await this.pxe.getIncomingNotes({ txHash });
+      const visibleOutgoingNotes = await this.pxe.getOutgoingNotes({ txHash });
       receipt.debugInfo = {
         noteHashes: tx.noteHashes,
         nullifiers: tx.nullifiers,
         publicDataWrites: tx.publicDataWrites,
         l2ToL1Msgs: tx.l2ToL1Msgs,
-        visibleNotes,
+        visibleIncomingNotes,
+        visibleOutgoingNotes,
       };
     }
     return receipt;
@@ -109,7 +111,7 @@ export class SentTx {
    */
   public async getVisibleNotes(): Promise<ExtendedNote[]> {
     await this.wait();
-    return this.pxe.getNotes({ txHash: await this.getTxHash() });
+    return this.pxe.getIncomingNotes({ txHash: await this.getTxHash() });
   }
 
   protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {

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,

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';
@@ -39,13 +40,13 @@ type EncodedFunctionCall = {
 /* 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));
     }
@@ -53,9 +54,9 @@ 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 */
@@ -92,18 +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),
-        new Fr(call.is_static),
-      ]),
-      this.#nonce,
-    ];
-  }
+  abstract toFields(): Fr[];
 
   /**
    * Hashes the payload
@@ -113,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);
   }
 
   /**
@@ -131,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,63 +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)'), /*isPrivate=*/ false),
-        isStatic: false,
-        args: [gasSettings.getFeeLimit()],
-      },
-    ]);
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.sender);
   }
 }