@aztec/aztec 0.0.0-test.0

package/src/cli/cmds/start_node.ts

@@ -0,0 +1,151 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
+import { NULL_KEY } from '@aztec/ethereum';
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import type { LogFn } from '@aztec/foundation/log';
+import { AztecNodeApiSchema, type PXE } from '@aztec/stdlib/interfaces/client';
+import { P2PApiSchema } from '@aztec/stdlib/interfaces/server';
+import {
+  type TelemetryClientConfig,
+  initTelemetryClient,
+  telemetryClientConfigMappings,
+} from '@aztec/telemetry-client';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+import { createAztecNode, deployContractsToL1 } from '../../sandbox/index.js';
+import { getL1Config } from '../get_l1_config.js';
+import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
+
+export async function startNode(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+): Promise<{ config: AztecNodeConfig }> {
+  // options specifically namespaced with --node.<option>
+  const nodeSpecificOptions = extractNamespacedOptions(options, 'node');
+  // All options that are relevant to the Aztec Node
+  let nodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...extractRelevantOptions(options, aztecNodeConfigMappings, 'node'),
+  };
+
+  if (options.proverNode) {
+    userLog(`Running a Prover Node within a Node is not yet supported`);
+    process.exit(1);
+  }
+
+  const initialFundedAccounts = nodeConfig.testAccounts ? await getInitialTestAccounts() : [];
+  const { genesisBlockHash, genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(
+    initialFundedAccounts.map(a => a.address),
+  );
+
+  // Deploy contracts if needed
+  if (nodeSpecificOptions.deployAztecContracts || nodeSpecificOptions.deployAztecContractsSalt) {
+    let account;
+    if (nodeSpecificOptions.publisherPrivateKey) {
+      account = privateKeyToAccount(nodeSpecificOptions.publisherPrivateKey);
+    } else if (options.l1Mnemonic) {
+      account = mnemonicToAccount(options.l1Mnemonic);
+    } else {
+      throw new Error('--node.publisherPrivateKey or --l1-mnemonic is required to deploy L1 contracts');
+    }
+    // REFACTOR: We should not be calling a method from sandbox on the prod start flow
+    await deployContractsToL1(nodeConfig, account!, undefined, {
+      assumeProvenThroughBlockNumber: nodeSpecificOptions.assumeProvenThroughBlockNumber,
+      salt: nodeSpecificOptions.deployAztecContractsSalt,
+      genesisBlockHash,
+      genesisArchiveRoot,
+    });
+  }
+  // If not deploying, validate that any addresses and config provided are correct.
+  else {
+    if (!nodeConfig.l1Contracts.registryAddress || nodeConfig.l1Contracts.registryAddress.isZero()) {
+      throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
+    }
+    const { addresses, config } = await getL1Config(
+      nodeConfig.l1Contracts.registryAddress,
+      nodeConfig.l1RpcUrls,
+      nodeConfig.l1ChainId,
+    );
+
+    // TODO(#12272): will clean this up.
+    nodeConfig = {
+      ...nodeConfig,
+      l1Contracts: {
+        ...addresses,
+        slashFactoryAddress: nodeConfig.l1Contracts.slashFactoryAddress,
+      },
+      ...config,
+    };
+  }
+
+  // if no publisher private key, then use l1Mnemonic
+  if (!options.archiver) {
+    // expect archiver url in node config
+    const archiverUrl = nodeConfig.archiverUrl;
+    if (!archiverUrl) {
+      userLog('Archiver Service URL is required to start Aztec Node without --archiver option');
+      throw new Error('Archiver Service URL is required to start Aztec Node without --archiver option');
+    }
+    nodeConfig.archiverUrl = archiverUrl;
+  }
+
+  if (!options.sequencer) {
+    nodeConfig.disableValidator = true;
+  } else {
+    const sequencerConfig = extractNamespacedOptions(options, 'sequencer');
+    let account;
+    if (!sequencerConfig.publisherPrivateKey || sequencerConfig.publisherPrivateKey === NULL_KEY) {
+      if (!options.l1Mnemonic) {
+        userLog(
+          '--sequencer.publisherPrivateKey or --l1-mnemonic is required to start Aztec Node with --sequencer option',
+        );
+        throw new Error('Private key or Mnemonic is required to start Aztec Node with --sequencer option');
+      } else {
+        account = mnemonicToAccount(options.l1Mnemonic);
+        const privKey = account.getHdKey().privateKey;
+        nodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+      }
+    } else {
+      nodeConfig.publisherPrivateKey = sequencerConfig.publisherPrivateKey;
+    }
+  }
+
+  if (nodeConfig.p2pEnabled) {
+    // ensure bootstrapNodes is an array
+    if (nodeConfig.bootstrapNodes && typeof nodeConfig.bootstrapNodes === 'string') {
+      nodeConfig.bootstrapNodes = (nodeConfig.bootstrapNodes as string).split(',');
+    }
+  }
+
+  const telemetryConfig = extractRelevantOptions<TelemetryClientConfig>(options, telemetryClientConfigMappings, 'tel');
+  const telemetry = initTelemetryClient(telemetryConfig);
+
+  // Create and start Aztec Node
+  const node = await createAztecNode(nodeConfig, { telemetry }, { prefilledPublicData });
+
+  // Add node and p2p to services list
+  services.node = [node, AztecNodeApiSchema];
+  services.p2p = [node.getP2P(), P2PApiSchema];
+
+  // Add node stop function to signal handlers
+  signalHandlers.push(node.stop.bind(node));
+
+  // Add a PXE client that connects to this node if requested
+  let pxe: PXE | undefined;
+  if (options.pxe) {
+    const { addPXE } = await import('./start_pxe.js');
+    ({ pxe } = await addPXE(options, signalHandlers, services, userLog, { node }));
+  }
+
+  // Add a txs bot if requested
+  if (options.bot) {
+    const { addBot } = await import('./start_bot.js');
+    await addBot(options, signalHandlers, services, { pxe, node, telemetry });
+  }
+
+  return { config: nodeConfig };
+}

