@aztec/cli-wallet 0.0.0-test.0

package/src/cmds/create_account.ts

@@ -0,0 +1,120 @@
+import type { DeployAccountOptions, PXE } from '@aztec/aztec.js';
+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';
+
+export async function createAccount(
+  client: PXE,
+  accountType: AccountType,
+  secretKey: Fr | undefined,
+  publicKey: string | undefined,
+  alias: string | undefined,
+  registerOnly: boolean,
+  publicDeploy: boolean,
+  skipInitialization: boolean,
+  wait: boolean,
+  feeOpts: IFeeOpts,
+  json: boolean,
+  debugLogger: Logger,
+  log: LogFn,
+) {
+  secretKey ??= Fr.random();
+
+  const account = await createOrRetrieveAccount(
+    client,
+    undefined /* address, we don't have it yet */,
+    undefined /* db, as we want to create from scratch */,
+    secretKey,
+    accountType,
+    Fr.ZERO,
+    publicKey,
+  );
+  const salt = account.getInstance().salt;
+  const { address, publicKeys, partialAddress } = await account.getCompleteAddress();
+
+  const out: Record<string, any> = {};
+  if (json) {
+    out.address = address;
+    out.publicKey = publicKeys;
+    if (secretKey) {
+      out.secretKey = secretKey;
+    }
+    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()}`);
+    log(`Public key:      ${publicKeys.toString()}`);
+    if (secretKey) {
+      log(`Secret key:     ${secretKey.toString()}`);
+    }
+    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 = {
+      skipClassRegistration: !publicDeploy,
+      skipPublicDeployment: !publicDeploy,
+      skipInitialization: skipInitialization,
+      ...(await feeOpts.toDeployAccountOpts(wallet)),
+    };
+    if (feeOpts.estimateOnly) {
+      const gas = await (await account.getDeployMethod(deployOpts.deployWallet)).estimateGas(deployOpts);
+      if (json) {
+        out.fee = {
+          gasLimits: {
+            da: gas.gasLimits.daGas,
+            l2: gas.gasLimits.l2Gas,
+          },
+          teardownGasLimits: {
+            da: gas.teardownGasLimits.daGas,
+            l2: gas.teardownGasLimits,
+          },
+        };
+      } else {
+        printGasEstimates(feeOpts, gas, log);
+      }
+    } else {
+      tx = account.deploy(deployOpts);
+      const txHash = await tx.getTxHash();
+      debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
+      out.txHash = txHash;
+      if (wait) {
+        if (!json) {
+          log(`\nWaiting for account contract deployment...`);
+        }
+        txReceipt = await tx.wait();
+        out.txReceipt = {
+          status: txReceipt.status,
+          transactionFee: txReceipt.transactionFee,
+        };
+      }
+    }
+  }
+
+  if (json) {
+    log(prettyPrintJSON(out));
+  } else {
+    if (tx) {
+      log(`Deploy tx hash:  ${await tx.getTxHash()}`);
+    }
+    if (txReceipt) {
+      log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+    }
+  }
+
+  return { alias, address, secretKey, salt };
+}

package/src/cmds/create_authwit.ts

@@ -0,0 +1,35 @@
+import { type AccountWalletWithSecretKey, type AztecAddress, Contract } from '@aztec/aztec.js';
+import { prepTx } from '@aztec/cli/utils';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function createAuthwit(
+  wallet: AccountWalletWithSecretKey,
+  functionName: string,
+  caller: AztecAddress,
+  functionArgsIn: any[],
+  contractArtifactPath: string,
+  contractAddress: AztecAddress,
+  log: LogFn,
+) {
+  const { functionArgs, contractArtifact, isPrivate } = await prepTx(
+    contractArtifactPath,
+    functionName,
+    functionArgsIn,
+    log,
+  );
+
+  if (!isPrivate) {
+    throw new Error(
+      'Cannot create an authwit for a public function. To allow a third party to call a public function, please authorize the action via the authorize-action command',
+    );
+  }
+
+  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
+  const action = contract.methods[functionName](...functionArgs);
+
+  const witness = await wallet.createAuthWit({ caller, action });
+
+  log(`Created authorization witness for action ${functionName} on contract ${contractAddress} for caller ${caller}`);
+
+  return witness;
+}

package/src/cmds/deploy.ts

@@ -0,0 +1,113 @@
+import { type AccountWalletWithSecretKey, ContractDeployer, type DeployMethod, Fr, type PXE } from '@aztec/aztec.js';
+import { GITHUB_TAG_PREFIX, encodeArgs, getContractArtifact } from '@aztec/cli/utils';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { getInitializer } from '@aztec/stdlib/abi';
+import { PublicKeys } from '@aztec/stdlib/keys';
+
+import { type IFeeOpts, printGasEstimates } from '../utils/options/fees.js';
+
+export async function deploy(
+  client: PXE,
+  wallet: AccountWalletWithSecretKey,
+  artifactPath: string,
+  json: boolean,
+  publicKeys: PublicKeys | undefined,
+  rawArgs: any[],
+  salt: Fr | undefined,
+  initializer: string | undefined,
+  skipPublicDeployment: boolean,
+  skipClassRegistration: boolean,
+  skipInitialization: boolean | undefined,
+  universalDeploy: boolean | undefined,
+  wait: boolean,
+  feeOpts: IFeeOpts,
+  debugLogger: Logger,
+  log: LogFn,
+  logJson: (output: any) => void,
+) {
+  salt ??= Fr.random();
+  const contractArtifact = await getContractArtifact(artifactPath, log);
+  const constructorArtifact = getInitializer(contractArtifact, initializer);
+
+  const nodeInfo = await client.getNodeInfo();
+  const expectedAztecNrVersion = `${GITHUB_TAG_PREFIX}-v${nodeInfo.nodeVersion}`;
+  if (contractArtifact.aztecNrVersion && contractArtifact.aztecNrVersion !== expectedAztecNrVersion) {
+    log(
+      `\nWarning: Contract was compiled with a different version of Aztec.nr: ${contractArtifact.aztecNrVersion}. Consider updating Aztec.nr to ${expectedAztecNrVersion}\n`,
+    );
+  }
+
+  const deployer = new ContractDeployer(contractArtifact, wallet, publicKeys ?? PublicKeys.default(), initializer);
+
+  let args = [];
+  if (rawArgs.length > 0) {
+    if (!constructorArtifact) {
+      throw new Error(`Cannot process constructor arguments as no constructor was found`);
+    }
+    debugLogger.debug(`Input arguments: ${rawArgs.map((x: any) => `"${x}"`).join(', ')}`);
+    args = encodeArgs(rawArgs, constructorArtifact!.parameters);
+    debugLogger.debug(`Encoded arguments: ${args.join(', ')}`);
+  }
+
+  const deploy = deployer.deploy(...args);
+  const deployOpts: Parameters<DeployMethod['send']>[0] = {
+    ...(await feeOpts.toSendOpts(wallet)),
+    contractAddressSalt: salt,
+    universalDeploy,
+    skipClassRegistration,
+    skipInitialization,
+    skipPublicDeployment,
+  };
+
+  if (feeOpts.estimateOnly) {
+    const gas = await deploy.estimateGas(deployOpts);
+    printGasEstimates(feeOpts, gas, log);
+    return;
+  }
+
+  const tx = deploy.send(deployOpts);
+
+  const txHash = await tx.getTxHash();
+  debugLogger.debug(`Deploy tx sent with hash ${txHash}`);
+  if (wait) {
+    const deployed = await tx.wait();
+    const { address, partialAddress, instance } = deployed.contract;
+    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}`);
+    }
+  } else {
+    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 {
+      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()}`);
+    }
+  }
+  return deploy.address;
+}

package/src/cmds/deploy_account.ts

@@ -0,0 +1,92 @@
+import type { AccountManager, DeployAccountOptions } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { type IFeeOpts, printGasEstimates } from '../utils/options/fees.js';
+
+export async function deployAccount(
+  account: AccountManager,
+  wait: boolean,
+  feeOpts: IFeeOpts,
+  json: 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();
+
+  if (json) {
+    out.address = address;
+    out.partialAddress = partialAddress;
+    out.salt = salt;
+    out.initHash = initializationHash;
+    out.deployer = deployer;
+  } else {
+    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 deployOpts: DeployAccountOptions = {
+    ...(await feeOpts.toDeployAccountOpts(wallet)),
+    skipInitialization: false,
+  };
+  if (feeOpts.estimateOnly) {
+    const gas = await (await account.getDeployMethod(deployOpts.deployWallet)).estimateGas(deployOpts);
+    if (json) {
+      out.fee = {
+        gasLimits: {
+          da: gas.gasLimits.daGas,
+          l2: gas.gasLimits.l2Gas,
+        },
+        teardownGasLimits: {
+          da: gas.teardownGasLimits.daGas,
+          l2: gas.teardownGasLimits,
+        },
+      };
+    } else {
+      printGasEstimates(feeOpts, gas, log);
+    }
+  } else {
+    tx = account.deploy(deployOpts);
+    const txHash = await tx.getTxHash();
+    debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
+    out.txHash = txHash;
+    if (wait) {
+      if (!json) {
+        log(`\nWaiting for account contract deployment...`);
+      }
+      txReceipt = await tx.wait();
+      out.txReceipt = {
+        status: txReceipt.status,
+        transactionFee: txReceipt.transactionFee,
+      };
+    }
+  }
+
+  if (json) {
+    log(prettyPrintJSON(out));
+  } else {
+    if (tx) {
+      log(`Deploy tx hash:  ${await tx.getTxHash()}`);
+    }
+    if (txReceipt) {
+      log(`Deploy tx fee:   ${txReceipt.transactionFee}`);
+    }
+  }
+
+  return { address, secretKey, salt };
+}

package/src/cmds/import_test_accounts.ts

@@ -0,0 +1,47 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { Fr, type PXE } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import type { LogFn } from '@aztec/foundation/log';
+
+import type { WalletDB } from '../storage/wallet_db.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)),
+  );
+
+  const out: Record<string, any> = {};
+  await Promise.all(
+    accounts.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();
+      await db.storeAccount(address, { type: 'schnorr', secretKey: secret, salt, alias, publicKey: undefined }, log);
+
+      if (json) {
+        out[alias] = {
+          alias,
+          address,
+          secret,
+          salt,
+        };
+      } else {
+        log(`\nTest account:`);
+        log(`Alias:           ${alias}`);
+        log(`Address:         ${address}`);
+        log(`Secret key:      ${secret}`);
+        log(`Salt:            ${salt}`);
+      }
+    }),
+  );
+
+  if (json) {
+    log(prettyPrintJSON(out));
+  } else {
+    log(`\n${testAccounts.length} test accounts imported to wallet db.\n`);
+  }
+}