@aztec/cli 0.0.0-test.1 → 0.0.1-commit.001888fc

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,33 @@ 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 <boolean>', 'Include initial test accounts in genesis state')
+        .env('TEST_ACCOUNTS')
+        .argParser(arg => arg === 'true'),
+    )
+    .addOption(
+      new Option('--sponsored-fpc <boolean>', 'Include sponsored FPC contract in genesis state')
+        .env('SPONSORED_FPC')
+        .argParser(arg => arg === 'true'),
+    )
+    .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 +296,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 +385,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 +453,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 +469,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 +482,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 +516,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;

package/src/cmds/l1/prover_stats.ts

@@ -1,5 +1,6 @@
 import { retrieveL2ProofVerifiedEvents } from '@aztec/archiver';
-import { type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
 import { compactArray, mapValues, unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type LogFn, type Logger, createLogger } from '@aztec/foundation/log';
@@ -46,7 +47,10 @@ export async function proverStats(opts: {
         .then(a => a.rollupAddress);
 
   const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
-  const publicClient = createPublicClient({ chain, transport: fallback(l1RpcUrls.map(url => http(url))) });
+  const publicClient = createPublicClient({
+    chain,
+    transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
+  });
   const lastBlockNum = endBlock ?? (await publicClient.getBlockNumber());
   debugLog.verbose(`Querying events on rollup at ${rollup.toString()} from ${startBlock} up to ${lastBlockNum}`);
 
@@ -55,33 +59,40 @@ export async function proverStats(opts: {
 
   // If we only care for raw logs, output them
   if (rawLogs && !provingTimeout) {
-    log(`l1_block_number, l2_block_number, prover_id, tx_hash`);
+    log(`l1_block_number, checkpoint_number, prover_id, tx_hash`);
     for (const event of events) {
-      const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
-      log(`${l1BlockNumber}, ${l2BlockNumber}, ${proverId}, ${txHash}`);
+      const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+      log(`${l1BlockNumber}, ${checkpointNumber}, ${proverId}, ${txHash}`);
     }
     return;
   }
 
-  // If we don't have a proving timeout, we can just count the number of unique blocks per prover
+  // If we don't have a proving timeout, we can just count the number of unique checkpoints per prover
   if (!provingTimeout) {
     const stats = groupBy(events, 'proverId');
-    log(`prover_id, total_blocks_proven`);
+    log(`prover_id, total_checkpoints_proven`);
     for (const proverId in stats) {
-      const uniqueBlocks = new Set(stats[proverId].map(e => e.l2BlockNumber));
-      log(`${proverId}, ${uniqueBlocks.size}`);
+      const uniqueCheckpoints = new Set(stats[proverId].map(e => e.checkpointNumber));
+      log(`${proverId}, ${uniqueCheckpoints.size}`);
     }
     return;
   }
 
-  // But if we do, fetch the events for each block submitted, so we can look up their timestamp
-  const blockEvents = await getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+  // But if we do, fetch the events for each checkpoint submitted, so we can look up their timestamp
+  const checkpointEvents = await getCheckpointProposedEvents(
+    startBlock,
+    lastBlockNum,
+    batchSize,
+    debugLog,
+    publicClient,
+    rollup,
+  );
   debugLog.verbose(
-    `First L2 block within range is ${blockEvents[0]?.args.blockNumber} at L1 block ${blockEvents[0]?.blockNumber}`,
+    `First checkpoint within range is ${checkpointEvents[0]?.args.checkpointNumber} at L1 block ${checkpointEvents[0]?.blockNumber}`,
   );
 
   // Get the timestamps for every block on every log, both for proof and block submissions
-  const l1BlockNumbers = unique([...events.map(e => e.l1BlockNumber), ...blockEvents.map(e => e.blockNumber)]);
+  const l1BlockNumbers = unique([...events.map(e => e.l1BlockNumber), ...checkpointEvents.map(e => e.blockNumber)]);
   const l1BlockTimestamps: Record<string, bigint> = {};
   for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))) {
     const blocks = await Promise.all(
@@ -93,44 +104,44 @@ export async function proverStats(opts: {
     }
   }
 
-  // Map from l2 block number to the l1 block in which it was submitted
-  const l2BlockSubmissions: Record<string, bigint> = {};
-  for (const blockEvent of blockEvents) {
-    l2BlockSubmissions[blockEvent.args.blockNumber!.toString()] = blockEvent.blockNumber;
+  // Map from checkpoint number to the l1 block in which it was submitted
+  const checkpointSubmissions: Record<string, bigint> = {};
+  for (const checkpointEvent of checkpointEvents) {
+    checkpointSubmissions[checkpointEvent.args.checkpointNumber!.toString()] = checkpointEvent.blockNumber;
   }
 
   // If we want raw logs, output them
   if (rawLogs) {
-    log(`l1_block_number, l2_block_number, l2_block_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
+    log(`l1_block_number, checkpoint_number, checkpoint_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
     for (const event of events) {
-      const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
-      const uploadedBlockNumber = l2BlockSubmissions[l2BlockNumber.toString()];
+      const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+      const uploadedBlockNumber = checkpointSubmissions[checkpointNumber.toString()];
       if (!uploadedBlockNumber) {
         continue;
       }
       const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
       const provenTimestamp = l1BlockTimestamps[l1BlockNumber.toString()];
-      log(`${l1BlockNumber}, ${l2BlockNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+      log(`${l1BlockNumber}, ${checkpointNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
     }
     return;
   }
 
   // Or calculate stats per prover
-  const stats = mapValues(groupBy(events, 'proverId'), (blocks, proverId) =>
+  const stats = mapValues(groupBy(events, 'proverId'), (checkpoints, proverId) =>
     compactArray(
-      blocks.map(e => {
+      checkpoints.map(e => {
         const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
-        const uploadedBlockNumber = l2BlockSubmissions[e.l2BlockNumber.toString()];
+        const uploadedBlockNumber = checkpointSubmissions[e.checkpointNumber.toString()];
         if (!uploadedBlockNumber) {
           debugLog.verbose(
-            `Skipping ${proverId}'s proof for L2 block ${e.l2BlockNumber} as it was before the start block`,
+            `Skipping ${proverId}'s proof for checkpoint ${e.checkpointNumber} as it was before the start block`,
           );
           return undefined;
         }
         const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
         const provingTime = provenTimestamp - uploadedTimestamp;
         debugLog.debug(
-          `prover=${e.proverId} blockNumber=${e.l2BlockNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`,
+          `prover=${e.proverId} checkpointNumber=${e.checkpointNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`,
         );
         return { provenTimestamp, uploadedTimestamp, provingTime, ...e };
       }),
@@ -141,8 +152,8 @@ export async function proverStats(opts: {
   for (const proverId in stats) {
     const blocks = stats[proverId];
     const withinTimeout = blocks.filter(b => b.provingTime <= provingTimeout);
-    const uniqueBlocksWithinTimeout = new Set(withinTimeout.map(e => e.l2BlockNumber));
-    const uniqueBlocks = new Set(blocks.map(e => e.l2BlockNumber));
+    const uniqueBlocksWithinTimeout = new Set(withinTimeout.map(e => e.checkpointNumber));
+    const uniqueBlocks = new Set(blocks.map(e => e.checkpointNumber));
     const avgProvingTime =
       blocks.length === 0 ? 0 : Math.ceil(Number(blocks.reduce((acc, b) => acc + b.provingTime, 0n)) / blocks.length);
 
@@ -171,7 +182,7 @@ async function getL2ProofVerifiedEvents(
   return events;
 }
 
-async function getL2BlockEvents(
+async function getCheckpointProposedEvents(
   startBlock: bigint,
   lastBlockNum: bigint,
   batchSize: bigint,
@@ -188,14 +199,14 @@ async function getL2BlockEvents(
       address: getAddress(rollup.toString()),
       event: getAbiItem({
         abi: RollupAbi,
-        name: 'L2BlockProposed',
+        name: 'CheckpointProposed',
       }),
       fromBlock: blockNum,
       toBlock: end,
     });
 
     events.push(...newEvents);
-    debugLog.verbose(`Got ${newEvents.length} events querying l2 block submitted from block ${blockNum} to ${end}`);
+    debugLog.verbose(`Got ${newEvents.length} events querying checkpoints submitted from block ${blockNum} to ${end}`);
     blockNum += batchSize;
   }
   return events;

package/src/cmds/l1/trigger_seed_snapshot.ts

@@ -0,0 +1,32 @@
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import type { LogFn } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import { getContract } from 'viem';
+
+import type { RollupCommandArgs } from './update_l1_validators.js';
+
+export async function triggerSeedSnapshot({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  rollupAddress,
+  log,
+}: RollupCommandArgs & { log: LogFn }) {
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic!, chain.chainInfo);
+
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client,
+  });
+
+  log('Triggering seed snapshot for next epoch');
+  const txHash = await rollup.write.checkpointRandao();
+  log(`Sent! | Seed snapshot setup for next epoch | tx hash: ${txHash}`);
+  const receipt = await client.waitForTransactionReceipt({ hash: txHash });
+  log(`Done! | Seed snapshot setup for next epoch | tx hash: ${txHash} | status: ${receipt.status}`);
+}