@aztec/aztec 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/README.md

@@ -8,7 +8,7 @@ Aztec is a package that allows for a simple development environment on Aztec sta
 
 The easiest way to run is by using `docker compose up`. This will create two containers:
 
-1. The sandbox listening on port `8080`
+1. The local network listening on port `8080`
 2. An anvil instance listening on port `8545`
 
 ### Node Server

package/dest/bin/index.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/bin/index.js

@@ -1,19 +1,22 @@
 #!/usr/bin/env node
 //
 import { injectCommands as injectBuilderCommands } from '@aztec/builder';
-import { injectCommands as injectWalletCommands } from '@aztec/cli-wallet';
-import { enrichEnvironmentWithChainConfig, enrichEnvironmentWithNetworkConfig } from '@aztec/cli/config';
+import { injectCommands as injectAztecNodeCommands } from '@aztec/cli/aztec_node';
+import { enrichEnvironmentWithChainName } from '@aztec/cli/config/chain';
+import { enrichEnvironmentWithNetworkConfig } from '@aztec/cli/config/network';
 import { injectCommands as injectContractCommands } from '@aztec/cli/contracts';
 import { injectCommands as injectInfrastructureCommands } from '@aztec/cli/infrastructure';
 import { injectCommands as injectL1Commands } from '@aztec/cli/l1';
 import { injectCommands as injectMiscCommands } from '@aztec/cli/misc';
-import { injectCommands as injectPXECommands } from '@aztec/cli/pxe';
+import { injectCommands as injectValidatorKeysCommands } from '@aztec/cli/validator_keys';
 import { getActiveNetworkName } from '@aztec/foundation/config';
 import { createConsoleLogger, createLogger } from '@aztec/foundation/log';
 import { Command } from 'commander';
-import { NETWORK_FLAG } from '../cli/aztec_start_options.js';
+import { injectCompileCommand } from '../cli/cmds/compile.js';
+import { injectMigrateCommand } from '../cli/cmds/migrate_ha_db.js';
 import { injectAztecCommands } from '../cli/index.js';
 import { getCliVersion } from '../cli/release_version.js';
+const NETWORK_FLAG = 'network';
 const userLog = createConsoleLogger();
 const debugLogger = createLogger('cli');
 /** CLI & full node main entrypoint */ async function main() {
@@ -31,18 +34,20 @@ const debugLogger = createLogger('cli');
     }
     const networkName = getActiveNetworkName(networkValue);
     await enrichEnvironmentWithNetworkConfig(networkName);
-    enrichEnvironmentWithChainConfig(networkName);
+    enrichEnvironmentWithChainName(networkName);
     const cliVersion = getCliVersion();
     let program = new Command('aztec');
-    program.description('Aztec command line interface').version(cliVersion);
+    program.description('Aztec command line interface').version(cliVersion).enablePositionalOptions();
     program = injectAztecCommands(program, userLog, debugLogger);
     program = injectBuilderCommands(program);
     program = injectContractCommands(program, userLog, debugLogger);
-    program = injectInfrastructureCommands(program, userLog, debugLogger);
+    program = injectInfrastructureCommands(program, userLog);
     program = injectL1Commands(program, userLog, debugLogger);
-    program = injectPXECommands(program, userLog, debugLogger);
+    program = injectAztecNodeCommands(program, userLog, debugLogger);
     program = injectMiscCommands(program, userLog);
