@aztec/cli-wallet 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/cmds/register_sender.ts

@@ -0,0 +1,7 @@
+import { type AccountWalletWithSecretKey, type AztecAddress } from '@aztec/aztec.js';
+import { type LogFn } from '@aztec/foundation/log';
+
+export async function registerSender(wallet: AccountWalletWithSecretKey, address: AztecAddress, log: LogFn) {
+  await wallet.registerSender(address);
+  log(`Sender registered: ${address}`);
+}

package/src/cmds/send.ts

@@ -0,0 +1,62 @@
+import { type AccountWalletWithSecretKey, type AztecAddress, Contract, Fr } from '@aztec/aztec.js';
+import { GasSettings } from '@aztec/circuits.js';
+import { prepTx } from '@aztec/cli/utils';
+import { type LogFn } from '@aztec/foundation/log';
+
+import { type IFeeOpts, printGasEstimates } from '../utils/options/fees.js';
+
+export async function send(
+  wallet: AccountWalletWithSecretKey,
+  functionName: string,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  wait: boolean,
+  cancellable: boolean,
+  feeOpts: IFeeOpts,
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+
+  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const call = contract.methods[functionName](...functionArgs);
+
+  const gasLimits = await call.estimateGas({ ...(await feeOpts.toSendOpts(wallet)) });
+  printGasEstimates(feeOpts, gasLimits, log);
+
+  if (feeOpts.estimateOnly) {
+    return;
+  }
+
+  const nonce = Fr.random();
+  const tx = call.send({ ...(await feeOpts.toSendOpts(wallet)), nonce, cancellable });
+  const txHash = await tx.getTxHash();
+  log(`\nTransaction hash: ${txHash.toString()}`);
+  if (wait) {
+    try {
+      await tx.wait();
+
+      log('Transaction has been mined');
+
+      const receipt = await tx.getReceipt();
+      log(` Tx fee: ${receipt.transactionFee}`);
+      log(` Status: ${receipt.status}`);
+      log(` Block number: ${receipt.blockNumber}`);
+      log(` Block hash: ${receipt.blockHash?.toString()}`);
+    } catch (err: any) {
+      log(`Transaction failed\n ${err.message}`);
+    }
+  } else {
+    log('Transaction pending. Check status with check-tx');
+  }
+  const gasSettings = GasSettings.from({
+    ...feeOpts.gasSettings,
+    ...gasLimits,
+  });
+  return {
+    txHash,
+    nonce,
+    cancellable,
+    gasSettings,
+  };
+}

package/src/cmds/simulate.ts

@@ -0,0 +1,42 @@
+import { type AccountWalletWithSecretKey, type AztecAddress, Contract, type ProfileResult } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+import { type LogFn } from '@aztec/foundation/log';
+
+import { format } from 'util';
+
+function printProfileResult(result: ProfileResult, log: LogFn) {
+  log(format('\nSimulation result:'));
+  log(format('Return value:', JSON.stringify(result.returnValues, null, 2)));
+
+  log(format('\nGate count per circuit:'));
+  let acc = 0;
+  result.gateCounts.forEach(r => {
+    acc += r.gateCount;
+    log(format('  ', r.circuitName.padEnd(50), 'Gates:', r.gateCount.toLocaleString(), '\tAcc:', acc.toLocaleString()));
+  });
+
+  log(format('\nTotal gates:', acc.toLocaleString()));
+}
+
+export async function simulate(
+  wallet: AccountWalletWithSecretKey,
+  functionName: string,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  profile: boolean,
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+
+  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const call = contract.methods[functionName](...functionArgs);
+
+  if (profile) {
+    const result = await call.simulateWithProfile();
+    printProfileResult(result, log);
+  } else {
+    const result = await call.simulate();
+    log(format('\nSimulation result: ', result, '\n'));
+  }
+}

package/src/storage/wallet_db.ts

