@aztec/cli 0.0.0-test.0

package/src/cmds/infrastructure/index.ts

@@ -0,0 +1,55 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseOptionalInteger, pxeOption } from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('setup-protocol-contracts')
+    .description('Bootstrap the blockchain by initializing all the protocol contracts')
+    .addOption(pxeOption)
+    .option('--testAccounts', 'Deploy funded test accounts.')
+    .option('--json', 'Output the contract addresses in JSON format')
+    .option('--skipProofWait', "Don't wait for proofs to land.")
+    .action(async options => {
+      const { setupL2Contracts } = await import('./setup_l2_contract.js');
+      await setupL2Contracts(options.rpcUrl, options.testAccounts, options.json, options.skipProofWait, log);
+    });
+
+  program
+    .command('sequencers')
+    .argument('<command>', 'Command to run: list, add, remove, who-next')
+    .argument('[who]', 'Who to add/remove')
+    .description('Manages or queries registered sequencers on the L1 rollup contract.')
+    .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(
+      '-m, --mnemonic <string>',
+      'The mnemonic for the sender of the tx',
+      'test test test test test test test test test test test junk',
+    )
+    .option('--block-number <number>', 'Block number to query next sequencer for', parseOptionalInteger)
+    .addOption(pxeOption)
+    .addOption(l1ChainIdOption)
+    .action(async (command, who, options) => {
+      const { sequencers } = await import('./sequencers.js');
+      await sequencers({
+        command: command,
+        who,
+        mnemonic: options.mnemonic,
+        rpcUrl: options.rpcUrl,
+        l1RpcUrls: options.l1RpcUrls.split(','),
+        chainId: options.l1ChainId,
+        blockNumber: options.blockNumber,
+        log,
+        debugLogger,
+      });
+    });
+
+  return program;
+}

package/src/cmds/infrastructure/sequencers.ts

@@ -0,0 +1,103 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+
+export async function sequencers(opts: {
+  command: 'list' | 'add' | 'remove' | 'who-next';
+  who?: string;
+  mnemonic?: string;
+  rpcUrl: string;
+  l1RpcUrls: string[];
+  chainId: number;
+  blockNumber?: number;
+  log: LogFn;
+  debugLogger: Logger;
+}) {
+  const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrls, chainId, log, debugLogger } = opts;
+  const client = await createCompatibleClient(rpcUrl, debugLogger);
+  const { l1ContractAddresses } = await client.getNodeInfo();
+
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(l1RpcUrls.map(url => http(url))),
+  });
+
+  const walletClient = mnemonic
+    ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map(url => http(url))),
+      })
+    : undefined;
+
+  const rollup = getContract({
+    address: l1ContractAddresses.rollupAddress.toString(),
+    abi: RollupAbi,
+    client: publicClient,
+  });
+
+  const writeableRollup = walletClient
+    ? getContract({
+        address: l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient,
+      })
+    : undefined;
+
+  const who = (maybeWho as `0x{string}`) ?? walletClient?.account.address.toString();
+
+  if (command === 'list') {
+    const sequencers = await rollup.read.getAttesters();
+    if (sequencers.length === 0) {
+      log(`No sequencers registered on rollup`);
+    } else {
+      log(`Registered sequencers on rollup:`);
+      for (const sequencer of sequencers) {
+        log(' ' + sequencer.toString());
+      }
+    }
+  } else if (command === 'add') {
+    if (!who || !writeableRollup || !walletClient) {
+      throw new Error(`Missing sequencer address`);
+    }
+
+    log(`Adding ${who} as sequencer`);
+
+    const stakingAsset = getContract({
+      address: await rollup.read.getStakingAsset(),
+      abi: TestERC20Abi,
+      client: walletClient,
+    });
+
+    const config = getL1ContractsConfigEnvVars();
+
+    await Promise.all(
+      [
+        await stakingAsset.write.mint([walletClient.account.address, config.minimumStake], {} as any),
+        await stakingAsset.write.approve([rollup.address, config.minimumStake], {} as any),
+      ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
+    );
+
+    const hash = await writeableRollup.write.deposit([who, who, who, config.minimumStake]);
+    await publicClient.waitForTransactionReceipt({ hash });
+    log(`Added in tx ${hash}`);
+  } else if (command === 'remove') {
+    if (!who || !writeableRollup) {
+      throw new Error(`Missing sequencer address`);
+    }
+    log(`Removing ${who} as sequencer`);
+    const hash = await writeableRollup.write.initiateWithdraw([who, who]);
+    await publicClient.waitForTransactionReceipt({ hash });
+    log(`Removed in tx ${hash}`);
+  } else if (command === 'who-next') {
+    const next = await rollup.read.getCurrentProposer();
+    log(`Sequencer expected to build is ${next}`);
+  } else {
+    throw new Error(`Unknown command ${command}`);
+  }
+}

