@lodestar/api 1.50.0-dev.1f129c79a1 → 1.50.0-dev.20062ed60e

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.50.0-dev.1f129c79a1",
+  "version": "1.50.0-dev.20062ed60e",
   "type": "module",
   "exports": {
     ".": {
@@ -75,11 +75,11 @@
   },
   "dependencies": {
     "@chainsafe/persistent-merkle-tree": "^1.3.1",
-    "@chainsafe/ssz": "^1.8.0",
-    "@lodestar/config": "^1.50.0-dev.1f129c79a1",
-    "@lodestar/params": "^1.50.0-dev.1f129c79a1",
-    "@lodestar/types": "^1.50.0-dev.1f129c79a1",
-    "@lodestar/utils": "^1.50.0-dev.1f129c79a1",
+    "@chainsafe/ssz": "^1.8.1",
+    "@lodestar/config": "^1.50.0-dev.20062ed60e",
+    "@lodestar/params": "^1.50.0-dev.20062ed60e",
+    "@lodestar/types": "^1.50.0-dev.20062ed60e",
+    "@lodestar/utils": "^1.50.0-dev.20062ed60e",
     "eventsource": "^2.0.2",
     "qs": "^6.14.2"
   },
@@ -96,5 +96,5 @@
     "api",
     "blockchain"
   ],
-  "gitHead": "56a698e7fdf2c99a7dd95e1602be9c66521fe94b"
+  "gitHead": "ec866a47abbc8e41a6b314235496afd0212f38c8"
 }

package/src/beacon/client/events.ts

