@aztec/cli 0.16.9 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/utils/aztec.js

@@ -0,0 +1,162 @@
+import { loadContractArtifact } from '@aztec/aztec.js/abi';
+import { FunctionType } from '@aztec/foundation/abi';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { gtr, ltr, satisfies, valid } from 'semver';
+import { getAddress, getContract, publicActions } from 'viem';
+import { encodeArgs } from './encoding.js';
+/**
+ * Helper to get an ABI function or throw error if it doesn't exist.
+ * @param artifact - Contract's build artifact in JSON format.
+ * @param fnName - Function name to be found.
+ * @returns The function's ABI.
+ */ export function getFunctionArtifact(artifact, fnName) {
+    const fn = artifact.functions.find(({ name })=>name === fnName);
+    if (!fn) {
+        throw Error(`Function ${fnName} not found in contract ABI.`);
+    }
+    return fn;
+}
+/**
+ * Function to execute the 'deployRollupContracts' command.
+ * @param rpcUrl - The RPC URL of the ethereum node.
+ * @param chainId - The chain ID of the L1 host.
+ * @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, chainId, privateKey, mnemonic, mnemonicIndex, salt, initialValidators, config, debugLogger) {
+    const { createEthereumChain, deployL1Contracts } = await import('@aztec/ethereum');
+    const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
+    const account = !privateKey ? mnemonicToAccount(mnemonic, {
+        addressIndex: mnemonicIndex
+    }) : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}`);
+    const chain = createEthereumChain(rpcUrl, chainId);
+    const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vks');
+    return await deployL1Contracts(chain.rpcUrl, account, chain.chainInfo, debugLogger, {
+        l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice,
+        vkTreeRoot: await getVKTreeRoot(),
+        protocolContractTreeRoot,
+        salt,
+        initialValidators,
+        ...config
+    });
+}
+/** Sets the assumed proven block number on the rollup contract on L1 */ export async function setAssumeProvenThrough(blockNumber, rollupAddress, walletClient) {
+    const rollup = getContract({
+        address: getAddress(rollupAddress.toString()),
+        abi: RollupAbi,
+        client: walletClient
+    });
+    const hash = await rollup.write.setAssumeProvenThroughBlockNumber([
+        BigInt(blockNumber)
+    ]);
+    await walletClient.extend(publicActions).waitForTransactionReceipt({
+        hash
+    });
+}
+/**
+ * Gets all contracts available in \@aztec/noir-contracts.js.
+ * @returns The contract names.
+ */ export async function getExampleContractNames() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { ContractNames } = await import('@aztec/noir-contracts.js');
+    return ContractNames;
+}
+/**
+ * Reads a file and converts it to an Aztec Contract ABI.
+ * @param fileDir - The directory of the compiled contract ABI.
+ * @returns The parsed contract artifact.
+ */ export async function getContractArtifact(fileDir, log) {
+    // first check if it's a noir-contracts example
+    const allNames = await getExampleContractNames();
+    const contractName = fileDir.replace(/Contract(Artifact)?$/, '');
+    if (allNames.includes(contractName)) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+        const imported = await import(`@aztec/noir-contracts.js/${contractName}`);
+        const artifact = imported[`${contractName}ContractArtifact`];
+        if (!artifact) {
+            throw Error(`Could not import ${contractName}ContractArtifact from @aztec/noir-contracts.js/${contractName}`);
+        }
+        return artifact;
+    }
+    let contents;
+    try {
+        contents = await readFile(fileDir, 'utf8');
+    } catch  {
+        throw Error(`Contract ${fileDir} not found`);
+    }
+    try {
+        return loadContractArtifact(JSON.parse(contents));
+    } catch (err) {
+        log('Invalid file used. Please try again.');
+        throw err;
+    }
+}
+/**
+ * Performs necessary checks, conversions & operations to call a contract fn from the CLI.
+ * @param contractFile - Directory of the compiled contract ABI.
+ * @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, functionName, _functionArgs, log) {
+    const contractArtifact = await getContractArtifact(contractFile, log);
+    const functionArtifact = getFunctionArtifact(contractArtifact, functionName);
+    const functionArgs = encodeArgs(_functionArgs, functionArtifact.parameters);
+    const isPrivate = functionArtifact.functionType === FunctionType.PRIVATE;
+    return {
+        functionArgs,
+        contractArtifact,
+        isPrivate
+    };
+}
+/**
+ * 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)=>{
+    if (hex.length > 2 && hex.startsWith('0x')) {
+        return hex.substring(2);
+    }
+    return hex;
+};
+/**
+ * Pretty prints Nargo.toml contents to a string
+ * @param config - Nargo.toml contents
+ * @returns The Nargo.toml contents as a string
+ */ export function prettyPrintNargoToml(config) {
+    const withoutDependencies = Object.fromEntries(Object.entries(config).filter(([key])=>key !== 'dependencies'));
+    const partialToml = TOML.stringify(withoutDependencies);
+    const dependenciesToml = Object.entries(config.dependencies).map(([name, dep])=>{
+        const depToml = TOML.stringify.value(dep);
+        return `${name} = ${depToml}`;
+    });
+    return partialToml + '\n[dependencies]\n' + dependenciesToml.join('\n') + '\n';
+}
+/** Mismatch between server and client versions. */ class VersionMismatchError extends Error {
+}
+/**
+ * Checks that Private eXecution Environment (PXE) version matches the expected one by this CLI. Throws if not.
+ * @param pxe - PXE client.
+ * @param expectedVersionRange - Expected version by CLI.
+ */ export async function checkServerVersion(pxe, expectedVersionRange) {
+    const serverName = 'Aztec Node';
+    const { nodeVersion } = await pxe.getNodeInfo();
+    if (!nodeVersion) {
+        throw new VersionMismatchError(`Couldn't determine ${serverName} version. You may run into issues.`);
+    }
+    if (!nodeVersion || !valid(nodeVersion)) {
+        throw new VersionMismatchError(`Missing or invalid version identifier for ${serverName} (${nodeVersion ?? 'empty'}).`);
+    } else if (!satisfies(nodeVersion, expectedVersionRange)) {
+        if (gtr(nodeVersion, expectedVersionRange)) {
+            throw new VersionMismatchError(`${serverName} is running version ${nodeVersion} which is newer than the expected by this CLI (${expectedVersionRange}). Consider upgrading your CLI to a newer version.`);
+        } else if (ltr(nodeVersion, expectedVersionRange)) {
+            throw new VersionMismatchError(`${serverName} is running version ${nodeVersion} which is older than the expected by this CLI (${expectedVersionRange}). Consider upgrading your ${serverName} to a newer version.`);
+        } else {
+            throw new VersionMismatchError(`${serverName} is running version ${nodeVersion} which does not match the expected by this CLI (${expectedVersionRange}).`);
+        }
+    }
+}

