@aztec/aztec 0.0.0-test.0

package/src/cli/aztec_start_options.ts

@@ -0,0 +1,371 @@
+import { type ArchiverConfig, archiverConfigMappings } from '@aztec/archiver/config';
+import { faucetConfigMapping } from '@aztec/aztec-faucet/config';
+import { sequencerClientConfigMappings } from '@aztec/aztec-node/config';
+import { blobSinkConfigMappings } from '@aztec/blob-sink/server';
+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 {
+  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 = ['l1RpcUrls', 'l1ChainId', 'l1Contracts', 'p2pEnabled', 'dataDirectory'];
+
+// Define categories and options
+export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
+  NETWORK: [
+    {
+      flag: '--network <value>',
+      description: 'Network to run Aztec on',
+      defaultValue: undefined,
+      envVar: 'NETWORK',
+    },
+  ],
+  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-urls <value>',
+      description: 'List of URLs of the Ethereum RPC nodes that services will connect to (comma separated)',
+      defaultValue: ['http://localhost:8545'],
+      envVar: 'ETHEREUM_HOSTS',
+      parseVal: (val: string) => val.split(',').map(url => url.trim()),
+    },
+    {
+      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',
+      defaultValue: undefined,
+    },
+    {
+      flag: '--node.deployAztecContractsSalt <value>',
+      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 <value>',
+      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),
+    },
+    {
+      flag: '--node.testAccounts',
+      description: 'Populate genesis state with initial fee juice for test accounts',
+      envVar: 'TEST_ACCOUNTS',
+      ...booleanConfigHelper(),
+    },
+  ],
+  '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', blobSinkConfigMappings),
+  ],
+  '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),
+  ],
+  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/chain_l2_config.ts