@@ -0,0 +1,205 @@
+import { type AuthWitness, type TxHash } from '@aztec/circuit-types';
+import { type AztecAddress, Fr, GasSettings } from '@aztec/circuits.js';
+import { type LogFn } from '@aztec/foundation/log';
+import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+
+import { type AccountType } from '../utils/accounts.js';
+import { extractECDSAPublicKeyFromBase64String } from '../utils/ecdsa.js';
+
+export const Aliases = ['accounts', 'contracts', 'artifacts', 'secrets', 'transactions', 'authwits'] as const;
+export type AliasType = (typeof Aliases)[number];
+
+export class WalletDB {
+  #accounts!: AztecMap<string, Buffer>;
+  #aliases!: AztecMap<string, Buffer>;
+  #bridgedFeeJuice!: AztecMap<string, Buffer>;
+  #transactions!: AztecMap<string, Buffer>;
+
+  private static instance: WalletDB;
+
+  static getInstance() {
+    if (!WalletDB.instance) {
+      WalletDB.instance = new WalletDB();
+    }
+
+    return WalletDB.instance;
+  }
+
+  init(store: AztecKVStore) {
+    this.#accounts = store.openMap('accounts');
+    this.#aliases = store.openMap('aliases');
+    this.#bridgedFeeJuice = store.openMap('bridgedFeeJuice');
+    this.#transactions = store.openMap('transactions');
+  }
+
+  async pushBridgedFeeJuice(recipient: AztecAddress, secret: Fr, amount: bigint, leafIndex: bigint, log: LogFn) {
+    let stackPointer = this.#bridgedFeeJuice.get(`${recipient.toString()}:stackPointer`)?.readInt8() || 0;
+    stackPointer++;
+    await this.#bridgedFeeJuice.set(
+      `${recipient.toString()}:${stackPointer}`,
+      Buffer.from(`${amount.toString()}:${secret.toString()}:${leafIndex.toString()}`),
+    );
+    await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([stackPointer]));
+    log(`Pushed ${amount} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+  }
+
+  async popBridgedFeeJuice(recipient: AztecAddress, log: LogFn) {
+    let stackPointer = this.#bridgedFeeJuice.get(`${recipient.toString()}:stackPointer`)?.readInt8() || 0;
+    const result = this.#bridgedFeeJuice.get(`${recipient.toString()}:${stackPointer}`);
+    if (!result) {
+      throw new Error(
+        `No stored fee juice available for recipient ${recipient.toString()}. Please provide claim amount and secret. Stack pointer ${stackPointer}`,
+      );
+    }
+    const [amountStr, secretStr, leafIndexStr] = result.toString().split(':');
+    await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([--stackPointer]));
+    log(`Retrieved ${amountStr} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    return { amount: BigInt(amountStr), secret: secretStr, leafIndex: BigInt(leafIndexStr) };
+  }
+
+  async storeAccount(
+    address: AztecAddress,
+    {
+      type,
+      secretKey,
+      salt,
+      alias,
+      publicKey,
+    }: { type: AccountType; secretKey: Fr; salt: Fr; alias: string | undefined; publicKey: string | undefined },
+    log: LogFn,
+  ) {
+    if (alias) {
+      await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+    }
+    await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type));
+    await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer());
+    await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer());
+    if (type === 'ecdsasecp256r1ssh' && publicKey) {
+      const publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
+      await this.storeAccountMetadata(address, 'publicSigningKey', publicSigningKey);
+    }
+    await this.#aliases.set('accounts:last', Buffer.from(address.toString()));
+    log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+  }
+
+  async storeSender(address: AztecAddress, alias: string, log: LogFn) {
+    await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+    log(`Account stored in database with alias ${alias} as a sender`);
+  }
+
+  async storeContract(address: AztecAddress, artifactPath: string, log: LogFn, alias?: string) {
+    if (alias) {
+      await this.#aliases.set(`contracts:${alias}`, Buffer.from(address.toString()));
+      await this.#aliases.set(`artifacts:${alias}`, Buffer.from(artifactPath));
+    }
+    await this.#aliases.set(`contracts:last`, Buffer.from(address.toString()));
+    await this.#aliases.set(`artifacts:last`, Buffer.from(artifactPath));
+    await this.#aliases.set(`artifacts:${address.toString()}`, Buffer.from(artifactPath));
+    log(`Contract stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+  }
+
+  async storeAuthwitness(authWit: AuthWitness, log: LogFn, alias?: string) {
+    if (alias) {
+      await this.#aliases.set(`authwits:${alias}`, Buffer.from(authWit.toString()));
+    }
+    await this.#aliases.set(`authwits:last`, Buffer.from(authWit.toString()));
+    log(`Authorization witness stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+  }
+
+  async storeTx(
+    {
+      txHash,
+      nonce,
+      cancellable,
+      gasSettings,
+    }: { txHash: TxHash; nonce: Fr; cancellable: boolean; gasSettings: GasSettings },
+    log: LogFn,
+    alias?: string,
+  ) {
+    if (alias) {
+      await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
+    }
+    await this.#transactions.set(`${txHash.toString()}:nonce`, nonce.toBuffer());
+    await this.#transactions.set(`${txHash.toString()}:cancellable`, Buffer.from(cancellable ? 'true' : 'false'));
+    await this.#transactions.set(`${txHash.toString()}:gasSettings`, gasSettings.toBuffer());
+    await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
+    log(`Transaction hash stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
+  }
+
+  retrieveTxData(txHash: TxHash) {
+    const nonceBuffer = this.#transactions.get(`${txHash.toString()}:nonce`);
+    if (!nonceBuffer) {
+      throw new Error(
+        `Could not find ${txHash.toString()}:nonce. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`,
+      );
+    }
+    const nonce = Fr.fromBuffer(nonceBuffer);
+    const cancellable = this.#transactions.get(`${txHash.toString()}:cancellable`)!.toString() === 'true';
+    const gasBuffer = this.#transactions.get(`${txHash.toString()}:gasSettings`)!;
+    return { txHash, nonce, cancellable, gasSettings: GasSettings.fromBuffer(gasBuffer) };
+  }
+
+  tryRetrieveAlias(arg: string) {
+    try {
+      return this.retrieveAlias(arg);
+    } catch (e) {
+      return arg;
+    }
+  }
+
+  retrieveAlias(arg: string) {
+    if (Aliases.find(alias => arg.startsWith(`${alias}:`))) {
+      const [type, ...alias] = arg.split(':');
+      const data = this.#aliases.get(`${type}:${alias.join(':') ?? 'last'}`);
+      if (!data) {
+        throw new Error(`Could not find alias ${arg}`);
+      }
+      return data.toString();
+    } else {
+      throw new Error(`Aliases must start with one of ${Aliases.join(', ')}`);
+    }
+  }
+
+  listAliases(type?: AliasType) {
+    const result = [];
+    if (type && !Aliases.includes(type)) {
+      throw new Error(`Unknown alias type ${type}`);
+    }
+    for (const [key, value] of this.#aliases.entries()) {
+      if (!type || key.startsWith(`${type}:`)) {
+        result.push({ key, value: value.toString() });
+      }
+    }
+    return result;
+  }
+
+  async storeAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string, metadata: Buffer) {
+    const { address } = this.retrieveAccount(aliasOrAddress);
+    await this.#accounts.set(`${address.toString()}:${metadataKey}`, metadata);
+  }
+
+  retrieveAccountMetadata(aliasOrAddress: AztecAddress | string, metadataKey: string) {
+    const { address } = this.retrieveAccount(aliasOrAddress);
+    const result = this.#accounts.get(`${address.toString()}:${metadataKey}`);
+    if (!result) {
+      throw new Error(`Could not find metadata with key ${metadataKey} for account ${aliasOrAddress}`);
+    }
+    return result;
+  }
+
+  retrieveAccount(address: AztecAddress | string) {
+    const secretKeyBuffer = this.#accounts.get(`${address.toString()}:sk`);
+    if (!secretKeyBuffer) {
+      throw new Error(`Could not find ${address}:sk. Account "${address.toString}" does not exist on this wallet.`);
+    }
+    const secretKey = Fr.fromBuffer(secretKeyBuffer);
+    const salt = Fr.fromBuffer(this.#accounts.get(`${address.toString()}:salt`)!);
+    const type = this.#accounts.get(`${address.toString()}:type`)!.toString('utf8') as AccountType;
+    return { address, secretKey, salt, type };
+  }
+
+  async storeAlias(type: AliasType, key: string, value: Buffer, log: LogFn) {
+    await this.#aliases.set(`${type}:${key}`, value);
+    log(`Data stored in database with alias ${type}:${key}`);
+  }
+}

package/src/utils/accounts.ts

@@ -0,0 +1,102 @@
+import { getIdentities } from '@aztec/accounts/utils';
+import { type AccountManager, type AccountWalletWithSecretKey } from '@aztec/aztec.js';
+import { type PXE } from '@aztec/circuit-types/interfaces';
+import { deriveSigningKey } from '@aztec/circuits.js/keys';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+
+import { type WalletDB } from '../storage/wallet_db.js';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+
+export const AccountTypes = ['schnorr', 'ecdsasecp256r1ssh', 'ecdsasecp256k1'] as const;
+export type AccountType = (typeof AccountTypes)[number];
+
+export async function createOrRetrieveAccount(
+  pxe: PXE,
+  address?: AztecAddress,
+  db?: WalletDB,
+  secretKey?: Fr,
+  type: AccountType = 'schnorr',
+  salt?: Fr,
+  publicKey?: string | undefined,
+) {
+  let account;
+
+  salt ??= Fr.ZERO;
+
+  if (db && address) {
+    ({ type, secretKey, salt } = db.retrieveAccount(address));
+  }
+
+  if (!salt) {
+    throw new Error('Cannot retrieve/create wallet without salt');
+  }
+
+  if (!secretKey) {
+    throw new Error('Cannot retrieve/create wallet without secret key');
+  }
+
+  switch (type) {
+    case 'schnorr': {
+      const { getSchnorrAccount } = await import('@aztec/accounts/schnorr');
+      account = getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt);
+      break;
+    }
+    case 'ecdsasecp256r1ssh': {
+      let publicSigningKey;
+      if (db && address) {
+        publicSigningKey = db.retrieveAccountMetadata(address, 'publicSigningKey');
+      } else if (publicKey) {
+        const identities = await getIdentities();
+        const foundIdentity = identities.find(
+          identity => identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey,
+        );
+        if (!foundIdentity) {
+          throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
+        }
+        publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+      } else {
+        throw new Error('Public key must be provided for ECDSA SSH account');
+      }
+
+      const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa');
+      account = getEcdsaRSSHAccount(pxe, secretKey, publicSigningKey, salt);
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported account type: ${type}`);
+    }
+  }
+
+  return account;
+}
+
+export async function addScopeToWallet(wallet: AccountWalletWithSecretKey, scope: AztecAddress, db?: WalletDB) {
+  const address = wallet.getAddress().toString();
+  const currentScopes = wallet.getScopes() ?? [];
+  const deduplicatedScopes = Array.from(
+    new Set([address, ...currentScopes, scope].map(scope => scope.toString())).values(),
+  );
+  if (db) {
+    await db.storeAccountMetadata(wallet.getAddress(), 'scopes', Buffer.from(deduplicatedScopes.join(',')));
+  }
+  wallet.setScopes(deduplicatedScopes.map(scope => AztecAddress.fromString(scope)));
+}
+
+export async function getWalletWithScopes(account: AccountManager, db?: WalletDB) {
+  const wallet = await account.getWallet();
+  if (db) {
+    const address = wallet.getAddress().toString();
+    let storedScopes: string[] = [];
+    try {
+      storedScopes = (db.retrieveAccountMetadata(wallet.getAddress(), 'scopes') ?? '').toString().split(',');
+      // eslint-disable-next-line no-empty
+    } catch {}
+    const currentScopes = wallet.getScopes()?.map(scopes => scopes.toString()) ?? [];
+    const deduplicatedScopes = Array.from(new Set([address, ...currentScopes, ...storedScopes]).values()).map(scope =>
+      AztecAddress.fromString(scope),
+    );
+    wallet.setScopes(deduplicatedScopes);
+  }
+  return wallet;
+}

