fix(eip8025): compute newPayloadRequestRoot from full ExecutionPayload, not header

Fixes the newPayloadRequestRoot computation to match Lighthouse's approach:
tree_hash_root(NewPayloadRequest) uses the full ExecutionPayload (with transactions,
withdrawals) not the compact ExecutionPayloadHeader. The spec's NewPayloadRequestHeader
is a separate concept used for proof engine verification, not for computing the root.

Author: spiral-ladder

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

@@ -9,11 +9,12 @@ import {
 } from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
 import {IBeaconStateView, isExecutionBlockBodyType} from "@lodestar/state-transition";
-import {SignedExecutionProof, bellatrix, electra} from "@lodestar/types";
+import {SignedExecutionProof, bellatrix, deneb, electra} from "@lodestar/types";
 import {ErrorAborted, Logger, toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadStatus, IExecutionEngine} from "../../execution/engine/interface.js";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
+import {computeNewPayloadRequestRoot} from "../eip8025/newPayloadRequestHeader.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {ExecutionProofPool} from "../opPools/executionProofPool.js";
 import {BlockProcessOpts} from "../options.js";
@@ -288,17 +289,24 @@ function verifyBlockExecutionPayloadByProof(
     executionBlock: executionPayload.blockNumber,
   };
 
-  // EIP-8025: Look up proofs by newPayloadRequestRoot.
-  // Find the requestRoot that maps to this block's blockRoot via the reverse mapping.
-  // TODO EIP-8025: Compute NewPayloadRequestHeader.hashTreeRoot() directly
-  // instead of relying on the reverse mapping.
+  // EIP-8025: Compute the newPayloadRequestRoot from the block data and look up proofs by it.
   let proofs: SignedExecutionProof[] = [];
   if (chain.executionProofPool) {
-    for (const [requestRootHex, mappedBlockRootHex] of chain.requestRootToBlockRoot ?? []) {
-      if (mappedBlockRootHex === blockRootHex) {
-        proofs = chain.executionProofPool.getByRequestRootHex(requestRootHex);
-        break;
-      }
+    const block = blockInput.getBlock();
+    const body = block.message.body as deneb.BeaconBlockBody;
+    const newPayloadRequestRoot = computeNewPayloadRequestRoot(
+      chain.config,
+      blockInput.slot,
+      executionPayload,
+      body.blobKzgCommitments ?? [],
+      block.message.parentRoot,
+      (body as electra.BeaconBlockBody).executionRequests
+    );
+    proofs = chain.executionProofPool.getByRequestRoot(newPayloadRequestRoot);
+
+    // Populate the reverse mapping so maybeTransitionToValidOnProofArrival can find the block
+    if (chain.requestRootToBlockRoot) {
+      chain.requestRootToBlockRoot.set(toRootHex(newPayloadRequestRoot), blockRootHex);
     }
   }
 

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

@@ -3,7 +3,6 @@ import {PrivateKey} from "@libp2p/interface";
 import {Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {
-  CheckpointWithHex,
   CheckpointWithPayloadStatus,
   ExecutionStatus,
   IForkChoice,

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

@@ -0,0 +1,51 @@
+import {ContainerType, ListCompositeType} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkSeq, MAX_BLOB_COMMITMENTS_PER_BLOCK} from "@lodestar/params";
+import {ExecutionPayload, Root, Slot, deneb, electra, ssz} from "@lodestar/types";
+import {kzgCommitmentToVersionedHash} from "../../util/blobs.js";
+
+/**
+ * EIP-8025: Compute the new_payload_request_root for a given block.
+ *
+ * The `newPayloadRequestRoot` is the tree hash root of `NewPayloadRequest`,
+ * which contains the full execution payload (not the header), versioned hashes,
+ * parent beacon block root, and execution requests.
+ *
+ * This matches Lighthouse's computation: `NewPayloadRequest.tree_hash_root()`.
+ */
+export function computeNewPayloadRequestRoot(
+  config: ChainForkConfig,
+  slot: Slot,
+  executionPayload: ExecutionPayload,
+  blobKzgCommitments: deneb.BlobKzgCommitments,
+  parentBeaconBlockRoot: Root,
+  executionRequests: electra.ExecutionRequests
+): Uint8Array {
+  const forkSeq = config.getForkSeq(slot);
+  const versionedHashes = blobKzgCommitments.map(kzgCommitmentToVersionedHash);
+
+  // Build the NewPayloadRequest container dynamically.
+  // Uses the full ExecutionPayload (not the header) — matches Lighthouse's tree_hash_root.
+  const payloadSszType = getExecutionPayloadSszType(forkSeq);
+  const NewPayloadRequest = new ContainerType({
+    executionPayload: payloadSszType,
+    versionedHashes: new ListCompositeType(ssz.deneb.VersionedHash, MAX_BLOB_COMMITMENTS_PER_BLOCK),
+    parentBeaconBlockRoot: ssz.Root,
+    executionRequests: ssz.electra.ExecutionRequests,
+  });
+
+  return NewPayloadRequest.hashTreeRoot({
+    executionPayload: executionPayload,
+    versionedHashes,
+    parentBeaconBlockRoot,
+    executionRequests,
+  });
+}
+
+function getExecutionPayloadSszType(forkSeq: ForkSeq): ContainerType<any> {
+  // ExecutionPayload is the same from deneb through electra/fulu
+  if (forkSeq >= ForkSeq.deneb) {
+    return ssz.deneb.ExecutionPayload;
+  }
+  throw new Error(`EIP-8025 requires at least deneb fork, got fork sequence ${forkSeq}`);
+}

packages/types/src/eip8025/sszTypes.ts

@@ -1,6 +1,6 @@
 import {ByteListType, ContainerType, ListBasicType, UintNumberType} from "@chainsafe/ssz";
 import {EXECUTION_PROOF_TYPE_COUNT, MAX_PROOF_DATA_BYTES} from "@lodestar/params";
-import {BLSSignature, Root, Slot, Uint8, UintNum64, ValidatorIndex} from "../primitive/sszTypes.js";
+import {BLSSignature, Root, Uint8, UintNum64, ValidatorIndex} from "../primitive/sszTypes.js";
 
 /**
  * ExecutionProofId identifies which zkVM/proof system + EL combination a proof belongs to.