@@ -0,0 +1,74 @@
+export type NetworkNames = 'testnet-ignition';
+
+export type L2ChainConfig = {
+  l1ChainId: number;
+  ethereumSlotDuration: number;
+  aztecSlotDuration: number;
+  aztecEpochDuration: number;
+  aztecProofSubmissionWindow: number;
+  testAccounts: boolean;
+  p2pEnabled: boolean;
+  p2pBootstrapNodes: string[];
+  registryAddress: string;
+  seqMinTxsPerBlock: number;
+  seqMaxTxsPerBlock: number;
+};
+
+export const testnetIgnitionL2ChainConfig: L2ChainConfig = {
+  l1ChainId: 11155111,
+  ethereumSlotDuration: 12,
+  aztecSlotDuration: 36,
+  aztecEpochDuration: 32,
+  aztecProofSubmissionWindow: 64,
+  testAccounts: true,
+  p2pEnabled: true,
+  p2pBootstrapNodes: [],
+  registryAddress: '0x12b3ebc176a1646b911391eab3760764f2e05fe3',
+  seqMinTxsPerBlock: 0,
+  seqMaxTxsPerBlock: 0,
+};
+
+export async function getBootnodes(networkName: NetworkNames) {
+  const url = `http://static.aztec.network/${networkName}/bootnodes.json`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch basic contract addresses from ${url}`);
+  }
+  const json = await response.json();
+  return json['bootnodes'];
+}
+
+export async function getL2ChainConfig(networkName: NetworkNames): Promise<L2ChainConfig | undefined> {
+  if (networkName === 'testnet-ignition') {
+    const config = { ...testnetIgnitionL2ChainConfig };
+    config.p2pBootstrapNodes = await getBootnodes(networkName);
+    return config;
+  }
+  return undefined;
+}
+
+function enrichVar(envVar: string, value: string) {
+  // Don't override
+  if (process.env[envVar]) {
+    return;
+  }
+  process.env[envVar] = value;
+}
+
+export async function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
+  const config = await getL2ChainConfig(networkName);
+  if (!config) {
+    throw new Error(`Unknown network name: ${networkName}`);
+  }
+  enrichVar('ETHEREUM_SLOT_DURATION', config.ethereumSlotDuration.toString());
+  enrichVar('AZTEC_SLOT_DURATION', config.aztecSlotDuration.toString());
+  enrichVar('AZTEC_EPOCH_DURATION', config.aztecEpochDuration.toString());
+  enrichVar('AZTEC_PROOF_SUBMISSION_WINDOW', config.aztecProofSubmissionWindow.toString());
+  enrichVar('P2P_BOOTSTRAP_NODES', config.p2pBootstrapNodes.join(','));
+  enrichVar('TEST_ACCOUNTS', config.testAccounts.toString());
+  enrichVar('P2P_ENABLED', config.p2pEnabled.toString());
+  enrichVar('L1_CHAIN_ID', config.l1ChainId.toString());
+  enrichVar('REGISTRY_CONTRACT_ADDRESS', config.registryAddress);
+  enrichVar('SEQ_MIN_TX_PER_BLOCK', config.seqMinTxsPerBlock.toString());
+  enrichVar('SEQ_MAX_TX_PER_BLOCK', config.seqMaxTxsPerBlock.toString());
+}

package/src/cli/cli.ts

@@ -0,0 +1,48 @@
+import type { LogFn, 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,55 @@
+import { Archiver, type ArchiverConfig, KVArchiverDataStore, archiverConfigMappings } from '@aztec/archiver';
+import { createLogger } from '@aztec/aztec.js';
+import { createBlobSinkClient } from '@aztec/blob-sink/client';
+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 { ArchiverApiSchema } 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 type { ArchiverConfig, DataStoreConfig };
+
+/** Starts a standalone archiver. */
+export async function startArchiver(
+  options: any,
+  signalHandlers: (() => Promise<void>)[],
+  services: NamespacedApiHandlers,
+): Promise<{ config: ArchiverConfig & DataStoreConfig }> {
+  let archiverConfig = extractRelevantOptions<ArchiverConfig & DataStoreConfig>(
+    options,
+    {
+      ...archiverConfigMappings,
+      ...dataConfigMappings,
+    },
+    'archiver',
+  );
+
+  if (!archiverConfig.l1Contracts.registryAddress || archiverConfig.l1Contracts.registryAddress.isZero()) {
+    throw new Error('L1 registry address is required to start an Archiver');
+  }
+
+  const { addresses, config } = await getL1Config(
+    archiverConfig.l1Contracts.registryAddress,
+    archiverConfig.l1RpcUrls,
+    archiverConfig.l1ChainId,
+  );
+
+  archiverConfig.l1Contracts = addresses;
+  archiverConfig = { ...archiverConfig, ...config };
+
+  const storeLog = createLogger('archiver:lmdb');
+  const store = await createStore('archiver', KVArchiverDataStore.SCHEMA_VERSION, 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 { config: archiverConfig };
+}

package/src/cli/cmds/start_blob_sink.ts

@@ -0,0 +1,31 @@
+import {
+  type BlobSinkConfig,
+  blobSinkConfigMappings,
+  createBlobSinkServer,
+  getBlobSinkConfigFromEnv,
+} from '@aztec/blob-sink/server';
+import type { LogFn } from '@aztec/foundation/log';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+
+import { extractRelevantOptions } from '../util.js';
+
+export async function startBlobSink(options: any, signalHandlers: (() => Promise<void>)[], userLog: LogFn) {
+  if (options.prover || options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
+    userLog(
+      `Starting a blob sink with --node, --sequencer, --pxe, --p2p-bootstrap, --prover or --txe is not supported.`,
+    );
+    process.exit(1);
+  }
+
+  const blobSinkConfig = {
+    ...getBlobSinkConfigFromEnv(), // get default config from env
+    ...extractRelevantOptions<BlobSinkConfig>(options, blobSinkConfigMappings, 'blobSink'), // override with command line options
+  };
+
+  const telemetry = initTelemetryClient(getTelemetryClientConfig());
+
+  const blobSink = await createBlobSinkServer(blobSinkConfig, telemetry);
+  signalHandlers.push(blobSink.stop.bind(blobSink));
+
+  await blobSink.start();
+}

package/src/cli/cmds/start_bot.ts

@@ -0,0 +1,49 @@
+import { type BotConfig, BotRunner, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
+import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import type { LogFn } from '@aztec/foundation/log';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+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];
+}