@lodestar/beacon-node 1.50.0-dev.08c4bed201 → 1.50.0-dev.09bef4706f

package/src/execution/engine/sszTypes.ts

@@ -0,0 +1,354 @@
+import {
+  BitVectorType,
+  ByteListType,
+  CompositeType,
+  CompositeView,
+  CompositeViewDU,
+  ContainerType,
+  ListCompositeType,
+  ValueOf,
+} from "@chainsafe/ssz";
+import {CELLS_PER_EXT_BLOB, ForkName, ForkPostBellatrix, MAX_BYTES_PER_TRANSACTION} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+
+/**
+ * SSZ containers of the REST engine API, per execution-apis `src/engine/refactor-ssz.md`
+ * at 5bcdc34a477b10af278c079525374e6a4046f291.
+ *
+ * Execution payloads, withdrawals and blobs bundles are shared with the consensus types since
+ * they serialize identically. Everything else is transport-only and therefore defined here.
+ */
+
+const MAX_EXECUTION_REQUESTS_PER_PAYLOAD = 256;
+const MAX_BYTES_PER_EXECUTION_REQUEST = MAX_BYTES_PER_TRANSACTION;
+const MAX_BAL_BYTES = MAX_BYTES_PER_TRANSACTION;
+const MAX_ERROR_BYTES = 1024;
+export const MAX_BODIES_REQUEST = 32;
+export const MAX_BLOBS_REQUEST = 128;
+
+/** `Optional[T]` is `List[T, 1]` on the wire, the ssz library's `OptionalType` is a different encoding */
+function Optional<T extends CompositeType<ValueOf<T>, CompositeView<T>, CompositeViewDU<T>>>(
+  type: T
+): ListCompositeType<T> {
+  return new ListCompositeType(type, 1);
+}
+
+const {Bytes8, Bytes32, Bytes48, ExecutionAddress, Root, Uint8, UintBn64, UintBn256, UintNum64} = ssz;
+
+const ExecutionRequestsList = new ListCompositeType(
+  new ByteListType(MAX_BYTES_PER_EXECUTION_REQUEST),
+  MAX_EXECUTION_REQUESTS_PER_PAYLOAD
+);
+
+export const PayloadStatus = new ContainerType(
+  {
+    status: Uint8,
+    latestValidHash: Optional(Bytes32),
+    validationError: Optional(new ByteListType(MAX_ERROR_BYTES)),
+  },
+  {typeName: "PayloadStatus"}
+);
+
+export const ForkchoiceState = new ContainerType(
+  {
+    headBlockHash: Bytes32,
+    safeBlockHash: Bytes32,
+    finalizedBlockHash: Bytes32,
+  },
+  {typeName: "ForkchoiceState"}
+);
+
+export const ForkchoiceUpdateResponse = new ContainerType(
+  {
+    payloadStatus: PayloadStatus,
+    payloadId: Optional(Bytes8),
+  },
+  {typeName: "ForkchoiceUpdateResponse"}
+);
+
+export const PayloadAttributesBellatrix = new ContainerType(
+  {
+    timestamp: UintNum64,
+    prevRandao: Bytes32,
+    suggestedFeeRecipient: ExecutionAddress,
+  },
+  {typeName: "PayloadAttributes"}
+);
+
+export const PayloadAttributesCapella = new ContainerType(
+  {
+    ...PayloadAttributesBellatrix.fields,
+    withdrawals: ssz.capella.Withdrawals,
+  },
+  {typeName: "PayloadAttributes"}
+);
+
+export const PayloadAttributesDeneb = new ContainerType(
+  {
+    ...PayloadAttributesCapella.fields,
+    parentBeaconBlockRoot: Root,
+  },
+  {typeName: "PayloadAttributes"}
+);
+
+export const PayloadAttributesGloas = new ContainerType(
+  {
+    ...PayloadAttributesDeneb.fields,
+    slotNumber: UintNum64,
+    targetGasLimit: UintBn64,
+  },
+  {typeName: "PayloadAttributes"}
+);
+
+const CustodyColumns = new BitVectorType(CELLS_PER_EXT_BLOB);
+
+function ForkchoiceUpdateType<T extends CompositeType<ValueOf<T>, CompositeView<T>, CompositeViewDU<T>>>(
+  payloadAttributes: T
+) {
+  return new ContainerType(
+    {
+      forkchoiceState: ForkchoiceState,
+      payloadAttributes: Optional(payloadAttributes),
+    },
+    {typeName: "ForkchoiceUpdate"}
+  );
+}
+
+export const ForkchoiceUpdateBellatrix = ForkchoiceUpdateType(PayloadAttributesBellatrix);
+export const ForkchoiceUpdateCapella = ForkchoiceUpdateType(PayloadAttributesCapella);
+export const ForkchoiceUpdateDeneb = ForkchoiceUpdateType(PayloadAttributesDeneb);
+export const ForkchoiceUpdateGloas = new ContainerType(
+  {
+    ...ForkchoiceUpdateType(PayloadAttributesGloas).fields,
+    custodyColumns: Optional(CustodyColumns),
+  },
+  {typeName: "ForkchoiceUpdate"}
+);
+
+export const ExecutionPayloadEnvelopeBellatrix = new ContainerType(
+  {payload: ssz.bellatrix.ExecutionPayload},
+  {typeName: "ExecutionPayloadEnvelope"}
+);
+export const ExecutionPayloadEnvelopeCapella = new ContainerType(
+  {payload: ssz.capella.ExecutionPayload},
+  {typeName: "ExecutionPayloadEnvelope"}
+);
+export const ExecutionPayloadEnvelopeDeneb = new ContainerType(
+  {
+    payload: ssz.deneb.ExecutionPayload,
+    parentBeaconBlockRoot: Root,
+  },
+  {typeName: "ExecutionPayloadEnvelope"}
+);
+export const ExecutionPayloadEnvelopeElectra = new ContainerType(
+  {
+    payload: ssz.electra.ExecutionPayload,
+    parentBeaconBlockRoot: Root,
+    executionRequests: ExecutionRequestsList,
+  },
+  {typeName: "ExecutionPayloadEnvelope"}
+);
+export const ExecutionPayloadEnvelopeGloas = new ContainerType(
+  {
+    payload: ssz.gloas.ExecutionPayload,
+    parentBeaconBlockRoot: Root,
+    executionRequests: ExecutionRequestsList,
+  },
+  {typeName: "ExecutionPayloadEnvelope"}
+);
+
+export const BuiltPayloadBellatrix = new ContainerType(
+  {
+    payload: ssz.bellatrix.ExecutionPayload,
+    blockValue: UintBn256,
+  },
+  {typeName: "BuiltPayload"}
+);
+export const BuiltPayloadCapella = new ContainerType(
+  {
+    payload: ssz.capella.ExecutionPayload,
+    blockValue: UintBn256,
+  },
+  {typeName: "BuiltPayload"}
+);
+export const BuiltPayloadDeneb = new ContainerType(
+  {
+    payload: ssz.deneb.ExecutionPayload,
+    blockValue: UintBn256,
+    blobsBundle: ssz.deneb.BlobsBundle,
+    shouldOverrideBuilder: ssz.Boolean,
+  },
+  {typeName: "BuiltPayload"}
+);
+export const BuiltPayloadElectra = new ContainerType(
+  {
+    payload: ssz.electra.ExecutionPayload,
+    blockValue: UintBn256,
+    blobsBundle: ssz.deneb.BlobsBundle,
+    executionRequests: ExecutionRequestsList,
+    shouldOverrideBuilder: ssz.Boolean,
+  },
+  {typeName: "BuiltPayload"}
+);
+export const BuiltPayloadFulu = new ContainerType(
+  {
+    payload: ssz.fulu.ExecutionPayload,
+    blockValue: UintBn256,
+    blobsBundle: ssz.fulu.BlobsBundle,
+    executionRequests: ExecutionRequestsList,
+    shouldOverrideBuilder: ssz.Boolean,
+  },
+  {typeName: "BuiltPayload"}
+);
+export const BuiltPayloadGloas = new ContainerType(
+  {
+    payload: ssz.gloas.ExecutionPayload,
+    blockValue: UintBn256,
+    blobsBundle: ssz.fulu.BlobsBundle,
+    executionRequests: ExecutionRequestsList,
+    shouldOverrideBuilder: ssz.Boolean,
+  },
+  {typeName: "BuiltPayload"}
+);
+
+export const ExecutionPayloadBodyBellatrix = new ContainerType(
+  {transactions: ssz.bellatrix.Transactions},
+  {typeName: "ExecutionPayloadBody"}
+);
+export const ExecutionPayloadBodyCapella = new ContainerType(
+  {
+    transactions: ssz.bellatrix.Transactions,
+    withdrawals: ssz.capella.Withdrawals,
+  },
+  {typeName: "ExecutionPayloadBody"}
+);
+export const ExecutionPayloadBodyGloas = new ContainerType(
+  {
+    transactions: ssz.bellatrix.Transactions,
+    withdrawals: ssz.capella.Withdrawals,
+    blockAccessList: new ByteListType(MAX_BAL_BYTES),
+  },
+  {typeName: "ExecutionPayloadBody"}
+);
+
+function BodiesResponseType<T extends CompositeType<ValueOf<T>, CompositeView<T>, CompositeViewDU<T>>>(body: T) {
+  const BodyEntry = new ContainerType({available: ssz.Boolean, body}, {typeName: "BodyEntry"});
+  return new ContainerType(
+    {entries: new ListCompositeType(BodyEntry, MAX_BODIES_REQUEST)},
+    {typeName: "BodiesResponse"}
+  );
+}
+
+export const BodiesResponseBellatrix = BodiesResponseType(ExecutionPayloadBodyBellatrix);
+export const BodiesResponseCapella = BodiesResponseType(ExecutionPayloadBodyCapella);
+export const BodiesResponseGloas = BodiesResponseType(ExecutionPayloadBodyGloas);
+
+export const BodiesByHashRequest = new ContainerType(
+  {blockHashes: new ListCompositeType(Bytes32, MAX_BODIES_REQUEST)},
+  {typeName: "BodiesByHashRequest"}
+);
+
+export const BlobsRequest = new ContainerType(
+  {versionedHashes: new ListCompositeType(Bytes32, MAX_BLOBS_REQUEST)},
+  {typeName: "BlobsRequest"}
+);
+
+const BlobAndProofV1 = new ContainerType(
+  {
+    blob: ssz.deneb.Blob,
+    proof: Bytes48,
+  },
+  {typeName: "BlobAndProofV1"}
+);
+
+const BlobAndProofV2 = new ContainerType(
+  {
+    blob: ssz.deneb.Blob,
+    proofs: new ListCompositeType(Bytes48, CELLS_PER_EXT_BLOB),
+  },
+  {typeName: "BlobAndProofV2"}
+);
+
+function BlobsResponseType<T extends CompositeType<ValueOf<T>, CompositeView<T>, CompositeViewDU<T>>>(contents: T) {
+  const BlobEntry = new ContainerType({available: ssz.Boolean, contents}, {typeName: "BlobEntry"});
+  return new ContainerType({entries: new ListCompositeType(BlobEntry, MAX_BLOBS_REQUEST)}, {typeName: "BlobsResponse"});
+}
+
+export const BlobsV1Response = BlobsResponseType(BlobAndProofV1);
+export const BlobsV2Response = BlobsResponseType(BlobAndProofV2);
+
+const bellatrix = {
+  PayloadAttributes: PayloadAttributesBellatrix,
+  ForkchoiceUpdate: ForkchoiceUpdateBellatrix,
+  ExecutionPayloadEnvelope: ExecutionPayloadEnvelopeBellatrix,
+  BuiltPayload: BuiltPayloadBellatrix,
+  BodiesResponse: BodiesResponseBellatrix,
+};
+
+const capella = {
+  PayloadAttributes: PayloadAttributesCapella,
+  ForkchoiceUpdate: ForkchoiceUpdateCapella,
+  ExecutionPayloadEnvelope: ExecutionPayloadEnvelopeCapella,
+  BuiltPayload: BuiltPayloadCapella,
+  BodiesResponse: BodiesResponseCapella,
+};
+
+const deneb = {
+  PayloadAttributes: PayloadAttributesDeneb,
+  ForkchoiceUpdate: ForkchoiceUpdateDeneb,
+  ExecutionPayloadEnvelope: ExecutionPayloadEnvelopeDeneb,
+  BuiltPayload: BuiltPayloadDeneb,
+  BodiesResponse: BodiesResponseCapella,
+};
+
+const electra = {
+  ...deneb,
+  ExecutionPayloadEnvelope: ExecutionPayloadEnvelopeElectra,
+  BuiltPayload: BuiltPayloadElectra,
+};
+
+const fulu = {
+  ...electra,
+  BuiltPayload: BuiltPayloadFulu,
+};
+
+const gloas = {
+  PayloadAttributes: PayloadAttributesGloas,
+  ForkchoiceUpdate: ForkchoiceUpdateGloas,
+  ExecutionPayloadEnvelope: ExecutionPayloadEnvelopeGloas,
+  BuiltPayload: BuiltPayloadGloas,
+  BodiesResponse: BodiesResponseGloas,
+};
+
+export const engineSszTypes = {
+  [ForkName.bellatrix]: bellatrix,
+  [ForkName.capella]: capella,
+  [ForkName.deneb]: deneb,
+  [ForkName.electra]: electra,
+  [ForkName.fulu]: fulu,
+  [ForkName.gloas]: gloas,
+  [ForkName.heze]: gloas,
+};
+
+export type PayloadStatusSsz = ValueOf<typeof PayloadStatus>;
+
+/** Fork names accepted in the `Eth-Execution-Version` header */
+export type ExecutionForkName = "paris" | "shanghai" | "cancun" | "prague" | "osaka" | "amsterdam";
+
+/** Heze has no execution fork name in the spec yet, auto mode serves it over JSON-RPC and ssz mode fails the call */
+export const executionForkName: Record<ForkPostBellatrix, ExecutionForkName | null> = {
+  [ForkName.bellatrix]: "paris",
+  [ForkName.capella]: "shanghai",
+  [ForkName.deneb]: "cancun",
+  [ForkName.electra]: "prague",
+  [ForkName.fulu]: "osaka",
+  [ForkName.gloas]: "amsterdam",
+  [ForkName.heze]: null,
+};
+
+export enum PayloadStatusCode {
+  VALID = 0,
+  INVALID = 1,
+  SYNCING = 2,
+  ACCEPTED = 3,
+}

