@aztec/cli 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/cmds/l1/deploy_l1_contracts_cmd.ts

@@ -0,0 +1,107 @@
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { type Operator, deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { SecretValue } from '@aztec/foundation/config';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { mnemonicToAccount } from 'viem/accounts';
+
+import { addLeadingHex } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
+
+export async function deployL1ContractsCmd(
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  testAccounts: boolean,
+  sponsoredFPC: boolean,
+  json: boolean,
+  initialValidators: EthAddress[],
+  realVerifier: boolean,
+  existingToken: EthAddress | undefined,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  // Compute initial accounts for genesis (test accounts + sponsored FPC)
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+  const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+  const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
+  const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
+
+  // Get the VK tree root
+  const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
+  const vkTreeRoot = getVKTreeRoot();
+
+  // Get private key (from direct input or mnemonic)
+  let deployerPrivateKey: `0x${string}`;
+  if (privateKey) {
+    deployerPrivateKey = addLeadingHex(privateKey);
+  } else {
+    const account = mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex });
+    deployerPrivateKey = `0x${Buffer.from(account.getHdKey().privateKey!).toString('hex')}`;
+  }
+
+  // Prepare validator operators with bn254 keys
+  const initialValidatorOperators: Operator[] = initialValidators.map(a => ({
+    attester: a,
+    withdrawer: a,
+    bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+  }));
+
+  debugLogger.info('Deploying L1 contracts via Forge...');
+
+  // Deploy using l1-contracts Forge scripts
+  const { l1ContractAddresses, rollupVersion } = await deployAztecL1Contracts(rpcUrls[0], deployerPrivateKey, chainId, {
+    // Initial validators to add during deployment
+    initialValidators: initialValidatorOperators,
+    // Genesis config
+    vkTreeRoot,
+    protocolContractsHash,
+    genesisArchiveRoot,
+    // Deployment options
+    realVerifier,
+    ...config,
+    feeJuicePortalInitialBalance: fundingNeeded,
+    existingTokenAddress: existingToken,
+  });
+
+  debugLogger.info('Forge deployment complete', { rollupVersion });
+
+  if (json) {
+    log(
+      JSON.stringify(
+        Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v]) => [k, v?.toString() ?? 'Not deployed'])),
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+    log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+    log(`GSE Address: ${l1ContractAddresses.gseAddress?.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()}`);
+    log(`FeeAssetHandler Address: ${l1ContractAddresses.feeAssetHandlerAddress?.toString()}`);
+    log(`StakingAssetHandler Address: ${l1ContractAddresses.stakingAssetHandlerAddress?.toString()}`);
+    log(`ZK Passport Verifier Address: ${l1ContractAddresses.zkPassportVerifierAddress?.toString()}`);
+    log(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+    log(`Initial validators: ${initialValidators.map(a => a.toString()).join(', ')}`);
+    log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+  }
+}

package/src/cmds/l1/deploy_new_rollup.ts

