@aztec/aztec.js 0.81.0 → 0.82.1-alpha-testnet.1

package/src/deployment/broadcast_function.ts

@@ -59,31 +59,31 @@ export async function broadcastPrivateFunction(
   const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
 
   const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_private_function(
-    contractClass.id,
-    artifactMetadataHash,
-    unconstrainedFunctionsArtifactTreeRoot,
-    privateFunctionTreeSiblingPath,
-    privateFunctionTreeLeafIndex,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
-  );
-
   const bytecode = bufferAsFields(
     privateFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  return registerer.methods
+    .broadcast_private_function(
+      contractClass.id,
+      artifactMetadataHash,
+      unconstrainedFunctionsArtifactTreeRoot,
+      privateFunctionTreeSiblingPath,
+      privateFunctionTreeLeafIndex,
+      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+      artifactTreeLeafIndex,
+      // eslint-disable-next-line camelcase
+      { selector, metadata_hash: functionMetadataHash, vk_hash: vkHash },
+    )
+    .with({
+      capsules: [
+        new Capsule(
+          ProtocolContractAddress.ContractClassRegisterer,
+          new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+          bytecode,
+        ),
+      ],
+    });
 }
 
 /**
@@ -122,27 +122,27 @@ export async function broadcastUnconstrainedFunction(
   } = await createUnconstrainedFunctionMembershipProof(selector, artifact);
 
   const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.broadcast_unconstrained_function(
-    contractClass.id,
-    artifactMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
-    artifactTreeLeafIndex,
-    // eslint-disable-next-line camelcase
-    { selector, metadata_hash: functionMetadataHash },
-  );
-
   const bytecode = bufferAsFields(
     unconstrainedFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      bytecode,
-    ),
-  );
-
-  return fn;
+  return registerer.methods
+    .broadcast_unconstrained_function(
+      contractClass.id,
+      artifactMetadataHash,
+      privateFunctionsArtifactTreeRoot,
+      padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+      artifactTreeLeafIndex,
+      // eslint-disable-next-line camelcase
+      { selector, metadata_hash: functionMetadataHash },
+    )
+    .with({
+      capsules: [
+        new Capsule(
+          ProtocolContractAddress.ContractClassRegisterer,
+          new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+          bytecode,
+        ),
+      ],
+    });
 }

package/src/deployment/contract_deployer.ts

@@ -2,9 +2,9 @@ import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/wallet.js';
 import { Contract } from '../contract/contract.js';
 import { DeployMethod } from '../contract/deploy_method.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /**
  * A class for deploying contract.

package/src/deployment/register_class.ts

@@ -9,36 +9,23 @@ import type { ContractFunctionInteraction } from '../contract/contract_function_
 import { getRegistererContract } from '../contract/protocol_contracts.js';
 import type { Wallet } from '../wallet/index.js';
 
-const defaultEmitPublicBytecode =
-  // guard against `process` not being defined (e.g. in the browser)
-  typeof process === 'object' && typeof process.env === 'object'
-    ? ['1', 'true', 'yes', ''].includes(process.env.AZTEC_EMIT_PUBLIC_BYTECODE ?? '')
-    : true;
-
 /** Sets up a call to register a contract class given its artifact. */
 export async function registerContractClass(
   wallet: Wallet,
   artifact: ContractArtifact,
-  emitPublicBytecode = defaultEmitPublicBytecode,
 ): Promise<ContractFunctionInteraction> {
   const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
     await getContractClassFromArtifact(artifact);
   const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.register(
-    artifactHash,
-    privateFunctionsRoot,
-    publicBytecodeCommitment,
-    emitPublicBytecode,
-  );
 
   const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      encodedBytecode,
-    ),
-  );
-
-  return fn;
+  return registerer.methods.register(artifactHash, privateFunctionsRoot, publicBytecodeCommitment).with({
+    capsules: [
+      new Capsule(
+        ProtocolContractAddress.ContractClassRegisterer,
+        new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
+        encodedBytecode,
+      ),
+    ],
+  });
 }

package/src/ethereum/portal_manager.ts

@@ -5,6 +5,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import type { SiblingPath } from '@aztec/foundation/trees';
+import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts/FeeAssetHandlerAbi';
 import { FeeJuicePortalAbi } from '@aztec/l1-artifacts/FeeJuicePortalAbi';
 import { OutboxAbi } from '@aztec/l1-artifacts/OutboxAbi';
 import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
