@aztec/aztec 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/cli/cmds/start_proof_verifier.ts

@@ -0,0 +1,18 @@
+import { type LogFn } from '@aztec/foundation/log';
+import { ProofVerifier, proofVerifierConfigMappings } from '@aztec/proof-verifier';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+
+export async function startProofVerifier(options: any, signalHandlers: (() => Promise<void>)[], userLog: LogFn) {
+  const config = extractRelevantOptions(options, proofVerifierConfigMappings, 'proofVerifier');
+
+  const telemetryConfig = extractRelevantOptions(options, telemetryClientConfigMappings, 'tel');
+  const telemetry = initTelemetryClient(telemetryConfig);
+  const proofVerifier = await ProofVerifier.new(config, telemetry);
+
+  userLog('Starting proof verifier');
+  proofVerifier.start();
+
+  signalHandlers.push(() => proofVerifier.stop());
+}

package/src/cli/cmds/start_prover_agent.ts

@@ -0,0 +1,65 @@
+import { times } from '@aztec/foundation/collection';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn } from '@aztec/foundation/log';
+import { buildServerCircuitProver } from '@aztec/prover-client';
+import {
+  InlineProofStore,
+  type ProverAgentConfig,
+  ProvingAgent,
+  createProvingJobBrokerClient,
+  proverAgentConfigMappings,
+} from '@aztec/prover-client/broker';
+import { getProverNodeAgentConfigFromEnv } from '@aztec/prover-node';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+
+export async function startProverAgent(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+) {
+  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover agent with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+    process.exit(1);
+  }
+
+  const config = {
+    ...getProverNodeAgentConfigFromEnv(), // get default config from env
+    ...extractRelevantOptions<ProverAgentConfig>(options, proverAgentConfigMappings, 'proverAgent'), // override with command line options
+  };
+
+  if (config.realProofs && (!config.bbBinaryPath || !config.acvmBinaryPath)) {
+    process.exit(1);
+  }
+
+  if (!config.proverBrokerUrl) {
+    process.exit(1);
+  }
+
+  const broker = createProvingJobBrokerClient(config.proverBrokerUrl);
+
+  const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+  const prover = await buildServerCircuitProver(config, telemetry);
+  const proofStore = new InlineProofStore();
+  const agents = times(
+    config.proverAgentCount,
+    () =>
+      new ProvingAgent(
+        broker,
+        proofStore,
+        prover,
+        config.proverAgentProofTypes,
+        config.proverAgentPollIntervalMs,
+        telemetry,
+      ),
+  );
+
+  await Promise.all(agents.map(agent => agent.start()));
+
+  signalHandlers.push(async () => {
+    await Promise.all(agents.map(agent => agent.stop()));
+    await telemetry.stop();
+  });
+}

package/src/cli/cmds/start_prover_broker.ts

@@ -0,0 +1,37 @@
+import { type ProvingJobBroker } from '@aztec/circuit-types';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn } from '@aztec/foundation/log';
+import {
+  type ProverBrokerConfig,
+  ProvingJobBrokerSchema,
+  createAndStartProvingBroker,
+  proverBrokerConfigMappings,
+} from '@aztec/prover-client/broker';
+import { getProverNodeBrokerConfigFromEnv } from '@aztec/prover-node';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+
+export async function startProverBroker(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+): Promise<ProvingJobBroker> {
+  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover broker with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+    process.exit(1);
+  }
+
+  const config: ProverBrokerConfig = {
+    ...getProverNodeBrokerConfigFromEnv(), // get default config from env
+    ...extractRelevantOptions<ProverBrokerConfig>(options, proverBrokerConfigMappings, 'proverBroker'), // override with command line options
+  };
+
+  const client = initTelemetryClient(getTelemetryClientConfig());
+  const broker = await createAndStartProvingBroker(config, client);
+  services.proverBroker = [broker, ProvingJobBrokerSchema];
+  signalHandlers.push(() => broker.stop());
+
+  return broker;
+}

package/src/cli/cmds/start_prover_node.ts

