@aztec/aztec-node 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/bin/index.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env -S node --no-warnings
 import { createLogger } from '@aztec/foundation/log';
+import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
 import http from 'http';
-import { AztecNodeService, createAztecNodeRpcServer, getConfigEnvVars } from '../index.js';
+import { AztecNodeService, getConfigEnvVars } from '../index.js';
 const { AZTEC_NODE_PORT = 8081, API_PREFIX = '' } = process.env;
 const logger = createLogger('node');
 /**
@@ -26,7 +28,7 @@ const logger = createLogger('node');
     process.once('SIGINT', shutdown);
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     process.once('SIGTERM', shutdown);
-    const rpcServer = createAztecNodeRpcServer(aztecNode);
+    const rpcServer = createTracedJsonRpcServer(aztecNode, AztecNodeApiSchema);
     const app = rpcServer.getApp(API_PREFIX);
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     const httpServer = http.createServer(app.callback());

package/dest/index.d.ts

@@ -1,4 +1,3 @@
 export * from './aztec-node/config.js';
 export * from './aztec-node/server.js';
-export * from './aztec-node/http_rpc_server.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/dest/index.js

@@ -1,3 +1,2 @@
 export * from './aztec-node/config.js';
 export * from './aztec-node/server.js';
-export * from './aztec-node/http_rpc_server.js';

package/dest/sentinel/config.d.ts

@@ -0,0 +1,8 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+export type SentinelConfig = {
+    sentinelHistoryLengthInEpochs: number;
+    sentinelHistoricProvenPerformanceLengthInEpochs: number;
+    sentinelEnabled: boolean;
+};
+export declare const sentinelConfigMappings: ConfigMappingsType<SentinelConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dest/sentinel/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/sentinel/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA2C,MAAM,0BAA0B,CAAC;AAE5G,MAAM,MAAM,cAAc,GAAG;IAC3B,6BAA6B,EAAE,MAAM,CAAC;IACtC,+CAA+C,EAAE,MAAM,CAAC;IACxD,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CA4BrE,CAAC"}

package/dest/sentinel/config.js

@@ -0,0 +1,29 @@
+import { booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+export const sentinelConfigMappings = {
+    sentinelHistoryLengthInEpochs: {
+        description: 'The number of L2 epochs kept of history for each validator for computing their stats.',
+        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',
+        ...booleanConfigHelper(false)
+    }
+};

package/dest/sentinel/factory.d.ts

@@ -0,0 +1,9 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { P2PClient } from '@aztec/p2p';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { SentinelConfig } from './config.js';
+import { Sentinel } from './sentinel.js';
+export declare function createSentinel(epochCache: EpochCache, archiver: L2BlockSource, p2p: P2PClient, config: SentinelConfig & DataStoreConfig & SlasherConfig, logger?: import("@aztec/foundation/log").Logger): Promise<Sentinel | undefined>;
+//# sourceMappingURL=factory.d.ts.map

package/dest/sentinel/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/sentinel/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,wBAAsB,cAAc,CAClC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,aAAa,EACvB,GAAG,EAAE,SAAS,EACd,MAAM,EAAE,cAAc,GAAG,eAAe,GAAG,aAAa,EACxD,MAAM,yCAAgC,GACrC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAiB/B"}

package/dest/sentinel/factory.js

@@ -0,0 +1,17 @@
+import { createLogger } from '@aztec/foundation/log';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { Sentinel } from './sentinel.js';
+import { SentinelStore } from './store.js';
+export async function createSentinel(epochCache, archiver, p2p, config, logger = createLogger('node:sentinel')) {
+    if (!config.sentinelEnabled) {
+        return undefined;
+    }
+    const kvStore = await createStore('sentinel', SentinelStore.SCHEMA_VERSION, config, createLogger('node:sentinel:lmdb'));
+    const storeHistoryLength = config.sentinelHistoryLengthInEpochs * epochCache.getL1Constants().epochDuration;
+    const storeHistoricProvenPerformanceLength = config.sentinelHistoricProvenPerformanceLengthInEpochs;
+    const sentinelStore = new SentinelStore(kvStore, {
+        historyLength: storeHistoryLength,
+        historicProvenPerformanceLength: storeHistoricProvenPerformanceLength
+    });
+    return new Sentinel(epochCache, archiver, p2p, sentinelStore, config, logger);
+}

package/dest/sentinel/index.d.ts

@@ -0,0 +1,3 @@
+export { Sentinel } from './sentinel.js';
+export type { ValidatorsStats, ValidatorStats, ValidatorStatusHistory, ValidatorStatusInSlot, } from '@aztec/stdlib/validators';
+//# sourceMappingURL=index.d.ts.map

package/dest/sentinel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sentinel/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,YAAY,EACV,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC"}

package/dest/sentinel/index.js

@@ -0,0 +1 @@
+export { Sentinel } from './sentinel.js';

package/dest/sentinel/sentinel.d.ts

@@ -0,0 +1,91 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type L2TipsStore } from '@aztec/kv-store/stores';
+import type { P2PClient } from '@aztec/p2p';
+import { type Watcher, type WatcherEmitter } from '@aztec/slasher';
+import type { SlasherConfig } from '@aztec/slasher/config';
+import { type L2BlockSource, L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
+import type { SingleValidatorStats, ValidatorStats, ValidatorStatusHistory, ValidatorStatusInSlot, ValidatorStatusType, ValidatorsEpochPerformance, ValidatorsStats } from '@aztec/stdlib/validators';
+import { SentinelStore } from './store.js';
+declare const Sentinel_base: new () => WatcherEmitter;
+export declare class Sentinel extends Sentinel_base implements L2BlockStreamEventHandler, Watcher {
+    protected epochCache: EpochCache;
+    protected archiver: L2BlockSource;
+    protected p2p: P2PClient;
+    protected store: SentinelStore;
+    protected config: Pick<SlasherConfig, 'slashInactivityTargetPercentage' | 'slashInactivityPenalty' | 'slashInactivityConsecutiveEpochThreshold'>;
+    protected logger: import("@aztec/foundation/log").Logger;
+    protected runningPromise: RunningPromise;
+    protected blockStream: L2BlockStream;
+    protected l2TipsStore: L2TipsStore;
+    protected initialSlot: bigint | undefined;
+    protected lastProcessedSlot: bigint | undefined;
+    protected slotNumberToBlock: Map<bigint, {
+        blockNumber: number;
+        archive: string;
+        attestors: EthAddress[];
+    }>;
+    constructor(epochCache: EpochCache, archiver: L2BlockSource, p2p: P2PClient, store: SentinelStore, config: Pick<SlasherConfig, 'slashInactivityTargetPercentage' | 'slashInactivityPenalty' | 'slashInactivityConsecutiveEpochThreshold'>, logger?: import("@aztec/foundation/log").Logger);
+    updateConfig(config: Partial<SlasherConfig>): void;
+    start(): Promise<void>;
+    /** Loads initial slot and initializes blockstream. We will not process anything at or before the initial slot. */
+    protected init(): Promise<void>;
+    stop(): Promise<void>;
+    handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
+    protected handleChainProven(event: L2BlockStreamEvent): Promise<void>;
+    protected computeProvenPerformance(epoch: bigint): Promise<ValidatorsEpochPerformance>;
+    /**
+     * Checks if a validator has been inactive for the specified number of consecutive epochs for which we have data on it.
+     * @param validator The validator address to check
+     * @param currentEpoch Epochs strictly before the current one are evaluated only
+     * @param requiredConsecutiveEpochs Number of consecutive epochs required for slashing
+     */
+    protected checkPastInactivity(validator: EthAddress, currentEpoch: bigint, requiredConsecutiveEpochs: number): Promise<boolean>;
+    protected handleProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance): Promise<void>;
+    /**
+     * Process data for two L2 slots ago.
+     * Note that we do not process historical data, since we rely on p2p data for processing,
+     * and we don't have that data if we were offline during the period.
+     */
+    work(): Promise<void>;
+    /**
+     * Check if we are ready to process data for two L2 slots ago, so we allow plenty of time for p2p to process all in-flight attestations.
+     * 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 isReadyToProcess(currentSlot: bigint): Promise<bigint | false>;
+    /**
+     * Gathers committee and proposer data for a given slot, computes slot stats,
+     * and updates overall stats.
+     */
+    protected processSlot(slot: bigint): Promise<void>;
+    /** Computes activity for a given slot. */
+    protected getSlotActivity(slot: bigint, epoch: bigint, proposer: EthAddress, committee: EthAddress[]): Promise<{
+        [k: string]: ValidatorStatusInSlot | undefined;
+    }>;
+    /** Push the status for each slot for each validator. */
+    protected updateValidators(slot: bigint, stats: Record<`0x${string}`, ValidatorStatusInSlot | undefined>): Promise<void>;
+    /** Computes stats to be returned based on stored data. */
+    computeStats({ fromSlot, toSlot, validators, }?: {
+        fromSlot?: bigint;
+        toSlot?: bigint;
+        validators?: EthAddress[];
+    }): Promise<ValidatorsStats>;
+    /** Computes stats for a single validator. */
+    getValidatorStats(validatorAddress: EthAddress, fromSlot?: bigint, toSlot?: bigint): Promise<SingleValidatorStats | undefined>;
+    protected computeStatsForValidator(address: `0x${string}`, allHistory: ValidatorStatusHistory, fromSlot?: bigint, toSlot?: bigint): ValidatorStats;
+    protected computeMissed(history: ValidatorStatusHistory, computeOverPrefix: ValidatorStatusType | undefined, filter: ValidatorStatusInSlot[]): {
+        currentStreak: number;
+        rate: number | undefined;
+        count: number;
+        total: number;
+    };
+    protected computeFromSlot(slot: bigint | undefined): {
+        timestamp: bigint;
+        slot: bigint;
+        date: string;
+    } | undefined;
+}
+export {};
+//# sourceMappingURL=sentinel.d.ts.map