package/src/execution/engine/transport.ts

@@ -0,0 +1,61 @@
+import {ForkName} from "@lodestar/params";
+import {BlobsBundle, ExecutionPayload, ExecutionRequests, Root, RootHex, Wei} from "@lodestar/types";
+import {BlobAndProof} from "@lodestar/types/deneb";
+import {BlobAndProofV2} from "@lodestar/types/fulu";
+import {ClientVersion, ExecutionPayloadStatus, PayloadAttributes, PayloadId, VersionedHashes} from "./interface.js";
+import {JsonRpcHttpClientEventEmitter} from "./jsonRpcHttpClient.js";
+import {ExecutionPayloadBodyV2} from "./types.js";
+
+export type PayloadStatusResult = {
+  status: ExecutionPayloadStatus;
+  latestValidHash: RootHex | null;
+  validationError: string | null;
+};
+
+export type ForkchoiceUpdatedResult = {
+  payloadStatus: PayloadStatusResult;
+  payloadId: PayloadId | null;
+};
+
+export type GetPayloadResult = {
+  executionPayload: ExecutionPayload;
+  executionPayloadValue: Wei;
+  blobsBundle?: BlobsBundle;
+  executionRequests?: ExecutionRequests;
+  shouldOverrideBuilder?: boolean;
+};
+
+/**
+ * Wire-level access to the engine API of the execution client. Implementations only translate
+ * between Lodestar types and the encoding of their transport, `ExecutionEngineHttp` owns request
+ * ordering, engine state and result interpretation.
+ */
+export interface IEngineTransport {
+  readonly emitter: JsonRpcHttpClientEventEmitter;
+
+  newPayload(
+    fork: ForkName,
+    executionPayload: ExecutionPayload,
+    versionedHashes?: VersionedHashes,
+    parentBeaconBlockRoot?: Root,
+    executionRequests?: ExecutionRequests
+  ): Promise<PayloadStatusResult>;
+
+  forkchoiceUpdated(
+    fork: ForkName,
+    headBlockHash: RootHex,
+    safeBlockHash: RootHex,
+    finalizedBlockHash: RootHex,
+    payloadAttributes?: PayloadAttributes
+  ): Promise<ForkchoiceUpdatedResult>;
+
+  getPayload(fork: ForkName, payloadId: PayloadId): Promise<GetPayloadResult>;
+
+  getPayloadBodiesByHashV2(blockHashes: RootHex[]): Promise<(ExecutionPayloadBodyV2 | null)[]>;
+
+  getBlobsV1(versionedHashes: VersionedHashes): Promise<(BlobAndProof | null)[]>;
+
+  getBlobsV2(versionedHashes: VersionedHashes, buffers?: Uint8Array[]): Promise<BlobAndProofV2[] | null>;
+
+  getClientVersion(clientVersion: ClientVersion): Promise<ClientVersion[]>;
+}

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 {Type} from "@chainsafe/ssz";
 import {
   BUILDER_DEPOSIT_REQUEST_TYPE,
   BUILDER_EXIT_REQUEST_TYPE,
@@ -20,7 +21,6 @@ import {
   bellatrix,
   capella,
   deneb,
-  electra,
   gloas,
   ssz,
 } from "@lodestar/types";
@@ -501,63 +501,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;
-}
-
-function serializeDepositRequests(depositRequests: electra.DepositRequests): DepositRequestsRpc {
-  const requestsBytes = ssz.electra.DepositRequests.serialize(depositRequests);
-  return bytesToData(prefixRequests(requestsBytes, DEPOSIT_REQUEST_TYPE));
-}
-
-function deserializeDepositRequests(serialized: DepositRequestsRpc): electra.DepositRequests {
-  return ssz.electra.DepositRequests.deserialize(dataToBytes(serialized, null));
-}
-
-function serializeWithdrawalRequests(withdrawalRequests: electra.WithdrawalRequests): WithdrawalRequestsRpc {
-  const requestsBytes = ssz.electra.WithdrawalRequests.serialize(withdrawalRequests);
-  return bytesToData(prefixRequests(requestsBytes, WITHDRAWAL_REQUEST_TYPE));
-}
-
-function deserializeWithdrawalRequests(serialized: WithdrawalRequestsRpc): electra.WithdrawalRequests {
-  return ssz.electra.WithdrawalRequests.deserialize(dataToBytes(serialized, null));
-}
-
-function serializeConsolidationRequests(
-  consolidationRequests: electra.ConsolidationRequests
-): ConsolidationRequestsRpc {
-  const requestsBytes = ssz.electra.ConsolidationRequests.serialize(consolidationRequests);
-  return bytesToData(prefixRequests(requestsBytes, CONSOLIDATION_REQUEST_TYPE));
-}
-
-function deserializeConsolidationRequests(serialized: ConsolidationRequestsRpc): electra.ConsolidationRequests {
-  return ssz.electra.ConsolidationRequests.deserialize(dataToBytes(serialized, null));
-}
-
-function serializeBuilderDepositRequests(
-  builderDepositRequests: gloas.BuilderDepositRequests
-): BuilderDepositRequestsRpc {
-  const requestsBytes = ssz.gloas.BuilderDepositRequests.serialize(builderDepositRequests);
-  return bytesToData(prefixRequests(requestsBytes, BUILDER_DEPOSIT_REQUEST_TYPE));
-}
-
-function deserializeBuilderDepositRequests(serialized: BuilderDepositRequestsRpc): gloas.BuilderDepositRequests {
-  return ssz.gloas.BuilderDepositRequests.deserialize(dataToBytes(serialized, null));
-}
-
-function serializeBuilderExitRequests(builderExitRequests: gloas.BuilderExitRequests): BuilderExitRequestsRpc {
-  const requestsBytes = ssz.gloas.BuilderExitRequests.serialize(builderExitRequests);
-  return bytesToData(prefixRequests(requestsBytes, BUILDER_EXIT_REQUEST_TYPE));
-}
-
-function deserializeBuilderExitRequests(serialized: BuilderExitRequestsRpc): gloas.BuilderExitRequests {
-  return ssz.gloas.BuilderExitRequests.deserialize(dataToBytes(serialized, null));
+  return uint8Array;
 }
 
 /**
@@ -567,62 +519,65 @@ function deserializeBuilderExitRequests(serialized: BuilderExitRequestsRpc): glo
  * Gloas extends the list with builder deposits (0x03) and builder exits (0x04) per
  * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#modified-get_execution_requests_list
  */