@@ -0,0 +1,100 @@
+import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker, createAztecNodeClient } from '@aztec/circuit-types';
+import { NULL_KEY } from '@aztec/ethereum';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn } from '@aztec/foundation/log';
+import { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
+import {
+  type ProverNodeConfig,
+  createProverNode,
+  getProverNodeConfigFromEnv,
+  proverNodeConfigMappings,
+} from '@aztec/prover-node';
+import { initTelemetryClient, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+
+import { mnemonicToAccount } from 'viem/accounts';
+
+import { extractRelevantOptions } from '../util.js';
+import { validateL1Config } from '../validation.js';
+import { startProverBroker } from './start_prover_broker.js';
+
+export async function startProverNode(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+) {
+  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+    userLog(`Starting a prover-node with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
+    process.exit(1);
+  }
+
+  const proverConfig = {
+    ...getProverNodeConfigFromEnv(), // get default config from env
+    ...extractRelevantOptions<ProverNodeConfig>(options, proverNodeConfigMappings, 'proverNode'), // override with command line options
+  };
+
+  if (!options.archiver && !proverConfig.archiverUrl) {
+    userLog('--archiver.archiverUrl is required to start a Prover Node without --archiver option');
+    process.exit(1);
+  }
+
+  if (!proverConfig.publisherPrivateKey || proverConfig.publisherPrivateKey === NULL_KEY) {
+    if (!options.l1Mnemonic) {
+      userLog(`--l1-mnemonic is required to start a Prover Node without --node.publisherPrivateKey`);
+      process.exit(1);
+    }
+    const hdAccount = mnemonicToAccount(options.l1Mnemonic);
+    const privKey = hdAccount.getHdKey().privateKey;
+    proverConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+  }
+
+  // TODO(palla/prover-node) L1 contract addresses should not silently default to zero,
+  // they should be undefined if not set and fail loudly.
+  // Load l1 contract addresses from aztec node if not set.
+  const isRollupAddressSet =
+    proverConfig.l1Contracts?.rollupAddress && !proverConfig.l1Contracts.rollupAddress.isZero();
+  const nodeUrl = proverConfig.nodeUrl ?? proverConfig.proverCoordinationNodeUrl;
+  if (nodeUrl && !isRollupAddressSet) {
+    userLog(`Loading L1 contract addresses from aztec node at ${nodeUrl}`);
+    proverConfig.l1Contracts = await createAztecNodeClient(nodeUrl).getL1ContractAddresses();
+  }
+
+  // If we create an archiver here, validate the L1 config
+  if (options.archiver) {
+    await validateL1Config(proverConfig);
+  }
+
+  const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+
+  let broker: ProvingJobBroker;
+  if (proverConfig.proverBrokerUrl) {
+    broker = createProvingJobBrokerClient(proverConfig.proverBrokerUrl);
+  } else if (options.proverBroker) {
+    broker = await startProverBroker(options, signalHandlers, services, userLog);
+  } else {
+    userLog(`--prover-broker-url or --prover-broker is required to start a Prover Node`);
+    process.exit(1);
+  }
+
+  if (proverConfig.proverAgentCount === 0) {
+    userLog(
+      `Running prover node without local prover agent. Connect one or more prover agents to this node or pass --proverAgent.proverAgentCount`,
+    );
+  }
+
+  const proverNode = await createProverNode(proverConfig, { telemetry, broker });
+  services.proverNode = [proverNode, ProverNodeApiSchema];
+
+  const p2p = proverNode.getP2P();
+  if (p2p) {
+    services.p2p = [proverNode.getP2P(), P2PApiSchema];
+  }
+
+  if (!proverConfig.proverBrokerUrl) {
+    services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
+  }
+
+  signalHandlers.push(proverNode.stop.bind(proverNode));
+
+  await proverNode.start();
+}

package/src/cli/cmds/start_pxe.ts

@@ -0,0 +1,124 @@
+import {
+  type ContractArtifact,
+  type ContractInstanceWithAddress,
+  Fr,
+  PublicKeys,
+  getContractClassFromArtifact,
+} from '@aztec/aztec.js';
+import { type AztecNode, PXESchema, createAztecNodeClient } from '@aztec/circuit-types';
+import { getContractArtifact } from '@aztec/cli/cli-utils';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn } from '@aztec/foundation/log';
+import {
+  AztecAddress,
+  type CliPXEOptions,
+  type PXEServiceConfig,
+  allPxeConfigMappings,
+  createPXEService,
+} from '@aztec/pxe';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+import { L2BasicContractsMap, Network } from '@aztec/types/network';
+
+import { extractRelevantOptions } from '../util.js';
+
+const contractAddressesUrl = 'http://static.aztec.network';
+
+export async function startPXE(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+) {
+  await addPXE(options, signalHandlers, services, userLog, {});
+  return services;
+}
+
+function isValidNetwork(value: any): value is Network {
+  return Object.values(Network).includes(value);
+}
+
+async function fetchBasicContractAddresses(url: string) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch basic contract addresses from ${url}`);
+  }
+  return response.json();
+}
+
+export async function addPXE(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+  deps: { node?: AztecNode } = {},
+) {
+  const pxeConfig = extractRelevantOptions<PXEServiceConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+
+  let nodeUrl;
+  if (pxeConfig.network) {
+    if (isValidNetwork(pxeConfig.network)) {
+      if (!pxeConfig.apiKey && !pxeConfig.nodeUrl) {
+        userLog(`API Key or Aztec Node URL is required to connect to ${pxeConfig.network}`);
+        process.exit(1);
+      } else if (pxeConfig.apiKey) {
+        nodeUrl = `https://api.aztec.network/${pxeConfig.network}/aztec-node-1/${pxeConfig.apiKey}`;
+      } else if (pxeConfig.nodeUrl) {
+        nodeUrl = pxeConfig.nodeUrl;
+      }
+    } else {
+      userLog(`Network ${pxeConfig.network} is not supported`);
+      process.exit(1);
+    }
+  } else {
+    nodeUrl = pxeConfig.nodeUrl;
+  }
+  if (!nodeUrl && !deps.node && !pxeConfig.network) {
+    userLog('Aztec Node URL (nodeUrl | AZTEC_NODE_URL) option is required to start PXE without --node option');
+    process.exit(1);
+  }
+
+  const node = deps.node ?? createAztecNodeClient(nodeUrl!, makeTracedFetch([1, 2, 3], true));
+  const pxe = await createPXEService(node, pxeConfig as PXEServiceConfig);
+
+  // register basic contracts
+  if (pxeConfig.network) {
+    userLog(`Registering basic contracts for ${pxeConfig.network}`);
+    const basicContractsInfo = await fetchBasicContractAddresses(
+      `${contractAddressesUrl}/${pxeConfig.network}/basic_contracts.json`,
+    );
+    const l2Contracts: Record<
+      string,
+      { name: string; address: AztecAddress; initHash: Fr; salt: Fr; artifact: ContractArtifact }
+    > = {};
+    for (const [key, artifactName] of Object.entries(L2BasicContractsMap[pxeConfig.network as Network])) {
+      l2Contracts[key] = {
+        name: key,
+        address: AztecAddress.fromString(basicContractsInfo[key].address),
+        initHash: Fr.fromHexString(basicContractsInfo[key].initHash),
+        salt: Fr.fromHexString(basicContractsInfo[key].salt),
+        artifact: await getContractArtifact(artifactName, userLog),
+      };
+    }
+
+    await Promise.all(
+      Object.values(l2Contracts).map(async ({ name, address, artifact, initHash, salt }) => {
+        const instance: ContractInstanceWithAddress = {
+          version: 1,
+          salt,
+          initializationHash: initHash,
+          address,
+          deployer: AztecAddress.ZERO,
+          contractClassId: (await getContractClassFromArtifact(artifact!)).id,
+          publicKeys: PublicKeys.default(),
+        };
+        userLog(`Registering ${name} at ${address.toString()}`);
+        await pxe.registerContract({ artifact, instance });
+      }),
+    );
+  }
+
+  // Add PXE to services list
+  services.pxe = [pxe, PXESchema];
+
+  return pxe;
+}

package/src/cli/cmds/start_txe.ts

@@ -0,0 +1,15 @@
+import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { type Logger } from '@aztec/foundation/log';
+import { createTXERpcServer } from '@aztec/txe';
+
+export async function startTXE(options: any, debugLogger: Logger) {
+  debugLogger.info(`Setting up TXE...`);
+
+  const txeServer = createTXERpcServer(debugLogger);
+  const { port } = await startHttpRpcServer(txeServer, {
+    port: options.port,
+    timeoutMs: 1e3 * 60 * 5,
+  });
+
+  debugLogger.info(`TXE listening on port ${port}`);
+}

package/src/cli/index.ts

@@ -0,0 +1 @@
+export * from './cli.js';

package/src/cli/util.ts

@@ -0,0 +1,216 @@
+import { type AccountManager, type Fr } from '@aztec/aztec.js';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type LogFn } from '@aztec/foundation/log';
+import { type PXEService } from '@aztec/pxe';
+
+import chalk from 'chalk';
+import { type Command } from 'commander';
+
+import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
+
+export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<void>>) => {
+  const shutdown = async () => {
+    logFn('Shutting down...');
+    if (cb) {
+      await Promise.all(cb);
+    }
+    process.exit(0);
+  };
+  process.removeAllListeners('SIGINT');
+  process.removeAllListeners('SIGTERM');
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGINT', shutdown);
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGTERM', shutdown);
+};
+
+/**
+ * Creates logs for the initial accounts
+ * @param accounts - The initial accounts
+ * @param pxe - A PXE instance to get the registered accounts
+ * @returns A string array containing the initial accounts details
+ */
+export async function createAccountLogs(
+  accountsWithSecretKeys: {
+    /**
+     * The account object
+     */
+    account: AccountManager;
+    /**
+     * The secret key of the account
+     */
+    secretKey: Fr;
+  }[],
+  pxe: PXEService,
+) {
+  const registeredAccounts = await pxe.getRegisteredAccounts();
+  const accountLogStrings = [`Initial Accounts:\n\n`];
+  for (const accountWithSecretKey of accountsWithSecretKeys) {
+    const completeAddress = await accountWithSecretKey.account.getCompleteAddress();
+    if (registeredAccounts.find(a => a.equals(completeAddress))) {
+      accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
+      accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
+      accountLogStrings.push(` Secret Key: ${accountWithSecretKey.secretKey.toString()}\n`);
+      accountLogStrings.push(
+        ` Master nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`,
+      );
+      accountLogStrings.push(
+        ` Master incoming viewing public key: ${completeAddress.publicKeys.masterIncomingViewingPublicKey.toString()}\n\n`,
+      );
+      accountLogStrings.push(
+        ` Master outgoing viewing public key: ${completeAddress.publicKeys.masterOutgoingViewingPublicKey.toString()}\n\n`,
+      );
+      accountLogStrings.push(
+        ` Master tagging public key: ${completeAddress.publicKeys.masterTaggingPublicKey.toString()}\n\n`,
+      );
+    }
+  }
+  return accountLogStrings;
+}
+
+export function getMaxLengths(sections: { [key: string]: AztecStartOption[] }): [number, number] {
+  let maxFlagLength = 0;
+  let maxDefaultLength = 0;
+
+  Object.values(sections).forEach(options => {
+    options.forEach(option => {
+      if (option.flag.length > maxFlagLength) {
+        maxFlagLength = option.flag.length;
+      }
+      const defaultLength = option.defaultValue ? option.defaultValue.length : 0;
+      if (defaultLength > maxDefaultLength) {
+        maxDefaultLength = defaultLength;
+      }
+    });
+  });
+
+  return [maxFlagLength + 1, maxDefaultLength + 1];
+}
+
+export function formatHelpLine(
+  option: string,
+  defaultValue: string,
+  envVar: string,
+  maxOptionLength: number,
+  maxDefaultLength: number,
+): string {
+  const paddedOption = option.padEnd(maxOptionLength + 2, ' ');
+  const paddedDefault = defaultValue.padEnd(maxDefaultLength + 2, ' ');
+
+  return `${chalk.cyan(paddedOption)}${chalk.yellow(paddedDefault)}${chalk.green(envVar)}`;
+}
+
+const getDefaultOrEnvValue = (opt: AztecStartOption) => {
+  let val;
+  // if the option is set in the environment, use that & parse it
+  if (opt.envVar && process.env[opt.envVar]) {
+    val = process.env[opt.envVar];
+    if (val && opt.parseVal) {
+      return opt.parseVal(val);
+    }
+    // if no env variable, use the default value
+  } else if (opt.defaultValue) {
+    val = opt.defaultValue;
+  }
+
+  return val;
+};
+
+// Function to add options dynamically
+export const addOptions = (cmd: Command, options: AztecStartOption[]) => {
+  options.forEach(opt => {
+    cmd.option(
+      opt.flag,
+      `${opt.description} (default: ${opt.defaultValue}) ($${opt.envVar})`,
+      opt.parseVal ? opt.parseVal : val => val,
+      getDefaultOrEnvValue(opt),
+    );
+  });
+};
+
+export const printAztecStartHelpText = () => {
+  const helpTextLines: string[] = [''];
+  const [maxFlagLength, maxDefaultLength] = getMaxLengths(aztecStartOptions);
+
+  Object.keys(aztecStartOptions).forEach(category => {
+    helpTextLines.push(chalk.bold.blue(`  ${category}`));
+    helpTextLines.push('');
+
+    aztecStartOptions[category].forEach(opt => {
+      const defaultValueText = opt.defaultValue
+        ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})`
+        : '';
+      const envVarText = opt.envVar ? `($${opt.envVar})` : '';
+      const flagText = `${opt.flag}`;
+
+      const paddedText = formatHelpLine(flagText, defaultValueText, envVarText, maxFlagLength, maxDefaultLength);
+
+      helpTextLines.push(`    ${paddedText}`);
+      helpTextLines.push(`          ${chalk.white(opt.description)}`);
+      helpTextLines.push('');
+    });
+  });
+
+  return helpTextLines.join('\n');
+};
+
+/**
+ * Extracts namespaced options from a key-value map.
+ * @param options - Key-value map of options.
+ * @param namespace - The namespace to extract.
+ * @returns Key-value map of namespaced options.
+ */
+export const extractNamespacedOptions = (options: Record<string, any>, namespace: string) => {
+  const extract = `${namespace}.`;
+  const namespacedOptions: Record<string, any> = {};
+  for (const key in options) {
+    if (key.startsWith(extract)) {
+      namespacedOptions[key.replace(extract, '')] = options[key];
+    }
+  }
+  return namespacedOptions;
+};
+
+/**
+ * Extracts relevant options from a key-value map.
+ * @template T - The type of the relevant options.
+ * @param options - Key-value map of options.
+ * @param mappings - The mappings to extract.
+ * @param namespace - The namespace to extract for.
+ * @returns Key-value map of relevant options.
+ */
+export const extractRelevantOptions = <T>(
+  options: Record<string, any>,
+  mappings: ConfigMappingsType<T>,
+  namespace: string,
+): T => {
+  const relevantOptions: T = {} as T;
+
+  // Iterate over each key in the options
+  Object.keys(options).forEach(optionKey => {
+    const keyParts = optionKey.split('.');
+    const optionNamespace = keyParts.length > 1 ? keyParts[0] : '';
+    const mainKey = keyParts.length > 1 ? keyParts[1] : keyParts[0];
+
+    // Check if the key exists in the mappings
+    if (mainKey in mappings) {
+      // Check for duplicates in the options
+      const duplicates = Object.keys(options).filter(optKey => {
+        const optKeyParts = optKey.split('.');
+        return optKeyParts[1] === mainKey || optKeyParts[0] === mainKey;
+      });
+
+      // If duplicates are found, use the namespace to differentiate
+      if (duplicates.length > 1) {
+        if (namespace === optionNamespace) {
+          relevantOptions[mainKey as keyof T] = options[optionKey];
+        }
+      } else {
+        // If no duplicates, extract the value without considering the namespace
+        relevantOptions[mainKey as keyof T] = options[optionKey];
+      }
+    }
+  });
+
+  return relevantOptions;
+};

package/src/cli/validation.ts

@@ -0,0 +1,38 @@
+import {
+  type L1ContractAddresses,
+  type L1ContractsConfig,
+  getL1ContractsAddresses,
+  getL1ContractsConfig,
+  getPublicClient,
+} from '@aztec/ethereum';
+
+/**
+ * Connects to L1 using the provided L1 RPC URL and reads all addresses and settings from the governance
+ * contract. For each key, compares it against the provided config (if it is not empty) and throws on mismatches.
+ */
+export async function validateL1Config(
+  config: L1ContractsConfig & { l1Contracts: L1ContractAddresses } & { l1ChainId: number; l1RpcUrl: string },
+) {
+  const publicClient = getPublicClient(config);
+  const actualAddresses = await getL1ContractsAddresses(publicClient, config.l1Contracts.governanceAddress);
+
+  for (const keyStr in actualAddresses) {
+    const key = keyStr as keyof Awaited<ReturnType<typeof getL1ContractsAddresses>>;
+    const actual = actualAddresses[key];
+    const expected = config.l1Contracts[key];
+
+    if (expected !== undefined && !expected.isZero() && !actual.equals(expected)) {
+      throw new Error(`Expected L1 contract address ${key} to be ${expected} but found ${actual}`);
+    }
+  }
+
+  const actualConfig = await getL1ContractsConfig(publicClient, actualAddresses);
+  for (const keyStr in actualConfig) {
+    const key = keyStr as keyof Awaited<ReturnType<typeof getL1ContractsConfig>> & keyof L1ContractsConfig;
+    const actual = actualConfig[key];
+    const expected = config[key];
+    if (expected !== undefined && actual !== expected) {
+      throw new Error(`Expected L1 setting ${key} to be ${expected} but found ${actual}`);
+    }
+  }
+}