package/dest/utils/commands.js

@@ -0,0 +1,303 @@
+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 { PublicKeys } from '@aztec/circuits.js/types';
+import { 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_HOST = `http://${LOCALHOST}:8545`, PRIVATE_KEY, API_KEY, CLI_VERSION } = process.env;
+export function addOptions(program, options) {
+    options.forEach((option)=>program.addOption(option));
+    return program;
+}
+export const makePxeOption = (mandatory)=>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, mandatory, argsParser)=>new Option('-sk, --secret-key <string>', description).env('SECRET_KEY').argParser(argsParser ?? parseSecretKey).makeOptionMandatory(mandatory);
+export const logJson = (log)=>(obj)=>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, contents) {
+    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, _from) {
+    let from;
+    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)=>{
+    if (hex.length > 2 && hex.startsWith('0x')) {
+        return hex.substring(2);
+    }
+    return hex;
+};
+export function parseBigint(bigint) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    return fields.map(parseField);
+}
+/**
+ * Pretty prints an object as JSON
+ * @param data - The object to stringify
+ * @returns A JSON string
+ */ export function prettyPrintJSON(data) {
+    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/dest/utils/encoding.js

@@ -0,0 +1,110 @@
+import { isU128Struct } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * 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, abiType) {
+    // Assign string bytes to struct fields.
+    const buf = Buffer.from(str.replace(/^0x/i, ''), 'hex');
+    const struct = {};
+    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, abiType, name) {
+    const { kind } = abiType;
+    if (kind === 'field' || kind === 'integer') {
+        let res;
+        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 = {};
+        if (isU128Struct(abiType)) {
+            // When dealing with U128 we don't expect to receive limbs from the user but instead just a normal number.
+            // Also encoder.ts expects a normal number so we just return it as such.
+            return obj;
+        } else {
+            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, params) {
+    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, index)=>{
+        const { type, name } = params[index];
+        return encodeArg(arg, type, name);
+    });
+}

package/dest/utils/github.js

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

package/dest/utils/index.js

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