@aztec/cli 0.0.0-test.0

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "@aztec/cli",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    "./contracts": "./dest/cmds/contracts/index.js",
+    "./devnet": "./dest/cmds/devnet/index.js",
+    "./infrastructure": "./dest/cmds/infrastructure/index.js",
+    "./l1": "./dest/cmds/l1/index.js",
+    "./pxe": "./dest/cmds/pxe/index.js",
+    "./cli-utils": "./dest/utils/index.js",
+    "./misc": "./dest/cmds/misc/index.js",
+    "./setup-contracts": "./dest/cmds/misc/setup_contracts.js",
+    "./utils": "./dest/utils/index.js",
+    "./inspect": "./dest/utils/inspect.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./dest/builder/index.js"
+    ],
+    "name": "Aztec CLI",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "preset": "ts-jest/presets/default-esm",
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/archiver": "0.0.0-test.0",
+    "@aztec/aztec.js": "0.0.0-test.0",
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/l1-artifacts": "0.0.0-test.0",
+    "@aztec/p2p": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/world-state": "0.0.0-test.0",
+    "@iarna/toml": "^2.2.5",
+    "@libp2p/peer-id-factory": "^3.0.4",
+    "commander": "^12.1.0",
+    "lodash.chunk": "^4.2.0",
+    "lodash.groupby": "^4.6.0",
+    "semver": "^7.5.4",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0",
+    "viem": "2.22.8"
+  },
+  "devDependencies": {
+    "@aztec/accounts": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/lodash.chunk": "^4.2.9",
+    "@types/lodash.groupby": "^4.6.9",
+    "@types/lodash.startcase": "^4.4.7",
+    "@types/node": "^18.7.23",
+    "@types/semver": "^7.5.2",
+    "@types/source-map-support": "^0.5.10",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.5",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "peerDependencies": {
+    "@aztec/accounts": "0.0.0-test.0",
+    "@aztec/bb-prover": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/l1-artifacts": "0.0.0-test.0",
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cmds/contracts/index.ts

@@ -0,0 +1,34 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('inspect-contract')
+    .description('Shows list of external callable functions for a contract')
+    .argument(
+      '<contractArtifactFile>',
+      `A compiled Noir contract's artifact in JSON format or name of a contract artifact exported by @aztec/noir-contracts.js`,
+    )
+    .action(async (contractArtifactFile: string) => {
+      const { inspectContract } = await import('./inspect_contract.js');
+      await inspectContract(contractArtifactFile, debugLogger, log);
+    });
+
+  // Helper for users to decode hex strings into structs if needed.
+  program
+    .command('parse-parameter-struct')
+    .description("Helper for parsing an encoded string into a contract's parameter struct.")
+    .argument('<encodedString>', 'The encoded hex string')
+    .requiredOption(
+      '-c, --contract-artifact <fileLocation>',
+      "A compiled Aztec.nr contract's ABI in JSON format or name of a contract ABI exported by @aztec/noir-contracts.js",
+    )
+    .requiredOption('-p, --parameter <parameterName>', 'The name of the struct parameter to decode into')
+    .action(async (encodedString, options) => {
+      const { parseParameterStruct } = await import('./parse_parameter_struct.js');
+      await parseParameterStruct(encodedString, options.contractArtifact, options.parameter, log);
+    });
+
+  return program;
+}

package/src/cmds/contracts/inspect_contract.ts