@@ -21,6 +21,7 @@ export function getClient(config: ChainForkConfig, baseUrl: string): ApiClient {
       topics,
       signal,
       onEvent,
+      onOpen,
       onError,
       onClose,
     }): Promise<ApiResponse<Endpoints["eventstream"]>> => {
@@ -39,6 +40,8 @@ export function getClient(config: ChainForkConfig, baseUrl: string): ApiClient {
       };
       signal.addEventListener("abort", close, {once: true});
 
+      eventSource.onopen = () => onOpen?.();
+
       for (const topic of topics) {
         eventSource.addEventListener(topic, (event: MessageEvent) => {
           try {

package/src/beacon/routes/beacon/block.ts

@@ -5,6 +5,7 @@ import {
   ForkPostGloas,
   ForkPreBellatrix,
   ForkPreDeneb,
+  ForkPreGloas,
   isForkPostBellatrix,
   isForkPostDeneb,
   isForkPostGloas,
@@ -296,7 +297,7 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
       method: "GET",
       req: blockIdOnlyReq,
       resp: {
-        data: WithVersion((fork) => ssz[fork].SignedBeaconBlock),
+        data: WithVersion((fork) => sszTypesFor(fork).SignedBeaconBlock),
         meta: ExecutionOptimisticFinalizedAndVersionCodec,
       },
     },
@@ -362,7 +363,7 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
             body:
               isForkPostDeneb(fork) && !isForkPostGloas(fork)
                 ? sszTypesFor(fork).SignedBlockContents.toJson(
-                    signedBlockContents as SignedBlockContents<ForkPostDeneb>
+                    signedBlockContents as SignedBlockContents<ForkPostDeneb & ForkPreGloas>
                   )
                 : sszTypesFor(fork).SignedBeaconBlock.toJson(
                     signedBlockContents.signedBlock as SignedBeaconBlock<ForkPreDeneb | ForkPostGloas>
@@ -380,7 +381,9 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
             signedBlockContents:
               isForkPostDeneb(forkName) && !isForkPostGloas(forkName)
                 ? sszTypesFor(forkName).SignedBlockContents.fromJson(body)
-                : {signedBlock: ssz[forkName].SignedBeaconBlock.fromJson(body)},
+                : ({signedBlock: sszTypesFor(forkName).SignedBeaconBlock.fromJson(body)} as SignedBlockContents<
+                    ForkPreDeneb | ForkPostGloas
+                  >),
             broadcastValidation: query.broadcast_validation as BroadcastValidation,
             builderUrl: fromHeaders(headers, MetaHeader.BuilderUrl, false),
           };
@@ -393,7 +396,7 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
             body:
               isForkPostDeneb(fork) && !isForkPostGloas(fork)
                 ? sszTypesFor(fork).SignedBlockContents.serialize(
-                    signedBlockContents as SignedBlockContents<ForkPostDeneb>
+                    signedBlockContents as SignedBlockContents<ForkPostDeneb & ForkPreGloas>
                   )
                 : sszTypesFor(fork).SignedBeaconBlock.serialize(
                     signedBlockContents.signedBlock as SignedBeaconBlock<ForkPreDeneb | ForkPostGloas>
@@ -411,7 +414,9 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
             signedBlockContents:
               isForkPostDeneb(forkName) && !isForkPostGloas(forkName)
                 ? sszTypesFor(forkName).SignedBlockContents.deserialize(body)
-                : {signedBlock: ssz[forkName].SignedBeaconBlock.deserialize(body)},
+                : ({signedBlock: sszTypesFor(forkName).SignedBeaconBlock.deserialize(body)} as SignedBlockContents<
+                    ForkPreDeneb | ForkPostGloas
+                  >),
             broadcastValidation: query.broadcast_validation as BroadcastValidation,
             builderUrl: fromHeaders(headers, MetaHeader.BuilderUrl, false),
           };

package/src/beacon/routes/beacon/index.ts

@@ -1,6 +1,10 @@
+import {ValueOf} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
-import {phase0, ssz} from "@lodestar/types";
+import {ArrayOf, Root, Slot, phase0, ssz} from "@lodestar/types";
+import {fromHex, toRootHex} from "@lodestar/utils";
 import {EmptyArgs, EmptyMeta, EmptyMetaCodec, EmptyRequest, EmptyRequestCodec} from "../../../utils/codecs.js";
+import {VersionCodec, VersionMeta} from "../../../utils/metadata.js";
+import {Schema} from "../../../utils/schema.js";
 import {Endpoint, RouteDefinitions} from "../../../utils/types.js";
 import * as block from "./block.js";
 import * as pool from "./pool.js";
@@ -27,8 +31,13 @@ export type {
   ValidatorIdentities,
   ValidatorResponse,
   ValidatorStatus,
+  ValidatorStatusFilter,
 } from "./state.js";
 
+const SignedProposerPreferencesListType = ArrayOf(ssz.gloas.SignedProposerPreferences);
+
+type SignedProposerPreferencesList = ValueOf<typeof SignedProposerPreferencesListType>;
+
 export type Endpoints = block.Endpoints &
   pool.Endpoints &
   state.Endpoints &
@@ -41,6 +50,18 @@ export type Endpoints = block.Endpoints &
       phase0.Genesis,
       EmptyMeta
     >;
+
+    /**
+     * Get proposer preferences
+     * Retrieves the signed proposer preferences known by the node for upcoming proposal slots.
+     */
+    getProposerPreferences: Endpoint<
+      "GET",
+      {slot?: Slot; dependentRoot?: Root},
+      {query: {slot?: number; dependent_root?: string}},
+      SignedProposerPreferencesList,
+      VersionMeta
+    >;
   };
 
 export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoints> {
@@ -54,6 +75,24 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         meta: EmptyMetaCodec,
       },
     },
+    getProposerPreferences: {
+      url: "/eth/v1/beacon/proposer_preferences",
+      method: "GET",
+      req: {
+        writeReq: ({slot, dependentRoot}) => ({
+          query: {slot, dependent_root: dependentRoot && toRootHex(dependentRoot)},
+        }),
+        parseReq: ({query}) => ({
+          slot: query.slot,
+          dependentRoot: query.dependent_root ? fromHex(query.dependent_root) : undefined,
+        }),
+        schema: {query: {slot: Schema.Uint, dependent_root: Schema.String}},
+      },
+      resp: {
+        data: SignedProposerPreferencesListType,
+        meta: VersionCodec,
+      },
+    },
     ...block.getDefinitions(config),
     ...pool.getDefinitions(config),
     ...state.getDefinitions(config),

package/src/beacon/routes/beacon/state.ts

@@ -6,6 +6,7 @@ import {
   BuilderStatus,
   CommitteeIndex,
   Epoch,
+  GeneralValidatorStatus,
   RootHex,
   Slot,
   StringType,
@@ -16,7 +17,8 @@ import {
   phase0,
   ssz,
 } from "@lodestar/types";
-import {JsonOnlyReq} from "../../../utils/codecs.js";
+import {JsonOnlyReq, WithVersion} from "../../../utils/codecs.js";
+import {getPostElectraForkTypes} from "../../../utils/fork.js";
 import {Endpoint, RequestCodec, RouteDefinitions, Schema} from "../../../utils/index.js";
 import {
   ExecutionOptimisticAndFinalizedCodec,
@@ -43,6 +45,12 @@ export type BuilderId = string | number;
 
 export type {BuilderStatus, ValidatorStatus};
 
+/**
+ * Beacon API `status` filter: oneOf [ValidatorStatus, enum [active, pending, exited, withdrawal]].
+ * https://github.com/ethereum/beacon-APIs/blob/master/apis/beacon/states/validators.yaml
+ */
+export type ValidatorStatusFilter = ValidatorStatus | GeneralValidatorStatus;
+
 export const RandaoResponseType = new ContainerType({
   randao: ssz.Root,
 });
@@ -91,6 +99,10 @@ export const EpochSyncCommitteeResponseType = new ContainerType(
   },
   {jsonCase: "eth2"}
 );
+export const PtcResponseType = new ContainerType({
+  slot: ssz.Slot,
+  validators: ssz.gloas.PayloadTimelinessCommittee,
+});
 export const ValidatorResponseListType = ArrayOf(ValidatorResponseType);
 export const BuilderResponseListType = ArrayOf(BuilderResponseType);
 export const ValidatorIdentitiesType = ArrayOf(ValidatorIdentityType);
@@ -104,6 +116,7 @@ export type BuilderResponse = ValueOf<typeof BuilderResponseType>;
 export type EpochCommitteeResponse = ValueOf<typeof EpochCommitteeResponseType>;
 export type ValidatorBalance = ValueOf<typeof ValidatorBalanceType>;
 export type EpochSyncCommitteeResponse = ValueOf<typeof EpochSyncCommitteeResponseType>;
+export type PtcResponse = ValueOf<typeof PtcResponseType>;
 
 export type ValidatorResponseList = ValueOf<typeof ValidatorResponseListType>;
 export type BuilderResponseList = ValueOf<typeof BuilderResponseListType>;
@@ -191,9 +204,9 @@ export type Endpoints = {
       /** Either hex encoded public key (with 0x prefix) or validator index */
       validatorIds?: ValidatorId[];
       /** [Validator status specification](https://hackmd.io/ofFJ5gOmQpu1jjHilHbdQQ) */
-      statuses?: ValidatorStatus[];
+      statuses?: ValidatorStatusFilter[];
     },
-    {params: {state_id: string}; query: {id?: ValidatorId[]; status?: ValidatorStatus[]}},
+    {params: {state_id: string}; query: {id?: ValidatorId[]; status?: ValidatorStatusFilter[]}},
     ValidatorResponseList,
     ExecutionOptimisticAndFinalizedMeta
   >;
@@ -208,9 +221,9 @@ export type Endpoints = {
       /** Either hex encoded public key (with 0x prefix) or validator index */
       validatorIds?: ValidatorId[];
       /** [Validator status specification](https://hackmd.io/ofFJ5gOmQpu1jjHilHbdQQ) */
-      statuses?: ValidatorStatus[];
+      statuses?: ValidatorStatusFilter[];
     },
-    {params: {state_id: string}; body: {ids?: string[]; statuses?: ValidatorStatus[]}},
+    {params: {state_id: string}; body: {ids?: string[]; statuses?: ValidatorStatusFilter[]}},
     ValidatorResponseList,
     ExecutionOptimisticAndFinalizedMeta
   >;
@@ -316,6 +329,19 @@ export type Endpoints = {
     ExecutionOptimisticAndFinalizedMeta
   >;
 
+  /**
+   * Get the payload timeliness committee for a slot from the given state.
+   *
+   * Defaults to the state's slot. Validator indices are returned in committee order and may contain duplicates.
+   */
+  getStatePtc: Endpoint<
+    "GET",
+    StateArgs & {slot?: Slot},
+    {params: {state_id: string}; query: {slot?: number}},
+    PtcResponse,
+    ExecutionOptimisticAndFinalizedMeta
+  >;
+
   /**
    * Get State Pending Deposits
    *
@@ -444,6 +470,22 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
         meta: ExecutionOptimisticAndFinalizedCodec,
       },
     },
+    getStatePtc: {
+      url: "/eth/v1/beacon/states/{state_id}/ptc",
+      method: "GET",
+      req: {
+        writeReq: ({stateId, slot}) => ({params: {state_id: stateId.toString()}, query: {slot}}),
+        parseReq: ({params, query}) => ({stateId: params.state_id, slot: query.slot}),
+        schema: {
+          params: {state_id: Schema.StringRequired},
+          query: {slot: Schema.Uint},
+        },
+      },
+      resp: {
+        data: PtcResponseType,
+        meta: ExecutionOptimisticAndFinalizedCodec,
+      },
+    },
     getStateFinalityCheckpoints: {
       url: "/eth/v1/beacon/states/{state_id}/finality_checkpoints",
       method: "GET",
@@ -642,7 +684,7 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
       method: "GET",
       req: stateIdOnlyReq,
       resp: {
-        data: ssz.electra.PendingDeposits,
+        data: WithVersion((fork) => getPostElectraForkTypes(fork).PendingDeposits),
         meta: ExecutionOptimisticFinalizedAndVersionCodec,
       },
     },
@@ -651,7 +693,7 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
       method: "GET",
       req: stateIdOnlyReq,
       resp: {
-        data: ssz.electra.PendingPartialWithdrawals,
+        data: WithVersion((fork) => getPostElectraForkTypes(fork).PendingPartialWithdrawals),
         meta: ExecutionOptimisticFinalizedAndVersionCodec,
       },
     },
@@ -660,7 +702,7 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
       method: "GET",
       req: stateIdOnlyReq,
       resp: {
-        data: ssz.electra.PendingConsolidations,
+        data: WithVersion((fork) => getPostElectraForkTypes(fork).PendingConsolidations),
         meta: ExecutionOptimisticFinalizedAndVersionCodec,
       },
     },

package/src/beacon/routes/debug.ts

@@ -80,40 +80,52 @@ const ForkChoiceResponseType = new ContainerType(
 
 const ForkChoiceNodeV2ExtraDataType = new ContainerType(
   {
+    attestationScore: ssz.Gwei,
     executionOptimistic: ssz.Boolean,
+    gasLimit: new OptionalType(ssz.UintNum64),
     timestamp: ssz.UintNum64,
+    stateRoot: stringType,
     target: stringType,
-    justifiedEpoch: ssz.Epoch,
-    finalizedEpoch: ssz.Epoch,
     unrealizedJustifiedEpoch: ssz.Epoch,
+    unrealizedJustifiedRoot: stringType,
     unrealizedFinalizedEpoch: ssz.Epoch,
-    payloadAttesterCount: new OptionalType(ssz.UintNum64),
-    payloadAvailabilityYesCount: new OptionalType(ssz.UintNum64),
-    payloadDataAvailabilityYesCount: new OptionalType(ssz.UintNum64),
-    gasLimit: new OptionalType(ssz.UintNum64),
+    unrealizedFinalizedRoot: stringType,
   },
   {jsonCase: "eth2"}
 );
+const payloadStatusType = new StringType<"pending" | "empty" | "full">();
 const ForkChoiceNodeV2Type = new ContainerType(
   {
-    payloadStatus: new StringType<"pending" | "empty" | "full">(),
     slot: ssz.Slot,
     blockRoot: stringType,
+    payloadStatus: payloadStatusType,
     parentRoot: stringType,
+    parentPayloadStatus: new OptionalType(payloadStatusType),
+    justifiedCheckpoint: ssz.phase0.Checkpoint,
+    finalizedCheckpoint: ssz.phase0.Checkpoint,
     weight: ssz.Gwei,
     validity: new StringType<"valid" | "invalid" | "optimistic">(),
     executionBlockHash: stringType,
+    payloadAttesterCount: ssz.UintNum64,
+    payloadAvailabilityYesCount: ssz.UintNum64,
+    payloadDataAvailabilityYesCount: ssz.UintNum64,
     extraData: ForkChoiceNodeV2ExtraDataType,
   },
   {jsonCase: "eth2"}
 );
 const ForkChoiceExtraDataType = new ContainerType(
   {
-    unrealizedJustifiedCheckpoint: ssz.phase0.Checkpoint,
-    unrealizedFinalizedCheckpoint: ssz.phase0.Checkpoint,
+    head: new ContainerType(
+      {
+        blockRoot: stringType,
+        payloadStatus: payloadStatusType,
+      },
+      {jsonCase: "eth2"}
+    ),
     proposerBoostRoot: stringType,
     previousProposerBoostRoot: stringType,
-    headRoot: stringType,
+    unrealizedJustifiedCheckpoint: ssz.phase0.Checkpoint,
+    unrealizedFinalizedCheckpoint: ssz.phase0.Checkpoint,
   },
   {jsonCase: "eth2"}
 );
@@ -255,14 +267,6 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
         data: ForkChoiceResponseV2Type,
         meta: EmptyMetaCodec,
         onlySupport: WireFormat.json,
-        transform: {
-          toResponse: (data) => ({
-            ...(data as ForkChoiceResponseV2),
-          }),
-          fromResponse: (resp) => ({
-            data: resp as ForkChoiceResponseV2,
-          }),
-        },
       },
     },
     getProtoArrayNodes: {

package/src/beacon/routes/events.ts

@@ -69,10 +69,31 @@ const headV2 = new ContainerType(
   },
   {typeName: "HeadV2", jsonCase: "eth2"}
 );
+const phase0Block = new ContainerType(
+  {
+    slot: ssz.Slot,
+    block: stringType,
+    executionOptimistic: ssz.Boolean,
+  },
+  {typeName: "Block", jsonCase: "eth2"}
+);
+const gloasBlock = new ContainerType(
+  {
+    slot: ssz.Slot,
+    block: stringType,
+    blockHash: stringType,
+    builderIndex: ssz.BuilderIndex,
+    executionOptimistic: ssz.Boolean,
+  },
+  {typeName: "BlockGloas", jsonCase: "eth2"}
+);
 type FuluDataColumnSidecarSSE = ValueOf<typeof fuluDataColumnSidecarSSE>;
 type GloasDataColumnSidecarSSE = ValueOf<typeof gloasDataColumnSidecarSSE>;
 type DataColumnSidecarSSE = FuluDataColumnSidecarSSE | GloasDataColumnSidecarSSE;
 type HeadV2 = ValueOf<typeof headV2>;
+type Phase0BlockSSE = ValueOf<typeof phase0Block>;
+type GloasBlockSSE = ValueOf<typeof gloasBlock>;
+type BlockSSE = Phase0BlockSSE | GloasBlockSSE;
 
 export enum EventType {
   /**
@@ -182,11 +203,7 @@ export type EventData = {
     version: ForkName;
     data: HeadV2;
   };
-  [EventType.block]: {
-    slot: Slot;
-    block: RootHex;
-    executionOptimistic: boolean;
-  };
+  [EventType.block]: BlockSSE;
   [EventType.blockGossip]: {
     slot: Slot;
     block: RootHex;
@@ -253,6 +270,8 @@ type EventstreamArgs = {
   topics: EventType[];
   signal: AbortSignal;
   onEvent: (event: BeaconEvent) => void;
+  /** Called every time the connection is established, including reconnects */
+  onOpen?: () => void;
   onError?: (err: Error) => void;
   onClose?: () => void;
 };
@@ -330,14 +349,22 @@ export function getTypeByEvent(config: ChainForkConfig): {[K in EventType]: Type
     ),
     [EventType.headV2]: WithVersion(() => headV2),
 
-    [EventType.block]: new ContainerType(
-      {
-        slot: ssz.Slot,
-        block: stringType,
-        executionOptimistic: ssz.Boolean,
+    [EventType.block]: {
+      toJson: (data) => {
+        const fork = config.getForkName(data.slot);
+        if (isForkPostGloas(fork)) {
+          return gloasBlock.toJson(data as GloasBlockSSE);
+        }
+        return phase0Block.toJson(data);
       },
-      {jsonCase: "eth2"}
-    ),
+      fromJson: (data) => {
+        const fork = config.getForkName(Number((data as BlockSSE).slot));
+        if (isForkPostGloas(fork)) {
+          return gloasBlock.fromJson(data);
+        }
+        return phase0Block.fromJson(data);
+      },
+    },
     [EventType.blockGossip]: new ContainerType(
       {
         slot: ssz.Slot,

package/src/beacon/routes/lodestar.ts

@@ -11,6 +11,7 @@ import {
   Slot,
   ValidatorIndex,
   ssz,
+  sszTypesFor,
 } from "@lodestar/types";
 import {
   EmptyArgs,
@@ -672,13 +673,13 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
           if (signedBlocks.length === 0) throw new Error("No blocks provided.");
           const fork = config.getForkName(signedBlocks[0].message.slot);
           return {
-            body: ArrayOf(ssz[fork].SignedBeaconBlock).toJson(signedBlocks as SignedBeaconBlock<typeof fork>[]),
+            body: ArrayOf(sszTypesFor(fork).SignedBeaconBlock).toJson(signedBlocks),
             headers: {[MetaHeader.Version]: fork},
           };
         },
         parseReqJson: ({body, headers}) => {
           const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
-          const signedBlocks = ArrayOf(ssz[fork].SignedBeaconBlock).fromJson(body) as SignedBeaconBlock[];
+          const signedBlocks = ArrayOf(sszTypesFor(fork).SignedBeaconBlock).fromJson(body);
           assertBlocksMatchFork(signedBlocks, fork);
           return {signedBlocks};
         },
@@ -686,13 +687,13 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
           if (signedBlocks.length === 0) throw new Error("No blocks provided.");
           const fork = config.getForkName(signedBlocks[0].message.slot);
           return {
-            body: ArrayOf(ssz[fork].SignedBeaconBlock).serialize(signedBlocks as SignedBeaconBlock<typeof fork>[]),
+            body: ArrayOf(sszTypesFor(fork).SignedBeaconBlock).serialize(signedBlocks),
             headers: {[MetaHeader.Version]: fork},
           };
         },
         parseReqSsz: ({body, headers}) => {
           const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
-          const signedBlocks = ArrayOf(ssz[fork].SignedBeaconBlock).deserialize(body) as SignedBeaconBlock[];
+          const signedBlocks = ArrayOf(sszTypesFor(fork).SignedBeaconBlock).deserialize(body);
           assertBlocksMatchFork(signedBlocks, fork);
           return {signedBlocks};
         },

package/src/index.ts

@@ -1,6 +1,6 @@
 // Re-exporting beacon only for backwards compatibility
 export * from "./beacon/index.js";
-export {ApiError} from "./utils/client/error.js";
+export {ApiError, type ApiFailure} from "./utils/client/error.js";
 export type {
   ApiClientMethods,
   HttpClientModules,

package/src/utils/client/error.ts

@@ -1,10 +1,16 @@
+/** Failure of a single item of a batch request, `index` refers to the submitted array */
+export type ApiFailure = {index: number; message: string};
+
 export class ApiError extends Error {
   status: number;
   operationId: string;
+  /** Set if the server rejected only some items of a batch request */
+  failures?: ApiFailure[];
 
-  constructor(message: string, status: number, operationId: string) {
+  constructor(message: string, status: number, operationId: string, failures?: ApiFailure[]) {
     super(`${operationId} failed with status ${status}: ${message}`);
     this.status = status;
     this.operationId = operationId;
+    this.failures = failures;
   }
 }

package/src/utils/client/response.ts

@@ -2,7 +2,7 @@ import {HeadersExtra, HttpHeader, parseContentTypeHeader} from "../headers.js";
 import {HttpStatusCode} from "../httpStatusCode.js";
 import {Endpoint} from "../types.js";
 import {WireFormat, getWireFormat} from "../wireFormat.js";
-import {ApiError} from "./error.js";
+import {ApiError, ApiFailure} from "./error.js";
 import {RouteDefinitionExtra} from "./request.js";
 
 export type RawBody =
@@ -162,7 +162,8 @@ export class ApiResponse<E extends Endpoint> extends Response {
       return null;
     }
 
-    return new ApiError(this.getErrorMessage(), this.status, this.definition.operationId);
+    const {message, failures} = this.parseErrorBody();
+    return new ApiError(message, this.status, this.definition.operationId, failures);
   }
 
   async errorBody(): Promise<string> {
@@ -187,19 +188,22 @@ export class ApiResponse<E extends Endpoint> extends Response {
     return this._errorBody;
   }
 
-  private getErrorMessage(): string {
+  private parseErrorBody(): {message: string; failures?: ApiFailure[]} {
     const errBody = this.resolvedErrorBody();
     try {
-      const errJson = JSON.parse(errBody) as {message?: string; failures?: {message: string}[]};
+      const errJson = JSON.parse(errBody) as {message?: string; failures?: ApiFailure[]};
       if (errJson.message) {
-        if (errJson.failures) {
-          return `${errJson.message}\n` + errJson.failures.map((e) => e.message).join("\n");
+        if (Array.isArray(errJson.failures)) {
+          return {
+            message: `${errJson.message}\n` + errJson.failures.map((e) => e.message).join("\n"),
+            failures: errJson.failures,
+          };
         }
-        return errJson.message;
+        return {message: errJson.message};
       }
-      return errBody;
+      return {message: errBody};
     } catch (_e) {
-      return errBody || this.statusText;
+      return {message: errBody || this.statusText};
     }
   }
 }

package/src/utils/fork.ts

@@ -3,10 +3,12 @@ import {
   ForkPostAltair,
   ForkPostBellatrix,
   ForkPostDeneb,
+  ForkPostElectra,
   ForkPostGloas,
   isForkPostAltair,
   isForkPostBellatrix,
   isForkPostDeneb,
+  isForkPostElectra,
   isForkPostGloas,
 } from "@lodestar/params";
 import {SSZTypesFor, sszTypesFor} from "@lodestar/types";
@@ -45,6 +47,14 @@ export function getPostDenebForkTypes(fork: ForkName): SSZTypesFor<ForkPostDeneb
   return sszTypesFor(fork);
 }
 
+export function getPostElectraForkTypes(fork: ForkName): SSZTypesFor<ForkPostElectra> {
+  if (!isForkPostElectra(fork)) {
+    throw Error(`Invalid fork=${fork} for post-electra fork types`);
+  }
+
+  return sszTypesFor(fork);
+}
+
 export function getPostGloasForkTypes(fork: ForkName): SSZTypesFor<ForkPostGloas> {
   if (!isForkPostGloas(fork)) {
     throw Error(`Invalid fork=${fork} for post-gloas fork types`);