@aztec-labs/cli 6.0.0-nightly.20260829

package/src/cmds/l1/prover_stats.ts

@@ -0,0 +1,213 @@
+import { RollupAbi } from '@aztec/l1-artifacts';
+
+import { retrieveL2ProofVerifiedEvents } from '@aztec-labs/archiver';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import type { ViemPublicClient } from '@aztec-labs/ethereum/types';
+import { compactArray, mapValues, unique } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type LogFn, type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { createAztecNodeClient } from '@aztec-labs/stdlib/interfaces/client';
+import chunk from 'lodash.chunk';
+import groupBy from 'lodash.groupby';
+import { createPublicClient, fallback, getAbiItem, getAddress, http } from 'viem';
+
+export async function proverStats(opts: {
+  l1RpcUrls: string[];
+  chainId: number;
+  l1RollupAddress: string | undefined;
+  nodeUrl: string | undefined;
+  log: LogFn;
+  startBlock: bigint;
+  endBlock: bigint | undefined;
+  batchSize: bigint;
+  provingTimeout: bigint | undefined;
+  rawLogs: boolean;
+}) {
+  const debugLog = createLogger('cli:prover_stats');
+  const {
+    startBlock,
+    chainId,
+    l1RpcUrls,
+    l1RollupAddress,
+    batchSize,
+    nodeUrl,
+    provingTimeout,
+    endBlock,
+    rawLogs,
+    log,
+  } = opts;
+  if (!l1RollupAddress && !nodeUrl) {
+    throw new Error('Either L1 rollup address or node URL must be set');
+  }
+
+  const rollup = l1RollupAddress
+    ? EthAddress.fromString(l1RollupAddress)
+    : await createAztecNodeClient(nodeUrl!)
+        .getL1ContractAddresses()
+        .then(a => a.rollupAddress);
+
+  const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
+  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}`);
+
+  // Get all events for L2 proof submissions
+  const events = await getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+
+  // If we only care for raw logs, output them
+  if (rawLogs && !provingTimeout) {
+    log(`l1_block_number, checkpoint_number, prover_id, tx_hash`);
+    for (const event of events) {
+      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 checkpoints per prover
+  if (!provingTimeout) {
+    const stats = groupBy(events, 'proverId');
+    log(`prover_id, total_checkpoints_proven`);
+    for (const proverId in stats) {
+      const uniqueCheckpoints = new Set(stats[proverId].map(e => e.checkpointNumber));
+      log(`${proverId}, ${uniqueCheckpoints.size}`);
+    }
+    return;
+  }
+
+  // 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 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), ...checkpointEvents.map(e => e.blockNumber)]);
+  const l1BlockTimestamps: Record<string, bigint> = {};
+  for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))) {
+    const blocks = await Promise.all(
+      l1Batch.map(blockNumber => publicClient.getBlock({ includeTransactions: false, blockNumber })),
+    );
+    debugLog.verbose(`Queried ${blocks.length} L1 blocks between ${l1Batch[0]} and ${l1Batch[l1Batch.length - 1]}`);
+    for (const block of blocks) {
+      l1BlockTimestamps[block.number.toString()] = block.timestamp;
+    }
+  }
+
+  // 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, checkpoint_number, checkpoint_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
+    for (const event of events) {
+      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}, ${checkpointNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+    }
+    return;
+  }
+
+  // Or calculate stats per prover
+  const stats = mapValues(groupBy(events, 'proverId'), (checkpoints, proverId) =>
+    compactArray(
+      checkpoints.map(e => {
+        const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
+        const uploadedBlockNumber = checkpointSubmissions[e.checkpointNumber.toString()];
+        if (!uploadedBlockNumber) {
+          debugLog.verbose(
+            `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} checkpointNumber=${e.checkpointNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`,
+        );
+        return { provenTimestamp, uploadedTimestamp, provingTime, ...e };
+      }),
+    ),
+  );
+
+  log(`prover_id, blocks_proven_within_timeout, total_blocks_proven, avg_proving_time`);
+  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.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);
+
+    log(`${proverId}, ${uniqueBlocksWithinTimeout.size}, ${uniqueBlocks.size}, ${avgProvingTime}`);
+  }
+  return;
+}
+
+async function getL2ProofVerifiedEvents(
+  startBlock: bigint,
+  lastBlockNum: bigint,
+  batchSize: bigint,
+  debugLog: Logger,
+  publicClient: ViemPublicClient,
+  rollup: EthAddress,
+) {
+  let blockNum = startBlock;
+  const events = [];
+  while (blockNum <= lastBlockNum) {
+    const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+    const newEvents = await retrieveL2ProofVerifiedEvents(publicClient, rollup, blockNum, end);
+    events.push(...newEvents);
+    debugLog.verbose(`Got ${newEvents.length} events querying l2 proof verified from block ${blockNum} to ${end}`);
+    blockNum += batchSize;
+  }
+  return events;
+}
+
+async function getCheckpointProposedEvents(
+  startBlock: bigint,
+  lastBlockNum: bigint,
+  batchSize: bigint,
+  debugLog: Logger,
+  publicClient: ViemPublicClient,
+  rollup: EthAddress,
+) {
+  let blockNum = startBlock;
+  const events = [];
+  while (blockNum <= lastBlockNum) {
+    const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+
+    const newEvents = await publicClient.getLogs({
+      address: getAddress(rollup.toString()),
+      event: getAbiItem({
+        abi: RollupAbi,
+        name: 'CheckpointProposed',
+      }),
+      fromBlock: blockNum,
+      toBlock: end,
+    });
+
+    events.push(...newEvents);
+    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 { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client } from '@aztec-labs/ethereum/client';
+import type { LogFn } from '@aztec-labs/foundation/log';
+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}`);
+}

