@lodestar/beacon-node 1.48.0-dev.2948e4a2af → 1.48.0-dev.30d2b0bf52

package/src/api/impl/validator/index.ts

@@ -133,37 +133,40 @@ type BidCandidate = {
 };
 
 /**
- * Ranking value of a bid, the boosted total payment scaled by 100 as `boostFactor` is a percentage.
- * Kept scaled so bids that differ by less than a percent are not truncated into a tie.
+ * Return the best bid by boosted total payment. A candidate with the max boost factor is
+ * preferred over any other regardless of value, ties prefer a builder api bid over the
+ * p2p bid, and the earlier received bid between builder api bids.
  */
-function getBoostedTotalScaled({totalGwei, boostFactor}: BidCandidate): bigint {
-  return boostFactor * totalGwei;
-}
-
-/** Order bid candidates by preference, best first, used to select a bid and to log the ranking */
-function compareBidCandidates(a: BidCandidate, b: BidCandidate): number {
-  // Preserve max boost preference before comparing bid values
-  const aIsMaxBoost = a.boostFactor === MAX_BUILDER_BOOST_FACTOR;
-  const bIsMaxBoost = b.boostFactor === MAX_BUILDER_BOOST_FACTOR;
-  if (aIsMaxBoost !== bIsMaxBoost) {
-    return aIsMaxBoost ? -1 : 1;
-  }
-
-  const aBoostedTotal = getBoostedTotalScaled(a);
-  const bBoostedTotal = getBoostedTotalScaled(b);
-  if (aBoostedTotal !== bBoostedTotal) {
-    return aBoostedTotal > bBoostedTotal ? -1 : 1;
-  }
-
-  // A tie prefers a builder api bid over the p2p bid
-  const aIsBuilderApi = a.url !== undefined;
-  const bIsBuilderApi = b.url !== undefined;
-  if (aIsBuilderApi !== bIsBuilderApi) {
-    return aIsBuilderApi ? -1 : 1;
+function selectBestBid(candidates: BidCandidate[]): BidCandidate | null {
+  const boostedValue = ({totalGwei, boostFactor}: BidCandidate): bigint => boostFactor * totalGwei;
+  let best: BidCandidate | null = null;
+  for (const candidate of candidates) {
+    if (best === null) {
+      best = candidate;
+      continue;
+    }
+    // Preserve max boost preference before comparing bid values
+    const candidateIsMaxBoost = candidate.boostFactor === MAX_BUILDER_BOOST_FACTOR;
+    const bestIsMaxBoost = best.boostFactor === MAX_BUILDER_BOOST_FACTOR;
+    if (candidateIsMaxBoost !== bestIsMaxBoost) {
+      if (candidateIsMaxBoost) {
+        best = candidate;
+      }
+      continue;
+    }
+    const candidateValue = boostedValue(candidate);
+    const bestValue = boostedValue(best);
+    if (candidateValue > bestValue) {
+      best = candidate;
+    } else if (
+      candidateValue === bestValue &&
+      // A tie prefers a builder api bid over the p2p bid, and the earlier received bid otherwise
+      (best.url === undefined || (candidate.url !== undefined && candidate.receivedMs < best.receivedMs))
+    ) {
+      best = candidate;
+    }
   }
-
-  // and the earlier received bid between builder api bids
-  return a.receivedMs - b.receivedMs;
+  return best;
 }
 
 type ProduceBlockContentsRes = {executionPayloadValue: Wei; consensusBlockValue: Wei} & {
@@ -1046,24 +1049,20 @@ export function getValidatorApi(
           });
         }
 
-        if (candidates.length === 0) {
-          return null;
-        }
-
-        const rankedCandidates = candidates.toSorted(compareBidCandidates);
-        for (const [index, candidate] of rankedCandidates.entries()) {
-          logger.debug("Builder bid candidate", {
+        const best = selectBestBid(candidates);
+        if (candidates.length > 0) {
+          logger.debug("Ranked builder bid candidates", {
             slot,
-            rank: index + 1,
-            source: candidate.url !== undefined ? toPrintableUrl(candidate.url) : "p2p",
-            builder: candidate.signedBid.message.builderIndex,
-            total: prettyGweiToEth(candidate.totalGwei),
-            boost: candidate.boostFactor,
-            boosted: prettyGweiToEth(getBoostedTotalScaled(candidate) / 100n),
-            receivedMs: candidate.receivedMs,
+            candidates: candidates
+              .map(
+                (candidate) =>
+                  `${candidate.url ?? "p2p"}:total=${prettyGweiToEth(candidate.totalGwei)}:boost=${candidate.boostFactor}:received=${candidate.receivedMs}ms`
+              )
+              .join(","),
+            bidSource: best?.url ?? "p2p",
           });
         }
-        return rankedCandidates[0];
+        return best;
       })();
 
       const commonBlockBodyPromise = chain.produceCommonBlockBody({

package/src/chain/chain.ts

@@ -1271,65 +1271,59 @@ export class BeaconChain implements IBeaconChain {
     try {
       const prevHead = this.forkChoice.getHead();
       const head = this.forkChoice.updateAndGetHead({mode: UpdateHeadOpt.GetCanonicalHead}).head;
-      this.emitHeadEvents(prevHead, head);
-      return head;
-    } catch (e) {
-      this.metrics?.forkChoice.errors.inc({entrypoint: UpdateHeadOpt.GetCanonicalHead});
-      throw e;
-    } finally {
-      timer?.();
-    }
-  }
 
-  /**
-   * Emit `head` and `head_v2` when the fork choice head differs between two observations. Every caller that
-   * can move the head, `updateAndGetHead()` and `updateTime()`, must capture the head before and pass both.
-   */
-  private emitHeadEvents(prevHead: ProtoBlock, head: ProtoBlock): void {
-    const headRootChanged = head.blockRoot !== prevHead.blockRoot;
+      const headRootChanged = head.blockRoot !== prevHead.blockRoot;
 
-    if (!headRootChanged && prevHead.payloadStatus === head.payloadStatus) {
-      return;
-    }
+      if (!headRootChanged && prevHead.payloadStatus === head.payloadStatus) {
+        return head;
+      }
 
-    try {
-      const previousDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.previous);
-      const currentDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.current);
-      const epochTransition = computeStartSlotAtEpoch(computeEpochAtSlot(head.slot)) === head.slot;
-      const executionOptimistic = isOptimisticBlock(head);
-
-      if (headRootChanged) {
-        this.emitter.emit(routes.events.EventType.head, {
-          block: head.blockRoot,
-          epochTransition,
-          slot: head.slot,
-          state: head.stateRoot,
-          previousDutyDependentRoot,
-          currentDutyDependentRoot,
-          executionOptimistic,
+      try {
+        const previousDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.previous);
+        const currentDutyDependentRoot = this.forkChoice.getDependentRoot(head, EpochDifference.current);
+        const epochTransition = computeStartSlotAtEpoch(computeEpochAtSlot(head.slot)) === head.slot;
+        const executionOptimistic = isOptimisticBlock(head);
+
+        if (headRootChanged) {
+          this.emitter.emit(routes.events.EventType.head, {
+            block: head.blockRoot,
+            epochTransition,
+            slot: head.slot,
+            state: head.stateRoot,
+            previousDutyDependentRoot,
+            currentDutyDependentRoot,
+            executionOptimistic,
+          });
+        }
+
+        this.emitter.emit(routes.events.EventType.headV2, {
+          version: this.config.getForkName(head.slot),
+          data: {
+            slot: head.slot,
+            block: head.blockRoot,
+            state: head.stateRoot,
+            payloadStatus: head.payloadStatus === PayloadStatus.FULL ? "full" : "empty",
+            epochTransition,
+            currentEpochDependentRoot: previousDutyDependentRoot,
+            nextEpochDependentRoot: currentDutyDependentRoot,
+            executionOptimistic,
+          },
         });
+      } catch (e) {
+        // getDependentRoot() may fail with error: "No block for root" as we can see in holesky non-finality issue
+        this.logger.debug(
+          "Error emitting head/head_v2 event",
+          {slot: head.slot, root: head.blockRoot, headRootChanged},
+          e as Error
+        );
       }
 
-      this.emitter.emit(routes.events.EventType.headV2, {
-        version: this.config.getForkName(head.slot),
-        data: {
-          slot: head.slot,
-          block: head.blockRoot,
-          state: head.stateRoot,
-          payloadStatus: head.payloadStatus === PayloadStatus.FULL ? "full" : "empty",
-          epochTransition,
-          currentEpochDependentRoot: previousDutyDependentRoot,
-          nextEpochDependentRoot: currentDutyDependentRoot,
-          executionOptimistic,
-        },
-      });
+      return head;
     } catch (e) {
-      // getDependentRoot() may fail with error: "No block for root" as we can see in holesky non-finality issue
-      this.logger.debug(
-        "Error emitting head/head_v2 event",
-        {slot: head.slot, root: head.blockRoot, headRootChanged},
-        e as Error
-      );
+      this.metrics?.forkChoice.errors.inc({entrypoint: UpdateHeadOpt.GetCanonicalHead});
+      throw e;
+    } finally {
+      timer?.();
     }
   }
 
@@ -1618,10 +1612,7 @@ export class BeaconChain implements IBeaconChain {
       this.processShutdownCallback(this.forkChoice.irrecoverableError);
     }
 
-    // updateTime() recomputes the head on epoch-boundary checkpoint pull-up and under fast confirmation
-    const prevHead = this.forkChoice.getHead();
     this.forkChoice.updateTime(slot);
-    this.emitHeadEvents(prevHead, this.forkChoice.getHead());
     this.metrics?.clockSlot.set(slot);
 
     this.attestationPool.prune(slot);

package/src/chain/produceBlock/produceBlockBody.ts

@@ -528,18 +528,23 @@ export async function produceBlockBody<T extends BlockType>(
         }
       }
 
-      const {blobKzgCommitments, executionRequests} = builderRes;
-      if (blobKzgCommitments === undefined) {
-        throw Error(`Invalid builder getHeader response for fork=${fork}, missing blobKzgCommitments`);
-      }
+      if (ForkSeq[fork] >= ForkSeq.deneb) {
+        const {blobKzgCommitments} = builderRes;
+        if (blobKzgCommitments === undefined) {
+          throw Error(`Invalid builder getHeader response for fork=${fork}, missing blobKzgCommitments`);
+        }
 
-      (blockBody as BlindedBeaconBlockBody<ForkName.fulu>).blobKzgCommitments = blobKzgCommitments;
-      Object.assign(logMeta, {blobs: blobKzgCommitments.length});
+        (blockBody as deneb.BlindedBeaconBlockBody).blobKzgCommitments = blobKzgCommitments;
+        Object.assign(logMeta, {blobs: blobKzgCommitments.length});
+      }
 
-      if (executionRequests === undefined) {
-        throw Error(`Invalid builder getHeader response for fork=${fork}, missing executionRequests`);
+      if (ForkSeq[fork] >= ForkSeq.electra) {
+        const {executionRequests} = builderRes;
+        if (executionRequests === undefined) {
+          throw Error(`Invalid builder getHeader response for fork=${fork}, missing executionRequests`);
+        }
+        (blockBody as electra.BlindedBeaconBlockBody).executionRequests = executionRequests;
       }
-      (blockBody as BlindedBeaconBlockBody<ForkName.fulu>).executionRequests = executionRequests;
     }
 
     // blockType === BlockType.Full
@@ -894,38 +899,45 @@ function preparePayloadAttributes(
 ): SSEPayloadAttributes["payloadAttributes"] {
   const timestamp = computeTimeAtSlot(chain.config, prepareSlot, prepareState.genesisTime);
   const prevRandao = prepareState.getRandaoMix(prepareState.epoch);
-  if (!isStatePostCapella(prepareState)) {
-    throw new Error("Expected Capella state for withdrawals");
-  }
+  const payloadAttributes = {
+    timestamp,
+    prevRandao,
+    suggestedFeeRecipient: feeRecipient,
+  };
 
-  let withdrawals: capella.Withdrawal[];
-  if (isStatePostGloas(prepareState)) {
-    const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
-    if (isExtendingPayload) {
-      // applyParentExecutionPayload sets latestBlockHash = parentBid.blockHash, so a mismatch
-      // here means the caller did not apply parent payload to prepareState
-      if (!byteArrayEquals(prepareState.latestBlockHash, prepareState.latestExecutionPayloadBid.blockHash)) {
-        throw new Error("Expected state with parent execution payload applied for withdrawals");
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    if (!isStatePostCapella(prepareState)) {
+      throw new Error("Expected Capella state for withdrawals");
+    }
+
+    if (isStatePostGloas(prepareState)) {
+      const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
+      if (isExtendingPayload) {
+        // applyParentExecutionPayload sets latestBlockHash = parentBid.blockHash, so a mismatch
+        // here means the caller did not apply parent payload to prepareState
+        if (!byteArrayEquals(prepareState.latestBlockHash, prepareState.latestExecutionPayloadBid.blockHash)) {
+          throw new Error("Expected state with parent execution payload applied for withdrawals");
+        }
+        (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+          prepareState.getExpectedWithdrawals().expectedWithdrawals;
+      } else {
+        // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
+        // already deducted from CL balances but never credited on the EL (the envelope
+        // was not delivered). The next payload must carry those same withdrawals to
+        // restore CL/EL consistency, otherwise validators permanently lose that balance.
+        (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+          prepareState.payloadExpectedWithdrawals;
       }
-      withdrawals = prepareState.getExpectedWithdrawals().expectedWithdrawals;
     } else {
-      // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
-      // already deducted from CL balances but never credited on the EL (the envelope
-      // was not delivered). The next payload must carry those same withdrawals to
-      // restore CL/EL consistency, otherwise validators permanently lose that balance.
-      withdrawals = prepareState.payloadExpectedWithdrawals;
+      // withdrawals logic is now fork aware as it changes on electra fork post capella
+      (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
+        prepareState.getExpectedWithdrawals().expectedWithdrawals;
     }
-  } else {
-    withdrawals = prepareState.getExpectedWithdrawals().expectedWithdrawals;
   }
 
-  const payloadAttributes: deneb.SSEPayloadAttributes["payloadAttributes"] = {
-    timestamp,
-    prevRandao,
-    suggestedFeeRecipient: feeRecipient,
-    withdrawals,
-    parentBeaconBlockRoot: parentBlockRoot,
-  };
+  if (ForkSeq[fork] >= ForkSeq.deneb) {
+    (payloadAttributes as deneb.SSEPayloadAttributes["payloadAttributes"]).parentBeaconBlockRoot = parentBlockRoot;
+  }
 
   if (ForkSeq[fork] >= ForkSeq.gloas) {
     if (!isStatePostGloas(prepareState)) {
@@ -1038,28 +1050,37 @@ export async function produceCommonBlockBody<T extends BlockType>(
     step: BlockProductionStep.attestations,
   });
 
-  const endSyncAggregate = stepsMetrics?.startTimer();
-  const parentBlockRoot = fromHex(parentBlock.blockRoot);
-  const previousSlot = slot - 1;
-  const syncAggregate = this.syncContributionAndProofPool.getAggregate(previousSlot, parentBlockRoot);
-  this.metrics?.production.producedSyncAggregateParticipants.observe(
-    syncAggregate.syncCommitteeBits.getTrueBitIndexes().length
-  );
-  endSyncAggregate?.({
-    step: BlockProductionStep.syncAggregate,
-  });
-
-  // Live proposal production is supported from Fulu onward.
-  return {
+  const blockBody: Omit<CommonBlockBody, "blsToExecutionChanges" | "syncAggregate"> = {
     randaoReveal,
     graffiti,
+    // Eth1 data voting is no longer required since electra
     eth1Data: currentState.eth1Data,
     proposerSlashings: this.opts.disableProposerSlashings === true ? [] : proposerSlashings,
     attesterSlashings,
     attestations,
+    // Since electra, deposits are processed by the execution layer,
+    // we no longer support handling deposits from earlier forks.
     deposits: [],
     voluntaryExits,
-    blsToExecutionChanges,
-    syncAggregate,
   };
+
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    (blockBody as CommonBlockBody).blsToExecutionChanges = blsToExecutionChanges;
+  }
+
+  const endSyncAggregate = stepsMetrics?.startTimer();
+  if (ForkSeq[fork] >= ForkSeq.altair) {
+    const parentBlockRoot = fromHex(parentBlock.blockRoot);
+    const previousSlot = slot - 1;
+    const syncAggregate = this.syncContributionAndProofPool.getAggregate(previousSlot, parentBlockRoot);
+    this.metrics?.production.producedSyncAggregateParticipants.observe(
+      syncAggregate.syncCommitteeBits.getTrueBitIndexes().length
+    );
+    (blockBody as CommonBlockBody).syncAggregate = syncAggregate;
+  }
+  endSyncAggregate?.({
+    step: BlockProductionStep.syncAggregate,
+  });
+
+  return blockBody as CommonBlockBody;
 }