@aztec/aztec 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/cli/aztec_start_action.ts

@@ -1,46 +1,48 @@
+import { getActiveNetworkName } from '@aztec/foundation/config';
 import {
   type NamespacedApiHandlers,
   createNamespacedSafeJsonRpcServer,
+  getApiKeyAuthMiddleware,
   startHttpRpcServer,
 } from '@aztec/foundation/json-rpc/server';
 import type { LogFn, Logger } from '@aztec/foundation/log';
-import { fileURLToPath } from '@aztec/foundation/url';
 import type { ChainConfig } from '@aztec/stdlib/config';
-import { AztecNodeApiSchema, PXESchema } from '@aztec/stdlib/interfaces/client';
+import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
 import { getVersioningMiddleware } from '@aztec/stdlib/versioning';
 import { getOtelJsonRpcPropagationMiddleware } from '@aztec/telemetry-client';
 
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-
-import { createSandbox } from '../sandbox/index.js';
+import { createLocalNetwork } from '../local-network/index.js';
 import { github, splash } from '../splash.js';
-import { enrichEnvironmentWithChainConfig } from './chain_l2_config.js';
+import { resolveAdminApiKey } from './admin_api_key_store.js';
 import { extractNamespacedOptions, installSignalHandlers } from './util.js';
 import { getVersions } from './versioning.js';
 
