@aztec/cli-wallet 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/utils/options/fees.ts

@@ -1,67 +1,31 @@
-import {
-  type AccountWallet,
-  type DeployAccountOptions,
-  FeeJuicePaymentMethod,
-  type FeePaymentMethod,
-  type PXE,
-  type SendMethodOptions,
-} from '@aztec/aztec.js';
-import { Fr } from '@aztec/foundation/fields';
+import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
+import type { FieldsOf } from '@aztec/foundation/types';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { Gas, GasFees, GasSettings, ManaUsageEstimate } from '@aztec/stdlib/gas';
+import type { FeeOptions } from '@aztec/wallet-sdk/base-wallet';
 
 import { Option } from 'commander';
 
 import type { WalletDB } from '../../storage/wallet_db.js';
-import { createOrRetrieveAccount } from '../accounts.js';
+import { MIN_FEE_PADDING } from '../constants.js';
 import { aliasedAddressParser } from './options.js';
 
-export type CliFeeArgs = {
+export type RawCliFeeArgs = {
   estimateGasOnly: boolean;
   gasLimits?: string;
   payment?: string;
   maxFeesPerGas?: string;
   maxPriorityFeesPerGas?: string;
-  estimateGas?: boolean;
 };
 
-export interface IFeeOpts {
-  estimateOnly: boolean;
-  gasSettings: GasSettings;
-  toSendOpts(sender: AccountWallet): Promise<SendMethodOptions>;
-  toDeployAccountOpts(sender: AccountWallet): Promise<DeployAccountOptions>;
-}
-
-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();
-}
-
-async function parseGasSettings(args: CliFeeArgs, pxe: PXE) {
-  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;
-  return GasSettings.default({
-    ...gasLimits,
-    maxFeesPerGas,
-    maxPriorityFeesPerGas,
-  });
-}
+export type ParsedFeeOptions = {
+  paymentMethod?: FeePaymentMethod;
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+};
 
 type OptionParams = {
   [key: string]: { type: string; description?: string; default?: string };
@@ -77,21 +41,23 @@ function printOptionParams(params: OptionParams) {
       params[name].default ? `Default: ${params[name].default}` : '',
     ].join(' '),
   );
-  return descriptionList.length ? `\n   Parameters:\n${descriptionList.join('\n')}` : '';
+  return descriptionList.length
+    ? `\n   Parameters:\n${descriptionList.join('\n')}\nFormat: --payment ${Object.keys(params)
+        .slice(0, 3)
+        .map(name => `${name}=${params[name].type}`)} ${Object.keys(params).length > 3 ? '...' : ''}`
+    : '';
 }
 
