@aztec/cli 0.16.9 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/utils/inspect.js

@@ -0,0 +1,177 @@
+import { NoteStatus } from '@aztec/circuit-types';
+import { siloNullifier } from '@aztec/circuits.js/hash';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+export async function inspectBlock(pxe, blockNumber, log, opts = {}) {
+    const block = await pxe.getBlock(blockNumber);
+    if (!block) {
+        log(`No block found for block number ${blockNumber}`);
+        return;
+    }
+    const blockHash = await block.hash();
+    log(`Block ${blockNumber} (${blockHash.toString()})`);
+    log(` Total fees: ${block.header.totalFees.toBigInt()}`);
+    log(` Total mana used: ${block.header.totalManaUsed.toBigInt()}`);
+    log(` Fee per gas unit: DA=${block.header.globalVariables.gasFees.feePerDaGas.toBigInt()} L2=${block.header.globalVariables.gasFees.feePerL2Gas.toBigInt()}`);
+    log(` Coinbase: ${block.header.globalVariables.coinbase}`);
+    log(` Fee recipient: ${block.header.globalVariables.feeRecipient}`);
+    log(` Timestamp: ${new Date(block.header.globalVariables.timestamp.toNumber() * 500)}`);
+    if (opts.showTxs) {
+        log(``);
+        const artifactMap = await getKnownArtifacts(pxe);
+        for (const txHash of block.body.txEffects.map((tx)=>tx.txHash)){
+            await inspectTx(pxe, txHash, log, {
+                includeBlockInfo: false,
+                artifactMap
+            });
+        }
+    } else {
+        log(` Transactions: ${block.body.txEffects.length}`);
+    }
+}
+export async function inspectTx(pxe, txHash, log, opts = {}) {
+    const [receipt, effectsInBlock, getNotes] = await Promise.all([
+        pxe.getTxReceipt(txHash),
+        pxe.getTxEffect(txHash),
+        pxe.getNotes({
+            txHash,
+            status: NoteStatus.ACTIVE_OR_NULLIFIED
+        })
+    ]);
+    // Base tx data
+    log(`Tx ${txHash.toString()}`);
+    log(` Status: ${receipt.status} ${effectsInBlock ? `(${effectsInBlock.data.revertCode.getDescription()})` : ''}`);
+    if (receipt.error) {
+        log(` Error: ${receipt.error}`);
+    }
+    if (!effectsInBlock) {
+        return;
+    }
+    const effects = effectsInBlock.data;
+    const artifactMap = opts?.artifactMap ?? await getKnownArtifacts(pxe);
+    if (opts.includeBlockInfo) {
+        log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);
+    }
+    if (receipt.transactionFee) {
+        log(` Fee: ${receipt.transactionFee.toString()}`);
+    }
+    // Public logs
+    const publicLogs = effects.publicLogs;
+    if (publicLogs.length > 0) {
+        log(' Logs:');
+        for (const publicLog of publicLogs){
+            log(`  ${publicLog.toHumanReadable()}`);
+        }
+    }
+    // Public data writes
+    const writes = effects.publicDataWrites;
+    if (writes.length > 0) {
+        log(' Public data writes:');
+        for (const write of writes){
+            log(`  Leaf ${write.leafSlot.toString()} = ${write.value.toString()}`);
+        }
+    }
+    // Created notes
+    const notes = effects.noteHashes;
+    if (notes.length > 0) {
+        log(' Created notes:');
+        log(`  Total: ${notes.length}. Found: ${getNotes.length}.`);
+        if (getNotes.length) {
+            log('  Found notes:');
+            for (const note of getNotes){
+                inspectNote(note, artifactMap, log);
+            }
+        }
+    }
+    // Nullifiers
+    const nullifierCount = effects.nullifiers.length;
+    const { deployNullifiers, initNullifiers, classNullifiers } = await getKnownNullifiers(pxe, artifactMap);
+    if (nullifierCount > 0) {
+        log(' Nullifiers:');
+        for (const nullifier of effects.nullifiers){
+            const [note] = await pxe.getNotes({
+                siloedNullifier: nullifier
+            });
+            const deployed = deployNullifiers[nullifier.toString()];
+            const initialized = initNullifiers[nullifier.toString()];
+            const registered = classNullifiers[nullifier.toString()];
+            if (nullifier.toBuffer().equals(txHash.toBuffer())) {
+                log(`  Transaction hash nullifier ${nullifier.toShortString()}`);
+            } else if (note) {
+                inspectNote(note, artifactMap, log, `Nullifier ${nullifier.toShortString()} for note`);
+            } else if (deployed) {
+                log(`  Contract ${toFriendlyAddress(deployed, artifactMap)} deployed via nullifier ${nullifier.toShortString()}`);
+            } else if (initialized) {
+                log(`  Contract ${toFriendlyAddress(initialized, artifactMap)} initialized via nullifier ${nullifier.toShortString()}`);
+            } else if (registered) {
+                log(`  Class ${registered} registered via nullifier ${nullifier.toShortString()}`);
+            } else {
+                log(`  Unknown nullifier ${nullifier.toString()}`);
+            }
+        }
+    }
+    // L2 to L1 messages
+    if (effects.l2ToL1Msgs.length > 0) {
+        log(` L2 to L1 messages:`);
+        for (const msg of effects.l2ToL1Msgs){
+            log(`  ${msg.toString()}`);
+        }
+    }
+}
+function inspectNote(note, artifactMap, log, text = 'Note') {
+    const artifact = artifactMap[note.contractAddress.toString()];
+    const contract = artifact?.name ?? note.contractAddress.toString();
+    const type = artifact?.notes[note.noteTypeId.toString()]?.typ ?? note.noteTypeId.toField().toShortString();
+    log(`  ${text} type ${type} at ${contract}`);
+    log(`    Owner: ${toFriendlyAddress(note.owner, artifactMap)}`);
+    for (const field of note.note.items){
+        log(`    ${field.toString()}`);
+    }
+}
+function toFriendlyAddress(address, artifactMap) {
+    const artifact = artifactMap[address.toString()];
+    if (!artifact) {
+        return address.toString();
+    }
+    return `${artifact.name}<${address.toString()}>`;
+}
+async function getKnownNullifiers(pxe, artifactMap) {
+    const knownContracts = await pxe.getContracts();
+    const deployerAddress = ProtocolContractAddress.ContractInstanceDeployer;
+    const registererAddress = ProtocolContractAddress.ContractClassRegisterer;
+    const initNullifiers = {};
+    const deployNullifiers = {};
+    const classNullifiers = {};
+    for (const contract of knownContracts){
+        initNullifiers[siloNullifier(contract, contract.toField()).toString()] = contract;
+        deployNullifiers[siloNullifier(deployerAddress, contract.toField()).toString()] = contract;
+    }
+    for (const artifact of Object.values(artifactMap)){
+        classNullifiers[siloNullifier(registererAddress, artifact.classId).toString()] = `${artifact.name}Class<${artifact.classId}>`;
+    }
+    return {
+        initNullifiers,
+        deployNullifiers,
+        classNullifiers
+    };
+}
+async function getKnownArtifacts(pxe) {
+    const knownContractAddresses = await pxe.getContracts();
+    const knownContracts = (await Promise.all(knownContractAddresses.map((contractAddress)=>pxe.getContractMetadata(contractAddress)))).map((contractMetadata)=>contractMetadata.contractInstance);
+    const classIds = [
+        ...new Set(knownContracts.map((contract)=>contract?.contractClassId))
+    ];
+    const knownArtifacts = (await Promise.all(classIds.map((classId)=>classId ? pxe.getContractClassMetadata(classId) : undefined))).map((contractClassMetadata)=>contractClassMetadata ? {
+            ...contractClassMetadata.artifact,
+            classId: contractClassMetadata.contractClass?.id
+        } : undefined);
+    const map = {};
+    for (const instance of knownContracts){
+        if (instance) {
+            const artifact = knownArtifacts.find((a)=>a?.classId?.equals(instance.contractClassId));
+            if (artifact) {
+                map[instance.address.toString()] = artifact;
+            }
+        }
+    }
+    return map;
+}

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@aztec/cli",
-  "version": "0.16.9",
+  "version": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
   "type": "module",
