@aztec/cli-wallet 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/utils/options/fees.ts

@@ -1,16 +1,17 @@
 import type { FeePaymentMethod } from '@aztec/aztec.js/fee';
 import type { AztecNode } from '@aztec/aztec.js/node';
-import type { FeeOptions, Wallet } from '@aztec/aztec.js/wallet';
-import { Fr } from '@aztec/foundation/fields';
+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 { BASE_FEE_PADDING } from '../wallet.js';
+import { MIN_FEE_PADDING } from '../constants.js';
 import { aliasedAddressParser } from './options.js';
 
 export type RawCliFeeArgs = {
@@ -114,6 +115,7 @@ export function parsePaymentMethod(
   payment: string,
   log: LogFn,
   db?: WalletDB,
+  estimateOnly?: boolean,
 ): (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => Promise<FeePaymentMethod | undefined> {
   const parsed = payment.split(',').reduce(
     (acc, item) => {
@@ -135,7 +137,7 @@ export function parsePaymentMethod(
     if (!parsed.asset) {
       throw new Error('Missing "asset" in payment option');
     }
-    return AztecAddress.fromString(parsed.asset);
+    return AztecAddress.fromStringUnsafe(parsed.asset);
   };
 
   return async (wallet: Wallet, from: AztecAddress, gasSettings: GasSettings) => {
@@ -148,7 +150,7 @@ export function parsePaymentMethod(
               amount: claimAmount,
               secret: claimSecret,
               leafIndex: messageLeafIndex,
-            } = await db.popBridgedFeeJuice(from, log));
+            } = estimateOnly ? await db.peekBridgedFeeJuice(from, log) : await db.popBridgedFeeJuice(from, log));
           } else {
             ({ claimAmount, claimSecret, messageLeafIndex } = parsed);
           }
@@ -156,10 +158,10 @@ export function parsePaymentMethod(
           const { FeeJuicePaymentMethodWithClaim } = await import('@aztec/aztec.js/fee');
           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 {
@@ -170,6 +172,9 @@ export function parsePaymentMethod(
       case 'fpc-public': {
         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, from, wallet, gasSettings);
@@ -177,6 +182,9 @@ export function parsePaymentMethod(
       case 'fpc-private': {
         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, from, wallet, gasSettings);
@@ -249,8 +257,11 @@ export class CLIFeeArgs {
   ) {}
 
   async toUserFeeOptions(node: AztecNode, wallet: Wallet, from: AztecAddress): Promise<ParsedFeeOptions> {
-    const maxFeesPerGas = (await node.getCurrentBaseFees()).mul(1 + BASE_FEE_PADDING);
-    const gasSettings = GasSettings.default({ ...this.gasSettings, maxFeesPerGas });
+    const minFees = await this.getMinFees(node);
+    const maxFeesPerGas = minFees.mul(1 + MIN_FEE_PADDING);
+    const { txsLimits } = await node.getNodeInfo();
+    const gasLimits = this.gasSettings.gasLimits ?? Gas.from(txsLimits.gas);
+    const gasSettings = GasSettings.fallback({ ...this.gasSettings, gasLimits, maxFeesPerGas });
     const paymentMethod = await this.paymentMethod(wallet, from, gasSettings);
     return {
       paymentMethod,
@@ -258,10 +269,32 @@ export class CLIFeeArgs {
     };
   }
 
+  /**
+   * 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(
-      !!args.estimateGasOnly,
-      parsePaymentMethod(args.payment ?? 'method=fee_juice', log, db),
+      estimateOnly,
+      parsePaymentMethod(args.payment ?? 'method=fee_juice', log, db, estimateOnly),
       parseGasSettings(args),
     );
   }
@@ -287,7 +320,7 @@ function formatGasEstimate(estimate: Pick<GasSettings, 'gasLimits' | 'teardownGa
 }
 
 function getEstimatedCost(estimate: Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>, maxFeesPerGas: GasFees) {
-  return GasSettings.default({ ...estimate, maxFeesPerGas })
+  return GasSettings.fallback({ ...estimate, maxFeesPerGas })
     .getFeeLimit()
     .toBigInt();
 }

package/src/utils/options/options.ts

@@ -7,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 '../wallet.js';
+import { AccountTypes } from '../constants.js';
 
 const TARGET_DIR = 'target';
 

package/src/utils/profiling.ts

@@ -95,7 +95,7 @@ export function printProfileResult(
 
   if (stats.nodeRPCCalls) {
     log(format('\nRPC calls:\n'));
-    for (const [method, { times }] of Object.entries(stats.nodeRPCCalls)) {
+    for (const [method, { times }] of Object.entries(stats.nodeRPCCalls.perMethod)) {
       const calls = times.length;
       const total = times.reduce((acc, time) => acc + time, 0);
       const avg = total / calls;
@@ -112,6 +112,20 @@ export function printProfileResult(
         ),
       );
     }
+
+    const { roundTrips } = stats.nodeRPCCalls;
+    log(format('\nRound trips (actual blocking waits):\n'));
+    log(format('Round trips:'.padEnd(25), `${roundTrips.roundTrips}`.padStart(COLUMN_MAX_WIDTH)));
+    log(
+      format(
+        'Total blocking time:'.padEnd(25),
+        `${roundTrips.totalBlockingTime.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH),
+      ),
+    );
+    if (roundTrips.roundTrips > 0) {
+      const avgRoundTrip = roundTrips.totalBlockingTime / roundTrips.roundTrips;
+      log(format('Avg round trip:'.padEnd(25), `${avgRoundTrip.toFixed(2)}ms`.padStart(COLUMN_MAX_WIDTH)));
+    }
   }
 
   log(format('\nSync time:'.padEnd(25), `${timings.sync?.toFixed(2)}ms`.padStart(16)));

package/src/utils/wallet.ts

@@ -1,39 +1,46 @@
 import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
-import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
-import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/ecdsa/stub';
+import { SchnorrAccountContract, SchnorrInitializerlessAccountContract } from '@aztec/accounts/schnorr';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/schnorr/stub';
 import { getIdentities } from '@aztec/accounts/utils';
-import { type Account, type AccountContract, SignerlessAccount } from '@aztec/aztec.js/account';
+import { type Account, type AccountContract, NO_FROM } from '@aztec/aztec.js/account';
 import {
+  ContractFunctionInteraction,
   type InteractionFeeOptions,
-  getContractInstanceFromInstantiationParams,
-  getGasLimits,
+  getContractClassFromArtifact,
 } from '@aztec/aztec.js/contracts';
 import type { AztecNode } from '@aztec/aztec.js/node';
-import { UniqueNote } from '@aztec/aztec.js/note';
-import { AccountManager, type Aliased, BaseWallet, type SimulateOptions } from '@aztec/aztec.js/wallet';
+import { AccountManager, type Aliased } from '@aztec/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
 import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
-import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
-import { Fr } from '@aztec/foundation/fields';
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
+import type { NotesFilter } from '@aztec/pxe/client/lazy';
 import type { PXEConfig } from '@aztec/pxe/config';
 import type { PXE } from '@aztec/pxe/server';
 import { createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Gas, GasUsed } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import type { NotesFilter } from '@aztec/stdlib/note';
-import type { TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
+import { NoteDao } from '@aztec/stdlib/note';
+import type { SimulationOverrides, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet, type SimulateViaEntrypointOptions, getGasLimits } from '@aztec/wallet-sdk/base-wallet';
 
 import type { WalletDB } from '../storage/wallet_db.js';
+import type { AccountType } from './constants.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 BASE_FEE_PADDING = 0.5;
+/** Padding the CLI wallet applies to simulated gas usage when deriving declared gas limits. */
+const DEFAULT_ESTIMATED_GAS_PADDING = 0.1;
 
 export class CLIWallet extends BaseWallet {
   private accountCache = new Map<string, Account>();
+  // Stub class ids, populated on wallet startup
+  // to avoid redundant work per simulation
+  private stubClassIds = new Map<AccountType, Fr>();
 
   constructor(
     pxe: PXE,
@@ -53,12 +60,55 @@ export class CLIWallet extends BaseWallet {
   ): Promise<CLIWallet> {
     const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
     const pxe = await createPXE(node, pxeConfig);
-    return new CLIWallet(pxe, node, log, db);
+    const wallet = new CLIWallet(pxe, node, log, db);
+    await wallet.initStubClasses();
+    await wallet.registerAuthRegistry();
+    return wallet;
+  }
+
+  private async registerAuthRegistry(): Promise<void> {
+    const { instance, artifact } = await getStandardAuthRegistry();
+    await this.pxe.registerContractClass(artifact);
+    await this.pxe.registerContract(instance);
+  }
+
+  /**
+   * Hashes and registers the stub class for every supported account type with PXE, populating
+   * stubClassIds. Called on wallet initialization.
+   */
+  private async initStubClasses(): Promise<void> {
+    const { id: schnorrClassId } = await getContractClassFromArtifact(StubSchnorrAccountContractArtifact);
+    await this.pxe.registerContractClass(StubSchnorrAccountContractArtifact);
+
+    // ecdsa stubs share the same class id
+    const { id: ecdsaClassId } = await getContractClassFromArtifact(StubEcdsaAccountContractArtifact);
+    await this.pxe.registerContractClass(StubEcdsaAccountContractArtifact);
+
+    this.stubClassIds.set('schnorr', schnorrClassId);
+    this.stubClassIds.set('schnorr_initializerless', schnorrClassId);
+    this.stubClassIds.set('ecdsasecp256k1', ecdsaClassId);
+    this.stubClassIds.set('ecdsasecp256r1', ecdsaClassId);
+    this.stubClassIds.set('ecdsasecp256r1ssh', ecdsaClassId);
   }
 
   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) })));
+    return Promise.resolve(
+      accounts.map(({ key, value }) => {
+        const alias = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key;
+        return { alias, item: AztecAddress.fromStringUnsafe(value) };
+      }),
+    );
+  }
+
+  /**
+   * Derives suggested total and teardown gas limits from simulated gas usage, padded and clamped to the
+   * network's per-tx admission limits.
+   * @param gasUsed - The gas consumed during simulation (from a `simulate({ includeMetadata: true })` result).
+   */
+  async estimateGasLimits(gasUsed: GasUsed): Promise<{ gasLimits: Gas; teardownGasLimits: Gas }> {
+    const maxTxGasLimits = await this.getMaxTxGasLimits();
+    return getGasLimits(gasUsed, maxTxGasLimits, DEFAULT_ESTIMATED_GAS_PADDING);
   }
 
   private async createCancellationTxExecutionRequest(
@@ -66,17 +116,25 @@ export class CLIWallet extends BaseWallet {
     txNonce: Fr,
     increasedFee: InteractionFeeOptions,
   ) {
-    const feeOptions = await this.getDefaultFeeOptions(from, increasedFee);
+    const executionPayload = ExecutionPayload.empty();
+    const feeOptions = await this.completeFeeOptions({
+      from,
+      feePayer: executionPayload.feePayer,
+      gasSettings: increasedFee.gasSettings,
+    });
     const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
     const fromAccount = await this.getAccountFromAddress(from);
+    const chainInfo = await this.getChainInfo();
     const executionOptions: DefaultAccountEntrypointOptions = {
       txNonce,
       cancellable: this.cancellableTransactions,
-      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+      // If from is an address, feeOptions include the way the account contract should handle the fee payment
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions!,
     };
     return await fromAccount.createTxExecutionRequest(
-      feeExecutionPayload ?? ExecutionPayload.empty(),
+      feeExecutionPayload ?? executionPayload,
       feeOptions.gasSettings,
+      chainInfo,
       executionOptions,
     );
   }
@@ -87,15 +145,12 @@ export class CLIWallet extends BaseWallet {
     increasedFee: InteractionFeeOptions,
   ): Promise<TxProvingResult> {
     const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
-    return await this.pxe.proveTx(cancellationTxRequest);
+    return await this.pxe.proveTx(cancellationTxRequest, { scopes: this.scopesFrom(from), senderForTags: from });
   }
 
   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())) {
+    if (this.accountCache.has(address.toString())) {
       return this.accountCache.get(address.toString())!;
     } else {
       const accountManager = await this.createOrRetrieveAccount(address);
@@ -109,13 +164,27 @@ export class CLIWallet extends BaseWallet {
   }
 
   private async createAccount(secret: Fr, salt: Fr, contract: AccountContract): Promise<AccountManager> {
-    const accountManager = await AccountManager.create(this, secret, contract, salt);
+    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());
+
+    // Initializerless accounts have no deployment tx; their address commits to the signing public key
+    // (via the contract's immutablesHash, resolved by AccountManager.create) and the constructor's
+    // storage writes are materialized locally via a simulated "store" call here.
+    if (contract instanceof SchnorrInitializerlessAccountContract) {
+      const constructorAbi = artifact.functions.find(f => f.name === 'constructor');
+      if (!constructorAbi) {
+        throw new Error('Could not create SchnorrInitializerlessAccount: constructor ABI not found');
+      }
+      const { x, y } = await contract.getSigningPublicKey();
+      const storeCall = new ContractFunctionInteraction(this, instance.address, constructorAbi, [x, y]);
+      await storeCall.simulate({ from: instance.address });
+    }
+
     return accountManager;
   }
 
@@ -143,6 +212,14 @@ export class CLIWallet extends BaseWallet {
         account = await this.createAccount(secretKey, salt, new SchnorrAccountContract(deriveSigningKey(secretKey)));
         break;
       }
+      case 'schnorr_initializerless': {
+        account = await this.createAccount(
+          secretKey,
+          salt,
+          new SchnorrInitializerlessAccountContract(deriveSigningKey(secretKey)),
+        );
+        break;
+      }
       case 'ecdsasecp256r1': {
         account = await this.createAccount(
           secretKey,
@@ -178,76 +255,84 @@ export class CLIWallet extends BaseWallet {
     return account;
   }
 
+  /**
+   * Creates a stub account that impersonates the given address, allowing kernelless simulations
+   * to bypass the account's authorization mechanisms via contract overrides.
+   * @param address - The address of the account to impersonate
+   * @returns The stub account, contract instance, and artifact for simulation
+   */
   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);
+    const contractInstance = await this.pxe.getContractInstance(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,
-    };
+    const { type } = await this.db!.retrieveAccount(address);
+    const stubAccount =
+      type === 'schnorr' || type === 'schnorr_initializerless'
+        ? createStubSchnorrAccount(originalAddress)
+        : createStubEcdsaAccount(originalAddress);
+    const stubClassId = this.stubClassIds.get(type);
+    if (!stubClassId) {
+      throw new Error(
+        `Stub class for account type '${type}' was not registered at wallet init. This is a bug — initStubClasses should cover every supported AccountType.`,
+      );
+    }
+    const instance = { ...contractInstance, currentContractClassId: stubClassId };
+    return { account: stubAccount, instance };
   }
 
-  override async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
-    let simulationResults;
-    const feeOptions = opts.fee?.estimateGas
-      ? await this.getFeeOptionsForGasEstimation(opts.from, opts.fee)
-      : await this.getDefaultFeeOptions(opts.from, opts.fee);
+  /**
+   * Uses a stub account for kernelless simulation, bypassing real account authorization.
+   * Uses DefaultEntrypoint directly for NO_FROM transactions.
+   */
+  protected override async simulateViaEntrypoint(
+    executionPayload: ExecutionPayload,
+    opts: SimulateViaEntrypointOptions,
+  ): Promise<TxSimulationResultWithAppOffset> {
+    const { from, feeOptions, additionalScopes, sendMessagesAs } = opts;
+    const scopes = this.scopesFrom(from, additionalScopes);
     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;
+    const chainInfo = await this.getChainInfo();
 
-    // 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,
-      );
+    let overrides: SimulationOverrides | undefined;
+    let txRequest: TxExecutionRequest;
+    if (from === NO_FROM) {
+      const entrypoint = new DefaultEntrypoint();
+      txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
     } else {
-      const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(opts.from);
-      const txRequest = await fromAccount.createTxExecutionRequest(
+      const { account, instance } = await this.getFakeAccountDataFor(from);
+      overrides = {
+        contracts: { [from.toString()]: { instance } },
+      };
+      const executionOptions: DefaultAccountEntrypointOptions = {
+        txNonce: Fr.random(),
+        cancellable: this.cancellableTransactions,
+        // If from is an address, feeOptions include the way the account contract should handle the fee payment
+        feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions!,
+      };
+      txRequest = await account.createTxExecutionRequest(
         finalExecutionPayload,
         feeOptions.gasSettings,
+        chainInfo,
         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;
+    const result = await this.pxe.simulateTx(txRequest, {
+      simulatePublic: true,
+      skipFeeEnforcement: true,
+      skipTxValidation: true,
+      overrides,
+      scopes,
+      senderForTags: this.senderForTagsFrom(from, sendMessagesAs),
+    });
+    const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+    return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
   }
 
   // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
@@ -258,7 +343,13 @@ export class CLIWallet extends BaseWallet {
 
   // 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<UniqueNote[]> {
-    return this.pxe.getNotes(filter);
+  getNotes(filter: NotesFilter): Promise<NoteDao[]> {
+    return this.pxe.debug.getNotes(filter);
+  }
+
+  // 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.
+  getContractArtifact(id: Fr) {
+    return this.pxe.getContractArtifact(id);
   }
 }