@lodestar/api 1.50.0-dev.fef46df5ba → 1.50.0

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/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`);