@aztec/cli-wallet 0.0.1-fake-ceab37513c → 0.0.2-commit.217f559981

package/src/utils/wallet.ts

@@ -0,0 +1,290 @@
+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 { AccessScopes, 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 { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { NoteDao } from '@aztec/stdlib/note';
+import type { TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet, type FeeOptions } 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 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 chainInfo = await this.getChainInfo();
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce,
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    return await fromAccount.createTxExecutionRequest(
+      feeExecutionPayload ?? executionPayload,
+      feeOptions.gasSettings,
+      chainInfo,
+      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, this.scopesFrom(from));
+  }
+
+  override async getAccountFromAddress(address: AztecAddress) {
+    let account: Account | undefined;
+    if (address.equals(AztecAddress.ZERO)) {
+      account = new SignerlessAccount();
+    } 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;
+  }
+
+  /**
+   * 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 originalAccount = await this.getAccountFromAddress(address);
+    // Account contracts can only be overridden if they have an associated address
+    // Overwriting SignerlessAccount is not supported, and does not really make sense
+    // since it has no authorization mechanism.
+    if (originalAccount instanceof SignerlessAccount) {
+      throw new Error(`Cannot create fake account data for SignerlessAccount at address: ${address}`);
+    }
+    const originalAddress = (originalAccount as Account).getCompleteAddress();
+    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);
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+
+  override async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
+    const simulationResults = await super.simulateTx(executionPayload, opts);
+
+    if (opts.fee?.estimateGas) {
+      const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
+      const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
+      printGasEstimates(feeOptions, limits, this.userLog);
+    }
+    return simulationResults;
+  }
+
+  /**
+   * Uses a stub account for kernelless simulation, bypassing real account authorization.
+   * Falls through to the standard entrypoint path for SignerlessAccount (ZERO address).
+   */
+  protected override async simulateViaEntrypoint(
+    executionPayload: ExecutionPayload,
+    from: AztecAddress,
+    feeOptions: FeeOptions,
+    scopes: AccessScopes,
+    skipTxValidation?: boolean,
+    skipFeeEnforcement?: boolean,
+  ): Promise<TxSimulationResult> {
+    if (from.equals(AztecAddress.ZERO)) {
+      return super.simulateViaEntrypoint(
+        executionPayload,
+        from,
+        feeOptions,
+        scopes,
+        skipTxValidation,
+        skipFeeEnforcement,
+      );
+    }
+
+    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 { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(from);
+    const chainInfo = await this.getChainInfo();
+    const txRequest = await fromAccount.createTxExecutionRequest(
+      finalExecutionPayload,
+      feeOptions.gasSettings,
+      chainInfo,
+      executionOptions,
+    );
+    return this.pxe.simulateTx(txRequest, {
+      simulatePublic: true,
+      skipFeeEnforcement: true,
+      skipTxValidation: true,
+      overrides: {
+        contracts: { [from.toString()]: { instance, artifact } },
+      },
+      scopes,
+    });
+  }
+
+  // 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);
+  }
+
+  // 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);
+  }
+}

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"}

package/dest/cmds/cancel_tx.js

@@ -1,43 +0,0 @@
-import { SentTx, TxStatus } from '@aztec/aztec.js';
-import { ExecutionPayload } from '@aztec/entrypoints/payload';
-import { GasFees, GasSettings } from '@aztec/stdlib/gas';
-import { DEFAULT_TX_TIMEOUT_S } from '../utils/pxe_wrapper.js';
-export async function cancelTx(wallet, { txHash, gasSettings: prevTxGasSettings, txNonce, cancellable }, paymentMethod, increasedFees, maxFeesPerGas, log) {
-    const receipt = await wallet.getTxReceipt(txHash);
-    if (receipt.status !== TxStatus.PENDING || !cancellable) {
-        log(`Transaction is in status ${receipt.status} and cannot be cancelled`);
-        return;
-    }
-    const maxPriorityFeesPerGas = new GasFees(prevTxGasSettings.maxPriorityFeesPerGas.feePerDaGas + increasedFees.feePerDaGas, prevTxGasSettings.maxPriorityFeesPerGas.feePerL2Gas + increasedFees.feePerL2Gas);
-    const fee = {
-        paymentMethod,
-        gasSettings: GasSettings.from({
-            ...prevTxGasSettings,
-            maxPriorityFeesPerGas,
-            maxFeesPerGas: maxFeesPerGas ?? prevTxGasSettings.maxFeesPerGas
-        })
-    };
-    const txRequest = await wallet.createTxExecutionRequest(ExecutionPayload.empty(), fee, {
-        txNonce,
-        cancellable: true
-    });
-    const txSimulationResult = await wallet.simulateTx(txRequest, true);
-    const txProvingResult = await wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
-    const sentTx = new SentTx(wallet, async ()=>{
-        const tx = await txProvingResult.toTx();
-        return wallet.sendTx(tx);
-    });
-    try {
-        await sentTx.wait({
-            timeout: DEFAULT_TX_TIMEOUT_S
-        });
-        log('Transaction has been cancelled');
-        const cancelReceipt = await sentTx.getReceipt();
-        log(` Tx fee: ${cancelReceipt.transactionFee}`);
-        log(` Status: ${cancelReceipt.status}`);
-        log(` Block number: ${cancelReceipt.blockNumber}`);
-        log(` Block hash: ${cancelReceipt.blockHash?.toString()}`);
-    } catch (err) {
-        log(`Could not cancel transaction\n ${err.message}`);
-    }
-}

