@aztec/cli 0.1.0-alpha13

package/dest/utils.js

@@ -0,0 +1,70 @@
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+import fs from 'fs';
+import { createEthereumChain, deployL1Contracts } from '@aztec/ethereum';
+import { AztecAddress } from '@aztec/aztec.js';
+import { encodeArgs } from './cli_encoder.js';
+/**
+ * Function to execute the 'deployRollupContracts' command.
+ * @param rpcUrl - The RPC URL of the ethereum node.
+ * @param apiKey - The api key of the ethereum node endpoint.
+ * @param privateKey - The private key to be used in contract deployment.
+ * @param mnemonic - The mnemonic to be used in contract deployment.
+ */
+export async function deployAztecContracts(rpcUrl, apiKey, privateKey, mnemonic, debugLogger) {
+    const account = !privateKey ? mnemonicToAccount(mnemonic) : privateKeyToAccount(`0x${privateKey}`);
+    const chain = createEthereumChain(rpcUrl, apiKey);
+    await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger);
+}
+/**
+ * Reads a file and converts it to an Aztec Contract ABI.
+ * @param fileDir - The directory of the compiled contract ABI.
+ * @returns The parsed ContractABI.
+ */
+export function getContractAbi(fileDir, log) {
+    const contents = fs.readFileSync(fileDir, 'utf8');
+    let contractAbi;
+    try {
+        contractAbi = JSON.parse(contents);
+    }
+    catch (err) {
+        log('Invalid file used. Please try again.');
+        throw err;
+    }
+    return contractAbi;
+}
+/**
+ * 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.
+ */
+export function prepTx(contractFile, _contractAddress, functionName, _from, _functionArgs, log) {
+    let contractAddress;
+    try {
+        contractAddress = AztecAddress.fromString(_contractAddress);
+    }
+    catch {
+        throw new Error(`Unable to parse contract address ${_contractAddress}.`);
+    }
+    const contractAbi = getContractAbi(contractFile, log);
+    const functionAbi = contractAbi.functions.find(({ name }) => name === functionName);
+    if (!functionAbi) {
+        throw new Error(`Function ${functionName} not found on contract ABI.`);
+    }
+    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 };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@aztec/cli",
+  "version": "0.1.0-alpha13",
+  "exports": "./dest/index.js",
+  "type": "module",
+  "dependencies": {
+    "@aztec/aztec.js": "0.1.0-alpha13",
+    "@aztec/ethereum": "0.1.0-alpha13",
+    "@aztec/foundation": "0.1.0-alpha13",
+    "commander": "^9.0.0",
+    "tslib": "^2.4.0",
+    "viem": "^1.2.5"
+  }
+}

package/src/cli_encoder.ts

@@ -0,0 +1,82 @@
+import { Fr } from '@aztec/aztec.js';
+import { ABIParameter, ABIType, StructType } from '@aztec/foundation/abi';
+
+/**
+ * Parses a hex string into an ABI struct type.
+ * @param str - The encoded hex string.
+ * @param abiType - The ABI Struct type.
+ * @returns An object in the ABI struct type's format.
+ */
+export function parseStructString(str: string, abiType: StructType) {
+  // Assing string bytes to struct fields.
+  const buf = Buffer.from(str.replace(/^0x/i, ''), 'hex');
+  const struct: any = {};
+  let byteIndex = 0;
+  let argIndex = 0;
+  while (byteIndex < buf.length) {
+    const { name } = abiType.fields[argIndex];
+    struct[name] = Fr.fromBuffer(buf.subarray(byteIndex, byteIndex + 32));
+    byteIndex += 32;
+    argIndex += 1;
+  }
+
+  return struct;
+}
+
+/**
+ * Helper function to encode CLI string args to an appropriate JS type.
+ * @param arg - The CLI argument.
+ * @param abiType - The type as described by the contract's ABI.
+ * @returns The encoded argument.
+ */
+function encodeArg(arg: string, abiType: ABIType): any {
+  const { kind } = abiType;
+  if (kind === 'field' || kind === 'integer') {
+    return BigInt(arg);
+  } else if (kind === 'boolean') {
+    if (arg === 'true') return true;
+    if (arg === 'false') return false;
+  } else if (kind === 'array') {
+    let arr;
+    try {
+      arr = JSON.parse(arg);
+      if (!Array.isArray(arr)) throw Error();
+      for (let i = 0; i < abiType.length; i += 1) {
+        return encodeArg(arg[i], abiType.type);
+      }
+    } catch {
+      throw new Error(`Unable to parse arg ${arg} as array`);
+    }
+  } else if (kind === 'struct') {
+    // check if input is encoded long string
+    if (arg.startsWith('0x')) {
+      return parseStructString(arg, abiType);
+    }
+    let obj;
+    try {
+      obj = JSON.parse(arg);
+      if (Array.isArray(obj)) throw Error();
+      const res = [];
+      for (const field of abiType.fields) {
+        res.push(encodeArg(obj[field.name], field.type));
+      }
+      return res;
+    } catch {
+      throw new Error(`Unable to parse arg ${arg} as struct`);
+    }
+  }
+}
+
+/**
+ * Tries to encode function args to their equivalent TS type.
+ * @param args - An array of function's / constructor's args.
+ * @returns The encoded array.
+ */
+export function encodeArgs(args: any[], params: ABIParameter[]) {
+  return args
+    .map((arg: any, index) => {
+      const paramType = params[index].type;
+      return encodeArg(arg, paramType);
+    })
+    .flat();
+}

