@aztec/epoch-cache 0.0.1-commit.6d3c34e → 0.0.1-commit.7035c9bd6

package/dest/test/test_epoch_cache.js

@@ -0,0 +1,195 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { getEpochAtSlot, getSlotAtTimestamp, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { PROPOSER_PIPELINING_SLOT_OFFSET } from '../epoch_cache.js';
+/** Default L1 constants for testing. */ const DEFAULT_L1_CONSTANTS = {
+    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 {
+    committee = [];
+    proposerAddress;
+    currentSlot = SlotNumber(0);
+    escapeHatchOpen = false;
+    seed = 0n;
+    registeredValidators = [];
+    l1Constants;
+    proposerPipeliningEnabled = false;
+    constructor(l1Constants = {}){
+        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) {
+        this.committee = committee;
+        return this;
+    }
+    /**
+   * Sets the proposer address returned by getProposerAttesterAddressInSlot.
+   * @param proposer - The address of the current proposer.
+   */ setProposer(proposer) {
+        this.proposerAddress = proposer;
+        return this;
+    }
+    /**
+   * Sets the current slot number.
+   * @param slot - The slot number to set.
+   */ setCurrentSlot(slot) {
+        this.currentSlot = slot;
+        return this;
+    }
+    /**
+   * Sets whether the escape hatch is open.
+   * @param open - True if escape hatch should be open.
+   */ setEscapeHatchOpen(open) {
+        this.escapeHatchOpen = open;
+        return this;
+    }
+    /**
+   * Sets the randomness seed used for proposer selection.
+   * @param seed - The seed value.
+   */ setSeed(seed) {
+        this.seed = seed;
+        return this;
+    }
+    /**
+   * Sets the list of registered validators (all validators, not just committee).
+   * @param validators - Array of validator addresses.
+   */ setRegisteredValidators(validators) {
+        this.registeredValidators = validators;
+        return this;
+    }
+    /**
+   * Sets the L1 constants used for epoch/slot calculations.
+   * @param constants - Partial constants to override defaults.
+   */ setL1Constants(constants) {
+        this.l1Constants = {
+            ...this.l1Constants,
+            ...constants
+        };
+        return this;
+    }
+    getL1Constants() {
+        return this.l1Constants;
+    }
+    setProposerPipeliningEnabled(enabled) {
+        this.proposerPipeliningEnabled = enabled;
+    }
+    getCommittee(_slot) {
+        const epoch = getEpochAtSlot(this.currentSlot, this.l1Constants);
+        return Promise.resolve({
+            committee: this.committee,
+            epoch,
+            seed: this.seed,
+            isEscapeHatchOpen: this.escapeHatchOpen
+        });
+    }
+    getSlotNow() {
+        return this.currentSlot;
+    }
+    getTargetSlot() {
+        return this.proposerPipeliningEnabled ? SlotNumber(this.currentSlot + PROPOSER_PIPELINING_SLOT_OFFSET) : this.currentSlot;
+    }
+    getEpochNow() {
+        return getEpochAtSlot(this.currentSlot, this.l1Constants);
+    }
+    getTargetEpoch() {
+        return getEpochAtSlot(this.getTargetSlot(), this.l1Constants);
+    }
+    isProposerPipeliningEnabled() {
+        return this.proposerPipeliningEnabled;
+    }
+    getEpochAndSlotNow() {
+        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() {
+        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() {
+        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, slot, seed) {
+        // 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, _epoch, _seed, size) {
+        if (size === 0n) {
+            return 0n;
+        }
+        return BigInt(slot) % size;
+    }
+    getCurrentAndNextSlot() {
+        const currentSlot = this.getSlotNow();
+        const next = this.getEpochAndSlotInNextL1Slot();
+        return {
+            currentSlot,
+            nextSlot: next.slot
+        };
+    }
+    getTargetAndNextSlot() {
+        const targetSlot = this.getTargetSlot();
+        const next = this.getTargetEpochAndSlotInNextL1Slot();
+        return {
+            targetSlot,
+            nextSlot: next.slot
+        };
+    }
+    getProposerAttesterAddressInSlot(_slot) {
+        return Promise.resolve(this.proposerAddress);
+    }
+    getRegisteredValidators() {
+        return Promise.resolve(this.registeredValidators);
+    }
+    isInCommittee(_slot, validator) {
+        return Promise.resolve(this.committee.some((v)=>v.equals(validator)));
+    }
+    filterInCommittee(_slot, validators) {
+        const committeeSet = new Set(this.committee.map((v)=>v.toString()));
+        return Promise.resolve(validators.filter((v)=>committeeSet.has(v.toString())));
+    }
+    isEscapeHatchOpen(_epoch) {
+        return Promise.resolve(this.escapeHatchOpen);
+    }
+    isEscapeHatchOpenAtSlot(_slot) {
+        return Promise.resolve(this.escapeHatchOpen);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/epoch-cache",
-  "version": "0.0.1-commit.6d3c34e",
+  "version": "0.0.1-commit.7035c9bd6",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -18,7 +18,7 @@
     "build": "yarn clean && ../scripts/tsc.sh",
     "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "start:dev": "concurrently -k \"tsgo -b -w\" \"nodemon --watch dest --exec yarn start\"",
+    "start:dev": "concurrently -k \"../scripts/tsc.sh --watch\" \"nodemon --watch dest --exec yarn start\"",
     "start": "node ./dest/index.js",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -26,11 +26,10 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/ethereum": "0.0.1-commit.6d3c34e",
-    "@aztec/foundation": "0.0.1-commit.6d3c34e",
-    "@aztec/l1-artifacts": "0.0.1-commit.6d3c34e",
-    "@aztec/stdlib": "0.0.1-commit.6d3c34e",
-    "@viem/anvil": "^0.0.10",
+    "@aztec/ethereum": "0.0.1-commit.7035c9bd6",
+    "@aztec/foundation": "0.0.1-commit.7035c9bd6",
+    "@aztec/l1-artifacts": "0.0.1-commit.7035c9bd6",
+    "@aztec/stdlib": "0.0.1-commit.7035c9bd6",
     "dotenv": "^16.0.3",
     "get-port": "^7.1.0",
     "jest-mock-extended": "^4.0.0",
@@ -42,7 +41,7 @@
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.3.3"

package/src/config.ts

@@ -1,11 +1,17 @@
 import { type L1ContractsConfig, getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { type L1ReaderConfig, getL1ReaderConfigFromEnv } from '@aztec/ethereum/l1-reader';
+import { type PipelineConfig, getPipelineConfigEnvVars } from '@aztec/stdlib/config';
 
 export type EpochCacheConfig = Pick<
-  L1ReaderConfig & L1ContractsConfig,
-  'l1RpcUrls' | 'l1ChainId' | 'viemPollingIntervalMS' | 'ethereumSlotDuration'
+  L1ReaderConfig & L1ContractsConfig & PipelineConfig,
+  | 'l1RpcUrls'
+  | 'l1ChainId'
+  | 'viemPollingIntervalMS'
+  | 'ethereumSlotDuration'
+  | 'l1HttpTimeoutMS'
+  | 'enableProposerPipelining'
 >;
 
 export function getEpochCacheConfigEnvVars(): EpochCacheConfig {
-  return { ...getL1ReaderConfigFromEnv(), ...getL1ContractsConfigEnvVars() };
+  return { ...getL1ReaderConfigFromEnv(), ...getL1ContractsConfigEnvVars(), ...getPipelineConfigEnvVars() };
 }

package/src/epoch_cache.ts

@@ -1,4 +1,5 @@
 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';
@@ -11,16 +12,19 @@ import {
   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: EpochNumber;
   slot: SlotNumber;
+  epoch: EpochNumber;
   ts: bigint;
 };
 
@@ -28,26 +32,34 @@ export type EpochCommitteeInfo = {
   committee: EthAddress[] | undefined;
   seed: bigint;
   epoch: EpochNumber;
+  /** True if the epoch is within an open escape hatch window. */
+  isEscapeHatchOpen: boolean;
 };
 
 export type SlotTag = 'now' | 'next' | SlotNumber;
 
 export interface EpochCacheInterface {
   getCommittee(slot: SlotTag | undefined): Promise<EpochCommitteeInfo>;
-  getEpochAndSlotNow(): EpochAndSlot;
-  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: 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;
-  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-    currentSlot: SlotNumber;
-    nextSlot: SlotNumber;
-  }>;
+  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;
 }
 
 /**
@@ -66,6 +78,8 @@ export class EpochCache implements EpochCacheInterface {
   private lastValidatorRefresh = 0;
   private readonly log: Logger = createLogger('epoch-cache');
 
+  protected enableProposerPipelining: boolean;
+
   constructor(
     private rollup: RollupContract,
     private readonly l1constants: L1RollupConstants & {
@@ -73,10 +87,12 @@ export class EpochCache implements EpochCacheInterface {
       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,
     });
   }
 
@@ -95,7 +111,7 @@ 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, { batch: false }))),
+        transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
         pollingInterval: config.viemPollingIntervalMS,
       });
       rollup = new RollupContract(publicClient, rollupOrAddress.toString());
@@ -109,6 +125,8 @@ export class EpochCache implements EpochCacheInterface {
       epochDuration,
       lagInEpochsForValidatorSet,
       lagInEpochsForRandao,
+      targetCommitteeSize,
+      rollupManaLimit,
     ] = await Promise.all([
       rollup.getL1StartBlock(),
       rollup.getL1GenesisTime(),
@@ -117,6 +135,8 @@ export class EpochCache implements EpochCacheInterface {
       rollup.getEpochDuration(),
       rollup.getLagInEpochsForValidatorSet(),
       rollup.getLagInEpochsForRandao(),
+      rollup.getTargetCommitteeSize(),
+      rollup.getManaLimit(),
     ] as const);
 
     const l1RollupConstants = {
@@ -128,18 +148,47 @@ export class EpochCache implements EpochCacheInterface {
       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 {
@@ -147,23 +196,33 @@ export class EpochCache implements EpochCacheInterface {
   }
 
   private getEpochAndSlotAtSlot(slot: SlotNumber): EpochAndSlot {
-    const epoch = getEpochAtSlot(slot, this.l1constants);
-    const ts = getTimestampRangeForEpoch(epoch, this.l1constants)[0];
-    return { epoch, ts, slot };
+    return this.getEpochAndSlotAtTimestamp(getTimestampForSlot(slot, this.l1constants));
+  }
+
+  public getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    const nowSeconds = this.nowInSeconds();
+    const nextSlotTs = nowSeconds + BigInt(this.l1constants.ethereumSlotDuration);
+    return { ...this.getEpochAndSlotAtTimestamp(nextSlotTs), nowSeconds };
   }
 
-  public getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
-    const now = this.nowInSeconds();
-    const nextSlotTs = now + BigInt(this.l1constants.ethereumSlotDuration);
-    return { ...this.getEpochAndSlotAtTimestamp(nextSlotTs), now };
+  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),
     };
   }
 
@@ -172,6 +231,38 @@ export class EpochCache implements EpochCacheInterface {
     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.
@@ -199,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') {
@@ -211,10 +302,11 @@ export class EpochCache implements EpochCacheInterface {
 
   private async computeCommittee(when: { epoch: EpochNumber; ts: bigint }): Promise<EpochCommitteeInfo> {
     const { ts, epoch } = when;
-    const [committee, seedBuffer, l1Timestamp] = await Promise.all([
+    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);
@@ -223,7 +315,7 @@ export class EpochCache implements EpochCacheInterface {
         `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 };
+    return { committee, seed: seedBuffer.toBigInt(), epoch, isEscapeHatchOpen };
   }
 
   /**
@@ -248,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: SlotNumber;
-    nextSlot: SlotNumber;
-    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,
     };
   }

package/src/test/index.ts

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