@aztec/aztec-node 0.87.7 → 1.0.0-nightly.20250605

package/src/sentinel/sentinel.ts

@@ -5,6 +5,8 @@ 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 type { SlasherConfig, WantToSlashArgs, Watcher, WatcherEmitter } from '@aztec/slasher/config';
+import { Offence, WANT_TO_SLASH_EVENT } from '@aztec/slasher/config';
 import {
   type L2BlockSource,
   L2BlockStream,
@@ -12,18 +14,21 @@ import {
   type L2BlockStreamEventHandler,
   getAttestationsFromPublishedL2Block,
 } from '@aztec/stdlib/block';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import type {
   ValidatorStats,
   ValidatorStatusHistory,
   ValidatorStatusInSlot,
   ValidatorStatusType,
+  ValidatorsEpochPerformance,
   ValidatorsStats,
 } from '@aztec/stdlib/validators';
 
+import EventEmitter from 'node:events';
+
 import { SentinelStore } from './store.js';
 
-export class Sentinel implements L2BlockStreamEventHandler {
+export class Sentinel extends (EventEmitter as new () => WatcherEmitter) implements L2BlockStreamEventHandler, Watcher {
   protected runningPromise: RunningPromise;
   protected blockStream!: L2BlockStream;
   protected l2TipsStore: L2TipsStore;
@@ -38,8 +43,17 @@ export class Sentinel implements L2BlockStreamEventHandler {
     protected archiver: L2BlockSource,
     protected p2p: P2PClient,
     protected store: SentinelStore,
+    protected config: Pick<
+      SlasherConfig,
+      | 'slashInactivityCreateTargetPercentage'
+      | 'slashInactivityCreatePenalty'
+      | 'slashInactivitySignalTargetPercentage'
+      | 'slashInactivityMaxPenalty'
+      | 'slashPayloadTtlSeconds'
+    >,
     protected logger = createLogger('node:sentinel'),
   ) {
+    super();
     this.l2TipsStore = new L2TipsMemoryStore();
     const interval = (epochCache.getL1Constants().ethereumSlotDuration * 1000) / 4;
     this.runningPromise = new RunningPromise(this.work.bind(this), logger, interval);
@@ -84,7 +98,110 @@ export class Sentinel implements L2BlockStreamEventHandler {
           this.slotNumberToBlock.delete(key);
         }
       }
+    } else if (event.type === 'chain-proven') {
+      await this.handleChainProven(event);
+    }
+  }
+
+  protected async handleChainProven(event: L2BlockStreamEvent) {
+    if (event.type !== 'chain-proven') {
+      return;
+    }
+    const 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());
+    this.logger.info(`Computing proven performance for epoch ${epoch}`);
+    const performance = await this.computeProvenPerformance(epoch);
+    this.logger.info(`Proven performance for epoch ${epoch}`, performance);
+
+    await this.updateProvenPerformance(epoch, performance);
+    this.handleProvenPerformance(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];
+    const { committee } = await this.epochCache.getCommittee(fromSlot);
+    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);
+  }
+
+  protected handleProvenPerformance(performance: ValidatorsEpochPerformance) {
+    const criminals = Object.entries(performance)
+      .filter(([_, { missed, total }]) => {
+        return missed / total >= this.config.slashInactivityCreateTargetPercentage;
+      })
+      .map(([address]) => address as `0x${string}`);
+
+    const args = criminals.map(address => ({
+      validator: EthAddress.fromString(address),
+      amount: this.config.slashInactivityCreatePenalty,
+      offense: Offence.INACTIVITY,
+    }));
+
+    this.logger.info(`Criminals: ${criminals.length}`, { args });
+
+    if (criminals.length > 0) {
+      this.emit(WANT_TO_SLASH_EVENT, args);
+    }
+  }
+
+  public async shouldSlash({ validator, amount }: WantToSlashArgs): Promise<boolean> {
+    const l1Constants = this.epochCache.getL1Constants();
+    const ttlL2Slots = this.config.slashPayloadTtlSeconds / l1Constants.slotDuration;
+    const ttlEpochs = BigInt(Math.ceil(ttlL2Slots / l1Constants.epochDuration));
+
+    const currentEpoch = this.epochCache.getEpochAndSlotNow().epoch;
+    const performance = await this.store.getProvenPerformance(validator);
+    const isCriminal =
+      performance
+        .filter(p => p.epoch >= currentEpoch - ttlEpochs)
+        .findIndex(p => p.missed / p.total >= this.config.slashInactivitySignalTargetPercentage) !== -1;
+    if (isCriminal) {
+      if (amount <= this.config.slashInactivityMaxPenalty) {
+        return true;
+      } else {
+        this.logger.warn(`Validator ${validator} is a criminal but the penalty is too high`, {
+          amount,
+          maxPenalty: this.config.slashInactivityMaxPenalty,
+        });
+        return false;
+      }
     }
+    return false;
   }
 
   /**
@@ -232,14 +349,18 @@ export class Sentinel implements L2BlockStreamEventHandler {
   }
 
   /** Computes stats to be returned based on stored data. */