-function getFeePaymentMethodParams(allowCustomFeePayer: boolean): OptionParams {
-  const feePayer = allowCustomFeePayer ? { type: 'address', description: 'The account paying the fee.' } : undefined;
+function getFeePaymentMethodParams(): OptionParams {
   return {
     method: {
       type: 'name',
-      description: 'Valid values: "fee_juice", "fpc-public", "fpc-private".',
+      description: 'Valid values: "fee_juice", "fpc-public", "fpc-private", "fpc-sponsored"',
       default: 'fee_juice',
     },
-    ...(feePayer ? { feePayer } : {}),
     asset: {
       type: 'address',
-      description: 'The asset used for fee payment. Not required for the "fee_juice" method.',
+      description: 'The asset used for fee payment. Required for "fpc-public" and "fpc-private".',
     },
     fpc: {
       type: 'address',
@@ -113,167 +79,68 @@ function getFeePaymentMethodParams(allowCustomFeePayer: boolean): OptionParams {
       type: 'bigint',
       description: 'The index of the claim in the l1toL2Message tree.',
     },
-    feeRecipient: {
-      type: 'string',
-      description: 'Recipient of the fee.',
-    },
   };
 }
 
-function getPaymentMethodOption(allowCustomFeePayer: boolean) {
-  const params = getFeePaymentMethodParams(allowCustomFeePayer);
-  const paramList = Object.keys(params).map(name => `${name}=${params[name].type}`);
-  return new Option(
-    `--payment <${paramList.join(',')}>`,
-    `Fee payment method and arguments.${printOptionParams(params)}`,
-  );
+export function getPaymentMethodOption() {
+  const params = getFeePaymentMethodParams();
+  return new Option(`--payment <options>`, `Fee payment method and arguments.${printOptionParams(params)}`);
 }
 
-function getFeeOptions(allowCustomFeePayer: boolean) {
+function getFeeOptions() {
   return [
-    getPaymentMethodOption(allowCustomFeePayer),
+    getPaymentMethodOption(),
     new Option('--gas-limits <da=100,l2=100,teardownDA=10,teardownL2=10>', 'Gas limits for the tx.'),
     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.'),
   ];
 }
 
-export class FeeOpts implements IFeeOpts {
-  constructor(
-    public estimateOnly: boolean,
-    public gasSettings: GasSettings,
-    private paymentMethodFactory: (sender: AccountWallet) => Promise<FeePaymentMethod>,
-    private getDeployWallet: (
-      sender: AccountWallet,
-      paymentMethod: FeePaymentMethod,
-    ) => Promise<AccountWallet | undefined>,
-    private estimateGas: boolean,
-  ) {}
-
-  async toSendOpts(sender: AccountWallet): Promise<SendMethodOptions> {
-    return {
-      fee: {
-        estimateGas: this.estimateGas,
-        gasSettings: this.gasSettings,
-        paymentMethod: await this.paymentMethodFactory(sender),
-      },
-    };
-  }
-
-  async toDeployAccountOpts(sender: AccountWallet): Promise<DeployAccountOptions> {
-    const paymentMethod = await this.paymentMethodFactory(sender);
-    const deployWallet = await this.getDeployWallet(sender, paymentMethod);
-    return {
-      deployWallet,
-      fee: {
-        estimateGas: this.estimateGas,
-        gasSettings: this.gasSettings,
-        paymentMethod,
-      },
-    };
-  }
-
-  static paymentMethodOption() {
-    return getPaymentMethodOption(false);
-  }
-
-  static getOptions() {
-    return getFeeOptions(false);
-  }
-
-  static async fromCli(args: CliFeeArgs, pxe: PXE, log: LogFn, db?: WalletDB) {
-    const estimateOnly = args.estimateGasOnly;
-    const gasSettings = await parseGasSettings(args, pxe);
-
-    const defaultPaymentMethod = async (sender: AccountWallet) => {
-      const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
-      return new FeeJuicePaymentMethod(sender.getAddress());
-    };
-
-    const getDeployWallet = () => {
-      // Returns undefined. The sender's wallet will be used by default.
-      return Promise.resolve(undefined);
-    };
-
-    return new FeeOpts(
-      estimateOnly,
-      gasSettings,
-      args.payment ? parsePaymentMethod(args.payment, false, log, db) : defaultPaymentMethod,
-      getDeployWallet,
-      !!args.estimateGas,
-    );
-  }
-}
-
-export class FeeOptsWithFeePayer extends FeeOpts {
-  static override paymentMethodOption() {
-    return getPaymentMethodOption(true);
-  }
-
-  static override getOptions() {
-    return getFeeOptions(true);
-  }
-
-  static override async fromCli(args: CliFeeArgs, pxe: PXE, log: LogFn, db?: WalletDB) {
-    const estimateOnly = args.estimateGasOnly;
-    const gasSettings = await parseGasSettings(args, pxe);
-
-    const defaultPaymentMethod = async (sender: AccountWallet) => {
-      const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
-      return new FeeJuicePaymentMethod(sender.getAddress());
-    };
-
-    const getDeployWallet = async (sender: AccountWallet, paymentMethod: FeePaymentMethod) => {
-      if (paymentMethod instanceof FeeJuicePaymentMethod) {
-        const feePayer = await paymentMethod.getFeePayer();
-        if (!sender.getAddress().equals(feePayer)) {
-          return (await createOrRetrieveAccount(pxe, feePayer, db)).getWallet();
-        }
-      }
-      return undefined;
-    };
-
-    return new FeeOptsWithFeePayer(
-      estimateOnly,
-      gasSettings,
-      args.payment ? parsePaymentMethod(args.payment, true, log, db) : defaultPaymentMethod,
-      getDeployWallet,
-      !!args.estimateGas,
-    );
-  }
+function parseGasSettings(args: RawCliFeeArgs): Partial<FieldsOf<GasSettings>> {
+  const gasLimits = args.gasLimits ? parseGasLimits(args.gasLimits) : {};
+  const maxFeesPerGas = args.maxFeesPerGas ? parseGasFees(args.maxFeesPerGas) : undefined;
+  const maxPriorityFeesPerGas = args.maxPriorityFeesPerGas ? parseGasFees(args.maxPriorityFeesPerGas) : undefined;
+  return {
+    ...gasLimits,
+    maxFeesPerGas,
+    maxPriorityFeesPerGas,
+  };
 }
 
 export function parsePaymentMethod(
   payment: string,
-  allowCustomFeePayer: boolean,
   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>);
+  estimateOnly?: boolean,
+): (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => Promise<FeePaymentMethod | undefined> {
+  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) => {
+  const getFpc = () => {
     if (!parsed.fpc) {
       throw new Error('Missing "fpc" in payment option');
     }
+    return aliasedAddressParser('contracts', parsed.fpc, db);
+  };
+
+  const getAsset = () => {
     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 AztecAddress.fromString(parsed.asset);
   };
 
-  return async (sender: AccountWallet) => {
+  return async (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => {
     switch (parsed.method) {
       case 'fee_juice': {
         if (parsed.claim || (parsed.claimSecret && parsed.claimAmount && parsed.messageLeafIndex)) {
@@ -283,41 +150,50 @@ export function parsePaymentMethod(
               amount: claimAmount,
               secret: claimSecret,
               leafIndex: messageLeafIndex,
-            } = await db.popBridgedFeeJuice(sender.getAddress(), log));
+            } = estimateOnly ? await db.peekBridgedFeeJuice(from, log) : await db.popBridgedFeeJuice(from, 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, {
+          return new FeeJuicePaymentMethodWithClaim(from, {
             claimAmount: (typeof claimAmount === 'string'
-              ? Fr.fromHexString(claimAmount)
+              ? Fr.fromString(claimAmount)
               : new Fr(claimAmount)
             ).toBigInt(),
-            claimSecret: Fr.fromHexString(claimSecret),
+            claimSecret: typeof claimSecret === 'string' ? Fr.fromString(claimSecret) : claimSecret,
             messageLeafIndex: BigInt(messageLeafIndex),
           });
         } else {
-          log(`Using Fee Juice for fee payment`);
-          const { FeeJuicePaymentMethod } = await import('@aztec/aztec.js/fee');
-          const feePayer =
-            parsed.feePayer && allowCustomFeePayer
-              ? aliasedAddressParser('accounts', parsed.feePayer, db)
-              : sender.getAddress();
-          return new FeeJuicePaymentMethod(feePayer);
+          log(`Using Fee Juice for fee payment with the balance of account ${from}`);
+          return;
         }
       }
       case 'fpc-public': {
-        const [asset, fpc] = getFpcOpts(parsed, db);
+        const fpc = getFpc();
+        const asset = getAsset();
+        log(
+          `WARNING: fpc-public is deprecated and will not work on mainnet alpha. Use fee_juice or fpc-sponsored instead.`,
+        );
         log(`Using public fee payment with asset ${asset} via paymaster ${fpc}`);
         const { PublicFeePaymentMethod } = await import('@aztec/aztec.js/fee');
-        return new PublicFeePaymentMethod(fpc, sender);
+        return new PublicFeePaymentMethod(fpc, from, wallet, gasSettings);
       }
       case 'fpc-private': {
-        const [asset, fpc] = getFpcOpts(parsed, db);
+        const fpc = getFpc();
+        const asset = getAsset();
+        log(
+          `WARNING: fpc-private is deprecated and will not work on mainnet alpha. Use fee_juice or fpc-sponsored instead.`,
+        );
         log(`Using private fee payment with asset ${asset} via paymaster ${fpc}`);
         const { PrivateFeePaymentMethod } = await import('@aztec/aztec.js/fee');
-        return new PrivateFeePaymentMethod(fpc, sender);
+        return new PrivateFeePaymentMethod(fpc, from, wallet, gasSettings);
+      }
+      case 'fpc-sponsored': {
+        const sponsor = getFpc();
+        log(`Using sponsored fee payment with sponsor ${sponsor}`);
+        const { SponsoredFeePaymentMethod } = await import('@aztec/aztec.js/fee/testing');
+        return new SponsoredFeePaymentMethod(sponsor);
       }
       case undefined:
         throw new Error('Missing "method" in payment option');
@@ -328,11 +204,14 @@ export function parsePaymentMethod(
 }
 
 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 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) {
@@ -348,11 +227,14 @@ function parseGasLimits(gasLimits: string): { gasLimits: Gas; teardownGasLimits:
 }
 
 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 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) {
@@ -363,3 +245,80 @@ export function parseGasFees(gasFees: string): GasFees {
 
   return new GasFees(parsed.da, parsed.l2);
 }
+export class CLIFeeArgs {
+  constructor(
+    public estimateOnly: boolean,
+    private paymentMethod: (
+      wallet: Wallet,
+      feePayer: AztecAddress,
+      gasSettings: GasSettings,
+    ) => Promise<FeePaymentMethod | undefined>,
+    private gasSettings: Partial<FieldsOf<GasSettings>>,
+  ) {}
+
+  async toUserFeeOptions(node: AztecNode, wallet: Wallet, from: AztecAddress): Promise<ParsedFeeOptions> {
+    const minFees = await this.getMinFees(node);
+    const maxFeesPerGas = minFees.mul(1 + MIN_FEE_PADDING);
+    const gasSettings = GasSettings.fallback({ ...this.gasSettings, maxFeesPerGas });
+    const paymentMethod = await this.paymentMethod(wallet, from, gasSettings);
+    return {
+      paymentMethod,
+      gasSettings,
+    };
+  }
+
+  /**
+   * Returns the worst-case min fee across predicted future slots.
+   * Falls back to getCurrentMinFees if the node doesn't support getPredictedMinFees.
+   */
+  private async getMinFees(node: AztecNode): Promise<GasFees> {
+    try {
+      const predicted = await node.getPredictedMinFees(ManaUsageEstimate.Limit);
+      if (predicted.length === 0) {
+        return node.getCurrentMinFees();
+      }
+      return predicted.reduce((worst, fees) => (fees.feePerL2Gas > worst.feePerL2Gas ? fees : worst));
+    } catch (err: any) {
+      // Fallback for old nodes that don't support getPredictedMinFees.
+      // Only fall back on method-not-found errors (JSON-RPC code -32601); rethrow others.
+      if (err?.cause?.code === -32601 || err?.message?.includes('Method not found')) {
+        return node.getCurrentMinFees();
+      }
+      throw err;
+    }
+  }
+
+  static parse(args: RawCliFeeArgs, log: LogFn, db?: WalletDB): CLIFeeArgs {
+    const estimateOnly = !!args.estimateGasOnly;
+    return new CLIFeeArgs(
+      estimateOnly,
+      parsePaymentMethod(args.payment ?? 'method=fee_juice', log, db, estimateOnly),
+      parseGasSettings(args),
+    );
+  }
+
+  static getOptions() {
+    return getFeeOptions();
+  }
+}
+
+// Printing
+
+export function printGasEstimates(
+  feeOpts: FeeOptions,
+  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.fallback({ ...estimate, maxFeesPerGas })
+    .getFeeLimit()
+    .toBigInt();
+}

package/src/utils/options/options.ts

@@ -1,3 +1,4 @@
+import { TxHash } from '@aztec/aztec.js/tx';
 import { parseAztecAddress, parseSecretKey, parseTxHash } from '@aztec/cli/utils';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -6,7 +7,7 @@ import { Option } from 'commander';
 import { readdir, stat } from 'fs/promises';
 
 import type { AliasType, WalletDB } from '../../storage/wallet_db.js';
-import { AccountTypes } from '../accounts.js';
+import { AccountTypes } from '../constants.js';
 
 const TARGET_DIR = 'target';
 
@@ -29,24 +30,28 @@ export function integerArgParser(
   return parsed;
 }
 
-export function aliasedTxHashParser(txHash: string, db?: WalletDB) {
+export function aliasedTxHashParser(txHash: string, db?: WalletDB): TxHash {
   try {
     return parseTxHash(txHash);
-  } catch (err) {
+  } catch {
     const prefixed = txHash.includes(':') ? txHash : `transactions:${txHash}`;
     const rawTxHash = db ? db.tryRetrieveAlias(prefixed) : txHash;
     return parseTxHash(rawTxHash);
   }
 }
 
-export function aliasedAuthWitParser(witness: string, db?: WalletDB) {
-  try {
-    return AuthWitness.fromString(witness);
-  } catch (err) {
-    const prefixed = witness.includes(':') ? witness : `authwits:${witness}`;
-    const rawAuthWitness = db ? db.tryRetrieveAlias(prefixed) : witness;
-    return AuthWitness.fromString(rawAuthWitness);
-  }
+export function aliasedAuthWitParser(witnesses: string, db?: WalletDB) {
+  const parsedWitnesses = witnesses.split(',').map(witness => {
+    try {
+      return AuthWitness.fromString(witness);
+    } catch {
+      const prefixed = witness.includes(':') ? witness : `authwits:${witness}`;
+      const rawAuthWitness = db ? db.tryRetrieveAlias(prefixed) : witness;
+      return AuthWitness.fromString(rawAuthWitness);
+    }
+  });
+
+  return parsedWitnesses;
 }
 
 export function aliasedAddressParser(defaultPrefix: AliasType, address: string, db?: WalletDB) {
@@ -79,6 +84,12 @@ export function createAccountOption(description: string, hide: boolean, db?: Wal
     .argParser(address => aliasedAddressParser('accounts', address, db));
 }
 
+export function createAuthwitnessOption(description: string, hide: boolean, db?: WalletDB) {
+  return new Option('-aw, --auth-witness <string,...>', description)
+    .hideHelp(hide)
+    .argParser(witness => aliasedAuthWitParser(witness, db));
+}
+
 export function createTypeOption(mandatory: boolean) {
   return new Option('-t, --type <string>', 'Type of account to create')
     .choices(AccountTypes)
@@ -103,6 +114,20 @@ export function createContractAddressOption(db?: WalletDB) {
     .makeOptionMandatory(true);
 }
 
+export function createDebugExecutionStepsDirOption() {
+  return new Option(
+    '--debug-execution-steps-dir <address>',
+    'Directory to write execution step artifacts for bb profiling/debugging.',
+  ).makeOptionMandatory(false);
+}
+
+export function createVerboseOption() {
+  return new Option(
+    '-v, --verbose',
+    'Provide timings on all executed operations (synching, simulating, proving)',
+  ).default(false);
+}
+
 export function artifactPathParser(filePath: string, db?: WalletDB) {
   if (filePath.includes('@')) {
     const [pkg, contractName] = filePath.split('@');
@@ -140,18 +165,11 @@ export function createArtifactOption(db?: WalletDB) {
     .makeOptionMandatory(false);
 }
 
-export function createProfileOption() {
-  return new Option(
-    '-p, --profile',
-    'Run the real prover and get the gate count for each function in the transaction.',
-  ).default(false);
-}
-
 async function contractArtifactFromWorkspace(pkg?: string, contractName?: string) {
   const cwd = process.cwd();
   try {
     await stat(`${cwd}/Nargo.toml`);
-  } catch (e) {
+  } catch {
     throw new Error(
       'Invalid contract artifact argument provided. To use this option, command should be called from a nargo workspace',
     );
@@ -173,3 +191,7 @@ async function contractArtifactFromWorkspace(pkg?: string, contractName?: string
   }
   return `${cwd}/${TARGET_DIR}/${bestMatch[0]}`;
 }
+
+export function cleanupAuthWitnesses(authWitnesses: AuthWitness[] | undefined): AuthWitness[] {
+  return authWitnesses?.filter(w => w !== undefined) ?? [];
+}