@aztec/ethereum 3.0.0-nightly.20251124 → 3.0.0-nightly.20251125

package/dest/test/rollup_cheat_codes.js

@@ -43,25 +43,21 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
    * Returns the pending and proven chain tips
    * @returns The pending and proven chain tips
    */ async getTips() {
-        const res = await this.rollup.read.getTips();
-        return {
-            pending: res.pendingBlockNumber,
-            proven: res.provenBlockNumber
-        };
+        return await this.rollup.read.getTips();
     }
     /**
    * Logs the current state of the rollup contract.
    */ async debugRollup() {
         const rollup = new RollupContract(this.client, this.rollup.address);
-        const pendingNum = await rollup.getBlockNumber();
-        const provenNum = await rollup.getProvenBlockNumber();
+        const pendingNum = await rollup.getCheckpointNumber();
+        const provenNum = await rollup.getProvenCheckpointNumber();
         const validators = await rollup.getAttesters();
         const committee = await rollup.getCurrentEpochCommittee();
         const archive = await rollup.archive();
         const slot = await this.getSlot();
         const epochNum = await rollup.getEpochNumberForSlotNumber(slot);
-        this.logger.info(`Pending block num: ${pendingNum}`);
-        this.logger.info(`Proven block num: ${provenNum}`);
+        this.logger.info(`Pending checkpoint num: ${pendingNum}`);
+        this.logger.info(`Proven checkpoint num: ${provenNum}`);
         this.logger.info(`Validators: ${validators.map((v)=>v.toString()).join(', ')}`);
         this.logger.info(`Committee: ${committee?.map((v)=>v.toString()).join(', ')}`);
         this.logger.info(`Archive: ${archive}`);
@@ -144,36 +140,36 @@ import { EthCheatCodes } from './eth_cheat_codes.js';
         this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
     }
     /**
-   * Marks the specified block (or latest if none) as proven
-   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
-   */ markAsProven(maybeBlockNumber) {
+   * Marks the specified checkpoint (or latest if none) as proven
+   * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
+   */ markAsProven(maybeCheckpointNumber) {
         return this.ethCheatCodes.execWithPausedAnvil(async ()=>{
             const tipsBefore = await this.getTips();
             const { pending, proven } = tipsBefore;
-            let blockNumber = maybeBlockNumber;
-            if (blockNumber === undefined || blockNumber > pending) {
-                blockNumber = pending;
+            let checkpointNumber = maybeCheckpointNumber;
+            if (checkpointNumber === undefined || checkpointNumber > pending) {
+                checkpointNumber = pending;
             }
-            if (blockNumber <= proven) {
-                this.logger.debug(`Block ${blockNumber} is already proven`);
+            if (checkpointNumber <= proven) {
+                this.logger.debug(`Checkpoint ${checkpointNumber} is already proven`);
                 return;
             }
             // @note @LHerskind this is heavily dependent on the storage layout and size of values
             // The rollupStore is a struct and if the size of elements or the struct changes, this can break
-            const provenBlockNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
+            const provenCheckpointNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
             // Need to pack it as a single 32 byte word
-            const newValue = BigInt(tipsBefore.pending) << 128n | BigInt(blockNumber);
-            await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenBlockNumberSlot, newValue);
+            const newValue = BigInt(tipsBefore.pending) << 128n | BigInt(checkpointNumber);
+            await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenCheckpointNumberSlot, newValue);
             const tipsAfter = await this.getTips();
             if (tipsAfter.pending < tipsAfter.proven) {
-                throw new Error('Overwrote pending tip to a block in the past');
+                throw new Error('Overwrote pending tip to a checkpoint in the past');
             }
             this.logger.info(`Proven tip moved: ${tipsBefore.proven} -> ${tipsAfter.proven}. Pending tip: ${tipsAfter.pending}.`);
         });
     }
     /**
    * Overrides the inProgress field of the Inbox contract state
-   * @param howMuch - How many blocks to move it forward
+   * @param howMuch - How many checkpoints to move it forward
    */ advanceInboxInProgress(howMuch) {
         return this.ethCheatCodes.execWithPausedAnvil(async ()=>{
             // Storage slot 2 contains the InboxState struct

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "3.0.0-nightly.20251124",
+  "version": "3.0.0-nightly.20251125",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -31,10 +31,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "3.0.0-nightly.20251124",
-    "@aztec/constants": "3.0.0-nightly.20251124",
-    "@aztec/foundation": "3.0.0-nightly.20251124",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20251124",
+    "@aztec/blob-lib": "3.0.0-nightly.20251125",
+    "@aztec/constants": "3.0.0-nightly.20251125",
+    "@aztec/foundation": "3.0.0-nightly.20251125",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20251125",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "lodash.chunk": "^4.2.0",

package/src/config.ts

@@ -90,7 +90,7 @@ export const DefaultL1ContractsConfig = {
   slashingExecutionDelayInRounds: 0, // round N may be submitted in round N + 1
   slashingVetoer: EthAddress.ZERO,
   governanceProposerRoundSize: 300,
-  manaTarget: BigInt(1e10),
+  manaTarget: BigInt(100e6),
   provingCostPerMana: BigInt(100),
   exitDelaySeconds: 2 * 24 * 60 * 60,
   slasherFlavor: 'tally' as const,
@@ -200,14 +200,14 @@ const DefaultRewardConfig = {
   sequencerBps: 8000,
   rewardDistributor: EthAddress.ZERO.toString(),
   booster: EthAddress.ZERO.toString(),
-  blockReward: 500n * 10n ** 18n,
+  checkpointReward: 500n * 10n ** 18n,
 };
 
 const MainnetRewardConfig = {
   sequencerBps: 7_000,
   rewardDistributor: EthAddress.ZERO.toString(),
   booster: EthAddress.ZERO.toString(),
-  blockReward: 400n * 10n ** 18n,
+  checkpointReward: 400n * 10n ** 18n,
 };
 
 export const getRewardConfig = (networkName: NetworkNames) => {

package/src/contracts/rollup.ts

@@ -332,16 +332,16 @@ export class RollupContract {
     return await slasher.getProposer();
   }
 
-  getBlockReward() {
-    return this.rollup.read.getBlockReward();
+  getCheckpointReward() {
+    return this.rollup.read.getCheckpointReward();
   }
 
-  getBlockNumber() {
-    return this.rollup.read.getPendingBlockNumber();
+  getCheckpointNumber() {
+    return this.rollup.read.getPendingCheckpointNumber();
   }
 
-  getProvenBlockNumber() {
-    return this.rollup.read.getProvenBlockNumber();
+  getProvenCheckpointNumber() {
+    return this.rollup.read.getProvenCheckpointNumber();
   }
 
   getSlotNumber() {
@@ -426,8 +426,8 @@ export class RollupContract {
     return result;
   }
 
-  getBlock(blockNumber: bigint | number) {
-    return this.rollup.read.getBlock([BigInt(blockNumber)]);
+  getCheckpoint(checkpointNumber: bigint | number) {
+    return this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
   }
 
   getTips() {
@@ -454,8 +454,8 @@ export class RollupContract {
     return this.rollup.read.getCurrentEpoch();
   }
 
-  getEpochNumberForBlock(blockNumber: bigint) {
-    return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
+  getEpochNumberForCheckpoint(checkpointNumber: bigint) {
+    return this.rollup.read.getEpochForCheckpoint([BigInt(checkpointNumber)]);
   }
 
   async getRollupAddresses(): Promise<L1RollupContractAddresses> {
@@ -539,15 +539,16 @@ export class RollupContract {
    * @dev     Throws if unable to propose
    *
    * @param archive - The archive that we expect to be current state
-   * @return [slot, blockNumber] - If you can propose, the L2 slot number and L2 block number of the next Ethereum block,
+   * @return [slot, checkpointNumber, timeOfNextL1Slot] - If you can propose, the L2 slot number, checkpoint number and
+   * timestamp of the next L1 block
    * @throws otherwise
    */
   public async canProposeAtNextEthBlock(
     archive: Buffer,
     account: `0x${string}` | Account,
     slotDuration: bigint | number,
-    opts: { forcePendingBlockNumber?: number } = {},
-  ): Promise<{ slot: bigint; blockNumber: bigint; timeOfNextL1Slot: bigint }> {
+    opts: { forcePendingCheckpointNumber?: number } = {},
+  ): Promise<{ slot: bigint; checkpointNumber: bigint; timeOfNextL1Slot: bigint }> {
     if (typeof slotDuration === 'number') {
       slotDuration = BigInt(slotDuration);
     }
@@ -557,35 +558,37 @@ export class RollupContract {
 
     try {
       const {
-        result: [slot, blockNumber],
+        result: [slot, checkpointNumber],
       } = await this.client.simulateContract({
         address: this.address,
         abi: RollupAbi,
         functionName: 'canProposeAtTime',
         args: [timeOfNextL1Slot, `0x${archive.toString('hex')}`, who],
         account,
-        stateOverride: await this.makePendingBlockNumberOverride(opts.forcePendingBlockNumber),
+        stateOverride: await this.makePendingCheckpointNumberOverride(opts.forcePendingCheckpointNumber),
       });
 
-      return { slot, blockNumber, timeOfNextL1Slot };
+      return { slot, checkpointNumber, timeOfNextL1Slot };
     } catch (err: unknown) {
       throw formatViemError(err);
     }
   }
 
   /**
-   * Returns a state override that sets the pending block number to the specified value. Useful for simulations.
-   * Requires querying the current state of the contract to get the current proven block number, as they are both
+   * Returns a state override that sets the pending checkpoint number to the specified value. Useful for simulations.
+   * Requires querying the current state of the contract to get the current proven checkpoint number, as they are both
    * stored in the same slot. If the argument is undefined, it returns an empty override.
    */
-  public async makePendingBlockNumberOverride(forcePendingBlockNumber: number | undefined): Promise<StateOverride> {
-    if (forcePendingBlockNumber === undefined) {
+  public async makePendingCheckpointNumberOverride(
+    forcePendingCheckpointNumber: number | undefined,
+  ): Promise<StateOverride> {
+    if (forcePendingCheckpointNumber === undefined) {
       return [];
     }
     const slot = RollupContract.stfStorageSlot;
     const currentValue = await this.client.getStorageAt({ address: this.address, slot });
-    const currentProvenBlockNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
-    const newValue = (BigInt(forcePendingBlockNumber) << 128n) | currentProvenBlockNumber;
+    const currentProvenCheckpointNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
+    const newValue = (BigInt(forcePendingCheckpointNumber) << 128n) | currentProvenCheckpointNumber;
     return [
       {
         address: this.address,
@@ -596,7 +599,7 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
   public buildInvalidateBadAttestationRequest(
-    blockNumber: number,
+    checkpointNumber: number,
     attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
     invalidIndex: number,
@@ -607,7 +610,7 @@ export class RollupContract {
         abi: RollupAbi,
         functionName: 'invalidateBadAttestation',
         args: [
-          BigInt(blockNumber),
+          BigInt(checkpointNumber),
           attestationsAndSigners,
           committee.map(addr => addr.toString()),
           BigInt(invalidIndex),
@@ -618,7 +621,7 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
   public buildInvalidateInsufficientAttestationsRequest(
-    blockNumber: number,
+    checkpointNumber: number,
     attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
   ): L1TxRequest {
@@ -627,17 +630,17 @@ export class RollupContract {
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'invalidateInsufficientAttestations',
-        args: [BigInt(blockNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
+        args: [BigInt(checkpointNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
       }),
     };
   }
 
   /** Calls getHasSubmitted directly. Returns whether the given prover has submitted a proof with the given length for the given epoch. */
-  public getHasSubmittedProof(epochNumber: number, numberOfBlocksInEpoch: number, prover: Hex | EthAddress) {
+  public getHasSubmittedProof(epochNumber: number, numberOfCheckpointsInEpoch: number, prover: Hex | EthAddress) {
     if (prover instanceof EthAddress) {
       prover = prover.toString();
     }
-    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfBlocksInEpoch), prover]);
+    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfCheckpointsInEpoch), prover]);
   }
 
   getManaBaseFeeAt(timestamp: bigint, inFeeAsset: boolean) {
@@ -648,9 +651,9 @@ export class RollupContract {
     return this.rollup.read.getSlotAt([timestamp]);
   }
 
-  async status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+  async status(checkpointNumber: bigint, options?: { blockNumber?: bigint }) {
     await checkBlockTag(options?.blockNumber, this.client);
-    return this.rollup.read.status([blockNumber], options);
+    return this.rollup.read.status([checkpointNumber], options);
   }
 
   async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
@@ -662,8 +665,8 @@ export class RollupContract {
     return this.rollup.read.archive();
   }
 
-  archiveAt(blockNumber: bigint) {
-    return this.rollup.read.archiveAt([blockNumber]);
+  archiveAt(checkpointNumber: bigint) {
+    return this.rollup.read.archiveAt([checkpointNumber]);
   }
 
   getSequencerRewards(address: Hex | EthAddress) {
@@ -705,8 +708,8 @@ export class RollupContract {
     return this.rollup.read.getStatus([address]);
   }
 
-  getBlobCommitmentsHash(blockNumber: bigint) {
-    return this.rollup.read.getBlobCommitmentsHash([blockNumber]);
+  getBlobCommitmentsHash(checkpointNumber: bigint) {
+    return this.rollup.read.getBlobCommitmentsHash([checkpointNumber]);
   }
 
   getCurrentBlobCommitmentsHash() {
@@ -761,15 +764,17 @@ export class RollupContract {
     );
   }
 
-  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
-    return this.rollup.watchEvent.BlockInvalidated(
+  public listenToCheckpointInvalidated(
+    callback: (args: { checkpointNumber: bigint }) => unknown,
+  ): WatchContractEventReturnType {
+    return this.rollup.watchEvent.CheckpointInvalidated(
       {},
       {
         onLogs: logs => {
           for (const log of logs) {
             const args = log.args;
-            if (args.blockNumber !== undefined) {
-              callback({ blockNumber: args.blockNumber });
+            if (args.checkpointNumber !== undefined) {
+              callback({ checkpointNumber: args.checkpointNumber });
             }
           }
         },

package/src/deploy_l1_contracts.ts

@@ -487,9 +487,9 @@ export const deploySharedContracts = async (
   const rewardDistributorAddress = await registry.getRewardDistributor();
 
   if (!args.existingTokenAddress) {
-    const blockReward = getRewardConfig(networkName).blockReward;
+    const checkpointReward = getRewardConfig(networkName).checkpointReward;
 
-    const funding = blockReward * 200000n;
+    const funding = checkpointReward * 200000n;
     const { txHash: fundRewardDistributorTxHash } = await deployer.sendTransaction({
       to: feeAssetAddress.toString(),
       data: encodeFunctionData({

package/src/test/chain_monitor.ts

@@ -10,8 +10,8 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
-  'l2-block-proven': [{ l2ProvenBlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
+  checkpoint: [{ checkpointNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
+  'checkpoint-proven': [{ provenCheckpointNumber: number; l1BlockNumber: number; timestamp: bigint }];
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: number; timestamp: bigint; committee: EthAddress[] | undefined }];
   'l2-slot': [{ l2SlotNumber: number; timestamp: bigint }];
@@ -27,14 +27,14 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
   /** Current L1 block number */
   public l1BlockNumber!: number;
-  /** Current L2 block number */
-  public l2BlockNumber!: number;
-  /** Current L2 proven block number */
-  public l2ProvenBlockNumber!: number;
-  /** L1 timestamp for the current L2 block */
-  public l2BlockTimestamp!: bigint;
-  /** L1 timestamp for the proven L2 block */
-  public l2ProvenBlockTimestamp!: bigint;
+  /** Current checkpoint number */
+  public checkpointNumber!: number;
+  /** Current proven checkpoint number */
+  public provenCheckpointNumber!: number;
+  /** L1 timestamp for the current checkpoint */
+  public checkpointTimestamp!: bigint;
+  /** L1 timestamp for the proven checkpoint */
+  public provenCheckpointTimestamp!: bigint;
   /** Total number of L2 messages pushed into the Inbox */
   public totalL2Messages: number = 0;
   /** Current L2 epoch number */
@@ -114,28 +114,28 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
     let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
 
-    const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
-    if (this.l2BlockNumber !== newL2BlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2BlockNumber));
-      msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
-      this.l2BlockNumber = newL2BlockNumber;
-      this.l2BlockTimestamp = timestamp;
-      this.emit('l2-block', {
-        l2BlockNumber: newL2BlockNumber,
+    const newCheckpointNumber = Number(await this.rollup.getCheckpointNumber());
+    if (this.checkpointNumber !== newCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(BigInt(newCheckpointNumber));
+      msg += ` with new checkpoint ${newCheckpointNumber} for epoch ${epochNumber}`;
+      this.checkpointNumber = newCheckpointNumber;
+      this.checkpointTimestamp = timestamp;
+      this.emit('checkpoint', {
+        checkpointNumber: newCheckpointNumber,
         l1BlockNumber: newL1BlockNumber,
         l2SlotNumber: Number(l2SlotNumber),
         timestamp,
       });
     }
 
-    const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
-    if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2ProvenBlockNumber));
-      msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
-      this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
-      this.l2ProvenBlockTimestamp = timestamp;
-      this.emit('l2-block-proven', {
-        l2ProvenBlockNumber: newL2ProvenBlockNumber,
+    const newProvenCheckpointNumber = Number(await this.rollup.getProvenCheckpointNumber());
+    if (this.provenCheckpointNumber !== newProvenCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(BigInt(newProvenCheckpointNumber));
+      msg += ` with proof up to checkpoint ${newProvenCheckpointNumber} for epoch ${epochNumber}`;
+      this.provenCheckpointNumber = newProvenCheckpointNumber;
+      this.provenCheckpointTimestamp = timestamp;
+      this.emit('checkpoint-proven', {
+        provenCheckpointNumber: newProvenCheckpointNumber,
         l1BlockNumber: newL1BlockNumber,
         timestamp,
       });
@@ -168,8 +168,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       l1BlockNumber: this.l1BlockNumber,
       l2SlotNumber,
       l2Epoch,
-      l2BlockNumber: this.l2BlockNumber,
-      l2ProvenBlockNumber: this.l2ProvenBlockNumber,
+      checkpointNumber: this.checkpointNumber,
+      provenCheckpointNumber: this.provenCheckpointNumber,
       totalL2Messages: this.totalL2Messages,
       committee,
     });
@@ -225,19 +225,19 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
-  public waitUntilL2Block(l2BlockNumber: number | bigint): Promise<void> {
-    const targetBlock = typeof l2BlockNumber === 'bigint' ? l2BlockNumber.valueOf() : l2BlockNumber;
-    if (this.l2BlockNumber >= targetBlock) {
+  public waitUntilCheckpoint(checkpointNumber: number | bigint): Promise<void> {
+    const targetBlock = typeof checkpointNumber === 'bigint' ? checkpointNumber.valueOf() : checkpointNumber;
+    if (this.checkpointNumber >= targetBlock) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { l2BlockNumber: number; timestamp: bigint }) => {
-        if (data.l2BlockNumber >= targetBlock) {
-          this.off('l2-block', listener);
+      const listener = (data: { checkpointNumber: number; timestamp: bigint }) => {
+        if (data.checkpointNumber >= targetBlock) {
+          this.off('checkpoint', listener);
           resolve();
         }
       };
-      this.on('l2-block', listener);
+      this.on('checkpoint', listener);
     });
   }
 }

package/src/test/rollup_cheat_codes.ts

@@ -69,11 +69,7 @@ export class RollupCheatCodes {
     /** The pending chain tip */ pending: bigint;
     /** The proven chain tip */ proven: bigint;
   }> {
-    const res = await this.rollup.read.getTips();
-    return {
-      pending: res.pendingBlockNumber,
-      proven: res.provenBlockNumber,
-    };
+    return await this.rollup.read.getTips();
   }
 
   /**
@@ -81,16 +77,16 @@ export class RollupCheatCodes {
    */
   public async debugRollup() {
     const rollup = new RollupContract(this.client, this.rollup.address);
-    const pendingNum = await rollup.getBlockNumber();
-    const provenNum = await rollup.getProvenBlockNumber();
+    const pendingNum = await rollup.getCheckpointNumber();
+    const provenNum = await rollup.getProvenCheckpointNumber();
     const validators = await rollup.getAttesters();
     const committee = await rollup.getCurrentEpochCommittee();
     const archive = await rollup.archive();
     const slot = await this.getSlot();
     const epochNum = await rollup.getEpochNumberForSlotNumber(slot);
 
-    this.logger.info(`Pending block num: ${pendingNum}`);
-    this.logger.info(`Proven block num: ${provenNum}`);
+    this.logger.info(`Pending checkpoint num: ${pendingNum}`);
+    this.logger.info(`Proven checkpoint num: ${provenNum}`);
     this.logger.info(`Validators: ${validators.map(v => v.toString()).join(', ')}`);
     this.logger.info(`Committee: ${committee?.map(v => v.toString()).join(', ')}`);
     this.logger.info(`Archive: ${archive}`);
@@ -171,34 +167,34 @@ export class RollupCheatCodes {
   }
 
   /**
-   * Marks the specified block (or latest if none) as proven
-   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
+   * Marks the specified checkpoint (or latest if none) as proven
+   * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
    */
-  public markAsProven(maybeBlockNumber?: number | bigint) {
+  public markAsProven(maybeCheckpointNumber?: number | bigint) {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
       const tipsBefore = await this.getTips();
       const { pending, proven } = tipsBefore;
 
-      let blockNumber = maybeBlockNumber;
-      if (blockNumber === undefined || blockNumber > pending) {
-        blockNumber = pending;
+      let checkpointNumber = maybeCheckpointNumber;
+      if (checkpointNumber === undefined || checkpointNumber > pending) {
+        checkpointNumber = pending;
       }
-      if (blockNumber <= proven) {
-        this.logger.debug(`Block ${blockNumber} is already proven`);
+      if (checkpointNumber <= proven) {
+        this.logger.debug(`Checkpoint ${checkpointNumber} is already proven`);
         return;
       }
 
       // @note @LHerskind this is heavily dependent on the storage layout and size of values
       // The rollupStore is a struct and if the size of elements or the struct changes, this can break
-      const provenBlockNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
+      const provenCheckpointNumberSlot = hexToBigInt(RollupContract.stfStorageSlot);
 
       // Need to pack it as a single 32 byte word
-      const newValue = (BigInt(tipsBefore.pending) << 128n) | BigInt(blockNumber);
-      await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenBlockNumberSlot, newValue);
+      const newValue = (BigInt(tipsBefore.pending) << 128n) | BigInt(checkpointNumber);
+      await this.ethCheatCodes.store(EthAddress.fromString(this.rollup.address), provenCheckpointNumberSlot, newValue);
 
       const tipsAfter = await this.getTips();
       if (tipsAfter.pending < tipsAfter.proven) {
-        throw new Error('Overwrote pending tip to a block in the past');
+        throw new Error('Overwrote pending tip to a checkpoint in the past');
       }
 
       this.logger.info(
@@ -209,7 +205,7 @@ export class RollupCheatCodes {
 
   /**
    * Overrides the inProgress field of the Inbox contract state
-   * @param howMuch - How many blocks to move it forward
+   * @param howMuch - How many checkpoints to move it forward
    */
   public advanceInboxInProgress(howMuch: number | bigint): Promise<bigint> {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {