@aztec/epoch-cache 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/epoch_cache.ts

@@ -1,231 +1,386 @@
-import { 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 { EventEmitter } from 'node:events';
-import { createPublicClient, encodeAbiParameters, fallback, http, keccak256 } from 'viem';
+import { createPublicClient, encodeAbiParameters, keccak256 } from 'viem';
 
 import { type EpochCacheConfig, getEpochCacheConfigEnvVars } from './config.js';
 
-type EpochAndSlot = {
-  epoch: bigint;
-  slot: bigint;
+export type EpochAndSlot = {
+  epoch: EpochNumber;
+  slot: SlotNumber;
   ts: bigint;
 };
 
+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(nextSlot: boolean): Promise<EthAddress[]>;
-  getEpochAndSlotNow(): EpochAndSlot;
-  getProposerIndexEncoding(epoch: bigint, slot: bigint, seed: bigint): `0x${string}`;
-  computeProposerIndex(slot: bigint, epoch: bigint, seed: bigint, size: bigint): bigint;
-  getProposerInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress;
-    nextProposer: EthAddress;
-    currentSlot: bigint;
-    nextSlot: bigint;
-  }>;
-  isInCommittee(validator: EthAddress): Promise<boolean>;
+  getCommittee(slot: SlotTag | undefined): Promise<EpochCommitteeInfo>;
+  getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint };
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint };
+  getProposerIndexEncoding(epoch: EpochNumber, slot: SlotNumber, seed: bigint): `0x${string}`;
+  computeProposerIndex(slot: SlotNumber, epoch: EpochNumber, seed: bigint, size: bigint): bigint;
+  getCurrentAndNextSlot(): { currentSlot: 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;
 }
 
 /**
  * Epoch cache
  *
  * This class is responsible for managing traffic to the l1 node, by caching the validator set.
+ * Keeps the last N epochs in cache.
  * It also provides a method to get the current or next proposer, and to check who is in the current slot.
  *
- * If the epoch changes, then we update the stored validator set.
- *
  * Note: This class is very dependent on the system clock being in sync.
  */
-export class EpochCache
-  extends EventEmitter<{ committeeChanged: [EthAddress[], bigint] }>
-  implements EpochCacheInterface
-{
-  private committee: EthAddress[];
-  private cachedEpoch: bigint;
-  private cachedSampleSeed: bigint;
+export class EpochCache implements EpochCacheInterface {
+  // 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');
 
   constructor(
     private rollup: RollupContract,
-    initialValidators: EthAddress[] = [],
-    initialSampleSeed: bigint = 0n,
-    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 },
   ) {
-    super();
-    this.committee = initialValidators;
-    this.cachedSampleSeed = initialSampleSeed;
-
-    this.log.debug(`Initialized EpochCache with constants and validators`, { l1constants, initialValidators });
-
-    this.cachedEpoch = getEpochNumberAtTimestamp(this.nowInSeconds(), this.l1constants);
+    this.log.debug(`Initialized EpochCache`, {
+      l1constants,
+    });
   }
 
   static async create(
-    rollupAddress: EthAddress,
+    rollupOrAddress: EthAddress | RollupContract,
     config?: EpochCacheConfig,
     deps: { dateProvider?: DateProvider } = {},
   ) {
     config = config ?? getEpochCacheConfigEnvVars();
 
-    const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
-    const publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: fallback(config.l1RpcUrls.map(url => http(url))),
-      pollingInterval: config.viemPollingIntervalMS,
-    });
+    // Load the rollup contract if we were given an address
+    let rollup: RollupContract;
+    if ('address' in rollupOrAddress) {
+      rollup = rollupOrAddress;
+    } else {
+      const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+      const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
+        pollingInterval: config.viemPollingIntervalMS,
+      });
+      rollup = new RollupContract(publicClient, rollupOrAddress.toString());
+    }
 
-    const rollup = new RollupContract(publicClient, rollupAddress.toString());
-    const [l1StartBlock, l1GenesisTime, initialValidators, sampleSeed] = await Promise.all([
+    const [
+      l1StartBlock,
+      l1GenesisTime,
+      proofSubmissionEpochs,
+      slotDuration,
+      epochDuration,
+      lagInEpochsForValidatorSet,
+      lagInEpochsForRandao,
+      targetCommitteeSize,
+      rollupManaLimit,
+    ] = await Promise.all([
       rollup.getL1StartBlock(),
       rollup.getL1GenesisTime(),
-      rollup.getCurrentEpochCommittee(),
-      rollup.getCurrentSampleSeed(),
+      rollup.getProofSubmissionEpochs(),
+      rollup.getSlotDuration(),
+      rollup.getEpochDuration(),
+      rollup.getLagInEpochsForValidatorSet(),
+      rollup.getLagInEpochsForRandao(),
+      rollup.getTargetCommitteeSize(),
+      rollup.getManaLimit(),
     ] as const);
 
-    const l1RollupConstants: L1RollupConstants = {
+    const l1RollupConstants = {
       l1StartBlock,
       l1GenesisTime,
-      slotDuration: config.aztecSlotDuration,
-      epochDuration: config.aztecEpochDuration,
+      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,
-      initialValidators.map(v => EthAddress.fromString(v)),
-      sampleSeed,
-      l1RollupConstants,
-      deps.dateProvider,
-    );
+    return new EpochCache(rollup, l1RollupConstants, deps.dateProvider);
+  }
+
+  public getL1Constants(): L1RollupConstants {
+    return this.l1constants;
   }
 
-  private nowInSeconds(): bigint {
+  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));
   }
 
