@lodestar/fork-choice 1.50.0-dev.5866a397b6 → 1.50.0-dev.58d40975f9

package/src/forkChoice/store.ts

@@ -2,7 +2,7 @@ import {EffectiveBalanceIncrements, IBeaconStateView} from "@lodestar/state-tran
 import {RootHex, Slot, ValidatorIndex, phase0} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {ForkChoiceStateGetter, IFastConfirmationStore} from "./fastConfirmation/types.js";
-import {CheckpointWithBalance, CheckpointWithTotalBalance} from "./interface.js";
+import {CheckpointWithBalance, CheckpointWithTotalBalance, PtcQuorumEvent} from "./interface.js";
 
 /**
  * Stores checkpoints in a hybrid format:
@@ -46,6 +46,7 @@ export interface IForkChoiceStore extends IFastConfirmationStore {
   justifiedBalancesGetter: JustifiedBalancesGetter;
   equivocatingIndices: Set<ValidatorIndex>;
   notifyFastConfirmation?(data: {block: RootHex; slot: Slot; currentSlot: Slot}): void;
+  notifyPtcQuorum?(data: PtcQuorumEvent): void;
 }
 
 /**
@@ -85,6 +86,7 @@ export class ForkChoiceStore implements IForkChoiceStore {
       onJustified: (cp: CheckpointWithHex) => void;
       onFinalized: (cp: CheckpointWithHex) => void;
       onFastConfirmation?: (data: {block: RootHex; slot: Slot; currentSlot: Slot}) => void;
+      onPtcQuorum?: (data: PtcQuorumEvent) => void;
     }
   ) {
     this.justifiedBalancesGetter = justifiedBalancesGetter;
@@ -142,6 +144,10 @@ export class ForkChoiceStore implements IForkChoiceStore {
   notifyFastConfirmation(data: {block: RootHex; slot: Slot; currentSlot: Slot}): void {
     this.events?.onFastConfirmation?.(data);
   }
+
+  notifyPtcQuorum(data: PtcQuorumEvent): void {
+    this.events?.onPtcQuorum?.(data);
+  }
 }
 
 export function toCheckpointWithHex(checkpoint: phase0.Checkpoint): CheckpointWithHex {

package/src/index.ts

@@ -26,6 +26,7 @@ export {
   EpochDifference,
   type IForkChoice,
   NotReorgedReason,
+  type PtcQuorumEvent,
 } from "./forkChoice/interface.js";
 export * from "./forkChoice/safeBlocks.js";
 export {
@@ -43,6 +44,7 @@ export type {
   PayloadExecutionStatus,
   ProtoBlock,
   ProtoNode,
+  PtcQuorum,
 } from "./protoArray/interface.js";
-export {ExecutionStatus, PayloadStatus, isGloasBlock} from "./protoArray/interface.js";
+export {ExecutionStatus, PayloadStatus, getPtcVerdict, isGloasBlock} from "./protoArray/interface.js";
 export {ProtoArray} from "./protoArray/protoArray.js";

package/src/metrics.ts

@@ -68,6 +68,11 @@ export function getForkChoiceMetrics(register: MetricsRegisterExtra) {
         help: "Reason why the current head is not re-orged out",
         labelNames: ["reason"],
       }),
+      ptcQuorum: register.counter<{verdict: "true" | "false"}>({
+        name: "beacon_fork_choice_ptc_quorum_total",
+        help: "Count of decided PTC verdicts, true once majorities voted present and available, false once a majority voted either against",
+        labelNames: ["verdict"],
+      }),
       computeDeltas: {
         duration: register.histogram({
           name: "beacon_fork_choice_compute_deltas_seconds",

package/src/protoArray/interface.ts

@@ -180,3 +180,24 @@ export type ProtoNode = ProtoBlock & {
   bestChild?: number;
   bestDescendant?: number;
 };
+
+/**
+ * PTC majority per PayloadAttestationData field: `true` or `false` once more than PTC_SIZE // 2
+ * members voted that way, `null` while neither outcome has a majority.
+ */
+export type PtcQuorum = {
+  payloadPresent: boolean | null;
+  blobDataAvailable: boolean | null;
+};
+
+/**
+ * The PTC verdict fork choice acts on: `false` once either field has a majority against the
+ * payload, `true` once both have a majority for it, `null` while undecided. A single majority
+ * against is final on its own because should_extend_payload needs both in favour and
+ * should_build_on_full moves the proposer onto EMPTY on either.
+ */
+export function getPtcVerdict({payloadPresent, blobDataAvailable}: PtcQuorum): boolean | null {
+  if (payloadPresent === false || blobDataAvailable === false) return false;
+  if (payloadPresent === true && blobDataAvailable === true) return true;
+  return null;
+}

