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

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 = await 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,19 +1,28 @@
-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, type SendInteractionOptions } 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 { GasSettings } from '@aztec/stdlib/gas';
 
-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[],
+  verbose: boolean,
   log: LogFn,
 ) {
   const { functionArgs, contractArtifact } = await prepTx(contractArtifactPath, functionName, functionArgsIn, log);
@@ -21,20 +30,32 @@ export async function send(
   const contract = await 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 { estimatedGas, stats } = await call.simulate({
+    ...sendOptions,
+    fee: { ...sendOptions.fee, estimateGas: true },
+  });
 
   if (feeOpts.estimateOnly) {
     return;
   }
 
-  const nonce = Fr.random();
-  const tx = call.send({ ...(await feeOpts.toSendOpts(wallet)), nonce, cancellable });
+  const tx = call.send({ ...sendOptions, fee: { ...sendOptions.fee, gasSettings: estimatedGas } });
+  if (verbose) {
+    printProfileResult(stats!, log);
+  }
+
   const txHash = await tx.getTxHash();
   log(`\nTransaction hash: ${txHash.toString()}`);
   if (wait) {
     try {
-      await tx.wait();
+      await tx.wait({ timeout: DEFAULT_TX_TIMEOUT_S });
 
       log('Transaction has been mined');
 
@@ -49,14 +70,7 @@ export async function send(
   } else {
     log('Transaction pending. Check status with check-tx');
   }
-  const gasSettings = GasSettings.from({
-    ...feeOpts.gasSettings,
-    ...gasLimits,
-  });
   return {
     txHash,
-    nonce,
-    cancellable,
-    gasSettings,
   };
 }

package/src/cmds/simulate.ts

@@ -1,42 +1,58 @@
-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 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.contractInstance) {
+          return undefined;
+        }
+        const classMetadata = await wallet.getContractClassMetadata(
+          metadata.contractInstance.currentContractClassId,
+          true,
+        );
+        return classMetadata.artifact;
+      },
+      log,
+    );
+    printProfileResult(simulationResult.stats!, log);
   }
+  log(format('\nSimulation result: ', simulationResult.result, '\n'));
 }

package/src/storage/wallet_db.ts

@@ -3,11 +3,10 @@ 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 { extractECDSAPublicKeyFromBase64String } from '../utils/ecdsa.js';
+import type { AccountType } from '../utils/wallet.js';
 
 export const Aliases = ['accounts', 'contracts', 'artifacts', 'secrets', 'transactions', 'authwits'] as const;
 export type AliasType = (typeof Aliases)[number];
@@ -16,7 +15,6 @@ export class WalletDB {
   #accounts!: AztecAsyncMap<string, Buffer>;
   #aliases!: AztecAsyncMap<string, Buffer>;
   #bridgedFeeJuice!: AztecAsyncMap<string, Buffer>;
-  #transactions!: AztecAsyncMap<string, Buffer>;
 
   private static instance: WalletDB;
 
@@ -34,7 +32,6 @@ export class WalletDB {
     this.#accounts = store.openMap('accounts');
     this.#aliases = store.openMap('aliases');
     this.#bridgedFeeJuice = store.openMap('bridgedFeeJuice');
-    this.#transactions = store.openMap('transactions');
 
     await this.refreshAliasCache();
   }
@@ -125,45 +122,20 @@ export class WalletDB {
     await this.refreshAliasCache();
   }
 
-  async storeTx(
-    {
-      txHash,
-      nonce,
-      cancellable,
-      gasSettings,
-    }: { txHash: TxHash; nonce: Fr; cancellable: boolean; gasSettings: GasSettings },
-    log: LogFn,
-    alias?: string,
-  ) {
+  async storeTx({ txHash }: { txHash: TxHash }, 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()));
     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() {
+    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;
+  }
+}