@aztec/aztec 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/cli/aztec_start_options.ts

@@ -0,0 +1,366 @@
+import { type ArchiverConfig, archiverConfigMappings } from '@aztec/archiver/config';
+import { faucetConfigMapping } from '@aztec/aztec-faucet/config';
+import { sequencerClientConfigMappings } from '@aztec/aztec-node/config';
+import { blobSinkConfigMapping } from '@aztec/blob-sink/client';
+import { botConfigMappings } from '@aztec/bot/config';
+import {
+  type ConfigMapping,
+  type EnvVar,
+  booleanConfigHelper,
+  isBooleanConfigValue,
+  omitConfigMappings,
+} from '@aztec/foundation/config';
+import { bootnodeConfigMappings, p2pConfigMappings } from '@aztec/p2p/config';
+import { proofVerifierConfigMappings } from '@aztec/proof-verifier/config';
+import {
+  type ProverAgentConfig,
+  type ProverBrokerConfig,
+  proverAgentConfigMappings,
+  proverBrokerConfigMappings,
+} from '@aztec/prover-client/broker';
+import { proverNodeConfigMappings } from '@aztec/prover-node/config';
+import { allPxeConfigMappings } from '@aztec/pxe/config';
+import { telemetryClientConfigMappings } from '@aztec/telemetry-client';
+
+import { DefaultMnemonic } from '../mnemonic.js';
+
+// Define an interface for options
+export interface AztecStartOption {
+  flag: string;
+  description: string;
+  defaultValue: any | undefined;
+  printDefault?: (val: any) => string;
+  envVar: EnvVar | undefined;
+  parseVal?: (val: string) => any;
+}
+
+export const getOptions = (namespace: string, configMappings: Record<string, ConfigMapping>) => {
+  const options: AztecStartOption[] = [];
+  for (const [key, { env, defaultValue: def, parseEnv, description, printDefault }] of Object.entries(configMappings)) {
+    if (universalOptions.includes(key)) {
+      continue;
+    }
+    const isBoolean = isBooleanConfigValue(configMappings, key as keyof typeof configMappings);
+    options.push({
+      flag: `--${namespace}.${key}${isBoolean ? '' : ' <value>'}`,
+      description,
+      defaultValue: def,
+      printDefault,
+      envVar: env,
+      parseVal: parseEnv,
+    });
+  }
+  return options;
+};
+
+// These are options used by multiple modules so should be inputted once
+export const universalOptions = ['l1RpcUrl', 'l1ChainId', 'l1Contracts', 'p2pEnabled', 'dataDirectory'];
+
+// Define categories and options
+export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
+  SANDBOX: [
+    {
+      flag: '--sandbox',
+      description: 'Starts Aztec Sandbox',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    {
+      flag: '--sandbox.testAccounts',
+      description: 'Deploy test accounts on sandbox start',
+      envVar: 'TEST_ACCOUNTS',
+      ...booleanConfigHelper(true),
+    },
+    {
+      flag: '--sandbox.noPXE',
+      description: 'Do not expose PXE service on sandbox start',
+      envVar: 'NO_PXE',
+      ...booleanConfigHelper(),
+    },
+  ],
+  API: [
+    {
+      flag: '--port <value>',
+      description: 'Port to run the Aztec Services on on',
+      defaultValue: 8080,
+      envVar: 'AZTEC_PORT',
+      parseVal: val => parseInt(val, 10),
+    },
+    {
+      flag: '--api-prefix <value>',
+      description: 'Prefix for API routes on any service that is started',
+      defaultValue: '',
+      envVar: 'API_PREFIX',
+    },
+  ],
+  ETHEREUM: [
+    {
+      flag: '--l1-rpc-url <value>',
+      description: 'URL of the Ethereum RPC node that services will connect to',
+      defaultValue: 'http://localhost:8545',
+      envVar: 'ETHEREUM_HOST',
+    },
+    {
+      flag: '--l1-chain-id <value>',
+      description: 'The L1 chain ID',
+      defaultValue: 31337,
+      envVar: 'L1_CHAIN_ID',
+      parseVal: val => parseInt(val, 10),
+    },
+    {
+      flag: '--l1-mnemonic <value>',
+      description: 'Mnemonic for L1 accounts. Will be used if no publisher private keys are provided',
+      defaultValue: DefaultMnemonic,
+      envVar: 'MNEMONIC',
+    },
+  ],
+  'L1 CONTRACT ADDRESSES': [
+    {
+      flag: '--rollup-address <value>',
+      description: 'The deployed L1 rollup contract address',
+      defaultValue: undefined,
+      envVar: 'ROLLUP_CONTRACT_ADDRESS',
+    },
+    {
+      flag: '--registry-address <value>',
+      description: 'The deployed L1 registry contract address',
+      defaultValue: undefined,
+      envVar: 'REGISTRY_CONTRACT_ADDRESS',
+    },
+    {
+      flag: '--inbox-address <value>',
+      description: 'The deployed L1 -> L2 inbox contract address',
+      defaultValue: undefined,
+      envVar: 'INBOX_CONTRACT_ADDRESS',
+    },
+    {
+      flag: '--outbox-address <value>',
+      description: 'The deployed L2 -> L1 outbox contract address',
+      defaultValue: undefined,
+      envVar: 'OUTBOX_CONTRACT_ADDRESS',
+    },
+    {
+      flag: '--fee-juice-address <value>',
+      description: 'The deployed L1 Fee Juice contract address',
+      defaultValue: undefined,
+      envVar: 'FEE_JUICE_CONTRACT_ADDRESS',
+    },
+    {
+      flag: '--staking-asset-address <value>',
+      description: 'The deployed L1 Staking Asset contract address',
+      defaultValue: undefined,
+      envVar: 'STAKING_ASSET_CONTRACT_ADDRESS',
+    },
+    {
+      flag: '--fee-juice-portal-address <value>',
+      description: 'The deployed L1 Fee Juice portal contract address',
+      defaultValue: undefined,
+      envVar: 'FEE_JUICE_PORTAL_CONTRACT_ADDRESS',
+    },
+  ],
+  // We can't easily auto-generate node options as they're parts of modules defined below
+  'AZTEC NODE': [
+    {
+      flag: '--node',
+      description: 'Starts Aztec Node with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    {
+      flag: '--data-directory <value>',
+      description: 'Where to store data. If not set, will store temporarily',
+      defaultValue: undefined,
+      envVar: 'DATA_DIRECTORY',
+    },
+    {
+      flag: '--node.archiverUrl <value>',
+      description: 'URL for an archiver service',
+      defaultValue: undefined,
+      envVar: 'ARCHIVER_URL',
+    },
+    {
+      flag: '--node.deployAztecContracts',
+      description: 'Deploys L1 Aztec contracts before starting the node. Needs mnemonic or private key to be set.',
+      envVar: 'DEPLOY_AZTEC_CONTRACTS',
+      ...booleanConfigHelper(),
+    },
+    {
+      flag: '--node.deployAztecContractsSalt',
+      description:
+        'Numeric salt for deploying L1 Aztec contracts before starting the node. Needs mnemonic or private key to be set. Implies --node.deployAztecContracts.',
+      envVar: 'DEPLOY_AZTEC_CONTRACTS_SALT',
+      defaultValue: undefined,
+      parseVal: (val: string) => (val ? parseInt(val) : undefined),
+    },
+    {
+      flag: '--node.assumeProvenThroughBlockNumber',
+      description:
+        'Cheats the rollup contract into assuming every block until this one is proven. Useful for speeding up bootstraps.',
+      envVar: 'ASSUME_PROVEN_THROUGH_BLOCK_NUMBER',
+      parseVal: (val: string) => parseInt(val, 10),
+      defaultValue: 0,
+    },
+    {
+      flag: '--node.publisherPrivateKey <value>',
+      description: 'Private key of account for publishing L1 contracts',
+      defaultValue: undefined,
+      envVar: 'L1_PRIVATE_KEY',
+    },
+    {
+      flag: '--node.worldStateBlockCheckIntervalMS <value>',
+      description: 'Frequency in which to check for blocks in ms',
+      defaultValue: 100,
+      envVar: 'WS_BLOCK_CHECK_INTERVAL_MS',
+      parseVal: val => parseInt(val, 10),
+    },
+  ],
+  'P2P SUBSYSTEM': [
+    {
+      flag: '--p2p-enabled',
+      description: 'Enable P2P subsystem',
+      envVar: 'P2P_ENABLED',
+      ...booleanConfigHelper(),
+    },
+    ...getOptions('p2p', p2pConfigMappings),
+  ],
+  TELEMETRY: [...getOptions('tel', telemetryClientConfigMappings)],
+  PXE: [
+    {
+      flag: '--pxe',
+      description: 'Starts Aztec PXE with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('pxe', allPxeConfigMappings),
+  ],
+  ARCHIVER: [
+    {
+      flag: '--archiver',
+      description: 'Starts Aztec Archiver with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    // filter out archiverUrl as it's passed separately in --node & --prover-node
+    ...getOptions('archiver', archiverConfigMappings).filter(opt => !opt.flag.includes('archiverUrl')),
+  ],
+  SEQUENCER: [
+    {
+      flag: '--sequencer',
+      description: 'Starts Aztec Sequencer with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('sequencer', sequencerClientConfigMappings),
+  ],
+  BLOB_SINK: [
+    {
+      flag: '--blob-sink',
+      description: 'Starts Aztec Blob Sink with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('blobSink', blobSinkConfigMapping),
+  ],
+  'PROVER NODE': [
+    {
+      flag: '--prover-node',
+      description: 'Starts Aztec Prover Node with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    {
+      flag: '--proverNode.archiverUrl <value>',
+      description: 'URL for an archiver service',
+      defaultValue: undefined,
+      envVar: 'ARCHIVER_URL',
+    },
+    ...getOptions(
+      'proverNode',
+      omitConfigMappings(proverNodeConfigMappings, [
+        // filter out options passed separately
+        ...(Object.keys(archiverConfigMappings) as (keyof ArchiverConfig)[]),
+        ...(Object.keys(proverBrokerConfigMappings) as (keyof ProverBrokerConfig)[]),
+        ...(Object.keys(proverAgentConfigMappings) as (keyof ProverAgentConfig)[]),
+      ]),
+    ),
+  ],
+  'PROVER BROKER': [
+    {
+      flag: '--prover-broker',
+      description: 'Starts Aztec proving job broker',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions(
+      'proverBroker',
+      // filter out archiver options from prover node options as they're passed separately in --archiver
+      proverBrokerConfigMappings,
+    ),
+  ],
+  'PROVER AGENT': [
+    {
+      flag: '--prover-agent',
+      description: 'Starts Aztec Prover Agent with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('proverAgent', proverAgentConfigMappings),
+  ],
+  'P2P BOOTSTRAP': [
+    {
+      flag: '--p2p-bootstrap',
+      description: 'Starts Aztec P2P Bootstrap with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('p2pBootstrap', bootnodeConfigMappings),
+  ],
+  BOT: [
+    {
+      flag: '--bot',
+      description: 'Starts Aztec Bot with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('bot', botConfigMappings),
+  ],
+  'PROOF VERIFIER': [
+    {
+      flag: '--proof-verifier',
+      description: 'Starts Aztec Proof Verifier with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    ...getOptions('proofVerifier', proofVerifierConfigMappings),
+  ],
+  TXE: [
+    {
+      flag: '--txe',
+      description: 'Starts Aztec TXE with options',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+  ],
+  FAUCET: [
+    {
+      flag: '--faucet',
+      description: 'Starts the Aztec faucet',
+      defaultValue: undefined,
+      envVar: undefined,
+    },
+    {
+      flag: '--faucet.apiServer',
+      description: 'Starts a simple HTTP server to access the faucet',
+      defaultValue: true,
+      envVar: undefined,
+    },
+    {
+      flag: '--faucet.apiServerPort <value>',
+      description: 'The port on which to start the api server on',
+      defaultValue: 8080,
+      envVar: undefined,
+      parseVal: val => parseInt(val, 10),
+    },
+    ...getOptions('faucet', faucetConfigMapping),
+  ],
+};

package/src/cli/cli.ts

@@ -0,0 +1,48 @@
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { Command } from 'commander';
+
+import { aztecStartOptions } from './aztec_start_options.js';
+import { addOptions, printAztecStartHelpText } from './util.js';
+
+/**
+ * Returns commander program that defines the 'aztec' command line interface.
+ * @param userLog - log function for logging user output.
+ * @param debugLogger - logger for logging debug messages.
+ */
+export function injectAztecCommands(program: Command, userLog: LogFn, debugLogger: Logger): Command {
+  const startCmd = new Command('start').description(
+    'Starts Aztec modules. Options for each module can be set as key-value pairs (e.g. "option1=value1,option2=value2") or as environment variables.',
+  );
+
+  // Assuming commands are added elsewhere, here we just add options to the main program
+  Object.keys(aztecStartOptions).forEach(category => {
+    addOptions(startCmd, aztecStartOptions[category]);
+  });
+
+  startCmd.helpInformation = printAztecStartHelpText;
+
+  startCmd.action(async options => {
+    const { aztecStart } = await import('./aztec_start_action.js');
+    return await aztecStart(options, userLog, debugLogger);
+  });
+
+  program.addCommand(startCmd);
+
+  program.configureHelp({ sortSubcommands: true });
+
+  program.addHelpText(
+    'after',
+    `
+
+  Additional commands:
+
+    test [options]: starts a dockerized TXE node via
+      $ aztec start --txe
+    then runs
+      $ aztec-nargo test --silence-warnings --oracle-resolver=<TXE_ADDRESS> [options]
+    `,
+  );
+
+  return program;
+}

package/src/cli/cmds/start_archiver.ts

@@ -0,0 +1,47 @@
+import {
+  Archiver,
+  type ArchiverConfig,
+  KVArchiverDataStore,
+  archiverConfigMappings,
+  getArchiverConfigFromEnv,
+} from '@aztec/archiver';
+import { createLogger } from '@aztec/aztec.js';
+import { createBlobSinkClient } from '@aztec/blob-sink/client';
+import { ArchiverApiSchema } from '@aztec/circuit-types';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+import { validateL1Config } from '../validation.js';
+
+/** Starts a standalone archiver. */
+export async function startArchiver(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+) {
+  const archiverConfig = extractRelevantOptions<ArchiverConfig & DataStoreConfig>(
+    options,
+    {
+      ...archiverConfigMappings,
+      ...dataConfigMappings,
+    },
+    'archiver',
+  );
+
+  await validateL1Config({ ...getArchiverConfigFromEnv(), ...archiverConfig });
+
+  const storeLog = createLogger('archiver:lmdb');
+  const store = await createStore('archiver', archiverConfig, storeLog);
+  const archiverStore = new KVArchiverDataStore(store, archiverConfig.maxLogs);
+
+  const telemetry = initTelemetryClient(getTelemetryClientConfig());
+  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/10056): place CL url in config here
+  const blobSinkClient = createBlobSinkClient();
+  const archiver = await Archiver.createAndSync(archiverConfig, archiverStore, { telemetry, blobSinkClient }, true);
+  services.archiver = [archiver, ArchiverApiSchema];
+  signalHandlers.push(archiver.stop);
+  return services;
+}

package/src/cli/cmds/start_bot.ts

@@ -0,0 +1,49 @@
+import { type BotConfig, BotRunner, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
+import { type AztecNode, type PXE } from '@aztec/circuit-types';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn } from '@aztec/foundation/log';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+
+export async function startBot(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+) {
+  const { proverNode, archiver, sequencer, p2pBootstrap, txe, prover } = options;
+  if (proverNode || archiver || sequencer || p2pBootstrap || txe || prover) {
+    userLog(
+      `Starting a bot with --prover-node, --prover, --archiver, --sequencer, --p2p-bootstrap, or --txe is not supported.`,
+    );
+    process.exit(1);
+  }
+  // Start a PXE client that is used by the bot if required
+  let pxe: PXE | undefined;
+  if (options.pxe) {
+    const { addPXE } = await import('./start_pxe.js');
+    pxe = await addPXE(options, signalHandlers, services, userLog);
+  }
+
+  const telemetry = initTelemetryClient(getTelemetryClientConfig());
+  await addBot(options, signalHandlers, services, { pxe, telemetry });
+}
+
+export function addBot(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  deps: { pxe?: PXE; node?: AztecNode; telemetry: TelemetryClient },
+) {
+  const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
+
+  const botRunner = new BotRunner(config, deps);
+  if (!config.noStart) {
+    void botRunner.start(); // Do not block since bot setup takes time
+  }
+  services.bot = getBotRunnerApiHandler(botRunner);
+  signalHandlers.push(botRunner.stop);
+  return Promise.resolve();
+}

package/src/cli/cmds/start_faucet.ts

@@ -0,0 +1,34 @@
+import {
+  Faucet,
+  FaucetSchema,
+  createFaucetHttpServer,
+  faucetConfigMapping,
+  getFaucetConfigFromEnv,
+} from '@aztec/aztec-faucet';
+import { type NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { type LogFn } from '@aztec/foundation/log';
+
+import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
+
+export async function startFaucet(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  log: LogFn,
+) {
+  const faucetOptions = extractNamespacedOptions(options, 'faucet');
+  const config = {
+    ...getFaucetConfigFromEnv(),
+    ...extractRelevantOptions(options, faucetConfigMapping, 'faucet'),
+  };
+
+  const faucet = await Faucet.create(config);
+  if (faucetOptions.apiServer) {
+    const httpServer = createFaucetHttpServer(faucet);
+    httpServer.listen(faucetOptions.apiServerPort);
+    signalHandlers.push(() => new Promise(res => httpServer.close(() => res())));
+    log(`Faucet now running on port: ${faucetOptions.apiServerPort}`);
+  }
+
+  services.faucet = [faucet, FaucetSchema];
+}

package/src/cli/cmds/start_node.ts

@@ -0,0 +1,123 @@
+import { aztecNodeConfigMappings, getConfigEnvVars as getNodeConfigEnvVars } from '@aztec/aztec-node';
+import { AztecNodeApiSchema, P2PApiSchema, type PXE } 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 {
+  type TelemetryClientConfig,
+  initTelemetryClient,
+  telemetryClientConfigMappings,
+} from '@aztec/telemetry-client';
+
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+import { createAztecNode, deployContractsToL1 } from '../../sandbox.js';
+import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
+import { validateL1Config } from '../validation.js';
+
+export async function startNode(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+  userLog: LogFn,
+) {
+  // options specifically namespaced with --node.<option>
+  const nodeSpecificOptions = extractNamespacedOptions(options, 'node');
+  // All options that are relevant to the Aztec Node
+  const nodeConfig = {
+    ...extractRelevantOptions(options, aztecNodeConfigMappings, 'node'),
+  };
+
+  if (options.proverNode) {
+    userLog(`Running a Prover Node within a Node is not yet supported`);
+    process.exit(1);
+  }
+
+  // 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,
+    });
+  }
+  // If not deploying, validate that the addresses and config provided are correct.
+  // Eventually, we should be able to dynamically load this just by having the L1 governance address,
+  // instead of only validating the config the user has entered.
+  else {
+    await validateL1Config({ ...getNodeConfigEnvVars(), ...nodeConfig });
+  }
+
+  // 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 });
+
+  // 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 });
+  }
+}

package/src/cli/cmds/start_p2p_bootstrap.ts

@@ -0,0 +1,25 @@
+import { P2PBootstrapApiSchema } from '@aztec/circuit-types';
+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 { 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');
+  const telemetryClient = initTelemetryClient(getTelemetryClientConfig());
+  const store = await createStore('p2p-bootstrap', 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}`);
+}