@aztec/epoch-cache 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/epoch_cache.ts

@@ -1,51 +1,65 @@
-import { NoCommitteeError, RollupContract, createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { makeL1HttpTransport } from '@aztec/ethereum/client';
+import { NoCommitteeError, RollupContract } from '@aztec/ethereum/contracts';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import {
-  EmptyL1RollupConstants,
   type L1RollupConstants,
   getEpochAtSlot,
   getEpochNumberAtTimestamp,
   getSlotAtTimestamp,
   getSlotRangeForEpoch,
   getTimestampForSlot,
-  getTimestampRangeForEpoch,
 } from '@aztec/stdlib/epoch-helpers';
 
-import { createPublicClient, encodeAbiParameters, fallback, http, keccak256 } from 'viem';
+import { createPublicClient, encodeAbiParameters, keccak256 } from 'viem';
 
 import { type EpochCacheConfig, getEpochCacheConfigEnvVars } from './config.js';
 
+/** When proposer pipelining is enabled, the proposer builds one slot ahead. */
+export const PROPOSER_PIPELINING_SLOT_OFFSET = 1;
+
+/** Flat return type for compound epoch/slot getters. */
 export type EpochAndSlot = {
-  epoch: bigint;
-  slot: bigint;
+  slot: SlotNumber;
+  epoch: EpochNumber;
   ts: bigint;
 };
 
 export type EpochCommitteeInfo = {
   committee: EthAddress[] | undefined;
   seed: bigint;
-  epoch: bigint;
+  epoch: EpochNumber;
+  /** True if the epoch is within an open escape hatch window. */
+  isEscapeHatchOpen: boolean;
 };
 
-export type SlotTag = 'now' | 'next' | bigint;
+export type SlotTag = 'now' | 'next' | SlotNumber;
 
 export interface EpochCacheInterface {
   getCommittee(slot: SlotTag | undefined): Promise<EpochCommitteeInfo>;
-  getEpochAndSlotNow(): EpochAndSlot;
-  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint };
-  getProposerIndexEncoding(epoch: bigint, slot: bigint, seed: bigint): `0x${string}`;
-  computeProposerIndex(slot: bigint, epoch: bigint, seed: bigint, size: bigint): bigint;
-  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-    currentSlot: bigint;
-    nextSlot: bigint;
-  }>;
+  getSlotNow(): SlotNumber;
+  getTargetSlot(): SlotNumber;
+  getEpochNow(): EpochNumber;
+  getTargetEpoch(): EpochNumber;
+  getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint };
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint };
+  /** Returns epoch/slot info for the next L1 slot with pipeline offset applied. */
+  getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint };
+  isProposerPipeliningEnabled(): boolean;
+  isEscapeHatchOpen(epoch: EpochNumber): Promise<boolean>;
+  isEscapeHatchOpenAtSlot(slot: SlotTag): Promise<boolean>;
+  getProposerIndexEncoding(epoch: EpochNumber, slot: SlotNumber, seed: bigint): `0x${string}`;
+  computeProposerIndex(slot: SlotNumber, epoch: EpochNumber, seed: bigint, size: bigint): bigint;
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber };
+  getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber };
+  getProposerAttesterAddressInSlot(slot: SlotNumber): Promise<EthAddress | undefined>;
   getRegisteredValidators(): Promise<EthAddress[]>;
   isInCommittee(slot: SlotTag, validator: EthAddress): Promise<boolean>;
   filterInCommittee(slot: SlotTag, validators: EthAddress[]): Promise<EthAddress[]>;
