@aztec/cli 0.17.0 → 0.77.0-testnet-ignition.17

package/src/utils/commands.ts

@@ -0,0 +1,384 @@
+import { FunctionSelector } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { EthAddress } from '@aztec/aztec.js/eth_address';
+import { Fr } from '@aztec/aztec.js/fields';
+import { LogId } from '@aztec/aztec.js/log_id';
+import { TxHash } from '@aztec/aztec.js/tx_hash';
+import type { LogFn } from '@aztec/foundation/log';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { PublicKeys } from '@aztec/stdlib/keys';
+
+import { type Command, CommanderError, InvalidArgumentError, Option } from 'commander';
+import { lookup } from 'dns/promises';
+import { rename, writeFile } from 'fs/promises';
+
+/**
+ * If we can successfully resolve 'host.docker.internal', then we are running in a container, and we should treat
+ * localhost as being host.docker.internal.
+ */
+export const getLocalhost = () =>
+  lookup('host.docker.internal')
+    .then(() => 'host.docker.internal')
+    .catch(() => 'localhost');
+
+export const LOCALHOST = await getLocalhost();
+export const { ETHEREUM_HOSTS = `http://${LOCALHOST}:8545`, PRIVATE_KEY, API_KEY, CLI_VERSION } = process.env;
+
+export function addOptions(program: Command, options: Option[]) {
+  options.forEach(option => program.addOption(option));
+  return program;
+}
+
+export const makePxeOption = (mandatory: boolean) =>
+  new Option('-u, --rpc-url <string>', 'URL of the PXE')
+    .env('PXE_URL')
+    .default(`http://${LOCALHOST}:8080`)
+    .conflicts('remote-pxe')
+    .makeOptionMandatory(mandatory);
+
+export const pxeOption = makePxeOption(true);
+
+export const l1ChainIdOption = new Option('-c, --l1-chain-id <number>', 'Chain ID of the ethereum host')
+  .env('L1_CHAIN_ID')
+  .default(31337)
+  .argParser(value => {
+    const parsedValue = Number(value);
+    if (isNaN(parsedValue)) {
+      throw new Error('Chain ID must be a number.');
+    }
+    return parsedValue;
+  });
+
+export const createSecretKeyOption = (
+  description: string,
+  mandatory: boolean,
+  argsParser?: (value: string, previous: Fr) => Fr,
+) =>
+  new Option('-sk, --secret-key <string>', description)
+    .env('SECRET_KEY')
+    .argParser(argsParser ?? parseSecretKey)
+    .makeOptionMandatory(mandatory);
+
+export const logJson = (log: LogFn) => (obj: object) => log(JSON.stringify(obj, null, 2));
+
+/**
+ * Updates a file in place atomically.
+ * @param filePath - Path to file
+ * @param contents - New contents to write
+ */
+export async function atomicUpdateFile(filePath: string, contents: string) {
+  const tmpFilepath = filePath + '.tmp';
+  try {
+    await writeFile(tmpFilepath, contents, {
+      // let's crash if the tmp file already exists
+      flag: 'wx',
+    });
+    await rename(tmpFilepath, filePath);
+  } catch (e) {
+    if (e instanceof Error && 'code' in e && e.code === 'EEXIST') {
+      const commanderError = new CommanderError(
+        1,
+        e.code,
+        `Temporary file already exists: ${tmpFilepath}. Delete this file and try again.`,
+      );
+      commanderError.nestedError = e.message;
+      throw commanderError;
+    } else {
+      throw e;
+    }
+  }
+}
+
+/**
+ * Utility to select a TX sender either from user input
+ * 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(pxe: PXE, _from?: string) {
+  let from: AztecAddress;
+  if (_from) {
+    try {
+      from = AztecAddress.fromString(_from);
+    } catch {
+      throw new InvalidArgumentError(`Invalid option 'from' passed: ${_from}`);
+    }
+  } else {
+    const accounts = await pxe.getRegisteredAccounts();
+    if (!accounts.length) {
+      throw new Error('No accounts found in PXE instance.');
+    }
+    from = accounts[0].address;
+  }
+  return from;
+}
+
+/**
+ * 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
+ */
+const stripLeadingHex = (hex: string) => {
+  if (hex.length > 2 && hex.startsWith('0x')) {
+    return hex.substring(2);
+  }
+  return hex;
+};
+
+export function parseBigint(bigint: string): bigint | undefined {
+  return bigint ? BigInt(bigint) : undefined;
+}
+
+/**
+ * Parses a hex encoded string to an Fr integer
+ * @param str - Hex encoded string
+ * @returns A integer
+ */
+export function parseFieldFromHexString(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;
+  let buf = Buffer.from(padded, 'hex');
+  if (buf.length > Fr.SIZE_IN_BYTES) {
+    buf = buf.subarray(buf.length - Fr.SIZE_IN_BYTES);
+  }
+
+  const fr = Buffer.alloc(Fr.SIZE_IN_BYTES, 0);
+  fr.set(buf, Fr.SIZE_IN_BYTES - buf.length);
+
+  // finally, turn it into an integer
+  return Fr.fromBuffer(fr);
+}
+
+/**
+ * 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 {
+    return AztecAddress.fromString(address);
+  } catch {
+    throw new InvalidArgumentError(`Invalid address: ${address}`);
+  }
+}
+
+/**
+ * Parses an Ethereum address from a string.
+ * @param address - A serialized Ethereum address
+ * @returns An Ethereum address
+ * @throws InvalidArgumentError if the input string is not valid.
+ */
+export function parseEthereumAddress(address: string): EthAddress {
+  try {
+    return EthAddress.fromString(address);
+  } catch {
+    throw new InvalidArgumentError(`Invalid address: ${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 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 {
+    return TxHash.fromString(txHash);
+  } catch {
+    throw new InvalidArgumentError(`Invalid transaction hash: ${txHash}`);
+  }
+}
+
+/**
+ * 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 keys object serialised as a string
+ * @returns A PublicKeys instance
+ * @throws InvalidArgumentError if the input string is not valid.
+ */
+export function parsePublicKey(publicKey: string): PublicKeys | undefined {
+  if (!publicKey) {
+    return undefined;
+  }
+  try {
+    return PublicKeys.fromString(publicKey);
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid public key: ${publicKey}`);
+  }
+}
+
+/**
+ * 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 {
+    return Fr.fromHexString(address);
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid partial address: ${address}`);
+  }
+}
+
+/**
+ * Parses a secret key from a string.
+ * @param privateKey - A string
+ * @returns A secret key
+ * @throws InvalidArgumentError if the input string is not valid.
+ */
+export function parseSecretKey(secretKey: string): Fr {
+  try {
+    return Fr.fromHexString(secretKey);
+  } catch (err) {
+    throw new InvalidArgumentError(`Invalid encryption secret key: ${secretKey}`);
+  }
+}
+
+/**
+ * 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 {
+    const isHex = field.startsWith('0x') || field.match(new RegExp(`^[0-9a-f]{${Fr.SIZE_IN_BYTES * 2}}$`, 'i'));
+    if (isHex) {
+      return Fr.fromHexString(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);
+}
+
+/**
+ * Pretty prints an object as JSON
+ * @param data - The object to stringify
+ * @returns A JSON string
+ */
+export function prettyPrintJSON(data: Record<string, any>): string {
+  return JSON.stringify(
+    data,
+    (_key, val) => {
+      if (typeof val === 'bigint') {
+        return String(val);
+      } else if (val && typeof val === 'object' && 'toBuffer' in val) {
+        return '0x' + val.toBuffer().toString('hex');
+      } else {
+        return val;
+      }
+    },
+    2,
+  );
+}