-  "main": "./dest/index.js",
-  "bin": {
-    "aztec-cli": "./dest/bin/index.js"
+  "exports": {
+    "./contracts": "./dest/cmds/contracts/index.js",
+    "./devnet": "./dest/cmds/devnet/index.js",
+    "./infrastructure": "./dest/cmds/infrastructure/index.js",
+    "./l1": "./dest/cmds/l1/index.js",
+    "./pxe": "./dest/cmds/pxe/index.js",
+    "./cli-utils": "./dest/utils/index.js",
+    "./misc": "./dest/cmds/misc/index.js",
+    "./setup-contracts": "./dest/cmds/misc/setup_contracts.js",
+    "./utils": "./dest/utils/index.js",
+    "./inspect": "./dest/utils/inspect.js"
   },
   "typedocOptions": {
     "entryPoints": [
-      "./src/index.ts"
+      "./dest/builder/index.js"
     ],
     "name": "Aztec CLI",
     "tsconfig": "./tsconfig.json"
@@ -19,8 +27,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --passWithNoTests",
-    "start": "node --no-warnings ./dest/bin/index.js"
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
     "../package.common.json"
@@ -31,38 +38,80 @@
       "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
     },
     "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 30000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.16.9",
-    "@aztec/ethereum": "0.16.9",
-    "@aztec/foundation": "0.16.9",
-    "@aztec/l1-artifacts": "0.16.9",
-    "@aztec/noir-compiler": "0.16.9",
-    "@aztec/noir-contracts": "0.16.9",
-    "@aztec/types": "0.16.9",
+    "@aztec/archiver": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/aztec.js": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/circuit-types": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/foundation": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/l1-artifacts": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/types": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@iarna/toml": "^2.2.5",
     "@libp2p/peer-id-factory": "^3.0.4",
-    "@ltd/j-toml": "^1.38.0",
-    "commander": "^9.0.0",
-    "jszip": "^3.10.1",
-    "lodash.startcase": "^4.4.0",
-    "node-fetch": "^3.3.2",
+    "commander": "^12.1.0",
+    "lodash.chunk": "^4.2.0",
+    "lodash.groupby": "^4.6.0",
     "semver": "^7.5.4",
+    "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
-    "viem": "^1.2.5"
+    "viem": "2.22.8"
   },
   "devDependencies": {
+    "@aztec/accounts": "workspace:^",
+    "@aztec/circuits.js": "workspace:^",
+    "@aztec/ethereum": "workspace:^",
+    "@aztec/protocol-contracts": "workspace:^",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
+    "@types/lodash.chunk": "^4.2.9",
+    "@types/lodash.groupby": "^4.6.9",
     "@types/lodash.startcase": "^4.4.7",
     "@types/node": "^18.7.23",
     "@types/semver": "^7.5.2",
+    "@types/source-map-support": "^0.5.10",
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.5",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4"
   },
