@lodestar/fork-choice 1.36.0-dev.f657221d88 → 1.36.0-dev.faac5550fb

package/src/protoArray/computeDeltas.ts

@@ -1,11 +1,23 @@
 import {EffectiveBalanceIncrements} from "@lodestar/state-transition";
 import {ValidatorIndex} from "@lodestar/types";
 import {ProtoArrayError, ProtoArrayErrorCode} from "./errors.js";
-import {VoteTracker} from "./interface.js";
+import {NULL_VOTE_INDEX, VoteIndex} from "./interface.js";
 
 // reuse arrays to avoid memory reallocation and gc
 const deltas = new Array<number>();
 
+export type DeltasResult = {
+  deltas: number[];
+  equivocatingValidators: number;
+  // inactive validators before beacon node started
+  oldInactiveValidators: number;
+  // new inactive validators after beacon node started
+  newInactiveValidators: number;
+  // below is for active validators
+  unchangedVoteValidators: number;
+  newVoteValidators: number;
+};
+
 /**
  * Returns a list of `deltas`, where there is one delta for each of the indices in `indices`
  *
@@ -17,27 +29,49 @@ const deltas = new Array<number>();
  */
 export function computeDeltas(
   numProtoNodes: number,
-  votes: VoteTracker[],
+  voteCurrentIndices: VoteIndex[],
+  voteNextIndices: VoteIndex[],
   oldBalances: EffectiveBalanceIncrements,
   newBalances: EffectiveBalanceIncrements,
   equivocatingIndices: Set<ValidatorIndex>
-): number[] {
+): DeltasResult {
+  if (voteCurrentIndices.length !== voteNextIndices.length) {
+    throw new Error(
+      `voteCurrentIndices and voteNextIndices must have the same length: ${voteCurrentIndices.length} !== ${voteNextIndices.length}`
+    );
+  }
+
+  if (numProtoNodes >= NULL_VOTE_INDEX) {
+    // this never happen in practice, but we check to be safe
+    throw new Error(`numProtoNodes must be less than NULL_VOTE_INDEX: ${numProtoNodes} >= ${NULL_VOTE_INDEX}`);
+  }
+
   deltas.length = numProtoNodes;
   deltas.fill(0);
 
   // avoid creating new variables in the loop to potentially reduce GC pressure
   let oldBalance: number, newBalance: number;
-  let currentIndex: number | null, nextIndex: number | null;
+  let currentIndex: VoteIndex, nextIndex: VoteIndex;
+  // sort equivocating indices to avoid Set.has() in the loop
+  const equivocatingArray = Array.from(equivocatingIndices).sort((a, b) => a - b);
+  let equivocatingIndex = 0;
+  let equivocatingValidatorIndex = equivocatingArray[equivocatingIndex];
 
-  for (let vIndex = 0; vIndex < votes.length; vIndex++) {
-    const vote = votes[vIndex];
+  const equivocatingValidators = equivocatingIndices.size;
+  let oldInactiveValidators = 0;
+  let newInactiveValidators = 0;
+  let unchangedVoteValidators = 0;
+  let newVoteValidators = 0;
+
+  for (let vIndex = 0; vIndex < voteNextIndices.length; vIndex++) {
+    currentIndex = voteCurrentIndices[vIndex];
+    nextIndex = voteNextIndices[vIndex];
     // There is no need to create a score change if the validator has never voted or both of their
     // votes are for the zero hash (genesis block)
-    if (vote === undefined) {
+    if (currentIndex === NULL_VOTE_INDEX && nextIndex === NULL_VOTE_INDEX) {
+      oldInactiveValidators++;
       continue;
     }
-    currentIndex = vote.currentIndex;
-    nextIndex = vote.nextIndex;
 
     // IF the validator was not included in the _old_ balances (i.e. it did not exist yet)
     // then say its balance was 0
@@ -50,9 +84,9 @@ export function computeDeltas(
     // on-boarded fewer validators than the prior fork.
     newBalance = newBalances === oldBalances ? oldBalance : (newBalances[vIndex] ?? 0);
 
-    if (equivocatingIndices.size > 0 && equivocatingIndices.has(vIndex)) {
+    if (vIndex === equivocatingValidatorIndex) {
       // this function could be called multiple times but we only want to process slashing validator for 1 time
-      if (currentIndex !== null) {
+      if (currentIndex !== NULL_VOTE_INDEX) {
         if (currentIndex >= numProtoNodes) {
           throw new ProtoArrayError({
             code: ProtoArrayErrorCode.INVALID_NODE_DELTA,
@@ -61,14 +95,21 @@ export function computeDeltas(
         }
         deltas[currentIndex] -= oldBalance;
       }
-      vote.currentIndex = null;
+      voteCurrentIndices[vIndex] = NULL_VOTE_INDEX;
+      equivocatingIndex++;
+      equivocatingValidatorIndex = equivocatingArray[equivocatingIndex];
+      continue;
+    }
+
+    if (oldBalance === 0 && newBalance === 0) {
+      newInactiveValidators++;
       continue;
     }
 
     if (currentIndex !== nextIndex || oldBalance !== newBalance) {
       // We ignore the vote if it is not known in `indices .
       // We assume that it is outside of our tree (ie: pre-finalization) and therefore not interesting
-      if (currentIndex !== null) {
+      if (currentIndex !== NULL_VOTE_INDEX) {
         if (currentIndex >= numProtoNodes) {
           throw new ProtoArrayError({
             code: ProtoArrayErrorCode.INVALID_NODE_DELTA,
@@ -80,7 +121,7 @@ export function computeDeltas(
 
       // We ignore the vote if it is not known in `indices .
       // We assume that it is outside of our tree (ie: pre-finalization) and therefore not interesting
-      if (nextIndex !== null) {
+      if (nextIndex !== NULL_VOTE_INDEX) {
         if (nextIndex >= numProtoNodes) {
           throw new ProtoArrayError({
             code: ProtoArrayErrorCode.INVALID_NODE_DELTA,
@@ -89,9 +130,24 @@ export function computeDeltas(
         }
         deltas[nextIndex] += newBalance;
       }
+      voteCurrentIndices[vIndex] = nextIndex;
+      newVoteValidators++;
+    } else {
+      unchangedVoteValidators++;
     }
-    vote.currentIndex = nextIndex;
+  } // end validator loop
+
+  if (deltas.length !== numProtoNodes) {
+    // deltas array could be growed in the loop, especially if we mistakenly set the [NULL_VOTE_INDEX] to it , just to be safe
+    throw new Error(`deltas length mismatch: expected ${numProtoNodes}, got ${deltas.length}`);
   }
 
-  return deltas;
+  return {
+    deltas,
+    equivocatingValidators,
+    oldInactiveValidators,
+    newInactiveValidators,
+    unchangedVoteValidators,
+    newVoteValidators,
+  };
 }

package/src/protoArray/interface.ts

@@ -6,15 +6,16 @@ import {Epoch, RootHex, Slot, UintNum64} from "@lodestar/types";
 export const HEX_ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
 
 /**
- * Simplified 'latest message' with previous message
- * The index is relative to ProtoArray indices
+ * The null vote index indicates that a validator votes to a non-existent block. This usually happens when
+ * we prune the proto array and the validator's latest message is in the pruned part.
+ * The number of proto nodes will never exceed this value because it represents (0xffffffff / 365 / 24 / 60 / 5), ie > 1634 years of non-finalized network.
  */
-export type VoteTracker = {
-  currentIndex: number | null;
-  // if a vode is out of date (the voted index was in the past while proto array is pruned), it will be set to null
-  nextIndex: number | null;
-  nextEpoch: Epoch;
-};
+export const NULL_VOTE_INDEX = 0xffffffff;
+
+/**
+ * A vote index is a non-negative integer from 0 to NULL_VOTE_INDEX inclusive, and it will never be undefined.
+ */
+export type VoteIndex = number;
 
 export enum ExecutionStatus {
   Valid = "Valid",