package/src/utils/ecdsa.ts

@@ -0,0 +1,15 @@
+export function extractECDSAPublicKeyFromBase64String(base64PublicKey: string): Buffer {
+  const buffer = Buffer.from(base64PublicKey, 'base64');
+  let keyOffset = 0;
+  const typeLen = buffer.readUInt32BE(keyOffset);
+  keyOffset += 4;
+  keyOffset += typeLen;
+
+  const curveLen = buffer.readUInt32BE(keyOffset);
+  keyOffset += 4;
+  keyOffset += curveLen;
+
+  const keyLen = buffer.readUInt32BE(keyOffset);
+  keyOffset += 5; // 4+1 to remove the prefix
+  return buffer.subarray(keyOffset, keyOffset + keyLen - 1);
+}

package/src/utils/options/fees.ts

@@ -0,0 +1,234 @@
+import { type AccountWallet, type FeePaymentMethod, type PXE, type SendMethodOptions } from '@aztec/aztec.js';
+import { AztecAddress, Fr, Gas, GasFees, GasSettings } from '@aztec/circuits.js';
+import { type LogFn } from '@aztec/foundation/log';
+
+import { Option } from 'commander';
+
+import { type WalletDB } from '../../storage/wallet_db.js';
+import { aliasedAddressParser } from './options.js';
+
+export type CliFeeArgs = {
+  estimateGasOnly: boolean;
+  gasLimits?: string;
+  payment?: string;
+  maxFeesPerGas?: string;
+  maxPriorityFeesPerGas?: string;
+  estimateGas?: boolean;
+};
+
+export interface IFeeOpts {
+  estimateOnly: boolean;
+  gasSettings: GasSettings;
+  toSendOpts(sender: AccountWallet): Promise<SendMethodOptions>;
+}
+
+export function printGasEstimates(
+  feeOpts: IFeeOpts,
+  gasEstimates: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>,
+  log: LogFn,
+) {
+  log(`Estimated gas usage:    ${formatGasEstimate(gasEstimates)}`);
+  log(`Maximum total tx fee:   ${getEstimatedCost(gasEstimates, feeOpts.gasSettings.maxFeesPerGas)}`);
+}
+
+function formatGasEstimate(estimate: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>) {
+  return `da=${estimate.gasLimits.daGas},l2=${estimate.gasLimits.l2Gas},teardownDA=${estimate.teardownGasLimits.daGas},teardownL2=${estimate.teardownGasLimits.l2Gas}`;
+}
+
+function getEstimatedCost(estimate: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>, maxFeesPerGas: GasFees) {
+  return GasSettings.default({ ...estimate, maxFeesPerGas })
+    .getFeeLimit()
+    .toBigInt();
+}
+
+export class FeeOpts implements IFeeOpts {
+  constructor(
+    public estimateOnly: boolean,
+    public gasSettings: GasSettings,
+    private paymentMethodFactory: (sender: AccountWallet) => Promise<FeePaymentMethod>,
+    private estimateGas: boolean,
+  ) {}
+
+  async toSendOpts(sender: AccountWallet): Promise<SendMethodOptions> {
+    return {
+      fee: {
+        estimateGas: this.estimateGas,
+        gasSettings: this.gasSettings,
+        paymentMethod: await this.paymentMethodFactory(sender),
+      },
+    };
+  }
+
+  static paymentMethodOption() {
+    return new Option(
+      '--payment <method=name,asset=address,fpc=address,claimSecret=string,claimAmount=string,feeRecipient=string>',
+      'Fee payment method and arguments. Valid methods are: none, fee_juice, fpc-public, fpc-private.',
+    );
+  }
+
+  static getOptions() {
+    return [
+      new Option('--gas-limits <da=100,l2=100,teardownDA=10,teardownL2=10>', 'Gas limits for the tx.'),
+      FeeOpts.paymentMethodOption(),
+      new Option('--max-fees-per-gas <da=100,l2=100>', 'Maximum fees per gas unit for DA and L2 computation.'),
+      new Option(
+        '--max-priority-fees-per-gas <da=0,l2=0>',
+        'Maximum priority fees per gas unit for DA and L2 computation.',
+      ),
+      new Option('--no-estimate-gas', 'Whether to automatically estimate gas limits for the tx.'),
+      new Option('--estimate-gas-only', 'Only report gas estimation for the tx, do not send it.'),
+    ];
+  }
+
+  static async fromCli(args: CliFeeArgs, pxe: PXE, log: LogFn, db?: WalletDB) {
+    const estimateOnly = args.estimateGasOnly;
+    const gasLimits = args.gasLimits ? parseGasLimits(args.gasLimits) : {};
+    const maxFeesPerGas = args.maxFeesPerGas ? parseGasFees(args.maxFeesPerGas) : await pxe.getCurrentBaseFees();
+    const maxPriorityFeesPerGas = args.maxPriorityFeesPerGas ? parseGasFees(args.maxPriorityFeesPerGas) : undefined;
+    const gasSettings = GasSettings.default({
+      ...gasLimits,
+      maxFeesPerGas,
+      maxPriorityFeesPerGas,
+    });
+
+    if (!args.gasLimits && !args.payment) {
+      return new NoFeeOpts(estimateOnly, gasSettings);
+    }
+
+    const defaultPaymentMethod = async () => {
+      const { NoFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+      return new NoFeePaymentMethod();
+    };
+
+    return new FeeOpts(
+      estimateOnly,
+      gasSettings,
+      args.payment ? parsePaymentMethod(args.payment, log, db) : defaultPaymentMethod,
+      !!args.estimateGas,
+    );
+  }
+}
+
+class NoFeeOpts implements IFeeOpts {
+  constructor(public estimateOnly: boolean, public gasSettings: GasSettings) {}
+
+  toSendOpts(): Promise<SendMethodOptions> {
+    return Promise.resolve({});
+  }
+}
+
+export function parsePaymentMethod(
+  payment: string,
+  log: LogFn,
+  db?: WalletDB,
+): (sender: AccountWallet) => Promise<FeePaymentMethod> {
+  const parsed = payment.split(',').reduce((acc, item) => {
+    const [dimension, value] = item.split('=');
+    acc[dimension] = value ?? 1;
+    return acc;
+  }, {} as Record<string, string>);
+
+  const getFpcOpts = (parsed: Record<string, string>, db?: WalletDB) => {
+    if (!parsed.fpc) {
+      throw new Error('Missing "fpc" in payment option');
+    }
+    if (!parsed.asset) {
+      throw new Error('Missing "asset" in payment option');
+    }
+
+    const fpc = aliasedAddressParser('contracts', parsed.fpc, db);
+
+    return [AztecAddress.fromString(parsed.asset), fpc];
+  };
+
+  return async (sender: AccountWallet) => {
+    switch (parsed.method) {
+      case 'none': {
+        log('Using no fee payment');
+        const { NoFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+        return new NoFeePaymentMethod();
+      }
+      case 'native': {
+        if (parsed.claim || (parsed.claimSecret && parsed.claimAmount && parsed.messageLeafIndex)) {
+          let claimAmount, claimSecret, messageLeafIndex;
+          if (parsed.claim && db) {
+            ({
+              amount: claimAmount,
+              secret: claimSecret,
+              leafIndex: messageLeafIndex,
+            } = await db.popBridgedFeeJuice(sender.getAddress(), log));
+          } else {
+            ({ claimAmount, claimSecret, messageLeafIndex } = parsed);
+          }
+          log(`Using Fee Juice for fee payments with claim for ${claimAmount} tokens`);
+          const { FeeJuicePaymentMethodWithClaim } = await import('@aztec/aztec.js/fee');
+          return new FeeJuicePaymentMethodWithClaim(sender.getAddress(), {
+            claimAmount: (typeof claimAmount === 'string'
+              ? Fr.fromHexString(claimAmount)
+              : new Fr(claimAmount)
+            ).toBigInt(),
+            claimSecret: Fr.fromHexString(claimSecret),
+            messageLeafIndex: BigInt(messageLeafIndex),
+          });
+        } else {
+          log(`Using Fee Juice for fee payment`);
+          const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
+          return new FeeJuicePaymentMethod(sender.getAddress());
+        }
+      }
+      case 'fpc-public': {
+        const [asset, fpc] = getFpcOpts(parsed, db);
+        log(`Using public fee payment with asset ${asset} via paymaster ${fpc}`);
+        const { PublicFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+        return new PublicFeePaymentMethod(fpc, sender);
+      }
+      case 'fpc-private': {
+        const [asset, fpc] = getFpcOpts(parsed, db);
+        log(`Using private fee payment with asset ${asset} via paymaster ${fpc}`);
+        const { PrivateFeePaymentMethod } = await import('@aztec/aztec.js/fee');
+        return new PrivateFeePaymentMethod(fpc, sender);
+      }
+      case undefined:
+        throw new Error('Missing "method" in payment option');
+      default:
+        throw new Error(`Invalid fee payment method: ${payment}`);
+    }
+  };
+}
+
+function parseGasLimits(gasLimits: string): { gasLimits: Gas; teardownGasLimits: Gas } {
+  const parsed = gasLimits.split(',').reduce((acc, limit) => {
+    const [dimension, value] = limit.split('=');
+    acc[dimension] = parseInt(value, 10);
+    return acc;
+  }, {} as Record<string, number>);
+
+  const expected = ['da', 'l2', 'teardownDA', 'teardownL2'];
+  for (const dimension of expected) {
+    if (!(dimension in parsed)) {
+      throw new Error(`Missing gas limit for ${dimension}`);
+    }
+  }
+
+  return {
+    gasLimits: new Gas(parsed.da, parsed.l2),
+    teardownGasLimits: new Gas(parsed.teardownDA, parsed.teardownL2),
+  };
+}
+
+export function parseGasFees(gasFees: string): GasFees {
+  const parsed = gasFees.split(',').reduce((acc, fee) => {
+    const [dimension, value] = fee.split('=');
+    acc[dimension] = parseInt(value, 10);
+    return acc;
+  }, {} as Record<string, number>);
+
+  const expected = ['da', 'l2'];
+  for (const dimension of expected) {
+    if (!(dimension in parsed)) {
+      throw new Error(`Missing gas fee for ${dimension}`);
+    }
+  }
+
+  return new GasFees(parsed.da, parsed.l2);
+}

package/src/utils/options/index.ts

@@ -0,0 +1,2 @@
+export * from './fees.js';
+export * from './options.js';