+  "peerDependencies": {
+    "@aztec/accounts": "workspace:^",
+    "@aztec/bb-prover": "workspace:^",
+    "@aztec/circuits.js": "workspace:^",
+    "@aztec/ethereum": "workspace:^",
+    "@aztec/l1-artifacts": "workspace:^",
+    "@aztec/noir-contracts.js": "workspace:^",
+    "@aztec/noir-protocol-circuits-types": "workspace:^",
+    "@aztec/protocol-contracts": "workspace:^"
+  },
   "files": [
     "dest",
     "src",

package/src/cmds/contracts/index.ts

@@ -0,0 +1,34 @@
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { type Command } from 'commander';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('inspect-contract')
+    .description('Shows list of external callable functions for a contract')
+    .argument(
+      '<contractArtifactFile>',
+      `A compiled Noir contract's artifact in JSON format or name of a contract artifact exported by @aztec/noir-contracts.js`,
+    )
+    .action(async (contractArtifactFile: string) => {
+      const { inspectContract } = await import('./inspect_contract.js');
+      await inspectContract(contractArtifactFile, debugLogger, log);
+    });
+
+  // Helper for users to decode hex strings into structs if needed.
+  program
+    .command('parse-parameter-struct')
+    .description("Helper for parsing an encoded string into a contract's parameter struct.")
+    .argument('<encodedString>', 'The encoded hex string')
+    .requiredOption(
+      '-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.js",
+    )
+    .requiredOption('-p, --parameter <parameterName>', 'The name of the struct parameter to decode into')
+    .action(async (encodedString, options) => {
+      const { parseParameterStruct } = await import('./parse_parameter_struct.js');
+      await parseParameterStruct(encodedString, options.contractArtifact, options.parameter, log);
+    });
+
+  return program;
+}

