@aztec/aztec-node 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/sentinel/config.ts

@@ -2,6 +2,7 @@ import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from
 
 export type SentinelConfig = {
   sentinelHistoryLengthInEpochs: number;
+  sentinelHistoricProvenPerformanceLengthInEpochs: number;
   sentinelEnabled: boolean;
 };
 
@@ -11,6 +12,23 @@ export const sentinelConfigMappings: ConfigMappingsType<SentinelConfig> = {
     env: 'SENTINEL_HISTORY_LENGTH_IN_EPOCHS',
     ...numberConfigHelper(24),
   },
+  /**
+   * The number of L2 epochs kept of proven performance history for each validator.
+   * This value must be large enough so that we have proven performance for every validator
+   * for at least slashInactivityConsecutiveEpochThreshold. Assuming this value is 3,
+   * and the committee size is 48, and we have 10k validators, then we pick 48 out of 10k each draw.
+   * For any fixed element, per-draw prob = 48/10000 = 0.0048.
+   * After n draws, count ~ Binomial(n, 0.0048). We want P(X >= 3).
+   * Results (exact binomial):
+   * - 90% chance: n = 1108
+   * - 95% chance: n = 1310
+   * - 99% chance: n = 1749
+   */
+  sentinelHistoricProvenPerformanceLengthInEpochs: {
+    description: 'The number of L2 epochs kept of proven performance history for each validator.',
+    env: 'SENTINEL_HISTORIC_PROVEN_PERFORMANCE_LENGTH_IN_EPOCHS',
+    ...numberConfigHelper(2000),
+  },
   sentinelEnabled: {
     description: 'Whether the sentinel is enabled or not.',
     env: 'SENTINEL_ENABLED',

package/src/sentinel/factory.ts

@@ -27,6 +27,10 @@ export async function createSentinel(
     createLogger('node:sentinel:lmdb'),
   );
   const storeHistoryLength = config.sentinelHistoryLengthInEpochs * epochCache.getL1Constants().epochDuration;
-  const sentinelStore = new SentinelStore(kvStore, { historyLength: storeHistoryLength });
+  const storeHistoricProvenPerformanceLength = config.sentinelHistoricProvenPerformanceLengthInEpochs;
+  const sentinelStore = new SentinelStore(kvStore, {
+    historyLength: storeHistoryLength,
+    historicProvenPerformanceLength: storeHistoricProvenPerformanceLength,
+  });
   return new Sentinel(epochCache, archiver, p2p, sentinelStore, config, logger);
 }

package/src/sentinel/sentinel.ts

@@ -1,20 +1,27 @@
 import type { EpochCache } from '@aztec/epoch-cache';
-import { countWhile, filterAsync } from '@aztec/foundation/collection';
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { countWhile, filterAsync, fromEntries, getEntries, mapValues } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { L2TipsMemoryStore, type L2TipsStore } from '@aztec/kv-store/stores';
 import type { P2PClient } from '@aztec/p2p';
-import { OffenseType, WANT_TO_SLASH_EVENT, type Watcher, type WatcherEmitter } from '@aztec/slasher';
+import {
+  OffenseType,
+  WANT_TO_SLASH_EVENT,
+  type WantToSlashArgs,
+  type Watcher,
+  type WatcherEmitter,
+} from '@aztec/slasher';
 import type { SlasherConfig } from '@aztec/slasher/config';
 import {
   type L2BlockSource,
   L2BlockStream,
   type L2BlockStreamEvent,
   type L2BlockStreamEventHandler,
-  getAttestationsFromPublishedL2Block,
+  getAttestationInfoFromPublishedL2Block,
 } from '@aztec/stdlib/block';