@@ -15,6 +16,8 @@ import type { PXE } from '@aztec/stdlib/interfaces/client';
 
 import { type GetContractReturnType, type Hex, getContract, toFunctionSelector } from 'viem';
 
+import type { Wallet } from '../index.js';
+
 // docs:start:claim_type
 // docs:start:claim_type_amount
 /** L1 to L2 message info to claim it on L2. */
@@ -55,19 +58,39 @@ export async function generateClaimSecret(logger?: Logger): Promise<[Fr, Fr]> {
 /** Helper for managing an ERC20 on L1. */
 export class L1TokenManager {
   private contract: GetContractReturnType<typeof TestERC20Abi, ViemWalletClient>;
+  private handler: GetContractReturnType<typeof FeeAssetHandlerAbi, ViemWalletClient> | undefined;
 
   public constructor(
     /** Address of the ERC20 contract. */
-    public readonly address: EthAddress,
+    public readonly tokenAddress: EthAddress,
+    /** Address of the handler/faucet contract. */
+    public readonly handlerAddress: EthAddress | undefined,
     private publicClient: ViemPublicClient,
     private walletClient: ViemWalletClient,
     private logger: Logger,
   ) {
     this.contract = getContract({
-      address: this.address.toString(),
+      address: this.tokenAddress.toString(),
       abi: TestERC20Abi,
       client: this.walletClient,
     });
+    if (this.handlerAddress) {
+      this.handler = getContract({
+        address: this.handlerAddress.toString(),
+        abi: FeeAssetHandlerAbi,
+        client: this.walletClient,
+      });
+    }
+  }
+
+  /** Returns the amount of tokens available to mint via the handler.
+   * @throws if the handler is not provided.
+   */
+  public async getMintAmount() {
+    if (!this.handler) {
+      throw new Error('Minting handler was not provided');
+    }
+    return await this.handler.read.mintAmount();
   }
 
   /**
@@ -79,16 +102,18 @@ export class L1TokenManager {
   }
 
   /**
-   * Mints tokens for the given address. Returns once the tx has been mined.
-   * @param amount - Amount to mint.
+   * Mints a fixed amount of tokens for the given address. Returns once the tx has been mined.
    * @param address - Address to mint the tokens for.
    * @param addressName - Optional name of the address for logging.
    */
-  public async mint(amount: bigint, address: Hex, addressName?: string) {
-    this.logger.info(`Minting ${amount} tokens for ${stringifyEthAddress(address, addressName)}`);
-    await this.publicClient.waitForTransactionReceipt({
-      hash: await this.contract.write.mint([address, amount]),
-    });
+  public async mint(address: Hex, addressName?: string) {
+    if (!this.handler) {
+      throw new Error('Minting handler was not provided');
+    }
+    const mintAmount = await this.getMintAmount();
+    this.logger.info(`Minting ${mintAmount} tokens for ${stringifyEthAddress(address, addressName)}`);
+    // NOTE: the handler mints a fixed amount.
+    await this.handler.write.mint([address]);
   }
 
   /**
@@ -113,11 +138,12 @@ export class L1FeeJuicePortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress,
     private readonly publicClient: ViemPublicClient,
     private readonly walletClient: ViemWalletClient,
     private readonly logger: Logger,
   ) {
-    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.tokenManager = new L1TokenManager(tokenAddress, handlerAddress, publicClient, walletClient, logger);
     this.contract = getContract({
       address: portalAddress.toString(),
       abi: FeeJuicePortalAbi,
@@ -136,16 +162,21 @@ export class L1FeeJuicePortalManager {
    * @param amount - Amount of tokens to send.
    * @param mint - Whether to mint the tokens before sending (only during testing).
    */
-  public async bridgeTokensPublic(to: AztecAddress, amount: bigint, mint = false): Promise<L2AmountClaim> {
+  public async bridgeTokensPublic(to: AztecAddress, amount: bigint | undefined, mint = false): Promise<L2AmountClaim> {
     const [claimSecret, claimSecretHash] = await generateClaimSecret();
+    const mintableAmount = await this.tokenManager.getMintAmount();
+    const amountToBridge = amount ?? mintableAmount;
     if (mint) {
-      await this.tokenManager.mint(amount, this.walletClient.account.address);
+      if (amountToBridge !== mintableAmount) {
+        throw new Error(`Minting amount must be ${mintableAmount}`);
+      }
+      await this.tokenManager.mint(this.walletClient.account.address);
     }
 
-    await this.tokenManager.approve(amount, this.contract.address, 'FeeJuice Portal');
+    await this.tokenManager.approve(amountToBridge, this.contract.address, 'FeeJuice Portal');
 
     this.logger.info('Sending L1 Fee Juice to L2 to be claimed publicly');
-    const args = [to.toString(), amount, claimSecretHash.toString()] as const;
+    const args = [to.toString(), amountToBridge, claimSecretHash.toString()] as const;
 
     await this.contract.simulate.depositToAztecPublic(args);
 
@@ -162,13 +193,13 @@ export class L1FeeJuicePortalManager {
       'DepositToAztecPublic',
       log =>
         log.args.secretHash === claimSecretHash.toString() &&
-        log.args.amount === amount &&
+        log.args.amount === amountToBridge &&
         log.args.to === to.toString(),
       this.logger,
     );
 
     return {
-      claimAmount: amount,
+      claimAmount: amountToBridge,
       claimSecret,
       claimSecretHash,
       messageHash: log.args.key,
@@ -178,26 +209,36 @@ export class L1FeeJuicePortalManager {
 
   /**
    * Creates a new instance
-   * @param pxe - PXE client used for retrieving the L1 contract addresses.
+   * @param walletOrPxe - Wallet or PXE client used for retrieving the L1 contract addresses.
    * @param publicClient - L1 public client.
    * @param walletClient - L1 wallet client.
    * @param logger - Logger.
    */
   public static async new(
-    pxe: PXE,
+    walletOrPxe: Wallet | PXE,
     publicClient: ViemPublicClient,
     walletClient: ViemWalletClient,
     logger: Logger,
   ): Promise<L1FeeJuicePortalManager> {
     const {
-      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress },
-    } = await pxe.getNodeInfo();
+      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress, feeAssetHandlerAddress },
+    } = await walletOrPxe.getNodeInfo();
 
     if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
       throw new Error('Portal or token not deployed on L1');
     }
+    if (!feeAssetHandlerAddress || feeAssetHandlerAddress.isZero()) {
+      throw new Error('Handler not deployed on L1, or handler address is zero');
+    }
 
-    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, publicClient, walletClient, logger);
+    return new L1FeeJuicePortalManager(
+      feeJuicePortalAddress,
+      feeJuiceAddress,
+      feeAssetHandlerAddress,
+      publicClient,
+      walletClient,
+      logger,
+    );
   }
 }
 
@@ -209,11 +250,12 @@ export class L1ToL2TokenPortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     protected publicClient: ViemPublicClient,
     protected walletClient: ViemWalletClient,
     protected logger: Logger,
   ) {
-    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.tokenManager = new L1TokenManager(tokenAddress, handlerAddress, publicClient, walletClient, logger);
     this.portal = getContract({
       address: portalAddress.toString(),
       abi: TokenPortalAbi,
@@ -267,6 +309,7 @@ export class L1ToL2TokenPortalManager {
     };
   }
 
+  // docs:start:bridge_tokens_private
   /**
    * Bridges tokens from L1 to L2 privately. Handles token approvals. Returns once the tx has been mined.
    * @param to - Address to send the tokens to on L2.
@@ -278,6 +321,7 @@ export class L1ToL2TokenPortalManager {
     amount: bigint,
     mint = false,
   ): Promise<L2AmountClaimWithRecipient> {
+    // docs:end:bridge_tokens_private
     const [claimSecret, claimSecretHash] = await this.bridgeSetup(amount, mint);
 
     this.logger.info('Sending L1 tokens to L2 to be claimed privately');
@@ -312,7 +356,11 @@ export class L1ToL2TokenPortalManager {
 
   private async bridgeSetup(amount: bigint, mint: boolean) {
     if (mint) {
-      await this.tokenManager.mint(amount, this.walletClient.account.address);
+      const mintableAmount = await this.tokenManager.getMintAmount();
+      if (amount !== mintableAmount) {
+        throw new Error(`Minting amount must be ${mintableAmount} for testing`);
+      }
+      await this.tokenManager.mint(this.walletClient.account.address);
     }
     await this.tokenManager.approve(amount, this.portal.address, 'TokenPortal');
     return generateClaimSecret();
@@ -326,12 +374,13 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     outboxAddress: EthAddress,
     publicClient: ViemPublicClient,
     walletClient: ViemWalletClient,
     logger: Logger,
   ) {
-    super(portalAddress, tokenAddress, publicClient, walletClient, logger);
+    super(portalAddress, tokenAddress, handlerAddress, publicClient, walletClient, logger);
     this.outbox = getContract({
       address: outboxAddress.toString(),
       abi: OutboxAbi,

package/src/fee/account_entrypoint_meta_payment_method.ts

@@ -0,0 +1,90 @@
+import {
+  EncodedAppEntrypointCalls,
+  EncodedCallsForEntrypoint,
+  computeCombinedPayloadHash,
+} from '@aztec/entrypoints/encoding';
+import type { AuthWitnessProvider, FeePaymentMethod } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
+import {
+  type ContractArtifact,
+  type FunctionArtifact,
+  FunctionCall,
+  FunctionSelector,
+  encodeArguments,
+  getFunctionArtifactByName,
+} from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+
+/**
+ * Fee payment method that allows a contract to pay for its own deployment
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle a fee payload.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in AccountManager.ts#getSelfPaymentMethod
+ */
+export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+  constructor(
+    private artifact: ContractArtifact,
+    private authWitnessProvider: AuthWitnessProvider,
+    private feePaymentNameOrArtifact: string | FunctionArtifact,
+    private accountAddress: AztecAddress,
+    private paymentMethod: FeePaymentMethod,
+  ) {}
+
+  getAsset(): Promise<AztecAddress> {
+    return this.paymentMethod.getAsset();
+  }
+
+  async getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload> {
+    const emptyAppCalls = await EncodedAppEntrypointCalls.fromAppExecution([]);
+    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
+    const { calls: feeCalls, authWitnesses: feeAuthwitnesses } = await this.paymentMethod.getExecutionPayload(
+      gasSettings,
+    );
+    // Encode the calls for the fee
+    const feePayer = await this.paymentMethod.getFeePayer(gasSettings);
+    const isFeePayer = feePayer.equals(this.accountAddress);
+    const feeEncodedCalls = await EncodedCallsForEntrypoint.fromFeeCalls(feeCalls, isFeePayer);
+
+    // Get the entrypoint args
+    const args = [emptyAppCalls, feeEncodedCalls, false];
+    const feePaymentArtifact =
+      typeof this.feePaymentNameOrArtifact === 'string'
+        ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact)
+        : this.feePaymentNameOrArtifact;
+
+    const entrypointCall = new FunctionCall(
+      feePaymentArtifact.name,
+      this.accountAddress,
+      await FunctionSelector.fromNameAndParameters(feePaymentArtifact.name, feePaymentArtifact.parameters),
+      feePaymentArtifact.functionType,
+      feePaymentArtifact.isStatic,
+      encodeArguments(feePaymentArtifact, args),
+      feePaymentArtifact.returnTypes,
+    );
+
+    // Compute the authwitness required to verify the combined payload
+    const combinedPayloadAuthWitness = await this.authWitnessProvider.createAuthWit(
+      await computeCombinedPayloadHash(emptyAppCalls, feeEncodedCalls),
+    );
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      [combinedPayloadAuthWitness, ...feeAuthwitnesses],
+      [],
+      [...emptyAppCalls.hashedArguments, ...feeEncodedCalls.hashedArguments],
+    );
+  }
+
+  getFeePayer(gasSettings: GasSettings): Promise<AztecAddress> {
+    return this.paymentMethod.getFeePayer(gasSettings);
+  }
+}

