@aztec/ethereum 0.0.1-commit.b655e406 → 0.0.1-commit.fce3e4f

package/src/test/chain_monitor.ts

@@ -1,4 +1,5 @@
 import { InboxContract, type RollupContract } from '@aztec/ethereum/contracts';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
@@ -10,11 +11,11 @@ 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: SlotNumber; 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 }];
+  'l2-epoch': [{ l2EpochNumber: EpochNumber; timestamp: bigint; committee: EthAddress[] | undefined }];
+  'l2-slot': [{ l2SlotNumber: SlotNumber; timestamp: bigint }];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -27,20 +28,20 @@ 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 */
-  public l2EpochNumber!: bigint;
+  public l2EpochNumber!: EpochNumber;
   /** Current L2 slot number */
-  public l2SlotNumber!: bigint;
+  public l2SlotNumber!: SlotNumber;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -114,28 +115,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),
+        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,
       });
@@ -153,13 +154,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
       committee = (await this.rollup.getCurrentEpochCommittee())?.map(addr => EthAddress.fromString(addr));
-      this.emit('l2-epoch', { l2EpochNumber: Number(l2Epoch), timestamp, committee });
+      this.emit('l2-epoch', { l2EpochNumber: l2Epoch, timestamp, committee });
       msg += ` starting new epoch ${this.l2EpochNumber} `;
     }
 
     if (l2SlotNumber !== this.l2SlotNumber) {
       this.l2SlotNumber = l2SlotNumber;
-      this.emit('l2-slot', { l2SlotNumber: Number(l2SlotNumber), timestamp });
+      this.emit('l2-slot', { l2SlotNumber, timestamp });
     }
 
     this.logger.info(msg, {
@@ -168,8 +169,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,
     });
@@ -177,14 +178,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     return this;
   }
 