package/src/cmds/contracts/inspect_contract.ts

@@ -0,0 +1,51 @@
+import { getContractClassFromArtifact } from '@aztec/circuits.js';
+import {
+  type FunctionArtifact,
+  FunctionSelector,
+  decodeFunctionSignature,
+  decodeFunctionSignatureWithParameterNames,
+} from '@aztec/foundation/abi';
+import { sha256 } from '@aztec/foundation/crypto';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { getContractArtifact } from '../../utils/aztec.js';
+
+export async function inspectContract(contractArtifactFile: string, debugLogger: Logger, log: LogFn) {
+  const contractArtifact = await getContractArtifact(contractArtifactFile, log);
+  const contractFns = contractArtifact.functions.filter(f => f.name !== 'compute_note_hash_and_optionally_a_nullifier');
+  if (contractFns.length === 0) {
+    log(`No functions found for contract ${contractArtifact.name}`);
+  }
+  const contractClass = await getContractClassFromArtifact(contractArtifact);
+  const bytecodeLengthInFields = 1 + Math.ceil(contractClass.packedBytecode.length / 31);
+
+  log(`Contract class details:`);
+  log(`\tidentifier: ${contractClass.id.toString()}`);
+  log(`\tartifact hash: ${contractClass.artifactHash.toString()}`);
+  log(`\tprivate function tree root: ${contractClass.privateFunctionsRoot.toString()}`);
+  log(`\tpublic bytecode commitment: ${contractClass.publicBytecodeCommitment.toString()}`);
+  log(`\tpublic bytecode length: ${contractClass.packedBytecode.length} bytes (${bytecodeLengthInFields} fields)`);
+
+  const externalFunctions = contractFns.filter(f => !f.isInternal);
+  if (externalFunctions.length > 0) {
+    log(`\nExternal functions:`);
+    await Promise.all(externalFunctions.map(f => logFunction(f, log)));
+  }
+
+  const internalFunctions = contractFns.filter(f => f.isInternal);
+  if (internalFunctions.length > 0) {
+    log(`\nInternal functions:`);
+    await Promise.all(internalFunctions.map(f => logFunction(f, log)));
+  }
+}
+
+async function logFunction(fn: FunctionArtifact, log: LogFn) {
+  const signatureWithParameterNames = decodeFunctionSignatureWithParameterNames(fn.name, fn.parameters);
+  const signature = decodeFunctionSignature(fn.name, fn.parameters);
+  const selector = await FunctionSelector.fromSignature(signature);
+  const bytecodeSize = fn.bytecode.length;
+  const bytecodeHash = sha256(fn.bytecode).toString('hex');
+  log(
+    `${fn.functionType} ${signatureWithParameterNames} \n\tfunction signature: ${signature}\n\tselector: ${selector}\n\tbytecode: ${bytecodeSize} bytes (sha256 ${bytecodeHash})`,
+  );
+}

package/src/cmds/contracts/parse_parameter_struct.ts

@@ -0,0 +1,27 @@
+import { type StructType } from '@aztec/foundation/abi';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { type LogFn } from '@aztec/foundation/log';
+
+import { getContractArtifact } from '../../utils/aztec.js';
+import { parseStructString } from '../../utils/encoding.js';
+
+export async function parseParameterStruct(
+  encodedString: string,
+  contractArtifactPath: string,
+  parameterName: string,
+  log: LogFn,
+) {
+  const contractArtifact = await getContractArtifact(contractArtifactPath, log);
+  const parameterAbitype = contractArtifact.functions
+    .map(({ parameters }) => parameters)
+    .flat()
+    .find(({ name, type }) => name === parameterName && type.kind === 'struct');
+
+  if (!parameterAbitype) {
+    log(`No struct parameter found with name ${parameterName}`);
+    return;
+  }
+
+  const data = parseStructString(encodedString, parameterAbitype.type as StructType);
+  log(`\nStruct Data: \n${jsonStringify(data, true)}\n`);
+}