-export function serializeExecutionRequests(fork: ForkName, executionRequests: ExecutionRequests): ExecutionRequestsRpc {
+export function serializeExecutionRequestsToBytes(fork: ForkName, executionRequests: ExecutionRequests): Uint8Array[] {
   const {deposits, withdrawals, consolidations} = executionRequests;
-  const result: ExecutionRequestsRpc = [];
+  const result: Uint8Array[] = [];
 
   if (deposits.length !== 0) {
-    result.push(serializeDepositRequests(deposits));
+    result.push(serializePrefixedRequests(ssz.electra.DepositRequests, deposits, DEPOSIT_REQUEST_TYPE));
   }
 
   if (withdrawals.length !== 0) {
-    result.push(serializeWithdrawalRequests(withdrawals));
+    result.push(serializePrefixedRequests(ssz.electra.WithdrawalRequests, withdrawals, WITHDRAWAL_REQUEST_TYPE));
   }
 
   if (consolidations.length !== 0) {
-    result.push(serializeConsolidationRequests(consolidations));
+    result.push(
+      serializePrefixedRequests(ssz.electra.ConsolidationRequests, consolidations, CONSOLIDATION_REQUEST_TYPE)
+    );
   }
 
   if (ForkSeq[fork] >= ForkSeq.gloas) {
     const {builderDeposits, builderExits} = executionRequests as gloas.ExecutionRequests;
 
     if (builderDeposits.length !== 0) {
-      result.push(serializeBuilderDepositRequests(builderDeposits));
+      result.push(
+        serializePrefixedRequests(ssz.gloas.BuilderDepositRequests, builderDeposits, BUILDER_DEPOSIT_REQUEST_TYPE)
+      );
     }
 
     if (builderExits.length !== 0) {
-      result.push(serializeBuilderExitRequests(builderExits));
+      result.push(serializePrefixedRequests(ssz.gloas.BuilderExitRequests, builderExits, BUILDER_EXIT_REQUEST_TYPE));
     }
   }
 
   return result;
 }
 
-export function deserializeExecutionRequests(fork: ForkName, serialized: ExecutionRequestsRpc): ExecutionRequests {
+export function serializeExecutionRequests(fork: ForkName, executionRequests: ExecutionRequests): ExecutionRequestsRpc {
+  return serializeExecutionRequestsToBytes(fork, executionRequests).map(bytesToData);
+}
+
+export function deserializeExecutionRequestsFromBytes(fork: ForkName, serialized: Uint8Array[]): ExecutionRequests {
   const result: ExecutionRequests =
     ForkSeq[fork] >= ForkSeq.gloas
       ? {deposits: [], withdrawals: [], consolidations: [], builderDeposits: [], builderExits: []}
       : {deposits: [], withdrawals: [], consolidations: []};
 
-  if (serialized.length === 0) {
-    return result;
-  }
-
   let prevRequestType: ExecutionRequestType | undefined;
 
-  for (let prefixedRequests of serialized) {
-    // Slice out 0x so it is easier to extract request type
-    if (prefixedRequests.startsWith("0x")) {
-      prefixedRequests = prefixedRequests.slice(2);
+  for (const prefixedRequests of serialized) {
+    if (prefixedRequests.length === 0) {
+      throw Error("Invalid request type, request must be prefixed with its type");
     }
 
-    const currentRequestType = parseInt(prefixedRequests.substring(0, 2), 16);
+    const currentRequestType = prefixedRequests[0];
 
     if (!isExecutionRequestType(currentRequestType)) {
-      throw Error(`Invalid request type currentRequestType=${prefixedRequests.substring(0, 2)}`);
+      throw Error(`Invalid request type currentRequestType=${currentRequestType}`);
     }
 
-    const requests = prefixedRequests.slice(2);
+    const requests = prefixedRequests.subarray(1);
 
     if (requests.length === 0) {
       throw Error(
@@ -638,29 +593,29 @@ export function deserializeExecutionRequests(fork: ForkName, serialized: Executi
 
     switch (currentRequestType) {
       case DEPOSIT_REQUEST_TYPE: {
-        result.deposits = deserializeDepositRequests(requests);
+        result.deposits = ssz.electra.DepositRequests.deserialize(requests);
         break;
       }
       case WITHDRAWAL_REQUEST_TYPE: {
-        result.withdrawals = deserializeWithdrawalRequests(requests);
+        result.withdrawals = ssz.electra.WithdrawalRequests.deserialize(requests);
         break;
       }
       case CONSOLIDATION_REQUEST_TYPE: {
-        result.consolidations = deserializeConsolidationRequests(requests);
+        result.consolidations = ssz.electra.ConsolidationRequests.deserialize(requests);
         break;
       }
       case BUILDER_DEPOSIT_REQUEST_TYPE: {
         if (ForkSeq[fork] < ForkSeq.gloas) {
           throw Error(`Builder deposit request is not supported pre-gloas fork=${fork}`);
         }
-        (result as gloas.ExecutionRequests).builderDeposits = deserializeBuilderDepositRequests(requests);
+        (result as gloas.ExecutionRequests).builderDeposits = ssz.gloas.BuilderDepositRequests.deserialize(requests);
         break;
       }
       case BUILDER_EXIT_REQUEST_TYPE: {
         if (ForkSeq[fork] < ForkSeq.gloas) {
           throw Error(`Builder exit request is not supported pre-gloas fork=${fork}`);
         }
-        (result as gloas.ExecutionRequests).builderExits = deserializeBuilderExitRequests(requests);
+        (result as gloas.ExecutionRequests).builderExits = ssz.gloas.BuilderExitRequests.deserialize(requests);
         break;
       }
     }
@@ -670,6 +625,13 @@ export function deserializeExecutionRequests(fork: ForkName, serialized: Executi
   return result;
 }
 
+export function deserializeExecutionRequests(fork: ForkName, serialized: ExecutionRequestsRpc): ExecutionRequests {
+  return deserializeExecutionRequestsFromBytes(
+    fork,
+    serialized.map((data) => dataToBytes(data, null))
+  );
+}
+
 export function deserializeExecutionPayloadBody(data: ExecutionPayloadBodyRpc | null): ExecutionPayloadBody | null {
   return data
     ? {

package/src/execution/engine/utils.ts

@@ -8,6 +8,7 @@ import {
   JsonRpcHttpClientEvent,
   JsonRpcHttpClientEventEmitter,
 } from "./jsonRpcHttpClient.js";
+import {EngineRestError, EngineRestResponseError} from "./restHttpClient.js";
 
 /** QUANTITY as defined in ethereum execution layer JSON RPC https://eth.wiki/json-rpc/API */
 export type QUANTITY = string;
@@ -191,12 +192,21 @@ function getExecutionEngineStateForPayloadError(
     return oldState;
   }
 
+  if (payloadError instanceof EngineRestError && (payloadError.status === 401 || payloadError.status === 403)) {
+    return ExecutionEngineState.AUTH_FAILED;
+  }
+
   // Originally this case was handled with {status: ExecutePayloadStatus.ELERROR}
-  if (payloadError instanceof HttpRpcError || payloadError instanceof ErrorJsonRpcResponse) {
+  if (
+    payloadError instanceof HttpRpcError ||
+    payloadError instanceof ErrorJsonRpcResponse ||
+    payloadError instanceof EngineRestError ||
+    payloadError instanceof EngineRestResponseError
+  ) {
     return ExecutionEngineState.SYNCING;
   }
 
-  if (payloadError && isFetchError(payloadError) && HTTP_FATAL_ERROR_CODES.includes(payloadError.code)) {
+  if (isFetchError(payloadError) && HTTP_FATAL_ERROR_CODES.includes(payloadError.code)) {
     return ExecutionEngineState.OFFLINE;
   }