-  public async computeStats(): Promise<ValidatorsStats> {
+  public async computeStats({
+    fromSlot: _fromSlot,
+    toSlot: _toSlot,
+  }: { fromSlot?: bigint; toSlot?: bigint } = {}): Promise<ValidatorsStats> {
     const histories = await this.store.getHistories();
     const slotNow = this.epochCache.getEpochAndSlotNow().slot;
-    const fromSlot = (this.lastProcessedSlot ?? slotNow) - BigInt(this.store.getHistoryLength());
+    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);
+      result[validatorAddress] = this.computeStatsForValidator(validatorAddress, history, fromSlot, toSlot);
     }
     return {
       stats: result,
@@ -253,8 +374,10 @@ export class Sentinel implements L2BlockStreamEventHandler {
     address: `0x${string}`,
     allHistory: ValidatorStatusHistory,
     fromSlot?: bigint,
+    toSlot?: bigint,
   ): ValidatorStats {
-    const history = fromSlot ? allHistory.filter(h => h.slot >= fromSlot) : allHistory;
+    let history = fromSlot ? allHistory.filter(h => h.slot >= fromSlot) : allHistory;
+    history = toSlot ? history.filter(h => h.slot <= toSlot) : history;
     return {
       address: EthAddress.fromString(address),
       lastProposal: this.computeFromSlot(

package/src/sentinel/store.ts

@@ -1,56 +1,128 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { BufferReader, numToUInt8, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { ValidatorStatusHistory, ValidatorStatusInSlot } from '@aztec/stdlib/validators';
+import type {
+  ValidatorStatusHistory,
+  ValidatorStatusInSlot,
+  ValidatorsEpochPerformance,
+} from '@aztec/stdlib/validators';
 
 export class SentinelStore {
-  public static readonly SCHEMA_VERSION = 1;
+  public static readonly SCHEMA_VERSION = 2;
 
-  private readonly map: AztecAsyncMap<`0x${string}`, Buffer>;
+  // a map from validator address to their ValidatorStatusHistory
+  private readonly historyMap: AztecAsyncMap<`0x${string}`, Buffer>;
+
+  // a map from validator address to their historical proven epoch performance
+  // e.g. { validator: [{ epoch: 1, missed: 1, total: 10 }, { epoch: 2, missed: 3, total: 7 }, ...] }
+  private readonly provenMap: AztecAsyncMap<`0x${string}`, Buffer>;
 
   constructor(
     private store: AztecAsyncKVStore,
     private config: { historyLength: number },
   ) {
-    this.map = store.openMap('sentinel-validator-status');
+    this.historyMap = store.openMap('sentinel-validator-status');
+    this.provenMap = store.openMap('sentinel-validator-proven');
   }
 
   public getHistoryLength() {
     return this.config.historyLength;
   }
 
+  public async updateProvenPerformance(epoch: bigint, 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 });
+      }
+    });
+  }
+
+  public async getProvenPerformance(who: EthAddress): Promise<{ missed: number; total: number; epoch: bigint }[]> {
+    const currentPerformanceBuffer = await this.provenMap.getAsync(who.toString());
+    return currentPerformanceBuffer ? this.deserializePerformance(currentPerformanceBuffer) : [];
+  }
+
+  private async pushValidatorProvenPerformanceForEpoch({
+    who,
+    missed,
+    total,
+    epoch,
+  }: {
+    who: EthAddress;
+    missed: number;
+    total: number;
+    epoch: bigint;
+  }) {
+    const currentPerformance = await this.getProvenPerformance(who);
+    const existingIndex = currentPerformance.findIndex(p => p.epoch === epoch);
+    if (existingIndex !== -1) {
+      currentPerformance[existingIndex] = { missed, total, epoch };
+    } else {
+      currentPerformance.push({ missed, total, epoch });
+    }
+
+    // This should be sorted by epoch, but just in case.
+    // 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);
+
+    await this.provenMap.set(who.toString(), this.serializePerformance(performanceToKeep));
+  }
+
   public async updateValidators(slot: bigint, statuses: Record<`0x${string}`, ValidatorStatusInSlot | undefined>) {
     await this.store.transactionAsync(async () => {
       for (const [who, status] of Object.entries(statuses)) {
         if (status) {
-          await this.pushValidatorStatusForSlot(who as `0x${string}`, slot, status);
+          await this.pushValidatorStatusForSlot(EthAddress.fromString(who), slot, status);
         }
       }
     });
   }
 
   private async pushValidatorStatusForSlot(
-    who: `0x${string}`,
+    who: EthAddress,
     slot: bigint,
     status: 'block-mined' | 'block-proposed' | 'block-missed' | 'attestation-sent' | 'attestation-missed',
   ) {
     const currentHistory = (await this.getHistory(who)) ?? [];
     const newHistory = [...currentHistory, { slot, status }].slice(-this.config.historyLength);
-    await this.map.set(who, this.serializeHistory(newHistory));
+    await this.historyMap.set(who.toString(), this.serializeHistory(newHistory));
   }
 
   public async getHistories(): Promise<Record<`0x${string}`, ValidatorStatusHistory>> {
     const histories: Record<`0x${string}`, ValidatorStatusHistory> = {};
-    for await (const [address, history] of this.map.entriesAsync()) {
+    for await (const [address, history] of this.historyMap.entriesAsync()) {
       histories[address] = this.deserializeHistory(history);
     }
     return histories;
   }
 
-  private async getHistory(address: `0x${string}`): Promise<ValidatorStatusHistory | undefined> {
-    const data = await this.map.getAsync(address);
+  private async getHistory(address: EthAddress): Promise<ValidatorStatusHistory | undefined> {
+    const data = await this.historyMap.getAsync(address.toString());
     return data && this.deserializeHistory(data);
   }
 
+  private serializePerformance(performance: { missed: number; total: number; epoch: bigint }[]): 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 }[] {
+    const reader = new BufferReader(buffer);
+    const performance: { missed: number; total: number; epoch: bigint }[] = [];
+    while (!reader.isEmpty()) {
+      performance.push({
+        epoch: BigInt(reader.readNumber()),
+        missed: reader.readNumber(),
+        total: reader.readNumber(),
+      });
+    }
+    return performance;
+  }
+
   private serializeHistory(history: ValidatorStatusHistory): Buffer {
     return serializeToBuffer(
       history.map(h => [numToUInt32BE(Number(h.slot)), numToUInt8(this.statusToNumber(h.status))]),