@aztec/cli 0.16.9 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/cmds/l1/deploy_l1_contracts.ts

@@ -0,0 +1,55 @@
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { type EthAddress } from '@aztec/foundation/eth-address';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { deployAztecContracts } from '../../utils/aztec.js';
+
+export async function deployL1Contracts(
+  rpcUrl: string,
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  salt: number | undefined,
+  json: boolean,
+  initialValidators: EthAddress[],
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  const { l1ContractAddresses } = await deployAztecContracts(
+    rpcUrl,
+    chainId,
+    privateKey,
+    mnemonic,
+    mnemonicIndex,
+    salt,
+    initialValidators,
+    config,
+    debugLogger,
+  );
+
+  if (json) {
+    log(
+      JSON.stringify(
+        Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v]) => [k, v.toString()])),
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+    log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+    log(`L1 -> L2 Inbox Address: ${l1ContractAddresses.inboxAddress.toString()}`);
+    log(`L2 -> L1 Outbox Address: ${l1ContractAddresses.outboxAddress.toString()}`);
+    log(`Fee Juice Address: ${l1ContractAddresses.feeJuiceAddress.toString()}`);
+    log(`Staking Asset Address: ${l1ContractAddresses.stakingAssetAddress.toString()}`);
+    log(`Fee Juice Portal Address: ${l1ContractAddresses.feeJuicePortalAddress.toString()}`);
+    log(`CoinIssuer Address: ${l1ContractAddresses.coinIssuerAddress.toString()}`);
+    log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
+    log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
+    log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
+    log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress.toString()}`);
+  }
+}

package/src/cmds/l1/deploy_l1_verifier.ts

@@ -0,0 +1,105 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+import { HonkVerifierAbi, HonkVerifierBytecode } from '@aztec/l1-artifacts';
+
+import { InvalidOptionArgumentError } from 'commander';
+import { type Hex, getContract } from 'viem';
+
+export async function deployUltraHonkVerifier(
+  rollupAddress: Hex | undefined,
+  ethRpcUrl: string,
+  l1ChainId: string,
+  privateKey: string | undefined,
+  mnemonic: string,
+  pxeRpcUrl: string,
+  bbBinaryPath: string,
+  bbWorkingDirectory: string,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  if (!bbBinaryPath || !bbWorkingDirectory) {
+    throw new InvalidOptionArgumentError('Missing path to bb binary and working directory');
+  }
+
+  const { publicClient, walletClient } = createL1Clients(
+    ethRpcUrl,
+    privateKey ?? mnemonic,
+    createEthereumChain(ethRpcUrl, l1ChainId).chainInfo,
+  );
+
+  if (!rollupAddress && pxeRpcUrl) {
+    const pxe = await createCompatibleClient(pxeRpcUrl, debugLogger);
+    const { l1ContractAddresses } = await pxe.getNodeInfo();
+    rollupAddress = l1ContractAddresses.rollupAddress.toString();
+  }
+
+  if (!rollupAddress) {
+    throw new InvalidOptionArgumentError('Missing rollup address');
+  }
+
+  const { RollupAbi } = await import('@aztec/l1-artifacts');
+
+  const rollup = getContract({
+    abi: RollupAbi,
+    address: rollupAddress,
+    client: walletClient,
+  });
+
+  const { address: verifierAddress } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    HonkVerifierAbi,
+    HonkVerifierBytecode,
+  );
+  log(`Deployed honk verifier at ${verifierAddress}`);
+
+  await rollup.write.setEpochVerifier([verifierAddress.toString()]);
+
+  log(`Rollup accepts only real proofs now`);
+}
+
+export async function deployMockVerifier(
+  rollupAddress: Hex | undefined,
+  ethRpcUrl: string,
+  l1ChainId: string,
+  privateKey: string | undefined,
+  mnemonic: string,
+  pxeRpcUrl: string,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const { publicClient, walletClient } = createL1Clients(
+    ethRpcUrl,
+    privateKey ?? mnemonic,
+    createEthereumChain(ethRpcUrl, l1ChainId).chainInfo,
+  );
+  const { MockVerifierAbi, MockVerifierBytecode, RollupAbi } = await import('@aztec/l1-artifacts');
+
+  const { address: mockVerifierAddress } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    MockVerifierAbi,
+    MockVerifierBytecode,
+  );
+  log(`Deployed MockVerifier at ${mockVerifierAddress.toString()}`);
+
+  if (!rollupAddress && pxeRpcUrl) {
+    const pxe = await createCompatibleClient(pxeRpcUrl, debugLogger);
+    const { l1ContractAddresses } = await pxe.getNodeInfo();
+    rollupAddress = l1ContractAddresses.rollupAddress.toString();
+  }
+
+  if (!rollupAddress) {
+    throw new InvalidOptionArgumentError('Missing rollup address');
+  }
+
+  const rollup = getContract({
+    abi: RollupAbi,
+    address: rollupAddress,
+    client: walletClient,
+  });
+
+  await rollup.write.setEpochVerifier([mockVerifierAddress.toString()]);
+  log(`Rollup accepts only fake proofs now`);
+}

package/src/cmds/l1/get_l1_balance.ts

@@ -0,0 +1,41 @@
+import { type EthAddress } from '@aztec/circuits.js';
+import { createEthereumChain } from '@aztec/ethereum';
+import { type LogFn } from '@aztec/foundation/log';
+import { TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createPublicClient, getContract, http } from 'viem';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function getL1Balance(
+  who: EthAddress,
+  token: EthAddress | undefined,
+  l1RpcUrl: string,
+  chainId: number,
+  json: boolean,
+  log: LogFn,
+) {
+  const chain = createEthereumChain(l1RpcUrl, chainId);
+  const publicClient = createPublicClient({ chain: chain.chainInfo, transport: http(chain.rpcUrl) });
+
+  let balance = 0n;
+  if (token) {
+    const gasL1 = getContract({
+      address: token.toString(),
+      abi: TestERC20Abi,
+      client: publicClient,
+    });
+
+    balance = await gasL1.read.balanceOf([who.toString()]);
+  } else {
+    balance = await publicClient.getBalance({
+      address: who.toString(),
+    });
+  }
+
+  if (json) {
+    log(prettyPrintJSON({ balance }));
+  } else {
+    log(`L1 balance of ${who.toString()} is ${balance.toString()}`);
+  }
+}

package/src/cmds/l1/index.ts

@@ -0,0 +1,415 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { type Command, Option } from 'commander';
+
+import {
+  ETHEREUM_HOST,
+  PRIVATE_KEY,
+  l1ChainIdOption,
+  makePxeOption,
+  parseAztecAddress,
+  parseBigint,
+  parseEthereumAddress,
+  pxeOption,
+} from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  const { BB_BINARY_PATH, BB_WORKING_DIRECTORY } = process.env;
+
+  program
+    .command('deploy-l1-contracts')
+    .description('Deploys all necessary Ethereum contracts for Aztec.')
+    .requiredOption(
+      '-u, --rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .option('--validators <string>', 'Comma separated list of validators')
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use in deployment', arg => parseInt(arg), 0)
+    .addOption(l1ChainIdOption)
+    .option('--salt <number>', 'The optional salt to use in deployment', arg => parseInt(arg))
+    .option('--json', 'Output the contract addresses in JSON format')
+    .action(async options => {
+      const { deployL1Contracts } = await import('./deploy_l1_contracts.js');
+
+      const initialValidators =
+        options.validators?.split(',').map((validator: string) => EthAddress.fromString(validator)) || [];
+      await deployL1Contracts(
+        options.rpcUrl,
+        options.l1ChainId,
+        options.privateKey,
+        options.mnemonic,
+        options.mnemonicIndex,
+        options.salt,
+        options.json,
+        initialValidators,
+        log,
+        debugLogger,
+      );
+    });
+
+  program
+    .command('generate-l1-account')
+    .description('Generates a new private key for an account on L1.')
+    .option('--json', 'Output the private key in JSON format')
+    .action(async () => {
+      const { generateL1Account } = await import('./update_l1_validators.js');
+      const account = generateL1Account();
+      log(JSON.stringify(account, null, 2));
+    });
+
+  program
+    .command('add-l1-validator')
+    .description('Adds a validator to the L1 rollup contract.')
+    .requiredOption(
+      '-u, --rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .addOption(l1ChainIdOption)
+    .option('--validator <address>', 'ethereum address of the validator', parseEthereumAddress)
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .option('--withdrawer <address>', 'ethereum address of the withdrawer', parseEthereumAddress)
+    .action(async options => {
+      const { addL1Validator } = await import('./update_l1_validators.js');
+      await addL1Validator({
+        rpcUrl: options.rpcUrl,
+        chainId: options.l1ChainId,
+        privateKey: options.privateKey,
+        mnemonic: options.mnemonic,
+        validatorAddress: options.validator,
+        rollupAddress: options.rollup,
+        withdrawerAddress: options.withdrawer,
+        log,
+        debugLogger,
+      });
+    });
+
+  program
+    .command('remove-l1-validator')
+    .description('Removes a validator to the L1 rollup contract.')
+    .requiredOption(
+      '-u, --rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .addOption(l1ChainIdOption)
+    .option('--validator <address>', 'ethereum address of the validator', parseEthereumAddress)
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .action(async options => {
+      const { removeL1Validator } = await import('./update_l1_validators.js');
+      await removeL1Validator({
+        rpcUrl: options.rpcUrl,
+        chainId: options.l1ChainId,
+        privateKey: options.privateKey,
+        mnemonic: options.mnemonic,
+        validatorAddress: options.validator,
+        rollupAddress: options.rollup,
+        log,
+        debugLogger,
+      });
+    });
+
+  program
+    .command('fast-forward-epochs')
+    .description('Fast forwards the epoch of the L1 rollup contract.')
+    .requiredOption(
+      '-u, --rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .addOption(l1ChainIdOption)
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .option('--count <number>', 'The number of epochs to fast forward', arg => BigInt(parseInt(arg)), 1n)
+    .action(async options => {
+      const { fastForwardEpochs } = await import('./update_l1_validators.js');
+      await fastForwardEpochs({
+        rpcUrl: options.rpcUrl,
+        chainId: options.l1ChainId,
+        rollupAddress: options.rollup,
+        numEpochs: options.count,
+        log,
+        debugLogger,
+      });
+    });
+
+  program
+    .command('debug-rollup')
+    .description('Debugs the rollup contract.')
+    .requiredOption(
+      '-u, --rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .addOption(l1ChainIdOption)
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .action(async options => {
+      const { debugRollup } = await import('./update_l1_validators.js');
+      await debugRollup({
+        rpcUrl: options.rpcUrl,
+        chainId: options.l1ChainId,
+        privateKey: options.privateKey,
+        mnemonic: options.mnemonic,
+        rollupAddress: options.rollup,
+        log,
+        debugLogger,
+      });
+    });
+
+  program
+    .command('prune-rollup')
+    .description('Prunes the pending chain on the rollup contract.')
+    .requiredOption(
+      '-u, --rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .addOption(l1ChainIdOption)
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .action(async options => {
+      const { pruneRollup } = await import('./update_l1_validators.js');
+      await pruneRollup({
+        rpcUrl: options.rpcUrl,
+        chainId: options.l1ChainId,
+        privateKey: options.privateKey,
+        mnemonic: options.mnemonic,
+        rollupAddress: options.rollup,
+        log,
+        debugLogger,
+      });
+    });
+
+  program
+    .command('deploy-l1-verifier')
+    .description('Deploys the rollup verifier contract')
+    .requiredOption(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .addOption(
+      new Option('--l1-chain-id <string>', 'The chain id of the L1 network')
+        .env('L1_CHAIN_ID')
+        .default('31337')
+        .makeOptionMandatory(true),
+    )
+    .addOption(makePxeOption(false).conflicts('rollup-address'))
+    .addOption(
+      new Option('--rollup-address <string>', 'The address of the rollup contract')
+        .env('ROLLUP_CONTRACT_ADDRESS')
+        .argParser(parseEthereumAddress)
+        .conflicts('rpc-url'),
+    )
+    .option('--l1-private-key <string>', 'The L1 private key to use for deployment', PRIVATE_KEY)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .requiredOption('--verifier <verifier>', 'Either mock or real', 'real')
+    .option('--bb <path>', 'Path to bb binary', BB_BINARY_PATH)
+    .option('--bb-working-dir <path>', 'Path to bb working directory', BB_WORKING_DIRECTORY)
+    .action(async options => {
+      const { deployMockVerifier, deployUltraHonkVerifier } = await import('./deploy_l1_verifier.js');
+      if (options.verifier === 'mock') {
+        await deployMockVerifier(
+          options.rollupAddress?.toString(),
+          options.l1RpcUrl,
+          options.l1ChainId,
+          options.l1PrivateKey,
+          options.mnemonic,
+          options.rpcUrl,
+          log,
+          debugLogger,
+        );
+      } else {
+        await deployUltraHonkVerifier(
+          options.rollupAddress?.toString(),
+          options.l1RpcUrl,
+          options.l1ChainId,
+          options.l1PrivateKey,
+          options.mnemonic,
+          options.rpcUrl,
+          options.bb,
+          options.bbWorkingDir,
+          log,
+          debugLogger,
+        );
+      }
+    });
+
+  program
+    .command('bridge-erc20')
+    .description('Bridges ERC20 tokens to L2.')
+    .argument('<amount>', 'The amount of Fee Juice to mint and bridge.', parseBigint)
+    .argument('<recipient>', 'Aztec address of the recipient.', parseAztecAddress)
+    .requiredOption(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use for deriving the Ethereum address that will mint and bridge',
+      'test test test test test test test test test test test junk',
+    )
+    .option('--mint', 'Mint the tokens on L1', false)
+    .option('--private', 'If the bridge should use the private flow', false)
+    .addOption(l1ChainIdOption)
+    .requiredOption('-t, --token <string>', 'The address of the token to bridge', parseEthereumAddress)
+    .requiredOption('-p, --portal <string>', 'The address of the portal contract', parseEthereumAddress)
+    .option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .option('--json', 'Output the claim in JSON format')
+    .action(async (amount, recipient, options) => {
+      const { bridgeERC20 } = await import('./bridge_erc20.js');
+      await bridgeERC20(
+        amount,
+        recipient,
+        options.l1RpcUrl,
+        options.l1ChainId,
+        options.l1PrivateKey,
+        options.mnemonic,
+        options.token,
+        options.portal,
+        options.private,
+        options.mint,
+        options.json,
+        log,
+        debugLogger,
+      );
+    });
+
+  program
+    .command('create-l1-account')
+    .option('--json', 'Output the account in JSON format')
+    .action(async options => {
+      const { createL1Account } = await import('./create_l1_account.js');
+      createL1Account(options.json, log);
+    });
+
+  program
+    .command('get-l1-balance')
+    .description('Gets the balance of an ERC token in L1 for the given Ethereum address.')
+    .argument('<who>', 'Ethereum address to check.', parseEthereumAddress)
+    .requiredOption(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option('-t, --token <string>', 'The address of the token to check the balance of', parseEthereumAddress)
+    .addOption(l1ChainIdOption)
+    .option('--json', 'Output the balance in JSON format')
+    .action(async (who, options) => {
+      const { getL1Balance } = await import('./get_l1_balance.js');
+      await getL1Balance(who, options.token, options.l1RpcUrl, options.l1ChainId, options.json, log);
+    });
+
+  program
+    .command('set-proven-through', { hidden: true })
+    .description(
+      'Instructs the L1 rollup contract to assume all blocks until the given number are automatically proven.',
+    )
+    .argument('[blockNumber]', 'The target block number, defaults to the latest pending block number.', parseBigint)
+    .requiredOption(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .addOption(pxeOption)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use for deriving the Ethereum address that will mint and bridge',
+      'test test test test test test test test test test test junk',
+    )
+    .addOption(l1ChainIdOption)
+    .option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .action(async (blockNumber, options) => {
+      const { assumeProvenThrough } = await import('./assume_proven_through.js');
+      await assumeProvenThrough(
+        blockNumber,
+        options.l1RpcUrl,
+        options.rpcUrl,
+        options.l1ChainId,
+        options.l1PrivateKey,
+        options.mnemonic,
+        log,
+      );
+    });
+
+  program
+    .command('advance-epoch')
+    .description('Use L1 cheat codes to warp time until the next epoch.')
+    .requiredOption(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .addOption(pxeOption)
+    .action(async options => {
+      const { advanceEpoch } = await import('./advance_epoch.js');
+      await advanceEpoch(options.l1RpcUrl, options.rpcUrl, log);
+    });
+
+  program
+    .command('prover-stats', { hidden: true })
+    .requiredOption(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .addOption(l1ChainIdOption)
+    .option('--start-block <number>', 'The L1 block number to start from', parseBigint, 1n)
+    .option('--end-block <number>', 'The last L1 block number to query', parseBigint)
+    .option('--batch-size <number>', 'The number of blocks to query in each batch', parseBigint, 100n)
+    .option('--proving-timeout <number>', 'Cutoff for proving time to consider a block', parseBigint)
+    .option('--l1-rollup-address <string>', 'Address of the rollup contract (required if node URL is not set)')
+    .option(
+      '--node-url <string>',
+      'JSON RPC URL of an Aztec node to retrieve the rollup contract address (required if L1 rollup address is not set)',
+    )
+    .option('--raw-logs', 'Output raw logs instead of aggregated stats')
+    .action(async options => {
+      const { proverStats } = await import('./prover_stats.js');
+      const { l1RpcUrl, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } =
+        options;
+      await proverStats({
+        l1RpcUrl,
+        chainId,
+        l1RollupAddress,
+        startBlock,
+        endBlock,
+        batchSize,
+        nodeUrl,
+        provingTimeout,
+        rawLogs,
+        log,
+      });
+    });
+
+  return program;
+}