@aztec/aztec 0.0.0-test.0

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_HOSTS` 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.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dest/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +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

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

@@ -0,0 +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;AAmB3D,wBAAsB,UAAU,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAyFjF"}

package/dest/cli/aztec_start_action.js

@@ -0,0 +1,108 @@
+import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { fileURLToPath } from '@aztec/foundation/url';
+import { AztecNodeApiSchema, PXESchema } from '@aztec/stdlib/interfaces/client';
+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 { github, splash } from '../splash.js';
+import { enrichEnvironmentWithChainConfig } from './chain_l2_config.js';
+import { extractNamespacedOptions, installSignalHandlers } from './util.js';
+import { getVersions } from './versioning.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 = {};
+    let config = undefined;
+    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 { node, pxe, stop } = await createSandbox({
+            l1Mnemonic: options.l1Mnemonic,
+            l1RpcUrls: options.l1RpcUrls,
+            l1Salt: nodeOptions.deployAztecContractsSalt,
+            noPXE: sandboxOptions.noPXE,
+            testAccounts: sandboxOptions.testAccounts
+        }, userLog);
+        // 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 a network is specified, enrich the environment with the chain config
+        if (options.network) {
+            await enrichEnvironmentWithChainConfig(options.network);
+        }
+        if (options.node) {
+            const { startNode } = await import('./cmds/start_node.js');
+            ({ config } = await startNode(options, signalHandlers, services, 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));
+        } else if (options.p2pBootstrap) {
+            const { startP2PBootstrap } = await import('./cmds/start_p2p_bootstrap.js');
+            ({ config } = 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);
+    const versions = getVersions(config);
+    if (Object.entries(services).length > 0) {
+        const rpcServer = createNamespacedSafeJsonRpcServer(services, {
+            http200OnError: false,
+            log: debugLogger,
+            middlewares: [
+                getOtelJsonRpcPropagationMiddleware(),
+                getVersioningMiddleware(versions)
+            ]
+        });
+        const { port } = await startHttpRpcServer(rpcServer, {
+            port: options.port
+        });
+        debugLogger.info(`Aztec Server listening on port ${port}`, versions);
+    }
+}

package/dest/cli/aztec_start_options.d.ts

@@ -0,0 +1,15 @@
+import { type ConfigMapping, type EnvVar } from '@aztec/foundation/config';
+export interface AztecStartOption {
+    flag: string;
+    description: string;
+    defaultValue: any | undefined;
+    printDefault?: (val: any) => string;
+    envVar: EnvVar | undefined;
+    parseVal?: (val: string) => any;
+}
+export declare const getOptions: (namespace: string, configMappings: Record<string, ConfigMapping>) => AztecStartOption[];
+export declare const universalOptions: string[];
+export declare const aztecStartOptions: {
+    [key: string]: AztecStartOption[];
+};
+//# sourceMappingURL=aztec_start_options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aztec_start_options.d.ts","sourceRoot":"","sources":["../../src/cli/aztec_start_options.ts"],"names":[],"mappings":"AAKA,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,GAAG,SAAS,CAAC;IAC9B,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;IACpC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;CACjC;AAED,eAAO,MAAM,UAAU,cAAe,MAAM,kBAAkB,OAAO,MAAM,EAAE,aAAa,CAAC,uBAiB1F,CAAC;AAGF,eAAO,MAAM,gBAAgB,UAA2E,CAAC;AAGzG,eAAO,MAAM,iBAAiB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAA;CAwTlE,CAAC"}

package/dest/cli/aztec_start_options.js

@@ -0,0 +1,348 @@
+import { 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 { booleanConfigHelper, isBooleanConfigValue, omitConfigMappings } from '@aztec/foundation/config';
+import { bootnodeConfigMappings, p2pConfigMappings } from '@aztec/p2p/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 = [
+    'l1RpcUrls',
+    'l1ChainId',
+    'l1Contracts',
+    'p2pEnabled',
+    'dataDirectory'
+];
+// Define categories and options
+export const aztecStartOptions = {
+    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)=>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)=>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)=>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),
+            ...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)
+    ],
+    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/chain_l2_config.d.ts

@@ -0,0 +1,19 @@
+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 declare const testnetIgnitionL2ChainConfig: L2ChainConfig;
+export declare function getBootnodes(networkName: NetworkNames): Promise<any>;
+export declare function getL2ChainConfig(networkName: NetworkNames): Promise<L2ChainConfig | undefined>;
+export declare function enrichEnvironmentWithChainConfig(networkName: NetworkNames): Promise<void>;
+//# sourceMappingURL=chain_l2_config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/cli/chain_l2_config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,aAY1C,CAAC;AAEF,wBAAsB,YAAY,CAAC,WAAW,EAAE,YAAY,gBAQ3D;AAED,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAOpG;AAUD,wBAAsB,gCAAgC,CAAC,WAAW,EAAE,YAAY,iBAgB/E"}

package/dest/cli/chain_l2_config.js

@@ -0,0 +1,56 @@
+export const testnetIgnitionL2ChainConfig = {
+    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) {
+    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) {
+    if (networkName === 'testnet-ignition') {
+        const config = {
+            ...testnetIgnitionL2ChainConfig
+        };
+        config.p2pBootstrapNodes = await getBootnodes(networkName);
+        return config;
+    }
+    return undefined;
+}
+function enrichVar(envVar, value) {
+    // Don't override
+    if (process.env[envVar]) {
+        return;
+    }
+    process.env[envVar] = value;
+}
+export async function enrichEnvironmentWithChainConfig(networkName) {
+    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());
+}