@aztec-labs/aztec.js 6.0.0-nightly.20260829

package/src/utils/authwit.ts

@@ -0,0 +1,327 @@
+import type { ChainInfo } from '@aztec-labs/entrypoints/interfaces';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { STANDARD_AUTH_REGISTRY_ADDRESS } from '@aztec-labs/standard-contracts/auth-registry/constants';
+import { type ABIParameterVisibility, type FunctionAbi, type FunctionCall, FunctionType } from '@aztec-labs/stdlib/abi';
+import { AuthWitness, computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec-labs/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { computeVarArgsHash } from '@aztec-labs/stdlib/hash';
+import type { TxProfileResult } from '@aztec-labs/stdlib/tx';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type {
+  InteractionWaitOptions,
+  ProfileInteractionOptions,
+  SendInteractionOptions,
+  SendInteractionOptionsWithoutWait,
+  SendReturn,
+  SimulateInteractionOptions,
+  SimulationResult,
+  TxSendResultMined,
+} from '../contract/interaction_options.js';
+import type { Wallet } from '../wallet/index.js';
+
+/** Intent with an inner hash */
+export type IntentInnerHash = {
+  /** The consumer   */
+  consumer: AztecAddress;
+  /** The action to approve */
+  innerHash: Fr;
+};
+
+/** Intent with a call */
+export type CallIntent = {
+  /** The caller to approve  */
+  caller: AztecAddress;
+  /** The call to approve */
+  call: FunctionCall;
+};
+
+/** Intent with a ContractFunctionInteraction */
+export type ContractFunctionInteractionCallIntent = {
+  /** The caller to approve  */
+  caller: AztecAddress;
+  /** The action to approve */
+  action: ContractFunctionInteraction;
+};
+
+/** Identifies ContractFunctionInteractionCallIntents */
+export function isContractFunctionInteractionCallIntent(
+  messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+): messageHashOrIntent is ContractFunctionInteractionCallIntent {
+  return (
+    'caller' in messageHashOrIntent &&
+    'action' in messageHashOrIntent &&
+    messageHashOrIntent.action instanceof ContractFunctionInteraction
+  );
+}
+
+/**
+ * Compute an authentication witness message hash from an intent and metadata
+ *
+ * If using the `IntentInnerHash`, the consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ * The `innerHash` itself will be the message that a contract is allowed to execute.
+ * At the point of "approval checking", the validating contract (account for private and registry for public) will be computing the message hash
+ * (`H(consumer, chainid, version, inner_hash)`) where the all but the `inner_hash` is injected from the context (consumer = msg_sender),
+ * and use it for the authentication check.
+ * Therefore, any allowed `innerHash` will therefore also have information around where it can be spent (version, chainId) and who can spend it (consumer).
+ *
+ * If using the `CallIntent`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * The action is then used along with the `caller` to compute the `innerHash` and the consumer.
+ *
+ *
+ * @param intent - The intent to approve (consumer and innerHash or caller and action)
+ *                 The consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ *                 The caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ *                 The caller becomes part of the `inner_hash` and is dealt with entirely in application logic.
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the action
+ */
+export const computeAuthWitMessageHash = async (
+  intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  metadata: ChainInfo,
+) => {
+  const chainId = metadata.chainId;
+  const version = metadata.version;
+
+  if ('caller' in intent) {
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    return computeOuterAuthWitHash(
+      call.to,
+      chainId,
+      version,
+      await computeInnerAuthWitHashFromAction(intent.caller, call),
+    );
+  } else {
+    const inner = Buffer.isBuffer(intent.innerHash) ? Fr.fromBuffer(intent.innerHash) : intent.innerHash;
+    return computeOuterAuthWitHash(intent.consumer, chainId, version, inner);
+  }
+};
+
+/**
+ * Compute an authentication witness message hash from an intent and metadata. This is just
+ * a wrapper around computeAuthwitMessageHash that allows receiving an already computed messageHash as input
+ * @param messageHashOrIntent - The precomputed messageHash or intent to approve (consumer and innerHash or caller and call/action)
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the intent
+ */
+export async function getMessageHashFromIntent(
+  messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  chainInfo: ChainInfo,
+) {
+  let messageHash: Fr;
+  const { chainId, version } = chainInfo;
+  if (messageHashOrIntent instanceof Fr) {
+    messageHash = messageHashOrIntent;
+  } else {
+    messageHash = await computeAuthWitMessageHash(messageHashOrIntent, { chainId, version });
+  }
+  return messageHash;
+}
+
+/**
+ * Computes the inner authwitness hash for either a function call or an action, for it to later be combined with the metadata
+ * required for the outer hash and eventually the full AuthWitness.
+ * @param caller - Who is going to be calling the function
+ * @param action - The action to compute the inner hash from
+ * @returns The inner hash for the action
+ **/
+export const computeInnerAuthWitHashFromAction = async (
+  caller: AztecAddress,
+  action: FunctionCall | ContractFunctionInteraction,
+) => {
+  const call = action instanceof ContractFunctionInteraction ? await action.getFunctionCall() : action;
+  return computeInnerAuthWitHash([caller.toField(), call.selector.toField(), await computeVarArgsHash(call.args)]);
+};
+
+/**
+ * Lookup the validity of an authwit in private and public contexts.
+ *
+ * Uses the chain id and version of the wallet.
+ *
+ * @param wallet - The wallet use to simulate and read the public data
+ * @param onBehalfOf - The address of the "approver"
+ * @param intent - The consumer and inner hash or the caller and action to lookup
+ * @param witness - The computed authentication witness to check
+ * @returns - A struct containing the validity of the authwit in private and public contexts.
+ */
+export async function lookupValidity(
+  wallet: Wallet,
+  onBehalfOf: AztecAddress,
+  intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  witness: AuthWitness,
+): Promise<{
+  /** boolean flag indicating if the authwit is valid in private context */
+  isValidInPrivate: boolean;
+  /** boolean flag indicating if the authwit is valid in public context */
+  isValidInPublic: boolean;
+}> {
+  let innerHash, consumer;
+  if ('caller' in intent) {
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
+    consumer = call.to;
+  } else {
+    ({ innerHash, consumer } = intent);
+  }
+  const chainInfo = await wallet.getChainInfo();
+  const messageHash = await getMessageHashFromIntent(intent, chainInfo);
+  const results = { isValidInPrivate: false, isValidInPublic: false };
+
+  // Check private
+  const lookupValidityAbi = {
+    name: 'lookup_validity',
+    isInitializer: false,
+    functionType: FunctionType.UTILITY,
+    isOnlySelf: false,
+    isStatic: false,
+    parameters: [
+      {
+        name: 'consumer',
+        type: {
+          fields: [{ name: 'inner', type: { kind: 'field' } }],
+          kind: 'struct',
+          path: 'aztec::protocol_types::address::aztec_address::AztecAddress',
+        },
+        visibility: 'private' as ABIParameterVisibility,
+      },
+      { name: 'inner_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
+    ],
+    returnType: { kind: 'boolean' },
+    errorTypes: {},
+  } as FunctionAbi;
+  try {
+    results.isValidInPrivate = (
+      await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [consumer, innerHash]).simulate({
+        from: onBehalfOf,
+        authWitnesses: [witness],
+      })
+    ).result as boolean;
+    // TODO: Narrow down the error to make sure simulation failed due to an invalid authwit
+    // eslint-disable-next-line no-empty
+  } catch {}
+
+  // check public
+  const isConsumableAbi = {
+    name: 'utility_is_consumable',
+    isInitializer: false,
+    functionType: FunctionType.UTILITY,
+    isOnlySelf: false,
+    isStatic: false,
+    parameters: [
+      {
+        name: 'address',
+        type: {
+          fields: [{ name: 'inner', type: { kind: 'field' } }],
+          kind: 'struct',
+          path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+        },
+        visibility: 'private' as ABIParameterVisibility,
+      },
+      { name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
+    ],
+    returnType: { kind: 'boolean' },
+    errorTypes: {},
+  } as FunctionAbi;
+  results.isValidInPublic = (
+    await new ContractFunctionInteraction(wallet, STANDARD_AUTH_REGISTRY_ADDRESS, isConsumableAbi, [
+      onBehalfOf,
+      messageHash,
+    ]).simulate({ from: onBehalfOf })
+  ).result as boolean;
+
+  return results;
+}
+
+/**
+ * Convenience class designed to wrap the very common interaction of setting a public authwit in the AuthRegistry contract
+ */
+export class SetPublicAuthwitContractInteraction extends ContractFunctionInteraction {
+  private constructor(
+    wallet: Wallet,
+    private from: AztecAddress,
+    messageHash: Fr,
+    authorized: boolean,
+  ) {
+    super(wallet, STANDARD_AUTH_REGISTRY_ADDRESS, SetPublicAuthwitContractInteraction.getSetAuthorizedAbi(), [
+      messageHash,
+      authorized,
+    ]);
+  }
+
+  static async create(
+    wallet: Wallet,
+    from: AztecAddress,
+    messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+    authorized: boolean,
+  ) {
+    const chainInfo = await wallet.getChainInfo();
+    const messageHash = await getMessageHashFromIntent(messageHashOrIntent, chainInfo);
+    return new SetPublicAuthwitContractInteraction(wallet, from, messageHash, authorized);
+  }
+
+  /**
+   * Overrides the simulate method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns The result of the transaction as returned by the contract function.
+   */
+  public override simulate(
+    options: Omit<SimulateInteractionOptions, 'from'> = {} as Omit<SimulateInteractionOptions, 'from'>,
+  ): Promise<SimulationResult> {
+    return super.simulate({ ...options, from: this.from } as SimulateInteractionOptions);
+  }
+
+  /**
+   * Overrides the profile method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - Same options as `simulate`, plus profiling method
+   * @returns An object containing the function return value and profile result.
+   */
+  public override profile(
+    options: Omit<ProfileInteractionOptions, 'from'> = { profileMode: 'gates' },
+  ): Promise<TxProfileResult> {
+    return super.profile({ ...options, from: this.from });
+  }
+
+  /**
+   * Overrides the send method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - An optional object containing 'fee' options information
+   * @returns A TxReceipt (if wait is true/undefined) or TxHash (if wait is false)
+   */
+  public override send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxSendResultMined>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override send<W extends InteractionWaitOptions>(
+    options?: Omit<SendInteractionOptions<W>, 'from'>,
+  ): Promise<SendReturn<W>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override send(
+    options?: Omit<SendInteractionOptions<InteractionWaitOptions>, 'from'>,
+  ): Promise<SendReturn<InteractionWaitOptions>> {
+    return super.send({ ...options, from: this.from });
+  }
+
+  private static getSetAuthorizedAbi(): FunctionAbi {
+    return {
+      name: 'set_authorized',
+      isInitializer: false,
+      functionType: FunctionType.PUBLIC,
+      isOnlySelf: true,
+      isStatic: false,
+      parameters: [
+        {
+          name: 'message_hash',
+          type: { kind: 'field' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+        {
+          name: 'authorize',
+          type: { kind: 'boolean' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+      ],
+      errorTypes: {},
+    };
+  }
+}

package/src/utils/cross_chain.ts

@@ -0,0 +1,55 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { retryUntil } from '@aztec-labs/foundation/retry';
+import type { BlockTag } from '@aztec-labs/stdlib/block';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+
+/**
+ * Waits for the L1 to L2 message to be ready to be consumed.
+ * @param node - Aztec node instance used to obtain the information about the message
+ * @param l1ToL2MessageHash - Hash of the L1 to L2 message
+ * @param opts - Options
+ */
+export function waitForL1ToL2MessageReady(
+  node: Pick<AztecNode, 'getBlockData' | 'getL1ToL2MessageIndex'>,
+  l1ToL2MessageHash: Fr,
+  opts: {
+    /** Timeout for the operation in seconds */ timeoutSeconds: number;
+    /**
+     * Chain tip to evaluate readiness against. Defaults to `'latest'`. Set this to the tip the consuming PXE syncs to
+     * (e.g. `'proven'`) so readiness answers whether the message is present at the same block the transaction
+     * simulation will anchor to, not at a newer tip.
+     */
+    chainTip?: BlockTag;
+  },
+): Promise<boolean> {
+  return retryUntil(
+    () => isL1ToL2MessageReady(node, l1ToL2MessageHash, opts.chainTip),
+    `L1 to L2 message ${l1ToL2MessageHash.toString()} ready`,
+    opts.timeoutSeconds,
+    1,
+  );
+}
+
+/**
+ * Returns whether the L1 to L2 message is ready to be consumed.
+ * @param node - Aztec node instance used to obtain the information about the message
+ * @param l1ToL2MessageHash - Hash of the L1 to L2 message
+ * @param chainTip - Chain tip to evaluate readiness against. Defaults to `'latest'`. Pass the tip the consuming PXE
+ * syncs to (e.g. `'proven'`) so readiness is checked at the block the transaction simulation will anchor to.
+ * @returns True if the message is ready to be consumed, false otherwise
+ */
+export async function isL1ToL2MessageReady(
+  node: Pick<AztecNode, 'getBlockData' | 'getL1ToL2MessageIndex'>,
+  l1ToL2MessageHash: Fr,
+  chainTip: BlockTag = 'latest',
+): Promise<boolean> {
+  const messageIndex = await node.getL1ToL2MessageIndex(l1ToL2MessageHash);
+  if (messageIndex === undefined) {
+    return false;
+  }
+
+  // Blocks consume L1-to-L2 messages in Inbox order into consecutive leaves of the message tree, so the message is
+  // available at a tip exactly when that tip's tree has grown past the message's leaf index.
+  const block = await node.getBlockData(chainTip);
+  return block !== undefined && messageIndex < BigInt(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+}

package/src/utils/fee_juice.ts

@@ -0,0 +1,14 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { deriveStorageSlotInMap } from '@aztec-labs/stdlib/hash';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+
+/**
+ * Returns the owner's fee juice balance.
+ * Note: This is used only e2e_local_network_example test. TODO: Consider nuking.
+ */
+export async function getFeeJuiceBalance(owner: AztecAddress, node: AztecNode): Promise<bigint> {
+  const slot = await deriveStorageSlotInMap(new Fr(1), owner);
+  return (await node.getPublicStorageAt('latest', ProtocolContractAddress.FeeJuice, slot)).toBigInt();
+}

package/src/utils/field_compressed_string.ts

@@ -0,0 +1,27 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+/**
+ * The representation of a FieldCompressedString in aztec.nr
+ */
+interface NoirFieldCompressedString {
+  /**
+   * The field value of the string
+   */
+  value: bigint;
+}
+/**
+ * This turns
+ * @param field - The field that contains the string
+ * @returns - the string that is decoded from the field
+ */
+export const readFieldCompressedString = (field: NoirFieldCompressedString): string => {
+  const vals: number[] = Array.from(new Fr(field.value).toBuffer());
+
+  let str = '';
+  for (let i = 0; i < vals.length; i++) {
+    if (vals[i] != 0) {
+      str += String.fromCharCode(Number(vals[i]));
+    }
+  }
+  return str;
+};

package/src/utils/node.ts

@@ -0,0 +1,110 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { retryUntil } from '@aztec-labs/foundation/retry';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+import type { TxHash, TxReceipt } from '@aztec-labs/stdlib/tx';
+import { SortedTxStatuses, TxStatus } from '@aztec-labs/stdlib/tx';
+
+import { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
+
+/**
+ * Waits for an Aztec node to become reachable, polling {@link AztecNode.getNodeInfo} until it succeeds.
+ * @param node - The Aztec node to contact.
+ * @param logger - Optional logger for polling progress.
+ * @param opts - Optional timeout and interval (in seconds). `timeout` defaults to {@link DefaultWaitOpts.timeout};
+ * pass `timeout: 0` to wait indefinitely.
+ * @throws TimeoutError if the node stays unreachable past the timeout.
+ */
+export const waitForNode = async (node: AztecNode, logger?: Logger, opts?: Pick<WaitOpts, 'timeout' | 'interval'>) => {
+  await retryUntil(
+    async () => {
+      try {
+        logger?.verbose('Attempting to contact Aztec node...');
+        await node.getNodeInfo();
+        logger?.verbose('Contacted Aztec node');
+        return true;
+      } catch {
+        logger?.verbose('Failed to contact Aztec Node');
+      }
+      return undefined;
+    },
+    'RPC Get Node Info',
+    opts?.timeout ?? DefaultWaitOpts.timeout,
+    opts?.interval ?? DefaultWaitOpts.interval,
+  );
+};
+
+/** Returns true if the receipt status is at least the desired status level. */
+function hasReachedStatus(receipt: TxReceipt, desiredStatus: TxStatus): boolean {
+  return SortedTxStatuses.indexOf(receipt.status) >= SortedTxStatuses.indexOf(desiredStatus);
+}
+
+/**
+ * Waits for a transaction to be mined and returns its receipt.
+ * @param node - The Aztec node to query for transaction status
+ * @param txHash - The hash of the transaction to wait for
+ * @param opts - Optional configuration for waiting behavior
+ * @returns The transaction receipt
+ * @throws If the transaction fails and dontThrowOnRevert is not set
+ */
+export async function waitForTx(node: AztecNode, txHash: TxHash, opts?: WaitOpts): Promise<TxReceipt> {
+  const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
+  const waitForStatus = opts?.waitForStatus ?? TxStatus.CHECKPOINTED;
+  const timeout = opts?.timeout ?? DefaultWaitOpts.timeout;
+  // The initial delay counts against the timeout: the deadline is fixed before sleeping, and the sleep never
+  // exceeds it.
+  const deadline = timeout ? { deadline: new Date(Date.now() + timeout * 1000) } : undefined;
+
+  if (opts?.initialDelay) {
+    const delay = Math.min(opts.initialDelay, timeout ?? Infinity);
+    await sleep(delay * 1000);
+  }
+
+  // The grace period for DROPPED receipts starts at the first poll, so the initial delay does not consume it.
+  const startTime = Date.now();
+
+  const receipt = await retryUntil(
+    async () => {
+      const txReceipt = await node.getTxReceipt(txHash);
+      // If receipt is not yet available, try again
+      if (txReceipt.isPending()) {
+        return undefined;
+      }
+      // If the tx was "dropped", either return it or ignore based on timing.
+      // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
+      // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
+      if (txReceipt.isDropped()) {
+        const elapsedSeconds = (Date.now() - startTime) / 1000;
+        if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
+          return txReceipt;
+        }
+        return undefined;
+      }
+      // Check if the receipt has reached the desired status level
+      if (!hasReachedStatus(txReceipt, waitForStatus)) {
+        return undefined;
+      }
+      return txReceipt;
+    },
+    'isMined',
+    deadline,
+    opts?.interval ?? DefaultWaitOpts.interval,
+  );
+
+  if (!receipt.isMined()) {
+    throw new Error(`Transaction ${txHash.toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`);
+  }
+  if (!receipt.hasExecutionSucceeded() && !opts?.dontThrowOnRevert) {
+    throw new Error(
+      `Transaction ${txHash.toString()} reverted: ${receipt.executionResult}. Reason: ${receipt.error ?? 'unknown'}`,
+    );
+  }
+
+  return receipt;
+}
+
+export {
+  createAztecNodeClient,
+  type AztecNode,
+  type AztecNodeClientOptions,
+} from '@aztec-labs/stdlib/interfaces/client';

package/src/utils/pub_key.ts

@@ -0,0 +1,12 @@
+import { Grumpkin } from '@aztec-labs/foundation/crypto/grumpkin';
+import type { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import type { PublicKey } from '@aztec-labs/stdlib/keys';
+
+/**
+ * Method for generating a public grumpkin key from a private key.
+ * @param privateKey - The private key.
+ * @returns The generated public key.
+ */
+export function generatePublicKey(privateKey: GrumpkinScalar): Promise<PublicKey> {
+  return Grumpkin.mul(Grumpkin.generator, privateKey);
+}

package/src/wallet/account_entrypoint_meta_payment_method.ts

@@ -0,0 +1,76 @@
+import { AccountFeePaymentMethodOptions } from '@aztec-labs/entrypoints/account';
+import type { ChainInfo } from '@aztec-labs/entrypoints/interfaces';
+import { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { GasSettings } from '@aztec-labs/stdlib/gas';
+import { ExecutionPayload } from '@aztec-labs/stdlib/tx';
+
+import type { Account } from '../account/account.js';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+
+/**
+ * Fee payment method that allows an account 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. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * 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 it.
+ * 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 DeployAccountMethod.ts#getSelfPaymentMethod
+ */
+export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+  constructor(
+    private account: Account,
+    private chainInfo: ChainInfo,
+    private paymentMethod?: FeePaymentMethod,
+    private feeEntrypointOptions?: any,
+  ) {}
+
+  getAsset(): Promise<AztecAddress> {
+    return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    // Get the execution payload for the fee
+    const innerPayload = (await this.paymentMethod?.getExecutionPayload()) ?? ExecutionPayload.empty();
+
+    // If no fee entrypoint options were provided, compute them based on the wrapped payment method
+    // This mimics how the actual account contract works when invoked directly:
+    // - If we are the fee payer, are there calls in the inner payload? In that case, those calls can
+    //   only be claiming fee juice, so we use FEE_JUICE_WITH_CLAIM
+    // - If we are the fee payer, but there are no calls, then we assume the account already has
+    //   fee juice and can pay directly with PREEXISTING_FEE_JUICE
+    // - If we are not the fee payer, then EXTERNAL is used
+    let options = this.feeEntrypointOptions;
+    if (!options) {
+      const feePayer = (await this.paymentMethod?.getFeePayer()) ?? this.account.getAddress();
+      const isFeePayer = feePayer.equals(this.account.getAddress());
+
+      let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+      if (isFeePayer) {
+        accountFeePaymentMethodOptions =
+          innerPayload.calls.length === 0
+            ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE
+            : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+      }
+
+      options = { feePaymentMethodOptions: accountFeePaymentMethodOptions };
+    }
+
+    // Use the generic wrapping mechanism from the account interface
+    return this.account.wrapExecutionPayload(innerPayload, this.chainInfo, options);
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.account.getAddress());
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.paymentMethod?.getGasSettings();
+  }
+}