+  getL1Constants(): L1RollupConstants;
 }
 
 /**
@@ -58,19 +72,27 @@ export interface EpochCacheInterface {
  * Note: This class is very dependent on the system clock being in sync.
  */
 export class EpochCache implements EpochCacheInterface {
-  protected cache: Map<bigint, EpochCommitteeInfo> = new Map();
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  protected cache: Map<EpochNumber, EpochCommitteeInfo> = new Map();
   private allValidators: Set<string> = new Set();
   private lastValidatorRefresh = 0;
   private readonly log: Logger = createLogger('epoch-cache');
 
+  protected enableProposerPipelining: boolean;
+
   constructor(
     private rollup: RollupContract,
-    private readonly l1constants: L1RollupConstants = EmptyL1RollupConstants,
+    private readonly l1constants: L1RollupConstants & {
+      lagInEpochsForValidatorSet: number;
+      lagInEpochsForRandao: number;
+    },
     private readonly dateProvider: DateProvider = new DateProvider(),
-    protected readonly config = { cacheSize: 12, validatorRefreshIntervalSeconds: 60 },
+    protected readonly config = { cacheSize: 12, validatorRefreshIntervalSeconds: 60, enableProposerPipelining: false },
   ) {
+    this.enableProposerPipelining = this.config.enableProposerPipelining;
     this.log.debug(`Initialized EpochCache`, {
       l1constants,
+      enableProposerPipelining: this.enableProposerPipelining,
     });
   }
 
@@ -89,71 +111,158 @@ export class EpochCache implements EpochCacheInterface {
       const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
       const publicClient = createPublicClient({
         chain: chain.chainInfo,
-        transport: fallback(config.l1RpcUrls.map(url => http(url))),
+        transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
         pollingInterval: config.viemPollingIntervalMS,
       });
       rollup = new RollupContract(publicClient, rollupOrAddress.toString());
     }
 
-    const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, slotDuration, epochDuration] = await Promise.all([
+    const [
+      l1StartBlock,
+      l1GenesisTime,
+      proofSubmissionEpochs,
+      slotDuration,
+      epochDuration,
+      lagInEpochsForValidatorSet,
+      lagInEpochsForRandao,
+      targetCommitteeSize,
+      rollupManaLimit,
+    ] = await Promise.all([
       rollup.getL1StartBlock(),
       rollup.getL1GenesisTime(),
       rollup.getProofSubmissionEpochs(),
       rollup.getSlotDuration(),
       rollup.getEpochDuration(),
+      rollup.getLagInEpochsForValidatorSet(),
+      rollup.getLagInEpochsForRandao(),
+      rollup.getTargetCommitteeSize(),
+      rollup.getManaLimit(),
     ] as const);
 
-    const l1RollupConstants: L1RollupConstants = {
+    const l1RollupConstants = {
       l1StartBlock,
       l1GenesisTime,
       proofSubmissionEpochs: Number(proofSubmissionEpochs),
       slotDuration: Number(slotDuration),
       epochDuration: Number(epochDuration),
       ethereumSlotDuration: config.ethereumSlotDuration,
+      lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+      lagInEpochsForRandao: Number(lagInEpochsForRandao),
+      targetCommitteeSize: Number(targetCommitteeSize),
+      rollupManaLimit: Number(rollupManaLimit),
     };
 
-    return new EpochCache(rollup, l1RollupConstants, deps.dateProvider);
+    return new EpochCache(rollup, l1RollupConstants, deps.dateProvider, {
+      cacheSize: 12,
+      validatorRefreshIntervalSeconds: 60,
+      enableProposerPipelining: config.enableProposerPipelining,
+    });
   }
 
   public getL1Constants(): L1RollupConstants {
     return this.l1constants;
   }
 
-  public getEpochAndSlotNow(): EpochAndSlot & { now: bigint } {
-    const now = this.nowInSeconds();
-    return { ...this.getEpochAndSlotAtTimestamp(now), now };
+  public isProposerPipeliningEnabled(): boolean {
+    return this.enableProposerPipelining;
+  }
+
+  public getSlotNow(): SlotNumber {
+    return this.getEpochAndSlotNow().slot;
+  }
+
+  public getTargetSlot(): SlotNumber {
+    const slotNow = this.getSlotNow();
+    const offset = this.isProposerPipeliningEnabled() ? PROPOSER_PIPELINING_SLOT_OFFSET : 0;
+    return SlotNumber(slotNow + offset);
+  }
+
+  public getEpochNow(): EpochNumber {
+    return this.getEpochAndSlotNow().epoch;
+  }
+
+  public getTargetEpoch(): EpochNumber {
+    return getEpochAtSlot(this.getTargetSlot(), this.l1constants);
+  }
+
+  public getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
+    const nowMs = BigInt(this.dateProvider.now());
+    const nowSeconds = nowMs / 1000n;
+    return { ...this.getEpochAndSlotAtTimestamp(nowSeconds), nowMs };
   }
 
   public nowInSeconds(): bigint {
     return BigInt(Math.floor(this.dateProvider.now() / 1000));
   }
 
-  private getEpochAndSlotAtSlot(slot: bigint): EpochAndSlot {
-    const epoch = getEpochAtSlot(slot, this.l1constants);
-    const ts = getTimestampRangeForEpoch(epoch, this.l1constants)[0];
-    return { epoch, ts, slot };
+  private getEpochAndSlotAtSlot(slot: SlotNumber): EpochAndSlot {
+    return this.getEpochAndSlotAtTimestamp(getTimestampForSlot(slot, this.l1constants));
   }
 
-  public getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
-    const now = this.nowInSeconds();
-    const nextSlotTs = now + BigInt(this.l1constants.ethereumSlotDuration);
-    return { ...this.getEpochAndSlotAtTimestamp(nextSlotTs), now };
+  public getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    const nowSeconds = this.nowInSeconds();
+    const nextSlotTs = nowSeconds + BigInt(this.l1constants.ethereumSlotDuration);
+    return { ...this.getEpochAndSlotAtTimestamp(nextSlotTs), nowSeconds };
+  }
+
+  public getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    if (!this.isProposerPipeliningEnabled()) {
+      return this.getEpochAndSlotInNextL1Slot();
+    }
+
+    const result = this.getEpochAndSlotInNextL1Slot();
+    const offset = PROPOSER_PIPELINING_SLOT_OFFSET;
+    const targetSlot = SlotNumber(result.slot + offset);
+    return { ...result, slot: targetSlot, epoch: getEpochAtSlot(targetSlot, this.l1constants) };
   }
 
   private getEpochAndSlotAtTimestamp(ts: bigint): EpochAndSlot {
     const slot = getSlotAtTimestamp(ts, this.l1constants);
+    const epoch = getEpochNumberAtTimestamp(ts, this.l1constants);
     return {
-      epoch: getEpochNumberAtTimestamp(ts, this.l1constants),
-      ts: getTimestampForSlot(slot, this.l1constants),
       slot,
+      epoch,
+      ts: getTimestampForSlot(slot, this.l1constants),
     };
   }
 
-  public getCommitteeForEpoch(epoch: bigint): Promise<EpochCommitteeInfo> {
+  public getCommitteeForEpoch(epoch: EpochNumber): Promise<EpochCommitteeInfo> {
     const [startSlot] = getSlotRangeForEpoch(epoch, this.l1constants);
     return this.getCommittee(startSlot);
   }
 
+  /**
+   * Returns whether the escape hatch is open for the given epoch.
+   *
+   * Uses the already-cached EpochCommitteeInfo when available. If not cached, it will fetch
+   * the epoch committee info (which includes the escape hatch flag) and return it.
+   */
+  public async isEscapeHatchOpen(epoch: EpochNumber): Promise<boolean> {
+    const cached = this.cache.get(epoch);
+    if (cached) {
+      return cached.isEscapeHatchOpen;
+    }
+    const info = await this.getCommitteeForEpoch(epoch);
+    return info.isEscapeHatchOpen;
+  }
+
+  /**
+   * Returns whether the escape hatch is open for the epoch containing the given slot.
+   *
+   * This is a lightweight helper intended for callers that already have a slot number and only
+   * need the escape hatch flag (without pulling full committee info).
+   */
+  public async isEscapeHatchOpenAtSlot(slot: SlotTag = 'now'): Promise<boolean> {
+    const epoch =
+      slot === 'now'
+        ? this.getEpochNow()
+        : slot === 'next'
+          ? this.getEpochAndSlotInNextL1Slot().epoch
+          : getEpochAtSlot(slot, this.l1constants);
+
+    return await this.isEscapeHatchOpen(epoch);
+  }
+
   /**
    * Get the current validator set
    * @param nextSlot - If true, get the validator set for the next slot.
@@ -181,7 +290,7 @@ export class EpochCache implements EpochCacheInterface {
     return epochData;
   }
 
-  private getEpochAndTimestamp(slot: SlotTag = 'now') {
+  private getEpochAndTimestamp(slot: SlotTag = 'now'): { epoch: EpochNumber; ts: bigint } {
     if (slot === 'now') {
       return this.getEpochAndSlotNow();
     } else if (slot === 'next') {
@@ -191,28 +300,39 @@ export class EpochCache implements EpochCacheInterface {
     }
   }
 
-  private async computeCommittee(when: { epoch: bigint; ts: bigint }): Promise<EpochCommitteeInfo> {
+  private async computeCommittee(when: { epoch: EpochNumber; ts: bigint }): Promise<EpochCommitteeInfo> {
     const { ts, epoch } = when;
-    const [committeeHex, seed] = await Promise.all([this.rollup.getCommitteeAt(ts), this.rollup.getSampleSeedAt(ts)]);
-    const committee = committeeHex?.map((v: `0x${string}`) => EthAddress.fromString(v));
-    return { committee, seed, epoch };
+    const [committee, seedBuffer, l1Timestamp, isEscapeHatchOpen] = await Promise.all([
+      this.rollup.getCommitteeAt(ts),
+      this.rollup.getSampleSeedAt(ts),
+      this.rollup.client.getBlock({ includeTransactions: false }).then(b => b.timestamp),
+      this.rollup.isEscapeHatchOpen(epoch),
+    ]);
+    const { lagInEpochsForValidatorSet, epochDuration, slotDuration } = this.l1constants;
+    const sub = BigInt(lagInEpochsForValidatorSet) * BigInt(epochDuration) * BigInt(slotDuration);
+    if (ts - sub > l1Timestamp) {
+      throw new Error(
+        `Cannot query committee for future epoch ${epoch} with timestamp ${ts} (current L1 time is ${l1Timestamp}). Check your Ethereum node is synced.`,
+      );
+    }
+    return { committee, seed: seedBuffer.toBigInt(), epoch, isEscapeHatchOpen };
   }
 
   /**
    * Get the ABI encoding of the proposer index - see ValidatorSelectionLib.sol computeProposerIndex
    */
-  getProposerIndexEncoding(epoch: bigint, slot: bigint, seed: bigint): `0x${string}` {
+  getProposerIndexEncoding(epoch: EpochNumber, slot: SlotNumber, seed: bigint): `0x${string}` {
     return encodeAbiParameters(
       [
         { type: 'uint256', name: 'epoch' },
         { type: 'uint256', name: 'slot' },
         { type: 'uint256', name: 'seed' },
       ],
-      [epoch, slot, seed],
+      [BigInt(epoch), BigInt(slot), seed],
     );
   }
 
-  public computeProposerIndex(slot: bigint, epoch: bigint, seed: bigint, size: bigint): bigint {
+  public computeProposerIndex(slot: SlotNumber, epoch: EpochNumber, seed: bigint, size: bigint): bigint {
     // if committe size is 0, then mod 1 is 0
     if (size === 0n) {
       return 0n;
@@ -220,25 +340,24 @@ export class EpochCache implements EpochCacheInterface {
     return BigInt(keccak256(this.getProposerIndexEncoding(epoch, slot, seed))) % size;
   }
 
-  /**
-   * Returns the current and next proposer's attester address
-   *
-   * We return the next proposer's attester address as the node will check if it is the proposer at the next ethereum block,
-   * which can be the next slot. If this is the case, then it will send proposals early.
-   */
-  public async getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentSlot: bigint;
-    nextSlot: bigint;
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-  }> {
-    const current = this.getEpochAndSlotNow();
+  /** Returns the current and next L2 slot in next eth L1 Slot. */
+  public getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    const currentSlot = this.getSlotNow();
     const next = this.getEpochAndSlotInNextL1Slot();
 
     return {
-      currentProposer: await this.getProposerAttesterAddressAt(current),
-      nextProposer: await this.getProposerAttesterAddressAt(next),
-      currentSlot: current.slot,
+      currentSlot,
+      nextSlot: next.slot,
+    };
+  }
+
+  /** Returns the taget and next L2 slot in the next L1 slot */
+  public getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber } {
+    const targetSlot = this.getTargetSlot();
+    const next = this.getTargetEpochAndSlotInNextL1Slot();
+
+    return {
+      targetSlot,
       nextSlot: next.slot,
     };
   }
@@ -248,7 +367,7 @@ export class EpochCache implements EpochCacheInterface {
    * @returns The proposer attester address. If the committee does not exist, we throw a NoCommitteeError.
    * If the committee is empty (i.e. target committee size is 0, and anyone can propose), we return undefined.
    */
-  public getProposerAttesterAddressInSlot(slot: bigint): Promise<EthAddress | undefined> {
+  public getProposerAttesterAddressInSlot(slot: SlotNumber): Promise<EthAddress | undefined> {
     const epochAndSlot = this.getEpochAndSlotAtSlot(slot);
     return this.getProposerAttesterAddressAt(epochAndSlot);
   }
@@ -282,7 +401,10 @@ export class EpochCache implements EpochCacheInterface {
     return committee[Number(proposerIndex)];
   }
 
-  public getProposerFromEpochCommittee(epochCommitteeInfo: EpochCommitteeInfo, slot: bigint): EthAddress | undefined {
+  public getProposerFromEpochCommittee(
+    epochCommitteeInfo: EpochCommitteeInfo,
+    slot: SlotNumber,
+  ): EthAddress | undefined {
     if (!epochCommitteeInfo.committee || epochCommitteeInfo.committee.length === 0) {
       return undefined;
     }
@@ -320,9 +442,9 @@ export class EpochCache implements EpochCacheInterface {
     const validatorRefreshTime = this.lastValidatorRefresh + validatorRefreshIntervalMs;
     if (validatorRefreshTime < this.dateProvider.now()) {
       const currentSet = await this.rollup.getAttesters();
-      this.allValidators = new Set(currentSet);
+      this.allValidators = new Set(currentSet.map(v => v.toString()));
       this.lastValidatorRefresh = this.dateProvider.now();
     }
-    return Array.from(this.allValidators.keys().map(v => EthAddress.fromString(v)));
+    return Array.from(this.allValidators.keys()).map(v => EthAddress.fromString(v));
   }
 }

package/src/test/index.ts

@@ -0,0 +1 @@
+export * from './test_epoch_cache.js';

package/src/test/test_epoch_cache.ts

@@ -0,0 +1,238 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { getEpochAtSlot, getSlotAtTimestamp, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+
+import {
+  type EpochAndSlot,
+  type EpochCacheInterface,
+  type EpochCommitteeInfo,
+  PROPOSER_PIPELINING_SLOT_OFFSET,
+  type SlotTag,
+} from '../epoch_cache.js';
+
+/** Default L1 constants for testing. */
+const DEFAULT_L1_CONSTANTS: L1RollupConstants = {
+  l1StartBlock: 0n,
+  l1GenesisTime: 0n,
+  slotDuration: 24,
+  epochDuration: 16,
+  ethereumSlotDuration: 12,
+  proofSubmissionEpochs: 2,
+  targetCommitteeSize: 48,
+  rollupManaLimit: Number.MAX_SAFE_INTEGER,
+};
+
+/**
+ * A test implementation of EpochCacheInterface that allows manual configuration
+ * of committee, proposer, slot, and escape hatch state for use in tests.
+ *
+ * Unlike the real EpochCache, this class doesn't require any RPC connections
+ * or mock setup. Simply use the setter methods to configure the test state.
+ */
+export class TestEpochCache implements EpochCacheInterface {
+  private committee: EthAddress[] = [];
+  private proposerAddress: EthAddress | undefined;
+  private currentSlot: SlotNumber = SlotNumber(0);
+  private escapeHatchOpen: boolean = false;
+  private seed: bigint = 0n;
+  private registeredValidators: EthAddress[] = [];
+  private l1Constants: L1RollupConstants;
+  private proposerPipeliningEnabled = false;
+
+  constructor(l1Constants: Partial<L1RollupConstants> = {}) {
+    this.l1Constants = { ...DEFAULT_L1_CONSTANTS, ...l1Constants };
+  }
+
+  /**
+   * Sets the committee members. Used in validation and attestation flows.
+   * @param committee - Array of committee member addresses.
+   */
+  setCommittee(committee: EthAddress[]): this {
+    this.committee = committee;
+    return this;
+  }
+
+  /**
+   * Sets the proposer address returned by getProposerAttesterAddressInSlot.
+   * @param proposer - The address of the current proposer.
+   */
+  setProposer(proposer: EthAddress | undefined): this {
+    this.proposerAddress = proposer;
+    return this;
+  }
+
+  /**
+   * Sets the current slot number.
+   * @param slot - The slot number to set.
+   */
+  setCurrentSlot(slot: SlotNumber): this {
+    this.currentSlot = slot;
+    return this;
+  }
+
+  /**
+   * Sets whether the escape hatch is open.
+   * @param open - True if escape hatch should be open.
+   */
+  setEscapeHatchOpen(open: boolean): this {
+    this.escapeHatchOpen = open;
+    return this;
+  }
+
+  /**
+   * Sets the randomness seed used for proposer selection.
+   * @param seed - The seed value.
+   */
+  setSeed(seed: bigint): this {
+    this.seed = seed;
+    return this;
+  }
+
+  /**
+   * Sets the list of registered validators (all validators, not just committee).
+   * @param validators - Array of validator addresses.
+   */
+  setRegisteredValidators(validators: EthAddress[]): this {
+    this.registeredValidators = validators;
+    return this;
+  }
+
+  /**
+   * Sets the L1 constants used for epoch/slot calculations.
+   * @param constants - Partial constants to override defaults.
+   */
+  setL1Constants(constants: Partial<L1RollupConstants>): this {
+    this.l1Constants = { ...this.l1Constants, ...constants };
+    return this;
+  }
+
+  getL1Constants(): L1RollupConstants {
+    return this.l1Constants;
+  }
+
+  setProposerPipeliningEnabled(enabled: boolean): void {
+    this.proposerPipeliningEnabled = enabled;
+  }
+
+  getCommittee(_slot?: SlotTag): Promise<EpochCommitteeInfo> {
+    const epoch = getEpochAtSlot(this.currentSlot, this.l1Constants);
+    return Promise.resolve({
+      committee: this.committee,
+      epoch,
+      seed: this.seed,
+      isEscapeHatchOpen: this.escapeHatchOpen,
+    });
+  }
+
+  getSlotNow(): SlotNumber {
+    return this.currentSlot;
+  }
+
+  getTargetSlot(): SlotNumber {
+    return this.proposerPipeliningEnabled
+      ? SlotNumber(this.currentSlot + PROPOSER_PIPELINING_SLOT_OFFSET)
+      : this.currentSlot;
+  }
+
+  getEpochNow(): EpochNumber {
+    return getEpochAtSlot(this.currentSlot, this.l1Constants);
+  }
+
+  getTargetEpoch(): EpochNumber {
+    return getEpochAtSlot(this.getTargetSlot(), this.l1Constants);
+  }
+
+  isProposerPipeliningEnabled(): boolean {
+    return this.proposerPipeliningEnabled;
+  }
+
+  getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
+    const epochNow = getEpochAtSlot(this.currentSlot, this.l1Constants);
+    const ts = getTimestampRangeForEpoch(epochNow, this.l1Constants)[0];
+    return {
+      epoch: epochNow,
+      slot: this.currentSlot,
+      ts,
+      nowMs: ts * 1000n,
+    };
+  }
+
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    const nowTs = getTimestampRangeForEpoch(getEpochAtSlot(this.currentSlot, this.l1Constants), this.l1Constants)[0];
+    const nextSlotTs = nowTs + BigInt(this.l1Constants.ethereumSlotDuration);
+    const nextSlot = getSlotAtTimestamp(nextSlotTs, this.l1Constants);
+    const epochNow = getEpochAtSlot(nextSlot, this.l1Constants);
+    const ts = getTimestampRangeForEpoch(epochNow, this.l1Constants)[0];
+    return {
+      epoch: epochNow,
+      slot: nextSlot,
+      ts,
+      nowSeconds: nowTs,
+    };
+  }
+
+  getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    const result = this.getEpochAndSlotInNextL1Slot();
+    const offset = this.isProposerPipeliningEnabled() ? PROPOSER_PIPELINING_SLOT_OFFSET : 0;
+    const targetSlot = SlotNumber(result.slot + offset);
+    return { ...result, slot: targetSlot, epoch: getEpochAtSlot(targetSlot, this.l1Constants) };
+  }
+
+  getProposerIndexEncoding(epoch: EpochNumber, slot: SlotNumber, seed: bigint): `0x${string}` {
+    // Simple encoding for testing purposes
+    return `0x${epoch.toString(16).padStart(64, '0')}${slot.toString(16).padStart(64, '0')}${seed.toString(16).padStart(64, '0')}`;
+  }
+
+  computeProposerIndex(slot: SlotNumber, _epoch: EpochNumber, _seed: bigint, size: bigint): bigint {
+    if (size === 0n) {
+      return 0n;
+    }
+    return BigInt(slot) % size;
+  }
+
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    const currentSlot = this.getSlotNow();
+    const next = this.getEpochAndSlotInNextL1Slot();
+
+    return {
+      currentSlot,
+      nextSlot: next.slot,
+    };
+  }
+
+  getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber } {
+    const targetSlot = this.getTargetSlot();
+    const next = this.getTargetEpochAndSlotInNextL1Slot();
+
+    return {
+      targetSlot,
+      nextSlot: next.slot,
+    };
+  }
+
+  getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
+    return Promise.resolve(this.proposerAddress);
+  }
+
+  getRegisteredValidators(): Promise<EthAddress[]> {
+    return Promise.resolve(this.registeredValidators);
+  }
+
+  isInCommittee(_slot: SlotTag, validator: EthAddress): Promise<boolean> {
+    return Promise.resolve(this.committee.some(v => v.equals(validator)));
+  }
+
+  filterInCommittee(_slot: SlotTag, validators: EthAddress[]): Promise<EthAddress[]> {
+    const committeeSet = new Set(this.committee.map(v => v.toString()));
+    return Promise.resolve(validators.filter(v => committeeSet.has(v.toString())));
+  }
+
+  isEscapeHatchOpen(_epoch: EpochNumber): Promise<boolean> {
+    return Promise.resolve(this.escapeHatchOpen);
+  }
+
+  isEscapeHatchOpenAtSlot(_slot?: SlotTag): Promise<boolean> {
+    return Promise.resolve(this.escapeHatchOpen);
+  }
+}