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

package/src/cmds/profile.ts

@@ -0,0 +1,48 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
+import { Contract } from '@aztec/aztec.js/contracts';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { prepTx } from '@aztec/cli/utils';
+import type { LogFn } from '@aztec/foundation/log';
+import { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import type { CLIFeeArgs } from '../utils/options/fees.js';
+import { printProfileResult } from '../utils/profiling.js';
+import type { CLIWallet } from '../utils/wallet.js';
+
+export async function profile(
+  wallet: CLIWallet,
+  node: AztecNode,
+  from: AztecAddress,
+  functionName: string,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  debugOutputPath: string | undefined,
+  feeOpts: CLIFeeArgs,
+  authWitnesses: AuthWitness[],
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
+
+  const contract = Contract.at(contractAddress, contractArtifact, wallet);
+  const call = contract.methods[functionName](...functionArgs);
+
+  const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, from);
+  const result = await call.profile({
+    fee: { gasSettings, paymentMethod },
+    from,
+    profileMode: 'full',
+    authWitnesses,
+    skipProofGeneration: false,
+  });
+  printProfileResult(result.stats, log, true, result.executionSteps);
+  if (debugOutputPath) {
+    const ivcInputsPath = path.join(debugOutputPath, 'ivc-inputs.msgpack');
+    log(`Debug output written to ${ivcInputsPath}.`);
+    await fs.writeFile(ivcInputsPath, serializePrivateExecutionSteps(result.executionSteps));
+  }
+}

package/src/cmds/register_contract.ts

@@ -1,20 +1,43 @@
-import type { AccountWalletWithSecretKey, AztecAddress, AztecNode } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys } from '@aztec/aztec.js/keys';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import { getContractArtifact } from '@aztec/cli/cli-utils';
 import type { LogFn } from '@aztec/foundation/log';
+import { getAllFunctionAbis, getInitializer } from '@aztec/stdlib/abi';
 
 export async function registerContract(
-  wallet: AccountWalletWithSecretKey,
+  wallet: Wallet,
   node: AztecNode,
   address: AztecAddress,
   artifactPath: string,
   log: LogFn,
+  initializer?: string,
+  publicKeys?: PublicKeys,
+  rawArgs?: any[],
+  salt?: Fr,
+  deployer?: AztecAddress,
 ) {
   const contractArtifact = await getContractArtifact(artifactPath, log);
-  const contractInstance = await node.getContract(address);
+  const hasInitializer = getAllFunctionAbis(contractArtifact).some(fn => fn.isInitializer);
+  const constructorArtifact = hasInitializer ? getInitializer(contractArtifact, initializer) : undefined;
+  let contractInstance = await node.getContract(address);
   if (!contractInstance) {
-    throw new Error(`Contract not found at address: ${address}`);
+    log(`Contract not found in the node at ${address}. Computing instance locally...`);
+    contractInstance = await getContractInstanceFromInstantiationParams(contractArtifact, {
+      constructorArtifact,
+      publicKeys: publicKeys ?? PublicKeys.default(),
+      constructorArgs: rawArgs,
+      salt: salt ?? Fr.ZERO,
+      deployer,
+    });
   }
-  await wallet.registerContract({ instance: contractInstance, artifact: contractArtifact });
+  if (!contractInstance.address.equals(address)) {
+    throw new Error(`Contract address mismatch: expected ${address}, got ${contractInstance.address}`);
+  }
+  await wallet.registerContract(contractInstance, contractArtifact);
   log(`Contract registered: at ${contractInstance.address}`);
   return contractInstance;
 }

package/src/cmds/register_sender.ts

@@ -1,7 +1,8 @@
-import type { AccountWalletWithSecretKey, AztecAddress } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import type { LogFn } from '@aztec/foundation/log';
 