@@ -0,0 +1,51 @@
+import { sha256 } from '@aztec/foundation/crypto';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import {
+  type FunctionArtifact,
+  FunctionSelector,
+  decodeFunctionSignature,
+  decodeFunctionSignatureWithParameterNames,
+} from '@aztec/stdlib/abi';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+
+import { getContractArtifact } from '../../utils/aztec.js';
+
+export async function inspectContract(contractArtifactFile: string, debugLogger: Logger, log: LogFn) {
+  const contractArtifact = await getContractArtifact(contractArtifactFile, log);
+  const contractFns = contractArtifact.functions;
+  if (contractFns.length === 0) {
+    log(`No functions found for contract ${contractArtifact.name}`);
+  }
+  const contractClass = await getContractClassFromArtifact(contractArtifact);
+  const bytecodeLengthInFields = 1 + Math.ceil(contractClass.packedBytecode.length / 31);
+
+  log(`Contract class details:`);
+  log(`\tidentifier: ${contractClass.id.toString()}`);
+  log(`\tartifact hash: ${contractClass.artifactHash.toString()}`);
+  log(`\tprivate function tree root: ${contractClass.privateFunctionsRoot.toString()}`);
+  log(`\tpublic bytecode commitment: ${contractClass.publicBytecodeCommitment.toString()}`);
+  log(`\tpublic bytecode length: ${contractClass.packedBytecode.length} bytes (${bytecodeLengthInFields} fields)`);
+
+  const externalFunctions = contractFns.filter(f => !f.isInternal);
+  if (externalFunctions.length > 0) {
+    log(`\nExternal functions:`);
+    await Promise.all(externalFunctions.map(f => logFunction(f, log)));
+  }
+
+  const internalFunctions = contractFns.filter(f => f.isInternal);
+  if (internalFunctions.length > 0) {
+    log(`\nInternal functions:`);
+    await Promise.all(internalFunctions.map(f => logFunction(f, log)));
+  }
+}
+
+async function logFunction(fn: FunctionArtifact, log: LogFn) {
+  const signatureWithParameterNames = decodeFunctionSignatureWithParameterNames(fn.name, fn.parameters);
+  const signature = decodeFunctionSignature(fn.name, fn.parameters);
+  const selector = await FunctionSelector.fromSignature(signature);
+  const bytecodeSize = fn.bytecode.length;
+  const bytecodeHash = sha256(fn.bytecode).toString('hex');
+  log(
+    `${fn.functionType} ${signatureWithParameterNames} \n\tfunction signature: ${signature}\n\tselector: ${selector}\n\tbytecode: ${bytecodeSize} bytes (sha256 ${bytecodeHash})`,
+  );
+}

package/src/cmds/contracts/parse_parameter_struct.ts

@@ -0,0 +1,27 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { LogFn } from '@aztec/foundation/log';
+import type { StructType } from '@aztec/stdlib/abi';
+
+import { getContractArtifact } from '../../utils/aztec.js';
+import { parseStructString } from '../../utils/encoding.js';
+
+export async function parseParameterStruct(
+  encodedString: string,
+  contractArtifactPath: string,
+  parameterName: string,
+  log: LogFn,
+) {
+  const contractArtifact = await getContractArtifact(contractArtifactPath, log);
+  const parameterAbitype = contractArtifact.functions
+    .map(({ parameters }) => parameters)
+    .flat()
+    .find(({ name, type }) => name === parameterName && type.kind === 'struct');
+
+  if (!parameterAbitype) {
+    log(`No struct parameter found with name ${parameterName}`);
+    return;
+  }
+
+  const data = parseStructString(encodedString, parameterAbitype.type as StructType);
+  log(`\nStruct Data: \n${jsonStringify(data, true)}\n`);
+}

package/src/cmds/devnet/bootstrap_network.ts

