@aztec/cli 0.1.0-alpha21 → 0.1.0-alpha23

package/src/index.ts

@@ -1,23 +1,27 @@
 #!/usr/bin/env -S node --no-warnings
 import { Command } from 'commander';
+import { mnemonicToAccount } from 'viem/accounts';
 import { createLogger } from '@aztec/foundation/log';
 import { createDebugLogger } from '@aztec/foundation/log';
 import {
   AztecAddress,
   Contract,
   ContractDeployer,
+  Fr,
   Point,
-  TxHash,
   createAccounts,
   createAztecRpcClient,
-  pointToPublicKey,
+  getAccountWallet,
 } from '@aztec/aztec.js';
+import { StructType } from '@aztec/foundation/abi';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { JsonStringify } from '@aztec/foundation/json-rpc';
+import { ContractData, TxHash, L2BlockL2Logs } from '@aztec/types';
 
 import { encodeArgs, parseStructString } from './cli_encoder.js';
-import { deployAztecContracts, getContractAbi, prepTx } from './utils.js';
-import { JsonStringify } from '@aztec/foundation/json-rpc';
-import { StructType } from '@aztec/foundation/abi';
-import { ContractData, L2BlockL2Logs } from '@aztec/types';
+import { deployAztecContracts, getContractAbi, getTxSender, prepTx } from './utils.js';
+
+const accountCreationSalt = Fr.ZERO;
 
 const debugLogger = createDebugLogger('aztec:cli');
 const log = createLogger();
@@ -26,65 +30,127 @@ const program = new Command();
 
 program.name('azti').description('CLI for interacting with Aztec.').version('0.1.0');
 