package/dest/utils/accounts.d.ts

@@ -1,9 +0,0 @@
-import type { AccountManager } from '@aztec/aztec.js';
-import { Fr } from '@aztec/foundation/fields';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { WalletDB } from '../storage/wallet_db.js';
-export declare const AccountTypes: readonly ["schnorr", "ecdsasecp256r1", "ecdsasecp256r1ssh", "ecdsasecp256k1"];
-export type AccountType = (typeof AccountTypes)[number];
-export declare function createOrRetrieveAccount(pxe: PXE, address?: AztecAddress, db?: WalletDB, secretKey?: Fr, type?: AccountType, salt?: Fr, publicKey?: string): Promise<AccountManager>;
-//# sourceMappingURL=accounts.d.ts.map

package/dest/utils/accounts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/utils/accounts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,eAAO,MAAM,YAAY,+EAAgF,CAAC;AAC1G,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,GAAG,EACR,OAAO,CAAC,EAAE,YAAY,EACtB,EAAE,CAAC,EAAE,QAAQ,EACb,SAAS,CAAC,EAAE,EAAE,EACd,IAAI,GAAE,WAAuB,EAC7B,IAAI,CAAC,EAAE,EAAE,EACT,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,cAAc,CAAC,CAuDzB"}

package/dest/utils/accounts.js