package/src/fee/fee_juice_payment_method.ts

@@ -1,9 +1,8 @@
+import type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionCall } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { FeePaymentMethod } from './fee_payment_method.js';
-
 // docs:start:fee_juice_method
 /**
  * Pay fee directly in the Fee Juice.
@@ -16,8 +15,8 @@ export class FeeJuicePaymentMethod implements FeePaymentMethod {
     return Promise.resolve(ProtocolContractAddress.FeeJuice);
   }
 
-  getFunctionCalls(): Promise<FunctionCall[]> {
-    return Promise.resolve([]);
+  getExecutionPayload(): Promise<ExecutionPayload> {
+    return Promise.resolve(ExecutionPayload.empty());
   }
 
   getFeePayer(): Promise<AztecAddress> {

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -1,6 +1,6 @@
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionCall } from '@aztec/stdlib/abi';
 import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 
 import { getFeeJuice } from '../contract/protocol_contracts.js';
@@ -20,30 +20,34 @@ export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in Fee Juice.
-   * @returns A function call
+   * Creates an execution payload to pay the fee in Fee Juice.
+   * @returns An execution payload that just contains the claim function call.
    */
-  override async getFunctionCalls(): Promise<FunctionCall[]> {
+  override async getExecutionPayload(): Promise<ExecutionPayload> {
     const canonicalFeeJuice = await getFeeJuice(this.senderWallet);
     const selector = await FunctionSelector.fromNameAndParameters(
       canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
     );
 
-    return Promise.resolve([
-      {
-        to: ProtocolContractAddress.FeeJuice,
-        name: 'claim',
-        selector,
-        isStatic: false,
-        args: [
-          this.senderWallet.getAddress().toField(),
-          new Fr(this.claim.claimAmount),
-          this.claim.claimSecret,
-          new Fr(this.claim.messageLeafIndex),
-        ],
-        returnTypes: [],
-        type: FunctionType.PRIVATE,
-      },
-    ]);
+    return new ExecutionPayload(
+      [
+        {
+          to: ProtocolContractAddress.FeeJuice,
+          name: 'claim',
+          selector,
+          isStatic: false,
+          args: [
+            this.senderWallet.getAddress().toField(),
+            new Fr(this.claim.claimAmount),
+            this.claim.claimSecret,
+            new Fr(this.claim.messageLeafIndex),
+          ],
+          returnTypes: [],
+          type: FunctionType.PRIVATE,
+        },
+      ],
+      [],
+      [],
+    );
   }
 }

