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

package/src/cmds/check_tx.ts

@@ -1,12 +1,188 @@
-import type { PXE, TxHash } from '@aztec/aztec.js';
-import { inspectTx } from '@aztec/cli/inspect';
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { ProtocolContractAddress } from '@aztec/aztec.js/protocol';
+import type { TxHash } from '@aztec/aztec.js/tx';
 import type { LogFn } from '@aztec/foundation/log';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import { NoteDao } from '@aztec/stdlib/note';
 
-export async function checkTx(client: PXE, txHash: TxHash, statusOnly: boolean, log: LogFn) {
+import type { CLIWallet } from '../utils/wallet.js';
+
+export async function checkTx(
+  wallet: CLIWallet,
+  aztecNode: AztecNode,
+  txHash: TxHash,
+  statusOnly: boolean,
+  log: LogFn,
+) {
   if (statusOnly) {
-    const receipt = await client.getTxReceipt(txHash);
+    const receipt = await aztecNode.getTxReceipt(txHash);
     return receipt.status;
   } else {
-    await inspectTx(client, txHash, log, { includeBlockInfo: true });
+    await inspectTx(wallet, aztecNode, txHash, log);
+  }
+}
+
+// The rest of the code here was copied over here from CLI because in CLI I needed to prune the inspect function of the PXE
+// dependency when dropping PXE JSON RPC Server.
+
+async function inspectTx(wallet: CLIWallet, aztecNode: AztecNode, txHash: TxHash, log: LogFn) {
+  const [receipt, effectsInBlock] = await Promise.all([aztecNode.getTxReceipt(txHash), aztecNode.getTxEffect(txHash)]);
+  // Base tx data
+  log(`Tx ${txHash.toString()}`);
+  log(` Status: ${receipt.status} ${effectsInBlock ? `(${effectsInBlock.data.revertCode.getDescription()})` : ''}`);
+  if (receipt.error) {
+    log(` Error: ${receipt.error}`);
+  }
+
+  if (!effectsInBlock) {
+    return;
+  }
+
+  const effects = effectsInBlock.data;
+  const artifactMap = await getKnownArtifacts(wallet);
+
+  log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);
+  if (receipt.transactionFee) {
+    log(` Fee: ${receipt.transactionFee.toString()}`);
+  }
+
+  // Public logs
+  const publicLogs = effects.publicLogs;
+  if (publicLogs.length > 0) {
+    log(' Logs:');
+    for (const publicLog of publicLogs) {
+      log(`  ${publicLog.toHumanReadable()}`);
+    }
+  }
+
+  // Public data writes
+  const writes = effects.publicDataWrites;
+  if (writes.length > 0) {
+    log(' Public data writes:');
+    for (const write of writes) {
+      log(`  Leaf ${write.leafSlot.toString()} = ${write.value.toString()}`);
+    }
+  }
+
+  // Created notes
+  const notes = effects.noteHashes;
+  if (notes.length > 0) {
+    log(' Created notes:');
+    log(`  Total: ${notes.length}`);
+    for (const note of notes) {
+      log(`  Note hash: ${note.toShortString()}`);
+    }
+  }
+
+  // Nullifiers
+  const nullifierCount = effects.nullifiers.length;
+  const { deployNullifiers, initNullifiers, classNullifiers } = await getKnownNullifiers(wallet, artifactMap);
+  if (nullifierCount > 0) {
+    log(' Nullifiers:');
+    for (const nullifier of effects.nullifiers) {
+      const deployed = deployNullifiers[nullifier.toString()];
+      const note = deployed
+        ? (await wallet.getNotes({ siloedNullifier: nullifier, contractAddress: deployed }))[0]
+        : undefined;
+      const initialized = initNullifiers[nullifier.toString()];
+      const registered = classNullifiers[nullifier.toString()];
+      if (nullifier.toBuffer().equals(txHash.toBuffer())) {
+        log(`  Transaction hash nullifier ${nullifier.toShortString()}`);
+      } else if (note) {
+        inspectNote(note, artifactMap, log, `Nullifier ${nullifier.toShortString()} for note`);
+      } else if (deployed) {
+        log(
+          `  Contract ${toFriendlyAddress(deployed, artifactMap)} deployed via nullifier ${nullifier.toShortString()}`,
+        );
+      } else if (initialized) {
+        log(
+          `  Contract ${toFriendlyAddress(
+            initialized,
+            artifactMap,
+          )} initialized via nullifier ${nullifier.toShortString()}`,
+        );
+      } else if (registered) {
+        log(`  Class ${registered} registered via nullifier ${nullifier.toShortString()}`);
+      } else {
+        log(`  Unknown nullifier ${nullifier.toString()}`);
+      }
+    }
+  }
+
+  // L2 to L1 messages
+  if (effects.l2ToL1Msgs.length > 0) {
+    log(` L2 to L1 messages:`);
+    for (const msg of effects.l2ToL1Msgs) {
+      log(`  ${msg.toString()}`);
+    }
+  }
+}
+
+function inspectNote(note: NoteDao, artifactMap: ArtifactMap, log: LogFn, text = 'Note') {
+  const artifact = artifactMap[note.contractAddress.toString()];
+  const contract = artifact?.name ?? note.contractAddress.toString();
+  log(`  ${text} at ${contract}`);
+  for (const field of note.note.items) {
+    log(`    ${field.toString()}`);
+  }
+}
+
+function toFriendlyAddress(address: AztecAddress, artifactMap: ArtifactMap) {
+  const artifact = artifactMap[address.toString()];
+  if (!artifact) {
+    return address.toString();
+  }
+
+  return `${artifact.name}<${address.toString()}>`;
+}
+
+async function getKnownNullifiers(wallet: CLIWallet, artifactMap: ArtifactMap) {
+  const knownContracts = await wallet.getContracts();
+  const deployerAddress = ProtocolContractAddress.ContractInstanceRegistry;
+  const classRegistryAddress = ProtocolContractAddress.ContractClassRegistry;
+  const initNullifiers: Record<string, AztecAddress> = {};
+  const deployNullifiers: Record<string, AztecAddress> = {};
+  const classNullifiers: Record<string, string> = {};
+  for (const contract of knownContracts) {
+    initNullifiers[(await siloNullifier(contract, contract.toField())).toString()] = contract;
+    deployNullifiers[(await siloNullifier(deployerAddress, contract.toField())).toString()] = contract;
+  }
+  for (const artifact of Object.values(artifactMap)) {
+    classNullifiers[(await siloNullifier(classRegistryAddress, artifact.classId)).toString()] =
+      `${artifact.name}Class<${artifact.classId}>`;
+  }
+  return { initNullifiers, deployNullifiers, classNullifiers };
+}
+
+type ArtifactMap = Record<string, ContractArtifactWithClassId>;
+type ContractArtifactWithClassId = ContractArtifact & { classId: Fr };
+
+async function getKnownArtifacts(wallet: CLIWallet): Promise<ArtifactMap> {
+  const knownContractAddresses = await wallet.getContracts();
+  const knownContracts = (
+    await Promise.all(knownContractAddresses.map(contractAddress => wallet.getContractMetadata(contractAddress)))
+  ).map(contractMetadata => contractMetadata.contractInstance);
+  const classIds = [...new Set(knownContracts.map(contract => contract?.currentContractClassId))];
+  const knownArtifacts = (
+    await Promise.all(classIds.map(classId => (classId ? wallet.getContractClassMetadata(classId) : undefined)))
+  ).map(contractClassMetadata =>
+    contractClassMetadata
+      ? { ...contractClassMetadata.artifact, classId: contractClassMetadata.contractClass?.id }
+      : undefined,
+  );
+  const map: Record<string, ContractArtifactWithClassId> = {};
+  for (const instance of knownContracts) {
+    if (instance) {
+      const artifact = knownArtifacts.find(a =>
+        a?.classId?.equals(instance.currentContractClassId),
+      ) as ContractArtifactWithClassId;
+      if (artifact) {
+        map[instance.address.toString()] = artifact;
+      }
+    }
   }
+  return map;
 }