package/src/cmds/infrastructure/setup_l2_contract.ts

@@ -0,0 +1,47 @@
+import { type InitialAccountData, deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { type AztecAddress, SignerlessWallet, type WaitOpts, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { LogFn } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+import { setupCanonicalL2FeeJuice } from '../misc/setup_contracts.js';
+
+export async function setupL2Contracts(
+  rpcUrl: string,
+  testAccounts: boolean,
+  json: boolean,
+  skipProofWait: boolean,
+  log: LogFn,
+) {
+  const waitOpts: WaitOpts = {
+    timeout: 180,
+    interval: 1,
+    proven: !skipProofWait,
+    provenTimeout: 600,
+  };
+  log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
+  log('setupL2Contracts: Creating PXE client...');
+  const pxe = createPXEClient(rpcUrl, {}, makeFetch([1, 1, 1, 1, 1], false));
+  const wallet = new SignerlessWallet(pxe);
+
+  log('setupL2Contracts: Getting fee juice portal address...');
+  // Deploy Fee Juice
+  const feeJuicePortalAddress = (await wallet.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
+  log('setupL2Contracts: Setting up fee juice portal...');
+  await setupCanonicalL2FeeJuice(wallet, feeJuicePortalAddress, waitOpts, log);
+
+  let deployedAccounts: InitialAccountData[] = [];
+  if (testAccounts) {
+    log('setupL2Contracts: Deploying test accounts...');
+    deployedAccounts = await getInitialTestAccounts();
+    await deployFundedSchnorrAccounts(pxe, deployedAccounts, waitOpts);
+  }
+
+  if (json) {
+    const toPrint: Record<string, AztecAddress> = { ...ProtocolContractAddress };
+    deployedAccounts.forEach((a, i) => {
+      toPrint[`testAccount${i}`] = a.address;
+    });
+    log(JSON.stringify(toPrint, null, 2));
+  }
+}

package/src/cmds/l1/advance_epoch.ts

@@ -0,0 +1,12 @@
+import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function advanceEpoch(l1RpcUrls: string[], rpcUrl: string, log: LogFn) {
+  const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
+  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+
+  const cheat = CheatCodes.createRollup(l1RpcUrls, { rollupAddress });
+
+  await cheat.advanceToNextEpoch();
+  log(`Warped time to advance to next epoch`);
+}

package/src/cmds/l1/assume_proven_through.ts

@@ -0,0 +1,19 @@
+import { EthCheatCodes, RollupCheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function assumeProvenThrough(
+  blockNumberOrLatest: number | undefined,
+  l1RpcUrls: string[],
+  rpcUrl: string,
+  log: LogFn,
+) {
+  const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
+  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+  const blockNumber = blockNumberOrLatest ?? (await pxe.getBlockNumber());
+
+  const ethCheatCode = new EthCheatCodes(l1RpcUrls);
+  const rollupCheatCodes = new RollupCheatCodes(ethCheatCode, { rollupAddress });
+
+  await rollupCheatCodes.markAsProven(blockNumber);
+  log(`Assumed proven through block ${blockNumber}`);
+}

package/src/cmds/l1/bridge_erc20.ts

@@ -0,0 +1,52 @@
+import { type AztecAddress, type EthAddress, type Fr, L1ToL2TokenPortalManager } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function bridgeERC20(
+  amount: bigint,
+  recipient: AztecAddress,
+  l1RpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  tokenAddress: EthAddress,
+  portalAddress: EthAddress,
+  privateTransfer: boolean,
+  mint: boolean,
+  json: boolean,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  // Prepare L1 client
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+
+  // Setup portal manager
+  const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, publicClient, walletClient, debugLogger);
+  let claimSecret: Fr;
+  let messageHash: `0x${string}`;
+  if (privateTransfer) {
+    ({ claimSecret, messageHash } = await manager.bridgeTokensPrivate(recipient, amount, mint));
+  } else {
+    ({ claimSecret, messageHash } = await manager.bridgeTokensPublic(recipient, amount, mint));
+  }
+
+  if (json) {
+    log(
+      prettyPrintJSON({
+        claimAmount: amount,
+        claimSecret: claimSecret,
+      }),
+    );
+  } else {
+    if (mint) {
+      log(`Minted ${amount} tokens on L1 and pushed to L2 portal`);
+    } else {
+      log(`Bridged ${amount} tokens to L2 portal`);
+    }
+    log(`claimAmount=${amount},claimSecret=${claimSecret}\n,messageHash=${messageHash}`);
+    log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+  }
+}

package/src/cmds/l1/create_l1_account.ts

@@ -0,0 +1,17 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export function createL1Account(json: boolean, log: LogFn) {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+
+  if (json) {
+    log(prettyPrintJSON({ privateKey, address: account.address }));
+  } else {
+    log(`Private Key: ${privateKey}`);
+    log(`Address: ${account.address}`);
+  }
+}

package/src/cmds/l1/deploy_l1_contracts.ts

@@ -0,0 +1,65 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { deployAztecContracts } from '../../utils/aztec.js';
+
+export async function deployL1Contracts(
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  salt: number | undefined,
+  testAccounts: boolean,
+  acceleratedTestDeployments: boolean,
+  json: boolean,
+  initialValidators: EthAddress[],
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
+  const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+
+  const { l1ContractAddresses } = await deployAztecContracts(
+    rpcUrls,
+    chainId,
+    privateKey,
+    mnemonic,
+    mnemonicIndex,
+    salt,
+    initialValidators,
+    genesisArchiveRoot,
+    genesisBlockHash,
+    acceleratedTestDeployments,
+    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, 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,
+  ethRpcUrls: 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(
+    ethRpcUrls,
+    privateKey ?? mnemonic,
+    createEthereumChain(ethRpcUrls, 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,
+  ethRpcUrls: string[],
+  l1ChainId: string,
+  privateKey: string | undefined,
+  mnemonic: string,
+  pxeRpcUrl: string,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const { publicClient, walletClient } = createL1Clients(
+    ethRpcUrls,
+    privateKey ?? mnemonic,
+    createEthereumChain(ethRpcUrls, 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/deploy_new_rollup.ts

@@ -0,0 +1,58 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { deployNewRollupContracts } from '../../utils/aztec.js';
+
+export async function deployNewRollup(
+  registryAddress: EthAddress,
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  salt: number | undefined,
+  testAccounts: boolean,
+  json: boolean,
+  initialValidators: EthAddress[],
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
+  const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+
+  const { payloadAddress, rollup } = await deployNewRollupContracts(
+    registryAddress,
+    rpcUrls,
+    chainId,
+    privateKey,
+    mnemonic,
+    mnemonicIndex,
+    salt,
+    initialValidators,
+    genesisArchiveRoot,
+    genesisBlockHash,
+    config,
+    debugLogger,
+  );
+
+  if (json) {
+    log(
+      JSON.stringify(
+        {
+          payloadAddress: payloadAddress.toString(),
+          rollupAddress: rollup.address,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Payload Address: ${payloadAddress.toString()}`);
+    log(`Rollup Address: ${rollup.address}`);
+  }
+}

package/src/cmds/l1/get_l1_addresses.ts

@@ -0,0 +1,30 @@
+import { EthAddress } from '@aztec/aztec.js';
+import { RegistryContract, type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { createPublicClient, fallback, http } from 'viem';
+
+export async function getL1Addresses(
+  registryAddress: EthAddress,
+  rollupVersion: number | bigint | 'canonical',
+  rpcUrls: string[],
+  chainId: number,
+  json: boolean,
+  log: LogFn,
+) {
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const publicClient: ViemPublicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(rpcUrls.map(url => http(url))),
+    pollingInterval: 100,
+  });
+  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress.toString(), rollupVersion);
+
+  if (json) {
+    log(JSON.stringify(addresses, null, 2));
+  } else {
+    for (const [key, value] of Object.entries(addresses)) {
+      log(`${key}: ${value.toString()}`);
+    }
+  }
+}

package/src/cmds/l1/get_l1_balance.ts

@@ -0,0 +1,44 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+import { TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createPublicClient, fallback, getContract, http } from 'viem';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function getL1Balance(
+  who: EthAddress,
+  token: EthAddress | undefined,
+  l1RpcUrls: string[],
+  chainId: number,
+  json: boolean,
+  log: LogFn,
+) {
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(l1RpcUrls.map(url => http(url))),
+  });
+
+  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()}`);
+  }
+}