-export async function registerSender(wallet: AccountWalletWithSecretKey, address: AztecAddress, log: LogFn) {
+export async function registerSender(wallet: Wallet, address: AztecAddress, log: LogFn) {
   await wallet.registerSender(address);
   log(`Sender registered: ${address}`);
 }

package/src/cmds/send.ts

@@ -1,62 +1,96 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, Contract, Fr } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
+import { Contract, NO_WAIT, type SendInteractionOptions } from '@aztec/aztec.js/contracts';
+import { type AztecNode, waitForTx } from '@aztec/aztec.js/node';
 import { prepTx } from '@aztec/cli/utils';
 import type { LogFn } from '@aztec/foundation/log';
-import { GasSettings } from '@aztec/stdlib/gas';
+import { TxStatus } from '@aztec/stdlib/tx';
 
-import { type IFeeOpts, printGasEstimates } from '../utils/options/fees.js';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import { CLIFeeArgs } from '../utils/options/fees.js';
+import { printProfileResult } from '../utils/profiling.js';
+import type { CLIWallet } from '../utils/wallet.js';
 
 export async function send(
-  wallet: AccountWalletWithSecretKey,
+  wallet: CLIWallet,
+  node: AztecNode,
+  from: AztecAddress,
   functionName: string,
   functionArgsIn: any[],
   contractArtifactPath: string,
   contractAddress: AztecAddress,
   wait: boolean,
   cancellable: boolean,
-  feeOpts: IFeeOpts,
+  feeOpts: CLIFeeArgs,
+  authWitnesses: AuthWitness[],
+  waitForStatus: TxStatus,
+  verbose: boolean,
   log: LogFn,
 ) {
   const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
 
-  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const contract = Contract.at(contractAddress, contractArtifact, wallet);
   const call = contract.methods[functionName](...functionArgs);
 
-  const gasLimits = await call.estimateGas({ ...(await feeOpts.toSendOpts(wallet)) });
-  printGasEstimates(feeOpts, gasLimits, log);
+  const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, from);
+  const sendOptions: SendInteractionOptions = {
+    fee: { paymentMethod, gasSettings },
+    from,
+    authWitnesses,
+  };
+
+  const localStart = performance.now();
+  const sim = await call.simulate({
+    ...sendOptions,
+    fee: { ...sendOptions.fee, estimateGas: true },
+  });
+  // estimateGas: true guarantees these fields are present
+  const estimatedGas = sim.estimatedGas!;
+  const stats = sim.stats!;
 
   if (feeOpts.estimateOnly) {
     return;
   }
 
-  const nonce = Fr.random();
-  const tx = call.send({ ...(await feeOpts.toSendOpts(wallet)), nonce, cancellable });
-  const txHash = await tx.getTxHash();
+  if (verbose) {
+    printProfileResult(stats!, log);
+  }
+
+  const { txHash } = await call.send({
+    ...sendOptions,
+    fee: { ...sendOptions.fee, gasSettings: estimatedGas },
+    wait: NO_WAIT,
+  });
+  const localTimeMs = performance.now() - localStart;
+
   log(`\nTransaction hash: ${txHash.toString()}`);
+
   if (wait) {
     try {
-      await tx.wait();
-
-      log('Transaction has been mined');
+      const nodeStart = performance.now();
+      const receipt = await waitForTx(node, txHash, { timeout: DEFAULT_TX_TIMEOUT_S, waitForStatus });
+      const nodeTimeMs = performance.now() - nodeStart;
 
-      const receipt = await tx.getReceipt();
+      const statusLabel = waitForStatus === TxStatus.PROPOSED ? 'proposed' : 'checkpointed';
+      log(`Transaction has been ${statusLabel}`);
       log(` Tx fee: ${receipt.transactionFee}`);
       log(` Status: ${receipt.status}`);
       log(` Block number: ${receipt.blockNumber}`);
       log(` Block hash: ${receipt.blockHash?.toString()}`);
+      log(` Local processing time: ${(localTimeMs / 1000).toFixed(1)}s`);
+      log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
+
+      return {
+        txHash,
+      };
     } catch (err: any) {
       log(`Transaction failed\n ${err.message}`);
+      throw err;
     }
   } else {
     log('Transaction pending. Check status with check-tx');
+    return {
+      txHash,
+    };
   }