+const { ETHEREUM_HOST, AZTEC_RPC_HOST, PRIVATE_KEY, PUBLIC_KEY, API_KEY } = process.env;
+
 /**
- * A placeholder for the Aztec-cli.
+ * Main function for the Aztec CLI.
  */
 async function main() {
   program
     .command('deploy-l1-contracts')
+    .description('Deploys all necessary Ethereum contracts for Aztec.')
     .argument(
       '[rpcUrl]',
       'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
-      'http://localhost:8545',
+      ETHEREUM_HOST || 'http://localhost:8545',
     )
-    .option('-a, --api-key <string>', 'Api key for the ethereum host', undefined)
-    .option('-p, --private-key <string>', 'The private key to use for deployment')
+    .option('-a, --api-key <string>', 'Api key for the ethereum host', API_KEY)
+    .option('-p, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
     .option(
       '-m, --mnemonic <string>',
       'The mnemonic to use in deployment',
       'test test test test test test test test test test test junk',
     )
     .action(async (rpcUrl: string, options) => {
-      await deployAztecContracts(rpcUrl, options.apiKey ?? '', options.privateKey, options.mnemonic, debugLogger);
+      const { rollupAddress, registryAddress, inboxAddress, outboxAddress, contractDeploymentEmitterAddress } =
+        await deployAztecContracts(rpcUrl, options.apiKey ?? '', options.privateKey, options.mnemonic, debugLogger);
+      log('\n');
+      log(`Rollup Address: ${rollupAddress.toString()}`);
+      log(`Registry Address: ${registryAddress.toString()}`);
+      log(`L1 -> L2 Inbox Address: ${inboxAddress.toString()}`);
+      log(`L2 -> L1 Outbox address: ${outboxAddress.toString()}`);
+      log(`Contract Deployment Emitter Address: ${contractDeploymentEmitterAddress.toString()}`);
+      log('\n');
+    });
+
+  program
+    .command('create-private-key')
+    .description('Generates a 32-byte private key.')
+    .option('-m, --mnemonic', 'A mnemonic string that can be used for the private key generation.')
+    .action(options => {
+      let privKey;
+      if (options.mnemonic) {
+        const acc = mnemonicToAccount(options.mnemonic);
+        privKey = Buffer.from(acc.getHdKey().privateKey!).toString('hex');
+      } else {
+        privKey = randomBytes(32).toString('hex');
+      }
+      log(`\n${privKey}\n`);
+    });
+
+  program
+    .command('create-account')
+    .description('Creates an aztec account that can be used for transactions.')
+    .option(
+      '-k, --private-key <string>',
+      'Private Key to use for the 1st account generation. Uses random by default.',
+      PRIVATE_KEY,
+    )
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .action(async options => {
+      const client = createAztecRpcClient(options.rpcUrl);
+      const privateKey = options.privateKey && Buffer.from(options.privateKey.replace(/^0x/i, ''), 'hex');
+      const wallet = await createAccounts(client, privateKey, accountCreationSalt, 1);
+      const accounts = await wallet.getAccounts();
+      const pubKeys = await Promise.all(accounts.map(acc => wallet.getAccountPublicKey(acc)));
+      log(`\nCreated account(s).`);
+      accounts.map((acc, i) => log(`\nAddress: ${acc.toString()}\nPublic Key: ${pubKeys[i].toString()}\n`));
     });
 
   program
     .command('deploy')
+    .description('Deploys a compiled Noir contract to Aztec.')
     .argument('<contractAbi>', "A compiled Noir contract's ABI in JSON format", undefined)
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
-    .option('-k, --public-key <string>')
-    .option('-a, --constructor-args [args...]', 'Contract constructor arguments', [])
-    .action(async (contractFile: string, options: any) => {
+    .argument('[constructorArgs...]', 'Contract constructor arguments', [])
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .option(
+      '-k, --public-key <string>',
+      'Public key of the deployer. If not provided, it will check the RPC for existing ones.',
+      PUBLIC_KEY,
+    )
+    .action(async (contractFile: string, args: string[], options: any) => {
       const contractAbi = getContractAbi(contractFile, log);
       const constructorAbi = contractAbi.functions.find(({ name }) => name === 'constructor');
 
-      const publicKey = Point.fromString(options.publicKey);
       const client = createAztecRpcClient(options.rpcUrl);
+      let publicKey;
+      if (options.publicKey) {
+        publicKey = Point.fromString(options.publicKey);
+      } else {
+        const accounts = await client.getAccounts();
+        if (!accounts) {
+          throw new Error('No public key provided or found in Aztec RPC.');
+        }
+        publicKey = await client.getAccountPublicKey(accounts[0]);
+      }
+
+      log(`Using Public Key: ${publicKey.toString()}`);
+
       const deployer = new ContractDeployer(contractAbi, client);
 
-      const tx = deployer
-        .deploy(...encodeArgs(options.constructorArgs, constructorAbi!.parameters), pointToPublicKey(publicKey))
-        .send();
+      const tx = deployer.deploy(...encodeArgs(args, constructorAbi!.parameters), publicKey.toBigInts()).send();
       await tx.isMined();
       const receipt = await tx.getReceipt();
-      log(`Contract deployed at ${receipt.contractAddress?.toString()}`);
+      log(`\nAztec Contract deployed at ${receipt.contractAddress?.toString()}\n`);
     });
 
   program
     .command('check-deploy')
+    .description('Checks if a contract is deployed to the specified Aztec address.')
     .argument('<contractAddress>', 'An Aztec address to check if contract has been deployed to.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .action(async (_contractAddress, options) => {
       const client = createAztecRpcClient(options.rpcUrl);
       const address = AztecAddress.fromString(_contractAddress);
       const isDeployed = await client.isContractDeployed(address);
-      log(isDeployed.toString());
+      log(`\n${isDeployed.toString()}\n`);
     });
 
   program
     .command('get-tx-receipt')
+    .description('Gets the receipt for the specified transaction hash.')
     .argument('<txHash>', 'A TX hash to get the receipt for.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .action(async (_txHash, options) => {
       const client = createAztecRpcClient(options.rpcUrl);
       const txHash = TxHash.fromString(_txHash);
@@ -92,14 +158,15 @@ async function main() {
       if (!receipt) {
         log(`No receipt found for tx hash ${_txHash}`);
       } else {
-        log(`TX Receipt: \n${JsonStringify(receipt, true)}`);
+        log(`\nTX Receipt: \n${JsonStringify(receipt, true)}\n`);
       }
     });
 
   program
     .command('get-contract-data')
+    .description('Gets information about the Aztec contract deployed at the specified address.')
     .argument('<contractAddress>', 'Aztec address of the contract.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .option('-b, --include-bytecode', "Include the contract's public function bytecode, if any.")
     .action(async (_contractAddress, options) => {
       const client = createAztecRpcClient(options.rpcUrl);
@@ -119,18 +186,20 @@ async function main() {
       } else {
         contractData = contractDataOrInfo;
       }
-      log(`Contract Data: \nAddress: ${contractData.contractAddress.toString()}`);
+      log(`\nContract Data: \nAddress: ${contractData.contractAddress.toString()}`);
       log(`Portal: ${contractData.portalContractAddress.toString()}`);
       if ('bytecode' in contractDataOrInfo) {
         log(`Bytecode: ${contractDataOrInfo.bytecode}`);
       }
+      log('\n');
     });
 
   program
     .command('get-logs')
+    .description('Gets all the unencrypted logs from L2 blocks in the range specified.')
     .argument('<from>', 'Block num start for getting logs.')
     .argument('<take>', 'How many block logs to fetch.')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .action(async (_from, _take, options) => {
       let from: number;
       let take: number;
@@ -151,26 +220,9 @@ async function main() {
       }
     });
 
-  // NOTE: This implementation should change soon but keeping it here for quick account creation.
-  program
-    .command('create-account')
-    .option('-k, --private-key', 'Private Key to use for the 1st account generation.')
-    .option('-n, --num-addresses <number>', 'Number of addresses the account can control')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
-    .action(async options => {
-      const client = createAztecRpcClient(options.rpcUrl);
-      const privateKey = options.privateKey && Buffer.from(options.privateKeystr.replace(/^0x/i, ''), 'hex');
-      const numAccounts = options.numAddresses ? parseInt(options.numAddresses) : 1;
-      const wallet = await createAccounts(client, privateKey, numAccounts);
-      const accounts = await wallet.getAccounts();
-      const pubKeys = await Promise.all(accounts.map(acc => wallet.getAccountPublicKey(acc)));
-      log(`Created account(s).`);
-      accounts.map((acc, i) => log(`\nAddress: ${acc.toString()}\nPublic Key: ${pubKeys[i].toString()}\n`));
-    });
-
   program
     .command('get-accounts')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .action(async (options: any) => {
       const client = createAztecRpcClient(options.rpcUrl);
       const accounts = await client.getAccounts();
@@ -178,14 +230,15 @@ async function main() {
         log('No accounts found.');
       } else {
         log(`Accounts found: \n`);
-        accounts.forEach(acc => log(`${acc}\n`));
+        accounts.forEach(async acc => log(`Address: ${acc}\nPublic Key: ${await client.getAccountPublicKey(acc)}\n`));
       }
     });
 
   program
     .command('get-account-public-key')
+    .description("Gets an account's public key, given its Aztec address.")
     .argument('<address>', 'The Aztec address to get the public key for')
-    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .action(async (_address, options) => {
       const client = createAztecRpcClient(options.rpcUrl);
       const address = AztecAddress.fromString(_address);
@@ -199,59 +252,68 @@ async function main() {
 
   program
     .command('call-fn')
+    .description('Calls a function on an Aztec contract.')
     .argument('<contractAbi>', "The compiled contract's ABI in JSON format", undefined)
     .argument('<contractAddress>', 'Address of the contract')
     .argument('<functionName>', 'Name of Function to view')
-    .argument('[from]', 'The caller of the transaction', undefined)
     .argument('[functionArgs...]', 'Function arguments', [])
-    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
-    .action(async (contractFile, _contractAddress, functionName, _from, _functionArgs, options) => {
-      const { contractAddress, functionArgs, from, contractAbi } = prepTx(
+    .option('-k, --private-key <string>', "The sender's private key.", PRIVATE_KEY)
+    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+
+    .action(async (contractFile, _contractAddress, functionName, _functionArgs, options) => {
+      const { contractAddress, functionArgs, contractAbi } = prepTx(
         contractFile,
         _contractAddress,
         functionName,
-        _from,
         _functionArgs,
         log,
       );
+
       const client = createAztecRpcClient(options.rpcUrl);
-      const wallet = await createAccounts(client);
+      const wallet = await getAccountWallet(client, Buffer.from(options.privateKey, 'hex'), accountCreationSalt);
       const contract = new Contract(contractAddress, contractAbi, wallet);
-      const tx = contract.methods[functionName](...functionArgs).send({ from });
+      const origin = (await wallet.getAccounts()).find(addr => addr.equals(wallet.getAddress()));
+      const tx = contract.methods[functionName](...functionArgs).send({
+        origin,
+      });
       await tx.isMined();
-      log('TX has been mined');
+      log('\nTX has been mined');
       const receipt = await tx.getReceipt();
       log(`TX Hash: ${(await tx.getTxHash()).toString()}`);
       log(`Block Num: ${receipt.blockNumber}`);
       log(`Block Hash: ${receipt.blockHash?.toString('hex')}`);
-      log(`TX Status: ${receipt.status}`);
+      log(`TX Status: ${receipt.status}\n`);
     });
 
   program
-    .command('view-tx')
+    .command('view-fn')
+    .description(
+      'Simulates the execution of a view (read-only) function on a deployed contract, without modifying state.',
+    )
     .argument('<contractAbi>', "The compiled contract's ABI in JSON format", undefined)
     .argument('<contractAddress>', 'Address of the contract')
     .argument('<functionName>', 'Name of Function to view')
-    .argument('[from]', 'The caller of the transaction', undefined)
     .argument('[functionArgs...]', 'Function arguments', [])
-    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
-    .action(async (contractFile, _contractAddress, functionName, _from, _functionArgs, options) => {
-      const { contractAddress, functionArgs, from } = prepTx(
+    .option('-f, --from <string>', 'Public key of the TX viewer. If empty, will try to find account in RPC.')
+    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
+    .action(async (contractFile, _contractAddress, functionName, _functionArgs, options) => {
+      const { contractAddress, functionArgs } = prepTx(
         contractFile,
         _contractAddress,
         functionName,
-        _from,
         _functionArgs,
         log,
       );
       const client = createAztecRpcClient(options.rpcUrl);
+      const from = await getTxSender(client, options.from);
       const result = await client.viewTx(functionName, functionArgs, contractAddress, from);
-      log('View TX returned result: ', JsonStringify(result, true));
+      log('\nView TX result: ', JsonStringify(result, true), '\n');
     });
 
   // Helper for users to decode hex strings into structs if needed
   program
     .command('parse-parameter-struct')
+    .description("Helper for parsing an encoded string into a contract's parameter struct.")
     .argument('<encodedString>', 'The encoded hex string')
     .argument('<contractAbi>', "The compiled contract's ABI in JSON format")
     .argument('<parameterName>', 'The name of the struct parameter to decode into')
@@ -266,16 +328,17 @@ async function main() {
         return;
       }
       const data = parseStructString(encodedString, parameterAbitype.type as StructType);
-      log(`Struct Data: \n${JsonStringify(data, true)}`);
+      log(`\nStruct Data: \n${JsonStringify(data, true)}\n`);
     });
 
   program
     .command('block-num')
-    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .description('Gets the current Aztec L2 number.')
+    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
     .action(async (options: any) => {
       const client = createAztecRpcClient(options.rpcUrl);
       const num = await client.getBlockNum();
-      log(num);
+      log(`${num}\n`);
     });
 
   await program.parseAsync(process.argv);

package/src/utils.ts

@@ -3,7 +3,7 @@ import fs from 'fs';
 import { createEthereumChain, deployL1Contracts } from '@aztec/ethereum';
 import { DebugLogger, Logger } from '@aztec/foundation/log';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/aztec.js';
+import { AztecAddress, AztecRPC } from '@aztec/aztec.js';
 import { encodeArgs } from './cli_encoder.js';
 
 /**
@@ -22,7 +22,7 @@ export async function deployAztecContracts(
 ) {
   const account = !privateKey ? mnemonicToAccount(mnemonic!) : privateKeyToAccount(`0x${privateKey}`);
   const chain = createEthereumChain(rpcUrl, apiKey);
-  await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger);
+  return await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger);
 }
 
 /**
@@ -42,12 +42,36 @@ export function getContractAbi(fileDir: string, log: Logger) {
   return contractAbi;
 }
 
+/**
+ * Utility to select a TX sender either from user input
+ * or from the first account that is found in an Aztec RPC instance.
+ * @param client - The Aztec RPC instance that will be checked for an account.
+ * @param _from - The user input.
+ * @returns An Aztec address. Will throw if one can't be found in either options.
+ */
+export async function getTxSender(client: AztecRPC, _from?: string) {
+  let from: AztecAddress;
+  if (_from) {
+    try {
+      from = AztecAddress.fromString(_from);
+    } catch {
+      throw new Error(`Invalid option 'from' passed: ${_from}`);
+    }
+  } else {
+    const accounts = await client.getAccounts();
+    if (!accounts.length) {
+      throw new Error('No accounts found in Aztec RPC insance.');
+    }
+    from = accounts[0];
+  }
+  return from;
+}
+
 /**
  * Performs necessary checks, conversions & operations to call a contract fn from the CLI.
  * @param contractFile - Directory of the compiled contract ABI.
  * @param _contractAddress - Aztec Address of the contract.
  * @param functionName - Name of the function to be called.
- * @param _from - The caller's address.
  * @param _functionArgs - Arguments to call the function with.
  * @param log - Logger instance that will output to the CLI
  * @returns Formatted contract address, function arguments and caller's aztec address.
@@ -56,7 +80,6 @@ export function prepTx(
   contractFile: string,
   _contractAddress: string,
   functionName: string,
-  _from: string,
   _functionArgs: string[],
   log: Logger,
 ) {
@@ -73,14 +96,6 @@ export function prepTx(
   }
 
   const functionArgs = encodeArgs(_functionArgs, functionAbi.parameters);
-  let from;
-  if (_from) {
-    try {
-      from = AztecAddress.fromString(_from);
-    } catch {
-      throw new Error(`Unable to parse caller address ${_from}.`);
-    }
-  }
 
-  return { contractAddress, functionArgs, from, contractAbi };
+  return { contractAddress, functionArgs, contractAbi };
 }