-const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-const cliVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
-
 export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logger) {
   // list of 'stop' functions to call when process ends
   const signalHandlers: Array<() => Promise<void>> = [];
   const services: NamespacedApiHandlers = {};
+  const adminServices: NamespacedApiHandlers = {};
+  const packageVersion = getPackageVersion();
   let config: ChainConfig | undefined = undefined;
 
-  if (options.sandbox) {
-    const sandboxOptions = extractNamespacedOptions(options, 'sandbox');
-    const nodeOptions = extractNamespacedOptions(options, 'node');
+  if (options.localNetwork) {
+    const localNetwork = extractNamespacedOptions(options, 'local-network');
+    localNetwork.testAccounts = true;
     userLog(`${splash}\n${github}\n\n`);
-    userLog(`Setting up Aztec Sandbox ${cliVersion}, please stand by...`);
+    userLog(`Setting up Aztec local network ${packageVersion ?? 'unknown'}, please stand by...`);
 
-    const { node, pxe, stop } = await createSandbox(
+    const { node, stop } = await createLocalNetwork(
       {
-        l1Mnemonic: options.l1Mnemonic,
+        l1Mnemonic: localNetwork.l1Mnemonic,
         l1RpcUrls: options.l1RpcUrls,
-        l1Salt: nodeOptions.deployAztecContractsSalt,
-        noPXE: sandboxOptions.noPXE,
-        testAccounts: sandboxOptions.testAccounts,
+        testAccounts: localNetwork.testAccounts,
+        realProofs: false,
+        // Setting the epoch duration to 2 by default for local network. This allows the epoch to be "proven" faster, so
+        // the users can consume out hash without having to wait for a long time.
+        // Note: We are not proving anything in the local network (realProofs == false). But in `createLocalNetwork`,
+        // the EpochTestSettler will set the out hash to the outbox when an epoch is complete.
+        aztecEpochDuration: 2,
       },
       userLog,
     );
@@ -48,31 +50,20 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
     // Start Node and PXE JSON-RPC server
     signalHandlers.push(stop);
     services.node = [node, AztecNodeApiSchema];
-    if (!sandboxOptions.noPXE) {
-      services.pxe = [pxe, PXESchema];
-    } else {
-      userLog(`Not exposing PXE API through JSON-RPC server`);
-    }
+    adminServices.node = [node, AztecNodeAdminApiSchema];
   } else {
-    // If a network is specified, enrich the environment with the chain config
-    if (options.network) {
-      await enrichEnvironmentWithChainConfig(options.network);
+    // Route --prover-node through startNode
+    if (options.proverNode && !options.node) {
+      options.node = true;
     }
+
     if (options.node) {
       const { startNode } = await import('./cmds/start_node.js');
-      ({ config } = await startNode(options, signalHandlers, services, userLog));
+      const networkName = getActiveNetworkName(options.network);
+      ({ config } = await startNode(options, signalHandlers, services, adminServices, userLog, networkName));
     } else if (options.bot) {
       const { startBot } = await import('./cmds/start_bot.js');
       await startBot(options, signalHandlers, services, userLog);
-    } else if (options.proverNode) {
-      const { startProverNode } = await import('./cmds/start_prover_node.js');
-      ({ config } = await startProverNode(options, signalHandlers, services, userLog));
-    } else if (options.blobSink) {
-      const { startBlobSink } = await import('./cmds/start_blob_sink.js');
-      await startBlobSink(options, signalHandlers, userLog);
-    } else if (options.pxe) {
-      const { startPXE } = await import('./cmds/start_pxe.js');
-      ({ config } = await startPXE(options, signalHandlers, services, userLog));
     } else if (options.archiver) {
       const { startArchiver } = await import('./cmds/start_archiver.js');
       ({ config } = await startArchiver(options, signalHandlers, services));
@@ -91,9 +82,6 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
     } else if (options.sequencer) {
       userLog(`Cannot run a standalone sequencer without a node`);
       process.exit(1);
-    } else if (options.faucet) {
-      const { startFaucet } = await import('./cmds/start_faucet.js');
-      await startFaucet(options, signalHandlers, services, userLog);
     } else {
       userLog(`No module specified to start`);
       process.exit(1);
@@ -102,13 +90,71 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
 
   installSignalHandlers(debugLogger.info, signalHandlers);
   const versions = getVersions(config);
+  const versioningOpts = { packageVersion };
+
+  // Start the main JSON-RPC server
   if (Object.entries(services).length > 0) {
     const rpcServer = createNamespacedSafeJsonRpcServer(services, {
       http200OnError: false,
       log: debugLogger,
-      middlewares: [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions)],
+      middlewares: [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions, versioningOpts)],
+      maxBatchSize: options.rpcMaxBatchSize,
+      maxBodySizeBytes: options.rpcMaxBodySize,
     });
     const { port } = await startHttpRpcServer(rpcServer, { port: options.port });
     debugLogger.info(`Aztec Server listening on port ${port}`, versions);
   }
+
+  // If there are any admin services, start a separate JSON-RPC server for them
+  if (Object.entries(adminServices).length > 0) {
+    const adminMiddlewares = [getOtelJsonRpcPropagationMiddleware(), getVersioningMiddleware(versions, versioningOpts)];
+
+    // Resolve the admin API key (auto-generated and persisted, or opt-out)
+    const apiKeyResolution = await resolveAdminApiKey(
+      {
+        adminApiKeyHash: options.adminApiKeyHash,
+        disableAdminApiKey: options.disableAdminApiKey,
+        resetAdminApiKey: options.resetAdminApiKey,
+        dataDirectory: options.dataDirectory,
+      },
+      debugLogger,
+    );
+    if (apiKeyResolution) {
+      adminMiddlewares.unshift(getApiKeyAuthMiddleware(apiKeyResolution.apiKeyHash));
+    } else {
+      debugLogger.warn('No admin API key set — admin endpoint is unauthenticated');
+    }
+
+    const rpcServer = createNamespacedSafeJsonRpcServer(adminServices, {
+      http200OnError: false,
+      log: debugLogger,
+      middlewares: adminMiddlewares,
+      maxBatchSize: options.rpcMaxBatchSize,
+      maxBodySizeBytes: options.rpcMaxBodySize,
+    });
+    const { port } = await startHttpRpcServer(rpcServer, { port: options.adminPort });
+    debugLogger.info(`Aztec Server admin API listening on port ${port}`, versions);
+
+    // Display the API key after the server has started
+    // Uses userLog which is never filtered by LOG_LEVEL.
+    if (apiKeyResolution?.rawKey) {
+      const separator = '='.repeat(70);
+      userLog('');
+      userLog(separator);
+      userLog('  ADMIN API KEY (save this — it will NOT be shown again)');
+      userLog('');
+      userLog(`  ${apiKeyResolution.rawKey}`);
+      userLog('');
+      userLog(`  Use via header:  x-api-key: <key>`);
+      userLog(`  Or via header:   Authorization: Bearer <key>`);
+      if (options.dataDirectory) {
+        userLog('');
+        userLog('  The key hash has been persisted — on next restart, the same key will be used.');
+      }
+      userLog('');
+      userLog('  To disable admin auth: --disable-admin-api-key or AZTEC_DISABLE_ADMIN_API_KEY=true');
+      userLog(separator);
+      userLog('');
+    }
+  }
 }