-    program = injectWalletCommands(program, userLog, debugLogger);
+    program = injectValidatorKeysCommands(program, userLog);
+    program = injectCompileCommand(program, userLog);
+    program = injectMigrateCommand(program, userLog);
     await program.parseAsync(process.argv);
 }
 main().catch((err)=>{

package/dest/cli/admin_api_key_store.d.ts

@@ -0,0 +1,45 @@
+import type { Logger } from '@aztec/foundation/log';
+/**
+ * Result of resolving the admin API key.
+ * Contains the SHA-256 hex hash of the API key to be used by the auth middleware,
+ * and optionally the raw key when newly generated (so the caller can display it).
+ */
+export interface AdminApiKeyResolution {
+    /** The SHA-256 hash of the API key. */
+    apiKeyHash: Buffer;
+    /**
+     * The raw API key, only present when a new key was generated during this call.
+     * The caller MUST display this to the operator — it will not be stored or returned again.
+     */
+    rawKey?: string;
+}
+export interface ResolveAdminApiKeyOptions {
+    /** SHA-256 hex hash of a pre-generated API key. When set, the node uses this hash directly. */
+    adminApiKeyHash?: string;
+    /** If true, disable admin API key auth entirely. */
+    noAdminApiKey?: boolean;
+    /** If true, force-generate a new key even if one is already persisted. */
+    resetAdminApiKey?: boolean;
+    /** Root data directory for persistent storage. */
+    dataDirectory?: string;
+}
+/**
+ * Resolves the admin API key for the admin RPC endpoint.
+ *
+ * Strategy:
+ * 1. If opt-out flag is set (`noAdminApiKey`), return undefined (no auth).
+ * 2. If a pre-generated hash is provided (`adminApiKeyHash`), use it directly.
+ * 3. If a data directory exists, look for a persisted hash file
+ *    at `<dataDirectory>/admin/api_key_hash`:
+ *    - If `resetAdminApiKey` is set, skip loading and force-generate a new key.
+ *    - Found: use the stored hash (operator already saved the key from first run).
+ *    - Not found: auto-generate a random key, display it once, persist the hash.
+ * 3. If no data directory: generate a random key
+ *    each run and display it (cannot persist).
+ *
+ * @param options - The options for resolving the admin API key.
+ * @param log - Logger for outputting the key and status messages.
+ * @returns The resolved API key hash, or undefined if auth is disabled.
+ */
+export declare function resolveAdminApiKey(options: ResolveAdminApiKeyOptions, log: Logger): Promise<AdminApiKeyResolution | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW5fYXBpX2tleV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsaS9hZG1pbl9hcGlfa2V5X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBU3BEOzs7O0dBSUc7QUFDSCxNQUFNLFdBQVcscUJBQXFCO0lBQ3BDLHVDQUF1QztJQUN2QyxVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25COzs7T0FHRztJQUNILE1BQU0sQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNqQjtBQUVELE1BQU0sV0FBVyx5QkFBeUI7SUFDeEMsK0ZBQStGO0lBQy9GLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN6QixvREFBb0Q7SUFDcEQsYUFBYSxDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQ3hCLDBFQUEwRTtJQUMxRSxnQkFBZ0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUMzQixrREFBa0Q7SUFDbEQsYUFBYSxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ3hCO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBQ0gsd0JBQXNCLGtCQUFrQixDQUN0QyxPQUFPLEVBQUUseUJBQXlCLEVBQ2xDLEdBQUcsRUFBRSxNQUFNLEdBQ1YsT0FBTyxDQUFDLHFCQUFxQixHQUFHLFNBQVMsQ0FBQyxDQTJENUMifQ==

package/dest/cli/admin_api_key_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin_api_key_store.d.ts","sourceRoot":"","sources":["../../src/cli/admin_api_key_store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AASpD;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,+FAA+F;IAC/F,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,yBAAyB,EAClC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CA2D5C"}

package/dest/cli/admin_api_key_store.js

@@ -0,0 +1,98 @@
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { sha256Hash } from '@aztec/foundation/json-rpc/server';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+/** Subdirectory under dataDirectory for admin API key storage. */ const ADMIN_STORE_DIR = 'admin';
+const HASH_FILE_NAME = 'api_key_hash';
+/**
+ * Resolves the admin API key for the admin RPC endpoint.
+ *
+ * Strategy:
+ * 1. If opt-out flag is set (`noAdminApiKey`), return undefined (no auth).
+ * 2. If a pre-generated hash is provided (`adminApiKeyHash`), use it directly.
+ * 3. If a data directory exists, look for a persisted hash file
+ *    at `<dataDirectory>/admin/api_key_hash`:
+ *    - If `resetAdminApiKey` is set, skip loading and force-generate a new key.
+ *    - Found: use the stored hash (operator already saved the key from first run).
+ *    - Not found: auto-generate a random key, display it once, persist the hash.
+ * 3. If no data directory: generate a random key
+ *    each run and display it (cannot persist).
+ *
+ * @param options - The options for resolving the admin API key.
+ * @param log - Logger for outputting the key and status messages.
+ * @returns The resolved API key hash, or undefined if auth is disabled.
+ */ export async function resolveAdminApiKey(options, log) {
+    // Operator explicitly opted out of admin auth
+    if (options.noAdminApiKey) {
+        log.warn('Admin API key authentication is DISABLED (--no-admin-api-key / AZTEC_NO_ADMIN_API_KEY)');
+        return undefined;
+    }
+    // Operator provided a pre-generated hash (e.g. via AZTEC_ADMIN_API_KEY_HASH env var)
+    if (options.adminApiKeyHash) {
+        const hex = options.adminApiKeyHash.trim();
+        if (hex.length !== 64 || !/^[0-9a-f]{64}$/.test(hex)) {
+            throw new Error(`Invalid admin API key hash: expected 64-char hex string, got "${hex}"`);
+        }
+        log.info('Admin API key authentication enabled (using pre-configured key hash)');
+        return {
+            apiKeyHash: Buffer.from(hex, 'hex')
+        };
+    }
+    // Persistent storage available, load or generate key
+    if (options.dataDirectory) {
+        const adminDir = join(options.dataDirectory, ADMIN_STORE_DIR);
+        const hashFilePath = join(adminDir, HASH_FILE_NAME);
+        // Unless a reset is forced, try to load the existing hash from disk
+        if (!options.resetAdminApiKey) {
+            try {
+                const storedHash = (await fs.readFile(hashFilePath, 'utf-8')).trim();
+                if (storedHash.length === 64) {
+                    log.info('Admin API key authentication enabled (loaded stored key hash from disk)');
+                    return {
+                        apiKeyHash: Buffer.from(storedHash, 'hex')
+                    };
+                }
+                log.warn(`Invalid stored admin API key hash at ${hashFilePath}, regenerating...`);
+            } catch (err) {
+                if (err.code !== 'ENOENT') {
+                    log.warn(`Failed to read admin API key hash from ${hashFilePath}: ${err.message}`);
+                }
+            // File doesn't exist — fall through to generate
+            }
+        } else {
+            log.warn('Admin API key reset requested — generating a new key');
+        }
+        // Generate a new key, persist the hash, and return the raw key for the caller to display
+        const { rawKey, hash } = generateApiKey();
+        await fs.mkdir(adminDir, {
+            recursive: true
+        });
+        await fs.writeFile(hashFilePath, hash.toString('hex'), 'utf-8');
+        // Set restrictive permissions (owner read/write only)
+        await fs.chmod(hashFilePath, 0o600);
+        log.info('Admin API key authentication enabled (new key generated and hash persisted to disk)');
+        return {
+            apiKeyHash: hash,
+            rawKey
+        };
+    }
+    // No data directory, generate a temporary key per session
+    const { rawKey, hash } = generateApiKey();
+    log.warn('No data directory configured — admin API key cannot be persisted.');
+    log.warn('A temporary key has been generated for this session only.');
+    return {
+        apiKeyHash: hash,
+        rawKey
+    };
+}
+/**
+ * Generates a cryptographically random API key and its SHA-256 hash.
+ * @returns The raw key (hex string) and its SHA-256 hash as a Buffer.
+ */ function generateApiKey() {
+    const rawKey = randomBytes(32).toString('hex');
+    const hash = sha256Hash(rawKey);
+    return {
+        rawKey,
+        hash
+    };
+}

package/dest/cli/aztec_start_action.d.ts

@@ -1,3 +1,3 @@
 import type { LogFn, Logger } from '@aztec/foundation/log';
 export declare function aztecStart(options: any, userLog: LogFn, debugLogger: Logger): Promise<void>;
-//# sourceMappingURL=aztec_start_action.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp0ZWNfc3RhcnRfYWN0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL2F6dGVjX3N0YXJ0X2FjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFhM0Qsd0JBQXNCLFVBQVUsQ0FBQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBd0lqRiJ9

package/dest/cli/aztec_start_action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aztec_start_action.d.ts","sourceRoot":"","sources":["../../src/cli/aztec_start_action.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAY3D,wBAAsB,UAAU,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAsGjF"}
+{"version":3,"file":"aztec_start_action.d.ts","sourceRoot":"","sources":["../../src/cli/aztec_start_action.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAa3D,wBAAsB,UAAU,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAwIjF"}

package/dest/cli/aztec_start_action.js

@@ -1,9 +1,10 @@
-import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
-import { AztecNodeApiSchema, PXESchema } from '@aztec/stdlib/interfaces/client';
+import { createNamespacedSafeJsonRpcServer, getApiKeyAuthMiddleware, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
 import { getVersioningMiddleware } from '@aztec/stdlib/versioning';
 import { getOtelJsonRpcPropagationMiddleware } from '@aztec/telemetry-client';
-import { createSandbox } from '../sandbox/index.js';
+import { createLocalNetwork } from '../local-network/index.js';
 import { github, splash } from '../splash.js';
+import { resolveAdminApiKey } from './admin_api_key_store.js';
 import { getCliVersion } from './release_version.js';
 import { extractNamespacedOptions, installSignalHandlers } from './util.js';
 import { getVersions } from './versioning.js';
@@ -13,19 +14,22 @@ export async function aztecStart(options, userLog, debugLogger) {
     const services = {};
     const adminServices = {};
     let config = undefined;
-    if (options.sandbox) {
+    if (options.localNetwork) {
         const cliVersion = getCliVersion();
-        const sandboxOptions = extractNamespacedOptions(options, 'sandbox');
-        sandboxOptions.testAccounts = true;
+        const localNetwork = extractNamespacedOptions(options, 'local-network');
+        localNetwork.testAccounts = true;
         userLog(`${splash}\n${github}\n\n`);
-        userLog(`Setting up Aztec Sandbox ${cliVersion}, please stand by...`);
-        const { node, pxe, stop } = await createSandbox({
-            l1Mnemonic: sandboxOptions.l1Mnemonic,
+        userLog(`Setting up Aztec local network ${cliVersion}, please stand by...`);
+        const { node, stop } = await createLocalNetwork({
+            l1Mnemonic: localNetwork.l1Mnemonic,
             l1RpcUrls: options.l1RpcUrls,
-            deployAztecContractsSalt: sandboxOptions.deployAztecContractsSalt,
-            noPXE: sandboxOptions.noPXE,
-            testAccounts: sandboxOptions.testAccounts,
-            realProofs: false
+            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);
         // Start Node and PXE JSON-RPC server
         signalHandlers.push(stop);
@@ -33,30 +37,17 @@ export async function aztecStart(options, userLog, debugLogger) {
             node,
             AztecNodeApiSchema
         ];
-        if (!sandboxOptions.noPXE) {
-            services.pxe = [
-                pxe,
-                PXESchema
-            ];
-        } else {
-            userLog(`Not exposing PXE API through JSON-RPC server`);
-        }
     } else {
+        // 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, adminServices, userLog));
         } 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));
@@ -101,13 +92,26 @@ export async function aztecStart(options, userLog, debugLogger) {
     }
     // 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)
+        ];
+        // Resolve the admin API key (auto-generated and persisted, or opt-out)
+        const apiKeyResolution = await resolveAdminApiKey({
+            adminApiKeyHash: options.adminApiKeyHash,
+            noAdminApiKey: options.noAdminApiKey,
+            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: [
-                getOtelJsonRpcPropagationMiddleware(),
-                getVersioningMiddleware(versions)
-            ],
+            middlewares: adminMiddlewares,
             maxBatchSize: options.rpcMaxBatchSize,
             maxBodySizeBytes: options.rpcMaxBodySize
         });
@@ -115,5 +119,26 @@ export async function aztecStart(options, userLog, debugLogger) {
             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: --no-admin-api-key or AZTEC_NO_ADMIN_API_KEY=true');
+            userLog(separator);
+            userLog('');
+        }
     }
 }

package/dest/cli/aztec_start_options.d.ts

@@ -14,4 +14,4 @@ export declare const NETWORK_FLAG = "network";
 export declare const aztecStartOptions: {
     [key: string]: AztecStartOption[];
 };
-//# sourceMappingURL=aztec_start_options.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXp0ZWNfc3RhcnRfb3B0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsaS9henRlY19zdGFydF9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE9BQU8sRUFDTCxLQUFLLGFBQWEsRUFDbEIsS0FBSyxNQUFNLEVBSVosTUFBTSwwQkFBMEIsQ0FBQztBQWVsQyxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLElBQUksRUFBRSxNQUFNLENBQUM7SUFDYixXQUFXLEVBQUUsTUFBTSxDQUFDO0lBQ3BCLFlBQVksRUFBRSxHQUFHLENBQUM7SUFDbEIsWUFBWSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxLQUFLLE1BQU0sQ0FBQztJQUNwQyxHQUFHLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUN4QixRQUFRLENBQUMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUNwQixRQUFRLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEtBQUssR0FBRyxDQUFDO0NBQ2pDO0FBRUQsZUFBTyxNQUFNLFVBQVUsMEZBb0J0QixDQUFDO0FBdUJGLGVBQU8sTUFBTSxnQkFBZ0IsVUFZNUIsQ0FBQztBQUVGLGVBQU8sTUFBTSxZQUFZLFlBQVksQ0FBQztBQUd0QyxlQUFPLE1BQU0saUJBQWlCLEVBQUU7SUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQTtDQXNPbEUsQ0FBQyJ9

package/dest/cli/aztec_start_options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aztec_start_options.d.ts","sourceRoot":"","sources":["../../src/cli/aztec_start_options.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,MAAM,EAIZ,MAAM,0BAA0B,CAAC;AAclC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,GAAG,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;IACpC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;CACjC;AAED,eAAO,MAAM,UAAU,GAAI,WAAW,MAAM,EAAE,gBAAgB,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,uBAoB1F,CAAC;AAuBF,eAAO,MAAM,gBAAgB,UAW5B,CAAC;AAEF,eAAO,MAAM,YAAY,YAAY,CAAC;AAGtC,eAAO,MAAM,iBAAiB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAA;CAqOlE,CAAC"}
+{"version":3,"file":"aztec_start_options.d.ts","sourceRoot":"","sources":["../../src/cli/aztec_start_options.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,MAAM,EAIZ,MAAM,0BAA0B,CAAC;AAelC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,GAAG,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;IACpC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;CACjC;AAED,eAAO,MAAM,UAAU,0FAoBtB,CAAC;AAuBF,eAAO,MAAM,gBAAgB,UAY5B,CAAC;AAEF,eAAO,MAAM,YAAY,YAAY,CAAC;AAGtC,eAAO,MAAM,iBAAiB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAA;CAsOlE,CAAC"}

package/dest/cli/aztec_start_options.js

@@ -1,19 +1,21 @@
 import { archiverConfigMappings } from '@aztec/archiver/config';
-import { sequencerClientConfigMappings } from '@aztec/aztec-node/config';
-import { blobSinkConfigMappings } from '@aztec/blob-sink/server';
+import { blobClientConfigMapping } from '@aztec/blob-client/client/config';
 import { botConfigMappings } from '@aztec/bot/config';
-import { l1ContractAddressesMapping, l1ContractsConfigMappings, l1ReaderConfigMappings } from '@aztec/ethereum';
+import { l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
+import { l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import { getKeys } from '@aztec/foundation/collection';
 import { booleanConfigHelper, isBooleanConfigValue, omitConfigMappings } from '@aztec/foundation/config';
 import { dataConfigMappings } from '@aztec/kv-store/config';
 import { sharedNodeConfigMappings } from '@aztec/node-lib/config';
 import { bootnodeConfigMappings, p2pConfigMappings } from '@aztec/p2p/config';
-import { proverAgentConfigMappings, proverBrokerConfigMappings } from '@aztec/prover-client/broker';
+import { proverAgentConfigMappings, proverBrokerConfigMappings } from '@aztec/prover-client/broker/config';
 import { proverNodeConfigMappings } from '@aztec/prover-node/config';
 import { allPxeConfigMappings } from '@aztec/pxe/config';
-import { chainConfigMappings } from '@aztec/stdlib/config';
-import { telemetryClientConfigMappings } from '@aztec/telemetry-client';
-import { worldStateConfigMappings } from '@aztec/world-state';
+import { sequencerClientConfigMappings } from '@aztec/sequencer-client/config';
+import { chainConfigMappings, nodeRpcConfigMappings } from '@aztec/stdlib/config';
+import { telemetryClientConfigMappings } from '@aztec/telemetry-client/config';
+import { worldStateConfigMappings } from '@aztec/world-state/config';
 import { DefaultMnemonic } from '../mnemonic.js';
 export const getOptions = (namespace, configMappings)=>{
     const options = [];
@@ -56,6 +58,7 @@ export const universalOptions = [
     'l1ConsensusHostApiKeys',
     'l1ConsensusHostApiKeyHeaders',
     'p2pEnabled',
+    'fishermanMode',
     ...getKeys(chainConfigMappings),
     ...getKeys(l1ContractsConfigMappings),
     ...getKeys(l1ContractAddressesMapping),
@@ -76,33 +79,21 @@ export const aztecStartOptions = {
         configToFlag('--auto-update', sharedNodeConfigMappings.autoUpdate),
         configToFlag('--auto-update-url', sharedNodeConfigMappings.autoUpdateUrl),
         configToFlag('--sync-mode', sharedNodeConfigMappings.syncMode),
-        configToFlag('--snapshots-urls', sharedNodeConfigMappings.snapshotsUrls)
+        configToFlag('--snapshots-urls', sharedNodeConfigMappings.snapshotsUrls),
+        configToFlag('--fisherman-mode', sharedNodeConfigMappings.fishermanMode)
     ],
-    SANDBOX: [
+    LOCAL_NETWORK: [
         {
-            flag: '--sandbox',
-            description: 'Starts Aztec Sandbox',
+            flag: '--local-network',
+            description: 'Starts Aztec Local Network',
             defaultValue: undefined,
             env: undefined
         },
         {
-            flag: '--sandbox.noPXE',
-            description: 'Do not expose PXE service on sandbox start',
-            env: 'NO_PXE',
-            ...booleanConfigHelper()
-        },
-        {
-            flag: '--sandbox.l1Mnemonic <value>',
+            flag: '--local-network.l1Mnemonic <value>',
             description: 'Mnemonic for L1 accounts. Will be used ',
             defaultValue: DefaultMnemonic,
             env: 'MNEMONIC'
-        },
-        {
-            flag: '--sandbox.deployAztecContractsSalt <value>',
-            description: 'Numeric salt for deploying L1 Aztec contracts before starting the sandbox. Needs mnemonic or private key to be set.',
-            env: 'DEPLOY_AZTEC_CONTRACTS_SALT',
-            defaultValue: undefined,
-            parseVal: (val)=>val ? parseInt(val) : undefined
         }
     ],
     API: [
@@ -115,17 +106,39 @@ export const aztecStartOptions = {
         },
         {
             flag: '--admin-port <value>',
-            description: 'Port to run admin APIs of Aztec Services on on',
+            description: 'Port to run admin APIs of Aztec Services on',
             defaultValue: 8880,
             env: 'AZTEC_ADMIN_PORT',
             parseVal: (val)=>parseInt(val, 10)
         },
+        {
+            flag: '--admin-api-key-hash <value>',
+            description: 'SHA-256 hex hash of a pre-generated admin API key. When set, the node uses this hash for authentication instead of auto-generating a key.',
+            defaultValue: undefined,
+            env: 'AZTEC_ADMIN_API_KEY_HASH'
+        },
+        {
+            flag: '--no-admin-api-key',
+            description: 'Disable API key authentication on the admin RPC endpoint. By default, a key is auto-generated, displayed once, and its hash is persisted.',
+            defaultValue: false,
+            env: 'AZTEC_NO_ADMIN_API_KEY',
+            parseVal: (val)=>val === 'true' || val === '1'
+        },
+        {
+            flag: '--reset-admin-api-key',
+            description: 'Force-generate a new admin API key, replacing any previously persisted key hash. The new key is displayed once at startup.',
+            defaultValue: false,
+            env: 'AZTEC_RESET_ADMIN_API_KEY',
+            parseVal: (val)=>val === 'true' || val === '1'
+        },
         {
             flag: '--api-prefix <value>',
             description: 'Prefix for API routes on any service that is started',
             defaultValue: '',
             env: 'API_PREFIX'
-        }
+        },
+        configToFlag('--rpcMaxBatchSize', nodeRpcConfigMappings.rpcMaxBatchSize),
+        configToFlag('--rpcMaxBodySize', nodeRpcConfigMappings.rpcMaxBodySize)
     ],
     ETHEREUM: [
         configToFlag('--l1-chain-id', l1ReaderConfigMappings.l1ChainId),
@@ -134,9 +147,9 @@ export const aztecStartOptions = {
             ...l1ReaderConfigMappings.l1RpcUrls,
             defaultValue: undefined
         }),
-        configToFlag('--l1-consensus-host-urls', blobSinkConfigMappings.l1ConsensusHostUrls),
-        configToFlag('--l1-consensus-host-api-keys', blobSinkConfigMappings.l1ConsensusHostApiKeys),
-        configToFlag('--l1-consensus-host-api-key-headers', blobSinkConfigMappings.l1ConsensusHostApiKeyHeaders)
+        configToFlag('--l1-consensus-host-urls', blobClientConfigMapping.l1ConsensusHostUrls),
+        configToFlag('--l1-consensus-host-api-keys', blobClientConfigMapping.l1ConsensusHostApiKeys),
+        configToFlag('--l1-consensus-host-api-key-headers', blobClientConfigMapping.l1ConsensusHostApiKeyHeaders)
     ],
     'L1 CONTRACTS': [
         configToFlag('--registry-address', l1ContractAddressesMapping.registryAddress),
@@ -149,7 +162,7 @@ export const aztecStartOptions = {
     'WORLD STATE': [
         configToFlag('--world-state-data-directory', worldStateConfigMappings.worldStateDataDirectory),
         configToFlag('--world-state-db-map-size-kb', worldStateConfigMappings.worldStateDbMapSizeKb),
-        configToFlag('--world-state-block-history', worldStateConfigMappings.worldStateBlockHistory)
+        configToFlag('--world-state-checkpoint-history', worldStateConfigMappings.worldStateCheckpointHistory)
     ],
     // We can't easily auto-generate node options as they're parts of modules defined below
     'AZTEC NODE': [
@@ -178,20 +191,12 @@ export const aztecStartOptions = {
         },
         ...getOptions('sequencer', omitConfigMappings(sequencerClientConfigMappings, [
             'fakeProcessingDelayPerTxMs',
+            'fakeThrowAfterProcessingTxCount',
             'skipCollectingAttestations',
             'skipInvalidateBlockAsProposer',
             'blobSinkMapSizeKb'
         ]))
     ],
-    'BLOB SINK': [
-        {
-            flag: '--blob-sink',
-            description: 'Starts Aztec Blob Sink with options',
-            defaultValue: undefined,
-            env: undefined
-        },
-        ...getOptions('blobSink', blobSinkConfigMappings)
-    ],
     'PROVER NODE': [
         {
             flag: '--prover-node',
@@ -201,12 +206,8 @@ export const aztecStartOptions = {
         },
         ...getOptions('proverNode', omitConfigMappings(proverNodeConfigMappings, [
             // filter out options passed separately
-            ...getKeys(archiverConfigMappings),
             ...getKeys(proverBrokerConfigMappings),
-            ...getKeys(proverAgentConfigMappings),
-            ...getKeys(p2pConfigMappings),
-            ...getKeys(worldStateConfigMappings),
-            ...getKeys(sharedNodeConfigMappings)
+            ...getKeys(proverAgentConfigMappings)
         ]))
     ],
     'PROVER BROKER': [

package/dest/cli/cli.d.ts

@@ -6,4 +6,4 @@ import { Command } from 'commander';
  * @param debugLogger - logger for logging debug messages.
  */
 export declare function injectAztecCommands(program: Command, userLog: LogFn, debugLogger: Logger): Command;
-//# sourceMappingURL=cli.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL2NsaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFM0QsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUtwQzs7OztHQUlHO0FBQ0gsd0JBQWdCLG1CQUFtQixDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0EyQ2xHIn0=

package/dest/cli/cli.js

@@ -20,15 +20,15 @@ import { addOptions, printAztecStartHelpText } from './util.js';
     program.configureHelp({
         sortSubcommands: true
     });
-    program.addHelpText('after', `
+    if (process.env.AZTEC_SHELL_WRAPPER) {
+        program.addHelpText('after', `
+Additional commands:
 
-  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]
+  init [folder] [options]  creates a new Aztec Noir project.
+  new <path> [options]     creates a new Aztec Noir project in a new directory.
+  test [options]           starts a TXE and runs "nargo test" using it as the oracle resolver.
     `);
+    }
     program.command('preload-crs').description('Preload the points data needed for proving and verifying').action(async (options)=>{
         const { preloadCrs } = await import('./preload_crs.js');
         return await preloadCrs(options, userLog, debugLogger);

package/dest/cli/cmds/compile.d.ts

@@ -0,0 +1,4 @@
+import type { LogFn } from '@aztec/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCompileCommand(program: Command, log: LogFn): Command;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGlsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NsaS9jbWRzL2NvbXBpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHbkQsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBaUZ6Qyx3QkFBZ0Isb0JBQW9CLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxHQUFHLE9BQU8sQ0FzQjFFIn0=

package/dest/cli/cmds/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/compile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiFzC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,GAAG,OAAO,CAsB1E"}