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

package/src/aztec-node/server.ts

@@ -11,14 +11,12 @@ import {
 } from '@aztec/constants';
 import { EpochCache, type EpochCacheInterface } from '@aztec/epoch-cache';
 import {
-  type EthSigner,
   type L1ContractAddresses,
   RegistryContract,
   RollupContract,
   createEthereumChain,
   getPublicClient,
 } from '@aztec/ethereum';
-import { createL1TxUtilsWithBlobsFromEthSigner } from '@aztec/ethereum/l1-tx-utils-with-blobs';
 import { compactArray, pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -30,6 +28,7 @@ import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 import { KeystoreManager, loadKeystores, mergeKeystores } from '@aztec/node-keystore';
 import { trySnapshotSync, uploadSnapshot } from '@aztec/node-lib/actions';
+import { createL1TxUtilsWithBlobsFromEthSigner } from '@aztec/node-lib/factories';
 import { type P2P, type P2PClientDeps, createP2PClient, getDefaultAllowedSetupFunctions } from '@aztec/p2p';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import {
@@ -74,6 +73,7 @@ import {
   type GetPublicLogsResponse,
 } from '@aztec/stdlib/interfaces/client';
 import {
+  type AllowedElement,
   type ClientProtocolCircuitVerifier,
   type L2LogsSource,
   type Service,
@@ -82,7 +82,7 @@ import {
   tryStop,
 } from '@aztec/stdlib/interfaces/server';
 import type { LogFilter, PrivateLog, TxScopedL2Log } from '@aztec/stdlib/logs';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { InboxLeaf, type L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { P2PClientType } from '@aztec/stdlib/p2p';
 import type { Offense, SlashPayloadRound } from '@aztec/stdlib/slashing';
 import type { NullifierLeafPreimage, PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
@@ -108,7 +108,12 @@ import {
   getTelemetryClient,
   trackSpan,
 } from '@aztec/telemetry-client';
-import { NodeKeystoreAdapter, ValidatorClient, createValidatorClient } from '@aztec/validator-client';
+import {
+  NodeKeystoreAdapter,
+  ValidatorClient,
+  createBlockProposalHandler,
+  createValidatorClient,
+} from '@aztec/validator-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
 import { createPublicClient, fallback, http } from 'viem';
@@ -212,6 +217,8 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       }
     }
 
+    await keyStoreManager?.validateSigners();
+
     // If we are a validator, verify our configuration before doing too much more.
     if (!config.disableValidator) {
       if (keyStoreManager === undefined) {
@@ -222,7 +229,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
           'KEY STORE CREATED FROM ENVIRONMENT, IT IS RECOMMENDED TO USE A FILE-BASED KEY STORE IN PRODUCTION ENVIRONMENTS',
         );
       }
-      ValidatorClient.validateKeyStoreConfiguration(keyStoreManager);
+      ValidatorClient.validateKeyStoreConfiguration(keyStoreManager, log);
     }
 
     // validate that the actual chain id matches that specified in configuration
@@ -300,12 +307,7 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       deps.p2pClientDeps,
     );
 
-    // Start world state and wait for it to sync to the archiver.
-    await worldStateSynchronizer.start();
-
-    // Start p2p. Note that it depends on world state to be running.
-    await p2pClient.start();
-
+    // We should really not be modifying the config object
     config.txPublicSetupAllowList = config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
 
     const blockBuilder = new BlockBuilder(
@@ -316,8 +318,52 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       telemetry,
     );
 
+    // We'll accumulate sentinel watchers here
     const watchers: Watcher[] = [];
 
+    // Create validator client if required
+    const validatorClient = createValidatorClient(config, {
+      p2pClient,
+      telemetry,
+      dateProvider,
+      epochCache,
+      blockBuilder,
+      blockSource: archiver,
+      l1ToL2MessageSource: archiver,
+      keyStoreManager,
+    });
+
+    // If we have a validator client, register it as a source of offenses for the slasher,
+    // and have it register callbacks on the p2p client *before* we start it, otherwise messages
+    // like attestations or auths will fail.
+    if (validatorClient) {
+      watchers.push(validatorClient);
+      if (!options.dontStartSequencer) {
+        await validatorClient.registerHandlers();
+      }
+    }
+
+    // If there's no validator client but alwaysReexecuteBlockProposals is enabled,
+    // create a BlockProposalHandler to reexecute block proposals for monitoring
+    if (!validatorClient && config.alwaysReexecuteBlockProposals) {
+      log.info('Setting up block proposal reexecution for monitoring');
+      createBlockProposalHandler(config, {
+        blockBuilder,
+        epochCache,
+        blockSource: archiver,
+        l1ToL2MessageSource: archiver,
+        p2pClient,
+        dateProvider,
+        telemetry,
+      }).registerForReexecution(p2pClient);
+    }
+
+    // Start world state and wait for it to sync to the archiver.
+    await worldStateSynchronizer.start();
+
+    // Start p2p. Note that it depends on world state to be running.
+    await p2pClient.start();
+
     const validatorsSentinel = await createSentinel(epochCache, archiver, p2pClient, config);
     if (validatorsSentinel) {
       // we can run a sentinel without trying to slash.
@@ -349,21 +395,6 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       watchers.push(attestationsBlockWatcher);
     }
 
-    const validatorClient = createValidatorClient(config, {
-      p2pClient,
-      telemetry,
-      dateProvider,
-      epochCache,
-      blockBuilder,
-      blockSource: archiver,
-      l1ToL2MessageSource: archiver,
-      keyStoreManager,
-    });
-
-    if (validatorClient) {
-      watchers.push(validatorClient);
-    }
-
     log.verbose(`All Aztec Node subsystems synced`);
 
     // Validator enabled, create/start relevant service
@@ -389,9 +420,12 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       );
       await slasherClient.start();
 