package/src/cli/cmds/start_p2p_bootstrap.ts

@@ -0,0 +1,29 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn, createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { type BootnodeConfig, BootstrapNode, bootnodeConfigMappings } from '@aztec/p2p';
+import { emptyChainConfig } from '@aztec/stdlib/config';
+import { P2PBootstrapApiSchema } from '@aztec/stdlib/interfaces/server';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+
+export async function startP2PBootstrap(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+) {
+  // Start a P2P bootstrap node.
+  const config = extractRelevantOptions<BootnodeConfig>(options, bootnodeConfigMappings, 'p2p');
+  userLog(`Starting P2P bootstrap node with config: ${jsonStringify(config)}`);
+  const telemetryClient = initTelemetryClient(getTelemetryClientConfig());
+  const store = await createStore('p2p-bootstrap', 1, config, createLogger('p2p:bootstrap:store'));
+  const node = new BootstrapNode(store, telemetryClient);
+  await node.start(config);
+  signalHandlers.push(() => node.stop());
+  services.bootstrap = [node, P2PBootstrapApiSchema];
+  userLog(`P2P bootstrap node started on ${config.udpListenAddress}`);
+  return { config: emptyChainConfig };
+}

package/src/cli/cmds/start_prover_agent.ts

@@ -0,0 +1,68 @@
+import { times } from '@aztec/foundation/collection';
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
+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, makeTracedFetch, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+import { getVersions } from '../versioning.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 fetch = makeTracedFetch([1, 2, 3], false, makeUndiciFetch(new Agent({ connections: 10 })));
+  const broker = createProvingJobBrokerClient(config.proverBrokerUrl, getVersions(), fetch);
+
+  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,46 @@
+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 type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+
+import { getL1Config } from '../get_l1_config.js';
+import { extractRelevantOptions } from '../util.js';
+
+export async function startProverBroker(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+): Promise<{ broker: ProvingJobBroker; config: ProverBrokerConfig }> {
+  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
+  };
+
+  if (!config.l1Contracts.registryAddress || config.l1Contracts.registryAddress.isZero()) {
+    throw new Error('L1 registry address is required to start Aztec Node without --deploy-aztec-contracts option');
+  }
+
+  const { addresses } = await getL1Config(config.l1Contracts.registryAddress, config.l1RpcUrls, config.l1ChainId);
+
+  config.l1Contracts = addresses;
+
+  const client = initTelemetryClient(getTelemetryClientConfig());
+  const broker = await createAndStartProvingBroker(config, client);
+  services.proverBroker = [broker, ProvingJobBrokerSchema];
+  signalHandlers.push(() => broker.stop());
+
+  return { broker, config };
+}

package/src/cli/cmds/start_prover_node.ts

