@lodestar/api 1.47.0-dev.f591cb177e → 1.47.0

package/src/builder/routes.ts

@@ -1,16 +1,18 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkName, VALIDATOR_REGISTRY_LIMIT, isForkPostDeneb} from "@lodestar/params";
+import {ForkName, ForkPostGloas, VALIDATOR_REGISTRY_LIMIT, isForkPostDeneb} from "@lodestar/params";
 import {
   ArrayOf,
   BLSPubkey,
   ExecutionPayload,
   ExecutionPayloadAndBlobsBundle,
   Root,
+  SignedBeaconBlock,
   SignedBlindedBeaconBlock,
   SignedBuilderBid,
   Slot,
   WithOptionalBytes,
   bellatrix,
+  gloas,
   ssz,
 } from "@lodestar/types";
 import {fromHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
@@ -23,7 +25,7 @@ import {
   EmptyResponseData,
   WithVersion,
 } from "../utils/codecs.js";
-import {getPostBellatrixForkTypes, getPostDenebForkTypes, toForkName} from "../utils/fork.js";
+import {getPostBellatrixForkTypes, getPostDenebForkTypes, getPostGloasForkTypes, toForkName} from "../utils/fork.js";
 import {fromHeaders} from "../utils/headers.js";
 import {Endpoint, RouteDefinitions, Schema} from "../utils/index.js";
 import {MetaHeader, VersionCodec, VersionMeta} from "../utils/metadata.js";
@@ -35,6 +37,9 @@ import {WireFormat} from "../utils/wireFormat.js";
 // It is important that this type indicates that there might be no value to ensure it is properly handled downstream.
 export type MaybeSignedBuilderBid = SignedBuilderBid | undefined;
 
+// Same as `MaybeSignedBuilderBid`, the builder responds with 204 if no bid is available
+export type MaybeSignedExecutionPayloadBid = gloas.SignedExecutionPayloadBid | undefined;
+
 const RegistrationsType = ArrayOf(ssz.bellatrix.SignedValidatorRegistrationV1, VALIDATOR_REGISTRY_LIMIT);
 
 export type Endpoints = {
@@ -82,6 +87,45 @@ export type Endpoints = {
     EmptyResponseData,
     EmptyMeta
   >;
+
+  getExecutionPayloadBid: Endpoint<
+    "POST",
+    {
+      slot: Slot;
+      parentHash: Root;
+      parentRoot: Root;
+      proposerPubkey: BLSPubkey;
+      /** Authenticates the requesting proposer to the builder */
+      requestAuth: gloas.SignedBuilderRequestAuth;
+      /** Unix timestamp in milliseconds at which the request was sent */
+      dateMilliseconds: number;
+      /** The proposer's timeout for the request in milliseconds, measured from `dateMilliseconds` */
+      timeoutMs: number;
+    },
+    {
+      params: {slot: Slot; parent_hash: string; parent_root: string; proposer_pubkey: string};
+      body: unknown;
+      headers: {[MetaHeader.Version]: string; [MetaHeader.DateMilliseconds]: string; [MetaHeader.TimeoutMs]: string};
+    },
+    MaybeSignedExecutionPayloadBid,
+    VersionMeta
+  >;
+
+  submitSignedBeaconBlock: Endpoint<
+    "POST",
+    {signedBlock: WithOptionalBytes<SignedBeaconBlock<ForkPostGloas>>},
+    {body: unknown; headers: {[MetaHeader.Version]: string}},
+    EmptyResponseData,
+    EmptyMeta
+  >;
+
+  submitBuilderPreferences: Endpoint<
+    "POST",
+    {proposerPubkey: BLSPubkey; request: gloas.BuilderPreferencesRequest},
+    {params: {proposer_pubkey: string}; body: unknown; headers: {[MetaHeader.Version]: string}},
+    EmptyResponseData,
+    EmptyMeta
+  >;
 };
 
 export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoints> {
@@ -223,5 +267,186 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
       },
       resp: EmptyResponseCodec,
     },
+    getExecutionPayloadBid: {
+      url: "/eth/v1/builder/execution_payload_bid/{slot}/{parent_hash}/{parent_root}/{proposer_pubkey}",
+      method: "POST",
+      req: {
+        writeReqJson: ({slot, parentHash, parentRoot, proposerPubkey, requestAuth, dateMilliseconds, timeoutMs}) => ({
+          params: {
+            slot,
+            parent_hash: toRootHex(parentHash),
+            parent_root: toRootHex(parentRoot),
+            proposer_pubkey: toPubkeyHex(proposerPubkey),
+          },
+          body: ssz.gloas.SignedBuilderRequestAuth.toJson(requestAuth),
+          headers: {
+            [MetaHeader.Version]: config.getForkName(slot),
+            [MetaHeader.DateMilliseconds]: dateMilliseconds.toString(),
+            [MetaHeader.TimeoutMs]: timeoutMs.toString(),
+          },
+        }),
+        parseReqJson: ({params, body, headers}) => {
+          toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            slot: params.slot,
+            parentHash: fromHex(params.parent_hash),
+            parentRoot: fromHex(params.parent_root),
+            proposerPubkey: fromHex(params.proposer_pubkey),
+            requestAuth: ssz.gloas.SignedBuilderRequestAuth.fromJson(body),
+            dateMilliseconds: parseRequiredUintHeader(
+              fromHeaders(headers, MetaHeader.DateMilliseconds),
+              MetaHeader.DateMilliseconds
+            ),
+            timeoutMs: parseRequiredUintHeader(fromHeaders(headers, MetaHeader.TimeoutMs), MetaHeader.TimeoutMs),
+          };
+        },
+        writeReqSsz: ({slot, parentHash, parentRoot, proposerPubkey, requestAuth, dateMilliseconds, timeoutMs}) => ({
+          params: {
+            slot,
+            parent_hash: toRootHex(parentHash),
+            parent_root: toRootHex(parentRoot),
+            proposer_pubkey: toPubkeyHex(proposerPubkey),
+          },
+          body: ssz.gloas.SignedBuilderRequestAuth.serialize(requestAuth),
+          headers: {
+            [MetaHeader.Version]: config.getForkName(slot),
+            [MetaHeader.DateMilliseconds]: dateMilliseconds.toString(),
+            [MetaHeader.TimeoutMs]: timeoutMs.toString(),
+          },
+        }),
+        parseReqSsz: ({params, body, headers}) => {
+          toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            slot: params.slot,
+            parentHash: fromHex(params.parent_hash),
+            parentRoot: fromHex(params.parent_root),
+            proposerPubkey: fromHex(params.proposer_pubkey),
+            requestAuth: ssz.gloas.SignedBuilderRequestAuth.deserialize(body),
+            dateMilliseconds: parseRequiredUintHeader(
+              fromHeaders(headers, MetaHeader.DateMilliseconds),
+              MetaHeader.DateMilliseconds
+            ),
+            timeoutMs: parseRequiredUintHeader(fromHeaders(headers, MetaHeader.TimeoutMs), MetaHeader.TimeoutMs),
+          };
+        },
+        schema: {
+          params: {
+            slot: Schema.UintRequired,
+            parent_hash: Schema.StringRequired,
+            parent_root: Schema.StringRequired,
+            proposer_pubkey: Schema.StringRequired,
+          },
+          body: Schema.Object,
+          headers: {
+            [MetaHeader.Version]: Schema.String,
+            [MetaHeader.DateMilliseconds]: Schema.String,
+            [MetaHeader.TimeoutMs]: Schema.String,
+          },
+        },
+      },
+      resp: {
+        data: WithVersion<MaybeSignedExecutionPayloadBid, VersionMeta>(
+          (fork: ForkName) => getPostGloasForkTypes(fork).SignedExecutionPayloadBid
+        ),
+        meta: VersionCodec,
+      },
+      init: {
+        requestWireFormat: WireFormat.ssz,
+      },
+    },
+    submitSignedBeaconBlock: {
+      url: "/eth/v1/builder/beacon_blocks",
+      method: "POST",
+      req: {
+        writeReqJson: ({signedBlock}) => {
+          const fork = config.getForkName(signedBlock.data.message.slot);
+          return {
+            body: getPostGloasForkTypes(fork).SignedBeaconBlock.toJson(signedBlock.data),
+            headers: {
+              [MetaHeader.Version]: fork,
+            },
+          };
+        },
+        parseReqJson: ({body, headers}) => {
+          const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            signedBlock: {data: getPostGloasForkTypes(fork).SignedBeaconBlock.fromJson(body)},
+          };
+        },
+        writeReqSsz: ({signedBlock}) => {
+          const fork = config.getForkName(signedBlock.data.message.slot);
+          return {
+            body: signedBlock.bytes ?? getPostGloasForkTypes(fork).SignedBeaconBlock.serialize(signedBlock.data),
+            headers: {
+              [MetaHeader.Version]: fork,
+            },
+          };
+        },
+        parseReqSsz: ({body, headers}) => {
+          const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            signedBlock: {data: getPostGloasForkTypes(fork).SignedBeaconBlock.deserialize(body)},
+          };
+        },
+        schema: {
+          body: Schema.Object,
+          headers: {[MetaHeader.Version]: Schema.String},
+        },
+      },
+      resp: EmptyResponseCodec,
+      init: {
+        requestWireFormat: WireFormat.ssz,
+      },
+    },
+    submitBuilderPreferences: {
+      url: "/eth/v1/builder/builder_preferences/{proposer_pubkey}",
+      method: "POST",
+      req: {
+        writeReqJson: ({proposerPubkey, request}) => ({
+          params: {proposer_pubkey: toPubkeyHex(proposerPubkey)},
+          body: ssz.gloas.BuilderPreferencesRequest.toJson(request),
+          headers: {[MetaHeader.Version]: config.getForkName(request.auth.message.slot)},
+        }),
+        parseReqJson: ({params, body, headers}) => {
+          toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            proposerPubkey: fromHex(params.proposer_pubkey),
+            request: ssz.gloas.BuilderPreferencesRequest.fromJson(body),
+          };
+        },
+        writeReqSsz: ({proposerPubkey, request}) => ({
+          params: {proposer_pubkey: toPubkeyHex(proposerPubkey)},
+          body: ssz.gloas.BuilderPreferencesRequest.serialize(request),
+          headers: {[MetaHeader.Version]: config.getForkName(request.auth.message.slot)},
+        }),
+        parseReqSsz: ({params, body, headers}) => {
+          toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            proposerPubkey: fromHex(params.proposer_pubkey),
+            request: ssz.gloas.BuilderPreferencesRequest.deserialize(body),
+          };
+        },
+        schema: {
+          params: {proposer_pubkey: Schema.StringRequired},
+          body: Schema.Object,
+          headers: {[MetaHeader.Version]: Schema.String},
+        },
+      },
+      resp: EmptyResponseCodec,
+      init: {
+        requestWireFormat: WireFormat.ssz,
+      },
+    },
   };
 }