package/src/protoArray/protoArray.ts

@@ -13,6 +13,7 @@ import {
   PayloadStatus,
   ProtoBlock,
   ProtoNode,
+  PtcQuorum,
   isGloasBlock,
 } from "./interface.js";
 
@@ -52,6 +53,12 @@ export function countNoVotes(attended: BitArray, yes: BitArray): number {
   return count;
 }
 
+function majorityVote(attended: BitArray, yes: BitArray, threshold: number): boolean | null {
+  if (bitCount(yes.uint8Array) > threshold) return true;
+  if (countNoVotes(attended, yes) > threshold) return false;
+  return null;
+}
+
 export const DEFAULT_PRUNE_THRESHOLD = 0;
 type ProposerBoost = {root: RootHex; score: bigint};
 
@@ -801,6 +808,23 @@ export class ProtoArray {
     };
   }
 
+  /**
+   * PTC majority per vote field from the raw tallies, regardless of whether the payload is locally
+   * available. Returns `null` for pre-Gloas (or pruned) roots, which have no vote maps.
+   */
+  getPtcQuorum(blockRoot: RootHex): PtcQuorum | null {
+    const attended = this.ptcAttested.get(blockRoot);
+    const timelinessVotes = this.payloadTimelinessVotes.get(blockRoot);
+    const daVotes = this.payloadDataAvailabilityVotes.get(blockRoot);
+    if (attended === undefined || timelinessVotes === undefined || daVotes === undefined) {
+      return null;
+    }
+    return {
+      payloadPresent: majorityVote(attended, timelinessVotes, PAYLOAD_TIMELY_THRESHOLD),
+      blobDataAvailable: majorityVote(attended, daVotes, DATA_AVAILABILITY_TIMELY_THRESHOLD),
+    };
+  }
+
   getPreviousProposerBoostRoot(): RootHex {
     return this.previousProposerBoost?.root ?? HEX_ZERO_HASH;
   }
@@ -1043,6 +1067,8 @@ export class ProtoArray {
 
   private propagateValidExecutionStatusByIndex(validNodeIndex: number): void {
     let nodeIndex: number | undefined = validNodeIndex;
+    // Payloads that transitioned to VALID, their gloas dependents are validated below
+    const validatedPayloadHashes = new Set<RootHex>();
     // propagate till we keep encountering syncing status
     while (nodeIndex !== undefined) {
       const node = this.getNodeFromIndex(nodeIndex);
@@ -1050,8 +1076,36 @@ export class ProtoArray {
         break;
       }
       this.validateNodeByIndex(nodeIndex);
+      if (node.payloadStatus === PayloadStatus.FULL && node.executionPayloadBlockHash !== null) {
+        validatedPayloadHashes.add(node.executionPayloadBlockHash);
+      }
       nodeIndex = node.parent;
     }
+
+    if (validatedPayloadHashes.size > 0) {
+      this.validatePayloadDependents(validatedPayloadHashes);
+    }
+  }
+
+  /**
+   * Gloas PENDING and EMPTY variants have no payload of their own, they inherit the execution status of
+   * the payload they build on, which is their `executionPayloadBlockHash`. Once that payload is VALID, all
+   * of them are, not only the ones on the chain the validation walked up (e.g. siblings, or blocks
+   * building on a sibling's EMPTY variant).
+   */
+  private validatePayloadDependents(payloadHashes: Set<RootHex>): void {
+    for (let nodeIndex = 0; nodeIndex < this.nodes.length; nodeIndex++) {
+      const node = this.nodes[nodeIndex];
+      if (
+        node.payloadStatus === PayloadStatus.PENDING &&
+        node.executionStatus === ExecutionStatus.Syncing &&
+        node.executionPayloadBlockHash !== null &&
+        payloadHashes.has(node.executionPayloadBlockHash)
+      ) {
+        // Also flips the sibling EMPTY variant
+        this.validateNodeByIndex(nodeIndex);
+      }
+    }
   }
 
   /**