@lodestar/beacon-node 1.50.1 → 1.51.0-dev.09763aa8d2

package/src/execution/engine/restTransport.ts

@@ -1,9 +1,19 @@
 import {Type} from "@chainsafe/ssz";
 import {CELLS_PER_EXT_BLOB, ForkName, ForkSeq, isForkPostBellatrix} from "@lodestar/params";
-import {ExecutionPayload, ExecutionRequests, Root, RootHex, capella, deneb, electra, gloas} from "@lodestar/types";
+import {
+  ExecutionPayload,
+  ExecutionRequests,
+  Root,
+  RootHex,
+  bellatrix,
+  capella,
+  deneb,
+  electra,
+  gloas,
+} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
-import {LodestarError, fromHex, strip0xPrefix, toHex, toRootHex} from "@lodestar/utils";
+import {EndTimer, LodestarError, fromHex, strip0xPrefix, toHex, toRootHex} from "@lodestar/utils";
 import {isValidBlobVersionedHashes} from "./blobVersionedHashes.js";
 import {
   ClientCode,
@@ -48,6 +58,7 @@ import {
   executionForkName,
 } from "./sszTypes.js";
 import {ForkchoiceUpdatedResult, GetPayloadResult, IEngineTransport, PayloadStatusResult} from "./transport.js";
+import {EngineTransportMetrics} from "./transportMetrics.js";
 import {
   ExecutionPayloadBodyV2,
   assertReqSizeLimit,
@@ -102,7 +113,10 @@ export function formatClientVersionHeader(clientVersion: ClientVersion): string
 export class RestEngineTransport implements IEngineTransport {
   private limits = DEFAULT_LIMITS;
 
-  constructor(private readonly client: EngineRestHttpClient) {}
+  constructor(
+    private readonly client: EngineRestHttpClient,
+    private readonly metrics?: EngineTransportMetrics | null
+  ) {}
 
   get emitter(): JsonRpcHttpClientEventEmitter {
     return this.client.emitter;
@@ -114,7 +128,7 @@ export class RestEngineTransport implements IEngineTransport {
       {method: "GET", path: "/capabilities", responseType: "json"},
       getCapabilitiesOpts
     );
-    const capabilities = parseJson(body, "getCapabilities");
+    const capabilities = parseJson(body, "getCapabilities", this.metrics);
     if (
       !isRecord(capabilities) ||
       !Array.isArray(capabilities.supported_forks) ||
@@ -220,7 +234,7 @@ export class RestEngineTransport implements IEngineTransport {
       {method: "POST", path: "/payloads", executionFork: toExecutionForkName(fork), body, responseType: "ssz"},
       notifyNewPayloadOpts
     );
-    return toPayloadStatusResult(deserializeResponse(PayloadStatus, res.body, "notifyNewPayload"));
+    return toPayloadStatusResult(deserializeResponse(PayloadStatus, res.body, "notifyNewPayload", this.metrics));
   }
 
   async forkchoiceUpdated(
@@ -268,7 +282,12 @@ export class RestEngineTransport implements IEngineTransport {
       {method: "POST", path: "/forkchoice", executionFork: toExecutionForkName(fork), body, responseType: "ssz"},
       fcUReqOpts
     );
-    const {payloadStatus, payloadId} = deserializeResponse(ForkchoiceUpdateResponse, res.body, "forkchoiceUpdated");
+    const {payloadStatus, payloadId} = deserializeResponse(
+      ForkchoiceUpdateResponse,
+      res.body,
+      "forkchoiceUpdated",
+      this.metrics
+    );
     return {
       payloadStatus: toPayloadStatusResult(payloadStatus),
       payloadId: payloadId.length > 0 ? toHex(payloadId[0]) : null,
@@ -289,7 +308,8 @@ export class RestEngineTransport implements IEngineTransport {
       const {payload, blockValue, blobsBundle, executionRequests, shouldOverrideBuilder} = deserializeResponse(
         BuiltPayloadGloas,
         res.body,
-        "getPayload"
+        "getPayload",
+        this.metrics
       );
       return {
         executionPayload: payload,
@@ -303,7 +323,8 @@ export class RestEngineTransport implements IEngineTransport {
       const {payload, blockValue, blobsBundle, executionRequests, shouldOverrideBuilder} = deserializeResponse(
         BuiltPayloadFulu,
         res.body,
-        "getPayload"
+        "getPayload",
+        this.metrics
       );
       return {
         executionPayload: payload,
@@ -317,7 +338,8 @@ export class RestEngineTransport implements IEngineTransport {
       const {payload, blockValue, blobsBundle, executionRequests, shouldOverrideBuilder} = deserializeResponse(
         BuiltPayloadElectra,
         res.body,
-        "getPayload"
+        "getPayload",
+        this.metrics
       );
       return {
         executionPayload: payload,
@@ -331,15 +353,16 @@ export class RestEngineTransport implements IEngineTransport {
       const {payload, blockValue, blobsBundle, shouldOverrideBuilder} = deserializeResponse(
         BuiltPayloadDeneb,
         res.body,
-        "getPayload"
+        "getPayload",
+        this.metrics
       );
       return {executionPayload: payload, executionPayloadValue: blockValue, blobsBundle, shouldOverrideBuilder};
     }
     if (ForkSeq[fork] >= ForkSeq.capella) {
-      const {payload, blockValue} = deserializeResponse(BuiltPayloadCapella, res.body, "getPayload");
+      const {payload, blockValue} = deserializeResponse(BuiltPayloadCapella, res.body, "getPayload", this.metrics);
       return {executionPayload: payload, executionPayloadValue: blockValue, shouldOverrideBuilder: false};
     }
-    const {payload, blockValue} = deserializeResponse(BuiltPayloadBellatrix, res.body, "getPayload");
+    const {payload, blockValue} = deserializeResponse(BuiltPayloadBellatrix, res.body, "getPayload", this.metrics);
     return {executionPayload: payload, executionPayloadValue: blockValue, shouldOverrideBuilder: false};
   }
 
@@ -356,7 +379,7 @@ export class RestEngineTransport implements IEngineTransport {
       },
       getPayloadBodiesByHashOpts
     );
-    const bodies = deserializeBodiesResponse(ForkName.gloas, res.body);
+    const bodies = deserializeBodiesResponse(ForkName.gloas, res.body, this.metrics);
     if (bodies.length !== blockHashes.length) {
       throw Error(`Invalid bodies response length=${bodies.length} blockHashes=${blockHashes.length}`);
     }
@@ -374,7 +397,7 @@ export class RestEngineTransport implements IEngineTransport {
       return versionedHashes.map(() => null);
     }
 
-    const {entries} = deserializeResponse(BlobsV1Response, res.body, "getBlobsV1");
+    const {entries} = deserializeResponse(BlobsV1Response, res.body, "getBlobsV1", this.metrics);
     if (entries.length !== versionedHashes.length) {
       throw Error(`Invalid blobs/v1 response length=${entries.length} versionedHashes=${versionedHashes.length}`);
     }
@@ -397,7 +420,7 @@ export class RestEngineTransport implements IEngineTransport {
       return null;
     }
 
-    const {entries} = deserializeResponse(BlobsV2Response, res.body, "getBlobsV2", {reuseBytes: true});
+    const {entries} = deserializeResponse(BlobsV2Response, res.body, "getBlobsV2", this.metrics, {reuseBytes: true});
     if (entries.length !== versionedHashes.length) {
       throw Error(`Invalid blobs/v2 response length=${entries.length} versionedHashes=${versionedHashes.length}`);
     }
@@ -418,7 +441,7 @@ export class RestEngineTransport implements IEngineTransport {
       {method: "GET", path: "/identity", responseType: "json"},
       getClientVersionOpts
     );
-    const versions = parseJson(body, "getClientVersion");
+    const versions = parseJson(body, "getClientVersion", this.metrics);
     if (!Array.isArray(versions)) {
       throw new EngineRestResponseError("getClientVersion", "Expected an array of client versions");
     }
@@ -441,6 +464,10 @@ export class RestEngineTransport implements IEngineTransport {
       };
     });
   }
+
+  getInclusionList(): Promise<bellatrix.Transactions> {
+    throw Error("engine_getInclusionListV1 is not available over the REST engine API");
+  }
 }
 
 function toPayloadAttributesBellatrix(attributes: PayloadAttributes) {
@@ -502,36 +529,54 @@ function toPayloadStatusResult(payloadStatus: PayloadStatusSsz): PayloadStatusRe
   }
 }
 
-function deserializeBodiesResponse(fork: ForkName, data: Uint8Array): (ExecutionPayloadBodyV2 | null)[] {
+function deserializeBodiesResponse(
+  fork: ForkName,
+  data: Uint8Array,
+  metrics?: EngineTransportMetrics | null
+): (ExecutionPayloadBodyV2 | null)[] {
   if (ForkSeq[fork] >= ForkSeq.gloas) {
-    return deserializeResponse(BodiesResponseGloas, data, "getPayloadBodiesByHash").entries.map((entry) =>
+    return deserializeResponse(BodiesResponseGloas, data, "getPayloadBodiesByHash", metrics).entries.map((entry) =>
       entry.available ? entry.body : null
     );
   }
   if (ForkSeq[fork] >= ForkSeq.capella) {
-    return deserializeResponse(BodiesResponseCapella, data, "getPayloadBodiesByHash").entries.map((entry) =>
+    return deserializeResponse(BodiesResponseCapella, data, "getPayloadBodiesByHash", metrics).entries.map((entry) =>
       entry.available ? {...entry.body, blockAccessList: null} : null
     );
   }
-  return deserializeResponse(BodiesResponseBellatrix, data, "getPayloadBodiesByHash").entries.map((entry) =>
+  return deserializeResponse(BodiesResponseBellatrix, data, "getPayloadBodiesByHash", metrics).entries.map((entry) =>
     entry.available ? {transactions: entry.body.transactions, withdrawals: null, blockAccessList: null} : null
   );
 }
 
 /** A 2xx response that does not decode is an execution client error, not an unreachable client */
-function deserializeResponse<T>(type: Type<T>, body: Uint8Array, routeId: string, opts?: {reuseBytes?: boolean}): T {
+function deserializeResponse<T>(
+  type: Type<T>,
+  body: Uint8Array,
+  routeId: string,
+  metrics?: EngineTransportMetrics | null,
+  opts?: {reuseBytes?: boolean}
+): T {
+  const timer = metrics?.responseParseTime.startTimer({routeId, encoding: "ssz"});
   try {
     return type.deserialize(body, opts);
   } catch (e) {
     throw new EngineRestResponseError(routeId, `Invalid SSZ: ${(e as Error).message}`);
+  } finally {
+    timer?.();
   }
 }
 
-function parseJson(body: Uint8Array, routeId: string): unknown {
+function parseJson(body: Uint8Array, routeId: string, metrics?: EngineTransportMetrics | null): unknown {
+  let timer: EndTimer | undefined;
   try {
-    return JSON.parse(textDecoder.decode(body));
+    const text = textDecoder.decode(body);
+    timer = metrics?.responseParseTime.startTimer({routeId, encoding: "json"});
+    return JSON.parse(text);
   } catch (e) {
     throw new EngineRestResponseError(routeId, `Invalid JSON: ${(e as Error).message}`);
+  } finally {
+    timer?.();
   }
 }
 

package/src/execution/engine/transport.ts

@@ -1,5 +1,5 @@
 import {ForkName} from "@lodestar/params";
-import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei} from "@lodestar/types";
+import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei, bellatrix} from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {ClientVersion, ExecutionPayloadStatus, PayloadAttributes, PayloadId, VersionedHashes} from "./interface.js";
@@ -10,6 +10,8 @@ export type PayloadStatusResult = {
   status: ExecutionPayloadStatus;
   latestValidHash: RootHex | null;
   validationError: string | null;
+  /** PayloadStatusV2: whether a VALID payload satisfied the inclusion list constraints, null otherwise */
+  inclusionListSatisfied?: boolean | null;
 };
 
 export type ForkchoiceUpdatedResult = {
@@ -38,7 +40,8 @@ export interface IEngineTransport {
     executionPayload: ExecutionPayload,
     versionedHashes?: VersionedHashes,
     parentBeaconBlockRoot?: Root,
-    executionRequests?: ExecutionRequests
+    executionRequests?: ExecutionRequests,
+    inclusionListTransactions?: bellatrix.Transactions
   ): Promise<PayloadStatusResult>;
 
   forkchoiceUpdated(
@@ -58,4 +61,6 @@ export interface IEngineTransport {
   getBlobsV2(versionedHashes: VersionedHashes, buffers?: Uint8Array[]): Promise<BlobAndProofV2[] | null>;
 
   getClientVersion(clientVersion: ClientVersion): Promise<ClientVersion[]>;
+
+  getInclusionList(): Promise<bellatrix.Transactions>;
 }

package/src/execution/engine/transportMetrics.ts

@@ -1,4 +1,4 @@
-import {Counter} from "@lodestar/utils";
+import {Counter, Histogram} from "@lodestar/utils";
 
 /**
  * Common metrics type for both json rpc and ssz transport.
@@ -6,4 +6,5 @@ import {Counter} from "@lodestar/utils";
 export type EngineTransportMetrics = {
   requestBytes: Counter<{routeId: string}>;
   responseBytes: Counter<{routeId: string}>;
+  responseParseTime: Histogram<{routeId: string; encoding: "json" | "ssz"}>;
 };

package/src/execution/engine/types.ts

@@ -1,3 +1,4 @@
+import {SerializedList, Type} from "@chainsafe/ssz";
 import {
   BUILDER_DEPOSIT_REQUEST_TYPE,
   BUILDER_EXIT_REQUEST_TYPE,
@@ -8,6 +9,7 @@ import {
   DEPOSIT_REQUEST_TYPE,
   FIELD_ELEMENTS_PER_BLOB,
   ForkName,
+  ForkPostElectra,
   ForkSeq,
   WITHDRAWAL_REQUEST_TYPE,
 } from "@lodestar/params";
@@ -22,6 +24,7 @@ import {
   deneb,
   gloas,
   ssz,
+  sszTypesFor,
 } from "@lodestar/types";
 import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
@@ -53,6 +56,7 @@ export type EngineApiRpcParamTypes = {
   engine_newPayloadV3: [ExecutionPayloadRpc, VersionedHashesRpc, DATA];
   engine_newPayloadV4: [ExecutionPayloadRpc, VersionedHashesRpc, DATA, ExecutionRequestsRpc];
   engine_newPayloadV5: [ExecutionPayloadRpc, VersionedHashesRpc, DATA, ExecutionRequestsRpc];
+  engine_newPayloadV6: [ExecutionPayloadRpc, VersionedHashesRpc, DATA, ExecutionRequestsRpc, InclusionListRpc];
   /**
    * 1. Object - Payload validity status with respect to the consensus rules:
    *   - blockHash: DATA, 32 Bytes - block hash value of the payload
@@ -74,6 +78,10 @@ export type EngineApiRpcParamTypes = {
     forkChoiceData: {headBlockHash: DATA; safeBlockHash: DATA; finalizedBlockHash: DATA},
     payloadAttributes?: PayloadAttributesRpc,
   ];
+  engine_forkchoiceUpdatedV5: [
+    forkChoiceData: {headBlockHash: DATA; safeBlockHash: DATA; finalizedBlockHash: DATA},
+    payloadAttributes?: PayloadAttributesRpc,
+  ];
   /**
    * 1. payloadId: QUANTITY, 64 Bits - Identifier of the payload building process
    */
@@ -96,12 +104,16 @@ export type EngineApiRpcParamTypes = {
 
   engine_getBlobsV1: [DATA[]];
   engine_getBlobsV2: [DATA[]];
+
+  engine_getInclusionListV1: [];
 };
 
 export type PayloadStatus = {
   status: ExecutionPayloadStatus;
   latestValidHash: DATA | null;
   validationError: string | null;
+  /** PayloadStatusV2: whether a VALID payload satisfied the inclusion list constraints, null otherwise */
+  inclusionListSatisfied?: boolean | null;
 };
 
 export type EngineApiRpcReturnTypes = {
@@ -114,6 +126,7 @@ export type EngineApiRpcReturnTypes = {
   engine_newPayloadV3: PayloadStatus;
   engine_newPayloadV4: PayloadStatus;
   engine_newPayloadV5: PayloadStatus;
+  engine_newPayloadV6: PayloadStatus;
   engine_forkchoiceUpdatedV1: {
     payloadStatus: PayloadStatus;
     payloadId: QUANTITY | null;
@@ -130,6 +143,10 @@ export type EngineApiRpcReturnTypes = {
     payloadStatus: PayloadStatus;
     payloadId: QUANTITY | null;
   };
+  engine_forkchoiceUpdatedV5: {
+    payloadStatus: PayloadStatus;
+    payloadId: QUANTITY | null;
+  };
   /**
    * payloadId | Error: QUANTITY, 64 Bits - Identifier of the payload building process
    */
@@ -146,6 +163,8 @@ export type EngineApiRpcReturnTypes = {
 
   engine_getBlobsV1: (BlobAndProofRpc | null)[];
   engine_getBlobsV2: BlobAndProofV2Rpc[] | null;
+
+  engine_getInclusionListV1: InclusionListRpc;
 };
 
 type ExecutionPayloadRpcWithValue = {
@@ -164,7 +183,7 @@ export type ExecutionPayloadBodyRpc = {
 };
 
 export type ExecutionPayloadBody = {
-  transactions: bellatrix.Transaction[];
+  transactions: bellatrix.Transactions;
   withdrawals: capella.Withdrawals | null;
 };
 
@@ -260,8 +279,13 @@ export type PayloadAttributesRpc = {
   slotNumber?: QUANTITY;
   /** QUANTITY, 64 Bits - target value for the gasLimit field of the new payload (GLOAS, execution-apis#796) */
   targetGasLimit?: QUANTITY;
+  /** Array of DATA - transactions that the built payload must include (PayloadAttributesV5, HEZE) */
+  inclusionListTransactions?: InclusionListRpc;
 };
 
+/** Array of DATA - array of transaction objects */
+export type InclusionListRpc = DATA[];
+
 export type ClientVersionRpc = {
   /** ClientCode */
   code: string;
@@ -294,7 +318,7 @@ export function serializeExecutionPayload(fork: ForkName, data: ExecutionPayload
     extraData: bytesToData(data.extraData),
     baseFeePerGas: numToQuantity(data.baseFeePerGas),
     blockHash: bytesToData(data.blockHash),
-    transactions: data.transactions.map((tran) => bytesToData(tran)),
+    transactions: Array.from(data.transactions, (tran) => bytesToData(tran)),
   };
 
   // Capella adds withdrawals to the ExecutionPayload
@@ -378,7 +402,7 @@ export function parseExecutionPayload(
     extraData: dataToBytes(data.extraData, null),
     baseFeePerGas: quantityToBigint(data.baseFeePerGas),
     blockHash: dataToBytes(data.blockHash, 32),
-    transactions: data.transactions.map((tran) => dataToBytes(tran, null)),
+    transactions: SerializedList.fromArray(data.transactions.map((tran) => dataToBytes(tran, null))),
   };
 
   if (ForkSeq[fork] >= ForkSeq.capella) {
@@ -441,6 +465,9 @@ export function serializePayloadAttributes(data: PayloadAttributes): PayloadAttr
     parentBeaconBlockRoot: data.parentBeaconBlockRoot ? bytesToData(data.parentBeaconBlockRoot) : undefined,
     slotNumber: data.slotNumber !== undefined ? numToQuantity(data.slotNumber) : undefined,
     targetGasLimit: data.targetGasLimit !== undefined ? numToQuantity(data.targetGasLimit) : undefined,
+    inclusionListTransactions: data.inclusionListTransactions
+      ? serializeInclusionList(data.inclusionListTransactions)
+      : undefined,
   };
 }
 
@@ -448,6 +475,14 @@ export function serializeBeaconBlockRoot(data: Root): DATA {
   return bytesToData(data);
 }
 
+export function serializeInclusionList(data: bellatrix.Transactions): InclusionListRpc {
+  return Array.from(data, (transaction) => bytesToData(transaction));
+}
+
+export function deserializeInclusionList(data: InclusionListRpc): bellatrix.Transactions {
+  return SerializedList.fromArray(data.map((transaction) => dataToBytes(transaction, null)));
+}
+
 export function deserializePayloadAttributes(data: PayloadAttributesRpc): PayloadAttributes {
   return {
     timestamp: quantityToNum(data.timestamp),
@@ -459,6 +494,9 @@ export function deserializePayloadAttributes(data: PayloadAttributesRpc): Payloa
     parentBeaconBlockRoot: data.parentBeaconBlockRoot ? dataToBytes(data.parentBeaconBlockRoot, 32) : undefined,
     slotNumber: data.slotNumber !== undefined ? quantityToNum(data.slotNumber) : undefined,
     targetGasLimit: data.targetGasLimit !== undefined ? quantityToBigint(data.targetGasLimit) : undefined,
+    inclusionListTransactions: data.inclusionListTransactions
+      ? deserializeInclusionList(data.inclusionListTransactions)
+      : undefined,
   };
 }
 
@@ -500,14 +538,15 @@ export function deserializeWithdrawal(serialized: WithdrawalRpc): capella.Withdr
 }
 
 /**
- * Prepend a single-byte requestType to requestsBytes
+ * Serialize requests prefixed with a single-byte requestType in one allocation
  */
-function prefixRequests(requestsBytes: Uint8Array, requestType: ExecutionRequestType): Uint8Array {
-  const prefixedRequests = new Uint8Array(1 + requestsBytes.length);
-  prefixedRequests[0] = requestType;
-  prefixedRequests.set(requestsBytes, 1);
+function serializePrefixedRequests<T>(type: Type<T>, requests: T, requestType: ExecutionRequestType): Uint8Array {
+  const uint8Array = new Uint8Array(1 + type.value_serializedSize(requests));
+  const dataView = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+  uint8Array[0] = requestType;
+  type.value_serializeToBytes({uint8Array, dataView}, 1, requests);
 
-  return prefixedRequests;
+  return uint8Array;
 }
 
 /**
@@ -522,16 +561,16 @@ export function serializeExecutionRequestsToBytes(fork: ForkName, executionReque
   const result: Uint8Array[] = [];
 
   if (deposits.length !== 0) {
-    result.push(prefixRequests(ssz.electra.DepositRequests.serialize(deposits), DEPOSIT_REQUEST_TYPE));
+    result.push(serializePrefixedRequests(ssz.electra.DepositRequests, deposits, DEPOSIT_REQUEST_TYPE));
   }
 
   if (withdrawals.length !== 0) {
-    result.push(prefixRequests(ssz.electra.WithdrawalRequests.serialize(withdrawals), WITHDRAWAL_REQUEST_TYPE));
+    result.push(serializePrefixedRequests(ssz.electra.WithdrawalRequests, withdrawals, WITHDRAWAL_REQUEST_TYPE));
   }
 
   if (consolidations.length !== 0) {
     result.push(
-      prefixRequests(ssz.electra.ConsolidationRequests.serialize(consolidations), CONSOLIDATION_REQUEST_TYPE)
+      serializePrefixedRequests(ssz.electra.ConsolidationRequests, consolidations, CONSOLIDATION_REQUEST_TYPE)
     );
   }
 
@@ -540,12 +579,12 @@ export function serializeExecutionRequestsToBytes(fork: ForkName, executionReque
 
     if (builderDeposits.length !== 0) {
       result.push(
-        prefixRequests(ssz.gloas.BuilderDepositRequests.serialize(builderDeposits), BUILDER_DEPOSIT_REQUEST_TYPE)
+        serializePrefixedRequests(ssz.gloas.BuilderDepositRequests, builderDeposits, BUILDER_DEPOSIT_REQUEST_TYPE)
       );
     }
 
     if (builderExits.length !== 0) {
-      result.push(prefixRequests(ssz.gloas.BuilderExitRequests.serialize(builderExits), BUILDER_EXIT_REQUEST_TYPE));
+      result.push(serializePrefixedRequests(ssz.gloas.BuilderExitRequests, builderExits, BUILDER_EXIT_REQUEST_TYPE));
     }
   }
 
@@ -591,7 +630,7 @@ export function deserializeExecutionRequestsFromBytes(fork: ForkName, serialized
 
     switch (currentRequestType) {
       case DEPOSIT_REQUEST_TYPE: {
-        result.deposits = ssz.electra.DepositRequests.deserialize(requests);
+        result.deposits = sszTypesFor(fork as ForkPostElectra).DepositRequests.deserialize(requests);
         break;
       }
       case WITHDRAWAL_REQUEST_TYPE: {
@@ -633,7 +672,7 @@ export function deserializeExecutionRequests(fork: ForkName, serialized: Executi
 export function deserializeExecutionPayloadBody(data: ExecutionPayloadBodyRpc | null): ExecutionPayloadBody | null {
   return data
     ? {
-        transactions: data.transactions.map((tran) => dataToBytes(tran, null)),
+        transactions: SerializedList.fromArray(data.transactions.map((tran) => dataToBytes(tran, null))),
         withdrawals: data.withdrawals ? data.withdrawals.map(deserializeWithdrawal) : null,
       }
     : null;
@@ -656,7 +695,7 @@ export function serializeExecutionPayloadBodyV2(data: ExecutionPayloadBodyV2 | n
 export function serializeExecutionPayloadBody(data: ExecutionPayloadBody | null): ExecutionPayloadBodyRpc | null {
   return data
     ? {
-        transactions: data.transactions.map((tran) => bytesToData(tran)),
+        transactions: Array.from(data.transactions, (tran) => bytesToData(tran)),
         withdrawals: data.withdrawals ? data.withdrawals.map(serializeWithdrawal) : null,
       }
     : null;

package/src/index.ts

@@ -6,6 +6,8 @@ export {persistAnchorState} from "./chain/index.js";
 export {DbCPStateDatastore} from "./chain/stateCache/datastore/db.js";
 export {FileCPStateDatastore} from "./chain/stateCache/datastore/file.js";
 export {BeaconDb, type IBeaconDb} from "./db/index.js";
+// Export execution engine to make it usable by builder
+export {initializeExecutionEngine} from "./execution/index.js";
 // Export metrics utilities to de-duplicate validator metrics
 export {
   type HttpMetricsServer,

package/src/metrics/metrics/beacon.ts

@@ -1,5 +1,6 @@
 import {ProducedBlockSource} from "@lodestar/types";
 import {BlockSelectionResult} from "../../api/impl/validator/index.js";
+import {InclusionListSource} from "../../chain/blocks/types.js";
 import {BlockProductionStep, PayloadPreparationType} from "../../chain/produceBlock/index.js";
 import {RegistryMetricCreator} from "../utils/registryMetricCreator.js";
 
@@ -432,5 +433,41 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
       name: "beacon_weak_head_detected_total",
       help: "Detected current head block is weak. May reorg it out when proposing next slot. See proposer boost reorg for more",
     }),
+
+    // HEZE:EIP-7805
+    inclusionListsReceived: register.counter<{source: InclusionListSource}>({
+      name: "beacon_inclusion_lists_received_total",
+      help: "Total number of received inclusion lists",
+      labelNames: ["source"],
+    }),
+    inclusionListsValid: register.counter<{source: InclusionListSource}>({
+      name: "beacon_inclusion_lists_valid_total",
+      help: "Total number of valid inclusion lists",
+      labelNames: ["source"],
+    }),
+    inclusionListsValidSize: register.counter({
+      name: "beacon_inclusion_lists_valid_size_bytes_total",
+      help: "Total size of valid inclusion lists in bytes",
+    }),
+    inclusionListTransactionsReceived: register.counter<{source: InclusionListSource}>({
+      name: "beacon_inclusion_list_transactions_received_total",
+      help: "Total number of transactions in received inclusion lists",
+      labelNames: ["source"],
+    }),
+    inclusionListsPublished: register.counter({
+      name: "beacon_inclusion_lists_published_total",
+      help: "Total number of published inclusion lists",
+    }),
+    inclusionListsValidationTime: register.histogram<{source: InclusionListSource}>({
+      name: "beacon_inclusion_lists_validation_time_seconds",
+      help: "Time taken to validate inclusion lists",
+      buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5],
+      labelNames: ["source"],
+    }),
+    inclusionListArrivalTime: register.histogram({
+      name: "beacon_inclusion_lists_arrival_time_seconds",
+      help: "Inclusion list arrival time since the beginning of slot",
+      buckets: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+    }),
   };
 }

package/src/metrics/metrics/lodestar.ts

@@ -16,6 +16,7 @@ import {
   type InvalidAttestationData,
   ScannedSlotsTerminationReason,
 } from "../../chain/opPools/aggregatedAttestationPool.js";
+import {InclusionListInsertOutcome} from "../../chain/opPools/inclusionListStore.js";
 import {InsertOutcome} from "../../chain/opPools/types.js";
 import {RegenCaller, RegenFnName} from "../../chain/regen/interface.js";
 import {ReprocessStatus} from "../../chain/reprocess.js";
@@ -330,6 +331,31 @@ export function createLodestarMetrics(
       }),
     },
 
+    columnReconstructionQueue: {
+      length: register.gauge({
+        name: "lodestar_column_reconstruction_queue_length",
+        help: "Count of total column reconstruction queue length",
+      }),
+      droppedJobs: register.gauge({
+        name: "lodestar_column_reconstruction_queue_dropped_jobs_total",
+        help: "Count of total column reconstruction queue dropped jobs",
+      }),
+      jobTime: register.histogram({
+        name: "lodestar_column_reconstruction_queue_job_time_seconds",
+        help: "Time to process column reconstruction queue job in seconds",
+        buckets: [0.01, 0.1, 1, 4, 12],
+      }),
+      jobWaitTime: register.histogram({
+        name: "lodestar_column_reconstruction_queue_job_wait_time_seconds",
+        help: "Time from job added to the column reconstruction queue to starting in seconds",
+        buckets: [0.01, 0.1, 1, 4, 12],
+      }),
+      concurrency: register.gauge({
+        name: "lodestar_column_reconstruction_queue_concurrency",
+        help: "Current concurrency of column reconstruction queue",
+      }),
+    },
+
     engineHttpProcessorQueue: {
       length: register.gauge({
         name: "lodestar_engine_http_processor_queue_length",
@@ -1177,11 +1203,31 @@ export function createLodestarMetrics(
       help: "The total result of calling notifyForkchoiceUpdate execution engine api",
       labelNames: ["result"],
     }),
+    getInclusionListV1Requests: register.counter({
+      name: "lodestar_execution_engine_get_inclusion_list_v1_requests_total",
+      help: "Total number of engine_getInclusionListV1 requests",
+    }),
+    getInclusionListV1RequestsDuration: register.histogram({
+      name: "lodestar_execution_engine_get_inclusion_list_v1_duration_seconds",
+      help: "Duration of engine_getInclusionListV1 requests",
+      buckets: [0.05, 0.1, 0.25, 0.5, 1],
+    }),
     engineApiRequests: register.counter<{transport: string}>({
       name: "lodestar_execution_engine_api_requests_total",
       help: "Total engine API requests by transport",
       labelNames: ["transport"],
     }),
+    inclusionListStore: {
+      size: register.gauge({
+        name: "lodestar_inclusion_list_store_size",
+        help: "Current number of inclusion lists retained in the InclusionListStore",
+      }),
+      insertOutcome: register.counter<{insertOutcome: InclusionListInsertOutcome}>({
+        name: "lodestar_inclusion_list_store_insert_outcome_total",
+        help: "Total number of InclusionListStore insertions by outcome",
+        labelNames: ["insertOutcome"],
+      }),
+    },
     opPool: {
       aggregatedAttestationPool: {
         size: register.gauge({
@@ -1428,6 +1474,11 @@ export function createLodestarMetrics(
           help: "Total number of InsertOutcome as a result of adding an execution payload bid from gossip to the pool",
           labelNames: ["insertOutcome"],
         }),
+        apiInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_execution_payload_bid_pool_api_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding an execution payload bid from api to the pool",
+          labelNames: ["insertOutcome"],
+        }),
         apiValidationTime: register.histogram({
           name: "lodestar_api_execution_payload_bid_validation_time_seconds",
           help: "Time elapsed for signed execution payload bid validation - api path",
@@ -2061,11 +2112,17 @@ export function createLodestarMetrics(
       }),
       streamTime: register.histogram<{routeId: string}>({
         name: "lodestar_execution_engine_http_client_stream_time_seconds",
-        help: "ExecutionEngineHttp client - streaming time by routeId",
+        help: "ExecutionEngineHttp client - response body consumption time, including failures and excluding parsing",
         labelNames: ["routeId"],
         // Provide max resolution on problematic values around 1 second
         buckets: [0.1, 0.5, 1, 2, 5, 15],
       }),
+      responseParseTime: register.histogram<{routeId: string; encoding: "json" | "ssz"}>({
+        name: "lodestar_execution_engine_http_client_response_parse_time_seconds",
+        help: "ExecutionEngineHttp client - JSON.parse or SSZ deserialize time, including failures, excluding body reads and subsequent value conversion",
+        labelNames: ["routeId", "encoding"],
+        buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1],
+      }),
       requestErrors: register.gauge<{routeId: string}>({
         name: "lodestar_execution_engine_http_client_request_errors_total",
         help: "ExecutionEngineHttp client - total count of request errors",