Relax nodeIsViableForHead if justified epoch is previous epoch

packages/beacon-node/src/chain/options.ts

@@ -53,6 +53,7 @@ export const defaultChainOptions: IChainOptions = {
   disableBlsBatchVerify: false,
   proposerBoostEnabled: true,
   computeUnrealized: true,
+  countUnrealizedFull: false,
   safeSlotsToImportOptimistically: SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY,
   suggestedFeeRecipient: defaultValidatorOptions.suggestedFeeRecipient,
   assertCorrectProgressiveBalances: false,

packages/cli/src/options/beaconNodeOptions/chain.ts

@@ -13,6 +13,7 @@ export interface IChainArgs {
   "chain.proposerBoostEnabled": boolean;
   "chain.disableImportExecutionFcU": boolean;
   "chain.computeUnrealized": boolean;
+  "chain.countUnrealizedFull": boolean;
   "chain.assertCorrectProgressiveBalances": boolean;
   "chain.maxSkipSlots": number;
   "safe-slots-to-import-optimistically": number;
@@ -30,6 +31,7 @@ export function parseArgs(args: IChainArgs): IBeaconNodeOptions["chain"] {
     proposerBoostEnabled: args["chain.proposerBoostEnabled"],
     disableImportExecutionFcU: args["chain.disableImportExecutionFcU"],
     computeUnrealized: args["chain.computeUnrealized"],
+    countUnrealizedFull: args["chain.countUnrealizedFull"],
     assertCorrectProgressiveBalances: args["chain.assertCorrectProgressiveBalances"],
     maxSkipSlots: args["chain.maxSkipSlots"],
     safeSlotsToImportOptimistically: args["safe-slots-to-import-optimistically"],
@@ -101,6 +103,14 @@ Will double processing times. Use only for debugging purposes.",
     group: "chain",
   },
 
+  "chain.countUnrealizedFull": {
+    hidden: true,
+    type: "boolean",
+    description: "Compute unrealized checkpoints and fully use it",
+    defaultDescription: String(defaultOptions.chain.computeUnrealized),
+    group: "chain",
+  },
+
   "chain.maxSkipSlots": {
     hidden: true,
     type: "number",

packages/cli/test/unit/options/beaconNodeOptions.test.ts

@@ -23,6 +23,7 @@ describe("options / beaconNodeOptions", () => {
       "chain.proposerBoostEnabled": false,
       "chain.disableImportExecutionFcU": false,
       "chain.computeUnrealized": true,
+      "chain.countUnrealizedFull": true,
       suggestedFeeRecipient: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "chain.assertCorrectProgressiveBalances": true,
       "chain.maxSkipSlots": 100,
@@ -91,6 +92,7 @@ describe("options / beaconNodeOptions", () => {
         proposerBoostEnabled: false,
         disableImportExecutionFcU: false,
         computeUnrealized: true,
+        countUnrealizedFull: true,
         safeSlotsToImportOptimistically: 256,
         suggestedFeeRecipient: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         assertCorrectProgressiveBalances: true,

packages/fork-choice/src/forkChoice/forkChoice.ts

@@ -42,6 +42,7 @@ import {IForkChoiceStore, CheckpointWithHex, toCheckpointWithHex, JustifiedBalan
 export type ForkChoiceOpts = {
   proposerBoostEnabled?: boolean;
   computeUnrealized?: boolean;
+  countUnrealizedFull?: boolean;
 };
 
 /**

packages/fork-choice/src/protoArray/protoArray.ts

@@ -1,7 +1,9 @@
 import {Epoch, RootHex, Slot} from "@lodestar/types";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {GENESIS_EPOCH} from "@lodestar/params";
 import {toHexString} from "@chainsafe/ssz";
 
+import {ForkChoiceOpts} from "../forkChoice/forkChoice.js";
 import {ProtoBlock, ProtoNode, HEX_ZERO_HASH, ExecutionStatus, LVHExecResponse} from "./interface.js";
 import {ProtoArrayError, ProtoArrayErrorCode, LVHExecError, LVHExecErrorCode} from "./errors.js";
 
@@ -23,35 +25,43 @@ export class ProtoArray {
   lvhError?: LVHExecError;
 
   private previousProposerBoost: ProposerBoost | null = null;
-
-  constructor({
-    pruneThreshold,
-    justifiedEpoch,
-    justifiedRoot,
-    finalizedEpoch,
-    finalizedRoot,
-  }: {
-    pruneThreshold: number;
-    justifiedEpoch: Epoch;
-    justifiedRoot: RootHex;
-    finalizedEpoch: Epoch;
-    finalizedRoot: RootHex;
-  }) {
+  private countUnrealizedFull = false;
+
+  constructor(
+    {
+      pruneThreshold,
+      justifiedEpoch,
+      justifiedRoot,
+      finalizedEpoch,
+      finalizedRoot,
+    }: {
+      pruneThreshold: number;
+      justifiedEpoch: Epoch;
+      justifiedRoot: RootHex;
+      finalizedEpoch: Epoch;
+      finalizedRoot: RootHex;
+    },
+    opts?: ForkChoiceOpts
+  ) {
     this.pruneThreshold = pruneThreshold;
     this.justifiedEpoch = justifiedEpoch;
     this.justifiedRoot = justifiedRoot;
     this.finalizedEpoch = finalizedEpoch;
     this.finalizedRoot = finalizedRoot;
+    this.countUnrealizedFull = opts?.countUnrealizedFull ?? false;
   }
 
-  static initialize(block: Omit<ProtoBlock, "targetRoot">, currentSlot: Slot): ProtoArray {
-    const protoArray = new ProtoArray({
-      pruneThreshold: DEFAULT_PRUNE_THRESHOLD,
-      justifiedEpoch: block.justifiedEpoch,
-      justifiedRoot: block.justifiedRoot,
-      finalizedEpoch: block.finalizedEpoch,
-      finalizedRoot: block.finalizedRoot,
-    });
+  static initialize(block: Omit<ProtoBlock, "targetRoot">, currentSlot: Slot, opts?: ForkChoiceOpts): ProtoArray {
+    const protoArray = new ProtoArray(
+      {
+        pruneThreshold: DEFAULT_PRUNE_THRESHOLD,
+        justifiedEpoch: block.justifiedEpoch,
+        justifiedRoot: block.justifiedRoot,
+        finalizedEpoch: block.finalizedEpoch,
+        finalizedRoot: block.finalizedRoot,
+      },
+      opts
+    );
     protoArray.onBlock(
       {
         ...block,
@@ -731,22 +741,30 @@ export class ProtoArray {
     if (node.executionStatus === ExecutionStatus.Invalid) {
       return false;
     }
+    const currentEpoch = computeEpochAtSlot(currentSlot);
+    const previousEpoch = currentEpoch - 1;
 
     // If block is from a previous epoch, filter using unrealized justification & finalization information
     // If block is from the current epoch, filter using the head state's justification & finalization information
-    const isFromPrevEpoch = computeEpochAtSlot(node.slot) < computeEpochAtSlot(currentSlot);
+    const isFromPrevEpoch = computeEpochAtSlot(node.slot) < currentEpoch;
     const nodeJustifiedEpoch = isFromPrevEpoch ? node.unrealizedJustifiedEpoch : node.justifiedEpoch;
     const nodeJustifiedRoot = isFromPrevEpoch ? node.unrealizedJustifiedRoot : node.justifiedRoot;
     const nodeFinalizedEpoch = isFromPrevEpoch ? node.unrealizedFinalizedEpoch : node.finalizedEpoch;
     const nodeFinalizedRoot = isFromPrevEpoch ? node.unrealizedFinalizedRoot : node.finalizedRoot;
 
-    const correctJustified =
-      (nodeJustifiedEpoch === this.justifiedEpoch && nodeJustifiedRoot === this.justifiedRoot) ||
-      this.justifiedEpoch === 0;
-    const correctFinalized =
-      (nodeFinalizedEpoch === this.finalizedEpoch && nodeFinalizedRoot === this.finalizedRoot) ||
-      this.finalizedEpoch === 0;
-    return correctJustified && correctFinalized;
+    // If previous epoch is justified, pull up all tips to at least the previous epoch
+    if (this.countUnrealizedFull && currentEpoch > GENESIS_EPOCH && this.justifiedEpoch === previousEpoch) {
+      return node.unrealizedJustifiedEpoch >= previousEpoch;
+      // If previous epoch is not justified, pull up only tips from past epochs up to the current epoch
+    } else {
+      const correctJustified =
+        (nodeJustifiedEpoch === this.justifiedEpoch && nodeJustifiedRoot === this.justifiedRoot) ||
+        this.justifiedEpoch === 0;
+      const correctFinalized =
+        (nodeFinalizedEpoch === this.finalizedEpoch && nodeFinalizedRoot === this.finalizedRoot) ||
+        this.finalizedEpoch === 0;
+      return correctJustified && correctFinalized;
+    }
   }
 
   /**