@aztec/aztec 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/README.md

@@ -0,0 +1,57 @@
+# aztec
+
+Aztec is a package that allows for a simple development environment on Aztec stack. It creates a Private eXecution Environment (PXE) that listens for HTTP requests on `localhost:8080` by default. When started, it deploys all necessary L1 Aztec contracts and then starts listening for RPC requests.
+
+## How to run:
+
+### Docker Compose
+
+The easiest way to run is by using `docker compose up`. This will create two containers:
+
+1. The sandbox listening on port `8080`
+2. An anvil instance listening on port `8545`
+
+### Node Server
+
+You can also run it as a standalone node server with:
+
+```sh
+yarn start
+```
+
+It will look for a local Ethereum RPC to talk to but you can change this with the `ETHEREUM_HOST` environment variable.
+
+## Examples
+
+The package also includes 2 examples. There are some system prerequisites that you will need to run these locally:
+
+- [nvm](https://github.com/nvm-sh/nvm)
+  - Node version > 18
+- [yarn](https://yarnpkg.com/)
+- [jq](https://jqlang.github.io/jq/download/)
+
+Before running locally you'll need to:
+
+- Head to `l1-contracts` directory and run `./bootstrap.sh`
+- Then go to `yarn-project and run:
+  - `yarn install`
+  - `yarn build`
+    And you should be good to go!
+
+From the `aztec` directory, you can run the two existing examples:
+
+- Deployment, mint and transfer on an Aztec Private Token
+  - `yarn run:example:token`
+- An L1 / L2 uniswap token trade.
+  - `yarn run:example:uniswap`
+  - To run this example, you need to set the following vars:
+
+```
+export FORK_BLOCK_NUMBER=17514288
+export FORK_URL=<YOUR_RPC_URL e.g. https://mainnet.infura.io/v3/API_KEY>
+```
+
+## Publishing
+
+This package is set-up to be published on dockerhub by CI whenever there's a tagged release on `master` branch.
+It's published under the tags `aztecprotocol/aztec:latest` & `aztecprotocol/aztec:<version-tag>`.

package/dest/bin/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+//
+import { injectCommands as injectBuilderCommands } from '@aztec/builder';
+import { injectCommands as injectWalletCommands } from '@aztec/cli-wallet';
+import { injectCommands as injectContractCommands } from '@aztec/cli/contracts';
+import { injectCommands as injectDevnetCommands } from '@aztec/cli/devnet';
+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 { createConsoleLogger, createLogger } from '@aztec/foundation/log';
+import { fileURLToPath } from '@aztec/foundation/url';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { injectAztecCommands } from '../cli/index.js';
+const userLog = createConsoleLogger();
+const debugLogger = createLogger('cli');
+/** CLI & full node main entrypoint */ async function main() {
+    const shutdown = ()=>{
+        process.exit(0);
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+    const cliVersion = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+    let program = new Command('aztec');
+    program.description('Aztec command line interface').version(cliVersion);
+    program = injectAztecCommands(program, userLog, debugLogger);
+    program = injectBuilderCommands(program);
+    program = injectContractCommands(program, userLog, debugLogger);
+    program = injectInfrastructureCommands(program, userLog, debugLogger);
+    program = injectL1Commands(program, userLog, debugLogger);
+    program = injectPXECommands(program, userLog, debugLogger);
+    program = injectMiscCommands(program, userLog);
+    program = injectDevnetCommands(program, userLog, debugLogger);
+    program = injectWalletCommands(program, userLog, debugLogger);
+    await program.parseAsync(process.argv);
+}
+main().catch((err)=>{
+    debugLogger.error(`Error in command execution`);
+    debugLogger.error(err + '\n' + err.stack);
+    // See https://nodejs.org/api/process.html#processexitcode
+    process.exitCode = 1;
+    throw err;
+});

package/dest/cli/aztec_start_action.js

@@ -0,0 +1,110 @@
+import { deployInitialTestAccounts } from '@aztec/accounts/testing';
+import { AztecNodeApiSchema, PXESchema } from '@aztec/circuit-types';
+import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { fileURLToPath } from '@aztec/foundation/url';
+import { getOtelJsonRpcPropagationMiddleware } from '@aztec/telemetry-client';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { createSandbox } from '../sandbox.js';
+import { github, splash } from '../splash.js';
+import { createAccountLogs, extractNamespacedOptions, installSignalHandlers } from './util.js';
+const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+const cliVersion = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+export async function aztecStart(options, userLog, debugLogger) {
+    // list of 'stop' functions to call when process ends
+    const signalHandlers = [];
+    const services = {};
+    if (options.sandbox) {
+        const sandboxOptions = extractNamespacedOptions(options, 'sandbox');
+        const nodeOptions = extractNamespacedOptions(options, 'node');
+        userLog(`${splash}\n${github}\n\n`);
+        userLog(`Setting up Aztec Sandbox ${cliVersion}, please stand by...`);
+        const { aztecNodeConfig, node, pxe, stop } = await createSandbox({
+            l1Mnemonic: options.l1Mnemonic,
+            l1RpcUrl: options.l1RpcUrl,
+            l1Salt: nodeOptions.deployAztecContractsSalt
+        });
+        // Deploy test accounts by default
+        if (sandboxOptions.testAccounts) {
+            if (aztecNodeConfig.p2pEnabled) {
+                userLog(`Not setting up test accounts as we are connecting to a network`);
+            } else if (sandboxOptions.noPXE) {
+                userLog(`Not setting up test accounts as we are not exposing a PXE`);
+            } else {
+                userLog('Setting up test accounts...');
+                const accounts = await deployInitialTestAccounts(pxe);
+                const accLogs = await createAccountLogs(accounts, pxe);
+                userLog(accLogs.join(''));
+            }
+        }
+        // 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`);
+        }
+    } else {
+        if (options.node) {
+            const { startNode } = await import('./cmds/start_node.js');
+            await startNode(options, signalHandlers, services, userLog);
+        } else if (options.proofVerifier) {
+            const { startProofVerifier } = await import('./cmds/start_proof_verifier.js');
+            await startProofVerifier(options, signalHandlers, 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');
+            await startProverNode(options, signalHandlers, services, userLog);
+        } else if (options.pxe) {
+            const { startPXE } = await import('./cmds/start_pxe.js');
+            await startPXE(options, signalHandlers, services, userLog);
+        } else if (options.archiver) {
+            const { startArchiver } = await import('./cmds/start_archiver.js');
+            await startArchiver(options, signalHandlers, services);
+        } else if (options.p2pBootstrap) {
+            const { startP2PBootstrap } = await import('./cmds/start_p2p_bootstrap.js');
+            await startP2PBootstrap(options, signalHandlers, services, userLog);
+        } else if (options.proverAgent) {
+            const { startProverAgent } = await import('./cmds/start_prover_agent.js');
+            await startProverAgent(options, signalHandlers, services, userLog);
+        } else if (options.proverBroker) {
+            const { startProverBroker } = await import('./cmds/start_prover_broker.js');
+            await startProverBroker(options, signalHandlers, services, userLog);
+        } else if (options.txe) {
+            const { startTXE } = await import('./cmds/start_txe.js');
+            await startTXE(options, debugLogger);
+        } 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);
+        }
+    }
+    installSignalHandlers(debugLogger.info, signalHandlers);
+    if (Object.entries(services).length > 0) {
+        const rpcServer = createNamespacedSafeJsonRpcServer(services, {
+            http200OnError: false,
+            log: debugLogger,
+            middlewares: [
+                getOtelJsonRpcPropagationMiddleware()
+            ]
+        });
+        const { port } = await startHttpRpcServer(rpcServer, {
+            port: options.port
+        });
+        debugLogger.info(`Aztec Server listening on port ${port}`);
+    }
+}

