@lodestar/beacon-node 1.51.0-dev.44a2c43710 → 1.51.0-dev.4a8c0994a0

package/src/chain/forkChoiceExecutionEngine.ts

@@ -0,0 +1,183 @@
+import {ExecutionStatus, IForkChoice, LVHInvalidResponse} from "@lodestar/fork-choice";
+import {ForkName, ForkPostFulu} from "@lodestar/params";
+import {RootHex, bellatrix} from "@lodestar/types";
+import {BlobAndProofV2} from "@lodestar/types/fulu";
+import {Logger} from "@lodestar/utils";
+import {ExecutionPayloadBodyV2} from "../execution/engine/types.js";
+import {DATA} from "../execution/engine/utils.js";
+import {
+  ClientVersion,
+  ExecutionEngineState,
+  ExecutionPayloadStatus,
+  ForkchoiceUpdatedResult,
+  IExecutionEngine,
+  PayloadAttributes,
+  PayloadId,
+  PayloadIdCache,
+  VersionedHashes,
+} from "../execution/index.js";
+import {Metrics} from "../metrics/index.js";
+import {ExecutionInvalidSource} from "./forkChoice/index.js";
+
+export type ForkChoiceExecutionEngineModules = {
+  forkChoice: IForkChoice;
+  /** Recompute and switch the chain head, fork choice is already updated when this runs */
+  recomputeHeadAfterELInvalidResponse: () => void;
+  logger: Logger;
+  metrics: Metrics | null;
+};
+
+/**
+ * The only handle on the execution engine. Payloads are imported optimistically, so every engine verdict that can
+ * change fork choice is applied here.
+ */
+export class ForkChoiceExecutionEngine {
+  private readonly forkChoice: IForkChoice;
+  private readonly recomputeHeadAfterELInvalidResponse: () => void;
+  private readonly logger: Logger;
+  private readonly metrics: Metrics | null;
+
+  constructor(
+    private readonly engine: IExecutionEngine,
+    modules: ForkChoiceExecutionEngineModules
+  ) {
+    this.forkChoice = modules.forkChoice;
+    this.recomputeHeadAfterELInvalidResponse = modules.recomputeHeadAfterELInvalidResponse;
+    this.logger = modules.logger;
+    this.metrics = modules.metrics;
+  }
+
+  get state(): ExecutionEngineState {
+    return this.engine.state;
+  }
+
+  get clientVersion(): ClientVersion | null | undefined {
+    return this.engine.clientVersion;
+  }
+
+  get payloadIdCache(): PayloadIdCache {
+    return this.engine.payloadIdCache;
+  }
+
+  notifyNewPayload(
+    ...args: Parameters<IExecutionEngine["notifyNewPayload"]>
+  ): ReturnType<IExecutionEngine["notifyNewPayload"]> {
+    return this.engine.notifyNewPayload(...args);
+  }
+
+  /**
+   * `headBlockRoot` is the root of the node whose payload hash is sent as `headBlockHash`, captured by the caller
+   * before the call: root and hash identify the exact fork choice node, gloas variant included.
+   *
+   * The verdict is applied to fork choice before returning. An INVALID verdict throws when preparing a payload so
+   * block production fails, otherwise it resolves to null.
+   */
+  async notifyForkchoiceUpdate(
+    fork: ForkName,
+    headBlockRoot: RootHex,
+    headBlockHash: RootHex,
+    safeBlockHash: RootHex,
+    finalizedBlockHash: RootHex,
+    payloadAttributes?: PayloadAttributes
+  ): Promise<PayloadId | null> {
+    const result = await this.engine.notifyForkchoiceUpdate(
+      fork,
+      headBlockHash,
+      safeBlockHash,
+      finalizedBlockHash,
+      payloadAttributes
+    );
+    this.applyForkchoiceUpdatedResult(headBlockRoot, headBlockHash, result);
+
+    if (result.payloadStatus.status === ExecutionPayloadStatus.INVALID) {
+      if (payloadAttributes) {
+        throw Error(`Invalid prepare payload, validationError=${result.payloadStatus.validationError ?? ""}`);
+      }
+      return null;
+    }
+    return result.payloadId;
+  }
+
+  getPayload(...args: Parameters<IExecutionEngine["getPayload"]>): ReturnType<IExecutionEngine["getPayload"]> {
+    return this.engine.getPayload(...args);
+  }
+
+  getInclusionList(): Promise<bellatrix.Transactions> {
+    return this.engine.getInclusionList();
+  }
+
+  getPayloadBodiesByHashV2(blockHashes: DATA[]): Promise<(ExecutionPayloadBodyV2 | null)[]> {
+    return this.engine.getPayloadBodiesByHashV2(blockHashes);
+  }
+
+  getBlobs(
+    fork: ForkPostFulu,
+    versionedHashes: VersionedHashes,
+    buffers?: Uint8Array[]
+  ): Promise<BlobAndProofV2[] | null> {
+    return this.engine.getBlobs(fork, versionedHashes, buffers);
+  }
+
+  /**
+   * Apply an execution engine INVALID verdict to fork choice and move the chain head off the invalid chain
+   */
+  invalidateExecutionPayloads(lvh: LVHInvalidResponse, source: ExecutionInvalidSource): void {
+    const logCtx = {
+      source,
+      blockRoot: lvh.invalidateFromParentBlockRoot,
+      blockHash: lvh.invalidateFromParentBlockHash,
+      latestValidHash: lvh.latestValidExecHash ?? "null",
+    };
+    const applied = this.forkChoice.validateLatestHash(lvh, {strict: source === ExecutionInvalidSource.blockSegment});
+    if (!applied) {
+      this.logger.warn("Execution engine INVALID verdict not applied to fork choice", logCtx);
+      return;
+    }
+    this.metrics?.forkChoice.executionInvalidations.inc({source});
+    this.logger.warn("Invalidated execution payloads in fork choice", logCtx);
+
+    try {
+      this.recomputeHeadAfterELInvalidResponse();
+    } catch (e) {
+      this.logger.error("Error recomputing head after execution payload invalidation", logCtx, e as Error);
+    }
+  }
+
+  private applyForkchoiceUpdatedResult(
+    headBlockRoot: RootHex,
+    headBlockHash: RootHex,
+    result: ForkchoiceUpdatedResult
+  ): void {
+    const {status, latestValidHash, validationError} = result.payloadStatus;
+    const executionStatus = this.forkChoice.getBlockHexAndBlockHash(headBlockRoot, headBlockHash)?.executionStatus;
+    try {
+      if (status === ExecutionPayloadStatus.INVALID) {
+        if (executionStatus === ExecutionStatus.Invalid) {
+          return;
+        }
+        this.logger.error("Execution engine reported INVALID forkchoice head", {
+          headBlockRoot,
+          headBlockHash,
+          latestValidHash: latestValidHash ?? "null",
+          validationError: validationError ?? "",
+        });
+        this.invalidateExecutionPayloads(
+          {
+            executionStatus: ExecutionStatus.Invalid,
+            latestValidExecHash: latestValidHash,
+            invalidateFromParentBlockRoot: headBlockRoot,
+            invalidateFromParentBlockHash: headBlockHash,
+          },
+          ExecutionInvalidSource.forkchoiceUpdated
+        );
+      } else if (status === ExecutionPayloadStatus.VALID && executionStatus === ExecutionStatus.Syncing) {
+        this.forkChoice.validateLatestHash(
+          {executionStatus: ExecutionStatus.Valid, latestValidExecHash: headBlockHash, blockRoot: headBlockRoot},
+          {strict: false}
+        );
+      }
+    } catch (e) {
+      this.logger.error("Error applying forkchoice update result", {headBlockRoot, headBlockHash, status}, e as Error);
+    }
+  }
+}