package/src/index.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createLogger } from '@aztec/foundation/log';
+import { createDebugLogger } from '@aztec/foundation/log';
+import {
+  AztecAddress,
+  Contract,
+  ContractDeployer,
+  Point,
+  TxHash,
+  createAccounts,
+  createAztecRpcClient,
+  pointToPublicKey,
+} from '@aztec/aztec.js';
+
+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';
+
+const debugLogger = createDebugLogger('aztec:cli');
+const log = createLogger();
+
+const program = new Command();
+
+program.name('azti').description('CLI for interacting with Aztec.').version('0.1.0');
+
+/**
+ * A placeholder for the Aztec-cli.
+ */
+async function main() {
+  program
+    .command('deploy-l1-contracts')
+    .argument(
+      '[rpcUrl]',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      '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(
+      '-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);
+    });
+
+  program
+    .command('deploy')
+    .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) => {
+      const contractAbi = getContractAbi(contractFile, log);
+      const constructorAbi = contractAbi.functions.find(({ name }) => name === 'constructor');
+
+      const publicKey = Point.fromString(options.publicKey);
+      const client = createAztecRpcClient(options.rpcUrl);
+      const deployer = new ContractDeployer(contractAbi, client);
+
+      const tx = deployer
+        .deploy(...encodeArgs(options.constructorArgs, constructorAbi!.parameters), pointToPublicKey(publicKey))
+        .send();
+      await tx.isMined();
+      const receipt = await tx.getReceipt();
+      log(`Contract deployed at ${receipt.contractAddress?.toString()}`);
+    });
+
+  program
+    .command('check-deploy')
+    .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')
+    .action(async (_contractAddress, options) => {
+      const client = createAztecRpcClient(options.rpcUrl);
+      const address = AztecAddress.fromString(_contractAddress);
+      const isDeployed = await client.isContractDeployed(address);
+      log(isDeployed.toString());
+    });
+
+  program
+    .command('get-tx-receipt')
+    .argument('<txHash>', 'A TX hash to get the receipt for.')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .action(async (_txHash, options) => {
+      const client = createAztecRpcClient(options.rpcUrl);
+      const txHash = TxHash.fromString(_txHash);
+      const receipt = await client.getTxReceipt(txHash);
+      if (!receipt) {
+        log(`No receipt found for tx hash ${_txHash}`);
+      } else {
+        log(`TX Receipt: \n${JsonStringify(receipt, true)}`);
+      }
+    });
+
+  program
+    .command('get-contract-data')
+    .argument('<contractAddress>', 'Aztec address of the contract.')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', '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);
+      const address = AztecAddress.fromString(_contractAddress);
+      const contractDataOrInfo = options.includeBytecode
+        ? await client.getContractData(address)
+        : await client.getContractInfo(address);
+
+      if (!contractDataOrInfo) {
+        log(`No contract data found at ${_contractAddress}`);
+        return;
+      }
+      let contractData: ContractData;
+
+      if ('contractData' in contractDataOrInfo) {
+        contractData = contractDataOrInfo.contractData;
+      } else {
+        contractData = contractDataOrInfo;
+      }
+      log(`Contract Data: \nAddress: ${contractData.contractAddress.toString()}`);
+      log(`Portal: ${contractData.portalContractAddress.toString()}`);
+      if ('bytecode' in contractDataOrInfo) {
+        log(`Bytecode: ${contractDataOrInfo.bytecode}`);
+      }
+    });
+
+  program
+    .command('get-logs')
+    .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')
+    .action(async (_from, _take, options) => {
+      let from: number;
+      let take: number;
+      try {
+        from = parseInt(_from);
+        take = parseInt(_take);
+      } catch {
+        log(`Invalid integer value(s) passed: ${_from}, ${_take}`);
+        return;
+      }
+      const client = createAztecRpcClient(options.rpcUrl);
+      const logs = await client.getUnencryptedLogs(from, take);
+      if (!logs.length) {
+        log(`No logs found in blocks ${from} to ${from + take}`);
+      } else {
+        log('Logs found: \n');
+        L2BlockL2Logs.unrollLogs(logs).forEach(fnLog => log(`${fnLog.toString('ascii')}\n`));
+      }
+    });
+
+  // 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')
+    .action(async (options: any) => {
+      const client = createAztecRpcClient(options.rpcUrl);
+      const accounts = await client.getAccounts();
+      if (!accounts.length) {
+        log('No accounts found.');
+      } else {
+        log(`Accounts found: \n`);
+        accounts.forEach(acc => log(`${acc}\n`));
+      }
+    });
+
+  program
+    .command('get-account-public-key')
+    .argument('<address>', 'The Aztec address to get the public key for')
+    .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .action(async (_address, options) => {
+      const client = createAztecRpcClient(options.rpcUrl);
+      const address = AztecAddress.fromString(_address);
+      const pk = await client.getAccountPublicKey(address);
+      if (!pk) {
+        log(`Unkown account ${_address}`);
+      } else {
+        log(`Public Key: \n ${pk.toString()}`);
+      }
+    });
+
+  program
+    .command('call-fn')
+    .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(
+        contractFile,
+        _contractAddress,
+        functionName,
+        _from,
+        _functionArgs,
+        log,
+      );
+      const client = createAztecRpcClient(options.rpcUrl);
+      const wallet = await createAccounts(client);
+      const contract = new Contract(contractAddress, contractAbi, wallet);
+      const tx = contract.methods[functionName](...functionArgs).send({ from });
+      await tx.isMined();
+      log('TX 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}`);
+    });
+
+  program
+    .command('view-tx')
+    .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(
+        contractFile,
+        _contractAddress,
+        functionName,
+        _from,
+        _functionArgs,
+        log,
+      );
+      const client = createAztecRpcClient(options.rpcUrl);
+      const result = await client.viewTx(functionName, functionArgs, contractAddress, from);
+      log('View TX returned result: ', JsonStringify(result, true));
+    });
+
+  // Helper for users to decode hex strings into structs if needed
+  program
+    .command('parse-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')
+    .action((encodedString, contractFile, parameterName) => {
+      const contractAbi = getContractAbi(contractFile, log);
+      const parameterAbitype = contractAbi.functions
+        .map(({ parameters }) => parameters)
+        .flat()
+        .find(({ name, type }) => name === parameterName && type.kind === 'struct');
+      if (!parameterAbitype) {
+        log(`No struct parameter found with name ${parameterName}`);
+        return;
+      }
+      const data = parseStructString(encodedString, parameterAbitype.type as StructType);
+      log(`Struct Data: \n${JsonStringify(data, true)}`);
+    });
+
+  program
+    .command('block-num')
+    .option('-u, --rpcUrl <string>', 'URL of the Aztec RPC', 'http://localhost:8080')
+    .action(async (options: any) => {
+      const client = createAztecRpcClient(options.rpcUrl);
+      const num = await client.getBlockNum();
+      log(num);
+    });
+
+  await program.parseAsync(process.argv);
+}
+
+main().catch(err => {
+  log(`Error thrown: ${err}`);
+  process.exit(1);
+});