@@ -0,0 +1,318 @@
+import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import {
+  AztecAddress,
+  BatchCall,
+  EthAddress,
+  Fr,
+  L1FeeJuicePortalManager,
+  type PXE,
+  type WaitOpts,
+  type Wallet,
+  createCompatibleClient,
+  retryUntil,
+} from '@aztec/aztec.js';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import {
+  type ContractArtifacts,
+  type L1Clients,
+  createEthereumChain,
+  createL1Clients,
+  deployL1Contract,
+} from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { getContract } from 'viem';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+type ContractDeploymentInfo = {
+  address: AztecAddress;
+  initHash: Fr;
+  salt: Fr;
+};
+
+const waitOpts: WaitOpts = {
+  timeout: 120,
+  provenTimeout: 4800,
+  interval: 1,
+};
+
+export async function bootstrapNetwork(
+  pxeUrl: string,
+  l1Urls: string[],
+  l1ChainId: string,
+  l1PrivateKey: `0x${string}` | undefined,
+  l1Mnemonic: string,
+  addressIndex: number,
+  json: boolean,
+  log: LogFn,
+  debugLog: Logger,
+) {
+  const pxe = await createCompatibleClient(pxeUrl, debugLog);
+
+  const [wallet] = await getDeployedTestAccountsWallets(pxe);
+
+  const l1Clients = createL1Clients(
+    l1Urls,
+    l1PrivateKey
+      ? privateKeyToAccount(l1PrivateKey)
+      : // We need to use a different account that the main "deployer" account because the "deployer" account creates transactions that send blobs.
+        // Note that this account needs to be funded on L1 !
+        mnemonicToAccount(l1Mnemonic, { addressIndex }),
+    createEthereumChain(l1Urls, +l1ChainId).chainInfo,
+  );
+
+  const { erc20Address, portalAddress } = await deployERC20(l1Clients);
+
+  const { token, bridge } = await deployToken(wallet, portalAddress);
+
+  await initPortal(pxe, l1Clients, erc20Address, portalAddress, bridge.address);
+
+  const fpcAdmin = wallet.getAddress();
+  const fpc = await deployFPC(wallet, token.address, fpcAdmin);
+
+  const counter = await deployCounter(wallet);
+
+  await fundFPC(counter.address, wallet, l1Clients, fpc.address, debugLog);
+
+  if (json) {
+    log(
+      JSON.stringify(
+        {
+          devCoinL1: erc20Address.toString(),
+          devCoinPortalL1: portalAddress.toString(),
+          devCoin: {
+            address: token.address.toString(),
+            initHash: token.initHash.toString(),
+            salt: token.salt.toString(),
+          },
+          devCoinBridge: {
+            address: bridge.address.toString(),
+            initHash: bridge.initHash.toString(),
+            salt: bridge.salt.toString(),
+          },
+          devCoinFpc: {
+            address: fpc.address.toString(),
+            initHash: fpc.initHash.toString(),
+            salt: fpc.salt.toString(),
+          },
+          counter: {
+            address: counter.address.toString(),
+            initHash: counter.initHash.toString(),
+            salt: counter.salt.toString(),
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`DevCoin L1: ${erc20Address}`);
+    log(`DevCoin L1 Portal: ${portalAddress}`);
+    log(`DevCoin L2: ${token.address}`);
+    log(`DevCoin L2 init hash: ${token.initHash}`);
+    log(`DevCoin L2 salt: ${token.salt}`);
+    log(`DevCoin L2 Bridge: ${bridge.address}`);
+    log(`DevCoin L2 Bridge init hash: ${bridge.initHash}`);
+    log(`DevCoin L2 Bridge salt: ${bridge.salt}`);
+    log(`DevCoin FPC: ${fpc.address}`);
+    log(`DevCoin FPC init hash: ${fpc.initHash}`);
+    log(`DevCoin FPC salt: ${fpc.salt}`);
+    log(`Counter: ${counter.address}`);
+    log(`Counter init hash: ${counter.initHash}`);
+    log(`Counter salt: ${counter.salt}`);
+  }
+}
+
+/**
+ * Step 1. Deploy the L1 contracts, but don't initialize
+ */
+async function deployERC20({ walletClient, publicClient }: L1Clients) {
+  const { TestERC20Abi, TestERC20Bytecode, TokenPortalAbi, TokenPortalBytecode } = await import('@aztec/l1-artifacts');
+
+  const erc20: ContractArtifacts = {
+    contractAbi: TestERC20Abi,
+    contractBytecode: TestERC20Bytecode,
+  };
+  const portal: ContractArtifacts = {
+    contractAbi: TokenPortalAbi,
+    contractBytecode: TokenPortalBytecode,
+  };
+
+  const { address: erc20Address } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    erc20.contractAbi,
+    erc20.contractBytecode,
+    ['DevCoin', 'DEV', walletClient.account.address],
+  );
+  const { address: portalAddress } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    portal.contractAbi,
+    portal.contractBytecode,
+  );
+
+  return {
+    erc20Address,
+    portalAddress,
+  };
+}
+
+/**
+ * Step 2. Deploy the L2 contracts
+ */
+async function deployToken(
+  wallet: Wallet,
+  l1Portal: EthAddress,
+): Promise<{ token: ContractDeploymentInfo; bridge: ContractDeploymentInfo }> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { TokenContract } = await import('@aztec/noir-contracts.js/Token');
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { TokenBridgeContract } = await import('@aztec/noir-contracts.js/TokenBridge');
+  const devCoin = await TokenContract.deploy(wallet, wallet.getAddress(), 'DevCoin', 'DEV', 18)
+    .send({ universalDeploy: true })
+    .deployed(waitOpts);
+  const bridge = await TokenBridgeContract.deploy(wallet, devCoin.address, l1Portal)
+    .send({ universalDeploy: true })
+    .deployed(waitOpts);
+
+  await new BatchCall(wallet, [
+    await devCoin.methods.set_minter(bridge.address, true).request(),
+    await devCoin.methods.set_admin(bridge.address).request(),
+  ])
+    .send()
+    .wait(waitOpts);
+
+  return {
+    token: {
+      address: devCoin.address,
+      initHash: devCoin.instance.initializationHash,
+      salt: devCoin.instance.salt,
+    },
+    bridge: {
+      address: bridge.address,
+      initHash: bridge.instance.initializationHash,
+      salt: bridge.instance.salt,
+    },
+  };
+}
+
+/**
+ * Step 3. Initialize DevCoin's L1 portal
+ */
+async function initPortal(
+  pxe: PXE,
+  { walletClient, publicClient }: L1Clients,
+  erc20: EthAddress,
+  portal: EthAddress,
+  bridge: AztecAddress,
+) {
+  const { TokenPortalAbi } = await import('@aztec/l1-artifacts');
+  const {
+    l1ContractAddresses: { registryAddress },
+  } = await pxe.getNodeInfo();
+
+  const contract = getContract({
+    abi: TokenPortalAbi,
+    address: portal.toString(),
+    client: walletClient,
+  });
+
+  const hash = await contract.write.initialize([registryAddress.toString(), erc20.toString(), bridge.toString()]);
+
+  await publicClient.waitForTransactionReceipt({ hash });
+}
+
+async function deployFPC(
+  wallet: Wallet,
+  tokenAddress: AztecAddress,
+  admin: AztecAddress,
+): Promise<ContractDeploymentInfo> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { FPCContract } = await import('@aztec/noir-contracts.js/FPC');
+  const fpc = await FPCContract.deploy(wallet, tokenAddress, admin).send({ universalDeploy: true }).deployed(waitOpts);
+  const info: ContractDeploymentInfo = {
+    address: fpc.address,
+    initHash: fpc.instance.initializationHash,
+    salt: fpc.instance.salt,
+  };
+  return info;
+}
+
+async function deployCounter(wallet: Wallet): Promise<ContractDeploymentInfo> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+  const counter = await CounterContract.deploy(wallet, 1, wallet.getAddress())
+    .send({ universalDeploy: true })
+    .deployed(waitOpts);
+  const info: ContractDeploymentInfo = {
+    address: counter.address,
+    initHash: counter.instance.initializationHash,
+    salt: counter.instance.salt,
+  };
+  return info;
+}
+
+// NOTE: Disabling for now in order to get devnet running
+async function fundFPC(
+  counterAddress: AztecAddress,
+  wallet: Wallet,
+  l1Clients: L1Clients,
+  fpcAddress: AztecAddress,
+  debugLog: Logger,
+) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { FeeJuiceContract } = await import('@aztec/noir-contracts.js/FeeJuice');
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+  const {
+    protocolContractAddresses: { feeJuice },
+  } = await wallet.getPXEInfo();
+
+  const feeJuiceContract = await FeeJuiceContract.at(feeJuice, wallet);
+
+  const feeJuicePortal = await L1FeeJuicePortalManager.new(
+    wallet,
+    l1Clients.publicClient,
+    l1Clients.walletClient,
+    debugLog,
+  );
+
+  const amount = FEE_FUNDING_FOR_TESTER_ACCOUNT;
+  const { claimAmount, claimSecret, messageLeafIndex, messageHash } = await feeJuicePortal.bridgeTokensPublic(
+    fpcAddress,
+    amount,
+    true,
+  );
+
+  await retryUntil(
+    async () => await wallet.isL1ToL2MessageSynced(Fr.fromHexString(messageHash)),
+    'message sync',
+    600,
+    1,
+  );
+
+  const counter = await CounterContract.at(counterAddress, wallet);
+
+  debugLog.info('Incrementing Counter');
+
+  // TODO (alexg) remove this once sequencer builds blocks continuously
+  // advance the chain
+  await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+  await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+
+  debugLog.info('Claiming FPC');
+
+  await feeJuiceContract.methods
+    .claim(fpcAddress, claimAmount, claimSecret, messageLeafIndex)
+    .send()
+    .wait({ ...waitOpts, proven: true });
+
+  debugLog.info('Finished claiming FPC');
+}

