@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/deployment/publish_instance.ts

@@ -0,0 +1,26 @@
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { getInstanceRegistryContract } from '../contract/protocol_contracts.js';
+import type { Wallet } from '../wallet/wallet.js';
+
+/**
+ * Sets up a call to the canonical contract instance registry to publish a contract instance.
+ * @param wallet - The wallet to use for the publication (setup) tx.
+ * @param instance - The instance to publish.
+ */
+export async function publishInstance(
+  wallet: Wallet,
+  instance: ContractInstanceWithAddress,
+): Promise<ContractFunctionInteraction> {
+  const contractInstanceRegistry = await getInstanceRegistryContract(wallet);
+  const { salt, currentContractClassId: contractClassId, publicKeys, deployer: instanceDeployer } = instance;
+  const isUniversalDeploy = instanceDeployer.isZero();
+  return contractInstanceRegistry.methods.publish_for_public_execution(
+    salt,
+    contractClassId,
+    instance.initializationHash,
+    publicKeys,
+    isUniversalDeploy,
+  );
+}

package/src/{api/ethereum → ethereum}/portal_manager.ts

@@ -1,19 +1,23 @@
-import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import type { ExtendedViemWalletClient, ViemContract } from '@aztec/ethereum/types';
 import { extractEvent } from '@aztec/ethereum/utils';
-import { sha256ToField } from '@aztec/foundation/crypto';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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 { FeeJuicePortalAbi, OutboxAbi, TestERC20Abi, TokenPortalAbi } from '@aztec/l1-artifacts';
+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';
+import { TokenPortalAbi } from '@aztec/l1-artifacts/TokenPortalAbi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computeSecretHash } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { computeL2ToL1MessageHash, computeSecretHash } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { getL2ToL1MessageLeafId } from '@aztec/stdlib/messaging';
 
-import { type GetContractReturnType, type Hex, getContract, toFunctionSelector } from 'viem';
+import { type Hex, getContract, toFunctionSelector } from 'viem';
 
