@aztec/cli-wallet 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/cmds/bridge_fee_juice.ts

@@ -0,0 +1,88 @@
+import { L1FeeJuicePortalManager, type PXE } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/utils';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr } from '@aztec/foundation/fields';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+export async function bridgeL1FeeJuice(
+  amount: bigint,
+  recipient: AztecAddress,
+  pxe: PXE,
+  l1RpcUrl: string,
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mint: boolean,
+  json: boolean,
+  wait: boolean,
+  interval = 60_000,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  // Prepare L1 client
+  const chain = createEthereumChain(l1RpcUrl, chainId);
+  const { publicClient, walletClient } = createL1Clients(chain.rpcUrl, privateKey ?? mnemonic, chain.chainInfo);
+
+  const {
+    protocolContractAddresses: { feeJuice: feeJuiceAddress },
+  } = await pxe.getPXEInfo();
+
+  // Setup portal manager
+  const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, debugLogger);
+  const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic(
+    recipient,
+    amount,
+    mint,
+  );
+
+  if (json) {
+    const out = {
+      claimAmount,
+      claimSecret,
+      messageLeafIndex,
+    };
+    log(prettyPrintJSON(out));
+  } else {
+    if (mint) {
+      log(`Minted ${claimAmount} fee juice on L1 and pushed to L2 portal`);
+    } else {
+      log(`Bridged ${claimAmount} fee juice to L2 portal`);
+    }
+    log(
+      `claimAmount=${claimAmount},claimSecret=${claimSecret},messageHash=${messageHash},messageLeafIndex=${messageLeafIndex}\n`,
+    );
+    log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+    if (wait) {
+      log(
+        `This command will now continually poll every ${
+          interval / 1000
+        }s for the inclusion of the newly created L1 to L2 message`,
+      );
+    }
+  }
+
+  if (wait) {
+    const delayedCheck = (delay: number) => {
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          void pxe
+            .getL1ToL2MembershipWitness(feeJuiceAddress, Fr.fromHexString(messageHash), claimSecret)
+            .then(witness => resolve(witness))
+            .catch(err => reject(err));
+        }, delay);
+      });
+    };
+
+    let witness;
+
+    while (!witness) {
+      witness = await delayedCheck(interval);
+      if (!witness) {
+        log(`No L1 to L2 message found yet, checking again in ${interval / 1000}s`);
+      }
+    }
+  }
+
+  return [claimSecret, messageLeafIndex] as const;
+}

package/src/cmds/cancel_tx.ts

@@ -0,0 +1,61 @@
+import { type AccountWalletWithSecretKey, type FeePaymentMethod, SentTx, type TxHash, TxStatus } from '@aztec/aztec.js';
+import { type FeeOptions } from '@aztec/aztec.js/entrypoint';
+import { type Fr, GasFees, GasSettings } from '@aztec/circuits.js';
+import { type LogFn } from '@aztec/foundation/log';
+
+export async function cancelTx(
+  wallet: AccountWalletWithSecretKey,
+  {
+    txHash,
+    gasSettings: prevTxGasSettings,
+    nonce,
+    cancellable,
+  }: { txHash: TxHash; gasSettings: GasSettings; nonce: Fr; cancellable: boolean },
+  paymentMethod: FeePaymentMethod,
+  increasedFees: GasFees,
+  maxFeesPerGas: GasFees | undefined,
+  log: LogFn,
+) {
+  const receipt = await wallet.getTxReceipt(txHash);
+  if (receipt.status !== TxStatus.PENDING || !cancellable) {
+    log(`Transaction is in status ${receipt.status} and cannot be cancelled`);
+    return;
+  }
+
+  const maxPriorityFeesPerGas = new GasFees(
+    prevTxGasSettings.maxPriorityFeesPerGas.feePerDaGas.add(increasedFees.feePerDaGas),
+    prevTxGasSettings.maxPriorityFeesPerGas.feePerL2Gas.add(increasedFees.feePerL2Gas),
+  );
+
+  const fee: FeeOptions = {
+    paymentMethod,
+    gasSettings: GasSettings.from({
+      ...prevTxGasSettings,
+      maxPriorityFeesPerGas,
+      maxFeesPerGas: maxFeesPerGas ?? prevTxGasSettings.maxFeesPerGas,
+    }),
+  };
+
+  const txRequest = await wallet.createTxExecutionRequest({
+    calls: [],
+    fee,
+    nonce,
+    cancellable: true,
+  });
+  const txSimulationResult = await wallet.simulateTx(txRequest, true);
+  const txProvingResult = await wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
+  const sentTx = new SentTx(wallet, wallet.sendTx(txProvingResult.toTx()));
+  try {
+    await sentTx.wait();
+
+    log('Transaction has been cancelled');
+
+    const cancelReceipt = await sentTx.getReceipt();
+    log(` Tx fee: ${cancelReceipt.transactionFee}`);
+    log(` Status: ${cancelReceipt.status}`);
+    log(` Block number: ${cancelReceipt.blockNumber}`);
+    log(` Block hash: ${cancelReceipt.blockHash?.toString()}`);
+  } catch (err: any) {
+    log(`Could not cancel transaction\n ${err.message}`);
+  }
+}

package/src/cmds/check_tx.ts

@@ -0,0 +1,12 @@
+import { type PXE, type TxHash } from '@aztec/aztec.js';
+import { inspectTx } from '@aztec/cli/inspect';
+import { type LogFn } from '@aztec/foundation/log';
+
+export async function checkTx(client: PXE, txHash: TxHash, statusOnly: boolean, log: LogFn) {
+  if (statusOnly) {
+    const receipt = await client.getTxReceipt(txHash);
+    return receipt.status;
+  } else {
+    await inspectTx(client, txHash, log, { includeBlockInfo: true });
+  }
+}

package/src/cmds/create_account.ts

@@ -0,0 +1,120 @@
+import { type DeployAccountOptions, type PXE } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import { Fr } from '@aztec/foundation/fields';
+import { type LogFn, type 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:      0x${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 sendOpts: DeployAccountOptions = {
+      ...(await feeOpts.toSendOpts(wallet)),
+      skipClassRegistration: !publicDeploy,
+      skipPublicDeployment: !publicDeploy,
+      skipInitialization: skipInitialization,
+    };
+    if (feeOpts.estimateOnly) {
+      const gas = await (await account.getDeployMethod()).estimateGas({ ...sendOpts });
+      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({ ...sendOpts });
+      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 { PublicKeys } from '@aztec/circuits.js';
+import { GITHUB_TAG_PREFIX, encodeArgs, getContractArtifact } from '@aztec/cli/utils';
+import { getInitializer } from '@aztec/foundation/abi';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+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: partialAddress.toString(),
+        initializationHash: instance.initializationHash.toString(),
+        salt: salt.toString(),
+        transactionFee: deployed.transactionFee?.toString(),
+      });
+    } else {
+      log(`Contract deployed at ${address.toString()}`);
+      log(`Contract partial address ${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: 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 ${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, type DeployAccountOptions } from '@aztec/aztec.js';
+import { prettyPrintJSON } from '@aztec/cli/cli-utils';
+import { type LogFn, type 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:      0x${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 sendOpts: DeployAccountOptions = {
+    ...(await feeOpts.toSendOpts(wallet)),
+    skipInitialization: false,
+  };
+  if (feeOpts.estimateOnly) {
+    const gas = await (await account.getDeployMethod()).estimateGas({ ...sendOpts });
+    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({ ...sendOpts });
+    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 };
+}