@aztec/cli 0.16.9 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/cmds/misc/setup_contracts.js

@@ -0,0 +1,25 @@
+import { DefaultWaitOpts, NoFeePaymentMethod } from '@aztec/aztec.js';
+import { FEE_JUICE_INITIAL_MINT, Gas } from '@aztec/circuits.js';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+/**
+ * Deploys the contract to pay for gas on L2.
+ */ export async function setupCanonicalL2FeeJuice(deployer, feeJuicePortalAddress, waitOpts = DefaultWaitOpts, log) {
+    // 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 { FeeJuiceContract } = await import('@aztec/noir-contracts.js/FeeJuice');
+    const feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, deployer);
+    const portalAddress = await deployer.getPublicStorageAt(feeJuiceContract.address, feeJuiceContract.artifact.storageLayout.portal_address.slot);
+    if (portalAddress.isZero()) {
+        log('setupCanonicalL2FeeJuice: Calling initialize on fee juice contract...');
+        await feeJuiceContract.methods.initialize(feeJuicePortalAddress, FEE_JUICE_INITIAL_MINT).send({
+            fee: {
+                paymentMethod: new NoFeePaymentMethod(),
+                gasSettings: {
+                    teardownGasLimits: Gas.empty()
+                }
+            }
+        }).wait(waitOpts);
+    } else {
+        log('setupCanonicalL2FeeJuice: Fee juice contract already initialized. Fee Juice Portal address: ' + portalAddress.toString());
+    }
+}

package/dest/cmds/misc/update/common.js

@@ -0,0 +1,3 @@
+/**
+ * Tracks changes to dependencies
+ */ export { };

package/dest/cmds/misc/update/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/cmds/misc/update/noir.js

@@ -0,0 +1,45 @@
+import { parseNoirPackageConfig } from '@aztec/foundation/noir';
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import { atomicUpdateFile, prettyPrintNargoToml } from './utils.js';
+/**
+ * Updates Aztec.nr dependencies
+ * @param contractPath - Path to the contract to be updated
+ * @param tag - The tag to update to
+ * @param log - Logging function
+ */ export async function updateAztecNr(contractPath, tag, log) {
+    const configFilepath = resolve(join(contractPath, 'Nargo.toml'));
+    const packageConfig = parseNoirPackageConfig(TOML.parse(await readFile(configFilepath, 'utf-8')));
+    const changes = {
+        dependencies: [],
+        file: configFilepath
+    };
+    log(`Updating Aztec.nr libraries to ${tag} in ${relative(process.cwd(), changes.file)}`);
+    for (const dep of Object.values(packageConfig.dependencies)){
+        if (!('git' in dep)) {
+            continue;
+        }
+        // remove trailing slash
+        const gitUrl = dep.git.toLowerCase().replace(/\/$/, '');
+        if (gitUrl !== 'https://github.com/aztecprotocol/aztec-packages') {
+            continue;
+        }
+        if (dep.tag !== tag) {
+            // show the Aztec.nr package name rather than the lib name
+            const dirParts = dep.directory?.split('/') ?? [];
+            changes.dependencies.push({
+                name: dirParts.slice(-2).join('/'),
+                from: dep.tag,
+                to: tag
+            });
+            dep.tag = tag;
+            dep.directory = dep.directory?.replace('yarn-project/', 'noir-projects/');
+        }
+    }
+    if (changes.dependencies.length > 0) {
+        const contents = prettyPrintNargoToml(packageConfig);
+        await atomicUpdateFile(configFilepath, contents);
+    }
+    return changes;
+}

package/dest/cmds/misc/update/npm.js