-      const l1TxUtils = keyStoreManager!.createAllValidatorPublisherSigners().map((signer: EthSigner) => {
-        return createL1TxUtilsWithBlobsFromEthSigner(publicClient, signer, log, dateProvider, config);
-      });
+      const l1TxUtils = await createL1TxUtilsWithBlobsFromEthSigner(
+        publicClient,
+        keyStoreManager!.createAllValidatorPublisherSigners(),
+        { ...config, scope: 'sequencer' },
+        { telemetry, logger: log.createChild('l1-tx-utils'), dateProvider },
+      );
 
       sequencer = await SequencerClient.new(config, {
         // if deps were provided, they should override the defaults,
@@ -416,6 +450,8 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     if (!options.dontStartSequencer && sequencer) {
       await sequencer.start();
       log.verbose(`Sequencer started`);
+    } else if (sequencer) {
+      log.warn(`Sequencer created but not started`);
     }
 
     return new AztecNodeService(
@@ -473,6 +509,10 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     return Promise.resolve(this.p2pClient.getEnr()?.encodeTxt());
   }
 
+  public async getAllowedPublicSetup(): Promise<AllowedElement[]> {
+    return this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+  }
+
   /**
    * Method to determine if the node is ready to accept transactions.
    * @returns - Flag indicating the readiness for tx submission.
@@ -508,8 +548,29 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
    * @param number - The block number being requested.
    * @returns The requested block.
    */
-  public async getBlock(number: number): Promise<L2Block | undefined> {
-    return await this.blockSource.getBlock(number);
+  public async getBlock(number: L2BlockNumber): Promise<L2Block | undefined> {
+    const blockNumber = number === 'latest' ? await this.getBlockNumber() : number;
+    return await this.blockSource.getBlock(blockNumber);
+  }
+
+  /**
+   * Get a block specified by its hash.
+   * @param blockHash - The block hash being requested.
+   * @returns The requested block.
+   */
+  public async getBlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+    const publishedBlock = await this.blockSource.getPublishedBlockByHash(blockHash);
+    return publishedBlock?.block;
+  }
+
+  /**
+   * Get a block specified by its archive root.
+   * @param archive - The archive root being requested.
+   * @returns The requested block.
+   */
+  public async getBlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+    const publishedBlock = await this.blockSource.getPublishedBlockByArchive(archive);
+    return publishedBlock?.block;
   }
 
   /**
@@ -858,13 +919,19 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     return [witness.index, witness.path];
   }
 
+  public async getL1ToL2MessageBlock(l1ToL2Message: Fr): Promise<number | undefined> {
+    const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
+    return messageIndex ? InboxLeaf.l2BlockFromIndex(messageIndex) : undefined;
+  }
+
   /**
    * Returns whether an L1 to L2 message is synced by archiver and if it's ready to be included in a block.
    * @param l1ToL2Message - The L1 to L2 message to check.
    * @returns Whether the message is synced and ready to be included in a block.
    */
   public async isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
-    return (await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message)) !== undefined;
+    const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
+    return messageIndex !== undefined;
   }
 
   /**
@@ -1014,6 +1081,24 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
       : this.blockSource.getBlockHeader(blockNumber);
   }
 
+  /**
+   * Get a block header specified by its hash.
+   * @param blockHash - The block hash being requested.
+   * @returns The requested block header.
+   */
+  public async getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+    return await this.blockSource.getBlockHeaderByHash(blockHash);
+  }
+
+  /**
+   * Get a block header specified by its archive root.
+   * @param archive - The archive root being requested.
+   * @returns The requested block header.
+   */
+  public async getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    return await this.blockSource.getBlockHeaderByArchive(archive);
+  }
+
   /**
    * Simulates the public part of a transaction with the current state.
    * @param tx - The transaction to simulate.
@@ -1062,12 +1147,11 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
 
     const merkleTreeFork = await this.worldStateSynchronizer.fork();
     try {
-      const processor = publicProcessorFactory.create(
-        merkleTreeFork,
-        newGlobalVariables,
+      const processor = publicProcessorFactory.create(merkleTreeFork, newGlobalVariables, {
         skipFeeEnforcement,
-        /*clientInitiatedSimulation*/ true,
-      );
+        clientInitiatedSimulation: true,
+        maxDebugLogMemoryReads: this.config.rpcSimulatePublicMaxDebugLogMemoryReads,
+      });
 
       // REFACTOR: Consider merging ProcessReturnValues into ProcessedTx
       const [processedTxs, failedTxs, _usedTxs, returns] = await processor.process([tx]);
