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

package/src/cmds/index.ts

@@ -1,71 +1,63 @@
 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';
 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, addScopeToWallet, createOrRetrieveAccount, getWalletWithScopes } 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,
-  aliasedAuthWitParser,
   aliasedSecretKeyParser,
   aliasedTxHashParser,
   artifactPathFromPromiseOrAlias,
   artifactPathParser,
+  cleanupAuthWitnesses,
   createAccountOption,
   createAliasOption,
   createArgsOption,
   createArtifactOption,
+  createAuthwitnessOption,
   createContractAddressOption,
-  createProfileOption,
+  createDebugExecutionStepsDirOption,
   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 = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      await importTestAccounts(client, db, json, log);
+      await importTestAccounts(wallet, db, json, log);
     });
 
   const createAccountCommand = program
@@ -74,16 +66,23 @@ 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.',
     )
-    .option('--public-deploy', 'Publicly deploys the account and registers the class if needed.')
+    .option(
+      '--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),
@@ -93,17 +92,30 @@ 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.
     // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
-    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction');
+    .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 } = 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();
@@ -118,19 +130,24 @@ export function injectCommands(
       ]);
       publicKey = answers.identity.split(' ')[1];
     }
-    const client = 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,
       log,
     );
@@ -143,26 +160,47 @@ 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
-    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction');
+    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
+    .option(
+      '--register-class',
+      'Register the contract class (useful for when the contract class has not been deployed yet).',
+    )
+    .option(
+      '--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 } = options;
+    const { wait, from: parsedFromAddress, json, registerClass, skipInitialization, publicDeploy, verbose } = options;
 
-    const client = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db);
+    const { wallet, node } = walletAndNodeWrapper;
 
     await deployAccount(
-      account,
+      wallet,
+      node,
+      parsedAccount,
       wait,
-      await FeeOptsWithFeePayer.fromCli(options, client, log, db),
+      parsedFromAddress,
+      registerClass,
+      publicDeploy,
+      skipInitialization,
+      CLIFeeArgs.parse(options, log, db),
       json,
+      verbose,
       debugLogger,
       log,
     );