+
+function parseRequiredUintHeader(value: string, header: MetaHeader): number {
+  if (!/^\d+$/.test(value)) {
+    throw Error(`${header} must be a non-negative integer`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    throw Error(`${header} must be a safe integer`);
+  }
+  return parsed;
+}

package/src/keymanager/index.ts

@@ -7,6 +7,8 @@ import * as keymanager from "./client.js";
 
 export type {
   BuilderBoostFactorData,
+  BuilderConfigData,
+  BuilderEntryConfig,
   Endpoints,
   FeeRecipientData,
   GasLimitData,
@@ -19,7 +21,13 @@ export type {
   SignerDefinition,
   SlashingProtectionData,
 } from "./routes.js";
-export {DeleteRemoteKeyStatus, DeletionStatus, ImportRemoteKeyStatus, ImportStatus} from "./routes.js";
+export {
+  DeleteRemoteKeyStatus,
+  DeletionStatus,
+  ImportRemoteKeyStatus,
+  ImportStatus,
+  builderConfigDataFromJson,
+} from "./routes.js";
 
 export type {ApiClient};
 

package/src/keymanager/routes.ts

@@ -1,6 +1,13 @@
 import {ContainerType, ValueOf} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
+import {
+  MAX_BUILDER_AUTH_DATA_SIZE,
+  MAX_BUILDER_ENTRIES,
+  MAX_BUILDER_PUBKEYS,
+  MAX_BUILDER_URL_SIZE,
+} from "@lodestar/params";
 import {Epoch, phase0, ssz, stringType} from "@lodestar/types";
+import {isValidAsciiHttpUrl} from "@lodestar/utils";
 import {
   EmptyArgs,
   EmptyMeta,
@@ -96,6 +103,137 @@ export type GraffitiData = ValueOf<typeof GraffitiDataType>;
 export type GasLimitData = ValueOf<typeof GasLimitDataType>;
 export type BuilderBoostFactorData = ValueOf<typeof BuilderBoostFactorDataType>;
 
+/** Configuration for a single builder to request bids from */
+export type BuilderEntryConfig = {
+  /** URL the bid requests for this entry are sent to */
+  url: string;
+  /** Auth data hex string as agreed with the builder, derived from the UTF-8 bytes of the builder url when omitted */
+  authData?: string;
+  /** Builder BLS pubkeys this entry accepts bids from, empty or omitted accepts any builder */
+  builderPubkeys?: string[];
+  /** Cap in Gwei on the execution payment counted from this builder's bids */
+  maxExecutionPayment?: bigint;
+  /** Floor in Gwei on the counted total payment accepted from this builder's bids */
+  minBid?: bigint;
+  /** Percentage multiplier weighting this builder's bids during selection */
+  builderBoostFactor?: bigint;
+};
+
+/** Per-key builder configuration for requesting and selecting bids */
+export type BuilderConfigData = {
+  /** Default for entries that do not set their own `minBid`, also applies to p2p bids */
+  minBid?: bigint;
+  /** Default for entries that do not set their own `builderBoostFactor`, also applies to p2p bids */
+  builderBoostFactor?: bigint;
+  /** Omitted means use the validator client's builders, empty means request bids from none */
+  builders?: BuilderEntryConfig[];
+};
+
+const BUILDER_AUTH_DATA_PATTERN = new RegExp(`^0x(?:[a-fA-F0-9]{2}){1,${MAX_BUILDER_AUTH_DATA_SIZE}}$`);
+const PUBKEY_PATTERN = /^0x[a-fA-F0-9]{96}$/;
+const UINT64_MAX = 2n ** 64n - 1n;
+
+function parseGweiAmount(value: unknown, field: string): bigint | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]{0,19})$/.test(value)) {
+    throw Error(`${field} must be an unsigned 64-bit integer encoded as a decimal string`);
+  }
+  const parsed = BigInt(value);
+  if (parsed > UINT64_MAX) {
+    throw Error(`${field} must not exceed 2**64 - 1`);
+  }
+  return parsed;
+}
+
+export function builderConfigDataToJson(config: BuilderConfigData): Record<string, unknown> {
+  return {
+    ...(config.minBid !== undefined ? {min_bid: config.minBid.toString()} : {}),
+    ...(config.builderBoostFactor !== undefined ? {builder_boost_factor: config.builderBoostFactor.toString()} : {}),
+    ...(config.builders !== undefined
+      ? {
+          builders: config.builders.map((entry) => ({
+            url: entry.url,
+            ...(entry.authData !== undefined ? {auth_data: entry.authData} : {}),
+            ...(entry.builderPubkeys !== undefined ? {builder_pubkeys: entry.builderPubkeys} : {}),
+            ...(entry.maxExecutionPayment !== undefined
+              ? {max_execution_payment: entry.maxExecutionPayment.toString()}
+              : {}),
+            ...(entry.minBid !== undefined ? {min_bid: entry.minBid.toString()} : {}),
+            ...(entry.builderBoostFactor !== undefined
+              ? {builder_boost_factor: entry.builderBoostFactor.toString()}
+              : {}),
+          })),
+        }
+      : {}),
+  };
+}
+
+export function builderConfigDataFromJson(json: unknown): BuilderConfigData {
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    throw Error("Builder config must be an object");
+  }
+  const {min_bid, builder_boost_factor, builders} = json as Record<string, unknown>;
+
+  let parsedBuilders: BuilderEntryConfig[] | undefined;
+  if (builders !== undefined) {
+    if (!Array.isArray(builders)) {
+      throw Error("builders must be an array");
+    }
+    if (builders.length > MAX_BUILDER_ENTRIES) {
+      throw Error(`builders must not contain more than ${MAX_BUILDER_ENTRIES} entries, got ${builders.length}`);
+    }
+    parsedBuilders = builders.map((entry, i): BuilderEntryConfig => {
+      if (typeof entry !== "object" || entry === null) {
+        throw Error(`builders[${i}] must be an object`);
+      }
+      const {url, auth_data, builder_pubkeys, max_execution_payment} = entry as Record<string, unknown>;
+      if (typeof url !== "string" || url.length === 0) {
+        throw Error(`builders[${i}].url must be a non-empty string`);
+      }
+      if (new TextEncoder().encode(url).length > MAX_BUILDER_URL_SIZE) {
+        throw Error(`builders[${i}].url must not exceed ${MAX_BUILDER_URL_SIZE} bytes`);
+      }
+      if (!isValidAsciiHttpUrl(url)) {
+        throw Error(`builders[${i}].url must be a valid HTTP or HTTPS URL using only ASCII characters`);
+      }
+      if (auth_data !== undefined && (typeof auth_data !== "string" || !BUILDER_AUTH_DATA_PATTERN.test(auth_data))) {
+        throw Error(
+          `builders[${i}].auth_data must be a non-empty hex string of at most ${MAX_BUILDER_AUTH_DATA_SIZE} bytes`
+        );
+      }
+      let builderPubkeys: string[] | undefined;
+      if (builder_pubkeys !== undefined) {
+        if (!Array.isArray(builder_pubkeys) || builder_pubkeys.length > MAX_BUILDER_PUBKEYS) {
+          throw Error(`builders[${i}].builder_pubkeys must be an array of at most ${MAX_BUILDER_PUBKEYS} pubkeys`);
+        }
+        builderPubkeys = builder_pubkeys.map((pubkey) => {
+          if (typeof pubkey !== "string" || !PUBKEY_PATTERN.test(pubkey)) {
+            throw Error(`builders[${i}].builder_pubkeys must contain 48-byte hex pubkeys`);
+          }
+          return pubkey;
+        });
+      }
+      return {
+        url,
+        authData: auth_data as string | undefined,
+        builderPubkeys,
+        maxExecutionPayment: parseGweiAmount(max_execution_payment, `builders[${i}].max_execution_payment`),
+        minBid: parseGweiAmount((entry as Record<string, unknown>).min_bid, `builders[${i}].min_bid`),
+        builderBoostFactor: parseGweiAmount(
+          (entry as Record<string, unknown>).builder_boost_factor,
+          `builders[${i}].builder_boost_factor`
+        ),
+      };
+    });
+  }
+
+  return {
+    minBid: parseGweiAmount(min_bid, "min_bid"),
+    builderBoostFactor: parseGweiAmount(builder_boost_factor, "builder_boost_factor"),
+    builders: parsedBuilders,
+  };
+}
+
 export type SignerDefinition = {
   pubkey: PubkeyHex;
   /**
@@ -117,9 +255,21 @@ export type ProposerConfigResponse = {
     gasLimit?: number;
     selection?: string;
     boostFactor?: string;
+    minBid?: string;
+    maxExecutionPayment?: string;
+    builders?: BuilderEntryConfigResponse[];
   };
 };
 
+export type BuilderEntryConfigResponse = {
+  url: string;
+  authData?: string;
+  builderPubkeys?: string[];
+  maxExecutionPayment?: string;
+  minBid?: string;
+  builderBoostFactor?: string;
+};
+
 /**
  * JSON serialized representation of a single keystore in EIP-2335: BLS12-381 Keystore format.
  * ```
@@ -367,6 +517,33 @@ export type Endpoints = {
     EmptyMeta
   >;
 
+  /** Get the builder configuration in effect for a validator public key, with omitted values resolved */
+  getBuilderConfig: Endpoint<
+    // ⏎
+    "GET",
+    {pubkey: PubkeyHex},
+    {params: {pubkey: string}},
+    BuilderConfigData,
+    EmptyMeta
+  >;
+  /** Set the builder configuration for a validator public key, replacing any stored configuration in full */
+  setBuilderConfig: Endpoint<
+    "POST",
+    {pubkey: PubkeyHex; builderConfig: BuilderConfigData},
+    {params: {pubkey: string}; body: unknown},
+    EmptyResponseData,
+    EmptyMeta
+  >;
+  /** Remove the builder configuration for a validator public key, it then follows the validator client again */
+  deleteBuilderConfig: Endpoint<
+    // ⏎
+    "DELETE",
+    {pubkey: PubkeyHex},
+    {params: {pubkey: string}},
+    EmptyResponseData,
+    EmptyMeta
+  >;
+
   getProposerConfig: Endpoint<
     // ⏎
     "GET",
@@ -654,6 +831,56 @@ export function getDefinitions(_config: ChainForkConfig): RouteDefinitions<Endpo
       },
       resp: EmptyResponseCodec,
     },
