@aztec/cli 0.0.0-test.0 → 0.0.1-fake-c83136db25

package/src/cmds/l1/advance_epoch.ts

@@ -1,11 +1,13 @@
-import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { RollupCheatCodes } from '@aztec/ethereum/test';
 import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 
-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);
+export async function advanceEpoch(l1RpcUrls: string[], nodeUrl: string, log: LogFn) {
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const rollupAddress = await aztecNode.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
 
-  const cheat = CheatCodes.createRollup(l1RpcUrls, { rollupAddress });
+  const cheat = RollupCheatCodes.create(l1RpcUrls, { rollupAddress }, new DateProvider());
 
   await cheat.advanceToNextEpoch();
   log(`Warped time to advance to next epoch`);

package/src/cmds/l1/assume_proven_through.ts

@@ -1,18 +1,19 @@
-import { EthCheatCodes, RollupCheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { RollupCheatCodes } from '@aztec/ethereum/test';
 import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 
 export async function assumeProvenThrough(
   blockNumberOrLatest: number | undefined,
   l1RpcUrls: string[],
-  rpcUrl: string,
+  nodeUrl: 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 aztecNode = createAztecNodeClient(nodeUrl);
+  const rollupAddress = await aztecNode.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+  const blockNumber = blockNumberOrLatest ?? (await aztecNode.getBlockNumber());
 
-  const ethCheatCode = new EthCheatCodes(l1RpcUrls);
-  const rollupCheatCodes = new RollupCheatCodes(ethCheatCode, { rollupAddress });
+  const rollupCheatCodes = RollupCheatCodes.create(l1RpcUrls, { rollupAddress }, new DateProvider());
 
   await rollupCheatCodes.markAsProven(blockNumber);
   log(`Assumed proven through block ${blockNumber}`);

package/src/cmds/l1/bridge_erc20.ts

@@ -1,5 +1,7 @@
-import { type AztecAddress, type EthAddress, type Fr, L1ToL2TokenPortalManager } from '@aztec/aztec.js';
-import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import type { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { L1ToL2TokenPortalManager } from '@aztec/aztec.js/ethereum';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
 import { prettyPrintJSON } from '../../utils/commands.js';
@@ -12,6 +14,7 @@ export async function bridgeERC20(
   privateKey: string | undefined,
   mnemonic: string,
   tokenAddress: EthAddress,
+  handlerAddress: EthAddress | undefined,
   portalAddress: EthAddress,
   privateTransfer: boolean,
   mint: boolean,
@@ -21,10 +24,10 @@ export async function bridgeERC20(
 ) {
   // Prepare L1 client
   const chain = createEthereumChain(l1RpcUrls, chainId);
-  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+  const l1Client = createExtendedL1Client(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
 
   // Setup portal manager
-  const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, publicClient, walletClient, debugLogger);
+  const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, handlerAddress, l1Client, debugLogger);
   let claimSecret: Fr;
   let messageHash: `0x${string}`;
   if (privateTransfer) {

package/src/cmds/l1/deploy_l1_contracts.ts

@@ -1,10 +1,13 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
+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';
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { SecretValue } from '@aztec/foundation/config';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { deployAztecContracts } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
 
 export async function deployL1Contracts(
   rpcUrls: string[],
@@ -14,16 +17,28 @@ export async function deployL1Contracts(
   mnemonicIndex: number,
   salt: number | undefined,
   testAccounts: boolean,
+  sponsoredFPC: boolean,
   acceleratedTestDeployments: boolean,
   json: boolean,
+  createVerificationJson: string | false,
   initialValidators: EthAddress[],
+  realVerifier: boolean,
+  existingToken: EthAddress | undefined,
   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 initialValidatorOperators = initialValidators.map(a => ({
+    attester: a,
+    withdrawer: a,
+    bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+  }));
 
   const { l1ContractAddresses } = await deployAztecContracts(
     rpcUrls,
@@ -32,18 +47,21 @@ export async function deployL1Contracts(
     mnemonic,
     mnemonicIndex,
     salt,
-    initialValidators,
+    initialValidatorOperators,
     genesisArchiveRoot,
-    genesisBlockHash,
+    fundingNeeded,
     acceleratedTestDeployments,
     config,
+    existingToken,
+    realVerifier,
+    createVerificationJson,
     debugLogger,
   );
 
   if (json) {
     log(
       JSON.stringify(
-        Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v]) => [k, v.toString()])),
+        Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v]) => [k, v?.toString() ?? 'Not deployed'])),
         null,
         2,
       ),
@@ -51,6 +69,7 @@ export async function deployL1Contracts(
   } 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()}`);
@@ -61,5 +80,11 @@ export async function deployL1Contracts(
     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,11 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { type Operator, 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';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
 
 export async function deployNewRollup(
   registryAddress: EthAddress,
@@ -15,17 +16,22 @@ export async function deployNewRollup(
   mnemonicIndex: number,
   salt: number | undefined,
   testAccounts: boolean,
+  sponsoredFPC: boolean,
   json: boolean,
-  initialValidators: EthAddress[],
+  initialValidators: Operator[],
+  realVerifier: boolean,
+  createVerificationJson: string | false,
   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,
@@ -35,8 +41,10 @@ export async function deployNewRollup(
     salt,
     initialValidators,
     genesisArchiveRoot,
-    genesisBlockHash,
+    fundingNeeded,
     config,
+    realVerifier,
+    createVerificationJson,
     debugLogger,
   );
 
@@ -44,15 +52,21 @@ export async function deployNewRollup(
     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,4 +1,4 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { RegistryContract, type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
 import type { LogFn } from '@aztec/foundation/log';
 

package/src/cmds/l1/governance_utils.ts

@@ -4,7 +4,7 @@ import {
   ProposalState,
   RegistryContract,
   createEthereumChain,
-  createL1Clients,
+  createExtendedL1Client,
 } from '@aztec/ethereum';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
@@ -33,19 +33,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 +84,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 +132,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 +171,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

@@ -3,17 +3,20 @@ import type { LogFn, Logger } from '@aztec/foundation/log';
 
 import { type Command, Option } from 'commander';
 
+import { getL1RollupAddressFromEnv } from '../../config/get_l1_config.js';
 import {
   ETHEREUM_HOSTS,
+  MNEMONIC,
   PRIVATE_KEY,
   l1ChainIdOption,
-  makePxeOption,
+  nodeOption,
   parseAztecAddress,
   parseBigint,
   parseEthereumAddress,
-  pxeOption,
 } from '../../utils/commands.js';
 
+export { addL1Validator } from './update_l1_validators.js';
+
 const l1RpcUrlsOption = new Option(
   '--l1-rpc-urls <string>',
   'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)',
@@ -23,9 +26,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.')
@@ -42,7 +45,11 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .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('--accelerated-test-deployments', 'Fire and forget deployment transactions, use in testing only', false)
+    .option('--real-verifier', 'Deploy the real verifier', false)
+    .option('--existing-token <address>', 'Use an existing ERC20 for both fee and staking', parseEthereumAddress)
+    .option('--create-verification-json [path]', 'Create JSON file for etherscan contract verification', false)
     .action(async options => {
       const { deployL1Contracts } = await import('./deploy_l1_contracts.js');
 
@@ -56,9 +63,13 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.mnemonicIndex,
         options.salt,
         options.testAccounts,
+        options.sponsoredFpc,
         options.acceleratedTestDeployments,
         options.json,
+        options.createVerificationJson,
         initialValidators,
+        options.realVerifier,
+        options.existingToken,
         log,
         debugLogger,
       );
@@ -66,7 +77,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 +85,16 @@ 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)
+    .option('--create-verification-json [path]', 'Create JSON file for etherscan contract verification', false)
     .action(async options => {
       const { deployNewRollup } = await import('./deploy_new_rollup.js');
 
@@ -95,8 +109,11 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.mnemonicIndex,
         options.salt,
         options.testAccounts,
+        options.sponsoredFpc,
         options.json,
         initialValidators,
+        options.realVerifier,
+        options.createVerificationJson,
         log,
         debugLogger,
       );
@@ -274,28 +291,40 @@ 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');
+
+      const rollupAddress = options.rollup ?? (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 +376,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 +444,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 +460,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 +473,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.l1PrivateKey,
         options.mnemonic,
         options.token,
+        options.faucet,
         options.portal,
         options.private,
         options.mint,
@@ -506,52 +511,20 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     )
     .argument('[blockNumber]', 'The target block number, defaults to the latest pending block number.', parseBigint)
     .addOption(l1RpcUrlsOption)
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .action(async (blockNumber, options) => {
       const { assumeProvenThrough } = await import('./assume_proven_through.js');
-      await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.rpcUrl, log);
+      await assumeProvenThrough(blockNumber, 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;