@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/utils/authwit.ts

@@ -1,37 +1,59 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type ABIParameterVisibility, type FunctionAbi, type FunctionCall, FunctionType } from '@aztec/stdlib/abi';
+import { AuthWitness, computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { HashedValues } from '@aztec/stdlib/tx';
+import { computeVarArgsHash } from '@aztec/stdlib/hash';
+import type { TxHash, TxProfileResult, TxReceipt } from '@aztec/stdlib/tx';
 
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-
-/** Metadata for the intent */
-export type IntentMetadata = {
-  /** The chain id to approve */
-  chainId: Fr;
-  /** The version to approve  */
-  version: Fr;
-};
+import type {
+  InteractionWaitOptions,
+  ProfileInteractionOptions,
+  SendInteractionOptions,
+  SendInteractionOptionsWithoutWait,
+  SendReturn,
+  SimulateInteractionOptions,
+  SimulationReturn,
+} 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: Buffer | Fr;
+  innerHash: Fr;
 };
 
-/** Intent with an action */
-export type IntentAction = {
+/** 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 | FunctionCall;
+  action: ContractFunctionInteraction;
 };
 
-// docs:start:authwit_computeAuthWitMessageHash
+/** 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
  *
@@ -42,7 +64,7 @@ export type IntentAction = {
  * 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 `IntentAction`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * 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.
  *
  *
@@ -53,58 +75,256 @@ export type IntentAction = {
  * @param metadata - The metadata for the intent (chainId, version)
  * @returns The message hash for the action
  */
-export const computeAuthWitMessageHash = async (intent: IntentInnerHash | IntentAction, metadata: IntentMetadata) => {
+export const computeAuthWitMessageHash = async (
+  intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  metadata: ChainInfo,
+) => {
   const chainId = metadata.chainId;
   const version = metadata.version;
 
   if ('caller' in intent) {
-    const action = intent.action instanceof ContractFunctionInteraction ? await intent.action.request() : intent.action;
+    const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
     return computeOuterAuthWitHash(
-      action.to,
+      call.to,
       chainId,
       version,
-      await computeInnerAuthWitHashFromAction(intent.caller, action),
+      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);
   }
 };
-// docs:end:authwit_computeAuthWitMessageHash
-
-export const computeInnerAuthWitHashFromAction = async (caller: AztecAddress, action: FunctionCall) =>
-  computeInnerAuthWitHash([
-    caller.toField(),
-    action.selector.toField(),
-    (await HashedValues.fromValues(action.args)).hash,
-  ]);
 
 /**
- * Compute the inner hash for an authentication witness.
- * This is the "intent" of the message, before siloed with the consumer.
- * It is used as part of the `computeAuthWitMessageHash` but can also be used
- * in case the message is not a "call" to a function, but arbitrary data.
- * @param args - The arguments to hash
- * @returns The inner hash for the witness
+ * 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 const computeInnerAuthWitHash = (args: Fr[]) => {
-  return poseidon2HashWithSeparator(args, GeneratorIndex.AUTHWIT_INNER);
+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)]);
 };
 
 /**
- * Compute the outer hash for an authentication witness.
- * This is the value siloed with its "consumer" and what the `on_behalf_of`
- * should be signing.
- * The consumer is who will be consuming the message, for token approvals it
- * is the token contract itself (because the token makes the call to check the approval).
- * It is used as part of the `computeAuthWitMessageHash` but can also be used
- * in case the message is not a "call" to a function, but arbitrary data.
- * @param consumer - The address that can "consume" the authwit
- * @param chainId - The chain id that can "consume" the authwit
- * @param version - The version that can "consume" the authwit
- * @param innerHash - The inner hash for the witness
- * @returns The outer hash for the witness
+ * 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.
  */
-const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
-  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], GeneratorIndex.AUTHWIT_OUTER);
-};
+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 },
+    ],
+    returnTypes: [{ kind: 'boolean' }],
+    errorTypes: {},
+  } as FunctionAbi;
+  try {
+    results.isValidInPrivate = (await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [
+      consumer,
+      innerHash,
+    ]).simulate({ from: onBehalfOf, authWitnesses: [witness] })) 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 },
+    ],
+    returnTypes: [{ kind: 'boolean' }],
+    errorTypes: {},
+  } as FunctionAbi;
+  results.isValidInPublic = (await new ContractFunctionInteraction(
+    wallet,
+    ProtocolContractAddress.AuthRegistry,
+    isConsumableAbi,
+    [onBehalfOf, messageHash],
+  ).simulate({ from: onBehalfOf })) 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, ProtocolContractAddress.AuthRegistry, 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<T extends SimulateInteractionOptions>(
+    options: Omit<T, 'from'>,
+  ): Promise<SimulationReturn<T['includeMetadata']>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public override simulate(
+    options: Omit<SimulateInteractionOptions, 'from'> = {},
+  ): Promise<SimulationReturn<typeof options.includeMetadata>> {
+    return super.simulate({ ...options, from: this.from });
+  }
+
+  /**
+   * 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)
+   */
+  // Overload for when wait is not specified at all - returns TxReceipt
+  public override send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxReceipt>;
+  // 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<TxReceipt | TxHash> {
+    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,
+        },
+      ],
+      returnTypes: [],
+      errorTypes: {},
+    };
+  }
+}