@@ -185,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')
@@ -197,9 +231,16 @@ export function injectCommands(
     // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
     .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
     .option('--no-class-registration', "Don't register this contract class")
-    .option('--no-public-deployment', "Don't emit this contract's public bytecode");
+    .option('--no-public-deployment', "Don't emit this contract's public bytecode")
+    .addOption(
+      new Option(
+        '--timeout <number>',
+        'The amount of time in seconds to wait for the deployment to post to L2',
+      ).conflicts('wait'),
+    )
+    .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 {
@@ -208,25 +249,25 @@ export function injectCommands(
       args,
       salt,
       wait,
-      secretKey,
       classRegistration,
       init,
       publicDeployment,
       universal,
-      rpcUrl,
       from: parsedFromAddress,
       alias,
+      timeout,
+      verbose,
     } = options;
-    const client = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-    const wallet = await getWalletWithScopes(account, db);
+
+    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(
-      client,
       wallet,
+      node,
+      universal ? undefined : parsedFromAddress,
       artifactPath,
       json,
       publicKey,
@@ -236,12 +277,12 @@ export function injectCommands(
       !publicDeployment,
       !classRegistration,
       typeof init === 'string' ? false : init,
-      universal,
       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);
@@ -252,7 +293,6 @@ 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))
@@ -260,13 +300,17 @@ export function injectCommands(
       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'),
+      createAuthwitnessOption(
+        'Authorization witness to use for the transaction. If using multiple, pass a comma separated string',
+        !db,
+        db,
+      ),
     )
     .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 {
@@ -275,67 +319,124 @@ export function injectCommands(
       contractAddress,
       from: parsedFromAddress,
       wait,
-      rpcUrl,
-      secretKey,
       alias,
-      cancel,
+      authWitness: authWitnessArray,
+      verbose,
     } = options;
-    const client = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-    const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-    const wallet = await getWalletWithScopes(account, db);
+
+    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.nonce.toString().slice(-4)}`;
+      const txAlias = alias ? alias : `${functionName}-${randomBytes(16).toString()}`;
       await db.storeTx(sentTx, log, txAlias);
     }
   });
 
-  program
+  const simulateCommand = program
     .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))
     .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))
-    .addOption(createProfileOption())
-    .action(async (functionName, _options, command) => {
-      const { simulate } = await import('./simulate.js');
-      const options = command.optsWithGlobals();
-      const {
-        args,
-        contractArtifact: artifactPathPromise,
-        contractAddress,
-        from: parsedFromAddress,
-        rpcUrl,
-        secretKey,
-        profile,
-      } = options;
-
-      const client = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
-      const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-      await simulate(wallet, functionName, args, artifactPath, contractAddress, profile, log);
-    });
+    .addOption(createVerboseOption());
+
+  addOptions(simulateCommand, CLIFeeArgs.getOptions()).action(async (functionName, _options, command) => {
+    const { simulate } = await import('./simulate.js');
+    const options = command.optsWithGlobals();
+    const {
+      args,
+      contractArtifact: artifactPathPromise,
+      contractAddress,
+      from: parsedFromAddress,
+      verbose,
+      authWitness,
+    } = options;
+
+    const { wallet, node } = walletAndNodeWrapper;
+
+    const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+    const authWitnesses = cleanupAuthWitnesses(authWitness);
+    await simulate(
+      wallet,
+      node,
+      parsedFromAddress,
+      functionName,
+      args,
+      artifactPath,
+      contractAddress,
+      CLIFeeArgs.parse(options, log, db),
+      authWitnesses,
+      verbose,
+      log,
+    );
+  });
+
+  const profileCommand = program
+    .command('profile')
+    .description('Profiles a private function by counting the unconditional operations in its execution steps')
+    .argument('<functionName>', 'Name of function to simulate')
+    .addOption(createArgsOption(false, db))
+    .addOption(createContractAddressOption(db))
+    .addOption(createArtifactOption(db))
+    .addOption(createDebugExecutionStepsDirOption())
+    .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, CLIFeeArgs.getOptions()).action(async (functionName, _options, command) => {
+    const { profile } = await import('./profile.js');
+    const options = command.optsWithGlobals();
+    const {
+      args,
+      contractArtifact: artifactPathPromise,
+      contractAddress,
+      from: parsedFromAddress,
+      debugExecutionStepsDir,
+      authWitness,
+    } = options;
+
+    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,
+      CLIFeeArgs.parse(options, log, db),
+      authWitnesses,
+      log,
+    );
+  });
 
   program
     .command('bridge-fee-juice')
@@ -357,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')
@@ -370,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 = 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,
@@ -402,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),
@@ -416,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 = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
-      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);
@@ -446,67 +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 = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
-      const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
-      await authorizeAction(wallet, functionName, caller, args, artifactPath, contractAddress, log);
-    });
+      const { args, contractArtifact: artifactPathPromise, contractAddress, from: parsedFromAddress } = options;
 
-  program
-    .command('add-authwit')
-    .description(
-      'Adds an authorization witness to the provided account, granting PXE access to the notes of the authorizer so that it can be verified',
-    )
-    .argument('<authwit>', 'Authorization witness to add to the account', witness => aliasedAuthWitParser(witness, db))
-    .argument('<authorizer>', 'Account that provides the authorization to perform the action', address =>
-      aliasedAddressParser('accounts', address, 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(
-      createAliasOption('Alias for the authorization witness. Used for easy reference in subsequent commands.', !db),
-    )
-    .action(async (authwit, authorizer, _options, command) => {
-      const { addAuthwit } = await import('./add_authwit.js');
-      const options = command.optsWithGlobals();
-      const { from: parsedFromAddress, rpcUrl, secretKey } = options;
+      const wallet = walletAndNodeWrapper.wallet;
 
-      const client = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
-      await addAuthwit(wallet, authwit, authorizer, log);
-      await addScopeToWallet(wallet, authorizer, db);
+      const artifactPath = await artifactPathFromPromiseOrAlias(artifactPathPromise, contractAddress, db);
+      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>',
@@ -516,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 = 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);
@@ -530,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 {
@@ -548,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 = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
-
-      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(
@@ -592,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 = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
+      const { alias } = options;
+
+      const wallet = walletAndNodeWrapper.wallet;
 
       await registerSender(wallet, address, log);
 
@@ -616,21 +630,43 @@ export function injectCommands(
       aliasedAddressParser('accounts', address, db),
     )
     .argument('[artifact]', ARTIFACT_DESCRIPTION, artifactPathParser)
+    .option('--init <string>', 'The contract initializer function to call', 'constructor')
+    .option(
+      '-k, --public-key <string>',
+      'Optional encryption public key for this address. Set this value only if this contract is expected to receive private notes, which will be encrypted using this public key.',
+      parsePublicKey,
+    )
+    .option(
+      '-s, --salt <hex string>',
+      'Optional deployment salt as a hex string for generating the deployment address.',
+      parseFieldFromHexString,
+    )
+    .option('--deployer <string>', 'The address of the account that deployed the contract', address =>
+      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 } = command.optsWithGlobals();
-      const client = pxeWrapper?.getPXE() ?? (await createCompatibleClient(rpcUrl, debugLogger));
-      const node = pxeWrapper?.getNode() ?? createAztecNodeClient(nodeUrl);
-      const account = await createOrRetrieveAccount(client, parsedFromAddress, db, secretKey);
-      const wallet = await getWalletWithScopes(account, db);
+      const { alias, init, publicKey, salt, deployer, args } = command.optsWithGlobals();
+
+      const wallet = walletAndNodeWrapper.wallet;
+      const node = walletAndNodeWrapper.node;
 
       const artifactPath = await artifactPathPromise;
 
-      const instance = await registerContract(wallet, node, address, artifactPath, log);
+      const instance = await registerContract(
+        wallet,
+        node,
+        address,
+        artifactPath,
+        log,
+        init,
+        publicKey,
+        args,
+        salt,
+        deployer,
+      );
 
       if (db && alias) {
         await db.storeContract(instance.address, artifactPath, log, alias);