+    getBuilderConfig: {
+      url: "/eth/v1/validator/{pubkey}/builder_config",
+      method: "GET",
+      req: {
+        writeReq: ({pubkey}) => ({params: {pubkey}}),
+        parseReq: ({params: {pubkey}}) => ({pubkey}),
+        schema: {
+          params: {pubkey: Schema.StringRequired},
+        },
+      },
+      resp: {
+        onlySupport: WireFormat.json,
+        data: {
+          toJson: (data) => builderConfigDataToJson(data),
+          fromJson: (data) => builderConfigDataFromJson(data),
+          serialize: () => {
+            throw Error("SSZ not supported");
+          },
+          deserialize: () => {
+            throw Error("SSZ not supported");
+          },
+        },
+        meta: EmptyMetaCodec,
+      },
+    },
+    setBuilderConfig: {
+      url: "/eth/v1/validator/{pubkey}/builder_config",
+      method: "POST",
+      req: JsonOnlyReq({
+        writeReqJson: ({pubkey, builderConfig}) => ({params: {pubkey}, body: builderConfigDataToJson(builderConfig)}),
+        parseReqJson: ({params: {pubkey}, body}) => ({pubkey, builderConfig: builderConfigDataFromJson(body)}),
+        schema: {
+          params: {pubkey: Schema.StringRequired},
+          body: Schema.Object,
+        },
+      }),
+      resp: EmptyResponseCodec,
+    },
+    deleteBuilderConfig: {
+      url: "/eth/v1/validator/{pubkey}/builder_config",
+      method: "DELETE",
+      req: {
+        writeReq: ({pubkey}) => ({params: {pubkey}}),
+        parseReq: ({params: {pubkey}}) => ({pubkey}),
+        schema: {
+          params: {pubkey: Schema.StringRequired},
+        },
+      },
+      resp: EmptyResponseCodec,
+    },
 
     getProposerConfig: {
       url: "/eth/v0/validator/{pubkey}/proposer_config",

package/src/utils/client/response.ts

@@ -90,7 +90,7 @@ export class ApiResponse<E extends Endpoint> extends Response {
           const metaJson = this.definition.resp.transform
             ? this.definition.resp.transform.fromResponse(rawBody.value).meta
             : rawBody.value;
-          this._meta = this.definition.resp.meta.fromJson(metaJson);
+          this._meta = this.definition.resp.meta.fromJson(metaJson, new HeadersExtra(this.headers));
           break;
         }
         case WireFormat.ssz:

package/src/utils/metadata.ts

@@ -80,6 +80,11 @@ export enum MetaHeader {
   ExecutionPayloadIncluded = "Eth-Execution-Payload-Included",
   ExecutionPayloadValue = "Eth-Execution-Payload-Value",
 
+  /* Builder API headers */
+  BuilderUrl = "Eth-Builder-Url",
+  DateMilliseconds = "Date-Milliseconds",
+  TimeoutMs = "X-Timeout-Ms",
+
   /* Lodestar-specific (non-standardized) headers */
   Finalized = "Eth-Consensus-Finalized",
   DependentRoot = "Eth-Consensus-Dependent-Root",

package/src/utils/types.ts

@@ -126,7 +126,7 @@ export type ResponseDataCodec<T, M> = {
 
 export type ResponseMetadataCodec<T> = {
   toJson: (val: T) => unknown; // server
-  fromJson: (val: unknown) => T; // client
+  fromJson: (val: unknown, headers?: HeadersExtra) => T; // client
   toHeadersObject: (val: T) => Record<string, string>; // server
   fromHeaders: (headers: HeadersExtra) => T; // server
 };