@@ -0,0 +1,127 @@
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import { parse } from 'semver';
+import { atomicUpdateFile } from './utils.js';
+const deprecatedNpmPackages = new Set([
+    '@aztec/cli',
+    '@aztec/aztec-sandbox'
+]);
+const npmDeprecationMessage = `
+The following packages have been deprecated and will no longer be updated on the npm registry:
+${Array.from(deprecatedNpmPackages).map((pkg)=>`  - ${pkg}`).join('\n')}
+Remove them from package.json
+`;
+/**
+ * Looks up a package.json file and returns its contents
+ * @param projectPath - Path to Nodejs project
+ * @returns The parsed package.json
+ */ export async function readPackageJson(projectPath) {
+    const configFilepath = resolve(join(projectPath, 'package.json'));
+    const pkg = JSON.parse(await readFile(configFilepath, 'utf-8'));
+    return pkg;
+}
+/**
+ * Queries the npm registry for the latest version of a package
+ * @param packageName - The package to query
+ * @param distTag - The distribution tag
+ * @returns The latest version of the package on that distribution tag
+ */ export async function getNewestVersion(packageName, distTag = 'latest') {
+    const url = new URL(packageName, 'https://registry.npmjs.org/');
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}`);
+    }
+    const body = await response.json();
+    const latestVersion = parse(body['dist-tags'][distTag]);
+    if (!latestVersion) {
+        throw new Error(`Failed to get latest version from registry`);
+    }
+    return latestVersion;
+}
+/**
+ * Updates a project's \@aztec/* dependencies to the specific version
+ * @param projectPath - Path to Nodejs project
+ * @param aztecVersion - The version to update to
+ * @returns True if the project was updated
+ */ export async function updateAztecDeps(projectPath, aztecVersion, log) {
+    const pkg = await readPackageJson(projectPath);
+    const changes = {
+        file: resolve(join(projectPath, 'package.json')),
+        dependencies: []
+    };
+    log(`Updating @aztec packages to ${aztecVersion} in ${relative(process.cwd(), changes.file)}`);
+    const version = aztecVersion.version;
+    let detectedDeprecatedPackages = false;
+    for (const depType of [
+        'dependencies',
+        'devDependencies'
+    ]){
+        const dependencies = pkg[depType];
+        if (!dependencies) {
+            continue;
+        }
+        for (const name of Object.keys(dependencies)){
+            if (!name.startsWith('@aztec/')) {
+                continue;
+            }
+            // different release schedule
+            if (name === '@aztec/aztec-ui') {
+                continue;
+            }
+            if (deprecatedNpmPackages.has(name)) {
+                detectedDeprecatedPackages = true;
+                continue;
+            }
+            if (dependencies[name] !== version) {
+                changes.dependencies.push({
+                    name,
+                    from: dependencies[name],
+                    to: version
+                });
+                dependencies[name] = version;
+            }
+        }
+    }
+    if (detectedDeprecatedPackages) {
+        log(npmDeprecationMessage);
+    }
+    if (changes.dependencies.length > 0) {
+        const contents = JSON.stringify(pkg, null, 2) + '\n';
+        await atomicUpdateFile(resolve(join(projectPath, 'package.json')), contents);
+    }
+    return changes;
+}
+/**
+ * Updates a project's yarn.lock or package-lock.json
+ * @param projectPath - Path to Nodejs project
+ */ export function updateLockfile(projectPath, log) {
+    const isNpm = existsSync(resolve(join(projectPath, 'package-lock.json')));
+    const isYarn = existsSync(resolve(join(projectPath, 'yarn.lock')));
+    const isPnpm = existsSync(resolve(join(projectPath, 'pnpm-lock.yaml')));
+    if (isPnpm) {
+        spawnSync('pnpm', [
+            'install'
+        ], {
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+    } else if (isYarn) {
+        spawnSync('yarn', [
+            'install'
+        ], {
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+    } else if (isNpm) {
+        spawnSync('npm', [
+            'install'
+        ], {
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+    } else {
+        log(`No lockfile found in ${projectPath}. Skipping lockfile update...`);
+    }
+}

package/dest/cmds/misc/update/utils.js

@@ -0,0 +1,38 @@
+import TOML from '@iarna/toml';
+import { CommanderError } from 'commander';
+import { rename, writeFile } from 'fs/promises';
+/**
+ * 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;
+        }
+    }
+}
+/**
+ * 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';
+}

package/dest/cmds/misc/update.js

@@ -0,0 +1,52 @@
+/* eslint-disable jsdoc/require-jsdoc */ import { relative, resolve } from 'path';
+import { parse } from 'semver';
+import { GITHUB_TAG_PREFIX } from './update/github.js';
+import { updateAztecNr } from './update/noir.js';
+import { getNewestVersion, updateAztecDeps, updateLockfile } from './update/npm.js';
+const AZTECJS_PACKAGE = '@aztec/aztec.js';
+const UPDATE_DOCS_URL = 'https://docs.aztec.network/developers/guides/local_env/versions-updating';
+export async function updateProject(projectPath, contracts, aztecVersion, log) {
+    const targetAztecVersion = aztecVersion === 'latest' ? await getNewestVersion(AZTECJS_PACKAGE, 'latest') : parse(aztecVersion);
+    if (!targetAztecVersion) {
+        throw new Error(`Invalid aztec version ${aztecVersion}`);
+    }
+    const projectDependencyChanges = [];
+    try {
+        const npmChanges = await updateAztecDeps(resolve(process.cwd(), projectPath), targetAztecVersion, log);
+        if (npmChanges.dependencies.length > 0) {
+            updateLockfile(projectPath, log);
+        }
+        projectDependencyChanges.push(npmChanges);
+    } catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            log(`No package.json found in ${projectPath}. Skipping npm update...`);
+        } else {
+            throw err;
+        }
+    }
+    for (const contract of contracts){
+        try {
+            projectDependencyChanges.push(await updateAztecNr(resolve(process.cwd(), projectPath, contract), `${GITHUB_TAG_PREFIX}-v${targetAztecVersion.version}`, log));
+        } catch (err) {
+            if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+                log(`No Nargo.toml found in ${relative(process.cwd(), contract)}. Skipping...`);
+            } else {
+                throw err;
+            }
+        }
+    }
+    log(`To update Docker containers follow instructions at ${UPDATE_DOCS_URL}`);
+    projectDependencyChanges.forEach((changes)=>{
+        printChanges(changes, log);
+    });
+}
+function printChanges(changes, log) {
+    log(`\nIn ${relative(process.cwd(), changes.file)}:`);
+    if (changes.dependencies.length === 0) {
+        log('  No changes');
+    } else {
+        changes.dependencies.forEach(({ name, from, to })=>{
+            log(`  Updated ${name} from ${from} to ${to}`);
+        });
+    }
+}

package/dest/cmds/pxe/add_contract.js

@@ -0,0 +1,27 @@
+import { AztecAddress, getContractClassFromArtifact } from '@aztec/aztec.js';
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { PublicKeys } from '@aztec/circuits.js';
+import { computeContractAddressFromInstance } from '@aztec/circuits.js/contract';
+import { getContractArtifact } from '../../utils/aztec.js';
+export async function addContract(rpcUrl, contractArtifactPath, address, initializationHash, salt, publicKeys, deployer, debugLogger, log) {
+    const artifact = await getContractArtifact(contractArtifactPath, log);
+    const instance = {
+        version: 1,
+        salt,
+        initializationHash,
+        contractClassId: (await getContractClassFromArtifact(artifact)).id,
+        publicKeys: publicKeys ?? PublicKeys.default(),
+        address,
+        deployer: deployer ?? AztecAddress.ZERO
+    };
+    const computed = await computeContractAddressFromInstance(instance);
+    if (!computed.equals(address)) {
+        throw new Error(`Contract address ${address.toString()} does not match computed address ${computed.toString()}`);
+    }
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    await client.registerContract({
+        artifact,
+        instance
+    });
+    log(`\nContract added to PXE at ${address.toString()} with class ${instance.contractClassId.toString()}\n`);
+}

package/dest/cmds/pxe/block_number.js

@@ -0,0 +1,10 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+export async function blockNumber(rpcUrl, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const [latestNum, provenNum] = await Promise.all([
+        client.getBlockNumber(),
+        client.getProvenBlockNumber()
+    ]);
+    log(`Latest block: ${latestNum}`);
+    log(`Proven block: ${provenNum}`);
+}

package/dest/cmds/pxe/get_account.js

@@ -0,0 +1,10 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+export async function getAccount(aztecAddress, rpcUrl, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const account = (await client.getRegisteredAccounts()).find((completeAddress)=>completeAddress.address.equals(aztecAddress));
+    if (!account) {
+        log(`Unknown account ${aztecAddress.toString()}`);
+    } else {
+        log(account.toReadableString());
+    }
+}

package/dest/cmds/pxe/get_accounts.js

@@ -0,0 +1,25 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+export async function getAccounts(rpcUrl, json, debugLogger, log, logJson) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const accounts = await client.getRegisteredAccounts();
+    if (!accounts.length) {
+        if (json) {
+            logJson([]);
+        } else {
+            log('No accounts found.');
+        }
+        return;
+    }
+    if (json) {
+        logJson(accounts.map((a)=>({
+                address: a.address.toString(),
+                publicKeys: a.publicKeys.toString(),
+                partialAddress: a.partialAddress.toString()
+            })));
+    } else {
+        log(`Accounts found: \n`);
+        for (const account of accounts){
+            log(account.toReadableString());
+        }
+    }
+}

package/dest/cmds/pxe/get_block.js

@@ -0,0 +1,9 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { inspectBlock } from '../../utils/inspect.js';
+export async function getBlock(rpcUrl, maybeBlockNumber, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const blockNumber = maybeBlockNumber ?? await client.getBlockNumber();
+    await inspectBlock(client, blockNumber, log, {
+        showTxs: true
+    });
+}

package/dest/cmds/pxe/get_contract_data.js

@@ -0,0 +1,31 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+export async function getContractData(rpcUrl, contractAddress, includeBytecode, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const { contractInstance: instance, isContractInitialized: isInitialized, isContractPubliclyDeployed: isPubliclyDeployed } = await client.getContractMetadata(contractAddress);
+    const contractClass = includeBytecode && instance && (await client.getContractClassMetadata(instance?.contractClassId)).contractClass;
+    const isPrivatelyDeployed = !!instance;
+    const initStr = isInitialized ? 'initialized' : 'not initialized';
+    const addrStr = contractAddress.toString();
+    if (isPubliclyDeployed && isPrivatelyDeployed) {
+        log(`Contract is ${initStr} and publicly deployed at ${addrStr}`);
+    } else if (isPrivatelyDeployed) {
+        log(`Contract is ${initStr} and registered in the local pxe at ${addrStr} but not publicly deployed`);
+    } else if (isPubliclyDeployed) {
+        log(`Contract is ${initStr} and publicly deployed at ${addrStr} but not registered in the local pxe`);
+    } else if (isInitialized) {
+        log(`Contract is initialized but not publicly deployed nor registered in the local pxe at ${addrStr}`);
+    } else {
+        log(`No contract found at ${addrStr}`);
+    }
+    if (instance) {
+        log(``);
+        Object.entries(instance).forEach(([key, value])=>{
+            const capitalized = key.charAt(0).toUpperCase() + key.slice(1);
+            log(`${capitalized}: ${value.toString()}`);
+        });
+        if (contractClass) {
+            log(`\nBytecode: ${contractClass.packedBytecode.toString('base64')}`);
+        }
+        log('');
+    }
+}

package/dest/cmds/pxe/get_current_base_fee.js

@@ -0,0 +1,7 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+export async function getCurrentBaseFee(rpcUrl, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const fees = await client.getCurrentBaseFees();
+    log(`Current fees: ${jsonStringify(fees)}`);
+}

package/dest/cmds/pxe/get_l1_to_l2_message_witness.js

@@ -0,0 +1,11 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+export async function getL1ToL2MessageWitness(rpcUrl, contractAddress, messageHash, secret, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const messageWitness = await client.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+    log(messageWitness === undefined ? `
+    L1 to L2 Message not found.
+    ` : `
+    L1 to L2 message index: ${messageWitness[0]}
+    L1 to L2 message sibling path: ${messageWitness[1]}
+    `);
+}

package/dest/cmds/pxe/get_logs.js

@@ -0,0 +1,51 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { sleep } from '@aztec/foundation/sleep';
+export async function getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, rpcUrl, follow, debugLogger, log) {
+    const pxe = await createCompatibleClient(rpcUrl, debugLogger);
+    if (follow) {
+        if (txHash) {
+            throw Error('Cannot use --follow with --tx-hash');
+        }
+        if (toBlock) {
+            throw Error('Cannot use --follow with --to-block');
+        }
+    }
+    const filter = {
+        txHash,
+        fromBlock,
+        toBlock,
+        afterLog,
+        contractAddress
+    };
+    const fetchLogs = async ()=>{
+        const response = await pxe.getPublicLogs(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((publicLog)=>log(publicLog.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 {
+        while(await fetchLogs()){
+        // Keep fetching logs until we reach the end.
+        }
+    }
+}

package/dest/cmds/pxe/get_node_info.js

@@ -0,0 +1,61 @@
+import { createAztecNodeClient, createCompatibleClient } from '@aztec/aztec.js';
+export async function getNodeInfo(rpcUrl, pxeRequest, debugLogger, json, log, logJson) {
+    let client;
+    if (pxeRequest) {
+        client = await createCompatibleClient(rpcUrl, debugLogger);
+    } else {
+        client = createAztecNodeClient(rpcUrl);
+    }
+    const info = await client.getNodeInfo();
+    if (json) {
+        logJson({
+            nodeVersion: info.nodeVersion,
+            l1ChainId: info.l1ChainId,
+            protocolVersion: info.protocolVersion,
+            enr: info.enr,
+            l1ContractAddresses: {
+                rollup: info.l1ContractAddresses.rollupAddress.toString(),
+                registry: info.l1ContractAddresses.registryAddress.toString(),
+                inbox: info.l1ContractAddresses.inboxAddress.toString(),
+                outbox: info.l1ContractAddresses.outboxAddress.toString(),
+                feeJuice: info.l1ContractAddresses.feeJuiceAddress.toString(),
+                stakingAsset: info.l1ContractAddresses.stakingAssetAddress.toString(),
+                feeJuicePortal: info.l1ContractAddresses.feeJuicePortalAddress.toString(),
+                coinIssuer: info.l1ContractAddresses.coinIssuerAddress.toString(),
+                rewardDistributor: info.l1ContractAddresses.rewardDistributorAddress.toString(),
+                governanceProposer: info.l1ContractAddresses.governanceProposerAddress.toString(),
+                governance: info.l1ContractAddresses.governanceAddress.toString(),
+                slashFactory: info.l1ContractAddresses.slashFactoryAddress.toString()
+            },
+            protocolContractAddresses: {
+                classRegisterer: info.protocolContractAddresses.classRegisterer.toString(),
+                feeJuice: info.protocolContractAddresses.feeJuice.toString(),
+                instanceDeployer: info.protocolContractAddresses.instanceDeployer.toString(),
+                multiCallEntrypoint: info.protocolContractAddresses.multiCallEntrypoint.toString()
+            }
+        });
+    } else {
+        log(`Node Version: ${info.nodeVersion}`);
+        log(`Chain Id: ${info.l1ChainId}`);
+        log(`Protocol Version: ${info.protocolVersion}`);
+        log(`Node ENR: ${info.enr}`);
+        log(`L1 Contract Addresses:`);
+        log(` Rollup Address: ${info.l1ContractAddresses.rollupAddress.toString()}`);
+        log(` Registry Address: ${info.l1ContractAddresses.registryAddress.toString()}`);
+        log(` L1 -> L2 Inbox Address: ${info.l1ContractAddresses.inboxAddress.toString()}`);
+        log(` L2 -> L1 Outbox Address: ${info.l1ContractAddresses.outboxAddress.toString()}`);
+        log(` Fee Juice Address: ${info.l1ContractAddresses.feeJuiceAddress.toString()}`);
+        log(` Staking Asset Address: ${info.l1ContractAddresses.stakingAssetAddress.toString()}`);
+        log(` Fee Juice Portal Address: ${info.l1ContractAddresses.feeJuicePortalAddress.toString()}`);
+        log(` CoinIssuer Address: ${info.l1ContractAddresses.coinIssuerAddress.toString()}`);
+        log(` RewardDistributor Address: ${info.l1ContractAddresses.rewardDistributorAddress.toString()}`);
+        log(` GovernanceProposer Address: ${info.l1ContractAddresses.governanceProposerAddress.toString()}`);
+        log(` Governance Address: ${info.l1ContractAddresses.governanceAddress.toString()}`);
+        log(` SlashFactory Address: ${info.l1ContractAddresses.slashFactoryAddress.toString()}`);
+        log(`L2 Contract Addresses:`);
+        log(` Class Registerer: ${info.protocolContractAddresses.classRegisterer.toString()}`);
+        log(` Fee Juice: ${info.protocolContractAddresses.feeJuice.toString()}`);
+        log(` Instance Deployer: ${info.protocolContractAddresses.instanceDeployer.toString()}`);
+        log(` MultiCall: ${info.protocolContractAddresses.multiCallEntrypoint.toString()}`);
+    }
+}

package/dest/cmds/pxe/get_pxe_info.js

@@ -0,0 +1,11 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+export async function getPXEInfo(rpcUrl, debugLogger, log) {
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const info = await client.getPXEInfo();
+    log(`PXE Version: ${info.pxeVersion}`);
+    log(`Protocol Contract Addresses:`);
+    log(` Class Registerer: ${info.protocolContractAddresses.classRegisterer.toString()}`);
+    log(` Fee Juice: ${info.protocolContractAddresses.feeJuice.toString()}`);
+    log(` Instance Deployer: ${info.protocolContractAddresses.instanceDeployer.toString()}`);
+    log(` Multi Call Entrypoint: ${info.protocolContractAddresses.multiCallEntrypoint.toString()}`);
+}

package/dest/cmds/pxe/index.js

@@ -0,0 +1,55 @@
+import { Fr } from '@aztec/circuits.js';
+import { logJson, makePxeOption, parseAztecAddress, parseEthereumAddress, parseField, parseFieldFromHexString, parseOptionalAztecAddress, parseOptionalInteger, parseOptionalLogId, parseOptionalTxHash, parsePublicKey, pxeOption } from '../../utils/commands.js';
+export function injectCommands(program, log, debugLogger) {
+    program.command('add-contract').description('Adds an existing contract to the PXE. This is useful if you have deployed a contract outside of the PXE and want to use it with the PXE.').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('-ca, --contract-address <address>', 'Aztec address of the contract.', parseAztecAddress).requiredOption('--init-hash <init hash>', 'Initialization hash', parseFieldFromHexString).option('--salt <salt>', 'Optional deployment salt', parseFieldFromHexString).option('-p, --public-key <public key>', 'Optional public key for this contract', parsePublicKey).option('--portal-address <address>', 'Optional address to a portal contract on L1', parseEthereumAddress).option('--deployer-address <address>', 'Optional address of the contract deployer', parseAztecAddress).addOption(pxeOption).action(async (options)=>{
+        const { addContract } = await import('./add_contract.js');
+        await addContract(options.rpcUrl, options.contractArtifact, options.contractAddress, options.initHash, options.salt ?? Fr.ZERO, options.publicKey, options.deployerAddress, debugLogger, log);
+    });
+    program.command('get-block').description('Gets info for a given block or latest.').argument('[blockNumber]', 'Block height', parseOptionalInteger).addOption(pxeOption).action(async (blockNumber, options)=>{
+        const { getBlock } = await import('./get_block.js');
+        await getBlock(options.rpcUrl, blockNumber, debugLogger, log);
+    });
+    program.command('get-current-base-fee').description('Gets the current base fee.').addOption(pxeOption).action(async (options)=>{
+        const { getCurrentBaseFee } = await import('./get_current_base_fee.js');
+        await getCurrentBaseFee(options.rpcUrl, debugLogger, log);
+    });
+    program.command('get-contract-data').description('Gets information about the Aztec contract deployed at the specified address.').argument('<contractAddress>', 'Aztec address of the contract.', parseAztecAddress).addOption(pxeOption).option('-b, --include-bytecode <boolean>', "Include the contract's public function bytecode, if any.", false).action(async (contractAddress, options)=>{
+        const { getContractData } = await import('./get_contract_data.js');
+        await getContractData(options.rpcUrl, contractAddress, options.includeBytecode, debugLogger, log);
+    });
+    program.command('get-logs').description('Gets all the public 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).addOption(pxeOption).option('--follow', 'If set, will keep polling for new logs until interrupted.').action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, rpcUrl, follow })=>{
+        const { getLogs } = await import('./get_logs.js');
+        await getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, rpcUrl, follow, debugLogger, log);
+    });
+    program.command('get-accounts').description('Gets all the Aztec accounts stored in the PXE.').addOption(pxeOption).option('--json', 'Emit output as json').action(async (options)=>{
+        const { getAccounts } = await import('./get_accounts.js');
+        await getAccounts(options.rpcUrl, options.json, debugLogger, log, logJson(log));
+    });
+    program.command('get-account').description('Gets an account given its Aztec address.').argument('<address>', 'The Aztec address to get account for', parseAztecAddress).addOption(pxeOption).action(async (address, options)=>{
+        const { getAccount } = await import('./get_account.js');
+        await getAccount(address, options.rpcUrl, debugLogger, log);
+    });
+    program.command('block-number').description('Gets the current Aztec L2 block number.').addOption(pxeOption).action(async (options)=>{
+        const { blockNumber } = await import('./block_number.js');
+        await blockNumber(options.rpcUrl, debugLogger, log);
+    });
+    program.command('get-l1-to-l2-message-witness').description('Gets a L1 to L2 message witness.').requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.', parseAztecAddress).requiredOption('--message-hash <messageHash>', 'The L1 to L2 message hash.', parseField).requiredOption('--secret <secret>', 'The secret used to claim the L1 to L2 message', parseField).addOption(pxeOption).action(async ({ contractAddress, messageHash, secret, rpcUrl })=>{
+        const { getL1ToL2MessageWitness } = await import('./get_l1_to_l2_message_witness.js');
+        await getL1ToL2MessageWitness(rpcUrl, contractAddress, messageHash, secret, debugLogger, log);
+    });
+    program.command('get-node-info').description('Gets the information of an Aztec node from a PXE or directly from an Aztec node.').option('--node-url <string>', 'URL of the node.').option('--json', 'Emit output as json').addOption(makePxeOption(false)).action(async (options)=>{
+        const { getNodeInfo } = await import('./get_node_info.js');
+        let url;
+        if (options.nodeUrl) {
+            url = options.nodeUrl;
+        } else {
+            url = options.rpcUrl;
+        }
+        await getNodeInfo(url, !options.nodeUrl, debugLogger, options.json, log, logJson(log));
+    });
+    program.command('get-pxe-info').description('Gets the information of a PXE at a URL.').addOption(pxeOption).action(async (options)=>{
+        const { getPXEInfo } = await import('./get_pxe_info.js');
+        await getPXEInfo(options.rpcUrl, debugLogger, log);
+    });
+    return program;
+}