-  public waitUntilL2Slot(slot: number | bigint): Promise<void> {
-    const targetSlot = typeof slot === 'bigint' ? slot.valueOf() : slot;
-    if (this.l2SlotNumber >= targetSlot) {
+  public waitUntilL2Slot(slot: SlotNumber): Promise<void> {
+    if (this.l2SlotNumber >= slot) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { l2SlotNumber: number; timestamp: bigint }) => {
-        if (data.l2SlotNumber >= targetSlot) {
+      const listener = (data: { l2SlotNumber: SlotNumber; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= slot) {
           this.off('l2-slot', listener);
           resolve();
         }
@@ -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/eth_cheat_codes.ts

@@ -6,7 +6,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { pluralize } from '@aztec/foundation/string';
 import type { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 
-import { type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { type Chain, type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { foundry } from 'viem/chains';
 
 import type { ViemPublicClient } from '../types.js';
 
@@ -28,9 +29,14 @@ export class EthCheatCodes {
      * The logger to use for the eth cheatcodes
      */
     public logger = createLogger('ethereum:cheat_codes'),
+    /**
+     * The chain configuration provided to Anvil
+     */
+    public chain: Chain = foundry,
   ) {
     this.publicClient = createPublicClient({
       transport: fallback(this.rpcUrls.map(url => http(url))),
+      chain: chain,
     });
   }
 

package/src/test/rollup_cheat_codes.ts

@@ -1,5 +1,6 @@
 import { RollupContract, type ViemPublicClient } from '@aztec/ethereum';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
@@ -14,7 +15,6 @@ import {
   hexToBigInt,
   http,
 } from 'viem';
-import { foundry } from 'viem/chains';
 
 import { EthCheatCodes } from './eth_cheat_codes.js';
 
@@ -30,7 +30,7 @@ export class RollupCheatCodes {
     addresses: Pick<L1ContractAddresses, 'rollupAddress'>,
   ) {
     this.client = createPublicClient({
-      chain: foundry,
+      chain: ethCheatCodes.chain,
       transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url))),
     });
     this.rollup = getContract({
@@ -50,15 +50,15 @@ export class RollupCheatCodes {
   }
 
   /** Returns the current slot */
-  public async getSlot() {
+  public async getSlot(): Promise<SlotNumber> {
     const ts = BigInt((await this.client.getBlock()).timestamp);
-    return await this.rollup.read.getSlotAt([ts]);
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([ts]));
   }
 
   /** Returns the current epoch */
-  public async getEpoch() {
+  public async getEpoch(): Promise<EpochNumber> {
     const slotNumber = await this.getSlot();
-    return await this.rollup.read.getEpochAtSlot([slotNumber]);
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([BigInt(slotNumber)]));
   }
 
   /**
@@ -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}`);
@@ -101,13 +97,13 @@ export class RollupCheatCodes {
   /** Fetches the epoch and slot duration config from the rollup contract */
   public async getConfig(): Promise<{
     /** Epoch duration */ epochDuration: bigint;
-    /** Slot duration */ slotDuration: bigint;
+    /** Slot duration */ slotDuration: number;
   }> {
     const [epochDuration, slotDuration] = await Promise.all([
       this.rollup.read.getEpochDuration(),
       this.rollup.read.getSlotDuration(),
     ]);
-    return { epochDuration, slotDuration };
+    return { epochDuration, slotDuration: Number(slotDuration) };
   }
 
   /**
@@ -116,15 +112,15 @@ export class RollupCheatCodes {
    * @param opts - Options
    */
   public async advanceToEpoch(
-    epoch: bigint | number,
+    epoch: EpochNumber,
     opts: {
       /** Offset in seconds */
       offset?: number;
     } = {},
   ) {
     const { epochDuration: slotsInEpoch } = await this.getConfig();
-    const timestamp =
-      (await this.rollup.read.getTimestampForSlot([BigInt(epoch) * slotsInEpoch])) + BigInt(opts.offset ?? 0);
+    const slotNumber = SlotNumber(epoch * Number(slotsInEpoch));
+    const timestamp = (await this.rollup.read.getTimestampForSlot([BigInt(slotNumber)])) + BigInt(opts.offset ?? 0);
     try {
       await this.ethCheatCodes.warp(Number(timestamp), { ...opts, silent: true, resetBlockInterval: true });
       this.logger.warn(`Warped to epoch ${epoch}`);
@@ -138,8 +134,8 @@ export class RollupCheatCodes {
   public async advanceToNextEpoch() {
     const slot = await this.getSlot();
     const { epochDuration, slotDuration } = await this.getConfig();
-    const slotsUntilNextEpoch = epochDuration - (slot % epochDuration) + 1n;
-    const timeToNextEpoch = slotsUntilNextEpoch * slotDuration;
+    const slotsUntilNextEpoch = epochDuration - (BigInt(slot) % epochDuration) + 1n;
+    const timeToNextEpoch = slotsUntilNextEpoch * BigInt(slotDuration);
     const l1Timestamp = BigInt((await this.client.getBlock()).timestamp);
     await this.ethCheatCodes.warp(Number(l1Timestamp + timeToNextEpoch), {
       silent: true,
@@ -151,10 +147,11 @@ export class RollupCheatCodes {
   /** Warps time in L1 until the beginning of the next slot. */
   public async advanceToNextSlot() {
     const currentSlot = await this.getSlot();
-    const timestamp = await this.rollup.read.getTimestampForSlot([currentSlot + 1n]);
+    const nextSlot = SlotNumber(currentSlot + 1);
+    const timestamp = await this.rollup.read.getTimestampForSlot([BigInt(nextSlot)]);
     await this.ethCheatCodes.warp(Number(timestamp), { silent: true, resetBlockInterval: true });
-    this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
-    return [timestamp, currentSlot + 1n];
+    this.logger.warn(`Advanced to slot ${nextSlot}`);
+    return [timestamp, nextSlot];
   }
 
   /**
@@ -163,42 +160,42 @@ export class RollupCheatCodes {
    */
   public async advanceSlots(howMany: number) {
     const l1Timestamp = (await this.client.getBlock()).timestamp;
-    const slotDuration = await this.rollup.read.getSlotDuration();
-    const timeToWarp = BigInt(howMany) * slotDuration;
+    const slotDuration = Number(await this.rollup.read.getSlotDuration());
+    const timeToWarp = BigInt(howMany) * BigInt(slotDuration);
     await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, { silent: true, resetBlockInterval: true });
     const [slot, epoch] = await Promise.all([this.getSlot(), this.getEpoch()]);
     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)
+   * 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 +206,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 () => {

package/src/test/start_anvil.ts

@@ -15,6 +15,7 @@ export async function startAnvil(
     log?: boolean;
     captureMethodCalls?: boolean;
     accounts?: number;
+    chainId?: number;
   } = {},
 ): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
   const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
@@ -35,6 +36,7 @@ export async function startAnvil(
         stopTimeout: 1000,
         accounts: opts.accounts ?? 20,
         gasLimit: 45_000_000n,
+        chainId: opts.chainId ?? 31337,
       });
 
       // Listen to the anvil output to get the port.