package/src/utils/encoding.ts

@@ -0,0 +1,117 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { ABIParameter, AbiType, StructType } from '@aztec/stdlib/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) {
+  // Assign 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, name: string): any {
+  const { kind } = abiType;
+  if (kind === 'field' || kind === 'integer') {
+    let res: bigint;
+    try {
+      res = BigInt(arg);
+    } catch (err) {
+      throw new Error(
+        `Invalid value passed for ${name}. Could not parse ${arg} as a${kind === 'integer' ? 'n' : ''} ${kind}.`,
+      );
+    }
+    return res;
+  } else if (kind === 'boolean') {
+    if (arg === 'true') {
+      return true;
+    }
+    if (arg === 'false') {
+      return false;
+    } else {
+      throw Error(`Invalid boolean value passed for ${name}: ${arg}.`);
+    }
+  } else if (kind === 'string') {
+    return arg;
+  } else if (kind === 'array') {
+    let arr;
+    const res = [];
+    try {
+      arr = JSON.parse(arg);
+    } catch {
+      throw new Error(`Unable to parse arg ${arg} as array for ${name} parameter`);
+    }
+    if (!Array.isArray(arr)) {
+      throw Error(`Invalid argument ${arg} passed for array parameter ${name}.`);
+    }
+    if (arr.length !== abiType.length) {
+      throw Error(`Invalid array length passed for ${name}. Expected ${abiType.length}, received ${arr.length}.`);
+    }
+    for (let i = 0; i < abiType.length; i += 1) {
+      res.push(encodeArg(arr[i], abiType.type, name));
+    }
+    return res;
+  } 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);
+    } catch {
+      throw new Error(`Unable to parse arg ${arg} as struct`);
+    }
+    if (Array.isArray(obj)) {
+      throw Error(`Array passed for arg ${name}. Expected a struct.`);
+    }
+    const res: any = {};
+    for (const field of abiType.fields) {
+      // Remove field name from list as it's present
+      const arg = obj[field.name];
+      if (!arg) {
+        throw Error(`Expected field ${field.name} not found in struct ${name}.`);
+      }
+      res[field.name] = encodeArg(obj[field.name], field.type, field.name);
+    }
+    return res;
+  }
+}
+
+/**
+ * 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[]) {
+  if (args.length !== params.length) {
+    throw new Error(
+      `Invalid args provided.\nExpected args: [${params
+        .map(param => param.name + ': ' + param.type.kind)
+        .join(', ')}]\nReceived args: ${args.join(', ')}`,
+    );
+  }
+  return args.map((arg: any, index) => {
+    const { type, name } = params[index];
+    return encodeArg(arg, type, name);
+  });
+}

package/src/utils/github.ts

@@ -0,0 +1,3 @@
+export const GITHUB_OWNER = 'AztecProtocol';
+export const GITHUB_REPO = 'aztec-packages';
+export const GITHUB_TAG_PREFIX = 'aztec-packages';

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './commands.js';
+export * from './aztec.js';
+export * from './encoding.js';
+export * from './github.js';