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

package/src/cmds/index.ts

@@ -1,31 +1,26 @@
-import { CopyCatAccountWallet } from '@aztec/accounts/copy-cat';
 import { getIdentities } from '@aztec/accounts/utils';
-import { createCompatibleClient } from '@aztec/aztec.js/rpc';
-import { TxHash } from '@aztec/aztec.js/tx_hash';
+import { TxHash } from '@aztec/aztec.js/tx';
 import {
   ETHEREUM_HOSTS,
   PRIVATE_KEY,
   addOptions,
   createSecretKeyOption,
   l1ChainIdOption,
-  logJson,
   parseBigint,
   parseFieldFromHexString,
   parsePublicKey,
-  pxeOption,
 } from '@aztec/cli/utils';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import type { LogFn, Logger } from '@aztec/foundation/log';
-import { GasFees } from '@aztec/stdlib/gas';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 
 import { type Command, Option } from 'commander';
 import inquirer from 'inquirer';
 
 import type { WalletDB } from '../storage/wallet_db.js';
-import { type AccountType, createOrRetrieveAccount } from '../utils/accounts.js';
-import { FeeOpts, FeeOptsWithFeePayer } from '../utils/options/fees.js';
+import type { CliWalletAndNodeWrapper } from '../utils/cli_wallet_and_node_wrapper.js';
 import {
   ARTIFACT_DESCRIPTION,
+  CLIFeeArgs,
   aliasedAddressParser,
   aliasedSecretKeyParser,
   aliasedTxHashParser,
@@ -42,33 +37,27 @@ import {
   createTypeOption,
   createVerboseOption,
   integerArgParser,
-  parseGasFees,
-  parsePaymentMethod,
 } from '../utils/options/index.js';
-import type { PXEWrapper } from '../utils/pxe_wrapper.js';
+import type { AccountType } from '../utils/wallet.js';
 
+// TODO: This function is only used in 1 place so we could just inline this
 export function injectCommands(
   program: Command,
   log: LogFn,
   debugLogger: Logger,
-  db?: WalletDB,
-  pxeWrapper?: PXEWrapper,
+  walletAndNodeWrapper: CliWalletAndNodeWrapper,
+  db: WalletDB,
 ) {
   program
     .command('import-test-accounts')
     .description('Import test accounts from pxe.')
-    .addOption(pxeOption)
     .option('--json', 'Emit output as json')
     .action(async options => {
-      if (!db) {
-        throw new Error(`A db is required to store the imported test accounts.`);
-      }
-
+      const { json } = options;
+      const wallet = walletAndNodeWrapper.wallet;
       const { importTestAccounts } = await import('./import_test_accounts.js');
-      const { rpcUrl, json } = options;
 
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      await importTestAccounts(client, db, json, log);
+      await importTestAccounts(wallet, db, json, log);
     });
 
   const createAccountCommand = program
@@ -77,6 +66,7 @@ export function injectCommands(
       'Creates an aztec account that can be used for sending transactions. Registers the account on the PXE and deploys an account contract. Uses a Schnorr single-key account which uses the same key for encryption and authentication (not secure for production usage).',
     )
     .summary('Creates an aztec account that can be used for sending transactions.')
+    .addOption(createAccountOption('Alias or address of the account performing the deployment', !db, db))
     .option(
       '--skip-initialization',
       'Skip initializing the account contract. Useful for publicly deploying an existing account.',
@@ -85,11 +75,14 @@ export function injectCommands(
       '--public-deploy',
       'Publishes the account contract instance (and the class, if needed). Needed if the contract contains public functions.',
     )
+    .option(
+      '--register-class',
+      'Register the contract class (useful for when the contract class has not been deployed yet).',
+    )
     .option(
       '-p, --public-key <string>',
       'Public key that identifies a private signing key stored outside of the wallet. Used for ECDSA SSH accounts over the secp256r1 curve.',
     )
-    .addOption(pxeOption)
     .addOption(
       createSecretKeyOption('Secret key for account. Uses random by default.', false, sk =>
         aliasedSecretKeyParser(sk, db),
@@ -99,7 +92,7 @@ export function injectCommands(
     .addOption(createTypeOption(true))
     .option(
       '--register-only',
-      'Just register the account on the PXE. Do not deploy or initialize the account contract.',
+      'Just register the account on the Wallet. Do not deploy or initialize the account contract.',
     )
     .option('--json', 'Emit output as json')
     // `options.wait` is default true. Passing `--no-wait` will set it to false.
@@ -107,11 +100,22 @@ export function injectCommands(
     .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
     .addOption(createVerboseOption());
 
-  addOptions(createAccountCommand, FeeOptsWithFeePayer.getOptions()).action(async (_options, command) => {
+  addOptions(createAccountCommand, CLIFeeArgs.getOptions()).action(async (_options, command) => {
     const { createAccount } = await import('./create_account.js');
     const options = command.optsWithGlobals();
-    const { type, secretKey, wait, registerOnly, skipInitialization, publicDeploy, rpcUrl, alias, json, verbose } =
-      options;
+    const {
+      type,
+      from: parsedFromAddress,
+      secretKey,
+      wait,
+      registerOnly,
+      skipInitialization,
+      publicDeploy,
+      registerClass,
+      alias,
+      json,
+      verbose,
+    } = options;
     let { publicKey } = options;
     if ((type as AccountType) === 'ecdsasecp256r1ssh' && !publicKey) {
       const identities = await getIdentities();
@@ -126,18 +130,22 @@ export function injectCommands(
       ]);
       publicKey = answers.identity.split(' ')[1];
     }
-    const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
+
+    const { wallet, node } = walletAndNodeWrapper;
     const accountCreationResult = await createAccount(
-      client,
+      wallet,
+      node,
       type,
       secretKey,
       publicKey,
       alias,
+      parsedFromAddress,
       registerOnly,
       skipInitialization,
       publicDeploy,
+      registerClass,
       wait,
-      await FeeOptsWithFeePayer.fromCli(options, client, log, db),
+      CLIFeeArgs.parse(options, log, db),
       json,
       verbose,
       debugLogger,
@@ -152,8 +160,10 @@ export function injectCommands(
   const deployAccountCommand = program
     .command('deploy-account')
     .description('Deploys an already registered aztec account that can be used for sending transactions.')
-    .addOption(createAccountOption('Alias or address of the account to deploy', !db, db))
-    .addOption(pxeOption)
+    .argument('<address>', 'The address of the contract to register', address =>
+      aliasedAddressParser('accounts', address, db),
+    )
+    .addOption(createAccountOption('Alias or address of the account performing the deployment', !db, db))
     .option('--json', 'Emit output as json')
     // `options.wait` is default true. Passing `--no-wait` will set it to false.
     // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
@@ -166,22 +176,29 @@ export function injectCommands(
       '--public-deploy',
       'Publishes the account contract instance (and the class, if needed). Needed if the contract contains public functions.',
     )
+    .option(
+      '--skip-initialization',
+      'Skip initializing the account contract. Useful for publicly deploying an existing account.',
+    )
     .addOption(createVerboseOption());
 
-  addOptions(deployAccountCommand, FeeOptsWithFeePayer.getOptions()).action(async (_options, command) => {
+  addOptions(deployAccountCommand, CLIFeeArgs.getOptions()).action(async (parsedAccount, _options, command) => {
     const { deployAccount } = await import('./deploy_account.js');
     const options = command.optsWithGlobals();
-    const { rpcUrl, wait, from: parsedFromAddress, json, registerClass, publicDeploy, verbose } = options;
+    const { wait, from: parsedFromAddress, json, registerClass, skipInitialization, publicDeploy, verbose } = options;
 
-    const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db);
+    const { wallet, node } = walletAndNodeWrapper;
 
     await deployAccount(
-      account,
+      wallet,
+      node,
+      parsedAccount,
       wait,
+      parsedFromAddress,
       registerClass,
       publicDeploy,
-      await FeeOptsWithFeePayer.fromCli(options, client, log, db),
+      skipInitialization,
+      CLIFeeArgs.parse(options, log, db),
       json,
       verbose,
       debugLogger,
@@ -206,11 +223,7 @@ export function injectCommands(
       parseFieldFromHexString,
     )
     .option('--universal', 'Do not mix the sender address into the deployment.')
-    .addOption(pxeOption)
     .addOption(createArgsOption(true, db))
-    .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
-    )
     .addOption(createAccountOption('Alias or address of the account to deploy from', !db, db))
     .addOption(createAliasOption('Alias for the contract. Used for easy reference subsequent commands.', !db))
     .option('--json', 'Emit output as json')
@@ -227,7 +240,7 @@ export function injectCommands(
     )
     .addOption(createVerboseOption());
 
-  addOptions(deployCommand, FeeOpts.getOptions()).action(async (artifactPathPromise, _options, command) => {
+  addOptions(deployCommand, CLIFeeArgs.getOptions()).action(async (artifactPathPromise, _options, command) => {
     const { deploy } = await import('./deploy.js');
     const options = command.optsWithGlobals();
     const {
@@ -236,27 +249,25 @@ export function injectCommands(
       args,
       salt,
       wait,
-      secretKey,
       classRegistration,
       init,
       publicDeployment,
       universal,
-      rpcUrl,
       from: parsedFromAddress,
       alias,
       timeout,
       verbose,
     } = options;
-    const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-    const wallet = await account.getWallet();
+
+    const { wallet, node } = walletAndNodeWrapper;
     const artifactPath = await artifactPathPromise;
 
-    debugLogger.info(`Using wallet with address ${wallet.getCompleteAddress().address.toString()}`);
+    debugLogger.info(`Using wallet with address ${parsedFromAddress.toString()}`);
 
     const address = await deploy(
       wallet,
-      universal ? undefined : wallet.getAddress(),
+      node,
+      universal ? undefined : parsedFromAddress,
       artifactPath,
       json,
       publicKey,
@@ -267,12 +278,11 @@ export function injectCommands(
       !classRegistration,
       typeof init === 'string' ? false : init,
       wait,
-      await FeeOpts.fromCli(options, client, log, db),
+      CLIFeeArgs.parse(options, log, db),
       timeout,
       verbose,
       debugLogger,
       log,
-      logJson(log),
     );
     if (db && address) {
       await db.storeContract(address, artifactPath, log, alias);
@@ -283,16 +293,12 @@ export function injectCommands(
     .command('send')
     .description('Calls a function on an Aztec contract.')
     .argument('<functionName>', 'Name of function to execute')
-    .addOption(pxeOption)
     .addOption(createArgsOption(false, db))
     .addOption(createArtifactOption(db))
     .addOption(createContractAddressOption(db))
     .addOption(
       createAliasOption('Alias for the transaction hash. Used for easy reference in subsequent commands.', !db),
     )
-    .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
-    )
     .addOption(
       createAuthwitnessOption(
         'Authorization witness to use for the transaction. If using multiple, pass a comma separated string',
@@ -302,10 +308,9 @@ export function injectCommands(
     )
     .addOption(createAccountOption('Alias or address of the account to send the transaction from', !db, db))
     .option('--no-wait', 'Print transaction hash without waiting for it to be mined')
-    .option('--no-cancel', 'Do not allow the transaction to be cancelled. This makes for cheaper transactions.')
     .addOption(createVerboseOption());
 
-  addOptions(sendCommand, FeeOpts.getOptions()).action(async (functionName, _options, command) => {
+  addOptions(sendCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command) => {
     const { send } = await import('./send.js');
     const options = command.optsWithGlobals();
     const {
@@ -314,36 +319,34 @@ export function injectCommands(
       contractAddress,
       from: parsedFromAddress,
       wait,
-      rpcUrl,
-      secretKey,
       alias,
-      cancel,
       authWitness: authWitnessArray,
       verbose,
     } = options;
-    const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-    const wallet = await account.getWallet();
+
+    const { wallet, node } = walletAndNodeWrapper;
     const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
 
-    debugLogger.info(`Using wallet with address ${wallet.getCompleteAddress().address.toString()}`);
+    debugLogger.info(`Using wallet with address ${parsedFromAddress.toString()}`);
 
     const authWitnesses = cleanupAuthWitnesses(authWitnessArray);
     const sentTx = await send(
       wallet,
+      node,
+      parsedFromAddress,
       functionName,
       args,
       artifactPath,
       contractAddress,
       wait,
-      cancel,
-      await FeeOpts.fromCli(options, client, log, db),
+      alias,
+      CLIFeeArgs.parse(options, log, db),
       authWitnesses,
       verbose,
       log,
     );
     if (db && sentTx) {
-      const txAlias = alias ? alias : `${functionName}-${sentTx.txNonce.toString().slice(-4)}`;
+      const txAlias = alias ? alias : `${functionName}-${randomBytes(16).toString('hex')}`;
       await db.storeTx(sentTx, log, txAlias);
     }
   });
@@ -352,7 +355,6 @@ export function injectCommands(
     .command('simulate')
     .description('Simulates the execution of a function on an Aztec contract.')
     .argument('<functionName>', 'Name of function to simulate')
-    .addOption(pxeOption)
     .addOption(createArgsOption(false, db))
     .addOption(createContractAddressOption(db))
     .addOption(createArtifactOption(db))
@@ -363,7 +365,7 @@ export function injectCommands(
     .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
     .addOption(createVerboseOption());
 
-  addOptions(simulateCommand, FeeOpts.getOptions()).action(async (functionName, _options, command) => {
+  addOptions(simulateCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command) => {
     const { simulate } = await import('./simulate.js');
     const options = command.optsWithGlobals();
     const {
@@ -371,25 +373,23 @@ export function injectCommands(
       contractArtifact: artifactPathPromise,
       contractAddress,
       from: parsedFromAddress,
-      rpcUrl,
-      secretKey,
       verbose,
       authWitness,
     } = options;
 
-    const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-    const originalWallet = await account.getWallet();
-    const wallet = await CopyCatAccountWallet.create(client, originalWallet);
+    const { wallet, node } = walletAndNodeWrapper;
+
     const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
     const authWitnesses = cleanupAuthWitnesses(authWitness);
     await simulate(
       wallet,
+      node,
+      parsedFromAddress,
       functionName,
       args,
       artifactPath,
       contractAddress,
-      await FeeOpts.fromCli(options, client, log, db),
+      CLIFeeArgs.parse(options, log, db),
       authWitnesses,
       verbose,
       log,
@@ -400,18 +400,14 @@ export function injectCommands(
     .command('profile')
     .description('Profiles a private function by counting the unconditional operations in its execution steps')
     .argument('<functionName>', 'Name of function to simulate')
-    .addOption(pxeOption)
     .addOption(createArgsOption(false, db))
     .addOption(createContractAddressOption(db))
     .addOption(createArtifactOption(db))
     .addOption(createDebugExecutionStepsDirOption())
-    .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
-    )
     .addOption(createAuthwitnessOption('Authorization witness to use for the simulation', !db, db))
     .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db));
 
-  addOptions(profileCommand, FeeOpts.getOptions()).action(async (functionName, _options, command) => {
+  addOptions(profileCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command) => {
     const { profile } = await import('./profile.js');
     const options = command.optsWithGlobals();
     const {
@@ -419,25 +415,24 @@ export function injectCommands(
       contractArtifact: artifactPathPromise,
       contractAddress,
       from: parsedFromAddress,
-      rpcUrl,
-      secretKey,
       debugExecutionStepsDir,
       authWitness,
     } = options;
 
-    const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-    const wallet = await account.getWallet();
+    const { wallet, node } = walletAndNodeWrapper;
+
     const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
     const authWitnesses = cleanupAuthWitnesses(authWitness);
     await profile(
       wallet,
+      node,
+      parsedFromAddress,
       functionName,
       args,
       artifactPath,
       contractAddress,
       debugExecutionStepsDir,
-      await FeeOptsWithFeePayer.fromCli(options, client, log, db),
+      CLIFeeArgs.parse(options, log, db),
       authWitnesses,
       log,
     );
@@ -463,12 +458,11 @@ export function injectCommands(
     )
     .option('--mint', 'Mint the tokens on L1', false)
     .option('--l1-private-key <string>', 'The private key to the eth account bridging', PRIVATE_KEY)
-    .addOption(pxeOption)
     .addOption(l1ChainIdOption)
     .option('--json', 'Output the claim in JSON format')
     // `options.wait` is default true. Passing `--no-wait` will set it to false.
     // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
-    .option('--no-wait', 'Wait for the brigded funds to be available in L2, polling every 60 seconds')
+    .option('--no-wait', 'Wait for the bridged funds to be available in L2, polling every 60 seconds')
     .addOption(
       new Option('--interval <number>', 'The polling interval in seconds for the bridged funds')
         .default('60')
@@ -476,13 +470,12 @@ export function injectCommands(
     )
     .action(async (amount, recipient, options) => {
       const { bridgeL1FeeJuice } = await import('./bridge_fee_juice.js');
-      const { rpcUrl, l1ChainId, l1RpcUrls, l1PrivateKey, mnemonic, mint, json, wait, interval: intervalS } = options;
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
+      const { l1ChainId, l1RpcUrls, l1PrivateKey, mnemonic, mint, json, wait, interval: intervalS } = options;
 
       const [secret, messageLeafIndex] = await bridgeL1FeeJuice(
         amount,
         recipient,
-        client,
+        walletAndNodeWrapper.node,
         l1RpcUrls,
         l1ChainId,
         l1PrivateKey,
@@ -508,13 +501,9 @@ export function injectCommands(
     .argument('<caller>', 'Account to be authorized to perform the action', address =>
       aliasedAddressParser('accounts', address, db),
     )
-    .addOption(pxeOption)
     .addOption(createArgsOption(false, db))
     .addOption(createContractAddressOption(db))
     .addOption(createArtifactOption(db))
-    .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
-    )
     .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
     .addOption(
       createAliasOption('Alias for the authorization witness. Used for easy reference in subsequent commands.', !db),
@@ -522,21 +511,20 @@ export function injectCommands(
     .action(async (functionName, caller, _options, command) => {
       const { createAuthwit } = await import('./create_authwit.js');
       const options = command.optsWithGlobals();
-      const {
+      const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress, alias } = options;
+
+      const wallet = walletAndNodeWrapper.wallet;
+      const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+      const witness = await createAuthwit(
+        wallet,
+        parsedFromAddress,
+        functionName,
+        caller,
         args,
-        contractArtifact: artifactPathPromise,
+        artifactPath,
         contractAddress,
-        from: parsedFromAddress,
-        rpcUrl,
-        secretKey,
-        alias,
-      } = options;
-
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await account.getWallet();
-      const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-      const witness = await createAuthwit(wallet, functionName, caller, args, artifactPath, contractAddress, log);
+        log,
+      );
 
       if (db) {
         await db.storeAuthwitness(witness, log, alias);
@@ -552,47 +540,25 @@ export function injectCommands(
     .argument('<caller>', 'Account to be authorized to perform the action', address =>
       aliasedAddressParser('accounts', address, db),
     )
-    .addOption(pxeOption)
     .addOption(createArgsOption(false, db))
     .addOption(createContractAddressOption(db))
     .addOption(createArtifactOption(db))
-    .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
-    )
     .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
     .action(async (functionName, caller, _options, command) => {
       const { authorizeAction } = await import('./authorize_action.js');
       const options = command.optsWithGlobals();
-      const {
-        args,
-        contractArtifact: artifactPathPromise,
-        contractAddress,
-        from: parsedFromAddress,
-        rpcUrl,
-        secretKey,
-      } = options;
-
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await account.getWallet();
+      const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress } = options;
+
+      const wallet = walletAndNodeWrapper.wallet;
+
       const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-      await authorizeAction(
-        wallet,
-        wallet.getAddress(),
-        functionName,
-        caller,
-        args,
-        artifactPath,
-        contractAddress,
-        log,
-      );
+      await authorizeAction(wallet, parsedFromAddress, functionName, caller, args, artifactPath, contractAddress, log);
     });
 
   program
     .command('get-tx')
     .description('Gets the status of the recent txs, or a detailed view if a specific transaction hash is provided')
     .argument('[txHash]', 'A transaction hash to get the receipt for.', txHash => aliasedTxHashParser(txHash, db))
-    .addOption(pxeOption)
     .option('-p, --page <number>', 'The page number to display', value => integerArgParser(value, '--page', 1), 1)
     .option(
       '-s, --page-size <number>',
@@ -602,12 +568,14 @@ export function injectCommands(
     )
     .action(async (txHash, options) => {
       const { checkTx } = await import('./check_tx.js');
-      const { rpcUrl, pageSize } = options;
+      const { pageSize } = options;
       let { page } = options;
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
+
+      const wallet = walletAndNodeWrapper.wallet;
+      const node = walletAndNodeWrapper.node;
 
       if (txHash) {
-        await checkTx(client, txHash, false, log);
+        await checkTx(wallet, node, txHash, false, log);
       } else if (db) {
         const aliases = await db.listAliases('transactions');
         const totalPages = Math.ceil(aliases.length / pageSize);
@@ -616,17 +584,16 @@ export function injectCommands(
           aliases.slice(page * pageSize, pageSize * (1 + page)).map(async ({ key, value }) => ({
             alias: key,
             txHash: value,
-            cancellable: (await db.retrieveTxData(TxHash.fromString(value))).cancellable,
-            status: await checkTx(client, TxHash.fromString(value), true, log),
+            status: await checkTx(wallet, node, TxHash.fromString(value), true, log),
           })),
         );
         log(`Recent transactions:`);
         log('');
         log(`${'Alias'.padEnd(32, ' ')} | ${'TxHash'.padEnd(64, ' ')} | ${'Cancellable'.padEnd(12, ' ')} | Status`);
-        log(''.padEnd(32 + 64 + 12 + 20, '-'));
-        for (const { alias, txHash, status, cancellable } of dataRows) {
-          log(`${alias.padEnd(32, ' ')} | ${txHash} | ${cancellable.toString()?.padEnd(12, ' ')} | ${status}`);
-          log(''.padEnd(32 + 64 + 12 + 20, '-'));
+        log(''.padEnd(32 + 64 + 20, '-'));
+        for (const { alias, txHash, status } of dataRows) {
+          log(`${alias.padEnd(32, ' ')} | ${txHash} | ${status}`);
+          log(''.padEnd(32 + 64 + 20, '-'));
         }
         log(`Displaying ${Math.min(pageSize, aliases.length)} rows, page ${page + 1}/${totalPages}`);
       } else {
@@ -634,42 +601,6 @@ export function injectCommands(
       }
     });
 
-  program
-    .command('cancel-tx')
-    .description('Cancels a pending tx by reusing its nonce with a higher fee and an empty payload')
-    .argument('<txHash>', 'A transaction hash to cancel.', txHash => aliasedTxHashParser(txHash, db))
-    .addOption(pxeOption)
-    .addOption(
-      createSecretKeyOption("The sender's secret key", !db, sk => aliasedSecretKeyParser(sk, db)).conflicts('account'),
-    )
-    .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
-    .addOption(FeeOpts.paymentMethodOption().default('method=fee_juice'))
-    .option(
-      '-i --increased-fees <da=1,l2=1>',
-      'The amounts by which the fees are increased',
-      value => parseGasFees(value),
-      new GasFees(1, 1),
-    )
-    .option('--max-fees-per-gas <da=100,l2=100>', 'Maximum fees per gas unit for DA and L2 computation.', value =>
-      parseGasFees(value),
-    )
-    .action(async (txHash, options) => {
-      const { cancelTx } = await import('./cancel_tx.js');
-      const { from: parsedFromAddress, rpcUrl, secretKey, payment, increasedFees, maxFeesPerGas } = options;
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await account.getWallet();
-
-      const txData = await db?.retrieveTxData(txHash);
-      if (!txData) {
-        throw new Error('Transaction data not found in the database, cannot reuse nonce');
-      }
-
-      const paymentMethod = await parsePaymentMethod(payment, false, log, db)(wallet);
-
-      await cancelTx(wallet, txData, paymentMethod, increasedFees, maxFeesPerGas, log);
-    });
-
   program
     .command('register-sender')
     .description(
@@ -678,15 +609,12 @@ export function injectCommands(
     .argument('[address]', 'The address of the sender to register', address =>
       aliasedAddressParser('accounts', address, db),
     )
-    .addOption(pxeOption)
-    .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
     .addOption(createAliasOption('Alias for the sender. Used for easy reference in subsequent commands.', !db))
     .action(async (address, options) => {
       const { registerSender } = await import('./register_sender.js');
-      const { from: parsedFromAddress, rpcUrl, secretKey, alias } = options;
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await account.getWallet();
+      const { alias } = options;
+
+      const wallet = walletAndNodeWrapper.wallet;
 
       await registerSender(wallet, address, log);
 
@@ -717,27 +645,13 @@ export function injectCommands(
       aliasedAddressParser('accounts', address, db),
     )
     .addOption(createArgsOption(true, db))
-    .addOption(pxeOption)
-    .addOption(createAccountOption('Alias or address of the account to simulate from', !db, db))
     .addOption(createAliasOption('Alias for the contact. Used for easy reference in subsequent commands.', !db))
     .action(async (address, artifactPathPromise, _options, command) => {
       const { registerContract } = await import('./register_contract.js');
-      const {
-        from: parsedFromAddress,
-        rpcUrl,
-        nodeUrl,
-        secretKey,
-        alias,
-        init,
-        publicKey,
-        salt,
-        deployer,
-        args,
-      } = command.optsWithGlobals();
-      const client = (await pxeWrapper?.getPXE()) ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const node = pxeWrapper?.getNode() ?? createAztecNodeClient(nodeUrl);
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await account.getWallet();
+      const { alias, init, publicKey, salt, deployer, args } = command.optsWithGlobals();
+
+      const wallet = walletAndNodeWrapper.wallet;
+      const node = walletAndNodeWrapper.node;
 
       const artifactPath = await artifactPathPromise;