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

package/src/utils/authwit.ts

@@ -1,37 +1,57 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
 import { Fr } from '@aztec/foundation/fields';
-import type { FunctionCall } from '@aztec/stdlib/abi';
+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 { TxProfileResult } 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 {
+  ProfileInteractionOptions,
+  SendInteractionOptions,
+  SimulateInteractionOptions,
+  SimulationReturn,
+} from '../contract/interaction_options.js';
+import type { SentTx } from '../contract/sent_tx.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: Buffer<ArrayBuffer> | 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 */
+function isContractFunctionIntractionCallIntent(
+  messageHashOrIntent: Fr | Buffer | 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 +62,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 +73,240 @@ 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 = isContractFunctionIntractionCallIntent(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 | Buffer | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  chainInfo: ChainInfo,
+) {
+  let messageHash: Fr;
+  const { chainId, version } = chainInfo;
+  if (Buffer.isBuffer(messageHashOrIntent)) {
+    messageHash = Fr.fromBuffer(messageHashOrIntent);
+  } else 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 = isContractFunctionIntractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+    innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
+    consumer = call.to;
+  } else if (Buffer.isBuffer(intent.innerHash)) {
+    innerHash = Fr.fromBuffer(intent.innerHash);
+    consumer = intent.consumer;
+  } 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,
+    isInternal: false,
+    isStatic: false,
+    parameters: [{ name: 'message_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,
+    isInternal: 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 | Buffer | 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 SentTx instance for tracking the transaction status and information.
+   */
+  public override send(options: Omit<SendInteractionOptions, 'from'> = {}): SentTx {
+    return super.send({ ...options, from: this.from });
+  }
+
+  private static getSetAuthorizedAbi(): FunctionAbi {
+    return {
+      name: 'set_authorized',
+      isInitializer: false,
+      functionType: FunctionType.PUBLIC,
+      isInternal: 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/fields';
+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

@@ -2,13 +2,13 @@ import { Fr } from '@aztec/foundation/fields';
 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_sandbox_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/node.ts

@@ -9,7 +9,7 @@ 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;

package/src/utils/pub_key.ts

@@ -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,105 @@
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { EncodedAppEntrypointCalls } from '@aztec/entrypoints/encoding';
+import { ExecutionPayload } from '@aztec/entrypoints/payload';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+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';
+
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { Wallet } from './index.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 wallet: Wallet,
+    private artifact: ContractArtifact,
+    private feePaymentNameOrArtifact: string | FunctionArtifact,
+    private accountAddress: AztecAddress,
+    private paymentMethod?: FeePaymentMethod,
+  ) {}
+
+  getAsset(): Promise<AztecAddress> {
+    return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
+    // It can be empty because the account might attempt to pay for the tx fee using its own
+    // FeeJuice balance
+    const { calls: feeCalls, authWitnesses: feeAuthwitnesses } =
+      (await this.paymentMethod?.getExecutionPayload()) ?? ExecutionPayload.empty();
+    // Encode the calls for the fee
+    const feePayer = (await this.paymentMethod?.getFeePayer()) ?? this.accountAddress;
+    const isFeePayer = feePayer.equals(this.accountAddress);
+    let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+    if (isFeePayer) {
+      // If the account is the fee payer, and the incoming fee payload has calls
+      // it can only be FeeJuicePaymentMethodWithClaim
+      // If the payload has no calls, it's paying using
+      // its own fee juice balance
+      accountFeePaymentMethodOptions =
+        feeCalls.length === 0
+          ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE
+          : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+    }
+    const feeEncodedCalls = await EncodedAppEntrypointCalls.create(feeCalls);
+
+    // Get the entrypoint args
+    const args = [feeEncodedCalls, accountFeePaymentMethodOptions, 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,
+      false /** hideMsgSender -- set to `false`, because it's not applicable for an entrypoint function (only for enqueued public calls) */,
+      feePaymentArtifact.isStatic,
+      encodeArguments(feePaymentArtifact, args),
+      feePaymentArtifact.returnTypes,
+    );
+
+    // Compute the authwitness required to verify the combined payload
+    const payloadAuthWitness = await this.wallet.createAuthWit(this.accountAddress, await feeEncodedCalls.hash());
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      [payloadAuthWitness, ...feeAuthwitnesses],
+      [],
+      feeEncodedCalls.hashedArguments,
+    );
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.accountAddress);
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.paymentMethod?.getGasSettings();
+  }
+}