package/src/utils/cross_chain.ts

@@ -0,0 +1,53 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { retryUntil } from '@aztec/foundation/retry';
+import type { AztecNode } from '@aztec/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 async function waitForL1ToL2MessageReady(
+  node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
+  l1ToL2MessageHash: Fr,
+  opts: {
+    /** Timeout for the operation in seconds */ timeoutSeconds: number;
+    /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
+  },
+) {
+  const messageBlockNumber = await node.getL1ToL2MessageBlock(l1ToL2MessageHash);
+  return retryUntil(
+    () => isL1ToL2MessageReady(node, l1ToL2MessageHash, { ...opts, messageBlockNumber }),
+    `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 opts - Options
+ * @returns True if the message is ready to be consumed, false otherwise
+ */
+export async function isL1ToL2MessageReady(
+  node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
+  l1ToL2MessageHash: Fr,
+  opts: {
+    /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
+    /** Cached synced block number for the message (will be fetched from PXE otherwise) */ messageBlockNumber?: number;
+  },
+): Promise<boolean> {
+  const blockNumber = await node.getBlockNumber();
+  const messageBlockNumber = opts.messageBlockNumber ?? (await node.getL1ToL2MessageBlock(l1ToL2MessageHash));
+  if (messageBlockNumber === undefined) {
+    return false;
+  }
+
+  // Note that public messages can be consumed 1 block earlier, since the sequencer will include the messages
+  // in the L1 to L2 message tree before executing the txs for the block. In private, however, we need to wait
+  // until the message is included so we can make use of the membership witness.
+  return opts.forPublicConsumption ? blockNumber + 1 >= messageBlockNumber : blockNumber >= messageBlockNumber;
+}

package/src/utils/fee_juice.ts

@@ -1,14 +1,14 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
-
-import type { PXE } from '../api/interfaces/pxe.js';
+import type { AztecNode } from '@aztec/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, pxe: PXE): Promise<bigint> {
+export async function getFeeJuiceBalance(owner: AztecAddress, node: AztecNode): Promise<bigint> {
   const slot = await deriveStorageSlotInMap(new Fr(1), owner);
-  return (await pxe.getPublicStorageAt(ProtocolContractAddress.FeeJuice, slot)).toBigInt();
+  return (await node.getPublicStorageAt('latest', ProtocolContractAddress.FeeJuice, slot)).toBigInt();
 }

package/src/utils/field_compressed_string.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * The representation of a FieldCompressedString in aztec.nr

package/src/utils/node.ts

@@ -1,6 +1,10 @@
 import type { Logger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import { SortedTxStatuses, TxStatus } from '@aztec/stdlib/tx';
+
+import { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
 
 export const waitForNode = async (node: AztecNode, logger?: Logger) => {
   await retryUntil(async () => {
@@ -9,11 +13,69 @@ export const waitForNode = async (node: AztecNode, logger?: Logger) => {
       await node.getNodeInfo();
       logger?.verbose('Contacted Aztec node');
       return true;
-    } catch (error) {
+    } catch {
       logger?.verbose('Failed to contact Aztec Node');
     }
     return undefined;
   }, 'RPC Get Node Info');
 };
 
+/** 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 startTime = Date.now();
+  const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
+  const waitForStatus = opts?.waitForStatus ?? TxStatus.CHECKPOINTED;
+
+  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',
+    opts?.timeout ?? DefaultWaitOpts.timeout,
+    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 } from '@aztec/stdlib/interfaces/client';

package/src/utils/pub_key.ts

@@ -1,5 +1,5 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import type { GrumpkinScalar } from '@aztec/foundation/fields';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import type { PublicKey } from '@aztec/stdlib/keys';
 
 /**
@@ -8,6 +8,5 @@ import type { PublicKey } from '@aztec/stdlib/keys';
  * @returns The generated public key.
  */
 export function generatePublicKey(privateKey: GrumpkinScalar): Promise<PublicKey> {
-  const grumpkin = new Grumpkin();
-  return grumpkin.mul(grumpkin.generator(), privateKey);
+  return Grumpkin.mul(Grumpkin.generator, privateKey);
 }

package/src/wallet/account_entrypoint_meta_payment_method.ts

@@ -0,0 +1,74 @@
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/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 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, options);
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.account.getAddress());
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.paymentMethod?.getGasSettings();
+  }
+}