package/src/cmds/create_account.ts

@@ -1,38 +1,45 @@
-import type { DeployAccountOptions, 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 { Fr } from '@aztec/foundation/curves/bn254';
 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 type { AccountType } from '../utils/constants.js';
+import { CLIFeeArgs } from '../utils/options/fees.js';
+import { printProfileResult } from '../utils/profiling.js';
+import { 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,
   log: LogFn,
 ) {
   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,
     publicKey,
   );
-  const salt = account.getInstance().salt;
+  const { salt } = account.getInstance();
   const { address, publicKeys, partialAddress } = await account.getCompleteAddress();
 
   const out: Record<string, any> = {};
@@ -45,7 +52,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()}`);
@@ -56,47 +62,65 @@ 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 = {
-      skipClassRegistration: !publicDeploy,
-      skipPublicDeployment: !publicDeploy,
-      skipInitialization: skipInitialization,
-      ...(await feeOpts.toDeployAccountOpts(wallet)),
+  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,
+      from,
+      fee: { paymentMethod, gasSettings },
     };
+
+    const deployMethod = await account.getDeployMethod();
+    const { estimatedGas, stats } = await deployMethod.simulate({
+      ...deployAccountOpts,
+      fee: { ...deployAccountOpts.fee, estimateGas: true },
+    });
+
     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,
+            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 {
-      tx = account.deploy(deployOpts);
+      tx = deployMethod.send({
+        ...deployAccountOpts,
+        fee: deployAccountOpts.fee
+          ? {
+              ...deployAccountOpts.fee,
+              gasSettings: estimatedGas,
+            }
+          : undefined,
+      });
+      if (verbose) {
+        printProfileResult(stats, log);
+      }
+
       const txHash = await tx.getTxHash();
-      debugLogger.debug(`Account contract tx sent with hash ${txHash}`);
+      debugLogger.debug(`Account contract tx sent with hash ${txHash.toString()}`);
       out.txHash = txHash;
       if (wait) {
         if (!json) {
           log(`\nWaiting for account contract deployment...`);
         }
-        txReceipt = await tx.wait();
+        txReceipt = await tx.wait({ timeout: DEFAULT_TX_TIMEOUT_S });
         out.txReceipt = {
           status: txReceipt.status,
           transactionFee: txReceipt.transactionFee,
@@ -109,7 +133,7 @@ export async function createAccount(
     log(prettyPrintJSON(out));
   } else {
     if (tx) {
-      log(`Deploy tx hash:  ${await tx.getTxHash()}`);
+      log(`Deploy tx hash:  ${(await tx.getTxHash()).toString()}`);
     }
     if (txReceipt) {
       log(`Deploy tx fee:   ${txReceipt.transactionFee}`);

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[],
@@ -24,10 +28,10 @@ export async function createAuthwit(
     );
   }
 
-  const contract = await Contract.at(contractAddress, contractArtifact, wallet);
-  const action = contract.methods[functionName](...functionArgs);
+  const contract = Contract.at(contractAddress, contractArtifact, wallet);
+  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,43 +1,52 @@
-import { type AccountWalletWithSecretKey, ContractDeployer, type DeployMethod, Fr, type PXE } from '@aztec/aztec.js';
-import { GITHUB_TAG_PREFIX, 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 { getInitializer } from '@aztec/stdlib/abi';
+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 type { CLIWallet } from '../utils/wallet.js';
 
 export async function deploy(
-  client: PXE,
-  wallet: AccountWalletWithSecretKey,
+  wallet: CLIWallet,
+  node: AztecNode,
+  deployer: AztecAddress,
   artifactPath: string,
   json: boolean,
   publicKeys: PublicKeys | undefined,
   rawArgs: any[],
   salt: Fr | undefined,
   initializer: string | undefined,
-  skipPublicDeployment: boolean,
-  skipClassRegistration: boolean,
+  skipInstancePublication: boolean,
+  skipClassPublication: boolean,
   skipInitialization: boolean | undefined,
-  universalDeploy: 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 constructorArtifact = getInitializer(contractArtifact, initializer);
+  const hasInitializer = getAllFunctionAbis(contractArtifact).some(fn => fn.isInitializer);
+  const constructorArtifact = hasInitializer ? getInitializer(contractArtifact, initializer) : undefined;
 
-  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`,
-    );
-  }
+  // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)?
 