@@ -1122,12 +1206,14 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
 
   public async setConfig(config: Partial<AztecNodeAdminConfig>): Promise<void> {
     const newConfig = { ...this.config, ...config };
-    this.sequencer?.updateSequencerConfig(config);
+    this.sequencer?.updateConfig(config);
     this.slasherClient?.updateConfig(config);
     this.validatorsSentinel?.updateConfig(config);
-    // this.blockBuilder.updateConfig(config); // TODO: Spyros has a PR to add the builder to `this`, so we can do this
     await this.p2pClient.updateP2PConfig(config);
-
+    const archiver = this.blockSource as Archiver;
+    if ('updateConfig' in archiver) {
+      archiver.updateConfig(config);
+    }
     if (newConfig.realProofs !== this.config.realProofs) {
       this.proofVerifier = config.realProofs ? await BBCircuitVerifier.new(newConfig) : new TestCircuitVerifier();
     }

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,26 @@
 import type { EpochCache } from '@aztec/epoch-cache';
-import { countWhile, filterAsync } from '@aztec/foundation/collection';
+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,
@@ -85,7 +91,9 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
         this.slotNumberToBlock.set(block.block.header.getSlot(), {
           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!),
         });
       }
 
@@ -115,53 +123,38 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
       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: bigint): 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,
+    }));
   }
 
   /**
@@ -199,11 +192,13 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   }
 
   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}`);
+    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,7 +211,7 @@ 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,
@@ -224,7 +219,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     }));
 
     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 },
       );
@@ -326,15 +321,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 });
 
@@ -378,20 +378,24 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
 
   /** 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?: bigint; toSlot?: bigint; 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 ??= (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: result,
+      stats,
       lastProcessedSlot: this.lastProcessedSlot,
       initialSlot: this.initialSlot,
       slotWindow: this.store.getHistoryLength(),
@@ -447,30 +451,31 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   ): ValidatorStats {
     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(
-        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,
     };
   }
 

package/src/sentinel/store.ts

@@ -19,7 +19,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,6 +29,10 @@ export class SentinelStore {
     return this.config.historyLength;
   }
 
+  public getHistoricProvenPerformanceLength() {
+    return this.config.historicProvenPerformanceLength;
+  }
+
   public async updateProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance) {
     await this.store.transactionAsync(async () => {
       for (const [who, { missed, total }] of Object.entries(performance)) {
@@ -65,8 +69,8 @@ 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));
   }