@aztec/cli 0.0.0-test.1 → 0.0.1-commit.017a351

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}`);
+}

package/src/cmds/l1/update_l1_validators.ts

@@ -1,15 +1,16 @@
-import {
-  EthCheatCodes,
-  createEthereumChain,
-  getExpectedAddress,
-  getL1ContractsConfigEnvVars,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
+import { createEthereumChain, isAnvilTestChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client, getPublicClient } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { GSEContract, RollupContract } from '@aztec/ethereum/contracts';
+import { createL1TxUtils } from '@aztec/ethereum/l1-tx-utils';
+import { EthCheatCodes } from '@aztec/ethereum/test';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn, Logger } from '@aztec/foundation/log';
-import { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { DateProvider } from '@aztec/foundation/timer';
+import { RollupAbi, StakingAssetHandlerAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
 
-import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { encodeFunctionData, formatEther, getContract, maxUint256 } from 'viem';
 import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 
 export interface RollupCommandArgs {
@@ -21,6 +22,14 @@ export interface RollupCommandArgs {
   withdrawerAddress?: EthAddress;
 }
 
+export interface StakingAssetHandlerCommandArgs {
+  rpcUrls: string[];
+  chainId: number;
+  privateKey?: string;
+  mnemonic?: string;
+  stakingAssetHandlerAddress: EthAddress;
+}
+
 export interface LoggerArgs {
   log: LogFn;
   debugLogger: Logger;
@@ -29,7 +38,6 @@ export interface LoggerArgs {
 export function generateL1Account() {
   const privateKey = generatePrivateKey();
   const account = privateKeyToAccount(privateKey);
-  account.address;
   return {
     privateKey,
     address: account.address,
@@ -41,83 +49,209 @@ export async function addL1Validator({
   chainId,
   privateKey,
   mnemonic,
-  validatorAddress,
-  rollupAddress,
+  attesterAddress,
   withdrawerAddress,
+  stakingAssetHandlerAddress,
+  proofParams,
+  blsSecretKey,
   log,
   debugLogger,
-}: RollupCommandArgs & LoggerArgs & { validatorAddress: EthAddress }) {
-  const config = getL1ContractsConfigEnvVars();
+}: StakingAssetHandlerCommandArgs &
+  LoggerArgs & {
+    blsSecretKey: bigint; // scalar field element of BN254
+    attesterAddress: EthAddress;
+    withdrawerAddress: EthAddress;
+    proofParams: Buffer;
+  }) {
   const dualLog = makeDualLog(log, debugLogger);
-  const publicClient = getPublicClient(rpcUrls, chainId);
-  const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+  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.toString(),
+    address: rollupAddress,
     abi: RollupAbi,
-    client: walletClient,
+    client: l1Client,
   });
 
-  const stakingAsset = getContract({
-    address: await rollup.read.getStakingAsset(),
+  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,
-    client: walletClient,
   });
+  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 });
 
-  await Promise.all(
-    [
-      await stakingAsset.write.mint([walletClient.account.address, config.minimumStake], {} as any),
-      await stakingAsset.write.approve([rollupAddress.toString(), config.minimumStake], {} as any),
-    ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
-  );
-
-  dualLog(`Adding validator ${validatorAddress.toString()} to rollup ${rollupAddress.toString()}`);
-  const txHash = await rollup.write.deposit([
-    validatorAddress.toString(),
-    // TODO(#11451): custom forwarders
-    getExpectedAddress(ForwarderAbi, ForwarderBytecode, [validatorAddress.toString()], validatorAddress.toString())
-      .address,
-    withdrawerAddress?.toString() ?? validatorAddress.toString(),
-    config.minimumStake,
-  ]);
-  dualLog(`Transaction hash: ${txHash}`);
-  await publicClient.waitForTransactionReceipt({ hash: txHash });
   if (isAnvilTestChain(chainId)) {
     dualLog(`Funding validator on L1`);
-    const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
-    await cheatCodes.setBalance(validatorAddress, 10n ** 20n);
+    const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), debugLogger);
+    await cheatCodes.setBalance(attesterAddress, 10n ** 20n);
   } else {
-    const balance = await publicClient.getBalance({ address: validatorAddress.toString() });
-    const balanceInEth = Number(balance) / 10 ** 18;
-    dualLog(`Validator balance: ${balanceInEth.toFixed(6)} ETH`);
-    if (balanceInEth === 0) {
-      dualLog(`WARNING: Validator has no balance. Remember to fund it!`);
+    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({
+export async function addL1ValidatorViaRollup({
   rpcUrls,
   chainId,
   privateKey,
   mnemonic,
-  validatorAddress,
+  attesterAddress,
+  withdrawerAddress,
+  blsSecretKey,
+  moveWithLatestRollup,
   rollupAddress,
   log,
   debugLogger,
-}: RollupCommandArgs & LoggerArgs & { validatorAddress: EthAddress }) {
+}: RollupCommandArgs &
+  LoggerArgs & {
+    blsSecretKey: bigint; // scalar field element of BN254
+    attesterAddress: EthAddress;
+    moveWithLatestRollup: boolean;
+  }) {
   const dualLog = makeDualLog(log, debugLogger);
-  const publicClient = getPublicClient(rpcUrls, chainId);
-  const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+  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: walletClient,
+    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 txHash = await rollup.write.initiateWithdraw([validatorAddress.toString(), validatorAddress.toString()]);
-  dualLog(`Transaction hash: ${txHash}`);
-  await publicClient.waitForTransactionReceipt({ hash: txHash });
+  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({
@@ -130,18 +264,20 @@ export async function pruneRollup({
   debugLogger,
 }: RollupCommandArgs & LoggerArgs) {
   const dualLog = makeDualLog(log, debugLogger);
-  const publicClient = getPublicClient(rpcUrls, chainId);
-  const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
-  const rollup = getContract({
-    address: rollupAddress.toString(),
-    abi: RollupAbi,
-    client: walletClient,
-  });
+  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 txHash = await rollup.write.prune();
-  dualLog(`Transaction hash: ${txHash}`);
-  await publicClient.waitForTransactionReceipt({ hash: txHash });
+  const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+    to: rollupAddress.toString(),
+    data: encodeFunctionData({
+      abi: RollupAbi,
+      functionName: 'prune',
+    }),
+  });
+  dualLog(`Transaction hash: ${receipt.transactionHash}`);
 }
 
 export async function fastForwardEpochs({
@@ -153,20 +289,20 @@ export async function fastForwardEpochs({
   debugLogger,
 }: RollupCommandArgs & LoggerArgs & { numEpochs: bigint }) {
   const dualLog = makeDualLog(log, debugLogger);
-  const publicClient = getPublicClient(rpcUrls, chainId);
+  const publicClient = getPublicClient({ l1RpcUrls: rpcUrls, l1ChainId: chainId });
   const rollup = getContract({
     address: rollupAddress.toString(),
     abi: RollupAbi,
     client: publicClient,
   });
 
-  const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
+  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));
+    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")) {
@@ -180,31 +316,27 @@ export async function fastForwardEpochs({
 
 export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }: RollupCommandArgs & LoggerArgs) {
   const config = getL1ContractsConfigEnvVars();
-  const publicClient = getPublicClient(rpcUrls, chainId);
-  const rollup = getContract({
-    address: rollupAddress.toString(),
-    abi: RollupAbi,
-    client: publicClient,
-  });
+  const publicClient = getPublicClient({ l1RpcUrls: rpcUrls, l1ChainId: chainId });
+  const rollup = new RollupContract(publicClient, rollupAddress);
 
-  const pendingNum = await rollup.read.getPendingBlockNumber();
+  const pendingNum = await rollup.getCheckpointNumber();
   log(`Pending block num: ${pendingNum}`);
-  const provenNum = await rollup.read.getProvenBlockNumber();
+  const provenNum = await rollup.getProvenCheckpointNumber();
   log(`Proven block num: ${provenNum}`);
-  const validators = await rollup.read.getAttesters();
+  const validators = await rollup.getAttesters();
   log(`Validators: ${validators.map(v => v.toString()).join(', ')}`);
-  const committee = await rollup.read.getCurrentEpochCommittee();
-  log(`Committee: ${committee.map(v => v.toString()).join(', ')}`);
-  const archive = await rollup.read.archive();
+  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.read.getCurrentEpoch();
+  const epochNum = await rollup.getCurrentEpochNumber();
   log(`Current epoch: ${epochNum}`);
-  const slot = await rollup.read.getCurrentSlot();
+  const slot = await rollup.getSlotNumber();
   log(`Current slot: ${slot}`);
-  const proposerDuringPrevL1Block = await rollup.read.getCurrentProposer();
+  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.read.getProposerAt([nextBlockTS]);
+  const proposer = await rollup.getProposerAt(nextBlockTS);
   log(`Proposer NOW: ${proposer.toString()}`);
 }
 
@@ -215,24 +347,12 @@ function makeDualLog(log: LogFn, debugLogger: Logger) {
   };
 }
 
-function getPublicClient(rpcUrls: string[], chainId: number) {
-  const chain = createEthereumChain(rpcUrls, chainId);
-  return createPublicClient({ chain: chain.chainInfo, transport: fallback(rpcUrls.map(url => http(url))) });
-}
-
-function getWalletClient(
-  rpcUrls: string[],
-  chainId: number,
-  privateKey: string | undefined,
-  mnemonic: string | undefined,
-) {
+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 chain = createEthereumChain(rpcUrls, chainId);
   const account = !privateKey
     ? mnemonicToAccount(mnemonic!)
     : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
-  return createWalletClient({ account, chain: chain.chainInfo, transport: fallback(rpcUrls.map(url => http(url))) });
+  return account;
 }

package/src/cmds/misc/generate_bootnode_enr.ts

@@ -3,10 +3,11 @@ import { createBootnodeENRandPeerId } from '@aztec/p2p/enr';
 
 export async function generateEncodedBootnodeENR(
   privateKey: string,
-  udpAnnounceAddress: string,
+  p2pIp: string,
+  p2pPort: number,
   l1ChainId: number,
   log: LogFn,
 ) {
-  const { enr } = await createBootnodeENRandPeerId(privateKey, udpAnnounceAddress, l1ChainId);
+  const { enr } = await createBootnodeENRandPeerId(privateKey, p2pIp, p2pPort, l1ChainId);
   log(`ENR: ${enr.encodeTxt()}`);
 }

package/src/cmds/misc/generate_secret_and_hash.ts

@@ -1,12 +1,12 @@
-import { computeSecretHash } from '@aztec/aztec.js';
-import { Fr } from '@aztec/foundation/fields';
+import { computeSecretHash } from '@aztec/aztec.js/crypto';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
 
-export function generateSecretAndHash(log: LogFn) {
+export async function generateSecretAndHash(log: LogFn) {
   const secret = Fr.random();
 
   // We hash this the same way that aztec nr hash does.
-  const secretHash = computeSecretHash(secret);
+  const secretHash = await computeSecretHash(secret);
 
   log(`
     Secret: ${secret}

package/src/cmds/misc/generate_secret_key.ts

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