package/dest/cli/aztec_start_options.js

@@ -0,0 +1,341 @@
+import { 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 { booleanConfigHelper, isBooleanConfigValue, omitConfigMappings } from '@aztec/foundation/config';
+import { bootnodeConfigMappings, p2pConfigMappings } from '@aztec/p2p/config';
+import { proofVerifierConfigMappings } from '@aztec/proof-verifier/config';
+import { 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';
+export const getOptions = (namespace, configMappings)=>{
+    const options = [];
+    for (const [key, { env, defaultValue: def, parseEnv, description, printDefault }] of Object.entries(configMappings)){
+        if (universalOptions.includes(key)) {
+            continue;
+        }
+        const isBoolean = isBooleanConfigValue(configMappings, key);
+        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 = {
+    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)=>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)=>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),
+            ...Object.keys(proverBrokerConfigMappings),
+            ...Object.keys(proverAgentConfigMappings)
+        ]))
+    ],
+    '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/dest/cli/cli.js

@@ -0,0 +1,33 @@
+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, userLog, debugLogger) {
+    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/dest/cli/cmds/start_archiver.js

@@ -0,0 +1,35 @@
+import { Archiver, 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 { 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, signalHandlers, services) {
+    const archiverConfig = extractRelevantOptions(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/dest/cli/cmds/start_bot.js

@@ -0,0 +1,31 @@
+import { BotRunner, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
+import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { extractRelevantOptions } from '../util.js';
+export async function startBot(options, signalHandlers, services, userLog) {
+    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;
+    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, signalHandlers, services, deps) {
+    const config = extractRelevantOptions(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/dest/cli/cmds/start_faucet.js

@@ -0,0 +1,20 @@
+import { Faucet, FaucetSchema, createFaucetHttpServer, faucetConfigMapping, getFaucetConfigFromEnv } from '@aztec/aztec-faucet';
+import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
+export async function startFaucet(options, signalHandlers, services, log) {
+    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
+    ];
+}