fix the newpayload engine codeflow to validate the cl requests

Author: g11tech

packages/client/src/rpc/modules/engine/engine.ts

@@ -32,7 +32,6 @@ import {
   recursivelyFindParents,
   validExecutedChainBlock,
   validHash,
-  validate4844BlobVersionedHashes,
   validateHardforkRange,
 } from './util/index.js'
 import {
@@ -374,6 +373,9 @@ export class Engine {
         ...payload,
         // ExecutionPayload only handles undefined
         parentBeaconBlockRoot: parentBeaconBlockRoot ?? undefined,
+      },
+      {
+        blobVersionedHashes: blobVersionedHashes ?? undefined,
         executionRequests: executionRequests ?? undefined,
       },
       this.chain,
@@ -395,41 +397,6 @@ export class Engine {
       return response
     }
 
-    /**
-     * Validate blob versioned hashes in the context of EIP-4844 blob transactions
-     */
-    if (headBlock.common.isActivatedEIP(4844)) {
-      let validationError: string | null = null
-      if (blobVersionedHashes === undefined || blobVersionedHashes === null) {
-        validationError = `Error verifying blobVersionedHashes: received none`
-      } else {
-        validationError = validate4844BlobVersionedHashes(headBlock, blobVersionedHashes)
-      }
-
-      // if there was a validation error return invalid
-      if (validationError !== null) {
-        this.config.logger.debug(validationError)
-        const latestValidHash = await validHash(
-          hexToBytes(parentHash as PrefixedHexString),
-          this.chain,
-          this.chainCache,
-        )
-        const response = { status: Status.INVALID, latestValidHash, validationError }
-        // skip marking the block invalid as this is more of a data issue from CL
-        return response
-      }
-    } else if (blobVersionedHashes !== undefined && blobVersionedHashes !== null) {
-      const validationError = `Invalid blobVersionedHashes before EIP-4844 is activated`
-      const latestValidHash = await validHash(
-        hexToBytes(parentHash as PrefixedHexString),
-        this.chain,
-        this.chainCache,
-      )
-      const response = { status: Status.INVALID, latestValidHash, validationError }
-      // skip marking the block invalid as this is more of a data issue from CL
-      return response
-    }
-
     /**
      * Stats and hardfork updates
      */
@@ -1341,7 +1308,7 @@ export class Engine {
       }
       // The third arg returned is the minerValue which we will use to
       // value the block
-      const [block, receipts, value, blobs] = built
+      const [block, receipts, value, blobs, requests] = built
 
       // do a blocking call even if execution might be busy for the moment and skip putting
       // it into chain till CL confirms with full data via new payload like versioned hashes
@@ -1355,7 +1322,7 @@ export class Engine {
       /**
        * Creates the payload in ExecutionPayloadV1 format to be returned
        */
-      const executionPayload = blockToExecutionPayload(block, value, blobs)
+      const executionPayload = blockToExecutionPayload(block, value, blobs, requests)
 
       let checkNotBeforeHf: Hardfork | null
       let checkNotAfterHf: Hardfork | null

packages/client/src/rpc/modules/engine/util/newPayload.ts

@@ -1,6 +1,7 @@
-import { createBlockFromExecutionPayload } from '@ethereumjs/block'
+import { createBlockFromExecutionPayload, genRequestsRoot } from '@ethereumjs/block'
 import { Blob4844Tx } from '@ethereumjs/tx'
-import { hexToBytes } from '@ethereumjs/util'
+import { bytesToHex, createCLRequest, equalsBytes, hexToBytes } from '@ethereumjs/util'
+import { sha256 } from 'ethereum-cryptography/sha256'
 
 import { short } from '../../../../util/index.js'
 import { Status } from '../types.js'
@@ -12,12 +13,18 @@ import type { ChainCache, PayloadStatusV1 } from '../types.js'
 import type { Block, ExecutionPayload } from '@ethereumjs/block'
 import type { PrefixedHexString } from '@ethereumjs/util'
 
+type CLValidationData = {
+  blobVersionedHashes?: PrefixedHexString[]
+  executionRequests?: PrefixedHexString[]
+}
+
 /**
  * Returns a block from a payload.
  * If errors, returns {@link PayloadStatusV1}
  */
 export const assembleBlock = async (
   payload: ExecutionPayload,
+  clValidationData: CLValidationData,
   chain: Chain,
   chainCache: ChainCache,
 ): Promise<{ block?: Block; error?: PayloadStatusV1 }> => {
@@ -32,6 +39,47 @@ export const assembleBlock = async (
     // TODO: validateData is also called in applyBlock while runBlock, may be it can be optimized
     // by removing/skipping block data validation from there
     await block.validateData()
+
+    // Validate CL data to see if it matches with the assembled block
+    const { blobVersionedHashes, executionRequests } = clValidationData
+
+    /**
+     * Validate blob versioned hashes in the context of EIP-4844 blob transactions
+     */
+    if (block.common.isActivatedEIP(4844)) {
+      let validationError: string | null = null
+      if (blobVersionedHashes === undefined) {
+        validationError = `Error verifying blobVersionedHashes: received none`
+      } else {
+        validationError = validate4844BlobVersionedHashes(block, blobVersionedHashes)
+      }
+
+      // if there was a validation error return invalid
+      if (validationError !== null) {
+        throw validationError
+      }
+    } else if (blobVersionedHashes !== undefined) {
+      const validationError = `Invalid blobVersionedHashes before EIP-4844 is activated`
+      throw validationError
+    }
+
+    if (block.common.isActivatedEIP(7685)) {
+      let validationError: string | null = null
+      if (executionRequests === undefined) {
+        validationError = `Error verifying executionRequests: received none`
+      } else {
+        validationError = validate7685ExecutionRequests(block, executionRequests)
+      }
+
+      // if there was a validation error return invalid
+      if (validationError !== null) {
+        throw validationError
+      }
+    } else if (executionRequests !== undefined) {
+      const validationError = `Invalid executionRequests before EIP-7685 is activated`
+      throw validationError
+    }
+
     return { block }
   } catch (error) {
     const validationError = `Error assembling block from payload: ${error}`
@@ -82,3 +130,22 @@ export const validate4844BlobVersionedHashes = (
   }
   return validationError
 }
+
+export const validate7685ExecutionRequests = (
+  headBlock: Block,
+  executionRequests: PrefixedHexString[],
+): string | null => {
+  let validationError: string | null = null
+
+  // Collect versioned hashes in the flat array `txVersionedHashes` to match with received
+  const requests = executionRequests.map((req) => createCLRequest(hexToBytes(req)))
+  const sha256Function = headBlock.common.customCrypto.sha256 ?? sha256
+  const requestsRoot = genRequestsRoot(requests, sha256Function)
+
+  if (!equalsBytes(requestsRoot, headBlock.header.requestsRoot!)) {
+    validationError = `Invalid requestsRoot received=${bytesToHex(
+      headBlock.header.requestsRoot!,
+    )} expected=${bytesToHex(requestsRoot)}`
+  }
+  return validationError
+}