package/src/chain/interface.ts

@@ -1,7 +1,7 @@
-import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithHex, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {type PubkeyCache} from "@lodestar/native/pubkeys";
 import {EpochShuffling, IBeaconStateView} from "@lodestar/state-transition";
 import {
   BeaconBlock,
@@ -25,7 +25,7 @@ import {
 } from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {BuilderApiClient} from "../execution/builder/apiClient.js";
-import {IExecutionBuilder, IExecutionEngine} from "../execution/index.js";
+import {IExecutionBuilder} from "../execution/index.js";
 import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
 import {IClock} from "../util/clock.js";
@@ -42,6 +42,7 @@ import {BuilderCircuitBreaker} from "./builderCircuitBreaker.js";
 import {ColumnReconstructionTracker} from "./ColumnReconstructionTracker.js";
 import {ChainEventEmitter} from "./emitter.js";
 import {ForkchoiceCaller} from "./forkChoice/index.js";
+import {ForkChoiceExecutionEngine} from "./forkChoiceExecutionEngine.js";
 import {GetBlobsTracker} from "./GetBlobsTracker.js";
 import {LightClientServer} from "./lightClient/index.js";
 import {AggregatedAttestationPool} from "./opPools/aggregatedAttestationPool.js";
@@ -53,11 +54,13 @@ import {
   OpPool,
   PayloadAttestationPool,
   ProposerPreferencesPool,
+  SingleAttestationPool,
   SyncCommitteeMessagePool,
   SyncContributionAndProofPool,
 } from "./opPools/index.js";
 import {IChainOptions} from "./options.js";
 import {AssembledBlockType, BlockAttributes, BlockType, ProduceResult} from "./produceBlock/produceBlockBody.js";
+import {ProposerTracker} from "./proposerTracker.js";
 import {IStateRegenerator, RegenCaller} from "./regen/index.js";
 import {ReprocessController} from "./reprocess.js";
 import {
@@ -77,8 +80,7 @@ import {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenCache/seenPa
 import {ShufflingCache} from "./shufflingCache.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
-export {BlockType, type AssembledBlockType};
-export {type ProposerPreparationData};
+export {type AssembledBlockType, BlockType, type ProposerPreparationData};
 export type BlockHash = RootHex;
 
 export type StateGetOpts = {
@@ -99,7 +101,7 @@ export interface IBeaconChain {
   readonly genesisTime: UintNum64;
   readonly genesisValidatorsRoot: Root;
   earliestAvailableSlot: Slot;
-  readonly executionEngine: IExecutionEngine;
+  readonly executionEngine: ForkChoiceExecutionEngine;
   readonly executionBuilder?: IExecutionBuilder;
   readonly builderCircuitBreaker: BuilderCircuitBreaker;
   readonly builderApiClient: BuilderApiClient;
@@ -127,6 +129,8 @@ export interface IBeaconChain {
   // Ops pool
   readonly attestationPool: AttestationPool;
   readonly aggregatedAttestationPool: AggregatedAttestationPool;
+  readonly singleAttestationPool: SingleAttestationPool;
+  readonly proposerTracker: ProposerTracker;
   readonly syncCommitteeMessagePool: SyncCommitteeMessagePool;
   readonly syncContributionAndProofPool: SyncContributionAndProofPool;
   readonly executionPayloadBidPool: ExecutionPayloadBidPool;
@@ -231,7 +235,6 @@ export interface IBeaconChain {
     root: RootHex
   ): Promise<{block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean} | null>;
   getBlobSidecars(blockSlot: Slot, blockRootHex: string): Promise<deneb.BlobSidecars | null>;
-  getSerializedBlobSidecars(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null>;
   getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecar[]>;
   getSerializedDataColumnSidecars(
     blockSlot: Slot,