@aztec/cli-wallet 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/cmds/create_account.ts

@@ -1,24 +1,29 @@
-import { AztecAddress, type DeployAccountOptions, type PXE } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { DeployAccountOptions } from '@aztec/aztec.js/wallet';
 import { prettyPrintJSON } from '@aztec/cli/cli-utils';
 import { Fr } from '@aztec/foundation/fields';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
-import { type AccountType, createOrRetrieveAccount } from '../utils/accounts.js';
-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 { DEFAULT_TX_TIMEOUT_S } from '../utils/pxe_wrapper.js';
+import { type AccountType, CLIWallet } from '../utils/wallet.js';
 
 export async function createAccount(
-  client: PXE,
+  wallet: CLIWallet,
+  aztecNode: AztecNode,
   accountType: AccountType,
   secretKey: Fr | undefined,
   publicKey: string | undefined,
   alias: string | undefined,
+  deployer: AztecAddress | undefined,
   registerOnly: boolean,
-  publicDeploy: boolean,
   skipInitialization: boolean,
+  publicDeploy: boolean,
+  registerClass: boolean,
   wait: boolean,
-  feeOpts: IFeeOpts,
+  feeOpts: CLIFeeArgs,
   json: boolean,
   verbose: boolean,
   debugLogger: Logger,
@@ -26,10 +31,8 @@ export async function createAccount(
 ) {
   secretKey ??= Fr.random();
 
-  const account = await createOrRetrieveAccount(
-    client,
+  const account = await wallet.createOrRetrieveAccount(
     undefined /* address, we don't have it yet */,
-    undefined /* db, as we want to create from scratch */,
     secretKey,
     accountType,
     Fr.ZERO,
@@ -48,7 +51,6 @@ export async function createAccount(
     out.partialAddress = partialAddress;
     out.salt = salt;
     out.initHash = account.getInstance().initializationHash;
-    out.deployer = account.getInstance().deployer;
   } else {
     log(`\nNew account:\n`);
     log(`Address:         ${address.toString()}`);
@@ -59,68 +61,56 @@ export async function createAccount(
     log(`Partial address: ${partialAddress.toString()}`);
     log(`Salt:            ${salt.toString()}`);
     log(`Init hash:       ${account.getInstance().initializationHash.toString()}`);
-    log(`Deployer:        ${account.getInstance().deployer.toString()}`);
   }
 
   let tx;
   let txReceipt;
-  if (registerOnly) {
-    await account.register();
-  } else {
-    const wallet = await account.getWallet();
-    const deployOpts: DeployAccountOptions = {
-      skipClassPublication: !publicDeploy,
+  if (!registerOnly) {
+    const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(aztecNode, wallet, address);
+
+    const delegatedDeployment = deployer && !account.address.equals(deployer);
+    const from = delegatedDeployment ? deployer : AztecAddress.ZERO;
+
+    const deployAccountOpts: DeployAccountOptions = {
+      skipClassPublication: !registerClass,
       skipInstancePublication: !publicDeploy,
-      skipInitialization: skipInitialization,
-      ...(await feeOpts.toDeployAccountOpts(wallet)),
+      skipInitialization,
+      from,
+      fee: { paymentMethod, gasSettings },
     };
-    /*
-     * This is usually handled by accountManager.create(), but we're accessing the lower
-     * level method to get gas and timings. That means we have to replicate some of the logic here.
-     * In case we're initializing and/or publishing our own account, we need to hijack the payment method for the fee,
-     * wrapping it in the one that will make use of the freshly deployed account's
-     * entrypoint. For reference, see aztec.js/src/account_manager.ts:sendAccountContractSetupTx()
-     * Also, salt and universalDeploy have to be explicitly provided
-     */
-    deployOpts.fee =
-      !deployOpts?.deployWallet && deployOpts?.fee
-        ? { ...deployOpts.fee, paymentMethod: await account.getSelfPaymentMethod(deployOpts.fee.paymentMethod) }
-        : deployOpts?.fee;
 
-    const deployMethod = await account.getDeployMethod(deployOpts.deployWallet);
+    const deployMethod = await account.getDeployMethod();
+    const { estimatedGas, stats } = await deployMethod.simulate({
+      ...deployAccountOpts,
+      fee: { ...deployAccountOpts.fee, estimateGas: true },
+    });
 
     if (feeOpts.estimateOnly) {
-      const gas = await deployMethod.estimateGas({
-        ...deployOpts,
-        from: AztecAddress.ZERO,
-        universalDeploy: true,
-        contractAddressSalt: salt,
-      });
       if (json) {
         out.fee = {
           gasLimits: {
-            da: gas.gasLimits.daGas,
-            l2: gas.gasLimits.l2Gas,
+            da: estimatedGas.gasLimits.daGas,
+            l2: estimatedGas.gasLimits.l2Gas,
           },
           teardownGasLimits: {
-            da: gas.teardownGasLimits.daGas,
-            l2: gas.teardownGasLimits,
+            da: estimatedGas.teardownGasLimits.daGas,
+            l2: estimatedGas.teardownGasLimits,
           },
         };
-      } else {
-        printGasEstimates(feeOpts, gas, log);
       }
     } else {
-      const provenTx = await deployMethod.prove({
-        ...deployOpts,
-        from: AztecAddress.ZERO,
-        universalDeploy: true,
-        contractAddressSalt: salt,
+      tx = deployMethod.send({
+        ...deployAccountOpts,
+        fee: deployAccountOpts.fee
+          ? {
+              ...deployAccountOpts.fee,
+              gasSettings: estimatedGas,
+            }
+          : undefined,
       });
       if (verbose) {
-        printProfileResult(provenTx.stats!, log);
+        printProfileResult(stats, log);
       }
-      tx = provenTx.send();
 
       const txHash = await tx.getTxHash();
       debugLogger.debug(`Account contract tx sent with hash ${txHash.toString()}`);

package/src/cmds/create_authwit.ts

@@ -1,9 +1,13 @@
-import { type AccountWalletWithSecretKey, type AztecAddress, Contract } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Contract } from '@aztec/aztec.js/contracts';
 import { prepTx } from '@aztec/cli/utils';
 import type { LogFn } from '@aztec/foundation/log';
 
+import type { CLIWallet } from '../utils/wallet.js';
+
 export async function createAuthwit(
-  wallet: AccountWalletWithSecretKey,
+  wallet: CLIWallet,
+  from: AztecAddress,
   functionName: string,
   caller: AztecAddress,
   functionArgsIn: any[],
@@ -25,9 +29,9 @@ export async function createAuthwit(
   }
 
   const contract = await Contract.at(contractAddress, contractArtifact, wallet);
-  const action = contract.methods[functionName](...functionArgs);
+  const call = await contract.methods[functionName](...functionArgs).getFunctionCall();
 
-  const witness = await wallet.createAuthWit({ caller, action });
+  const witness = await wallet.createAuthWit(from, { caller, call });
 
   log(`Created authorization witness for action ${functionName} on contract ${contractAddress} for caller ${caller}`);
 

package/src/cmds/deploy.ts

@@ -1,22 +1,22 @@
-import {
-  type AccountWalletWithSecretKey,
-  AztecAddress,
-  ContractDeployer,
-  type DeployOptions,
-  Fr,
-} from '@aztec/aztec.js';
-import { encodeArgs, getContractArtifact } from '@aztec/cli/utils';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { DeployOptions } from '@aztec/aztec.js/contracts';
+import { ContractDeployer } from '@aztec/aztec.js/deployment';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { encodeArgs, getContractArtifact, prettyPrintJSON } from '@aztec/cli/utils';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { getAllFunctionAbis, getInitializer } from '@aztec/stdlib/abi';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-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 { DEFAULT_TX_TIMEOUT_S } from '../utils/pxe_wrapper.js';
+import type { CLIWallet } from '../utils/wallet.js';
 
 export async function deploy(
-  wallet: AccountWalletWithSecretKey,
-  deployer: AztecAddress | undefined,
+  wallet: CLIWallet,
+  node: AztecNode,
+  deployer: AztecAddress,
   artifactPath: string,
   json: boolean,
   publicKeys: PublicKeys | undefined,
@@ -27,13 +27,13 @@ export async function deploy(
   skipClassPublication: boolean,
   skipInitialization: boolean | undefined,
   wait: boolean,
-  feeOpts: IFeeOpts,
+  feeOpts: CLIFeeArgs,
   verbose: boolean,
   timeout: number = DEFAULT_TX_TIMEOUT_S,
   debugLogger: Logger,
   log: LogFn,
-  logJson: (output: any) => void,
 ) {
+  const out: Record<string, any> = {};
   salt ??= Fr.random();
   const contractArtifact = await getContractArtifact(artifactPath, log);
   const hasInitializer = getAllFunctionAbis(contractArtifact).some(fn => fn.isInitializer);
@@ -59,8 +59,9 @@ export async function deploy(
   }
 
   const deploy = contractDeployer.deploy(...args);
+  const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, deployer);
   const deployOpts: DeployOptions = {
-    ...(await feeOpts.toDeployAccountOpts(wallet)),
+    fee: { gasSettings, paymentMethod },
     from: deployer ?? AztecAddress.ZERO,
     contractAddressSalt: salt,
     universalDeploy: !deployer,
@@ -69,60 +70,61 @@ export async function deploy(
     skipInstancePublication,
   };
 
-  if (feeOpts.estimateOnly) {
-    const gas = await deploy.estimateGas(deployOpts);
-    printGasEstimates(feeOpts, gas, log);
-    return;
-  }
-
-  const provenTx = await deploy.prove(deployOpts);
-  if (verbose) {
-    printProfileResult(provenTx.stats!, log);
-  }
-
-  const tx = provenTx.send();
+  const { estimatedGas, stats } = await deploy.simulate({
+    ...deployOpts,
+    fee: { ...deployOpts.fee, estimateGas: true },
+  });
 
-  const txHash = await tx.getTxHash();
-  debugLogger.debug(`Deploy tx sent with hash ${txHash.toString()}`);
-  if (wait) {
-    const deployed = await tx.wait({ timeout });
-    const { address, partialAddress, instance } = deployed.contract;
+  if (feeOpts.estimateOnly) {
     if (json) {
-      logJson({
-        address: address.toString(),
-        partialAddress: (await partialAddress).toString(),
-        initializationHash: instance.initializationHash.toString(),
-        salt: salt.toString(),
-        transactionFee: deployed.transactionFee?.toString(),
-      });
-    } else {
-      log(`Contract deployed at ${address.toString()}`);
-      log(`Contract partial address ${(await partialAddress).toString()}`);
-      log(`Contract init hash ${instance.initializationHash.toString()}`);
-      log(`Deployment tx hash: ${txHash.toString()}`);
-      log(`Deployment salt: ${salt.toString()}`);
-      log(`Deployment fee: ${deployed.transactionFee}`);
+      out.fee = {
+        gasLimits: {
+          da: estimatedGas.gasLimits.daGas,
+          l2: estimatedGas.gasLimits.l2Gas,
+        },
+        teardownGasLimits: {
+          da: estimatedGas.teardownGasLimits.daGas,
+          l2: estimatedGas.teardownGasLimits,
+        },
+      };
     }
   } else {
+    const tx = deploy.send(deployOpts);
+    if (verbose) {
+      printProfileResult(stats, log);
+    }
+
+    const txHash = await tx.getTxHash();
+    debugLogger.debug(`Deploy tx sent with hash ${txHash.toString()}`);
+    out.hash = txHash;
     const { address, partialAddress } = deploy;
     const instance = await deploy.getInstance();
-    if (json) {
-      logJson({
-        address: address?.toString() ?? 'N/A',
-        partialAddress: (await partialAddress)?.toString() ?? 'N/A',
-        txHash: txHash.toString(),
-        initializationHash: instance.initializationHash.toString(),
-        salt: salt.toString(),
-        deployer: instance.deployer.toString(),
-      });
-    } else {
+    if (!json) {
       log(`Contract deployed at ${address?.toString()}`);
       log(`Contract partial address ${(await partialAddress)?.toString()}`);
       log(`Contract init hash ${instance.initializationHash.toString()}`);
       log(`Deployment tx hash: ${txHash.toString()}`);
       log(`Deployment salt: ${salt.toString()}`);
       log(`Deployer: ${instance.deployer.toString()}`);
+    } else {
+      out.contract = {
+        address: address?.toString(),
+        partialAddress: (await partialAddress)?.toString(),
+        initializationHash: instance.initializationHash.toString(),
+        salt: salt.toString(),
+      };
     }
+    if (wait) {
+      const deployed = await tx.wait({ timeout });
+      if (!json) {
+        log(`Transaction fee: ${deployed.transactionFee?.toString()}`);
+      } else {
+        out.contract.transactionFee = deployed.transactionFee?.toString();
+      }
+    }
+  }
+  if (json) {
+    log(prettyPrintJSON(out));
   }
   return deploy.address;
 }

package/src/cmds/deploy_account.ts

@@ -1,27 +1,34 @@
-import { type AccountManager, AztecAddress, type DeployAccountOptions } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { DeployAccountOptions } from '@aztec/aztec.js/wallet';
 import { prettyPrintJSON } from '@aztec/cli/cli-utils';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
-import { type IFeeOpts, printGasEstimates } from '../utils/options/fees.js';
+import { DEFAULT_TX_TIMEOUT_S } from '../utils/cli_wallet_and_node_wrapper.js';
+import type { CLIFeeArgs } from '../utils/options/fees.js';
 import { printProfileResult } from '../utils/profiling.js';
-import { DEFAULT_TX_TIMEOUT_S } from '../utils/pxe_wrapper.js';
+import type { CLIWallet } from '../utils/wallet.js';
 
 export async function deployAccount(
-  account: AccountManager,
+  wallet: CLIWallet,
+  aztecNode: AztecNode,
+  address: AztecAddress,
   wait: boolean,
+  deployer: AztecAddress | undefined,
   registerClass: boolean,
   publicDeploy: boolean,
-  feeOpts: IFeeOpts,
+  skipInitialization: boolean,
+  feeOpts: CLIFeeArgs,
   json: boolean,
   verbose: boolean,
   debugLogger: Logger,
   log: LogFn,
 ) {
   const out: Record<string, any> = {};
-  const { address, partialAddress, publicKeys } = await account.getCompleteAddress();
-  const { initializationHash, deployer, salt } = account.getInstance();
-  const wallet = await account.getWallet();
-  const secretKey = wallet.getSecretKey();
+
+  const account = await wallet.createOrRetrieveAccount(address);
+  const { partialAddress, publicKeys } = await account.getCompleteAddress();
+  const { initializationHash, salt } = account.getInstance();
 
   if (json) {
     out.address = address;
@@ -33,71 +40,58 @@ export async function deployAccount(
     log(`\nNew account:\n`);
     log(`Address:         ${address.toString()}`);
     log(`Public key:      ${publicKeys.toString()}`);
-    if (secretKey) {
-      log(`Secret key:     ${secretKey.toString()}`);
-    }
     log(`Partial address: ${partialAddress.toString()}`);
     log(`Salt:            ${salt.toString()}`);
     log(`Init hash:       ${initializationHash.toString()}`);
-    log(`Deployer:        ${deployer.toString()}`);
   }
 
   let tx;
   let txReceipt;
+  const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(aztecNode, wallet, address);
 
-  const deployOpts: DeployAccountOptions = {
-    skipInstancePublication: !publicDeploy,
+  const delegatedDeployment = deployer && !account.address.equals(deployer);
+  const from = delegatedDeployment ? deployer : AztecAddress.ZERO;
+
+  const deployAccountOpts: DeployAccountOptions = {
     skipClassPublication: !registerClass,
-    ...(await feeOpts.toDeployAccountOpts(wallet)),
+    skipInstancePublication: !publicDeploy,
+    skipInitialization,
+    from,
+    fee: { paymentMethod, gasSettings },
   };
 
-  /*
-   * This is usually handled by accountManager.deploy(), but we're accessing the lower
-   * level method to get gas and timings. That means we have to replicate some of the logic here.
-   * In case we're deploying our own account, we need to hijack the payment method for the fee,
-   * wrapping it in the one that will make use of the freshly deployed account's
-   * entrypoint. For reference, see aztec.js/src/account_manager.ts:deploy()
-   * Also, salt and universalDeploy have to be explicitly provided
-   */
-  deployOpts.fee =
-    !deployOpts?.deployWallet && deployOpts?.fee
-      ? { ...deployOpts.fee, paymentMethod: await account.getSelfPaymentMethod(deployOpts.fee.paymentMethod) }
-      : deployOpts?.fee;
-
-  const deployMethod = await account.getDeployMethod(deployOpts.deployWallet);
+  const deployMethod = await account.getDeployMethod();
+  const { estimatedGas, stats } = await deployMethod.simulate({
+    ...deployAccountOpts,
+    fee: { ...deployAccountOpts.fee, estimateGas: true },
+  });
 
   if (feeOpts.estimateOnly) {
-    const gas = await deployMethod.estimateGas({
-      ...deployOpts,
-      from: AztecAddress.ZERO,
-      universalDeploy: true,
-      contractAddressSalt: salt,
-    });
     if (json) {
       out.fee = {
         gasLimits: {
-          da: gas.gasLimits.daGas,
-          l2: gas.gasLimits.l2Gas,
+          da: estimatedGas.gasLimits.daGas,
+          l2: estimatedGas.gasLimits.l2Gas,
         },
         teardownGasLimits: {
-          da: gas.teardownGasLimits.daGas,
-          l2: gas.teardownGasLimits,
+          da: estimatedGas.teardownGasLimits.daGas,
+          l2: estimatedGas.teardownGasLimits,
         },
       };
-    } else {
-      printGasEstimates(feeOpts, gas, log);
     }
   } else {
-    const provenTx = await deployMethod.prove({
-      ...deployOpts,
-      from: AztecAddress.ZERO,
-      universalDeploy: true,
-      contractAddressSalt: salt,
+    tx = deployMethod.send({
+      ...deployAccountOpts,
+      fee: deployAccountOpts.fee
+        ? {
+            ...deployAccountOpts.fee,
+            gasSettings: estimatedGas,
+          }
+        : undefined,
     });
     if (verbose) {
-      printProfileResult(provenTx.stats!, log);
+      printProfileResult(stats, log);
     }
-    tx = provenTx.send();
 
     const txHash = await tx.getTxHash();
     debugLogger.debug(`Account contract tx sent with hash ${txHash.toString()}`);
@@ -124,6 +118,4 @@ export async function deployAccount(
       log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
     }
   }
-
-  return { address, secretKey, salt };
 }

package/src/cmds/import_test_accounts.ts

@@ -1,25 +1,21 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { Fr, type PXE } from '@aztec/aztec.js';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { Fr } from '@aztec/aztec.js/fields';
 import { prettyPrintJSON } from '@aztec/cli/cli-utils';
 import type { LogFn } from '@aztec/foundation/log';
 
 import type { WalletDB } from '../storage/wallet_db.js';
+import type { CLIWallet } from '../utils/wallet.js';
 
-export async function importTestAccounts(client: PXE, db: WalletDB, json: boolean, log: LogFn) {
-  const testAccounts = await getInitialTestAccounts();
-  const accounts = await Promise.all(
-    testAccounts.map(({ secret, signingKey, salt }) => getSchnorrAccount(client, secret, signingKey, salt)),
-  );
+export async function importTestAccounts(wallet: CLIWallet, db: WalletDB, json: boolean, log: LogFn) {
+  const testAccounts = await getInitialTestAccountsData();
 
   const out: Record<string, any> = {};
   await Promise.all(
-    accounts.map(async (account, i) => {
+    testAccounts.map(async (account, i) => {
       const alias = `test${i}`;
       const secret = testAccounts[i].secret;
       const salt = new Fr(account.salt);
-      const address = account.getAddress();
-      await account.register();
+      const address = account.address;
       await db.storeAccount(address, { type: 'schnorr', secretKey: secret, salt, alias, publicKey: undefined }, log);
 
       if (json) {