-  getEpochAndSlotNow(): EpochAndSlot {
-    return this.getEpochAndSlotAtTimestamp(this.nowInSeconds());
+  private getEpochAndSlotAtSlot(slot: SlotNumber): EpochAndSlot {
+    const epoch = getEpochAtSlot(slot, this.l1constants);
+    const ts = getTimestampRangeForEpoch(epoch, this.l1constants)[0];
+    return { epoch, ts, slot };
   }
 
-  private getEpochAndSlotInNextSlot(): EpochAndSlot {
-    const nextSlotTs = this.nowInSeconds() + BigInt(this.l1constants.slotDuration);
-    return this.getEpochAndSlotAtTimestamp(nextSlotTs);
+  public getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
+    const now = this.nowInSeconds();
+    const nextSlotTs = now + BigInt(this.l1constants.ethereumSlotDuration);
+    return { ...this.getEpochAndSlotAtTimestamp(nextSlotTs), now };
   }
 
   private getEpochAndSlotAtTimestamp(ts: bigint): EpochAndSlot {
+    const slot = getSlotAtTimestamp(ts, this.l1constants);
     return {
       epoch: getEpochNumberAtTimestamp(ts, this.l1constants),
-      slot: getSlotAtTimestamp(ts, this.l1constants),
-      ts,
+      ts: getTimestampForSlot(slot, this.l1constants),
+      slot,
     };
   }
 
+  public getCommitteeForEpoch(epoch: EpochNumber): Promise<EpochCommitteeInfo> {
+    const [startSlot] = getSlotRangeForEpoch(epoch, this.l1constants);
+    return this.getCommittee(startSlot);
+  }
+
   /**
-   * Get the current validator set
+   * 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.getEpochAndSlotNow().epoch
+        : 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.
    * @returns The current validator set.
    */
-  async getCommittee(nextSlot: boolean = false): Promise<EthAddress[]> {
-    // If the current epoch has changed, then we need to make a request to update the validator set
-    const { epoch: calculatedEpoch, ts } = nextSlot ? this.getEpochAndSlotInNextSlot() : this.getEpochAndSlotNow();
-
-    if (calculatedEpoch !== this.cachedEpoch) {
-      this.log.debug(`Updating validator set for new epoch ${calculatedEpoch}`, {
-        epoch: calculatedEpoch,
-        previousEpoch: this.cachedEpoch,
-      });
-      const [committeeAtTs, sampleSeedAtTs] = await Promise.all([
-        this.rollup.getCommitteeAt(ts),
-        this.rollup.getSampleSeedAt(ts),
-      ]);
-      this.committee = committeeAtTs.map((v: `0x${string}`) => EthAddress.fromString(v));
-      this.cachedEpoch = calculatedEpoch;
-      this.cachedSampleSeed = sampleSeedAtTs;
-      this.log.debug(`Updated validator set for epoch ${calculatedEpoch}`, { commitee: this.committee });
-      this.emit('committeeChanged', this.committee, calculatedEpoch);
+  public async getCommittee(slot: SlotTag = 'now'): Promise<EpochCommitteeInfo> {
+    const { epoch, ts } = this.getEpochAndTimestamp(slot);
+
+    if (this.cache.has(epoch)) {
+      return this.cache.get(epoch)!;
     }
 
-    return this.committee;
+    const epochData = await this.computeCommittee({ epoch, ts });
+    // If the committee size is 0 or undefined, then do not cache
+    if (!epochData.committee || epochData.committee.length === 0) {
+      return epochData;
+    }
+    this.cache.set(epoch, epochData);
+
+    const toPurge = Array.from(this.cache.keys())
+      .sort((a, b) => Number(b - a))
+      .slice(this.config.cacheSize);
+    toPurge.forEach(key => this.cache.delete(key));
+
+    return epochData;
+  }
+
+  private getEpochAndTimestamp(slot: SlotTag = 'now') {
+    if (slot === 'now') {
+      return this.getEpochAndSlotNow();
+    } else if (slot === 'next') {
+      return this.getEpochAndSlotInNextL1Slot();
+    } else {
+      return this.getEpochAndSlotAtSlot(slot);
+    }
+  }
+
+  private async computeCommittee(when: { epoch: EpochNumber; ts: bigint }): Promise<EpochCommitteeInfo> {
+    const { ts, epoch } = when;
+    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],
     );
   }
 
-  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;
+    }
     return BigInt(keccak256(this.getProposerIndexEncoding(epoch, slot, seed))) % size;
   }
 