package/src/fee/private_fee_payment_method.ts

@@ -1,12 +1,12 @@
+import type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
-import { type FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
 
-import type { Wallet } from '../account/wallet.js';
-import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { SignerlessWallet } from '../wallet/signerless_wallet.js';
-import type { FeePaymentMethod } from './fee_payment_method.js';
+import type { Wallet } from '../wallet/wallet.js';
+import { simulateWithoutSignature } from './utils.js';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
@@ -38,11 +38,10 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
    */
   getAsset(): Promise<AztecAddress> {
     if (!this.assetPromise) {
-      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
-      const signerlessWallet = new SignerlessWallet(this.wallet);
-
-      const interaction = new ContractFunctionInteraction(
-        signerlessWallet,
+      // We use the utility method to avoid a signature because this function could be triggered
+      // before the associated account is deployed.
+      this.assetPromise = simulateWithoutSignature(
+        this.wallet,
         this.paymentContract,
         {
           name: 'get_accepted_asset',
@@ -68,9 +67,7 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
           isInitializer: false,
         },
         [],
-      );
-
-      this.assetPromise = interaction.simulate();
+      ) as Promise<AztecAddress>;
     }
     return this.assetPromise!;
   }
@@ -80,17 +77,17 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in the given asset.
+   * Creates an execution payload to pay the fee using a private function through an FPC in the desired asset
    * @param gasSettings - The gas settings.
-   * @returns The function call to pay the fee.
+   * @returns An execution payload that contains the required function calls and auth witnesses.
    */
-  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
+  async getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload> {
     // We assume 1:1 exchange rate between fee juice and token. But in reality you would need to convert feeLimit
     // (maxFee) to be in token denomination.
     const maxFee = this.setMaxFeeToOne ? Fr.ONE : gasSettings.getFeeLimit();
     const nonce = Fr.random();
 
-    await this.wallet.createAuthWit({
+    const witness = await this.wallet.createAuthWit({
       caller: this.paymentContract,
       action: {
         name: 'transfer_to_public',
@@ -103,16 +100,20 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
       },
     });
 
-    return [
-      {
-        name: 'fee_entrypoint_private',
-        to: this.paymentContract,
-        selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
-        type: FunctionType.PRIVATE,
-        isStatic: false,
-        args: [maxFee, nonce],
-        returnTypes: [],
-      },
-    ];
+    return new ExecutionPayload(
+      [
+        {
+          name: 'fee_entrypoint_private',
+          to: this.paymentContract,
+          selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
+          type: FunctionType.PRIVATE,
+          isStatic: false,
+          args: [maxFee, nonce],
+          returnTypes: [],
+        },
+      ],
+      [witness],
+      [],
+    );
   }
 }