@@ -0,0 +1,121 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { NULL_KEY } from '@aztec/ethereum';
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
+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 { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { initTelemetryClient, makeTracedFetch, telemetryClientConfigMappings } from '@aztec/telemetry-client';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { mnemonicToAccount } from 'viem/accounts';
+
+import { getL1Config } from '../get_l1_config.js';
+import { extractRelevantOptions } from '../util.js';
+import { getVersions } from '../versioning.js';
+import { startProverBroker } from './start_prover_broker.js';
+
+export async function startProverNode(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+): Promise<{ config: ProverNodeConfig }> {
+  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);
+  }
+
+  let 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) {
+    if (!proverConfig.l1Contracts.registryAddress || proverConfig.l1Contracts.registryAddress.isZero()) {
+      throw new Error('L1 registry address is required to start a Prover Node with --archiver option');
+    }
+    const { addresses, config } = await getL1Config(
+      proverConfig.l1Contracts.registryAddress,
+      proverConfig.l1RpcUrls,
+      proverConfig.l1ChainId,
+    );
+    proverConfig.l1Contracts = addresses;
+    proverConfig = { ...proverConfig, ...config };
+  }
+
+  const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+
+  let broker: ProvingJobBroker;
+  if (proverConfig.proverBrokerUrl) {
+    // at 1TPS we'd enqueue ~1k tube proofs and ~1k AVM proofs immediately
+    // set a lower connectio  limit such that we don't overload the server
+    const fetch = makeTracedFetch([1, 2, 3], false, makeUndiciFetch(new Agent({ connections: 100 })));
+    broker = createProvingJobBrokerClient(proverConfig.proverBrokerUrl, getVersions(proverConfig), fetch);
+  } 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 initialFundedAccounts = proverConfig.testAccounts ? await getInitialTestAccounts() : [];
+  const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+
+  const proverNode = await createProverNode(proverConfig, { telemetry, broker }, { prefilledPublicData });
+  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));
+
+  proverNode.start();
+  return { config: proverConfig };
+}

package/src/cli/cmds/start_pxe.ts

@@ -0,0 +1,129 @@
+import {
+  AztecAddress,
+  type ContractArtifact,
+  type ContractInstanceWithAddress,
+  Fr,
+  PublicKeys,
+  getContractClassFromArtifact,
+} from '@aztec/aztec.js';
+import { getContractArtifact } from '@aztec/cli/cli-utils';
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import type { LogFn } from '@aztec/foundation/log';
+import {
+  type CliPXEOptions,
+  type PXEService,
+  type PXEServiceConfig,
+  allPxeConfigMappings,
+  createPXEService,
+} from '@aztec/pxe/server';
+import { type AztecNode, PXESchema, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { L2BasicContractsMap, Network } from '@aztec/stdlib/network';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+import { getVersions } from '../versioning.js';
+
+export type { PXEServiceConfig, CliPXEOptions };
+
+const contractAddressesUrl = 'http://static.aztec.network';
+
+export async function startPXE(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+): Promise<{ pxe: PXEService; config: PXEServiceConfig & CliPXEOptions }> {
+  return await addPXE(options, signalHandlers, services, userLog, {});
+}
+
+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 } = {},
+): Promise<{ pxe: PXEService; config: PXEServiceConfig & CliPXEOptions }> {
+  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!, getVersions(pxeConfig), 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 contractClass = await getContractClassFromArtifact(artifact!);
+        const instance: ContractInstanceWithAddress = {
+          version: 1,
+          salt,
+          initializationHash: initHash,
+          address,
+          deployer: AztecAddress.ZERO,
+          currentContractClassId: contractClass.id,
+          originalContractClassId: contractClass.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, config: pxeConfig };
+}

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/get_l1_config.ts

@@ -0,0 +1,18 @@
+import { type L1ContractAddresses, RegistryContract, getL1ContractsConfig, getPublicClient } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+export async function getL1Config(
+  registryAddress: EthAddress,
+  l1RpcUrls: string[],
+  l1ChainId: number,
+): Promise<{ addresses: L1ContractAddresses; config: Awaited<ReturnType<typeof getL1ContractsConfig>> }> {
+  const publicClient = getPublicClient({ l1RpcUrls, l1ChainId });
+  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, 'canonical');
+
+  const config = await getL1ContractsConfig(publicClient, addresses);
+
+  return {
+    addresses,
+    config,
+  };
+}

package/src/cli/index.ts

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