@aztec/cli-wallet 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

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 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 '../wallet.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 };
@@ -84,15 +48,13 @@ function printOptionParams(params: OptionParams) {
     : '';
 }
 
-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", "fpc-sponsored"',
       default: 'fee_juice',
     },
-    ...(feePayer ? { feePayer } : {}),
     asset: {
       type: 'address',
       description: 'The asset used for fee payment. Required for "fpc-public" and "fpc-private".',
@@ -117,144 +79,43 @@ 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);
+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('--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 {
-      from: sender.getAddress(),
-      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> {
+): (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => Promise<FeePaymentMethod | undefined> {
   const parsed = payment.split(',').reduce(
     (acc, item) => {
       const [dimension, value] = item.split('=');
@@ -278,7 +139,7 @@ export function parsePaymentMethod(
     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)) {
@@ -288,13 +149,13 @@ export function parsePaymentMethod(
               amount: claimAmount,
               secret: claimSecret,
               leafIndex: messageLeafIndex,
-            } = await db.popBridgedFeeJuice(sender.getAddress(), 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)
               : new Fr(claimAmount)
@@ -303,13 +164,8 @@ export function parsePaymentMethod(
             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': {
@@ -317,14 +173,14 @@ export function parsePaymentMethod(
         const asset = getAsset();
         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 fpc = getFpc();
         const asset = getAsset();
         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();
@@ -382,3 +238,57 @@ 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 maxFeesPerGas = (await node.getCurrentMinFees()).mul(1 + MIN_FEE_PADDING);
+    const gasSettings = GasSettings.default({ ...this.gasSettings, maxFeesPerGas });
+    const paymentMethod = await this.paymentMethod(wallet, from, gasSettings);
+    return {
+      paymentMethod,
+      gasSettings,
+    };
+  }
+
+  static parse(args: RawCliFeeArgs, log: LogFn, db?: WalletDB): CLIFeeArgs {
+    return new CLIFeeArgs(
+      !!args.estimateGasOnly,
+      parsePaymentMethod(args.payment ?? 'method=fee_juice', log, db),
+      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.default({ ...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 '../wallet.js';
 
 const TARGET_DIR = 'target';
 
@@ -29,7 +30,7 @@ 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 {

package/src/utils/wallet.ts

@@ -0,0 +1,266 @@
+import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { getIdentities } from '@aztec/accounts/utils';
+import { type Account, type AccountContract, SignerlessAccount } from '@aztec/aztec.js/account';
+import {
+  type InteractionFeeOptions,
+  getContractInstanceFromInstantiationParams,
+  getGasLimits,
+} from '@aztec/aztec.js/contracts';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { AccountManager, type Aliased, type SimulateOptions } from '@aztec/aztec.js/wallet';
+import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LogFn } from '@aztec/foundation/log';
+import type { PXEConfig } from '@aztec/pxe/config';
+import type { PXE } from '@aztec/pxe/server';
+import { createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { NoteDao } from '@aztec/stdlib/note';
+import type { NotesFilter } from '@aztec/stdlib/note';
+import type { TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet } from '@aztec/wallet-sdk/base-wallet';
+
+import type { WalletDB } from '../storage/wallet_db.js';
+import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
+import { printGasEstimates } from './options/fees.js';
+
+export const AccountTypes = ['schnorr', 'ecdsasecp256r1', 'ecdsasecp256r1ssh', 'ecdsasecp256k1'] as const;
+export type AccountType = (typeof AccountTypes)[number];
+
+export const MIN_FEE_PADDING = 0.5;
+
+export class CLIWallet extends BaseWallet {
+  private accountCache = new Map<string, Account>();
+
+  constructor(
+    pxe: PXE,
+    node: AztecNode,
+    private userLog: LogFn,
+    private db?: WalletDB,
+  ) {
+    super(pxe, node);
+    this.cancellableTransactions = true;
+  }
+
+  static async create(
+    node: AztecNode,
+    log: LogFn,
+    db?: WalletDB,
+    overridePXEConfig?: Partial<PXEConfig>,
+  ): Promise<CLIWallet> {
+    const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
+    const pxe = await createPXE(node, pxeConfig);
+    return new CLIWallet(pxe, node, log, db);
+  }
+
+  override async getAccounts(): Promise<Aliased<AztecAddress>[]> {
+    const accounts = (await this.db?.listAliases('accounts')) ?? [];
+    return Promise.resolve(accounts.map(({ key, value }) => ({ alias: value, item: AztecAddress.fromString(key) })));
+  }
+
+  private async createCancellationTxExecutionRequest(
+    from: AztecAddress,
+    txNonce: Fr,
+    increasedFee: InteractionFeeOptions,
+  ) {
+    const executionPayload = ExecutionPayload.empty();
+    const feeOptions = await this.completeFeeOptions(from, executionPayload.feePayer, increasedFee.gasSettings);
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const fromAccount = await this.getAccountFromAddress(from);
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce,
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    return await fromAccount.createTxExecutionRequest(
+      feeExecutionPayload ?? executionPayload,
+      feeOptions.gasSettings,
+      executionOptions,
+    );
+  }
+
+  async proveCancellationTx(
+    from: AztecAddress,
+    txNonce: Fr,
+    increasedFee: InteractionFeeOptions,
+  ): Promise<TxProvingResult> {
+    const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
+    return await this.pxe.proveTx(cancellationTxRequest);
+  }
+
+  override async getAccountFromAddress(address: AztecAddress) {
+    let account: Account | undefined;
+    if (address.equals(AztecAddress.ZERO)) {
+      const chainInfo = await this.getChainInfo();
+      account = new SignerlessAccount(chainInfo);
+    } else if (this.accountCache.has(address.toString())) {
+      return this.accountCache.get(address.toString())!;
+    } else {
+      const accountManager = await this.createOrRetrieveAccount(address);
+      account = await accountManager.getAccount();
+    }
+
+    if (!account) {
+      throw new Error(`Account not found in wallet for address: ${address}`);
+    }
+    return account;
+  }
+
+  private async createAccount(secret: Fr, salt: Fr, contract: AccountContract): Promise<AccountManager> {
+    const accountManager = await AccountManager.create(this, secret, contract, salt);
+
+    const instance = accountManager.getInstance();
+    const artifact = await contract.getContractArtifact();
+
+    await this.registerContract(instance, artifact, secret);
+    this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
+    return accountManager;
+  }
+
+  async createOrRetrieveAccount(
+    address?: AztecAddress,
+    secretKey?: Fr,
+    type: AccountType = 'schnorr',
+    salt?: Fr,
+    publicKey?: string,
+  ): Promise<AccountManager> {
+    let account;
+
+    salt ??= Fr.ZERO;
+
+    if (this.db && address) {
+      ({ type, secretKey, salt } = await this.db.retrieveAccount(address));
+    }
+
+    if (!secretKey) {
+      throw new Error('Cannot retrieve/create wallet without secret key');
+    }
+
+    switch (type) {
+      case 'schnorr': {
+        account = await this.createAccount(secretKey, salt, new SchnorrAccountContract(deriveSigningKey(secretKey)));
+        break;
+      }
+      case 'ecdsasecp256r1': {
+        account = await this.createAccount(
+          secretKey,
+          salt,
+          new EcdsaRAccountContract(deriveSigningKey(secretKey).toBuffer()),
+        );
+        break;
+      }
+      case 'ecdsasecp256r1ssh': {
+        let publicSigningKey;
+        if (this.db && address) {
+          publicSigningKey = await this.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');
+        }
+        account = await this.createAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported account type: ${type}`);
+      }
+    }
+
+    return account;
+  }
+
+  private async getFakeAccountDataFor(address: AztecAddress) {
+    const chainInfo = await this.getChainInfo();
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const { contractInstance } = await this.pxe.getContractMetadata(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const stubAccount = createStubAccount(originalAddress, chainInfo);
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+
+  override async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
+    let simulationResults;
+    const feeOptions = opts.fee?.estimateGas
+      ? await this.completeFeeOptionsForEstimation(opts.from, executionPayload.feePayer, opts.fee?.gasSettings)
+      : await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce: Fr.random(),
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
+      : executionPayload;
+
+    // Kernelless simulations using the multicall entrypoints are not currently supported,
+    // since we only override proper account contracts.
+    // TODO: allow disabling kernels even when no overrides are necessary
+    if (opts.from.equals(AztecAddress.ZERO)) {
+      const fromAccount = await this.getAccountFromAddress(opts.from);
+      const txRequest = await fromAccount.createTxExecutionRequest(
+        finalExecutionPayload,
+        feeOptions.gasSettings,
+        executionOptions,
+      );
+      simulationResults = await this.pxe.simulateTx(
+        txRequest,
+        true /* simulatePublic */,
+        opts?.skipTxValidation,
+        opts?.skipFeeEnforcement ?? true,
+      );
+    } else {
+      const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(opts.from);
+      const txRequest = await fromAccount.createTxExecutionRequest(
+        finalExecutionPayload,
+        feeOptions.gasSettings,
+        executionOptions,
+      );
+      const contractOverrides = {
+        [opts.from.toString()]: { instance, artifact },
+      };
+      simulationResults = await this.pxe.simulateTx(txRequest, true /* simulatePublic */, true, true, {
+        contracts: contractOverrides,
+      });
+    }
+
+    if (opts.fee?.estimateGas) {
+      const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
+      printGasEstimates(feeOptions, limits, this.userLog);
+    }
+    return simulationResults;
+  }
+
+  // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+  // this is just a CLI wallet.
+  getContracts(): Promise<AztecAddress[]> {
+    return this.pxe.getContracts();
+  }
+
+  // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
+  // this is just a CLI wallet.
+  getNotes(filter: NotesFilter): Promise<NoteDao[]> {
+    return this.pxe.debug.getNotes(filter);
+  }
+}

package/dest/cmds/cancel_tx.d.ts

@@ -1,11 +0,0 @@
-import { type AccountWalletWithSecretKey, type FeePaymentMethod, type TxHash } from '@aztec/aztec.js';
-import { Fr } from '@aztec/foundation/fields';
-import type { LogFn } from '@aztec/foundation/log';
-import { GasFees, GasSettings } from '@aztec/stdlib/gas';
-export declare function cancelTx(wallet: AccountWalletWithSecretKey, { txHash, gasSettings: prevTxGasSettings, txNonce, cancellable, }: {
-    txHash: TxHash;
-    gasSettings: GasSettings;
-    txNonce: Fr;
-    cancellable: boolean;
-}, paymentMethod: FeePaymentMethod, increasedFees: GasFees, maxFeesPerGas: GasFees | undefined, log: LogFn): Promise<void>;
-//# sourceMappingURL=cancel_tx.d.ts.map

package/dest/cmds/cancel_tx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cancel_tx.d.ts","sourceRoot":"","sources":["../../src/cmds/cancel_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,KAAK,gBAAgB,EAAU,KAAK,MAAM,EAAY,MAAM,iBAAiB,CAAC;AAGxH,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIzD,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,0BAA0B,EAClC,EACE,MAAM,EACN,WAAW,EAAE,iBAAiB,EAC9B,OAAO,EACP,WAAW,GACZ,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,EAClF,aAAa,EAAE,gBAAgB,EAC/B,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,OAAO,GAAG,SAAS,EAClC,GAAG,EAAE,KAAK,iBA6CX"}