@aztec/cli 0.6.7 → 0.7.2

package/Dockerfile

@@ -0,0 +1,15 @@
+FROM 278380418400.dkr.ecr.eu-west-2.amazonaws.com/yarn-project-base AS builder
+
+COPY . .
+
+WORKDIR /usr/src/yarn-project/cli
+RUN yarn build && yarn formatting && yarn test
+
+# Prune dev dependencies. See comment in base image.
+RUN yarn cache clean
+RUN yarn workspaces focus --production > /dev/null
+
+FROM node:18-alpine
+COPY --from=builder /usr/src/ /usr/src/
+WORKDIR /usr/src/yarn-project/cli
+ENTRYPOINT ["yarn", "start"]

package/README.md

@@ -135,7 +135,7 @@ aztec-cli create-account
 
 ### deploy
 
-Deploys a compiled Noir contract to Aztec.
+Deploys a compiled Aztec.nr contract to Aztec.
 
 Syntax:
 
@@ -145,12 +145,12 @@ aztec-cli deploy <contractAbi> [options]
 
 Options:
 
-- `-c, --contract-abi <fileLocation>`: Path to the compiled Noir contract's ABI file in JSON format. You can also use one of Aztec's example contracts found in [@aztec/noir-contracts](https://www.npmjs.com/package/@aztec/noir-contracts), e.g. PrivateTokenContractAbi. You can get a full ist of the available contracts with `aztec-cli example-contracts`
+- `-c, --contract-abi <fileLocation>`: Path to the compiled Aztec.nr contract's ABI file in JSON format. You can also use one of Aztec's example contracts found in [@aztec/noir-contracts](https://www.npmjs.com/package/@aztec/noir-contracts), e.g. PrivateTokenContractAbi. You can get a full ist of the available contracts with `aztec-cli example-contracts`
 - `-a, --args <constructorArgs...>` (optional): Contract constructor arguments Default: [].
 - `-u, --rpc-url <string>`: URL of the Aztec RPC. Default: `http://localhost:8080`.
 - `-k, --public-key <string>`: Public key of the deployer. If not provided, it will check the RPC for existing ones.
 
-This command deploys a compiled Noir contract to Aztec. It requires the path to the contract's ABI file in JSON format. Optionally, you can specify the public key of the deployer and provide constructor arguments for the contract. The command displays the address of the deployed contract.
+This command deploys a compiled Aztec.nr contract to Aztec. It requires the path to the contract's ABI file in JSON format. Optionally, you can specify the public key of the deployer and provide constructor arguments for the contract. The command displays the address of the deployed contract.
 
 Example usage:
 

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@aztec/cli",
-  "version": "0.6.7",
+  "version": "0.7.2",
   "main": "./dest/index.js",
   "type": "module",
   "dependencies": {
-    "@aztec/aztec.js": "0.6.7",
-    "@aztec/ethereum": "0.6.7",
-    "@aztec/foundation": "0.6.7",
-    "@aztec/noir-compiler": "0.6.7",
-    "@aztec/noir-contracts": "0.6.7",
-    "@aztec/types": "0.6.7",
+    "@aztec/aztec.js": "0.7.2",
+    "@aztec/ethereum": "0.7.2",
+    "@aztec/foundation": "0.7.2",
+    "@aztec/noir-compiler": "0.7.2",
+    "@aztec/noir-contracts": "0.7.2",
+    "@aztec/types": "0.7.2",
     "commander": "^9.0.0",
+    "jszip": "^3.10.1",
     "lodash.startcase": "^4.4.0",
+    "node-fetch": "^3.3.2",
     "semver": "^7.5.4",
     "tslib": "^2.4.0",
     "viem": "^1.2.5"

package/src/index.ts

@@ -6,16 +6,14 @@ import {
   GrumpkinScalar,
   Point,
   generatePublicKey,
-  getAccountWallets,
   getSchnorrAccount,
   isContractDeployed,
 } from '@aztec/aztec.js';
-import { StructType } from '@aztec/foundation/abi';
+import { StructType, decodeFunctionSignatureWithParameterNames } from '@aztec/foundation/abi';
 import { JsonStringify } from '@aztec/foundation/json-rpc';
 import { DebugLogger, LogFn } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
-import { compileContract } from '@aztec/noir-compiler/cli';
-import { SchnorrAccountContractAbi } from '@aztec/noir-contracts/artifacts';
+import { compileContract, generateNoirInterface, generateTypescriptInterface } from '@aztec/noir-compiler/cli';
 import { CompleteAddress, ContractData, L2BlockL2Logs, TxHash } from '@aztec/types';
 
 import { Command } from 'commander';
@@ -26,6 +24,7 @@ import { mnemonicToAccount } from 'viem/accounts';
 
 import { createCompatibleClient } from './client.js';
 import { encodeArgs, parseStructString } from './encoding.js';
+import { unboxContract } from './unbox.js';
 import {
   deployAztecContracts,
   getAbiFunction,
@@ -150,10 +149,10 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
 
   program
     .command('deploy')
-    .description('Deploys a compiled Noir contract to Aztec.')
+    .description('Deploys a compiled Aztec.nr contract to Aztec.')
     .argument(
       '<abi>',
-      "A compiled Noir contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
+      "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
     .option('-a, --args <constructorArgs...>', 'Contract constructor arguments', [])
     .option('-u, --rpc-url <string>', 'URL of the Aztec RPC', AZTEC_RPC_HOST || 'http://localhost:8080')
@@ -362,7 +361,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .option('-a, --args [functionArgs...]', 'Function arguments', [])
     .requiredOption(
       '-c, --contract-abi <fileLocation>',
-      "A compiled Noir contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
+      "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
     .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.')
     .option('-k, --private-key <string>', "The sender's private key.", PRIVATE_KEY)
@@ -387,13 +386,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       const privateKey = GrumpkinScalar.fromString(stripLeadingHex(options.privateKey));
 
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const wallet = await getAccountWallets(
-        client,
-        SchnorrAccountContractAbi,
-        [privateKey],
-        [privateKey],
-        [accountCreationSalt],
-      );
+      const wallet = await getSchnorrAccount(client, privateKey, privateKey, accountCreationSalt).getWallet();
       const contract = await Contract.at(contractAddress, contractAbi, wallet);
       const tx = contract.methods[functionName](...functionArgs).send();
       await tx.wait();
@@ -414,7 +407,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .option('-a, --args [functionArgs...]', 'Function arguments', [])
     .requiredOption(
       '-c, --contract-abi <fileLocation>',
-      "A compiled Noir contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
+      "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
     .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.')
     .option('-f, --from <string>', 'Public key of the TX viewer. If empty, will try to find account in RPC.')
@@ -446,7 +439,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .argument('<encodedString>', 'The encoded hex string')
     .requiredOption(
       '-c, --contract-abi <fileLocation>',
-      "A compiled Noir contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
+      "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
     )
     .requiredOption('-p, --parameter <parameterName>', 'The name of the struct parameter to decode into')
     .action(async (encodedString, options) => {
@@ -482,6 +475,18 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       names.forEach(name => log(name));
     });
 
+  program
+    .command('unbox')
+    .description(
+      'Unboxes an example contract from @aztec/boxes.  Also Copies `noir-libs` dependencies and setup simple frontend for the contract using its ABI.',
+    )
+    .argument('<contractName>', 'Name of the contract to unbox, e.g. "PrivateToken"')
+    .argument('[localDirectory]', 'Local directory to unbox to (relative or absolute), defaults to `<contractName>`')
+    .action(async (contractName, localDirectory) => {
+      const unboxTo: string = localDirectory ? localDirectory : contractName;
+      await unboxContract(contractName, unboxTo, version, log);
+    });
+
   program
     .command('get-node-info')
     .description('Gets the information of an aztec node at a URL.')
@@ -493,7 +498,30 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       Object.entries(info).map(([key, value]) => log(`${startCase(key)}: ${value}`));
     });
 
+  program
+    .command('inspect-contract')
+    .description('Shows list of external callable functions for a contract')
+    .argument(
+      '<contractAbiFile>',
+      `A compiled Noir contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts`,
+    )
+    .action(async (contractAbiFile: string) => {
+      const contractAbi = await getContractAbi(contractAbiFile, debugLogger);
+      const contractFns = contractAbi.functions.filter(
+        f => !f.isInternal && f.name !== 'compute_note_hash_and_nullifier',
+      );
+      if (contractFns.length === 0) {
+        log(`No external functions found for contract ${contractAbi.name}`);
+      }
+      for (const fn of contractFns) {
+        const signature = decodeFunctionSignatureWithParameterNames(fn.name, fn.parameters);
+        log(`${fn.functionType} ${signature}`);
+      }
+    });
+
   compileContract(program, 'compile', log);
+  generateTypescriptInterface(program, 'generate-typescript', log);
+  generateNoirInterface(program, 'generate-noir-interface', log);
 
   return program;
 }

package/src/unbox.ts

@@ -0,0 +1,303 @@
+// inspired by https://github.com/trufflesuite/truffle/blob/develop/packages/box/lib/utils/unbox.ts
+// however, their boxes are stored as standalone git repositories, while ours are subpackages in a monorepo
+// so we do some hacky conversions post copy to make them work as standalone packages.
+// We download the master branch of the monorepo, and then
+// (1) copy "boxes/{CONTRACT_NAME}" subpackage to the specified output directory
+// (2) if the box doesnt include noir source code, we copy it from the "noir-contracts" subpackage to into a new subdirectory "X/src/contracts",
+// These are used by a simple frontend to interact with the contract and deploy to a local sandbox instance of aztec3.
+// The unbox logic can be tested locally by running `$ts-node --esm src/bin/index.ts unbox PrivateToken`
+// from `yarn-project/cli/`
+import { LogFn } from '@aztec/foundation/log';
+
+import { promises as fs } from 'fs';
+import JSZip from 'jszip';
+import fetch from 'node-fetch';
+import * as path from 'path';
+
+const GITHUB_OWNER = 'AztecProtocol';
+const GITHUB_REPO = 'aztec-packages';
+const NOIR_CONTRACTS_PATH = 'yarn-project/noir-contracts/src/contracts';
+const BOXES_PATH = 'yarn-project/boxes';
+
+/**
+ * Converts a contract name in "upper camel case" to a folder name in snake case.
+ * @param contractName - The contract name.
+ * @returns The folder name.
+ * */
+function contractNameToFolder(contractName: string): string {
+  return contractName.replace(/[\w]([A-Z])/g, m => m[0] + '_' + m[1]).toLowerCase();
+}
+
+/**
+ * If the box contains the noir contract source code, we don't need to download it from github.
+ * Otherwise, we download the contract source code from the `noir-contracts` and `noir-libs` subpackages.
+ */
+async function isDirectoryNonEmpty(directoryPath: string): Promise<boolean> {
+  const files = await fs.readdir(directoryPath);
+  return files.length > 0;
+}
+
+/**
+ *
+ * @param data - in memory unzipped clone of a github repo
+ * @param repositoryFolderPath - folder to copy from github repo
+ * @param localOutputPath - local path to copy to
+ */
+async function copyFolderFromGithub(data: JSZip, repositoryFolderPath: string, localOutputPath: string, log: LogFn) {
+  log('downloading from github:', repositoryFolderPath);
+  const repositoryDirectories = Object.values(data.files).filter(file => {
+    return file.dir && file.name.startsWith(repositoryFolderPath);
+  });
+
+  for (const directory of repositoryDirectories) {
+    const relativePath = directory.name.replace(repositoryFolderPath, '');
+    const targetPath = `${localOutputPath}/${relativePath}`;
+    await fs.mkdir(targetPath, { recursive: true });
+  }
+
+  const starterFiles = Object.values(data.files).filter(file => {
+    return !file.dir && file.name.startsWith(repositoryFolderPath);
+  });
+
+  for (const file of starterFiles) {
+    const relativePath = file.name.replace(repositoryFolderPath, '');
+    const targetPath = `${localOutputPath}/${relativePath}`;
+    const content = await file.async('nodebuffer');
+    await fs.writeFile(targetPath, content);
+  }
+}
+
+/**
+ * Not flexible at at all, but quick fix to download a noir smart contract from our
+ * monorepo on github.  this will copy over the `yarn-projects/boxes/{contract_name}` folder
+ * as well as the specified `directoryPath` if the box doesn't include source code
+ * `directoryPath` should point to a single noir contract in `yarn-projects/noir-contracts/src/contracts/...`
+ * @param tagVersion - the version of the CLI that is running.  we pull from the corresponding tag in the monorepo
+ * @param directoryPath - path to a noir contract's source code (folder) in the github repo
+ * @param outputPath - local path that we will copy the noir contracts and web3 starter kit to
+ * @returns
+ */
+async function downloadContractAndBoxFromGithub(
+  tagVersion: string,
+  contractName: string,
+  outputPath: string,
+  log: LogFn,
+): Promise<void> {
+  // small string conversion, in the ABI the contract name looks like PrivateToken
+  // but in the repostory it looks like private_token
+  const snakeCaseContractName = contractNameToFolder(contractName);
+
+  log(`Downloaded '@aztex/boxes/${snakeCaseContractName}' to ${outputPath}`);
+  // Step 1: Fetch the monorepo ZIP from GitHub, matching the CLI version
+  const url = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/refs/tags/aztec-packages-v${tagVersion}.zip`;
+  const response = await fetch(url);
+  const buffer = await response.arrayBuffer();
+
+  const zip = new JSZip();
+  const data = await zip.loadAsync(buffer);
+
+  // Step 2: copy the '@aztec/boxes/{contract-name}' subpackage to the output directory
+  // this is currently only implemented for PrivateToken under 'boxes/private-token/'
+  const repoDirectoryPrefix = `${GITHUB_REPO}-v${tagVersion}/`;
+
+  const boxPath = `${repoDirectoryPrefix}${BOXES_PATH}/${snakeCaseContractName}`;
+  await copyFolderFromGithub(data, boxPath, outputPath, log);
+
+  const boxContainsNoirSource = await isDirectoryNonEmpty(`${outputPath}/src/contracts`);
+  if (boxContainsNoirSource) {
+    return;
+  }
+  // this remaining logic only kicks in if the box doesn't already have a src/contracts folder
+  // in which case we optimistically grab the noir source files from the
+  // noir-contracts and noir-libs subpackages and pray that the versions are compatible
+
+  // source noir files for the contract are in this folder
+  const contractFolder = `${NOIR_CONTRACTS_PATH}/${snakeCaseContractName}_contract`;
+  // copy the noir contracts to the output directory under subdir /src/contracts/
+  const contractDirectoryPath = `${repoDirectoryPrefix}${contractFolder}/`;
+
+  const contractFiles = Object.values(data.files).filter(file => {
+    return !file.dir && file.name.startsWith(contractDirectoryPath);
+  });
+
+  const contractTargetDirectory = path.join(outputPath, 'src', 'contracts');
+  await fs.mkdir(contractTargetDirectory, { recursive: true });
+  // Nargo.toml file needs to be in the root of the contracts directory,
+  // and noir files in the src/ subdirectory
+  await fs.mkdir(path.join(contractTargetDirectory, 'src'), { recursive: true });
+  for (const file of contractFiles) {
+    const targetPath = path.join(contractTargetDirectory, file.name.replace(contractDirectoryPath, ''));
+    log(`Copying ${file.name} to ${targetPath}`);
+    const content = await file.async('nodebuffer');
+    await fs.writeFile(targetPath, content);
+    log(`Copied ${file.name} to ${targetPath}`);
+  }
+}
+/**
+ * Does some conversion from the package/build configurations in the monorepo to the
+ * something usable by the copied standalone unboxed folder.  Adjusts relative paths
+ * and package versions.
+ * @param packageVersion - CLI npm version, which determines what npm version to grab
+ * @param outputPath - relative path where we are copying everything
+ * @param log - logger
+ */
+async function updatePackagingConfigurations(packageVersion: string, outputPath: string, log: LogFn): Promise<void> {
+  await updatePackageJsonVersions(packageVersion, outputPath, log);
+  await updateTsConfig(outputPath, log);
+  await updateNargoToml(packageVersion, outputPath, log);
+}
+
+/**
+ * adjust the contract Nargo.toml file to use the same repository version as the npm packages
+ * @param packageVersion - CLI npm version, which determines what npm version to grab
+ * @param outputPath - relative path where we are copying everything
+ * @param log - logger
+ */
+async function updateNargoToml(packageVersion: string, outputPath: string, log: LogFn): Promise<void> {
+  const nargoTomlPath = path.join(outputPath, 'src', 'contracts', 'Nargo.toml');
+  const fileContent = await fs.readFile(nargoTomlPath, 'utf-8');
+  const lines = fileContent.split('\n');
+  const updatedLines = lines.map(line => line.replace(/tag="master"/g, `tag="v${packageVersion}"`));
+  const updatedContent = updatedLines.join('\n');
+  await fs.writeFile(nargoTomlPath, updatedContent);
+  log(`Updated Nargo.toml to point to local copy of noir-libs`);
+}
+
+/**
+ * The `tsconfig.json` also needs to be updated to remove the "references" section, which
+ * points to the monorepo's subpackages.  Those are unavailable in the cloned subpackage,
+ * so we remove the entries to install the the workspace packages from npm.
+ * @param outputPath - directory we are unboxing to
+ */
+async function updateTsConfig(outputPath: string, log: LogFn) {
+  try {
+    const tsconfigJsonPath = path.join(outputPath, 'tsconfig.json');
+    const data = await fs.readFile(tsconfigJsonPath, 'utf8');
+    const config = JSON.parse(data);
+
+    delete config.references;
+
+    const updatedData = JSON.stringify(config, null, 2);
+    await fs.writeFile(tsconfigJsonPath, updatedData, 'utf8');
+
+    log('tsconfig.json has been updated');
+  } catch (error) {
+    log('Error updating tsconfig.json:', error);
+    throw error;
+  }
+}
+
+/**
+ * We pin to "workspace:^" in the package.json for subpackages, but we need to replace it with
+ * an the actual version number in the cloned starter kit
+ * We modify the copied package.json and pin to the version of the package that was downloaded
+ * @param packageVersion - CLI npm version, which determines what npm version to grab
+ * @param outputPath - directory we are unboxing to
+ * @param log - logger
+ */
+async function updatePackageJsonVersions(packageVersion: string, outputPath: string, log: LogFn): Promise<void> {
+  const packageJsonPath = path.join(outputPath, 'package.json');
+  const fileContent = await fs.readFile(packageJsonPath, 'utf-8');
+  const packageData = JSON.parse(fileContent);
+
+  // Check and replace "workspace^" pins in dependencies, which are monorepo yarn workspace references
+  if (packageData.dependencies) {
+    for (const [key, value] of Object.entries(packageData.dependencies)) {
+      if (value === 'workspace:^') {
+        packageData.dependencies[key] = `^${packageVersion}`;
+      }
+    }
+  }
+
+  // Check and replace in devDependencies
+  if (packageData.devDependencies) {
+    for (const [key, value] of Object.entries(packageData.devDependencies)) {
+      if (value === 'workspace:^') {
+        // TODO: check if this right post landing.  the package.json version looks like 0.1.0
+        // but the npm versions look like v0.1.0-alpha63 so we are not fully pinned
+        packageData.devDependencies[key] = `^${packageVersion}`;
+      }
+    }
+  }
+
+  // modify the version of the sandbox to pull - it's set to "latest" version in the monorepo,
+  // but we need to replace with the same tagVersion as the cli and the other aztec npm packages
+  // similarly, make sure we spinup the sandbox with the same version.
+  packageData.scripts['install:sandbox'] = packageData.scripts['install:sandbox'].replace(
+    'latest',
+    `v${packageVersion}`,
+  );
+
+  packageData.scripts['start:sandbox'] = packageData.scripts['start:sandbox'].replace('latest', `v${packageVersion}`);
+
+  // Convert back to a string and write back to the package.json file
+  const updatedContent = JSON.stringify(packageData, null, 2);
+  await fs.writeFile(packageJsonPath, updatedContent);
+
+  log(`Updated package.json versions to ${packageVersion}`);
+}
+
+/**
+ *
+ * @param outputDirectoryName - user specified directory we are "unboxing" files into
+ * @param log - logger
+ * @returns
+ */
+async function createDirectory(outputDirectoryName: string, log: LogFn): Promise<string> {
+  const absolutePath = path.resolve(outputDirectoryName);
+
+  try {
+    // Checking if the path exists and if it is a directory
+    const stats = await fs.stat(absolutePath);
+    if (!stats.isDirectory()) {
+      throw new Error(`The specified path ${outputDirectoryName} is not a directory/folder.`);
+    }
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      await fs.mkdir(absolutePath, { recursive: true });
+      log(`The directory did not exist and has been created: ${absolutePath}`);
+    } else {
+      throw error;
+    }
+  }
+
+  return absolutePath;
+}
+
+/**
+ * Unboxes a contract from `@aztec/boxes` by performing the following operations:
+ * 1. Copies the frontend template from `@aztec/boxes/{contract_name}` to the outputDirectory
+ * 2. Checks if the contract source was copied over from `@aztec/boxes/{contract_name}/src/contracts`
+ * 3. If not, copies the contract from the appropriate `@aztec/noir-contracts/src/contracts/...` folder.
+ *
+ * The box provides a simple React app which parses the contract ABI
+ * and generates a UI to deploy + interact with the contract on a local aztec testnet.
+ * @param contractName - name of contract from `@aztec/noir-contracts`, in a format like "PrivateToken" (rather than "private_token", as it appears in the noir-contracts repo)
+ * @param log - Logger instance that will output to the CLI
+ */
+export async function unboxContract(
+  contractName: string,
+  outputDirectoryName: string,
+  packageVersion: string,
+  log: LogFn,
+) {
+  const contractNames = ['PrivateToken'];
+
+  if (!contractNames.includes(contractName)) {
+    log(
+      `The noir contract named "${contractName}" was not found in "@aztec/boxes" package.  Valid options are: 
+        ${contractNames.join('\n\t')}
+      We recommend "PrivateToken" as a default.`,
+    );
+    return;
+  }
+  const outputPath = await createDirectory(outputDirectoryName, log);
+
+  // downloads the selected contract's relevant folder in @aztec/boxes/{contract_name}
+  // and the noir source code from `noir-contracts` into `${outputDirectoryName}/src/contracts`
+  // if not present in the box
+  await downloadContractAndBoxFromGithub(packageVersion, contractName, outputPath, log);
+  // make adjustments for packaging to work as a standalone, as opposed to part of yarn workspace
+  // as in the monorepo source files
+  await updatePackagingConfigurations(packageVersion, outputPath, log);
+}