+  /** Returns the current and next L2 slot numbers. */
+  public getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    const current = this.getEpochAndSlotNow();
+    const next = this.getEpochAndSlotInNextL1Slot();
+
+    return {
+      currentSlot: current.slot,
+      nextSlot: next.slot,
+    };
+  }
+
   /**
-   * Returns the current and next proposer
-   *
-   * We return the next proposer 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.
-   *
-   * If we are at an epoch boundary, then we can update the cache for the next epoch, this is the last check
-   * we do in the validator client, so we can update the cache here.
+   * Get the proposer attester address in the given L2 slot
+   * @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.
    */
-  async getProposerInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress;
-    nextProposer: EthAddress;
-    currentSlot: bigint;
-    nextSlot: bigint;
-  }> {
-    // Validators are sorted by their index in the committee, and getValidatorSet will cache
-    const committee = await this.getCommittee();
-    const { slot: currentSlot, epoch: currentEpoch } = this.getEpochAndSlotNow();
-    const { slot: nextSlot, epoch: nextEpoch } = this.getEpochAndSlotInNextSlot();
-
-    // Compute the proposer in this and the next slot
-    const proposerIndex = this.computeProposerIndex(
-      currentSlot,
-      this.cachedEpoch,
-      this.cachedSampleSeed,
-      BigInt(committee.length),
-    );
+  public getProposerAttesterAddressInSlot(slot: SlotNumber): Promise<EthAddress | undefined> {
+    const epochAndSlot = this.getEpochAndSlotAtSlot(slot);
+    return this.getProposerAttesterAddressAt(epochAndSlot);
+  }
 
-    // Check if the next proposer is in the next epoch
-    if (nextEpoch !== currentEpoch) {
-      await this.getCommittee(/*next slot*/ true);
+  /**
+   * Get the proposer attester address in the next slot
+   * @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 getProposerAttesterAddressInNextSlot(): Promise<EthAddress | undefined> {
+    const epochAndSlot = this.getEpochAndSlotInNextL1Slot();
+    return this.getProposerAttesterAddressAt(epochAndSlot);
+  }
+
+  /**
+   * Get the proposer attester address at a given epoch and slot
+   * @param when - The epoch and slot to get the proposer attester address at
+   * @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.
+   */
+  private async getProposerAttesterAddressAt(when: EpochAndSlot) {
+    const { epoch, slot } = when;
+    const { committee, seed } = await this.getCommittee(slot);
+    if (!committee) {
+      throw new NoCommitteeError();
+    } else if (committee.length === 0) {
+      return undefined;
     }
-    const nextProposerIndex = this.computeProposerIndex(
-      nextSlot,
-      this.cachedEpoch,
-      this.cachedSampleSeed,
-      BigInt(committee.length),
-    );
 
-    const currentProposer = committee[Number(proposerIndex)];
-    const nextProposer = committee[Number(nextProposerIndex)];
+    const proposerIndex = this.computeProposerIndex(slot, epoch, seed, BigInt(committee.length));
+    return committee[Number(proposerIndex)];
+  }
+
+  public getProposerFromEpochCommittee(
+    epochCommitteeInfo: EpochCommitteeInfo,
+    slot: SlotNumber,
+  ): EthAddress | undefined {
+    if (!epochCommitteeInfo.committee || epochCommitteeInfo.committee.length === 0) {
+      return undefined;
+    }
+    const proposerIndex = this.computeProposerIndex(
+      slot,
+      epochCommitteeInfo.epoch,
+      epochCommitteeInfo.seed,
+      BigInt(epochCommitteeInfo.committee.length),
+    );
 
-    return { currentProposer, nextProposer, currentSlot, nextSlot };
+    return epochCommitteeInfo.committee[Number(proposerIndex)];
   }
 
-  /**
-   * Check if a validator is in the current epoch's committee
-   */
-  async isInCommittee(validator: EthAddress): Promise<boolean> {
-    const committee = await this.getCommittee();
+  /** Check if a validator is in the given slot's committee */
+  async isInCommittee(slot: SlotTag, validator: EthAddress): Promise<boolean> {
+    const { committee } = await this.getCommittee(slot);
+    if (!committee) {
+      return false;
+    }
     return committee.some(v => v.equals(validator));
   }
+
+  /** From the set of given addresses, return all that are on the committee for the given slot */
+  async filterInCommittee(slot: SlotTag, validators: EthAddress[]): Promise<EthAddress[]> {
+    const { committee } = await this.getCommittee(slot);
+    if (!committee) {
+      return [];
+    }
+    const committeeSet = new Set(committee.map(v => v.toString()));
+    return validators.filter(v => committeeSet.has(v.toString()));
+  }
+
+  async getRegisteredValidators(): Promise<EthAddress[]> {
+    const validatorRefreshIntervalMs = this.config.validatorRefreshIntervalSeconds * 1000;
+    const validatorRefreshTime = this.lastValidatorRefresh + validatorRefreshIntervalMs;
+    if (validatorRefreshTime < this.dateProvider.now()) {
+      const currentSet = await this.rollup.getAttesters();
+      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));
+  }
 }

package/src/test/index.ts

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