-  const deployer = new ContractDeployer(contractArtifact, wallet, publicKeys ?? PublicKeys.default(), initializer);
+  const contractDeployer = new ContractDeployer(
+    contractArtifact,
+    wallet,
+    publicKeys ?? PublicKeys.default(),
+    initializer,
+  );
 
   let args = [];
   if (rawArgs.length > 0) {
@@ -49,65 +58,73 @@ export async function deploy(
     debugLogger.debug(`Encoded arguments: ${args.join(', ')}`);
   }
 
-  const deploy = deployer.deploy(...args);
-  const deployOpts: Parameters<DeployMethod['send']>[0] = {
-    ...(await feeOpts.toSendOpts(wallet)),
+  const deploy = contractDeployer.deploy(...args);
+  const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, deployer);
+  const deployOpts: DeployOptions = {
+    fee: { gasSettings, paymentMethod },
+    from: deployer ?? AztecAddress.ZERO,
     contractAddressSalt: salt,
-    universalDeploy,
-    skipClassRegistration,
+    universalDeploy: !deployer,
+    skipClassPublication,
     skipInitialization,
-    skipPublicDeployment,
+    skipInstancePublication,
   };
 
-  if (feeOpts.estimateOnly) {
-    const gas = await deploy.estimateGas(deployOpts);
-    printGasEstimates(feeOpts, gas, log);
-    return;
-  }
-
-  const tx = deploy.send(deployOpts);
+  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}`);
-  if (wait) {
-    const deployed = await tx.wait();
-    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;
 }