-  const gasSettings = GasSettings.from({
-    ...feeOpts.gasSettings,
-    ...gasLimits,
-  });
-  return {
-    txHash,
-    nonce,
-    cancellable,
-    gasSettings,
-  };
 }

package/src/cmds/simulate.ts

@@ -1,42 +1,55 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, Contract, type ProfileResult } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { AuthWitness } from '@aztec/aztec.js/authorization';
+import { Contract } from '@aztec/aztec.js/contracts';
+import type { AztecNode } from '@aztec/aztec.js/node';
 import { prepTx } from '@aztec/cli/utils';
 import type { LogFn } from '@aztec/foundation/log';
 
 import { format } from 'util';
 
-function printProfileResult(result: ProfileResult, log: LogFn) {
-  log(format('\nSimulation result:'));
-  log(format('Return value:', JSON.stringify(result.returnValues, null, 2)));
-
-  log(format('\nGate count per circuit:'));
-  let acc = 0;
-  result.gateCounts.forEach(r => {
-    acc += r.gateCount;
-    log(format('  ', r.circuitName.padEnd(50), 'Gates:', r.gateCount.toLocaleString(), '\tAcc:', acc.toLocaleString()));
-  });
-
-  log(format('\nTotal gates:', acc.toLocaleString()));
-}
+import { printAuthorizations } from '../utils/authorizations.js';
+import type { CLIFeeArgs } from '../utils/options/fees.js';
+import { printProfileResult } from '../utils/profiling.js';
+import type { CLIWallet } from '../utils/wallet.js';
 
 export async function simulate(
-  wallet: AccountWalletWithSecretKey,
+  wallet: CLIWallet,
+  node: AztecNode,
+  from: AztecAddress,
   functionName: string,
   functionArgsIn: any[],
   contractArtifactPath: string,
   contractAddress: AztecAddress,
-  profile: boolean,
+  feeOpts: CLIFeeArgs,
+  authWitnesses: AuthWitness[],
+  verbose: boolean,
   log: LogFn,
 ) {
   const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
 
-  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const contract = Contract.at(contractAddress, contractArtifact, wallet);
   const call = contract.methods[functionName](...functionArgs);
-
-  if (profile) {
-    const result = await call.simulateWithProfile();
-    printProfileResult(result, log);
-  } else {
-    const result = await call.simulate();
-    log(format('\nSimulation result: ', result, '\n'));
+  const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, from);
+  const simulationResult = await call.simulate({
+    fee: { paymentMethod, gasSettings },
+    from,
+    authWitnesses,
+    includeMetadata: true,
+  });
+  if (verbose) {
+    await printAuthorizations(
+      simulationResult.offchainEffects,
+      async (address: AztecAddress) => {
+        const metadata = await wallet.getContractMetadata(address);
+        if (!metadata.instance) {
+          return undefined;
+        }
+        const artifact = await wallet.getContractArtifact(metadata.instance.currentContractClassId);
+        return artifact;
+      },
+      log,
+    );
+    printProfileResult(simulationResult.stats!, log);
   }
+  log(format('\nSimulation result: ', simulationResult.result, '\n'));
 }

package/src/storage/wallet_db.ts