@@ -1,10 +1,12 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { deployNewRollupContracts } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
 
 export async function deployNewRollup(
   registryAddress: EthAddress,
@@ -13,46 +15,53 @@ export async function deployNewRollup(
   privateKey: string | undefined,
   mnemonic: string,
   mnemonicIndex: number,
-  salt: number | undefined,
   testAccounts: boolean,
+  sponsoredFPC: boolean,
   json: boolean,
-  initialValidators: EthAddress[],
+  initialValidators: Operator[],
+  realVerifier: boolean,
   log: LogFn,
-  debugLogger: Logger,
 ) {
   const config = getL1ContractsConfigEnvVars();
 
-  const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
-  const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+  const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+  const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
+  const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
 
-  const { payloadAddress, rollup } = await deployNewRollupContracts(
+  const { rollup, slashFactoryAddress } = await deployNewRollupContracts(
     registryAddress,
     rpcUrls,
-    chainId,
     privateKey,
+    chainId,
     mnemonic,
     mnemonicIndex,
-    salt,
     initialValidators,
     genesisArchiveRoot,
-    genesisBlockHash,
+    fundingNeeded,
     config,
-    debugLogger,
+    realVerifier,
   );
 
   if (json) {
     log(
       JSON.stringify(
         {
-          payloadAddress: payloadAddress.toString(),
           rollupAddress: rollup.address,
+          initialFundedAccounts: initialFundedAccounts.map(a => a.toString()),
+          initialValidators: initialValidators.map(a => a.attester.toString()),
+          genesisArchiveRoot: genesisArchiveRoot.toString(),
+          slashFactoryAddress: slashFactoryAddress.toString(),
         },
         null,
         2,
       ),
     );
   } else {
-    log(`Payload Address: ${payloadAddress.toString()}`);
     log(`Rollup Address: ${rollup.address}`);
+    log(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+    log(`Initial validators: ${initialValidators.map(a => a.attester.toString()).join(', ')}`);
+    log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+    log(`Slash Factory Address: ${slashFactoryAddress.toString()}`);
   }
 }

package/src/cmds/l1/get_l1_addresses.ts

@@ -1,5 +1,7 @@
-import { EthAddress } from '@aztec/aztec.js';
-import { RegistryContract, type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { RegistryContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
 import type { LogFn } from '@aztec/foundation/log';
 
 import { createPublicClient, fallback, http } from 'viem';
@@ -15,7 +17,7 @@ export async function getL1Addresses(
   const chain = createEthereumChain(rpcUrls, chainId);
   const publicClient: ViemPublicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(rpcUrls.map(url => http(url))),
+    transport: fallback(rpcUrls.map(url => http(url, { batch: false }))),
     pollingInterval: 100,
   });
   const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress.toString(), rollupVersion);

package/src/cmds/l1/get_l1_balance.ts

@@ -1,4 +1,4 @@
-import { createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn } from '@aztec/foundation/log';
 import { TestERC20Abi } from '@aztec/l1-artifacts';
@@ -18,7 +18,7 @@ export async function getL1Balance(
   const chain = createEthereumChain(l1RpcUrls, chainId);
   const publicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(l1RpcUrls.map(url => http(url))),
+    transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
   });
 
   let balance = 0n;

package/src/cmds/l1/governance_utils.ts

@@ -1,11 +1,6 @@
-import {
-  FeeJuiceContract,
-  GovernanceContract,
-  ProposalState,
-  RegistryContract,
-  createEthereumChain,
-  createL1Clients,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract } from '@aztec/ethereum/contracts';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
 export async function depositGovernanceTokens({
@@ -33,19 +28,20 @@ export async function depositGovernanceTokens({
 }) {
   debugLogger.info(`Depositing ${amount} governance tokens to ${recipient}`);
   const chain = createEthereumChain(rpcUrls, chainId);
-  const { publicClient, walletClient } = createL1Clients(
+  const extendedClient = createExtendedL1Client(
     rpcUrls,
     privateKey ?? mnemonic,
     chain.chainInfo,
+    undefined,
     mnemonicIndex,
   );
 
-  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, 'canonical');
+  const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
   const governanceAddress = addresses.governanceAddress.toString();
-  const tokenAddress = addresses.feeJuiceAddress.toString();
+  const tokenAddress = addresses.stakingAssetAddress.toString();
 
-  const feeJuice = new FeeJuiceContract(tokenAddress, publicClient, walletClient);
-  const governance = new GovernanceContract(governanceAddress, publicClient, walletClient);
+  const feeJuice = new FeeJuiceContract(tokenAddress, extendedClient);
+  const governance = new GovernanceContract(governanceAddress, extendedClient);
   if (mint) {
     await feeJuice.mint(recipient, amount);
     debugLogger.info(`Minted ${amount} tokens to ${recipient}`);
@@ -83,19 +79,19 @@ export async function proposeWithLock({
 }) {
   debugLogger.info(`Proposing with lock from ${payloadAddress} to ${registryAddress}`);
   const chain = createEthereumChain(rpcUrls, chainId);
-  const clients = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+  const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
 
-  const addresses = await RegistryContract.collectAddresses(clients.publicClient, registryAddress, 'canonical');
+  const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
   const governanceAddress = addresses.governanceAddress.toString();
 
-  const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+  const governance = new GovernanceContract(governanceAddress, client);
 
   const proposalId = await governance.proposeWithLock({
     payloadAddress,
-    withdrawAddress: clients.walletClient.account.address,
+    withdrawAddress: client.account.address,
   });
   if (json) {
-    log(JSON.stringify({ proposalId }, null, 2));
+    log(JSON.stringify({ proposalId: Number(proposalId) }, null, 2));
   } else {
     log(`Proposed with lock`);
     log(`Proposal ID: ${proposalId}`);
@@ -131,12 +127,12 @@ export async function voteOnGovernanceProposal({
     `Voting on proposal ${proposalId} with ${voteAmount ? voteAmount : 'all'} tokens in favor: ${inFavor}`,
   );
   const chain = createEthereumChain(rpcUrls, chainId);
-  const clients = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+  const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
 
-  const addresses = await RegistryContract.collectAddresses(clients.publicClient, registryAddress, 'canonical');
+  const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
   const governanceAddress = addresses.governanceAddress.toString();
 
-  const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+  const governance = new GovernanceContract(governanceAddress, client);
   const state = await governance.getProposalState(proposalId);
   if (state !== ProposalState.Active && !waitTilActive) {
     debugLogger.warn(`Proposal is not active, but waitTilActive is false. Not voting.`);
@@ -170,12 +166,12 @@ export async function executeGovernanceProposal({
 }) {
   debugLogger.info(`Executing proposal ${proposalId}`);
   const chain = createEthereumChain(rpcUrls, chainId);
-  const clients = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+  const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
 
-  const addresses = await RegistryContract.collectAddresses(clients.publicClient, registryAddress, 'canonical');
+  const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
   const governanceAddress = addresses.governanceAddress.toString();
 
-  const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+  const governance = new GovernanceContract(governanceAddress, client);
   const state = await governance.getProposalState(proposalId);
   if (state !== ProposalState.Executable && !waitTilExecutable) {
     debugLogger.warn(`Proposal is not executable, but waitTilExecutable is false. Not executing.`);

package/src/cmds/l1/index.ts

@@ -1,3 +1,4 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
@@ -5,13 +6,13 @@ import { type Command, Option } from 'commander';
 
 import {
   ETHEREUM_HOSTS,
+  MNEMONIC,
   PRIVATE_KEY,
   l1ChainIdOption,
-  makePxeOption,
+  nodeOption,
   parseAztecAddress,
   parseBigint,
   parseEthereumAddress,
-  pxeOption,
 } from '../../utils/commands.js';
 
 const l1RpcUrlsOption = new Option(
@@ -23,9 +24,9 @@ const l1RpcUrlsOption = new Option(
   .makeOptionMandatory(true)
   .argParser((arg: string) => arg.split(',').map(url => url.trim()));
 
-export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
-  const { BB_BINARY_PATH, BB_WORKING_DIRECTORY } = process.env;
+const networkOption = new Option('--network <string>', 'Network to execute against').env('NETWORK');
 
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
   program
     .command('deploy-l1-contracts')
     .description('Deploys all necessary Ethereum contracts for Aztec.')
@@ -39,26 +40,28 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     )
     .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')
     .option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts')
-    .option('--accelerated-test-deployments', 'Fire and forget deployment transactions, use in testing only', false)
+    .option('--sponsored-fpc', 'Populate genesis state with a testing sponsored FPC contract')
+    .option('--real-verifier', 'Deploy the real verifier', false)
+    .option('--existing-token <address>', 'Use an existing ERC20 for both fee and staking', parseEthereumAddress)
     .action(async options => {
-      const { deployL1Contracts } = await import('./deploy_l1_contracts.js');
+      const { deployL1ContractsCmd } = await import('./deploy_l1_contracts_cmd.js');
 
       const initialValidators =
         options.validators?.split(',').map((validator: string) => EthAddress.fromString(validator)) || [];
-      await deployL1Contracts(
+      await deployL1ContractsCmd(
         options.l1RpcUrls,
         options.l1ChainId,
         options.privateKey,
         options.mnemonic,
         options.mnemonicIndex,
-        options.salt,
         options.testAccounts,
-        options.acceleratedTestDeployments,
+        options.sponsoredFpc,
         options.json,
         initialValidators,
+        options.realVerifier,
+        options.existingToken,
         log,
         debugLogger,
       );
@@ -66,7 +69,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
 
   program
     .command('deploy-new-rollup')
-    .description('Deploys a new rollup contract and a payload to upgrade the registry with it.')
+    .description('Deploys a new rollup contract and adds it to the registry (if you are the owner).')
     .requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress)
     .addOption(l1RpcUrlsOption)
     .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
@@ -74,13 +77,14 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .option(
       '-m, --mnemonic <string>',
       'The mnemonic to use in deployment',
-      'test test test test test test test test test test test junk',
+      MNEMONIC ?? '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')
     .option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts')
+    .option('--sponsored-fpc', 'Populate genesis state with a testing sponsored FPC contract')
+    .option('--real-verifier', 'Deploy the real verifier', false)
     .action(async options => {
       const { deployNewRollup } = await import('./deploy_new_rollup.js');
 
@@ -93,15 +97,25 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.privateKey,
         options.mnemonic,
         options.mnemonicIndex,
-        options.salt,
         options.testAccounts,
+        options.sponsoredFpc,
         options.json,
         initialValidators,
+        options.realVerifier,
         log,
-        debugLogger,
       );
     });
 
+  program
+    .command('compute-genesis-values')
+    .description('Computes genesis values (VK tree root, protocol contracts hash, genesis archive root).')
+    .addOption(new Option('--test-accounts', 'Include initial test accounts in genesis state').env('TEST_ACCOUNTS'))
+    .addOption(new Option('--sponsored-fpc', 'Include sponsored FPC contract in genesis state').env('SPONSORED_FPC'))
+    .action(async options => {
+      const { computeGenesisValuesCmd } = await import('./compute_genesis_values.js');
+      await computeGenesisValuesCmd(options.testAccounts, options.sponsoredFpc, log);
+    });
+
   program
     .command('deposit-governance-tokens')
     .description('Deposits governance tokens to the governance contract.')
@@ -274,28 +288,44 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
 
   program
     .command('add-l1-validator')
-    .description('Adds a validator to the L1 rollup contract.')
+    .description('Adds a validator to the L1 rollup contract via a direct deposit.')
     .addOption(l1RpcUrlsOption)
-    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .addOption(networkOption)
+    .option('-pk, --private-key <string>', 'The private key to use sending the transaction', PRIVATE_KEY)
     .option(
       '-m, --mnemonic <string>',
-      'The mnemonic to use in deployment',
+      'The mnemonic to use sending the transaction',
       '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('--attester <address>', 'ethereum address of the attester', parseEthereumAddress)
     .option('--withdrawer <address>', 'ethereum address of the withdrawer', parseEthereumAddress)
+    .option(
+      '--bls-secret-key <string>',
+      'The BN254 scalar field element used as a secret key for BLS signatures. Will be associated with the attester address.',
+      parseBigint,
+    )
+    .option('--move-with-latest-rollup', 'Whether to move with the latest rollup', true)
+    .option('--rollup <string>', 'Rollup contract address', parseEthereumAddress)
     .action(async options => {
-      const { addL1Validator } = await import('./update_l1_validators.js');
-      await addL1Validator({
+      const { addL1ValidatorViaRollup } = await import('./update_l1_validators.js');
+
+      let rollupAddress = options.rollup;
+      if (!rollupAddress) {
+        const { getL1RollupAddressFromEnv } = await import('../../config/get_l1_config.js');
+        rollupAddress = await getL1RollupAddressFromEnv(options.l1RpcUrls, options.l1ChainId);
+      }
+
+      await addL1ValidatorViaRollup({
         rpcUrls: options.l1RpcUrls,
         chainId: options.l1ChainId,
         privateKey: options.privateKey,
         mnemonic: options.mnemonic,
-        validatorAddress: options.validator,
-        rollupAddress: options.rollup,
+        attesterAddress: options.attester,
+        blsSecretKey: options.blsSecretKey,
         withdrawerAddress: options.withdrawer,
+        rollupAddress,
+        moveWithLatestRollup: options.moveWithLatestRollup,
         log,
         debugLogger,
       });
@@ -347,6 +377,30 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
       });
     });
 
+  program
+    .command('trigger-seed-snapshot')
+    .description('Triggers a seed snapshot for the next epoch.')
+    .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',
+    )
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .addOption(l1RpcUrlsOption)
+    .addOption(l1ChainIdOption)
+    .action(async options => {
+      const { triggerSeedSnapshot } = await import('./trigger_seed_snapshot.js');
+      await triggerSeedSnapshot({
+        rollupAddress: options.rollup,
+        rpcUrls: options.l1RpcUrls,
+        chainId: options.l1ChainId,
+        privateKey: options.privateKey,
+        mnemonic: options.mnemonic,
+        log,
+      });
+    });
+
   program
     .command('debug-rollup')
     .description('Debugs the rollup contract.')
@@ -391,56 +445,6 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
       });
     });
 
-  program
-    .command('deploy-l1-verifier')
-    .description('Deploys the rollup verifier contract')
-    .addOption(l1RpcUrlsOption)
-    .addOption(l1ChainIdOption)
-    .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.l1RpcUrls,
-          options.l1ChainId,
-          options.l1PrivateKey,
-          options.mnemonic,
-          options.rpcUrl,
-          log,
-          debugLogger,
-        );
-      } else {
-        await deployUltraHonkVerifier(
-          options.rollupAddress?.toString(),
-          options.l1RpcUrls,
-          options.l1ChainId,
-          options.l1PrivateKey,
-          options.mnemonic,
-          options.rpcUrl,
-          options.bb,
-          options.bbWorkingDir,
-          log,
-          debugLogger,
-        );
-      }
-    });
-
   program
     .command('bridge-erc20')
     .description('Bridges ERC20 tokens to L2.')
@@ -457,6 +461,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .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('-f, --faucet <string>', 'The address of the faucet contract (only used if minting)', 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) => {
@@ -469,6 +474,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.l1PrivateKey,
         options.mnemonic,
         options.token,
+        options.faucet,
         options.portal,
         options.private,
         options.mint,
@@ -502,56 +508,24 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
   program
     .command('set-proven-through', { hidden: true })
     .description(
-      'Instructs the L1 rollup contract to assume all blocks until the given number are automatically proven.',
+      'Instructs the L1 rollup contract to assume all blocks until the given checkpoint are automatically proven.',
     )
-    .argument('[blockNumber]', 'The target block number, defaults to the latest pending block number.', parseBigint)
+    .argument('[checkpoint]', 'The target checkpoint, defaults to the latest pending checkpoint.', parseBigint)
     .addOption(l1RpcUrlsOption)
-    .addOption(pxeOption)
-    .action(async (blockNumber, options) => {
+    .addOption(nodeOption)
+    .action(async (checkpoint, options) => {
       const { assumeProvenThrough } = await import('./assume_proven_through.js');
-      await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.rpcUrl, log);
+      await assumeProvenThrough(CheckpointNumber.fromBigInt(checkpoint), options.l1RpcUrls, options.nodeUrl, log);
     });
 
   program
     .command('advance-epoch')
     .description('Use L1 cheat codes to warp time until the next epoch.')
     .addOption(l1RpcUrlsOption)
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .action(async options => {
       const { advanceEpoch } = await import('./advance_epoch.js');
-      await advanceEpoch(options.l1RpcUrls, options.rpcUrl, log);
-    });
-
-  program
-    .command('prover-stats', { hidden: true })
-    .addOption(l1RpcUrlsOption)
-    .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 { l1RpcUrls, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } =
-        options;
-      await proverStats({
-        l1RpcUrls,
-        chainId,
-        l1RollupAddress,
-        startBlock,
-        endBlock,
-        batchSize,
-        nodeUrl,
-        provingTimeout,
-        rawLogs,
-        log,
-      });
+      await advanceEpoch(options.l1RpcUrls, options.nodeUrl, log);
     });
 
   return program;