package/src/cmds/devnet/faucet.ts

@@ -0,0 +1,33 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function dripFaucet(
+  faucetUrl: string,
+  asset: string,
+  account: EthAddress,
+  json: boolean,
+  log: LogFn,
+): Promise<void> {
+  const url = new URL(`/drip/${account.toString()}`, faucetUrl);
+  url.searchParams.set('asset', asset);
+  const res = await fetch(url);
+  if (res.status === 200) {
+    if (json) {
+      log(prettyPrintJSON({ ok: true }));
+    } else {
+      log(`Dripped ${asset} for ${account.toString()}`);
+    }
+  } else {
+    if (json) {
+      log(prettyPrintJSON({ ok: false }));
+    } else if (res.status === 429) {
+      log(`Rate limited when dripping ${asset} for ${account.toString()}`);
+    } else {
+      log(`Failed to drip ${asset} for ${account.toString()}`);
+    }
+
+    process.exit(1);
+  }
+}

package/src/cmds/devnet/index.ts

@@ -0,0 +1,60 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseEthereumAddress, pxeOption } from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('bootstrap-network')
+    .description('Bootstrap a new network')
+    .addOption(pxeOption)
+    .addOption(l1ChainIdOption)
+    .requiredOption<string[]>(
+      '--l1-rpc-urls <string>',
+      'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)',
+      (arg: string) => arg.split(','),
+      [ETHEREUM_HOSTS],
+    )
+    .option('--l1-private-key <string>', 'The private key to use for deployment', process.env.PRIVATE_KEY)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .option(
+      '-ai, --address-index <number>',
+      'The address index to use when calculating an address',
+      arg => BigInt(arg),
+      0n,
+    )
+    .option('--json', 'Output the result as JSON')
+    .action(async options => {
+      const { bootstrapNetwork } = await import('./bootstrap_network.js');
+      await bootstrapNetwork(
+        options[pxeOption.attributeName()],
+        options.l1RpcUrls,
+        options[l1ChainIdOption.attributeName()],
+        options.l1PrivateKey,
+        options.mnemonic,
+        options.addressIndex,
+        options.json,
+        log,
+        debugLogger,
+      );
+    });
+
+  program
+    .command('drip-faucet')
+    .description('Drip the faucet')
+    .requiredOption('-u, --faucet-url <string>', 'Url of the faucet', 'http://localhost:8082')
+    .requiredOption('-t, --token <string>', 'The asset to drip', 'eth')
+    .requiredOption('-a, --address <string>', 'The Ethereum address to drip to', parseEthereumAddress)
+    .option('--json', 'Output the result as JSON')
+    .action(async options => {
+      const { dripFaucet } = await import('./faucet.js');
+      await dripFaucet(options.faucetUrl, options.token, options.address, options.json, log);
+    });
+
+  return program;
+}