package/dest/sentinel/sentinel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentinel.d.ts","sourceRoot":"","sources":["../../src/sentinel/sentinel.ts"],"names":[],"mappings":"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"}

package/dest/sentinel/sentinel.js

@@ -0,0 +1,391 @@
+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 } from '@aztec/kv-store/stores';
+import { OffenseType, WANT_TO_SLASH_EVENT } from '@aztec/slasher';
+import { L2BlockStream, getAttestationInfoFromPublishedL2Block } from '@aztec/stdlib/block';
+import { getEpochAtSlot, getSlotRangeForEpoch, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import EventEmitter from 'node:events';
+export class Sentinel extends EventEmitter {
+    epochCache;
+    archiver;
+    p2p;
+    store;
+    config;
+    logger;
+    runningPromise;
+    blockStream;
+    l2TipsStore;
+    initialSlot;
+    lastProcessedSlot;
+    slotNumberToBlock;
+    constructor(epochCache, archiver, p2p, store, config, logger = createLogger('node:sentinel')){
+        super(), this.epochCache = epochCache, this.archiver = archiver, this.p2p = p2p, this.store = store, this.config = config, this.logger = logger, this.slotNumberToBlock = new Map();
+        this.l2TipsStore = new L2TipsMemoryStore();
+        const interval = epochCache.getL1Constants().ethereumSlotDuration * 1000 / 4;
+        this.runningPromise = new RunningPromise(this.work.bind(this), logger, interval);
+    }
+    updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    async start() {
+        await this.init();
+        this.runningPromise.start();
+    }
+    /** Loads initial slot and initializes blockstream. We will not process anything at or before the initial slot. */ async init() {
+        this.initialSlot = this.epochCache.getEpochAndSlotNow().slot;
+        const startingBlock = 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
+        });
+    }
+    stop() {
+        return this.runningPromise.stop();
+    }
+    async handleBlockStreamEvent(event) {
+        await this.l2TipsStore.handleBlockStreamEvent(event);
+        if (event.type === 'blocks-added') {
+            // 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,
+                    archive: block.block.archive.root.toString(),
+                    attestors: getAttestationInfoFromPublishedL2Block(block).filter((a)=>a.status === 'recovered-from-signature').map((a)=>a.address)
+                });
+            }
+            // Prune the archive map to only keep at most N entries
+            const historyLength = this.store.getHistoryLength();
+            if (this.slotNumberToBlock.size > historyLength) {
+                const toDelete = Array.from(this.slotNumberToBlock.keys()).sort((a, b)=>Number(a - b)).slice(0, this.slotNumberToBlock.size - historyLength);
+                for (const key of toDelete){
+                    this.slotNumberToBlock.delete(key);
+                }
+            }
+        } else if (event.type === 'chain-proven') {
+            await this.handleChainProven(event);
+        }
+    }
+    async handleChainProven(event) {
+        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;
+        }
+        // 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.store.updateProvenPerformance(epoch, performance);
+        await this.handleProvenPerformance(epoch, performance);
+    }
+    async computeProvenPerformance(epoch) {
+        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,
+            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
+            }));
+    }
+    /**
+   * Checks if a validator has been inactive for the specified number of consecutive epochs for which we have data on it.
+   * @param validator The validator address to check
+   * @param currentEpoch Epochs strictly before the current one are evaluated only
+   * @param requiredConsecutiveEpochs Number of consecutive epochs required for slashing
+   */ async checkPastInactivity(validator, currentEpoch, requiredConsecutiveEpochs) {
+        if (requiredConsecutiveEpochs === 0) {
+            return true;
+        }
+        // Get all historical performance for this validator
+        const allPerformance = await this.store.getProvenPerformance(validator);
+        // If we don't have enough historical data, don't slash
+        if (allPerformance.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).slice(0, requiredConsecutiveEpochs).every((p)=>p.missed / p.total >= this.config.slashInactivityTargetPercentage);
+    }
+    async handleProvenPerformance(epoch, performance) {
+        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,
+            epoch,
+            inactivityTargetPercentage: this.config.slashInactivityTargetPercentage
+        });
+        const epochThreshold = this.config.slashInactivityConsecutiveEpochThreshold;
+        const criminals = await filterAsync(inactiveValidators, (address)=>this.checkPastInactivity(EthAddress.fromString(address), epoch, epochThreshold - 1));
+        const args = criminals.map((address)=>({
+                validator: EthAddress.fromString(address),
+                amount: this.config.slashInactivityPenalty,
+                offenseType: OffenseType.INACTIVITY,
+                epochOrSlot: epoch
+            }));
+        if (criminals.length > 0) {
+            this.logger.verbose(`Identified ${criminals.length} validators to slash due to inactivity in at least ${epochThreshold} consecutive epochs`, {
+                ...args,
+                epochThreshold
+            });
+            this.emit(WANT_TO_SLASH_EVENT, args);
+        }
+    }
+    /**
+   * Process data for two L2 slots ago.
+   * Note that we do not process historical data, since we rely on p2p data for processing,
+   * and we don't have that data if we were offline during the period.
+   */ async work() {
+        const { slot: currentSlot } = this.epochCache.getEpochAndSlotNow();
+        try {
+            // Manually sync the block stream to ensure we have the latest data.
+            // Note we never `start` the blockstream, so it loops at the same pace as we do.
+            await this.blockStream.sync();
+            // Check if we are ready to process data for two L2 slots ago.
+            const targetSlot = await this.isReadyToProcess(currentSlot);
+            // And process it if we are.
+            if (targetSlot !== false) {
+                await this.processSlot(targetSlot);
+            }
+        } catch (err) {
+            this.logger.error(`Failed to process slot ${currentSlot}`, err);
+        }
+    }
+    /**
+   * Check if we are ready to process data for two L2 slots ago, so we allow plenty of time for p2p to process all in-flight attestations.
+   * 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.
+   */ async isReadyToProcess(currentSlot) {
+        const targetSlot = currentSlot - 2n;
+        if (this.lastProcessedSlot && this.lastProcessedSlot >= targetSlot) {
+            this.logger.trace(`Already processed slot ${targetSlot}`, {
+                lastProcessedSlot: this.lastProcessedSlot
+            });
+            return false;
+        }
+        if (this.initialSlot === undefined) {
+            this.logger.error(`Initial slot not loaded.`);
+            return false;
+        }
+        if (targetSlot <= this.initialSlot) {
+            this.logger.trace(`Refusing to process slot ${targetSlot} given initial slot ${this.initialSlot}`);
+            return false;
+        }
+        const archiverSlot = await this.archiver.getL2SlotNumber();
+        if (archiverSlot === undefined || archiverSlot < targetSlot) {
+            this.logger.debug(`Waiting for archiver to sync with L2 slot ${targetSlot}`, {
+                archiverSlot,
+                targetSlot
+            });
+            return false;
+        }
+        const archiverLastBlockHash = await this.l2TipsStore.getL2Tips().then((tip)=>tip.latest.hash);
+        const p2pLastBlockHash = await this.p2p.getL2Tips().then((tips)=>tips.latest.hash);
+        const isP2pSynced = archiverLastBlockHash === p2pLastBlockHash;
+        if (!isP2pSynced) {
+            this.logger.debug(`Waiting for P2P client to sync with archiver`, {
+                archiverLastBlockHash,
+                p2pLastBlockHash
+            });
+            return false;
+        }
+        return targetSlot;
+    }
+    /**
+   * Gathers committee and proposer data for a given slot, computes slot stats,
+   * and updates overall stats.
+   */ async processSlot(slot) {
+        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}`);
+            this.lastProcessedSlot = slot;
+            return;
+        }
+        const proposerIndex = this.epochCache.computeProposerIndex(slot, epoch, seed, BigInt(committee.length));
+        const proposer = committee[Number(proposerIndex)];
+        const stats = await this.getSlotActivity(slot, epoch, proposer, committee);
+        this.logger.verbose(`Updating L2 slot ${slot} observed activity`, stats);
+        await this.updateValidators(slot, stats);
+        this.lastProcessedSlot = slot;
+    }
+    /** Computes activity for a given slot. */ async getSlotActivity(slot, epoch, proposer, committee) {
+        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
+        // Here we get all attestations for the block mined at the given slot,
+        // or all attestations for all proposals in the slot if no block was mined.
+        // We gather from both p2p (contains the ones seen on the p2p layer) and archiver
+        // (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);
+        // Filter out attestations with invalid signatures
+        const p2pAttestors = p2pAttested.map((a)=>a.getSender()).filter((s)=>s !== undefined);
+        const attestors = new Set([
+            ...p2pAttestors.map((a)=>a.toString()),
+            ...block?.attestors.map((a)=>a.toString()) ?? []
+        ].filter((addr)=>proposer.toString() !== addr));
+        // 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
+        });
+        // Get attestors that failed their duties for this block, but only if there was a block proposed
+        const missedAttestors = new Set(blockStatus === 'missed' ? [] : committee.filter((v)=>!attestors.has(v.toString()) && !proposer.equals(v)).map((v)=>v.toString()));
+        this.logger.debug(`Retrieved ${attestors.size} attestors out of ${committee.length} for slot ${slot}`, {
+            blockStatus,
+            proposer: proposer.toString(),
+            ...block,
+            slot,
+            attestors: [
+                ...attestors
+            ],
+            missedAttestors: [
+                ...missedAttestors
+            ],
+            committee: committee.map((c)=>c.toString())
+        });
+        // Compute the status for each validator in the committee
+        const statusFor = (who)=>{
+            if (who === proposer.toString()) {
+                return `block-${blockStatus}`;
+            } else if (attestors.has(who)) {
+                return 'attestation-sent';
+            } else if (missedAttestors.has(who)) {
+                return 'attestation-missed';
+            } else {
+                return undefined;
+            }
+        };
+        return Object.fromEntries(committee.map((v)=>v.toString()).map((who)=>[
+                who,
+                statusFor(who)
+            ]));
+    }
+    /** Push the status for each slot for each validator. */ updateValidators(slot, stats) {
+        return this.store.updateValidators(slot, stats);
+    }
+    /** Computes stats to be returned based on stored data. */ async computeStats({ fromSlot, toSlot, validators } = {}) {
+        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;
+        fromSlot ??= (this.lastProcessedSlot ?? slotNow) - BigInt(this.store.getHistoryLength());
+        toSlot ??= this.lastProcessedSlot ?? slotNow;
+        const stats = mapValues(histories, (history, address)=>this.computeStatsForValidator(address, history ?? [], fromSlot, toSlot));
+        return {
+            stats,
+            lastProcessedSlot: this.lastProcessedSlot,
+            initialSlot: this.initialSlot,
+            slotWindow: this.store.getHistoryLength()
+        };
+    }
+    /** Computes stats for a single validator. */ async getValidatorStats(validatorAddress, fromSlot, toSlot) {
+        const history = await this.store.getHistory(validatorAddress);
+        if (!history || history.length === 0) {
+            return undefined;
+        }
+        const slotNow = this.epochCache.getEpochAndSlotNow().slot;
+        const effectiveFromSlot = fromSlot ?? (this.lastProcessedSlot ?? slotNow) - BigInt(this.store.getHistoryLength());
+        const effectiveToSlot = toSlot ?? this.lastProcessedSlot ?? slotNow;
+        const historyLength = BigInt(this.store.getHistoryLength());
+        if (effectiveToSlot - effectiveFromSlot > historyLength) {
+            throw new Error(`Slot range (${effectiveToSlot - effectiveFromSlot}) exceeds history length (${historyLength}). ` + `Requested range: ${effectiveFromSlot} to ${effectiveToSlot}.`);
+        }
+        const validator = this.computeStatsForValidator(validatorAddress.toString(), history, effectiveFromSlot, effectiveToSlot);
+        const allTimeProvenPerformance = await this.store.getProvenPerformance(validatorAddress);
+        return {
+            validator,
+            allTimeProvenPerformance,
+            lastProcessedSlot: this.lastProcessedSlot,
+            initialSlot: this.initialSlot,
+            slotWindow: this.store.getHistoryLength()
+        };
+    }
+    computeStatsForValidator(address, allHistory, fromSlot, toSlot) {
+        let history = fromSlot ? allHistory.filter((h)=>h.slot >= fromSlot) : allHistory;
+        history = toSlot ? history.filter((h)=>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(lastProposal?.slot),
+            lastAttestation: this.computeFromSlot(lastAttestation?.slot),
+            totalSlots: history.length,
+            missedProposals: this.computeMissed(history, 'block', [
+                'block-missed'
+            ]),
+            missedAttestations: this.computeMissed(history, 'attestation', [
+                'attestation-missed'
+            ]),
+            history
+        };
+    }
+    computeMissed(history, computeOverPrefix, 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)=>filter.includes(h.status)),
+            rate: relevantHistory.length === 0 ? undefined : filteredHistory.length / relevantHistory.length,
+            count: filteredHistory.length,
+            total: relevantHistory.length
+        };
+    }
+    computeFromSlot(slot) {
+        if (slot === undefined) {
+            return undefined;
+        }
+        const timestamp = getTimestampForSlot(slot, this.epochCache.getL1Constants());
+        return {
+            timestamp,
+            slot,
+            date: new Date(Number(timestamp) * 1000).toISOString()
+        };
+    }
+}

package/dest/sentinel/store.d.ts

@@ -0,0 +1,34 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { ValidatorStatusHistory, ValidatorStatusInSlot, ValidatorsEpochPerformance } from '@aztec/stdlib/validators';
+export declare class SentinelStore {
+    private store;
+    private config;
+    static readonly SCHEMA_VERSION = 2;
+    private readonly historyMap;
+    private readonly provenMap;
+    constructor(store: AztecAsyncKVStore, config: {
+        historyLength: number;
+        historicProvenPerformanceLength: number;
+    });
+    getHistoryLength(): number;
+    getHistoricProvenPerformanceLength(): number;
+    updateProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance): Promise<void>;
+    getProvenPerformance(who: EthAddress): Promise<{
+        missed: number;
+        total: number;
+        epoch: bigint;
+    }[]>;
+    private pushValidatorProvenPerformanceForEpoch;
+    updateValidators(slot: bigint, statuses: Record<`0x${string}`, ValidatorStatusInSlot | undefined>): Promise<void>;
+    private pushValidatorStatusForSlot;
+    getHistories(): Promise<Record<`0x${string}`, ValidatorStatusHistory>>;
+    getHistory(address: EthAddress): Promise<ValidatorStatusHistory | undefined>;
+    private serializePerformance;
+    private deserializePerformance;
+    private serializeHistory;
+    private deserializeHistory;
+    private statusToNumber;
+    private statusFromNumber;
+}
+//# sourceMappingURL=store.d.ts.map