package/src/cmds/l1/update_l1_validators.ts

@@ -0,0 +1,358 @@
+import { RollupAbi, StakingAssetHandlerAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createEthereumChain, isAnvilTestChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client, getPublicClient } from '@aztec-labs/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { GSEContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { createL1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import { EthCheatCodes } from '@aztec-labs/ethereum/test';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { ZkPassportProofParams } from '@aztec-labs/stdlib/zkpassport';
+import { encodeFunctionData, formatEther, getContract, maxUint256 } from 'viem';
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+export interface RollupCommandArgs {
+  rpcUrls: string[];
+  chainId: number;
+  privateKey?: string;
+  mnemonic?: string;
+  rollupAddress: EthAddress;
+  withdrawerAddress?: EthAddress;
+}
+
+export interface StakingAssetHandlerCommandArgs {
+  rpcUrls: string[];
+  chainId: number;
+  privateKey?: string;
+  mnemonic?: string;
+  stakingAssetHandlerAddress: EthAddress;
+}
+
+export interface LoggerArgs {
+  log: LogFn;
+  debugLogger: Logger;
+}
+
+export function generateL1Account() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  return {
+    privateKey,
+    address: account.address,
+  };
+}
+
+export async function addL1Validator({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  attesterAddress,
+  withdrawerAddress,
+  stakingAssetHandlerAddress,
+  proofParams,
+  blsSecretKey,
+  log,
+  debugLogger,
+}: StakingAssetHandlerCommandArgs &
+  LoggerArgs & {
+    blsSecretKey: bigint; // scalar field element of BN254
+    attesterAddress: EthAddress;
+    withdrawerAddress: EthAddress;
+    proofParams: Buffer;
+  }) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const account = getAccount(privateKey, mnemonic);
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+
+  const stakingAssetHandler = getContract({
+    address: stakingAssetHandlerAddress.toString(),
+    abi: StakingAssetHandlerAbi,
+    client: l1Client,
+  });
+
+  const rollupAddress = await stakingAssetHandler.read.getRollup();
+  dualLog(`Adding validator ${attesterAddress} to rollup ${rollupAddress.toString()}`);
+
+  const rollup = getContract({
+    address: rollupAddress,
+    abi: RollupAbi,
+    client: l1Client,
+  });
+
+  const gseAddress = await rollup.read.getGSE();
+  const gse = new GSEContract(l1Client, gseAddress);
+  const registrationTuple = await gse.makeRegistrationTuple(blsSecretKey);
+
+  const l1TxUtils = createL1TxUtils(l1Client, { logger: debugLogger });
+  const proofParamsObj = ZkPassportProofParams.fromBuffer(proofParams);
+
+  // Step 1: Claim STK tokens from the faucet
+  dualLog(`Claiming STK tokens from faucet`);
+  const { receipt: claimReceipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: stakingAssetHandlerAddress.toString(),
+    data: encodeFunctionData({
+      abi: StakingAssetHandlerAbi,
+      functionName: 'claim',
+      args: [proofParamsObj.toViem()],
+    }),
+    abi: StakingAssetHandlerAbi,
+  });
+  dualLog(`Claim transaction hash: ${claimReceipt.transactionHash}`);
+  await l1Client.waitForTransactionReceipt({ hash: claimReceipt.transactionHash });
+
+  // Step 2: Approve the rollup to spend STK tokens
+  const stakingAssetAddress = await stakingAssetHandler.read.STAKING_ASSET();
+  dualLog(`Approving rollup to spend STK tokens`);
+  const { receipt: approveReceipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: stakingAssetAddress,
+    data: encodeFunctionData({
+      abi: TestERC20Abi,
+      functionName: 'approve',
+      args: [rollupAddress, maxUint256],
+    }),
+    abi: TestERC20Abi,
+  });
+  await l1Client.waitForTransactionReceipt({ hash: approveReceipt.transactionHash });
+
+  // Step 3: Deposit into the rollup to register as a validator
+  dualLog(`Depositing into rollup to register validator`);
+  const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: rollupAddress,
+    data: encodeFunctionData({
+      abi: RollupAbi,
+      functionName: 'deposit',
+      args: [
+        attesterAddress.toString(),
+        withdrawerAddress.toString(),
+        registrationTuple.publicKeyInG1,
+        registrationTuple.publicKeyInG2,
+        registrationTuple.proofOfPossession,
+        false, // moveWithLatestRollup
+      ],
+    }),
+    abi: RollupAbi,
+  });
+  dualLog(`Deposit transaction hash: ${receipt.transactionHash}`);
+  await l1Client.waitForTransactionReceipt({ hash: receipt.transactionHash });
+
+  if (isAnvilTestChain(chainId)) {
+    dualLog(`Funding validator on L1`);
+    const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+    await cheatCodes.setBalance(attesterAddress, 10n ** 20n);
+  } else {
+    const balance = await l1Client.getBalance({ address: attesterAddress.toString() });
+    dualLog(`Validator balance: ${formatEther(balance)} ETH`);
+    if (balance === 0n) {
+      dualLog(`WARNING: Proposer has no balance. Remember to fund it!`);
+    }
+  }
+}
+
+export async function addL1ValidatorViaRollup({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  attesterAddress,
+  withdrawerAddress,
+  blsSecretKey,
+  moveWithLatestRollup,
+  rollupAddress,
+  log,
+  debugLogger,
+}: RollupCommandArgs &
+  LoggerArgs & {
+    blsSecretKey: bigint; // scalar field element of BN254
+    attesterAddress: EthAddress;
+    moveWithLatestRollup: boolean;
+  }) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const account = getAccount(privateKey, mnemonic);
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+
+  dualLog(`Adding validator ${attesterAddress} to rollup ${rollupAddress.toString()} via direct deposit`);
+
+  if (!withdrawerAddress) {
+    throw new Error(`Withdrawer address required`);
+  }
+
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: l1Client,
+  });
+
+  const gseAddress = await rollup.read.getGSE();
+
+  const gse = new GSEContract(l1Client, gseAddress);
+
+  const registrationTuple = await gse.makeRegistrationTuple(blsSecretKey);
+
+  const l1TxUtils = createL1TxUtils(l1Client, { logger: debugLogger });
+
+  const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: rollupAddress.toString(),
+    data: encodeFunctionData({
+      abi: RollupAbi,
+      functionName: 'deposit',
+      args: [
+        attesterAddress.toString(),
+        withdrawerAddress.toString(),
+        registrationTuple.publicKeyInG1,
+        registrationTuple.publicKeyInG2,
+        registrationTuple.proofOfPossession,
+        moveWithLatestRollup,
+      ],
+    }),
+    abi: StakingAssetHandlerAbi,
+  });
+  dualLog(`Transaction hash: ${receipt.transactionHash}`);
+  await l1Client.waitForTransactionReceipt({ hash: receipt.transactionHash });
+  if (isAnvilTestChain(chainId)) {
+    dualLog(`Funding validator on L1`);
+    const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+    await cheatCodes.setBalance(attesterAddress, 10n ** 20n);
+  } else {
+    const balance = await l1Client.getBalance({ address: attesterAddress.toString() });
+    dualLog(`Validator balance: ${formatEther(balance)} ETH`);
+    if (balance === 0n) {
+      dualLog(`WARNING: Proposer has no balance. Remember to fund it!`);
+    }
+  }
+}
+
+export async function removeL1Validator({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  validatorAddress,
+  rollupAddress,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs & { validatorAddress: EthAddress }) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const account = getAccount(privateKey, mnemonic);
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+  const l1TxUtils = createL1TxUtils(l1Client, { logger: debugLogger });
+
+  dualLog(`Removing validator ${validatorAddress.toString()} from rollup ${rollupAddress.toString()}`);
+  const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: rollupAddress.toString(),
+    data: encodeFunctionData({
+      abi: RollupAbi,
+      functionName: 'initiateWithdraw',
+      args: [validatorAddress.toString(), validatorAddress.toString()],
+    }),
+  });
+  dualLog(`Transaction hash: ${receipt.transactionHash}`);
+}
+
+export async function pruneRollup({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  rollupAddress,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const account = getAccount(privateKey, mnemonic);
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+  const l1TxUtils = createL1TxUtils(l1Client, { logger: debugLogger });
+
+  dualLog(`Trying prune`);
+  const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: rollupAddress.toString(),
+    data: encodeFunctionData({
+      abi: RollupAbi,
+      functionName: 'prune',
+    }),
+  });
+  dualLog(`Transaction hash: ${receipt.transactionHash}`);
+}
+
+export async function fastForwardEpochs({
+  rpcUrls,
+  chainId,
+  rollupAddress,
+  numEpochs,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs & { numEpochs: bigint }) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const publicClient = getPublicClient({ l1RpcUrls: rpcUrls, l1ChainId: chainId });
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: publicClient,
+  });
+
+  const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+  const currentSlot = await rollup.read.getCurrentSlot();
+  const l2SlotsInEpoch = await rollup.read.getEpochDuration();
+  const timestamp = await rollup.read.getTimestampForSlot([currentSlot + l2SlotsInEpoch * numEpochs]);
+  dualLog(`Fast forwarding ${numEpochs} epochs to ${timestamp}`);
+  try {
+    await cheatCodes.warp(Number(timestamp), { resetBlockInterval: true });
+    dualLog(`Fast forwarded ${numEpochs} epochs to ${timestamp}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("is lower than or equal to previous block's timestamp")) {
+      dualLog(`Someone else fast forwarded the chain to a point after/equal to the target time`);
+    } else {
+      // Re-throw other errors
+      throw error;
+    }
+  }
+}
+
+export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }: RollupCommandArgs & LoggerArgs) {
+  const config = getL1ContractsConfigEnvVars();
+  const publicClient = getPublicClient({ l1RpcUrls: rpcUrls, l1ChainId: chainId });
+  const rollup = new RollupContract(publicClient, rollupAddress);
+
+  const pendingNum = await rollup.getCheckpointNumber();
+  log(`Pending block num: ${pendingNum}`);
+  const provenNum = await rollup.getProvenCheckpointNumber();
+  log(`Proven block num: ${provenNum}`);
+  const validators = await rollup.getAttesters();
+  log(`Validators: ${validators.map(v => v.toString()).join(', ')}`);
+  const committee = await rollup.getCurrentEpochCommittee();
+  log(`Committee: ${committee?.map(v => v.toString()).join(', ')}`);
+  const archive = await rollup.archive();
+  log(`Archive: ${archive}`);
+  const epochNum = await rollup.getCurrentEpochNumber();
+  log(`Current epoch: ${epochNum}`);
+  const slot = await rollup.getSlotNumber();
+  log(`Current slot: ${slot}`);
+  const proposerDuringPrevL1Block = await rollup.getCurrentProposer();
+  log(`Proposer during previous L1 block: ${proposerDuringPrevL1Block}`);
+  const nextBlockTS = BigInt((await publicClient.getBlock()).timestamp + BigInt(config.ethereumSlotDuration));
+  const proposer = await rollup.getProposerAt(nextBlockTS);
+  log(`Proposer NOW: ${proposer.toString()}`);
+}
+
+function makeDualLog(log: LogFn, debugLogger: Logger) {
+  return (msg: string) => {
+    log(msg);
+    debugLogger.info(msg);
+  };
+}
+
+function getAccount(privateKey: string | undefined, mnemonic: string | undefined) {
+  if (!privateKey && !mnemonic) {
+    throw new Error('Either privateKey or mnemonic must be provided to create a wallet client');
+  }
+  const account = !privateKey
+    ? mnemonicToAccount(mnemonic!)
+    : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
+  return account;
+}

package/src/cmds/misc/generate_bootnode_enr.ts

@@ -0,0 +1,13 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { createBootnodeENRandPeerId } from '@aztec-labs/p2p/enr';
+
+export async function generateEncodedBootnodeENR(
+  privateKey: string,
+  p2pIp: string,
+  p2pPort: number,
+  l1ChainId: number,
+  log: LogFn,
+) {
+  const { enr } = await createBootnodeENRandPeerId(privateKey, p2pIp, p2pPort, l1ChainId);
+  log(`ENR: ${enr.encodeTxt()}`);
+}

package/src/cmds/misc/generate_p2p_private_key.ts

@@ -0,0 +1,9 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+
+export async function generateP2PPrivateKey(log: LogFn) {
+  const peerId = await createSecp256k1PeerId();
+  const exportedPeerId = Buffer.from(peerId.privateKey!).toString('hex');
+  log(`Private key: ${exportedPeerId}`);
+  log(`Peer Id: ${peerId}`);
+}

package/src/cmds/misc/generate_secret_key.ts

@@ -0,0 +1,5 @@
+import { Fr } from '@aztec-labs/aztec.js/fields';
+
+export function generateSecretKey() {
+  return { secretKey: Fr.random() };
+}