feat: proposer boost reorg

packages/api/src/beacon/routes/debug.ts

@@ -34,6 +34,7 @@ const protoNodeSszType = new ContainerType(
     parentRoot: stringType,
     stateRoot: stringType,
     targetRoot: stringType,
+    timeliness: ssz.Boolean,
     justifiedEpoch: ssz.Epoch,
     justifiedRoot: stringType,
     finalizedEpoch: ssz.Epoch,

packages/api/test/unit/beacon/testData/debug.ts

@@ -40,6 +40,7 @@ export const testData: GenericServerTestCases<Api> = {
           weight: 1,
           bestChild: "1",
           bestDescendant: "1",
+          timeliness: false,
         },
       ],
     },

packages/beacon-node/src/api/impl/validator/index.ts

@@ -484,7 +484,6 @@ export function getValidatorApi({
       // forkChoice.updateTime() might have already been called by the onSlot clock
       // handler, in which case this should just return.
       chain.forkChoice.updateTime(slot);
-      chain.recomputeForkChoiceHead();
 
       const fork = config.getForkName(slot);
       // set some sensible opts
@@ -529,10 +528,13 @@ export function getValidatorApi({
       };
 
       logger.verbose("Assembling block with produceEngineOrBuilderBlock", loggerContext);
+      const proposerHead = chain.getProposerHead(slot);
+
       const commonBlockBody = await chain.produceCommonBlockBody({
         slot,
         randaoReveal,
         graffiti: toGraffitiBuffer(graffiti || ""),
+        proposerHead,
       });
       logger.debug("Produced common block body", loggerContext);
 

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

@@ -28,7 +28,7 @@ import {
   bellatrix,
   isBlindedBeaconBlock,
 } from "@lodestar/types";
-import {CheckpointWithHex, ExecutionStatus, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {CheckpointWithHex, ExecutionStatus, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
 import {ProcessShutdownCallback} from "@lodestar/validator";
 import {Logger, gweiToWei, isErrorAborted, pruneSetToMax, sleep, toHex} from "@lodestar/utils";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
@@ -43,7 +43,14 @@ import {ensureDir, writeIfNotExist} from "../util/file.js";
 import {isOptimisticBlock} from "../util/forkChoice.js";
 import {BlockProcessor, ImportBlockOpts} from "./blocks/index.js";
 import {ChainEventEmitter, ChainEvent} from "./emitter.js";
-import {IBeaconChain, ProposerPreparationData, BlockHash, StateGetOpts, CommonBlockBody} from "./interface.js";
+import {
+  IBeaconChain,
+  ProposerPreparationData,
+  BlockHash,
+  StateGetOpts,
+  CommonBlockBody,
+  FindHeadFnName,
+} from "./interface.js";
 import {IChainOptions} from "./options.js";
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
 import {initializeForkChoice} from "./forkChoice/index.js";
@@ -252,7 +259,8 @@ export class BeaconChain implements IBeaconChain {
       clock.currentSlot,
       cachedState,
       opts,
-      this.justifiedBalancesGetter.bind(this)
+      this.justifiedBalancesGetter.bind(this),
+      logger
     );
     const regen = new QueuedStateRegenerator({
       config,
@@ -476,7 +484,7 @@ export class BeaconChain implements IBeaconChain {
 
   async produceCommonBlockBody(blockAttributes: BlockAttributes): Promise<CommonBlockBody> {
     const {slot} = blockAttributes;
-    const head = this.forkChoice.getHead();
+    const head = blockAttributes.proposerHead ?? this.forkChoice.getHead();
     const state = await this.regen.getBlockSlotState(
       head.blockRoot,
       slot,
@@ -648,10 +656,38 @@ export class BeaconChain implements IBeaconChain {
 
   recomputeForkChoiceHead(): ProtoBlock {
     this.metrics?.forkChoice.requests.inc();
-    const timer = this.metrics?.forkChoice.findHead.startTimer();
+    const timer = this.metrics?.forkChoice.findHead.startTimer({entrypoint: FindHeadFnName.recomputeForkChoiceHead});
+
+    try {
+      return this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetCanonicialHead});
+    } catch (e) {
+      this.metrics?.forkChoice.errors.inc();
+      throw e;
+    } finally {
+      timer?.();
+    }
+  }
+
+  predictProposerHead(slot: Slot): ProtoBlock {
+    this.metrics?.forkChoice.requests.inc();
+    const timer = this.metrics?.forkChoice.findHead.startTimer({entrypoint: FindHeadFnName.predictProposerHead});
+
+    try {
+      return this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetPredictedProposerHead, slot});
+    } catch (e) {
+      this.metrics?.forkChoice.errors.inc();
+      throw e;
+    } finally {
+      timer?.();
+    }
+  }
+
+  getProposerHead(slot: Slot): ProtoBlock {
+    this.metrics?.forkChoice.requests.inc();
+    const timer = this.metrics?.forkChoice.findHead.startTimer({entrypoint: FindHeadFnName.getProposerHead});
 
     try {
-      return this.forkChoice.updateHead();
+      return this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetProposerHead, slot});
     } catch (e) {
       this.metrics?.forkChoice.errors.inc();
       throw e;

packages/beacon-node/src/chain/forkChoice/index.ts

@@ -16,6 +16,7 @@ import {
   isMergeTransitionComplete,
 } from "@lodestar/state-transition";
 
+import {Logger} from "@lodestar/utils";
 import {computeAnchorCheckpoint} from "../initState.js";
 import {ChainEventEmitter} from "../emitter.js";
 import {ChainEvent} from "../emitter.js";
@@ -32,7 +33,8 @@ export function initializeForkChoice(
   currentSlot: Slot,
   state: CachedBeaconStateAllForks,
   opts: ForkChoiceOpts,
-  justifiedBalancesGetter: JustifiedBalancesGetter
+  justifiedBalancesGetter: JustifiedBalancesGetter,
+  logger?: Logger
 ): ForkChoice {
   const {blockHeader, checkpoint} = computeAnchorCheckpoint(config, state);
   const finalizedCheckpoint = {...checkpoint};
@@ -68,6 +70,7 @@ export function initializeForkChoice(
         parentRoot: toHexString(blockHeader.parentRoot),
         stateRoot: toHexString(blockHeader.stateRoot),
         blockRoot: toHexString(checkpoint.root),
+        timeliness: true, // Optimisitcally assume is timely
 
         justifiedEpoch: justifiedCheckpoint.epoch,
         justifiedRoot: toHexString(justifiedCheckpoint.root),
@@ -89,6 +92,7 @@ export function initializeForkChoice(
       currentSlot
     ),
 
+    logger,
     opts
   );
 }

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

@@ -62,6 +62,12 @@ export type StateGetOpts = {
   allowRegen: boolean;
 };
 
+export enum FindHeadFnName {
+  recomputeForkChoiceHead = "recomputeForkChoiceHead",
+  predictProposerHead = "predictProposerHead",
+  getProposerHead = "getProposerHead",
+}
+
 /**
  * The IBeaconChain service deals with processing incoming blocks, advancing a state transition
  * and applying the fork choice rule to update the chain head
@@ -180,6 +186,12 @@ export interface IBeaconChain {
 
   recomputeForkChoiceHead(): ProtoBlock;
 
+  /** When proposerBoostReorg is enabled, this is called at slot n-1 to predict the head block to build on if we are proposing at slot n */
+  predictProposerHead(slot: Slot): ProtoBlock;
+
+  /** When proposerBoostReorg is enabled and we are proposing a block, this is called to determine which head block to build on */
+  getProposerHead(slot: Slot): ProtoBlock;
+
   waitForBlock(slot: Slot, root: RootHex): Promise<boolean>;
 
   updateBeaconProposerData(epoch: Epoch, proposers: ProposerPreparationData[]): Promise<void>;

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

@@ -89,6 +89,7 @@ export const defaultChainOptions: IChainOptions = {
   blsVerifyAllMultiThread: false,
   disableBlsBatchVerify: false,
   proposerBoostEnabled: true,
+  proposerBoostReorgEnabled: false,
   computeUnrealized: true,
   safeSlotsToImportOptimistically: SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY,
   suggestedFeeRecipient: defaultValidatorOptions.suggestedFeeRecipient,

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

@@ -2,6 +2,7 @@ import {
   computeEpochAtSlot,
   isExecutionStateType,
   computeTimeAtSlot,
+  CachedBeaconStateExecutions,
   StateHashTreeRootSource,
 } from "@lodestar/state-transition";
 import {ChainForkConfig} from "@lodestar/config";
@@ -143,7 +144,29 @@ export class PrepareNextSlotScheduler {
       if (isExecutionStateType(prepareState)) {
         const proposerIndex = prepareState.epochCtx.getBeaconProposer(prepareSlot);
         const feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
+        let updatedPrepareState = prepareState;
+        let updatedHeadRoot = headRoot;
+
         if (feeRecipient) {
+          // If we are proposing next slot, we need to predict if we can proposer-boost-reorg or not
+          const {slot: proposerHeadSlot, blockRoot: proposerHeadRoot} = this.chain.predictProposerHead(clockSlot);
+
+          // If we predict we can reorg, update prepareState with proposer head block
+          if (proposerHeadRoot !== headRoot || proposerHeadSlot !== headSlot) {
+            this.logger.verbose("Weak head detected. May build on this block instead:", {
+              proposerHeadSlot,
+              proposerHeadRoot,
+            });
+            this.metrics?.weakHeadDetected.inc();
+            updatedPrepareState = (await this.chain.regen.getBlockSlotState(
+              proposerHeadRoot,
+              prepareSlot,
+              {dontTransferCache: !isEpochTransition},
+              RegenCaller.precomputeEpoch
+            )) as CachedBeaconStateExecutions;
+            updatedHeadRoot = proposerHeadRoot;
+          }
+
           // Update the builder status, if enabled shoot an api call to check status
           this.chain.updateBuilderStatus(clockSlot);
           if (this.chain.executionBuilder?.status) {
@@ -166,10 +189,10 @@ export class PrepareNextSlotScheduler {
             this.chain,
             this.logger,
             fork as ForkExecution, // State is of execution type
-            fromHex(headRoot),
+            fromHex(updatedHeadRoot),
             safeBlockHash,
             finalizedBlockHash,
-            prepareState,
+            updatedPrepareState,
             feeRecipient
           );
           this.logger.verbose("PrepareNextSlotScheduler prepared new payload", {
@@ -182,7 +205,7 @@ export class PrepareNextSlotScheduler {
         // If emitPayloadAttributes is true emit a SSE payloadAttributes event
         if (this.chain.opts.emitPayloadAttributes === true) {
           const data = await getPayloadAttributesForSSE(fork as ForkExecution, this.chain, {
-            prepareState,
+            prepareState: updatedPrepareState,
             prepareSlot,
             parentBlockRoot: fromHex(headRoot),
             // The likely consumers of this API are builders and will anyway ignore the

packages/beacon-node/src/chain/produceBlock/produceBlockBody.ts

@@ -28,6 +28,7 @@ import {ChainForkConfig} from "@lodestar/config";
 import {ForkSeq, ForkExecution, isForkExecution} from "@lodestar/params";
 import {toHex, sleep, Logger} from "@lodestar/utils";
 
+import {ProtoBlock} from "@lodestar/fork-choice";
 import type {BeaconChain} from "../chain.js";
 import {PayloadId, IExecutionEngine, IExecutionBuilder, PayloadAttributes} from "../../execution/index.js";
 import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
@@ -65,6 +66,7 @@ export type BlockAttributes = {
   graffiti: Bytes32;
   slot: Slot;
   feeRecipient?: string;
+  proposerHead?: ProtoBlock;
 };
 
 export enum BlockType {

packages/beacon-node/src/metrics/metrics/beacon.ts

@@ -57,10 +57,11 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
     // Non-spec'ed
 
     forkChoice: {
-      findHead: register.histogram({
+      findHead: register.histogram<{entrypoint: string}>({
         name: "beacon_fork_choice_find_head_seconds",
         help: "Time taken to find head in seconds",
         buckets: [0.1, 1, 10],
+        labelNames: ["entrypoint"],
       }),
       requests: register.gauge({
         name: "beacon_fork_choice_requests_total",
@@ -198,5 +199,10 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
       name: "beacon_clock_epoch",
       help: "Current clock epoch",
     }),
+
+    weakHeadDetected: register.gauge({
+      name: "beacon_weak_head_detected",
+      help: "Detected current head block is weak. May reorg it out when proposing next slot. See proposer boost reorg for more",
+    }),
   };
 }

packages/beacon-node/test/mocks/mockedBeaconChain.ts

@@ -133,10 +133,12 @@ vi.mock("../../src/chain/chain.js", async (importActual) => {
       beaconProposerCache: new BeaconProposerCache(),
       shufflingCache: new ShufflingCache(),
       produceCommonBlockBody: vi.fn(),
+      getProposerHead: vi.fn(),
       produceBlock: vi.fn(),
       produceBlindedBlock: vi.fn(),
       getCanonicalBlockAtSlot: vi.fn(),
       recomputeForkChoiceHead: vi.fn(),
+      predictProposerHead: vi.fn(),
       getHeadStateAtCurrentEpoch: vi.fn(),
       getHeadState: vi.fn(),
       updateBuilderStatus: vi.fn(),

packages/beacon-node/test/perf/chain/opPools/aggregatedAttestationPool.test.ts

@@ -64,6 +64,8 @@ describe(`getAttestationsForBlock vc=${vc}`, () => {
         unrealizedFinalizedRoot: toHexString(finalizedCheckpoint.root),
         executionPayloadBlockHash: null,
         executionStatus: ExecutionStatus.PreMerge,
+
+        timeliness: false,
       },
       originalState.slot
     );
@@ -87,6 +89,7 @@ describe(`getAttestationsForBlock vc=${vc}`, () => {
           unrealizedFinalizedRoot: toHexString(finalizedCheckpoint.root),
           executionPayloadBlockHash: null,
           executionStatus: ExecutionStatus.PreMerge,
+          timeliness: false,
         },
         slot
       );

packages/beacon-node/test/perf/chain/produceBlock/produceBlockBody.test.ts

@@ -29,6 +29,7 @@ describe("produceBlockBody", () => {
     chain = new BeaconChain(
       {
         proposerBoostEnabled: true,
+        proposerBoostReorgEnabled: false,
         computeUnrealized: false,
         safeSlotsToImportOptimistically: SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY,
         disableArchiveOnCheckpoint: true,

packages/beacon-node/test/perf/chain/verifyImportBlocks.test.ts

@@ -85,6 +85,7 @@ describe.skip("verify+import blocks - range sync perf test", () => {
       const chain = new BeaconChain(
         {
           proposerBoostEnabled: true,
+          proposerBoostReorgEnabled: false,
           computeUnrealized: false,
           safeSlotsToImportOptimistically: SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY,
           disableArchiveOnCheckpoint: true,

packages/beacon-node/test/unit/chain/prepareNextSlot.test.ts

@@ -120,6 +120,7 @@ describe("PrepareNextSlot scheduler", () => {
     chainStub.emitter.on(routes.events.EventType.payloadAttributes, spy);
     getForkStub.mockReturnValue(ForkName.bellatrix);
     chainStub.recomputeForkChoiceHead.mockReturnValue({...zeroProtoBlock, slot: SLOTS_PER_EPOCH - 3} as ProtoBlock);
+    chainStub.predictProposerHead.mockReturnValue({...zeroProtoBlock, slot: SLOTS_PER_EPOCH - 3} as ProtoBlock);
     forkChoiceStub.getJustifiedBlock.mockReturnValue({} as ProtoBlock);
     forkChoiceStub.getFinalizedBlock.mockReturnValue({} as ProtoBlock);
     updateBuilderStatus.mockReturnValue(void 0);

packages/beacon-node/test/utils/state.ts

@@ -153,5 +153,7 @@ export const zeroProtoBlock: ProtoBlock = {
   unrealizedFinalizedEpoch: 0,
   unrealizedFinalizedRoot: ZERO_HASH_HEX,
 
+  timeliness: false,
+
   ...{executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge},
 };

packages/beacon-node/test/utils/typeGenerator.ts

@@ -40,6 +40,8 @@ export function generateProtoBlock(overrides: Partial<ProtoBlock> = {}): ProtoBl
     unrealizedFinalizedEpoch: 0,
     unrealizedFinalizedRoot: ZERO_HASH_HEX,
 
+    timeliness: false,
+
     ...{executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge},
 
     ...overrides,

packages/beacon-node/test/utils/validationData/attestation.ts

@@ -75,6 +75,8 @@ export function getAttestationValidData(opts: AttestationValidDataOpts): {
     unrealizedFinalizedEpoch: 0,
     unrealizedFinalizedRoot: ZERO_HASH_HEX,
 
+    timeliness: false,
+
     ...{executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge},
   };