-// docs:start:claim_type
-// docs:start:claim_type_amount
 /** L1 to L2 message info to claim it on L2. */
 export type L2Claim = {
   /** Secret for claiming. */
@@ -25,11 +29,9 @@ export type L2Claim = {
   /** Leaf index in the L1 to L2 message tree. */
   messageLeafIndex: bigint;
 };
-// docs:end:claim_type
 
 /** L1 to L2 message info that corresponds to an amount to claim. */
 export type L2AmountClaim = L2Claim & { /** Amount to claim */ claimAmount: bigint };
-// docs:end:claim_type_amount
 
 /** L1 to L2 message info that corresponds to an amount to claim with associated recipient. */
 export type L2AmountClaimWithRecipient = L2AmountClaim & {
@@ -51,20 +53,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 contract: ViemContract<typeof TestERC20Abi>;
+  private handler: ViemContract<typeof FeeAssetHandlerAbi> | undefined;
 
   public constructor(
     /** Address of the ERC20 contract. */
-    public readonly address: EthAddress,
-    private publicClient: ViemPublicClient,
-    private walletClient: ViemWalletClient,
+    public readonly tokenAddress: EthAddress,
+    /** Address of the handler/faucet contract. */
+    public readonly handlerAddress: EthAddress | undefined,
+    private readonly extendedClient: ExtendedViemWalletClient,
     private logger: Logger,
   ) {
     this.contract = getContract({
-      address: this.address.toString(),
+      address: this.tokenAddress.toString(),
       abi: TestERC20Abi,
-      client: this.walletClient,
+      client: this.extendedClient,
     });
+    if (this.handlerAddress) {
+      this.handler = getContract({
+        address: this.handlerAddress.toString(),
+        abi: FeeAssetHandlerAbi,
+        client: this.extendedClient,
+      });
+    }
+  }
+
+  /** 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();
   }
 
   /**
@@ -76,16 +97,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]);
   }
 
   /**
@@ -96,7 +119,7 @@ export class L1TokenManager {
    */
   public async approve(amount: bigint, address: Hex, addressName = '') {
     this.logger.info(`Approving ${amount} tokens for ${stringifyEthAddress(address, addressName)}`);
-    await this.publicClient.waitForTransactionReceipt({
+    await this.extendedClient.waitForTransactionReceipt({
       hash: await this.contract.write.approve([address, amount]),
     });
   }
@@ -105,20 +128,20 @@ export class L1TokenManager {
 /** Helper for interacting with the FeeJuicePortal on L1. */
 export class L1FeeJuicePortalManager {
   private readonly tokenManager: L1TokenManager;
-  private readonly contract: GetContractReturnType<typeof FeeJuicePortalAbi, ViemWalletClient>;
+  private readonly contract: ViemContract<typeof FeeJuicePortalAbi>;
 
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
-    private readonly publicClient: ViemPublicClient,
-    private readonly walletClient: ViemWalletClient,
+    handlerAddress: EthAddress | undefined,
+    private readonly extendedClient: ExtendedViemWalletClient,
     private readonly logger: Logger,
   ) {
-    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.tokenManager = new L1TokenManager(tokenAddress, handlerAddress, extendedClient, logger);
     this.contract = getContract({
       address: portalAddress.toString(),
       abi: FeeJuicePortalAbi,
-      client: this.walletClient,
+      client: extendedClient,
     });
   }
 
@@ -133,39 +156,59 @@ 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 amountToBridge = amount ?? (await this.tokenManager.getMintAmount());
     if (mint) {
-      await this.tokenManager.mint(amount, this.walletClient.account.address);
+      const mintableAmount = await this.tokenManager.getMintAmount();
+      if (amountToBridge !== mintableAmount) {
+        throw new Error(`Minting amount must be ${mintableAmount}`);
+      }
+      await this.tokenManager.mint(this.extendedClient.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);
 
-    const txReceipt = await this.publicClient.waitForTransactionReceipt({
+    const txReceipt = await this.extendedClient.waitForTransactionReceipt({
       hash: await this.contract.write.depositToAztecPublic(args),
     });
 
-    this.logger.info('Deposited to Aztec public successfully');
+    this.logger.info('Deposited to Aztec public successfully', { txReceipt });
 
     const log = extractEvent(
       txReceipt.logs,
       this.contract.address,
       this.contract.abi,
       'DepositToAztecPublic',
-      log =>
-        log.args.secretHash === claimSecretHash.toString() &&
-        log.args.amount === amount &&
-        log.args.to === to.toString(),
+      log => {
+        // Normalize hex strings for comparison (case-insensitive, handle different formats)
+        const normalizeHex = (val: string | bigint | number) => {
+          const hexStr = typeof val === 'string' ? val : `0x${val.toString(16).padStart(64, '0')}`;
+          return hexStr.toLowerCase();
+        };
+
+        const secretHashMatch = normalizeHex(log.args.secretHash) === normalizeHex(claimSecretHash.toString());
+        const amountMatch = log.args.amount === amountToBridge;
+        const toMatch = normalizeHex(log.args.to) === normalizeHex(to.toString());
+
+        this.logger.debug(
+          `Event filter matching: secretHash=${secretHashMatch} (${log.args.secretHash} vs ${claimSecretHash.toString()}), ` +
+            `amount=${amountMatch} (${log.args.amount} vs ${amountToBridge}), ` +
+            `to=${toMatch} (${log.args.to} vs ${to.toString()})`,
+        );
+
+        return secretHashMatch && amountMatch && toMatch;
+      },
       this.logger,
     );
 
     return {
-      claimAmount: amount,
+      claimAmount: amountToBridge,
       claimSecret,
       claimSecretHash,
       messageHash: log.args.key,
@@ -175,46 +218,48 @@ export class L1FeeJuicePortalManager {
 
   /**
    * Creates a new instance
-   * @param pxe - PXE client used for retrieving the L1 contract addresses.
-   * @param publicClient - L1 public client.
-   * @param walletClient - L1 wallet client.
+   * @param node - Aztec node client used for retrieving the L1 contract addresses.
+   * @param extendedClient - Wallet client, extended with public actions.
    * @param logger - Logger.
    */
   public static async new(
-    pxe: PXE,
-    publicClient: ViemPublicClient,
-    walletClient: ViemWalletClient,
+    node: AztecNode,
+    extendedClient: ExtendedViemWalletClient,
     logger: Logger,
   ): Promise<L1FeeJuicePortalManager> {
     const {
-      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress },
-    } = await pxe.getNodeInfo();
+      l1ContractAddresses: { feeJuiceAddress, feeJuicePortalAddress, feeAssetHandlerAddress },
+    } = await node.getNodeInfo();
 
     if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
       throw new Error('Portal or token not deployed on L1');
     }
 
-    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, publicClient, walletClient, logger);
+    // Handler is optional - it's only needed for minting tokens during testing
+    const handlerAddress =
+      feeAssetHandlerAddress && !feeAssetHandlerAddress.isZero() ? feeAssetHandlerAddress : undefined;
+
+    return new L1FeeJuicePortalManager(feeJuicePortalAddress, feeJuiceAddress, handlerAddress, extendedClient, logger);
   }
 }
 
 /** Helper for interacting with a test TokenPortal on L1 for sending tokens to L2. */
 export class L1ToL2TokenPortalManager {
-  protected readonly portal: GetContractReturnType<typeof TokenPortalAbi, ViemWalletClient>;
+  protected readonly portal: ViemContract<typeof TokenPortalAbi>;
   protected readonly tokenManager: L1TokenManager;
 
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
-    protected publicClient: ViemPublicClient,
-    protected walletClient: ViemWalletClient,
+    handlerAddress: EthAddress | undefined,
+    protected extendedClient: ExtendedViemWalletClient,
     protected logger: Logger,
   ) {
-    this.tokenManager = new L1TokenManager(tokenAddress, publicClient, walletClient, logger);
+    this.tokenManager = new L1TokenManager(tokenAddress, handlerAddress, extendedClient, logger);
     this.portal = getContract({
       address: portalAddress.toString(),
       abi: TokenPortalAbi,
-      client: this.walletClient,
+      client: extendedClient,
     });
   }
 
@@ -239,8 +284,8 @@ export class L1ToL2TokenPortalManager {
       claimSecretHash.toString(),
     ]);
 
-    const txReceipt = await this.publicClient.waitForTransactionReceipt({
-      hash: await this.walletClient.writeContract(request),
+    const txReceipt = await this.extendedClient.waitForTransactionReceipt({
+      hash: await this.extendedClient.writeContract(request),
     });
 
     const log = extractEvent(
@@ -248,10 +293,19 @@ export class L1ToL2TokenPortalManager {
       this.portal.address,
       this.portal.abi,
       'DepositToAztecPublic',
-      log =>
-        log.args.secretHash === claimSecretHash.toString() &&
-        log.args.amount === amount &&
-        log.args.to === to.toString(),
+      log => {
+        // Normalize hex strings for comparison (case-insensitive, handle different formats)
+        const normalizeHex = (val: string | bigint | number) => {
+          const hexStr = typeof val === 'string' ? val : `0x${val.toString(16).padStart(64, '0')}`;
+          return hexStr.toLowerCase();
+        };
+
+        return (
+          normalizeHex(log.args.secretHash) === normalizeHex(claimSecretHash.toString()) &&
+          log.args.amount === amount &&
+          normalizeHex(log.args.to) === normalizeHex(to.toString())
+        );
+      },
       this.logger,
     );
 
@@ -280,8 +334,8 @@ export class L1ToL2TokenPortalManager {
     this.logger.info('Sending L1 tokens to L2 to be claimed privately');
     const { request } = await this.portal.simulate.depositToAztecPrivate([amount, claimSecretHash.toString()]);
 
-    const txReceipt = await this.publicClient.waitForTransactionReceipt({
-      hash: await this.walletClient.writeContract(request),
+    const txReceipt = await this.extendedClient.waitForTransactionReceipt({
+      hash: await this.extendedClient.writeContract(request),
     });
 
     const log = extractEvent(
@@ -289,7 +343,18 @@ export class L1ToL2TokenPortalManager {
       this.portal.address,
       this.portal.abi,
       'DepositToAztecPrivate',
-      log => log.args.amount === amount && log.args.secretHashForL2MessageConsumption === claimSecretHash.toString(),
+      log => {
+        // Normalize hex strings for comparison (case-insensitive, handle different formats)
+        const normalizeHex = (val: string | bigint | number) => {
+          const hexStr = typeof val === 'string' ? val : `0x${val.toString(16).padStart(64, '0')}`;
+          return hexStr.toLowerCase();
+        };
+
+        return (
+          log.args.amount === amount &&
+          normalizeHex(log.args.secretHashForL2MessageConsumption) === normalizeHex(claimSecretHash.toString())
+        );
+      },
       this.logger,
     );
 
@@ -309,7 +374,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.extendedClient.account.address);
     }
     await this.tokenManager.approve(amount, this.portal.address, 'TokenPortal');
     return generateClaimSecret();
@@ -318,21 +387,21 @@ export class L1ToL2TokenPortalManager {
 
 /** Helper for interacting with a test TokenPortal on L1 for both withdrawing from and bridging to L2. */
 export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
-  private readonly outbox: GetContractReturnType<typeof OutboxAbi, ViemWalletClient>;
+  private readonly outbox: ViemContract<typeof OutboxAbi>;
 
   constructor(
     portalAddress: EthAddress,
     tokenAddress: EthAddress,
+    handlerAddress: EthAddress | undefined,
     outboxAddress: EthAddress,
-    publicClient: ViemPublicClient,
-    walletClient: ViemWalletClient,
+    extendedClient: ExtendedViemWalletClient,
     logger: Logger,
   ) {
-    super(portalAddress, tokenAddress, publicClient, walletClient, logger);
+    super(portalAddress, tokenAddress, handlerAddress, extendedClient, logger);
     this.outbox = getContract({
       address: outboxAddress.toString(),
       abi: OutboxAbi,
-      client: walletClient,
+      client: extendedClient,
     });
   }
 
@@ -340,24 +409,27 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
    * Withdraws funds from the portal by consuming an L2 to L1 message. Returns once the tx is mined on L1.
    * @param amount - Amount to withdraw.
    * @param recipient - Who will receive the funds.
-   * @param blockNumber - L2 block number of the message.
+   * @param epochNumber - Epoch number of the message.
    * @param messageIndex - Index of the message.
    * @param siblingPath - Sibling path of the message.
    */
   public async withdrawFunds(
     amount: bigint,
     recipient: EthAddress,
-    blockNumber: bigint,
+    epochNumber: EpochNumber,
     messageIndex: bigint,
     siblingPath: SiblingPath<number>,
   ) {
     this.logger.info(
-      `Sending L1 tx to consume message at block ${blockNumber} index ${messageIndex} to withdraw ${amount}`,
+      `Sending L1 tx to consume message at epoch ${epochNumber} index ${messageIndex} to withdraw ${amount}`,
     );
 
-    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtBlockAndIndex([blockNumber, messageIndex]);
+    const messageLeafId = getL2ToL1MessageLeafId({ leafIndex: messageIndex, siblingPath });
+    const isConsumedBefore = await this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epochNumber), messageLeafId]);
     if (isConsumedBefore) {
-      throw new Error(`L1 to L2 message at block ${blockNumber} index ${messageIndex} has already been consumed`);
+      throw new Error(
+        `L2 to L1 message at epoch ${epochNumber} index ${messageIndex} height ${siblingPath.pathSize} has already been consumed`,
+      );
     }
 
     // Call function on L1 contract to consume the message
@@ -365,16 +437,20 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
       recipient.toString(),
       amount,
       false,
-      BigInt(blockNumber),
+      BigInt(epochNumber),
       messageIndex,
       siblingPath.toBufferArray().map((buf: Buffer): Hex => `0x${buf.toString('hex')}`),
     ]);
 
-    await this.publicClient.waitForTransactionReceipt({ hash: await this.walletClient.writeContract(withdrawRequest) });
+    await this.extendedClient.waitForTransactionReceipt({
+      hash: await this.extendedClient.writeContract(withdrawRequest),
+    });
 
-    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtBlockAndIndex([blockNumber, messageIndex]);
+    const isConsumedAfter = await this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epochNumber), messageLeafId]);
     if (!isConsumedAfter) {
-      throw new Error(`L1 to L2 message at block ${blockNumber} index ${messageIndex} not consumed after withdrawal`);
+      throw new Error(
+        `L2 to L1 message at epoch ${epochNumber} index ${messageIndex} height ${siblingPath.pathSize} not consumed after withdrawal`,
+      );
     }
   }
 
@@ -385,26 +461,27 @@ export class L1TokenPortalManager extends L1ToL2TokenPortalManager {
    * @param l2Bridge - Address of the L2 bridge.
    * @param callerOnL1 - Caller address on L1.
    */
-  public getL2ToL1MessageLeaf(
+  public async getL2ToL1MessageLeaf(
     amount: bigint,
     recipient: EthAddress,
     l2Bridge: AztecAddress,
     callerOnL1: EthAddress = EthAddress.ZERO,
-  ): Fr {
+  ): Promise<Fr> {
+    const version = await this.outbox.read.VERSION();
+
     const content = sha256ToField([
       Buffer.from(toFunctionSelector('withdraw(address,uint256,address)').substring(2), 'hex'),
       recipient.toBuffer32(),
       new Fr(amount).toBuffer(),
       callerOnL1.toBuffer32(),
     ]);
-    const leaf = sha256ToField([
-      l2Bridge.toBuffer(),
-      new Fr(1).toBuffer(), // aztec version
-      EthAddress.fromString(this.portal.address).toBuffer32() ?? Buffer.alloc(32, 0),
-      new Fr(this.publicClient.chain.id).toBuffer(), // chain id
-      content.toBuffer(),
-    ]);
 
-    return leaf;
+    return computeL2ToL1MessageHash({
+      l2Sender: l2Bridge,
+      l1Recipient: EthAddress.fromString(this.portal.address),
+      content,
+      rollupVersion: new Fr(version),
+      chainId: new Fr(this.extendedClient.chain.id),
+    });
   }
 }

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -1,49 +1,64 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionCall } 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 { ExecutionPayload } from '@aztec/stdlib/tx';
 
-import type { L2AmountClaim } from '../api/ethereum/portal_manager.js';
-import { getFeeJuice } from '../contract/protocol_contracts.js';
-import type { Wallet } from '../wallet/index.js';
-import { FeeJuicePaymentMethod } from './fee_juice_payment_method.js';
+import type { L2AmountClaim } from '../ethereum/portal_manager.js';
+import type { FeePaymentMethod } from './fee_payment_method.js';
 
 /**
- * Pay fee directly with Fee Juice claimed on the same tx.
+ * Pay fee directly with Fee Juice claimed in the same tx. Claiming consumes an L1 to L2 message that "contains"
+ * the fee juice bridged from L1.
  */
-export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
+export class FeeJuicePaymentMethodWithClaim implements FeePaymentMethod {
   constructor(
-    private senderWallet: Wallet,
+    private sender: AztecAddress,
     private claim: Pick<L2AmountClaim, 'claimAmount' | 'claimSecret' | 'messageLeafIndex'>,
-  ) {
-    super(senderWallet.getAddress());
-  }
+  ) {}
 
   /**
-   * 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_and_end_setup` function call.
    */
-  override async getFunctionCalls(): Promise<FunctionCall[]> {
-    const canonicalFeeJuice = await getFeeJuice(this.senderWallet);
-    const selector = await FunctionSelector.fromNameAndParameters(
-      canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    const selector = await FunctionSelector.fromSignature('claim_and_end_setup((Field),u128,Field,Field)');
+
+    return new ExecutionPayload(
+      [
+        {
+          to: ProtocolContractAddress.FeeJuice,
+          name: 'claim_and_end_setup',
+          selector,
+          hideMsgSender: false,
+          isStatic: false,
+          args: [
+            this.sender.toField(),
+            new Fr(this.claim.claimAmount),
+            this.claim.claimSecret,
+            new Fr(this.claim.messageLeafIndex),
+          ],
+          returnTypes: [],
+          type: FunctionType.PRIVATE,
+        },
+      ],
+      [],
+      [],
+      [],
+      this.sender, // feePayer
     );
+  }
+
+  getAsset() {
+    return Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.sender);
+  }
 
-    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,
-      },
-    ]);
+  getGasSettings(): GasSettings | undefined {
+    return;
   }
 }

package/src/fee/fee_payment_method.ts

@@ -1,6 +1,6 @@
-import type { FunctionCall } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GasSettings } from '@aztec/stdlib/gas';
+import type { ExecutionPayload } from '@aztec/stdlib/tx';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
@@ -9,14 +9,18 @@ export interface FeePaymentMethod {
   /** The asset used to pay the fee. */
   getAsset(): Promise<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.
+   * Returns the data to be added to the final execution request
+   * to pay the fee in the given asset
+   * @returns The function calls to pay the fee.
    */
-  getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]>;
+  getExecutionPayload(): Promise<ExecutionPayload>;
   /**
    * The expected fee payer for this tx.
-   * @param gasSettings - The gas limits and max fees.
    */
-  getFeePayer(gasSettings: GasSettings): Promise<AztecAddress>;
+  getFeePayer(): Promise<AztecAddress>;
+  /**
+   * The gas settings (if any) used to compute the
+   * execution payload of the payment method
+   */
+  getGasSettings(): GasSettings | undefined;
 }