@@ -1,61 +0,0 @@
-import { getIdentities } from '@aztec/accounts/utils';
-import { Fr } from '@aztec/foundation/fields';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
-export const AccountTypes = [
-    'schnorr',
-    'ecdsasecp256r1',
-    'ecdsasecp256r1ssh',
-    'ecdsasecp256k1'
-];
-export async function createOrRetrieveAccount(pxe, address, db, secretKey, type = 'schnorr', salt, publicKey) {
-    let account;
-    salt ??= Fr.ZERO;
-    if (db && address) {
-        ({ type, secretKey, salt } = await 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 'ecdsasecp256r1':
-            {
-                const { getEcdsaRAccount } = await import('@aztec/accounts/ecdsa');
-                account = getEcdsaRAccount(pxe, secretKey, deriveSigningKey(secretKey).toBuffer(), salt);
-                break;
-            }
-        case 'ecdsasecp256r1ssh':
-            {
-                let publicSigningKey;
-                if (db && address) {
-                    publicSigningKey = await 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;
-}

package/dest/utils/pxe_wrapper.d.ts

@@ -1,12 +0,0 @@
-import { type PXEServiceConfig } from '@aztec/pxe/server';
-import { type AztecNode, type PXE } from '@aztec/stdlib/interfaces/client';
-export declare const DEFAULT_TX_TIMEOUT_S = 180;
-export declare class PXEWrapper {
-    private static pxeConfig;
-    private static pxe;
-    private static node;
-    getPXE(): Promise<PXE>;
-    getNode(): AztecNode | undefined;
-    prepare(nodeUrl: string, dataDir: string, overridePXEServiceConfig?: Partial<PXEServiceConfig>): void;
-}
-//# sourceMappingURL=pxe_wrapper.d.ts.map

package/dest/utils/pxe_wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pxe_wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/pxe_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAyC,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,GAAG,EAAyB,MAAM,iCAAiC,CAAC;AAElG,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAMxC,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAC,SAAS,CAA+B;IACvD,OAAO,CAAC,MAAM,CAAC,GAAG,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAwB;IAErC,MAAM;IAOZ,OAAO,IAAI,SAAS,GAAG,SAAS;IAIhC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,wBAAwB,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC;CAM/F"}

package/dest/utils/pxe_wrapper.js

@@ -1,26 +0,0 @@
-import { createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-export const DEFAULT_TX_TIMEOUT_S = 180;
-/*
- * Wrapper class for PXE service, avoids initialization issues due to
- * closures when providing PXE service to injected commander.js commands
- */ export class PXEWrapper {
-    static pxeConfig;
-    static pxe;
-    static node;
-    async getPXE() {
-        if (!PXEWrapper.pxe) {
-            PXEWrapper.pxe = await createPXEService(PXEWrapper.node, PXEWrapper.pxeConfig);
-        }
-        return PXEWrapper.pxe;
-    }
-    getNode() {
-        return PXEWrapper.node;
-    }
-    prepare(nodeUrl, dataDir, overridePXEServiceConfig) {
-        PXEWrapper.node = createAztecNodeClient(nodeUrl);
-        const pxeConfig = Object.assign(getPXEServiceConfig(), overridePXEServiceConfig);
-        pxeConfig.dataDirectory = dataDir;
-        PXEWrapper.pxeConfig = pxeConfig;
-    }
-}

package/src/cmds/cancel_tx.ts

@@ -1,66 +0,0 @@
-import { type AccountWalletWithSecretKey, type FeePaymentMethod, SentTx, type TxHash, TxStatus } from '@aztec/aztec.js';
-import type { FeeOptions } from '@aztec/entrypoints/interfaces';
-import { ExecutionPayload } from '@aztec/entrypoints/payload';
-import { Fr } from '@aztec/foundation/fields';
-import type { LogFn } from '@aztec/foundation/log';
-import { GasFees, GasSettings } from '@aztec/stdlib/gas';
-
-import { DEFAULT_TX_TIMEOUT_S } from '../utils/pxe_wrapper.js';
-
-export async 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,
-) {
-  const receipt = await wallet.getTxReceipt(txHash);
-  if (receipt.status !== TxStatus.PENDING || !cancellable) {
-    log(`Transaction is in status ${receipt.status} and cannot be cancelled`);
-    return;
-  }
-
-  const maxPriorityFeesPerGas = new GasFees(
-    prevTxGasSettings.maxPriorityFeesPerGas.feePerDaGas + increasedFees.feePerDaGas,
-    prevTxGasSettings.maxPriorityFeesPerGas.feePerL2Gas + increasedFees.feePerL2Gas,
-  );
-
-  const fee: FeeOptions = {
-    paymentMethod,
-    gasSettings: GasSettings.from({
-      ...prevTxGasSettings,
-      maxPriorityFeesPerGas,
-      maxFeesPerGas: maxFeesPerGas ?? prevTxGasSettings.maxFeesPerGas,
-    }),
-  };
-
-  const txRequest = await wallet.createTxExecutionRequest(ExecutionPayload.empty(), fee, {
-    txNonce,
-    cancellable: true,
-  });
-  const txSimulationResult = await wallet.simulateTx(txRequest, true);
-  const txProvingResult = await wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
-  const sentTx = new SentTx(wallet, async () => {
-    const tx = await txProvingResult.toTx();
-    return wallet.sendTx(tx);
-  });
-  try {
-    await sentTx.wait({ timeout: DEFAULT_TX_TIMEOUT_S });
-
-    log('Transaction has been cancelled');
-
-    const cancelReceipt = await sentTx.getReceipt();
-    log(` Tx fee: ${cancelReceipt.transactionFee}`);
-    log(` Status: ${cancelReceipt.status}`);
-    log(` Block number: ${cancelReceipt.blockNumber}`);
-    log(` Block hash: ${cancelReceipt.blockHash?.toString()}`);
-  } catch (err: any) {
-    log(`Could not cancel transaction\n ${err.message}`);
-  }
-}

package/src/utils/accounts.ts

@@ -1,77 +0,0 @@
-import { getIdentities } from '@aztec/accounts/utils';
-import type { AccountManager } from '@aztec/aztec.js';
-import { Fr } from '@aztec/foundation/fields';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
-
-import type { WalletDB } from '../storage/wallet_db.js';
-import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
-
-export const AccountTypes = ['schnorr', 'ecdsasecp256r1', '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,
-): Promise<AccountManager> {
-  let account;
-
-  salt ??= Fr.ZERO;
-
-  if (db && address) {
-    ({ type, secretKey, salt } = await 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 'ecdsasecp256r1': {
-      const { getEcdsaRAccount } = await import('@aztec/accounts/ecdsa');
-      account = getEcdsaRAccount(pxe, secretKey, deriveSigningKey(secretKey).toBuffer(), salt);
-      break;
-    }
-    case 'ecdsasecp256r1ssh': {
-      let publicSigningKey;
-      if (db && address) {
-        publicSigningKey = await 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;
-}

package/src/utils/pxe_wrapper.ts

@@ -1,32 +0,0 @@
-import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
-import { type AztecNode, type PXE, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-
-export const DEFAULT_TX_TIMEOUT_S = 180;
-
-/*
- * Wrapper class for PXE service, avoids initialization issues due to
- * closures when providing PXE service to injected commander.js commands
- */
-export class PXEWrapper {
-  private static pxeConfig: PXEServiceConfig | undefined;
-  private static pxe: PXE | undefined;
-  private static node: AztecNode | undefined;
-
-  async getPXE() {
-    if (!PXEWrapper.pxe) {
-      PXEWrapper.pxe = await createPXEService(PXEWrapper.node!, PXEWrapper.pxeConfig!);
-    }
-    return PXEWrapper.pxe;
-  }
-
-  getNode(): AztecNode | undefined {
-    return PXEWrapper.node;
-  }
-
-  prepare(nodeUrl: string, dataDir: string, overridePXEServiceConfig?: Partial<PXEServiceConfig>) {
-    PXEWrapper.node = createAztecNodeClient(nodeUrl);
-    const pxeConfig = Object.assign(getPXEServiceConfig(), overridePXEServiceConfig);
-    pxeConfig.dataDirectory = dataDir;
-    PXEWrapper.pxeConfig = pxeConfig;
-  }
-}