@@ -1,22 +1,21 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasSettings } from '@aztec/stdlib/gas';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-import type { AccountType } from '../utils/accounts.js';
+import type { AccountType } from '../utils/constants.js';
 import { extractECDSAPublicKeyFromBase64String } from '../utils/ecdsa.js';
 
 export const Aliases = ['accounts', 'contracts', 'artifacts', 'secrets', 'transactions', 'authwits'] as const;
 export type AliasType = (typeof Aliases)[number];
 
 export class WalletDB {
+  #store!: AztecAsyncKVStore;
   #accounts!: AztecAsyncMap<string, Buffer>;
   #aliases!: AztecAsyncMap<string, Buffer>;
   #bridgedFeeJuice!: AztecAsyncMap<string, Buffer>;
-  #transactions!: AztecAsyncMap<string, Buffer>;
 
   private static instance: WalletDB;
 
@@ -31,10 +30,10 @@ export class WalletDB {
   }
 
   async init(store: AztecAsyncKVStore) {
+    this.#store = store;
     this.#accounts = store.openMap('accounts');
     this.#aliases = store.openMap('aliases');
     this.#bridgedFeeJuice = store.openMap('bridgedFeeJuice');
-    this.#transactions = store.openMap('transactions');
 
     await this.refreshAliasCache();
   }
@@ -44,14 +43,17 @@ export class WalletDB {
   }
 
   async pushBridgedFeeJuice(recipient: AztecAddress, secret: Fr, amount: bigint, leafIndex: bigint, log: LogFn) {
-    let stackPointer = (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
-    stackPointer++;
-    await this.#bridgedFeeJuice.set(
-      `${recipient.toString()}:${stackPointer}`,
-      Buffer.from(`${amount.toString()}:${secret.toString()}:${leafIndex.toString()}`),
-    );
-    await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([stackPointer]));
-    log(`Pushed ${amount} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    await this.#store.transactionAsync(async () => {
+      let stackPointer =
+        (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
+      stackPointer++;
+      await this.#bridgedFeeJuice.set(
+        `${recipient.toString()}:${stackPointer}`,
+        Buffer.from(`${amount.toString()}:${secret.toString()}:${leafIndex.toString()}`),
+      );
+      await this.#bridgedFeeJuice.set(`${recipient.toString()}:stackPointer`, Buffer.from([stackPointer]));
+      log(`Pushed ${amount} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    });
   }
 
   async popBridgedFeeJuice(recipient: AztecAddress, log: LogFn) {
@@ -68,6 +70,20 @@ export class WalletDB {
     return { amount: BigInt(amountStr), secret: secretStr, leafIndex: BigInt(leafIndexStr) };
   }
 
+  async peekBridgedFeeJuice(recipient: AztecAddress, log: LogFn) {
+    const stackPointer =
+      (await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:stackPointer`))?.readInt8() || 0;
+    const result = await this.#bridgedFeeJuice.getAsync(`${recipient.toString()}:${stackPointer}`);
+    if (!result) {
+      throw new Error(
+        `No stored fee juice available for recipient ${recipient.toString()}. Please provide claim amount and secret. Stack pointer ${stackPointer}`,
+      );
+    }
+    const [amountStr, secretStr, leafIndexStr] = result.toString().split(':');
+    log(`Peeked ${amountStr} fee juice for recipient ${recipient.toString()}. Stack pointer ${stackPointer}`);
+    return { amount: BigInt(amountStr), secret: secretStr, leafIndex: BigInt(leafIndexStr) };
+  }
+
   async storeAccount(
     address: AztecAddress,
     {
@@ -79,19 +95,24 @@ export class WalletDB {
     }: { type: AccountType; secretKey: Fr; salt: Fr; alias: string | undefined; publicKey: string | undefined },
     log: LogFn,
   ) {
-    if (alias) {
-      await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
-    }
-    await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type));
-    await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer());
-    await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer());
+    let publicSigningKey: Buffer | undefined;
     if (type === 'ecdsasecp256r1ssh' && publicKey) {
-      const publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
-      await this.storeAccountMetadata(address, 'publicSigningKey', publicSigningKey);
+      publicSigningKey = extractECDSAPublicKeyFromBase64String(publicKey);
     }
-    await this.#aliases.set('accounts:last', Buffer.from(address.toString()));
-    log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
 
+    await this.#store.transactionAsync(async () => {
+      if (alias) {
+        await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString()));
+      }
+      await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type));
+      await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer());
+      await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer());
+      if (publicSigningKey) {
+        await this.#accounts.set(`${address.toString()}:publicSigningKey`, publicSigningKey);
+      }
+      await this.#aliases.set('accounts:last', Buffer.from(address.toString()));
+    });
+    log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
     await this.refreshAliasCache();
   }
 
@@ -103,67 +124,45 @@ export class WalletDB {
   }
 
   async storeContract(address: AztecAddress, artifactPath: string, log: LogFn, alias?: string) {
-    if (alias) {
-      await this.#aliases.set(`contracts:${alias}`, Buffer.from(address.toString()));
-      await this.#aliases.set(`artifacts:${alias}`, Buffer.from(artifactPath));
-    }
-    await this.#aliases.set(`contracts:last`, Buffer.from(address.toString()));
-    await this.#aliases.set(`artifacts:last`, Buffer.from(artifactPath));
-    await this.#aliases.set(`artifacts:${address.toString()}`, Buffer.from(artifactPath));
+    await this.#store.transactionAsync(async () => {
+      if (alias) {
+        await this.#aliases.set(`contracts:${alias}`, Buffer.from(address.toString()));
+        await this.#aliases.set(`artifacts:${alias}`, Buffer.from(artifactPath));
+      }
+      await this.#aliases.set(`contracts:last`, Buffer.from(address.toString()));
+      await this.#aliases.set(`artifacts:last`, Buffer.from(artifactPath));
+      await this.#aliases.set(`artifacts:${address.toString()}`, Buffer.from(artifactPath));
+    });
     log(`Contract stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
-
     await this.refreshAliasCache();
   }
 
   async storeAuthwitness(authWit: AuthWitness, log: LogFn, alias?: string) {
-    if (alias) {
-      await this.#aliases.set(`authwits:${alias}`, Buffer.from(authWit.toString()));
-    }
-    await this.#aliases.set(`authwits:last`, Buffer.from(authWit.toString()));
+    await this.#store.transactionAsync(async () => {
+      if (alias) {
+        await this.#aliases.set(`authwits:${alias}`, Buffer.from(authWit.toString()));
+      }
+      await this.#aliases.set(`authwits:last`, Buffer.from(authWit.toString()));
+    });
     log(`Authorization witness stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
-
     await this.refreshAliasCache();
   }
 
-  async storeTx(
-    {
-      txHash,
-      nonce,
-      cancellable,
-      gasSettings,
-    }: { txHash: TxHash; nonce: Fr; cancellable: boolean; gasSettings: GasSettings },
-    log: LogFn,
-    alias?: string,
-  ) {
-    if (alias) {
-      await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
-    }
-    await this.#transactions.set(`${txHash.toString()}:nonce`, nonce.toBuffer());
-    await this.#transactions.set(`${txHash.toString()}:cancellable`, Buffer.from(cancellable ? 'true' : 'false'));
-    await this.#transactions.set(`${txHash.toString()}:gasSettings`, gasSettings.toBuffer());
-    await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
+  async storeTx({ txHash }: { txHash: TxHash }, log: LogFn, alias?: string) {
+    await this.#store.transactionAsync(async () => {
+      if (alias) {
+        await this.#aliases.set(`transactions:${alias}`, Buffer.from(txHash.toString()));
+      }
+      await this.#aliases.set(`transactions:last`, Buffer.from(txHash.toString()));
+    });
     log(`Transaction hash stored in database with alias${alias ? `es last & ${alias}` : ' last'}`);
-
     await this.refreshAliasCache();
   }
 
-  async retrieveTxData(txHash: TxHash) {
-    const nonceBuffer = await this.#transactions.getAsync(`${txHash.toString()}:nonce`);
-    if (!nonceBuffer) {
-      throw new Error(
-        `Could not find ${txHash.toString()}:nonce. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`,
-      );
-    }
-    const nonce = Fr.fromBuffer(nonceBuffer);
-    const cancellable = (await this.#transactions.getAsync(`${txHash.toString()}:cancellable`))!.toString() === 'true';
-    const gasBuffer = (await this.#transactions.getAsync(`${txHash.toString()}:gasSettings`))!;
-    return { txHash, nonce, cancellable, gasSettings: GasSettings.fromBuffer(gasBuffer) };
-  }
-
   tryRetrieveAlias(arg: string) {
     try {
       return this.retrieveAliasFromCache(arg);
-    } catch (e) {
+    } catch {
       return arg;
     }
   }

package/src/utils/authorizations.ts

@@ -0,0 +1,51 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { CallAuthorizationRequest } from '@aztec/aztec.js/authorization';
+import type { LogFn } from '@aztec/foundation/log';
+import { type AbiDecoded, decodeFromAbi, getFunctionArtifact } from '@aztec/stdlib/abi';
+import type { OffchainEffect } from '@aztec/stdlib/tx';
+
+import { format } from 'util';
+
+export async function printAuthorizations(
+  offchainEffects: OffchainEffect[],
+  artifactRetriever: (address: AztecAddress) => Promise<ContractArtifact | undefined>,
+  log: LogFn,
+) {
+  log(format('\nAuthorizations requested by the tx:\n'));
+  const callAuthorizationSelector = await CallAuthorizationRequest.getSelector();
+  const callAuthorizationEffects = offchainEffects.filter(effect =>
+    effect.data[0].equals(callAuthorizationSelector.toField()),
+  );
+  for (const callAuthorizationEffect of callAuthorizationEffects) {
+    const callAuthorizationRequest = await CallAuthorizationRequest.fromFields(callAuthorizationEffect.data);
+    const artifact = await artifactRetriever(callAuthorizationEffect.contractAddress);
+    if (!artifact) {
+      log(format(' -', `Call authorization. Inner hash: ${callAuthorizationRequest.innerHash.toString()}\n`));
+      log(format('  ', `Contract: unknown@${callAuthorizationEffect.contractAddress}`));
+      log(
+        format(
+          ' ',
+          `${callAuthorizationRequest.functionSelector.toString()}(\n${callAuthorizationRequest.args.map(arg => `    ${arg.toString()}`).join(',\n')}\n  )`,
+        ),
+      );
+    } else {
+      const functionAbi = await getFunctionArtifact(artifact, callAuthorizationRequest.functionSelector);
+      const callData = decodeFromAbi(
+        functionAbi.parameters.map(param => param.type),
+        callAuthorizationRequest.args,
+      ) as AbiDecoded[];
+      const parameters = functionAbi.parameters.map((param, i) => ({ name: param.name, value: callData[i] }));
+      log(format(' -', `Call authorization. Inner hash: ${callAuthorizationRequest.innerHash.toString()}`));
+      log(format('  ', `Contract: ${artifact.name}@${callAuthorizationEffect.contractAddress}`));
+      log(
+        format(
+          '  ',
+          /* eslint-disable-next-line @typescript-eslint/no-base-to-string */
+          `${functionAbi.name}(\n${parameters.map(p => `    ${p.name}: ${p.value}`).join(',\n')}\n  )`,
+        ),
+      );
+    }
+    log(`\n`);
+  }
+}

package/src/utils/cli_wallet_and_node_wrapper.ts

@@ -0,0 +1,35 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+import { CLIWallet } from './wallet.js';
+
+export const DEFAULT_TX_TIMEOUT_S = 180;
+
+/*
+ * Wrapper class for CLIWallet and AztecNode, avoids initialization issues due to closures when providing CLIWallet
+ * and AztecNode to injected commander.js commands
+ */
+export class CliWalletAndNodeWrapper {
+  private _wallet: CLIWallet | undefined;
+  private _node: AztecNode | undefined;
+
+  constructor() {}
+
+  get wallet() {
+    if (!this._wallet) {
+      throw new Error('Wallet not initialized while it should have been initialized in preSubcommand');
+    }
+    return this._wallet;
+  }
+
+  get node(): AztecNode {
+    if (!this._node) {
+      throw new Error('Node not initialized while it should have been initialized in preSubcommand');
+    }
+    return this._node;
+  }
+
+  setNodeAndWallet(node: AztecNode, wallet: CLIWallet) {
+    this._node = node;
+    this._wallet = wallet;
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,4 @@
+export const MIN_FEE_PADDING = 0.5;
+
+export const AccountTypes = ['schnorr', 'ecdsasecp256r1', 'ecdsasecp256r1ssh', 'ecdsasecp256k1'] as const;
+export type AccountType = (typeof AccountTypes)[number];