package/src/utils.ts

@@ -0,0 +1,86 @@
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+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 { encodeArgs } from './cli_encoder.js';
+
+/**
+ * Function to execute the 'deployRollupContracts' command.
+ * @param rpcUrl - The RPC URL of the ethereum node.
+ * @param apiKey - The api key of the ethereum node endpoint.
+ * @param privateKey - The private key to be used in contract deployment.
+ * @param mnemonic - The mnemonic to be used in contract deployment.
+ */
+export async function deployAztecContracts(
+  rpcUrl: string,
+  apiKey: string,
+  privateKey: string,
+  mnemonic: string,
+  debugLogger: DebugLogger,
+) {
+  const account = !privateKey ? mnemonicToAccount(mnemonic!) : privateKeyToAccount(`0x${privateKey}`);
+  const chain = createEthereumChain(rpcUrl, apiKey);
+  await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger);
+}
+
+/**
+ * Reads a file and converts it to an Aztec Contract ABI.
+ * @param fileDir - The directory of the compiled contract ABI.
+ * @returns The parsed ContractABI.
+ */
+export function getContractAbi(fileDir: string, log: Logger) {
+  const contents = fs.readFileSync(fileDir, 'utf8');
+  let contractAbi: ContractAbi;
+  try {
+    contractAbi = JSON.parse(contents) as ContractAbi;
+  } catch (err) {
+    log('Invalid file used. Please try again.');
+    throw err;
+  }
+  return contractAbi;
+}
+
+/**
+ * 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.
+ */
+export function prepTx(
+  contractFile: string,
+  _contractAddress: string,
+  functionName: string,
+  _from: string,
+  _functionArgs: string[],
+  log: Logger,
+) {
+  let contractAddress;
+  try {
+    contractAddress = AztecAddress.fromString(_contractAddress);
+  } catch {
+    throw new Error(`Unable to parse contract address ${_contractAddress}.`);
+  }
+  const contractAbi = getContractAbi(contractFile, log);
+  const functionAbi = contractAbi.functions.find(({ name }) => name === functionName);
+  if (!functionAbi) {
+    throw new Error(`Function ${functionName} not found on contract ABI.`);
+  }
+
+  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 };
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "..",
+  "compilerOptions": {
+    "outDir": "dest",
+    "rootDir": "src",
+    "tsBuildInfoFile": ".tsbuildinfo"
+  },
+  "references": [
+    {
+      "path": "../aztec.js"
+    },
+    {
+      "path": "../ethereum"
+    },
+    {
+      "path": "../foundation"
+    }
+  ],
+  "include": ["src"],
+  "exclude": ["contracts"]
+}