@aztec/cli 0.8.9 → 0.8.11

package/src/index.ts

@@ -11,9 +11,10 @@ import {
 import { StructType, decodeFunctionSignatureWithParameterNames } from '@aztec/foundation/abi';
 import { JsonStringify } from '@aztec/foundation/json-rpc';
 import { DebugLogger, LogFn } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
 import { fileURLToPath } from '@aztec/foundation/url';
 import { compileContract, generateNoirInterface, generateTypescriptInterface } from '@aztec/noir-compiler/cli';
-import { CompleteAddress, ContractData, L2BlockL2Logs } from '@aztec/types';
+import { CompleteAddress, ContractData, LogFilter } from '@aztec/types';
 
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { Command, Option } from 'commander';
@@ -27,13 +28,18 @@ import { encodeArgs, parseStructString } from './encoding.js';
 import { unboxContract } from './unbox.js';
 import {
   deployAztecContracts,
-  getAbiFunction,
-  getContractAbi,
+  getContractArtifact,
   getExampleContractArtifacts,
+  getFunctionArtifact,
   getTxSender,
   parseAztecAddress,
   parseField,
   parseFields,
+  parseOptionalAztecAddress,
+  parseOptionalInteger,
+  parseOptionalLogId,
+  parseOptionalSelector,
+  parseOptionalTxHash,
   parsePartialAddress,
   parsePrivateKey,
   parsePublicKey,
@@ -150,18 +156,29 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       createPrivateKeyOption('Private key for note encryption and transaction signing. Uses random by default.', false),
     )
     .addOption(pxeOption)
-    .action(async options => {
-      const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const privateKey = options.privateKey ?? GrumpkinScalar.random();
+    // `options.wait` is default true. Passing `--no-wait` will set it to false.
+    // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
+    .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
+    .action(async ({ rpcUrl, privateKey, wait }) => {
+      const client = await createCompatibleClient(rpcUrl, debugLogger);
+      const actualPrivateKey = privateKey ?? GrumpkinScalar.random();
 
-      const account = getSchnorrAccount(client, privateKey, privateKey, accountCreationSalt);
-      const wallet = await account.waitDeploy();
-      const { address, publicKey, partialAddress } = wallet.getCompleteAddress();
+      const account = getSchnorrAccount(client, actualPrivateKey, actualPrivateKey, accountCreationSalt);
+      const { address, publicKey, partialAddress } = await account.getCompleteAddress();
+      const tx = await account.deploy();
+      const txHash = await tx.getTxHash();
+      debugLogger(`Account contract tx sent with hash ${txHash}`);
+      if (wait) {
+        log(`\nWaiting for account contract deployment...`);
+        await tx.wait();
+      } else {
+        log(`\nAccount deployment transaction hash: ${txHash}\n`);
+      }
 
-      log(`\nCreated new account:\n`);
+      log(`\nNew account:\n`);
       log(`Address:         ${address.toString()}`);
       log(`Public key:      ${publicKey.toString()}`);
-      if (!options.privateKey) log(`Private key:     ${privateKey.toString(true)}`);
+      if (!privateKey) log(`Private key:     ${actualPrivateKey.toString(true)}`);
       log(`Partial address: ${partialAddress.toString()}`);
     });
 
@@ -169,8 +186,8 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .command('deploy')
     .description('Deploys a compiled Aztec.nr contract to Aztec.')
     .argument(
-      '<abi>',
-      "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts",
+      '<artifact>',
+      "A compiled Aztec.nr contract's artifact in JSON format or name of a contract artifact exported by @aztec/noir-contracts",
     )
     .option('-a, --args <constructorArgs...>', 'Contract constructor arguments', [])
     .addOption(pxeOption)
@@ -187,18 +204,18 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     // `options.wait` is default true. Passing `--no-wait` will set it to false.
     // https://github.com/tj/commander.js#other-option-types-negatable-boolean-and-booleanvalue
     .option('--no-wait', 'Skip waiting for the contract to be deployed. Print the hash of deployment transaction')
-    .action(async (abiPath, { rpcUrl, publicKey, args: rawArgs, salt, wait }) => {
-      const contractAbi = await getContractAbi(abiPath, log);
-      const constructorAbi = contractAbi.functions.find(({ name }) => name === 'constructor');
+    .action(async (artifactPath, { rpcUrl, publicKey, args: rawArgs, salt, wait }) => {
+      const contractArtifact = await getContractArtifact(artifactPath, log);
+      const constructorArtifact = contractArtifact.functions.find(({ name }) => name === 'constructor');
 
       const client = await createCompatibleClient(rpcUrl, debugLogger);
-      const deployer = new ContractDeployer(contractAbi, client, publicKey);
+      const deployer = new ContractDeployer(contractArtifact, client, publicKey);
 
-      const constructor = getAbiFunction(contractAbi, 'constructor');
+      const constructor = getFunctionArtifact(contractArtifact, 'constructor');
       if (!constructor) throw new Error(`Constructor not found in contract ABI`);
 
       debugLogger(`Input arguments: ${rawArgs.map((x: any) => `"${x}"`).join(', ')}`);
-      const args = encodeArgs(rawArgs, constructorAbi!.parameters);
+      const args = encodeArgs(rawArgs, constructorArtifact!.parameters);
       debugLogger(`Encoded arguments: ${args.join(', ')}`);
 
       const tx = deployer.deploy(...args).send({ contractAddressSalt: salt });
@@ -208,7 +225,8 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
         const deployed = await tx.wait();
         log(`\nContract deployed at ${deployed.contractAddress!.toString()}\n`);
       } else {
-        log(`\nDeployment transaction hash: ${txHash}\n`);
+        log(`\nContract Address: ${tx.completeContractAddress?.address.toString() ?? 'N/A'}`);
+        log(`Deployment transaction hash: ${txHash}\n`);
       }
     });
 
@@ -277,22 +295,58 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
 
   program
     .command('get-logs')
-    .description('Gets all the unencrypted logs from L2 blocks in the range specified.')
-    .option('-f, --from <blockNum>', 'Initial block number for getting logs (defaults to 1).')
-    .option('-l, --limit <blockCount>', 'How many blocks to fetch (defaults to 100).')
+    .description('Gets all the unencrypted logs from an intersection of all the filter params.')
+    .option('-tx, --tx-hash <txHash>', 'A transaction hash to get the receipt for.', parseOptionalTxHash)
+    .option(
+      '-fb, --from-block <blockNum>',
+      'Initial block number for getting logs (defaults to 1).',
+      parseOptionalInteger,
+    )
+    .option('-tb, --to-block <blockNum>', 'Up to which block to fetch logs (defaults to latest).', parseOptionalInteger)
+    .option('-al --after-log <logId>', 'ID of a log after which to fetch the logs.', parseOptionalLogId)
+    .option('-ca, --contract-address <address>', 'Contract address to filter logs by.', parseOptionalAztecAddress)
+    .option('-s, --selector <hex string>', 'Event selector to filter logs by.', parseOptionalSelector)
     .addOption(pxeOption)
-    .action(async options => {
-      const { from, limit } = options;
-      const fromBlock = from ? parseInt(from) : 1;
-      const limitCount = limit ? parseInt(limit) : 100;
+    .option('--follow', 'If set, will keep polling for new logs until interrupted.')
+    .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, selector, rpcUrl, follow }) => {
+      const pxe = await createCompatibleClient(rpcUrl, debugLogger);
 
-      const client = await createCompatibleClient(options.rpcUrl, debugLogger);
-      const logs = await client.getUnencryptedLogs(fromBlock, limitCount);
-      if (!logs.length) {
-        log(`No logs found in blocks ${fromBlock} to ${fromBlock + limitCount}`);
+      if (follow) {
+        if (txHash) throw Error('Cannot use --follow with --tx-hash');
+        if (toBlock) throw Error('Cannot use --follow with --to-block');
+      }
+
+      const filter: LogFilter = { txHash, fromBlock, toBlock, afterLog, contractAddress, selector };
+
+      const fetchLogs = async () => {
+        const response = await pxe.getUnencryptedLogs(filter);
+        const logs = response.logs;
+
+        if (!logs.length) {
+          const filterOptions = Object.entries(filter)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join(', ');
+          if (!follow) log(`No logs found for filter: {${filterOptions}}`);
+        } else {
+          if (!follow && !filter.afterLog) log('Logs found: \n');
+          logs.forEach(unencryptedLog => log(unencryptedLog.toHumanReadable()));
+          // Set the continuation parameter for the following requests
+          filter.afterLog = logs[logs.length - 1].id;
+        }
+        return response.maxLogsHit;
+      };
+
+      if (follow) {
+        log('Fetching logs...');
+        while (true) {
+          const maxLogsHit = await fetchLogs();
+          if (!maxLogsHit) await sleep(1000);
+        }
       } else {
-        log('Logs found: \n');
-        L2BlockL2Logs.unrollLogs(logs).forEach(fnLog => log(`${fnLog.toString('ascii')}\n`));
+        while (await fetchLogs()) {
+          // Keep fetching logs until we reach the end.
+        }
       }
     });
 
@@ -385,7 +439,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .argument('<functionName>', 'Name of function to execute')
     .option('-a, --args [functionArgs...]', 'Function arguments', [])
     .requiredOption(
-      '-c, --contract-abi <fileLocation>',
+      '-c, --contract-artifact <fileLocation>',
       "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.', parseAztecAddress)
@@ -393,14 +447,19 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .addOption(pxeOption)
     .option('--no-wait', 'Print transaction hash without waiting for it to be mined')
     .action(async (functionName, options) => {
-      const { functionArgs, contractAbi } = await prepTx(options.contractAbi, functionName, options.args, log);
+      const { functionArgs, contractArtifact } = await prepTx(
+        options.contractArtifact,
+        functionName,
+        options.args,
+        log,
+      );
       const { contractAddress, privateKey } = options;
 
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
       const wallet = await getSchnorrAccount(client, privateKey, privateKey, accountCreationSalt).getWallet();
-      const contract = await Contract.at(contractAddress, contractAbi, wallet);
+      const contract = await Contract.at(contractAddress, contractArtifact, wallet);
       const tx = contract.methods[functionName](...functionArgs).send();
-      log(`Transaction hash: ${(await tx.getTxHash()).toString()}`);
+      log(`\nTransaction hash: ${(await tx.getTxHash()).toString()}`);
       if (options.wait) {
         await tx.wait();
 
@@ -411,7 +470,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
         log(`Block number: ${receipt.blockNumber}`);
         log(`Block hash: ${receipt.blockHash?.toString('hex')}`);
       } else {
-        log('\nTransaction pending. Check status with get-tx-receipt');
+        log('Transaction pending. Check status with get-tx-receipt');
       }
     });
 
@@ -423,19 +482,24 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .argument('<functionName>', 'Name of function to call')
     .option('-a, --args [functionArgs...]', 'Function arguments', [])
     .requiredOption(
-      '-c, --contract-abi <fileLocation>',
+      '-c, --contract-artifact <fileLocation>',
       "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.', parseAztecAddress)
     .option('-f, --from <string>', 'Aztec address of the caller. If empty, will use the first account from RPC.')
     .addOption(pxeOption)
     .action(async (functionName, options) => {
-      const { functionArgs, contractAbi } = await prepTx(options.contractAbi, functionName, options.args, log);
+      const { functionArgs, contractArtifact } = await prepTx(
+        options.contractArtifact,
+        functionName,
+        options.args,
+        log,
+      );
 
-      const fnAbi = getAbiFunction(contractAbi, functionName);
-      if (fnAbi.parameters.length !== options.args.length) {
+      const fnArtifact = getFunctionArtifact(contractArtifact, functionName);
+      if (fnArtifact.parameters.length !== options.args.length) {
         throw Error(
-          `Invalid number of args passed. Expected ${fnAbi.parameters.length}; Received: ${options.args.length}`,
+          `Invalid number of args passed. Expected ${fnArtifact.parameters.length}; Received: ${options.args.length}`,
         );
       }
       const client = await createCompatibleClient(options.rpcUrl, debugLogger);
@@ -465,13 +529,13 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .description("Helper for parsing an encoded string into a contract's parameter struct.")
     .argument('<encodedString>', 'The encoded hex string')
     .requiredOption(
-      '-c, --contract-abi <fileLocation>',
+      '-c, --contract-artifact <fileLocation>',
       "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) => {
-      const contractAbi = await getContractAbi(options.contractAbi, log);
-      const parameterAbitype = contractAbi.functions
+      const contractArtifact = await getContractArtifact(options.contractArtifact, log);
+      const parameterAbitype = contractArtifact.functions
         .map(({ parameters }) => parameters)
         .flat()
         .find(({ name, type }) => name === options.parameter && type.kind === 'struct');
@@ -533,16 +597,16 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
     .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`,
+      '<contractArtifactFile>',
+      `A compiled Noir contract's artifact in JSON format or name of a contract artifact exported by @aztec/noir-contracts`,
     )
-    .action(async (contractAbiFile: string) => {
-      const contractAbi = await getContractAbi(contractAbiFile, debugLogger);
-      const contractFns = contractAbi.functions.filter(
+    .action(async (contractArtifactFile: string) => {
+      const contractArtifact = await getContractArtifact(contractArtifactFile, debugLogger);
+      const contractFns = contractArtifact.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}`);
+        log(`No external functions found for contract ${contractArtifact.name}`);
       }
       for (const fn of contractFns) {
         const signature = decodeFunctionSignatureWithParameterNames(fn.name, fn.parameters);

package/src/test/mocks.ts

@@ -1,6 +1,6 @@
-import { ABIParameterVisibility, ContractAbi, FunctionType } from '@aztec/foundation/abi';
+import { ABIParameterVisibility, ContractArtifact, FunctionType } from '@aztec/foundation/abi';
 
-export const mockContractAbi: ContractAbi = {
+export const mockContractArtifact: ContractArtifact = {
   name: 'MockContract',
   functions: [
     {
@@ -61,4 +61,5 @@ export const mockContractAbi: ContractAbi = {
       bytecode: 'mockBytecode',
     },
   ],
+  events: [],
 };

package/src/utils.ts

@@ -1,6 +1,6 @@
-import { AztecAddress, Fr, GrumpkinScalar, PXE, Point, TxHash } from '@aztec/aztec.js';
+import { AztecAddress, Fr, FunctionSelector, GrumpkinScalar, PXE, Point, TxHash } from '@aztec/aztec.js';
 import { L1ContractArtifactsForDeployment, createEthereumChain, deployL1Contracts } from '@aztec/ethereum';
-import { ContractAbi } from '@aztec/foundation/abi';
+import { ContractArtifact } from '@aztec/foundation/abi';
 import { DebugLogger, LogFn } from '@aztec/foundation/log';
 import {
   ContractDeploymentEmitterAbi,
@@ -14,6 +14,7 @@ import {
   RollupAbi,
   RollupBytecode,
 } from '@aztec/l1-artifacts';
+import { LogId } from '@aztec/types';
 
 import { InvalidArgumentError } from 'commander';
 import fs from 'fs';
@@ -25,17 +26,17 @@ import { encodeArgs } from './encoding.js';
  * Helper type to dynamically import contracts.
  */
 interface ArtifactsType {
-  [key: string]: ContractAbi;
+  [key: string]: ContractArtifact;
 }
 
 /**
  * Helper to get an ABI function or throw error if it doesn't exist.
- * @param abi - Contract's ABI in JSON format.
+ * @param artifact - Contract's build artifact in JSON format.
  * @param fnName - Function name to be found.
  * @returns The function's ABI.
  */
-export function getAbiFunction(abi: ContractAbi, fnName: string) {
-  const fn = abi.functions.find(({ name }) => name === fnName);
+export function getFunctionArtifact(artifact: ContractArtifact, fnName: string) {
+  const fn = artifact.functions.find(({ name }) => name === fnName);
   if (!fn) {
     throw Error(`Function ${fnName} not found in contract ABI.`);
   }
@@ -95,14 +96,14 @@ export async function getExampleContractArtifacts() {
 /**
  * Reads a file and converts it to an Aztec Contract ABI.
  * @param fileDir - The directory of the compiled contract ABI.
- * @returns The parsed ContractABI.
+ * @returns The parsed contract artifact.
  */
-export async function getContractAbi(fileDir: string, log: LogFn) {
+export async function getContractArtifact(fileDir: string, log: LogFn) {
   // first check if it's a noir-contracts example
   let contents: string;
   const artifacts = await getExampleContractArtifacts();
   if (artifacts[fileDir]) {
-    return artifacts[fileDir] as ContractAbi;
+    return artifacts[fileDir] as ContractArtifact;
   }
 
   try {
@@ -112,14 +113,14 @@ export async function getContractAbi(fileDir: string, log: LogFn) {
   }
 
   // if not found, try reading as path directly
-  let contractAbi: ContractAbi;
+  let contractArtifact: ContractArtifact;
   try {
-    contractAbi = JSON.parse(contents) as ContractAbi;
+    contractArtifact = JSON.parse(contents) as ContractArtifact;
   } catch (err) {
     log('Invalid file used. Please try again.');
     throw err;
   }
-  return contractAbi;
+  return contractArtifact;
 }
 
 /**
@@ -150,18 +151,17 @@ export async function getTxSender(pxe: PXE, _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 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, functionName: string, _functionArgs: string[], log: LogFn) {
-  const contractAbi = await getContractAbi(contractFile, log);
-  const functionAbi = getAbiFunction(contractAbi, functionName);
-  const functionArgs = encodeArgs(_functionArgs, functionAbi.parameters);
+  const contractArtifact = await getContractArtifact(contractFile, log);
+  const functionArtifact = getFunctionArtifact(contractArtifact, functionName);
+  const functionArgs = encodeArgs(_functionArgs, functionArtifact.parameters);
 
-  return { functionArgs, contractAbi };
+  return { functionArgs, contractArtifact };
 }
 
 /**
@@ -198,9 +198,10 @@ export function parseSaltFromHexString(str: string): Fr {
 }
 
 /**
- * Parses an AztecAddress from a string. Throws InvalidArgumentError if the string is not a valid.
- * @param address - A serialised Aztec address
+ * Parses an AztecAddress from a string.
+ * @param address - A serialized Aztec address
  * @returns An Aztec address
+ * @throws InvalidArgumentError if the input string is not valid.
  */
 export function parseAztecAddress(address: string): AztecAddress {
   try {
@@ -211,9 +212,71 @@ export function parseAztecAddress(address: string): AztecAddress {
 }
 
 /**
- * Parses a TxHash from a string. Throws InvalidArgumentError if the string is not a valid.
+ * Parses an AztecAddress from a string.
+ * @param address - A serialized Aztec address
+ * @returns An Aztec address
+ * @throws InvalidArgumentError if the input string is not valid.
+ */
+export function parseOptionalAztecAddress(address: string): AztecAddress | undefined {
+  if (!address) {
+    return undefined;
+  }
+  return parseAztecAddress(address);
+}
+
+/**
+ * Parses an optional log ID string into a LogId object.
+ *
+ * @param logId - The log ID string to parse.
+ * @returns The parsed LogId object, or undefined if the log ID is missing or empty.
+ */
+export function parseOptionalLogId(logId: string): LogId | undefined {
+  if (!logId) {
+    return undefined;
+  }
+  return LogId.fromString(logId);
+}
+
+/**
+ * Parses a selector from a string.
+ * @param selector - A serialized selector.
+ * @returns A selector.
+ * @throws InvalidArgumentError if the input string is not valid.
+ */
+export function parseOptionalSelector(selector: string): FunctionSelector | undefined {
+  if (!selector) {
+    return undefined;
+  }
+  try {
+    return FunctionSelector.fromString(selector);
+  } catch {
+    throw new InvalidArgumentError(`Invalid selector: ${selector}`);
+  }
+}
+
+/**
+ * Parses a string into an integer or returns undefined if the input is falsy.
+ *
+ * @param value - The string to parse into an integer.
+ * @returns The parsed integer, or undefined if the input string is falsy.
+ * @throws If the input is not a valid integer.
+ */
+export function parseOptionalInteger(value: string): number | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new InvalidArgumentError('Invalid integer.');
+  }
+  return parsed;
+}
+
+/**
+ * Parses a TxHash from a string.
  * @param txHash - A transaction hash
  * @returns A TxHash instance
+ * @throws InvalidArgumentError if the input string is not valid.
  */
 export function parseTxHash(txHash: string): TxHash {
   try {
@@ -224,9 +287,24 @@ export function parseTxHash(txHash: string): TxHash {
 }
 
 /**
- * Parses a public key from a string. Throws InvalidArgumentError if the string is not a valid.
+ * Parses an optional TxHash from a string.
+ * Calls parseTxHash internally.
+ * @param txHash - A transaction hash
+ * @returns A TxHash instance, or undefined if the input string is falsy.
+ * @throws InvalidArgumentError if the input string is not valid.
+ */
+export function parseOptionalTxHash(txHash: string): TxHash | undefined {
+  if (!txHash) {
+    return undefined;
+  }
+  return parseTxHash(txHash);
+}
+
+/**
+ * Parses a public key from a string.
  * @param publicKey - A public key
  * @returns A Point instance
+ * @throws InvalidArgumentError if the input string is not valid.
  */
 export function parsePublicKey(publicKey: string): Point {
   try {
@@ -237,9 +315,10 @@ export function parsePublicKey(publicKey: string): Point {
 }
 
 /**
- * Parses a partial address from a string. Throws InvalidArgumentError if the string is not a valid.
+ * Parses a partial address from a string.
  * @param address - A partial address
  * @returns A Fr instance
+ * @throws InvalidArgumentError if the input string is not valid.
  */
 export function parsePartialAddress(address: string): Fr {
   try {
@@ -250,9 +329,10 @@ export function parsePartialAddress(address: string): Fr {
 }
 
 /**
- * Parses a private key from a string. Throws InvalidArgumentError if the string is not a valid.
+ * Parses a private key from a string.
  * @param privateKey - A string
  * @returns A private key
+ * @throws InvalidArgumentError if the input string is not valid.
  */
 export function parsePrivateKey(privateKey: string): GrumpkinScalar {
   try {
@@ -269,9 +349,10 @@ export function parsePrivateKey(privateKey: string): GrumpkinScalar {
 }
 
 /**
- * Parses a field from a string. Throws InvalidArgumentError if the string is not a valid field value.
+ * Parses a field from a string.
  * @param field - A string representing the field.
  * @returns A field.
+ * @throws InvalidArgumentError if the input string is not valid.
  */
 export function parseField(field: string): Fr {
   try {