@aztec/cli 0.7.9 → 0.8.4

package/src/unbox.ts

@@ -17,18 +17,8 @@ import * as path from 'path';
 const GITHUB_OWNER = 'AztecProtocol';
 const GITHUB_REPO = 'aztec-packages';
 const GITHUB_TAG_PREFIX = '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 or kebab case.
- * @param contractName - The contract name.
- * @returns The folder name.
- * */
-function contractNameToFolder(contractName: string, separator = '-'): string {
-  return contractName.replace(/[\w]([A-Z])/g, m => `${m[0]}${separator}${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.
@@ -50,7 +40,7 @@ async function isDirectoryNonEmpty(directoryPath: string): Promise<boolean> {
  * @param localOutputPath - local path to copy to
  */
 async function copyFolderFromGithub(data: JSZip, repositoryFolderPath: string, localOutputPath: string, log: LogFn) {
-  log(`Downloading from github: ${repositoryFolderPath}`);
+  log(`Downloading folder from github: ${repositoryFolderPath}`);
   const repositoryDirectories = Object.values(data.files).filter(file => {
     return file.dir && file.name.startsWith(repositoryFolderPath);
   });
@@ -61,11 +51,11 @@ async function copyFolderFromGithub(data: JSZip, repositoryFolderPath: string, l
     await fs.mkdir(targetPath, { recursive: true });
   }
 
-  const starterFiles = Object.values(data.files).filter(file => {
+  const folderFiles = Object.values(data.files).filter(file => {
     return !file.dir && file.name.startsWith(repositoryFolderPath);
   });
 
-  for (const file of starterFiles) {
+  for (const file of folderFiles) {
     const relativePath = file.name.replace(repositoryFolderPath, '');
     const targetPath = `${localOutputPath}/${relativePath}`;
     const content = await file.async('nodebuffer');
@@ -73,6 +63,27 @@ async function copyFolderFromGithub(data: JSZip, repositoryFolderPath: string, l
   }
 }
 
+/**
+ * @param data - in memory unzipped clone of a github repo
+ * @param repositoryFile - path of the file to copy from github repo
+ * @param localOutputPath - local path to copy the file to
+ */
+async function copyFileFromGithub(data: JSZip, repositoryFile: string, localOutputPath: string, log: LogFn) {
+  log(`Downloading file from github: ${repositoryFile}`);
+
+  const file = data.files[repositoryFile];
+
+  if (!file || file.dir) {
+    throw new Error(`File not found or it's a directory: ${repositoryFile}`);
+  }
+
+  const filename = path.basename(repositoryFile);
+  const targetPath = `${localOutputPath}/${filename}`;
+
+  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
@@ -92,8 +103,7 @@ async function downloadContractAndBoxFromGithub(
   // small string conversion, in the ABI the contract name looks like PrivateToken
   // but in the repostory it looks like private_token
 
-  const kebabCaseContractName = contractNameToFolder(contractName, '-');
-  log(`Downloading @aztex/boxes/${kebabCaseContractName} to ${outputPath}...`);
+  log(`Downloading @aztex/boxes/${contractName} 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/${tag}.zip`;
   const response = await fetch(url);
@@ -103,40 +113,26 @@ async function downloadContractAndBoxFromGithub(
   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/'
+  // this is currently only implemented for `blank` and `private-token` under 'boxes/{box-name}/'
   const repoDirectoryPrefix = `${GITHUB_REPO}-${tag}`;
 
-  const boxPath = `${repoDirectoryPrefix}/${BOXES_PATH}/${kebabCaseContractName}`;
+  const boxPath = `${repoDirectoryPrefix}/${BOXES_PATH}/${contractName}`;
   await copyFolderFromGithub(data, boxPath, outputPath, log);
 
+  // the expected noir version is contained in
+  // aztec-packages/yarn-project/noir-compiler/src/noir-version.json
+  // copy it in and use to update the package.json script to install that version of noir
+  const noirVersionPath = `${repoDirectoryPrefix}/yarn-project/noir-compiler/src/noir-version.json`;
+  await copyFileFromGithub(data, noirVersionPath, outputPath, log);
+
   const contractTargetDirectory = path.join(outputPath, 'src', 'contracts');
   const boxContainsNoirSource = await isDirectoryNonEmpty(contractTargetDirectory);
   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
-  log('Copying noir contracts...');
-
-  // source noir files for the contract are in this folder
-  const snakeCaseContractName = contractNameToFolder(contractName, '_');
-  const contractDirectoryPath = `${repoDirectoryPrefix}/${NOIR_CONTRACTS_PATH}/${snakeCaseContractName}_contract`;
-  // copy the noir contracts to the output directory under subdir /src/contracts/
-  const contractFiles = Object.values(data.files).filter(file => {
-    return !file.dir && file.name.startsWith(contractDirectoryPath);
-  });
-
-  // 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 filename = file.name.replace(`${contractDirectoryPath}/`, '');
-    const targetPath = path.join(contractTargetDirectory, filename);
-    const content = await file.async('nodebuffer');
-    await fs.writeFile(targetPath, content);
-    log(` ✓ ${filename}`);
+  } else {
+    // we used to support downloading from the noir contracts monorepo but now force box to contain source code
+    // This should never happen, because of the check we do initially on the box name.
+    throw Error(`Box ${contractName} does not contain noir source code.`);
   }
 }
 /**
@@ -232,16 +228,23 @@ async function updatePackageJsonVersions(packageVersion: string, outputPath: str
       }
     }
   }
+  // read the `noir-version.json`, grab the expected noir version, and patch the noir install script
+  const noirVersionPath = path.join(outputPath, 'noir-version.json');
+  const noirVersionContent = await fs.readFile(noirVersionPath, 'utf-8');
+  const noirVersionJSON = JSON.parse(noirVersionContent);
+  const noirTag = noirVersionJSON.tag;
+  packageData.scripts['install:noir'] = packageData.scripts['install:noir'].replace('NOIR_VERSION', `${noirTag}`);
+  log(`Updated Noir version to: ${noirTag}`);
 
   // 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}`,
+    `${packageVersion}`,
   );
 
-  packageData.scripts['start:sandbox'] = packageData.scripts['start:sandbox'].replace('latest', `v${packageVersion}`);
+  packageData.scripts['start:sandbox'] = packageData.scripts['start:sandbox'].replace('latest', `${packageVersion}`);
 
   // Convert back to a string and write back to the package.json file
   const updatedContent = JSON.stringify(packageData, null, 2);
@@ -294,13 +297,13 @@ export async function unboxContract(
   packageVersion: string,
   log: LogFn,
 ) {
-  const contractNames = ['PrivateToken'];
+  const contractNames = ['private-token', 'blank', 'blank-react'];
 
   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.`,
+      We recommend "private-token" as a default.`,
     );
     return;
   }
@@ -308,17 +311,17 @@ export async function unboxContract(
 
   const tag = `${GITHUB_TAG_PREFIX}-v${packageVersion}`;
   // 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(tag, 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
+  // as in the monorepo source files.  replace things like "workspace^" with the actual version number
   await updatePackagingConfigurations(packageVersion, tag, outputPath, log);
 
   log('');
-  log(`${contractName} has been successfully initialised!`);
+  log(`${contractName} has been successfully initialized!`);
   log('To get started, simply run the following commands:');
   log(`    cd ${outputDirectoryName}`);
   log('    yarn');
+  log('    yarn start:sandbox');
+  log('And in another terminal in the same directory,');
   log('    yarn start:dev');
 }

package/src/utils.ts

@@ -1,14 +1,26 @@
-import { AztecAddress, AztecRPC } from '@aztec/aztec.js';
-import { createEthereumChain, deployL1Contracts } from '@aztec/ethereum';
+import { AztecAddress, Fr, GrumpkinScalar, PXE, Point, TxHash } from '@aztec/aztec.js';
+import { L1ContractArtifactsForDeployment, createEthereumChain, deployL1Contracts } from '@aztec/ethereum';
 import { ContractAbi } from '@aztec/foundation/abi';
 import { DebugLogger, LogFn } from '@aztec/foundation/log';
+import {
+  ContractDeploymentEmitterAbi,
+  ContractDeploymentEmitterBytecode,
+  InboxAbi,
+  InboxBytecode,
+  OutboxAbi,
+  OutboxBytecode,
+  RegistryAbi,
+  RegistryBytecode,
+  RollupAbi,
+  RollupBytecode,
+} from '@aztec/l1-artifacts';
 
+import { InvalidArgumentError } from 'commander';
 import fs from 'fs';
 import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 
 import { encodeArgs } from './encoding.js';
 
-export { createClient } from './client.js';
 /**
  * Helper type to dynamically import contracts.
  */
@@ -46,7 +58,29 @@ export async function deployAztecContracts(
 ) {
   const account = !privateKey ? mnemonicToAccount(mnemonic!) : privateKeyToAccount(`0x${privateKey}`);
   const chain = createEthereumChain(rpcUrl, apiKey);
-  return await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger);
+  const l1Artifacts: L1ContractArtifactsForDeployment = {
+    contractDeploymentEmitter: {
+      contractAbi: ContractDeploymentEmitterAbi,
+      contractBytecode: ContractDeploymentEmitterBytecode,
+    },
+    registry: {
+      contractAbi: RegistryAbi,
+      contractBytecode: RegistryBytecode,
+    },
+    inbox: {
+      contractAbi: InboxAbi,
+      contractBytecode: InboxBytecode,
+    },
+    outbox: {
+      contractAbi: OutboxAbi,
+      contractBytecode: OutboxBytecode,
+    },
+    rollup: {
+      contractAbi: RollupAbi,
+      contractBytecode: RollupBytecode,
+    },
+  };
+  return await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger, l1Artifacts);
 }
 
 /**
@@ -90,23 +124,23 @@ export async function getContractAbi(fileDir: string, log: LogFn) {
 
 /**
  * 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.
+ * or from the first account that is found in a PXE instance.
+ * @param pxe - The PXE 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) {
+export async function getTxSender(pxe: PXE, _from?: string) {
   let from: AztecAddress;
   if (_from) {
     try {
       from = AztecAddress.fromString(_from);
     } catch {
-      throw new Error(`Invalid option 'from' passed: ${_from}`);
+      throw new InvalidArgumentError(`Invalid option 'from' passed: ${_from}`);
     }
   } else {
-    const accounts = await client.getRegisteredAccounts();
+    const accounts = await pxe.getRegisteredAccounts();
     if (!accounts.length) {
-      throw new Error('No accounts found in Aztec RPC instance.');
+      throw new Error('No accounts found in PXE instance.');
     }
     from = accounts[0].address;
   }
@@ -116,28 +150,161 @@ export async function getTxSender(client: AztecRPC, _from?: string) {
 /**
  * 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 contractAddress - Aztec Address of the contract.
  * @param functionName - Name of the function to be called.
  * @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 async function prepTx(
-  contractFile: string,
-  _contractAddress: string,
-  functionName: string,
-  _functionArgs: string[],
-  log: LogFn,
-) {
-  let contractAddress;
-  try {
-    contractAddress = AztecAddress.fromString(_contractAddress);
-  } catch {
-    throw new Error(`Unable to parse contract address ${_contractAddress}.`);
-  }
+export async function prepTx(contractFile: string, functionName: string, _functionArgs: string[], log: LogFn) {
   const contractAbi = await getContractAbi(contractFile, log);
   const functionAbi = getAbiFunction(contractAbi, functionName);
   const functionArgs = encodeArgs(_functionArgs, functionAbi.parameters);
 
-  return { contractAddress, functionArgs, contractAbi };
+  return { functionArgs, contractAbi };
+}
+
+/**
+ * Removes the leading 0x from a hex string. If no leading 0x is found the string is returned unchanged.
+ * @param hex - A hex string
+ * @returns A new string with leading 0x removed
+ */
+export const stripLeadingHex = (hex: string) => {
+  if (hex.length > 2 && hex.startsWith('0x')) {
+    return hex.substring(2);
+  }
+  return hex;
+};
+
+/**
+ * Parses a hex encoded string to an Fr integer to be used as salt
+ * @param str - Hex encoded string
+ * @returns A integer to be used as salt
+ */
+export function parseSaltFromHexString(str: string): Fr {
+  const hex = stripLeadingHex(str);
+
+  // ensure it's a hex string
+  if (!hex.match(/^[0-9a-f]+$/i)) {
+    throw new InvalidArgumentError('Invalid hex string');
+  }
+
+  // pad it so that we may read it as a buffer.
+  // Buffer needs _exactly_ two hex characters per byte
+  const padded = hex.length % 2 === 1 ? '0' + hex : hex;
+
+  // finally, turn it into an integer
+  return Fr.fromBuffer(Buffer.from(padded, 'hex'));
+}
+
+/**
+ * Parses an AztecAddress from a string. Throws InvalidArgumentError if the string is not a valid.
+ * @param address - A serialised Aztec address
+ * @returns An Aztec address
+ */
+export function parseAztecAddress(address: string): AztecAddress {
+  try {
+    return AztecAddress.fromString(address);
+  } catch {
+    throw new InvalidArgumentError(`Invalid address: ${address}`);
+  }
+}
+
+/**
+ * Parses a TxHash from a string. Throws InvalidArgumentError if the string is not a valid.
+ * @param txHash - A transaction hash
+ * @returns A TxHash instance
+ */
+export function parseTxHash(txHash: string): TxHash {
+  try {
+    return TxHash.fromString(txHash);
+  } catch {
+    throw new InvalidArgumentError(`Invalid transaction hash: ${txHash}`);
+  }
+}
+
+/**
+ * Parses a public key from a string. Throws InvalidArgumentError if the string is not a valid.
+ * @param publicKey - A public key
+ * @returns A Point instance
+ */
+export function parsePublicKey(publicKey: string): Point {
+  try {
+    return Point.fromString(publicKey);
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid public key: ${publicKey}`);
+  }
+}
+
+/**
+ * Parses a partial address from a string. Throws InvalidArgumentError if the string is not a valid.
+ * @param address - A partial address
+ * @returns A Fr instance
+ */
+export function parsePartialAddress(address: string): Fr {
+  try {
+    return Fr.fromString(address);
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid partial address: ${address}`);
+  }
+}
+
+/**
+ * Parses a private key from a string. Throws InvalidArgumentError if the string is not a valid.
+ * @param privateKey - A string
+ * @returns A private key
+ */
+export function parsePrivateKey(privateKey: string): GrumpkinScalar {
+  try {
+    const value = GrumpkinScalar.fromString(privateKey);
+    // most likely a badly formatted key was passed
+    if (value.isZero()) {
+      throw new Error('Private key must not be zero');
+    }
+
+    return value;
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid private key: ${privateKey}`);
+  }
+}
+
+/**
+ * Parses a field from a string. Throws InvalidArgumentError if the string is not a valid field value.
+ * @param field - A string representing the field.
+ * @returns A field.
+ */
+export function parseField(field: string): Fr {
+  try {
+    const isHex = field.startsWith('0x') || field.match(new RegExp(`^[0-9a-f]{${Fr.SIZE_IN_BYTES * 2}}$`, 'i'));
+    if (isHex) {
+      return Fr.fromString(field);
+    }
+
+    if (['true', 'false'].includes(field)) {
+      return new Fr(field === 'true');
+    }
+
+    const isNumber = +field || field === '0';
+    if (isNumber) {
+      return new Fr(BigInt(field));
+    }
+
+    const isBigInt = field.endsWith('n');
+    if (isBigInt) {
+      return new Fr(BigInt(field.replace(/n$/, '')));
+    }
+
+    return new Fr(BigInt(field));
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid field: ${field}`);
+  }
+}
+
+/**
+ * Parses an array of strings to Frs.
+ * @param fields - An array of strings representing the fields.
+ * @returns An array of Frs.
+ */
+export function parseFields(fields: string[]): Fr[] {
+  return fields.map(parseField);
 }

package/.eslintrc.cjs

@@ -1 +0,0 @@
-module.exports = require('@aztec/foundation/eslint');