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

package/src/cmds/misc/update/noir.ts

@@ -0,0 +1,57 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { parseNoirPackageConfig } from '@aztec/foundation/noir';
+
+import TOML from '@iarna/toml';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+
+import type { DependencyChanges } from './common.js';
+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: string, tag: string, log: LogFn): Promise<DependencyChanges> {
+  const configFilepath = resolve(join(contractPath, 'Nargo.toml'));
+  const packageConfig = parseNoirPackageConfig(TOML.parse(await readFile(configFilepath, 'utf-8')));
+  const changes: DependencyChanges = {
+    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/src/cmds/misc/update/npm.ts

@@ -0,0 +1,154 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import { type SemVer, parse } from 'semver';
+
+import type { DependencyChanges } from './common.js';
+import { atomicUpdateFile } from './utils.js';
+
+const deprecatedNpmPackages = new Set<string>(['@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: string): Promise<{
+  /** dependencies */
+  dependencies?: Record<string, string>;
+  /** devDependencies */
+  devDependencies?: Record<string, string>;
+}> {
+  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: string, distTag = 'latest'): Promise<SemVer> {
+  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: string,
+  aztecVersion: SemVer,
+  log: LogFn,
+): Promise<DependencyChanges> {
+  const pkg = await readPackageJson(projectPath);
+  const changes: DependencyChanges = {
+    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'] as const) {
+    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: string, log: LogFn): void {
+  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/src/cmds/misc/update/utils.ts

@@ -0,0 +1,50 @@
+import type { NoirPackageConfig } from '@aztec/foundation/noir';
+
+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: 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;
+    }
+  }
+}
+
+/**
+ * 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: NoirPackageConfig): string {
+  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/src/cmds/misc/update.ts

@@ -0,0 +1,78 @@
+/* eslint-disable jsdoc/require-jsdoc */
+import type { LogFn } from '@aztec/foundation/log';
+
+import { relative, resolve } from 'path';
+import { parse } from 'semver';
+
+import type { DependencyChanges } from './update/common.js';
+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: string,
+  contracts: string[],
+  aztecVersion: string,
+  log: LogFn,
+): Promise<void> {
+  const targetAztecVersion =
+    aztecVersion === 'latest' ? await getNewestVersion(AZTECJS_PACKAGE, 'latest') : parse(aztecVersion);
+
+  if (!targetAztecVersion) {
+    throw new Error(`Invalid aztec version ${aztecVersion}`);
+  }
+
+  const projectDependencyChanges: DependencyChanges[] = [];
+  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: DependencyChanges, log: LogFn): void {
+  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/src/cmds/pxe/add_contract.ts

@@ -0,0 +1,41 @@
+import { AztecAddress, type ContractInstanceWithAddress, type Fr, getContractClassFromArtifact } from '@aztec/aztec.js';
+import { createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { computeContractAddressFromInstance } from '@aztec/stdlib/contract';
+import { PublicKeys } from '@aztec/stdlib/keys';
+
+import { getContractArtifact } from '../../utils/aztec.js';
+
+export async function addContract(
+  rpcUrl: string,
+  contractArtifactPath: string,
+  address: AztecAddress,
+  initializationHash: Fr,
+  salt: Fr,
+  publicKeys: PublicKeys,
+  deployer: AztecAddress | undefined,
+  debugLogger: Logger,
+  log: LogFn,
+) {
+  const artifact = await getContractArtifact(contractArtifactPath, log);
+  const contractClass = await getContractClassFromArtifact(artifact);
+  const instance: ContractInstanceWithAddress = {
+    version: 1,
+    salt,
+    initializationHash,
+    currentContractClassId: contractClass.id,
+    originalContractClassId: contractClass.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.currentContractClassId.toString()}\n`);
+}

package/src/cmds/pxe/block_number.ts

@@ -0,0 +1,9 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function blockNumber(rpcUrl: string, debugLogger: Logger, log: LogFn) {
+  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/src/cmds/pxe/get_account.ts

@@ -0,0 +1,16 @@
+import type { AztecAddress } from '@aztec/aztec.js';
+import { createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function getAccount(aztecAddress: AztecAddress, rpcUrl: string, debugLogger: Logger, log: LogFn) {
+  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/src/cmds/pxe/get_accounts.ts

@@ -0,0 +1,35 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function getAccounts(
+  rpcUrl: string,
+  json: boolean,
+  debugLogger: Logger,
+  log: LogFn,
+  logJson: (output: any) => void,
+) {
+  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/src/cmds/pxe/get_block.ts

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

package/src/cmds/pxe/get_contract_data.ts

@@ -0,0 +1,51 @@
+import type { AztecAddress } from '@aztec/aztec.js';
+import { createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function getContractData(
+  rpcUrl: string,
+  contractAddress: AztecAddress,
+  includeBytecode: boolean,
+  debugLogger: Logger,
+  log: LogFn,
+) {
+  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?.currentContractClassId)).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/src/cmds/pxe/get_current_base_fee.ts

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

package/src/cmds/pxe/get_l1_to_l2_message_witness.ts

@@ -0,0 +1,25 @@
+import { type AztecAddress, type Fr, createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function getL1ToL2MessageWitness(
+  rpcUrl: string,
+  contractAddress: AztecAddress,
+  messageHash: Fr,
+  secret: Fr,
+  debugLogger: Logger,
+  log: LogFn,
+) {
+  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/src/cmds/pxe/get_logs.ts

@@ -0,0 +1,66 @@
+import type { AztecAddress, LogFilter, LogId, TxHash } from '@aztec/aztec.js';
+import { createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+
+export async function getLogs(
+  txHash: TxHash,
+  fromBlock: number,
+  toBlock: number,
+  afterLog: LogId,
+  contractAddress: AztecAddress,
+  rpcUrl: string,
+  follow: boolean,
+  debugLogger: Logger,
+  log: LogFn,
+) {
+  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: LogFilter = { 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/src/cmds/pxe/get_node_info.ts

@@ -0,0 +1,71 @@
+import { type AztecNode, type PXE, createAztecNodeClient, createCompatibleClient } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function getNodeInfo(
+  rpcUrl: string,
+  pxeRequest: boolean,
+  debugLogger: Logger,
+  json: boolean,
+  log: LogFn,
+  logJson: (output: any) => void,
+) {
+  let client: AztecNode | PXE;
+  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()}`);
+  }
+}