-import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { getEpochAtSlot, getSlotRangeForEpoch, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import type {
   SingleValidatorStats,
   ValidatorStats,
@@ -34,9 +41,10 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   protected blockStream!: L2BlockStream;
   protected l2TipsStore: L2TipsStore;
 
-  protected initialSlot: bigint | undefined;
-  protected lastProcessedSlot: bigint | undefined;
-  protected slotNumberToBlock: Map<bigint, { blockNumber: number; archive: string; attestors: EthAddress[] }> =
+  protected initialSlot: SlotNumber | undefined;
+  protected lastProcessedSlot: SlotNumber | undefined;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  protected slotNumberToBlock: Map<SlotNumber, { blockNumber: BlockNumber; archive: string; attestors: EthAddress[] }> =
     new Map();
 
   constructor(
@@ -68,7 +76,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   /** Loads initial slot and initializes blockstream. We will not process anything at or before the initial slot. */
   protected async init() {
     this.initialSlot = this.epochCache.getEpochAndSlotNow().slot;
-    const startingBlock = await this.archiver.getBlockNumber();
+    const startingBlock = BlockNumber(await this.archiver.getBlockNumber());
     this.logger.info(`Starting validator sentinel with initial slot ${this.initialSlot} and block ${startingBlock}`);
     this.blockStream = new L2BlockStream(this.archiver, this.l2TipsStore, this, this.logger, { startingBlock });
   }
@@ -83,9 +91,11 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
       // Store mapping from slot to archive, block number, and attestors
       for (const block of event.blocks) {
         this.slotNumberToBlock.set(block.block.header.getSlot(), {
-          blockNumber: block.block.number,
+          blockNumber: BlockNumber(block.block.number),
           archive: block.block.archive.root.toString(),
-          attestors: getAttestationsFromPublishedL2Block(block).map(att => att.getSender()),
+          attestors: getAttestationInfoFromPublishedL2Block(block)
+            .filter(a => a.status === 'recovered-from-signature')
+            .map(a => a.address!),
         });
       }
 
@@ -108,60 +118,49 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     if (event.type !== 'chain-proven') {
       return;
     }
-    const blockNumber = event.block.number;
+    const blockNumber = BlockNumber(event.block.number);
     const block = await this.archiver.getBlock(blockNumber);
     if (!block) {
       this.logger.error(`Failed to get block ${blockNumber}`, { block });
       return;
     }
 
-    const epoch = getEpochAtSlot(block.header.getSlot(), await this.archiver.getL1Constants());
+    // TODO(palla/slash): We should only be computing proven performance if this is
+    // a full proof epoch and not a partial one, otherwise we'll end up with skewed stats.
+    const epoch = getEpochAtSlot(block.header.getSlot(), this.epochCache.getL1Constants());
     this.logger.debug(`Computing proven performance for epoch ${epoch}`);
     const performance = await this.computeProvenPerformance(epoch);
     this.logger.info(`Computed proven performance for epoch ${epoch}`, performance);
 
-    await this.updateProvenPerformance(epoch, performance);
+    await this.store.updateProvenPerformance(epoch, performance);
     await this.handleProvenPerformance(epoch, performance);
   }
 
-  protected async computeProvenPerformance(epoch: bigint) {
-    const headers = await this.archiver.getBlockHeadersForEpoch(epoch);
-    const provenSlots = headers.map(h => h.getSlot());
-    const fromSlot = provenSlots[0];
-    const toSlot = provenSlots[provenSlots.length - 1];
+  protected async computeProvenPerformance(epoch: EpochNumber): Promise<ValidatorsEpochPerformance> {
+    const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, this.epochCache.getL1Constants());
     const { committee } = await this.epochCache.getCommittee(fromSlot);
     if (!committee) {
       this.logger.trace(`No committee found for slot ${fromSlot}`);
       return {};
     }
-    const stats = await this.computeStats({ fromSlot, toSlot });
-    this.logger.debug(`Stats for epoch ${epoch}`, stats);
-
-    const performance: ValidatorsEpochPerformance = {};
-    for (const validator of Object.keys(stats.stats)) {
-      let address;
-      try {
-        address = EthAddress.fromString(validator);
-      } catch (e) {
-        this.logger.error(`Invalid validator address ${validator}`, e);
-        continue;
-      }
-      if (!committee.find(v => v.equals(address))) {
-        continue;
-      }
-      let missed = 0;
-      for (const history of stats.stats[validator].history) {
-        if (provenSlots.includes(history.slot) && history.status === 'attestation-missed') {
-          missed++;
-        }
-      }
-      performance[address.toString()] = { missed, total: provenSlots.length };
-    }
-    return performance;
-  }
 
-  protected updateProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance) {
-    return this.store.updateProvenPerformance(epoch, performance);
+    const stats = await this.computeStats({
+      fromSlot,
+      toSlot,
+      validators: committee,
+    });
+    this.logger.debug(`Stats for epoch ${epoch}`, { ...stats, fromSlot, toSlot, epoch });
+
+    // Note that we are NOT using the total slots in the epoch as `total` here, since we only
+    // compute missed attestations over the blocks that had a proposal in them. So, let's say
+    // we have an epoch with 10 slots, but only 5 had a block proposal. A validator that was
+    // offline, assuming they were not picked as proposer, will then be reported as having missed
+    // 5/5 attestations. If we used the total, they'd be reported as 5/10, which would probably
+    // allow them to avoid being slashed.
+    return mapValues(stats.stats, stat => ({
+      missed: stat.missedAttestations.count + stat.missedProposals.count,
+      total: stat.missedAttestations.total + stat.missedProposals.total,
+    }));
   }
 
   /**
@@ -172,7 +171,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
    */
   protected async checkPastInactivity(
     validator: EthAddress,
-    currentEpoch: bigint,
+    currentEpoch: EpochNumber,
     requiredConsecutiveEpochs: number,
   ): Promise<boolean> {
     if (requiredConsecutiveEpochs === 0) {
@@ -182,28 +181,31 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     // Get all historical performance for this validator
     const allPerformance = await this.store.getProvenPerformance(validator);
 
+    // Sort by epoch descending to get most recent first, keep only epochs strictly before the current one, and get the first N
+    const pastEpochs = allPerformance.sort((a, b) => Number(b.epoch - a.epoch)).filter(p => p.epoch < currentEpoch);
+
     // If we don't have enough historical data, don't slash
-    if (allPerformance.length < requiredConsecutiveEpochs) {
+    if (pastEpochs.length < requiredConsecutiveEpochs) {
       this.logger.debug(
         `Not enough historical data for slashing ${validator} for inactivity (${allPerformance.length} epochs < ${requiredConsecutiveEpochs} required)`,
       );
       return false;
     }
 
-    // Sort by epoch descending to get most recent first, keep only epochs strictly before the current one, and get the first N
-    return allPerformance
-      .sort((a, b) => Number(b.epoch - a.epoch))
-      .filter(p => p.epoch < currentEpoch)
+    // Check that we have at least requiredConsecutiveEpochs and that all of them are above the inactivity threshold
+    return pastEpochs
       .slice(0, requiredConsecutiveEpochs)
       .every(p => p.missed / p.total >= this.config.slashInactivityTargetPercentage);
   }
 
-  protected async handleProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance) {
-    const inactiveValidators = Object.entries(performance)
-      .filter(([_, { missed, total }]) => {
-        return missed / total >= this.config.slashInactivityTargetPercentage;
-      })
-      .map(([address]) => address as `0x${string}`);
+  protected async handleProvenPerformance(epoch: EpochNumber, performance: ValidatorsEpochPerformance) {
+    if (this.config.slashInactivityPenalty === 0n) {
+      return;
+    }
+
+    const inactiveValidators = getEntries(performance)
+      .filter(([_, { missed, total }]) => missed / total >= this.config.slashInactivityTargetPercentage)
+      .map(([address]) => address);
 
     this.logger.debug(`Found ${inactiveValidators.length} inactive validators in epoch ${epoch}`, {
       inactiveValidators,
@@ -216,15 +218,15 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
       this.checkPastInactivity(EthAddress.fromString(address), epoch, epochThreshold - 1),
     );
 
-    const args = criminals.map(address => ({
+    const args: WantToSlashArgs[] = criminals.map(address => ({
       validator: EthAddress.fromString(address),
       amount: this.config.slashInactivityPenalty,
       offenseType: OffenseType.INACTIVITY,
-      epochOrSlot: epoch,
+      epochOrSlot: BigInt(epoch),
     }));
 
     if (criminals.length > 0) {
-      this.logger.info(
+      this.logger.verbose(
         `Identified ${criminals.length} validators to slash due to inactivity in at least ${epochThreshold} consecutive epochs`,
         { ...args, epochThreshold },
       );
@@ -261,8 +263,13 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
    * We also don't move past the archiver last synced L2 slot, as we don't want to process data that is not yet available.
    * Last, we check the p2p is synced with the archiver, so it has pulled all attestations from it.
    */
-  protected async isReadyToProcess(currentSlot: bigint) {
-    const targetSlot = currentSlot - 2n;
+  protected async isReadyToProcess(currentSlot: SlotNumber): Promise<SlotNumber | false> {
+    if (currentSlot < 2) {
+      this.logger.trace(`Current slot ${currentSlot} too early.`);
+      return false;
+    }
+
+    const targetSlot = SlotNumber(currentSlot - 2);
     if (this.lastProcessedSlot && this.lastProcessedSlot >= targetSlot) {
       this.logger.trace(`Already processed slot ${targetSlot}`, { lastProcessedSlot: this.lastProcessedSlot });
       return false;
@@ -279,7 +286,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     }
 
     const archiverSlot = await this.archiver.getL2SlotNumber();
-    if (archiverSlot < targetSlot) {
+    if (archiverSlot === undefined || archiverSlot < targetSlot) {
       this.logger.debug(`Waiting for archiver to sync with L2 slot ${targetSlot}`, { archiverSlot, targetSlot });
       return false;
     }
@@ -299,7 +306,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
    * Gathers committee and proposer data for a given slot, computes slot stats,
    * and updates overall stats.
    */
-  protected async processSlot(slot: bigint) {
+  protected async processSlot(slot: SlotNumber) {
     const { epoch, seed, committee } = await this.epochCache.getCommittee(slot);
     if (!committee || committee.length === 0) {
       this.logger.trace(`No committee found for slot ${slot} at epoch ${epoch}`);
@@ -315,7 +322,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   }
 
   /** Computes activity for a given slot. */
-  protected async getSlotActivity(slot: bigint, epoch: bigint, proposer: EthAddress, committee: EthAddress[]) {
+  protected async getSlotActivity(slot: SlotNumber, epoch: EpochNumber, proposer: EthAddress, committee: EthAddress[]) {
     this.logger.debug(`Computing stats for slot ${slot} at epoch ${epoch}`, { slot, epoch, proposer, committee });
 
     // Check if there is an L2 block in L1 for this L2 slot
@@ -326,15 +333,20 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     // (contains the ones synced from mined blocks, which we may have missed from p2p).
     const block = this.slotNumberToBlock.get(slot);
     const p2pAttested = await this.p2p.getAttestationsForSlot(slot, block?.archive);
-    const attestors = new Set([
-      ...p2pAttested.map(a => a.getSender().toString()),
-      ...(block?.attestors.map(a => a.toString()) ?? []),
-    ]);
+    // Filter out attestations with invalid signatures
+    const p2pAttestors = p2pAttested.map(a => a.getSender()).filter((s): s is EthAddress => s !== undefined);
+    const attestors = new Set(
+      [...p2pAttestors.map(a => a.toString()), ...(block?.attestors.map(a => a.toString()) ?? [])].filter(
+        addr => proposer.toString() !== addr, // Exclude the proposer from the attestors
+      ),
+    );
 
-    // We assume that there was a block proposal if at least one of the validators attested to it.
+    // We assume that there was a block proposal if at least one of the validators (other than the proposer) attested to it.
     // It could be the case that every single validator failed, and we could differentiate it by having
     // this node re-execute every block proposal it sees and storing it in the attestation pool.
     // But we'll leave that corner case out to reduce pressure on the node.
+    // TODO(palla/slash): This breaks if a given node has more than one validator in the current committee,
+    // since they will attest to their own proposal it even if it's not re-executable.
     const blockStatus = block ? 'mined' : attestors.size > 0 ? 'proposed' : 'missed';
     this.logger.debug(`Block for slot ${slot} was ${blockStatus}`, { ...block, slot });
 
@@ -372,26 +384,30 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   }
 
   /** Push the status for each slot for each validator. */
-  protected updateValidators(slot: bigint, stats: Record<`0x${string}`, ValidatorStatusInSlot | undefined>) {
+  protected updateValidators(slot: SlotNumber, stats: Record<`0x${string}`, ValidatorStatusInSlot | undefined>) {
     return this.store.updateValidators(slot, stats);
   }
 
   /** Computes stats to be returned based on stored data. */
   public async computeStats({
-    fromSlot: _fromSlot,
-    toSlot: _toSlot,
-  }: { fromSlot?: bigint; toSlot?: bigint } = {}): Promise<ValidatorsStats> {
-    const histories = await this.store.getHistories();
+    fromSlot,
+    toSlot,
+    validators,
+  }: { fromSlot?: SlotNumber; toSlot?: SlotNumber; validators?: EthAddress[] } = {}): Promise<ValidatorsStats> {
+    const histories = validators
+      ? fromEntries(await Promise.all(validators.map(async v => [v.toString(), await this.store.getHistory(v)])))
+      : await this.store.getHistories();
+
     const slotNow = this.epochCache.getEpochAndSlotNow().slot;
-    const fromSlot = _fromSlot ?? (this.lastProcessedSlot ?? slotNow) - BigInt(this.store.getHistoryLength());
-    const toSlot = _toSlot ?? this.lastProcessedSlot ?? slotNow;
-    const result: Record<`0x${string}`, ValidatorStats> = {};
-    for (const [address, history] of Object.entries(histories)) {
-      const validatorAddress = address as `0x${string}`;
-      result[validatorAddress] = this.computeStatsForValidator(validatorAddress, history, fromSlot, toSlot);
-    }
+    fromSlot ??= SlotNumber(Math.max((this.lastProcessedSlot ?? slotNow) - this.store.getHistoryLength(), 0));
+    toSlot ??= this.lastProcessedSlot ?? slotNow;
+
+    const stats = mapValues(histories, (history, address) =>
+      this.computeStatsForValidator(address, history ?? [], fromSlot, toSlot),
+    );
+
     return {
-      stats: result,
+      stats,
       lastProcessedSlot: this.lastProcessedSlot,
       initialSlot: this.initialSlot,
       slotWindow: this.store.getHistoryLength(),
@@ -401,8 +417,8 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   /** Computes stats for a single validator. */
   public async getValidatorStats(
     validatorAddress: EthAddress,
-    fromSlot?: bigint,
-    toSlot?: bigint,
+    fromSlot?: SlotNumber,
+    toSlot?: SlotNumber,
   ): Promise<SingleValidatorStats | undefined> {
     const history = await this.store.getHistory(validatorAddress);
 
@@ -411,13 +427,14 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     }
 
     const slotNow = this.epochCache.getEpochAndSlotNow().slot;
-    const effectiveFromSlot = fromSlot ?? (this.lastProcessedSlot ?? slotNow) - BigInt(this.store.getHistoryLength());
+    const effectiveFromSlot =
+      fromSlot ?? SlotNumber(Math.max((this.lastProcessedSlot ?? slotNow) - this.store.getHistoryLength(), 0));
     const effectiveToSlot = toSlot ?? this.lastProcessedSlot ?? slotNow;
 
     const historyLength = BigInt(this.store.getHistoryLength());
-    if (effectiveToSlot - effectiveFromSlot > historyLength) {
+    if (BigInt(effectiveToSlot) - BigInt(effectiveFromSlot) > historyLength) {
       throw new Error(
-        `Slot range (${effectiveToSlot - effectiveFromSlot}) exceeds history length (${historyLength}). ` +
+        `Slot range (${BigInt(effectiveToSlot) - BigInt(effectiveFromSlot)}) exceeds history length (${historyLength}). ` +
           `Requested range: ${effectiveFromSlot} to ${effectiveToSlot}.`,
       );
     }
@@ -428,11 +445,10 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
       effectiveFromSlot,
       effectiveToSlot,
     );
-    const allTimeProvenPerformance = await this.store.getProvenPerformance(validatorAddress);
 
     return {
       validator,
-      allTimeProvenPerformance,
+      allTimeProvenPerformance: await this.store.getProvenPerformance(validatorAddress),
       lastProcessedSlot: this.lastProcessedSlot,
       initialSlot: this.initialSlot,
       slotWindow: this.store.getHistoryLength(),
@@ -442,39 +458,40 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   protected computeStatsForValidator(
     address: `0x${string}`,
     allHistory: ValidatorStatusHistory,
-    fromSlot?: bigint,
-    toSlot?: bigint,
+    fromSlot?: SlotNumber,
+    toSlot?: SlotNumber,
   ): ValidatorStats {
-    let history = fromSlot ? allHistory.filter(h => h.slot >= fromSlot) : allHistory;
-    history = toSlot ? history.filter(h => h.slot <= toSlot) : history;
+    let history = fromSlot ? allHistory.filter(h => BigInt(h.slot) >= fromSlot) : allHistory;
+    history = toSlot ? history.filter(h => BigInt(h.slot) <= toSlot) : history;
+    const lastProposal = history.filter(h => h.status === 'block-proposed' || h.status === 'block-mined').at(-1);
+    const lastAttestation = history.filter(h => h.status === 'attestation-sent').at(-1);
     return {
       address: EthAddress.fromString(address),
-      lastProposal: this.computeFromSlot(
-        history.filter(h => h.status === 'block-proposed' || h.status === 'block-mined').at(-1)?.slot,
-      ),
-      lastAttestation: this.computeFromSlot(history.filter(h => h.status === 'attestation-sent').at(-1)?.slot),
+      lastProposal: this.computeFromSlot(lastProposal?.slot),
+      lastAttestation: this.computeFromSlot(lastAttestation?.slot),
       totalSlots: history.length,
-      missedProposals: this.computeMissed(history, 'block', 'block-missed'),
-      missedAttestations: this.computeMissed(history, 'attestation', 'attestation-missed'),
+      missedProposals: this.computeMissed(history, 'block', ['block-missed']),
+      missedAttestations: this.computeMissed(history, 'attestation', ['attestation-missed']),
       history,
     };
   }
 
   protected computeMissed(
     history: ValidatorStatusHistory,
-    computeOverPrefix: ValidatorStatusType,
-    filter: ValidatorStatusInSlot,
+    computeOverPrefix: ValidatorStatusType | undefined,
+    filter: ValidatorStatusInSlot[],
   ) {
-    const relevantHistory = history.filter(h => h.status.startsWith(computeOverPrefix));
-    const filteredHistory = relevantHistory.filter(h => h.status === filter);
+    const relevantHistory = history.filter(h => !computeOverPrefix || h.status.startsWith(computeOverPrefix));
+    const filteredHistory = relevantHistory.filter(h => filter.includes(h.status));
     return {
-      currentStreak: countWhile([...relevantHistory].reverse(), h => h.status === filter),
+      currentStreak: countWhile([...relevantHistory].reverse(), h => filter.includes(h.status)),
       rate: relevantHistory.length === 0 ? undefined : filteredHistory.length / relevantHistory.length,
       count: filteredHistory.length,
+      total: relevantHistory.length,
     };
   }
 
-  protected computeFromSlot(slot: bigint | undefined) {
+  protected computeFromSlot(slot: SlotNumber | undefined) {
     if (slot === undefined) {
       return undefined;
     }

package/src/sentinel/store.ts

@@ -1,3 +1,4 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BufferReader, numToUInt8, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
@@ -19,7 +20,7 @@ export class SentinelStore {
 
   constructor(
     private store: AztecAsyncKVStore,
-    private config: { historyLength: number },
+    private config: { historyLength: number; historicProvenPerformanceLength: number },
   ) {
     this.historyMap = store.openMap('sentinel-validator-status');
     this.provenMap = store.openMap('sentinel-validator-proven');
@@ -29,7 +30,11 @@ export class SentinelStore {
     return this.config.historyLength;
   }
 
-  public async updateProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance) {
+  public getHistoricProvenPerformanceLength() {
+    return this.config.historicProvenPerformanceLength;
+  }
+
+  public async updateProvenPerformance(epoch: EpochNumber, performance: ValidatorsEpochPerformance) {
     await this.store.transactionAsync(async () => {
       for (const [who, { missed, total }] of Object.entries(performance)) {
         await this.pushValidatorProvenPerformanceForEpoch({ who: EthAddress.fromString(who), missed, total, epoch });
@@ -37,7 +42,7 @@ export class SentinelStore {
     });
   }
 
-  public async getProvenPerformance(who: EthAddress): Promise<{ missed: number; total: number; epoch: bigint }[]> {
+  public async getProvenPerformance(who: EthAddress): Promise<{ missed: number; total: number; epoch: EpochNumber }[]> {
     const currentPerformanceBuffer = await this.provenMap.getAsync(who.toString());
     return currentPerformanceBuffer ? this.deserializePerformance(currentPerformanceBuffer) : [];
   }
@@ -51,7 +56,7 @@ export class SentinelStore {
     who: EthAddress;
     missed: number;
     total: number;
-    epoch: bigint;
+    epoch: EpochNumber;
   }) {
     const currentPerformance = await this.getProvenPerformance(who);
     const existingIndex = currentPerformance.findIndex(p => p.epoch === epoch);
@@ -65,13 +70,13 @@ export class SentinelStore {
     // Since we keep the size small, this is not a big deal.
     currentPerformance.sort((a, b) => Number(a.epoch - b.epoch));
 
-    // keep the most recent `historyLength` entries.
-    const performanceToKeep = currentPerformance.slice(-this.config.historyLength);
+    // keep the most recent `historicProvenPerformanceLength` entries.
+    const performanceToKeep = currentPerformance.slice(-this.config.historicProvenPerformanceLength);
 
     await this.provenMap.set(who.toString(), this.serializePerformance(performanceToKeep));
   }
 
-  public async updateValidators(slot: bigint, statuses: Record<`0x${string}`, ValidatorStatusInSlot | undefined>) {
+  public async updateValidators(slot: SlotNumber, statuses: Record<`0x${string}`, ValidatorStatusInSlot | undefined>) {
     await this.store.transactionAsync(async () => {
       for (const [who, status] of Object.entries(statuses)) {
         if (status) {
@@ -83,7 +88,7 @@ export class SentinelStore {
 
   private async pushValidatorStatusForSlot(
     who: EthAddress,
-    slot: bigint,
+    slot: SlotNumber,
     status: 'block-mined' | 'block-proposed' | 'block-missed' | 'attestation-sent' | 'attestation-missed',
   ) {
     await this.store.transactionAsync(async () => {
@@ -106,18 +111,18 @@ export class SentinelStore {
     return data && this.deserializeHistory(data);
   }
 
-  private serializePerformance(performance: { missed: number; total: number; epoch: bigint }[]): Buffer {
+  private serializePerformance(performance: { missed: number; total: number; epoch: EpochNumber }[]): Buffer {
     return serializeToBuffer(
       performance.map(p => [numToUInt32BE(Number(p.epoch)), numToUInt32BE(p.missed), numToUInt32BE(p.total)]),
     );
   }
 
-  private deserializePerformance(buffer: Buffer): { missed: number; total: number; epoch: bigint }[] {
+  private deserializePerformance(buffer: Buffer): { missed: number; total: number; epoch: EpochNumber }[] {
     const reader = new BufferReader(buffer);
-    const performance: { missed: number; total: number; epoch: bigint }[] = [];
+    const performance: { missed: number; total: number; epoch: EpochNumber }[] = [];
     while (!reader.isEmpty()) {
       performance.push({
-        epoch: BigInt(reader.readNumber()),
+        epoch: EpochNumber(reader.readNumber()),
         missed: reader.readNumber(),
         total: reader.readNumber(),
       });
@@ -135,7 +140,7 @@ export class SentinelStore {
     const reader = new BufferReader(buffer);
     const history: ValidatorStatusHistory = [];
     while (!reader.isEmpty()) {
-      const slot = BigInt(reader.readNumber());
+      const slot = SlotNumber(reader.readNumber());
       const status = this.statusFromNumber(reader.readUInt8());
       history.push({ slot, status });
     }