@lodestar/beacon-node 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/network/reqresp/handlers/blobSidecarsByRoot.ts

@@ -1,62 +0,0 @@
-import {BLOBSIDECAR_FIXED_SIZE} from "@lodestar/params";
-import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {RootHex} from "@lodestar/types";
-import {fromHex, toRootHex} from "@lodestar/utils";
-import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {BLOB_SIDECARS_IN_WRAPPER_INDEX} from "../../../db/repositories/blobSidecars.js";
-import {BlobSidecarsByRootRequest} from "../../../util/types.js";
-
-export async function* onBlobSidecarsByRoot(
-  requestBody: BlobSidecarsByRootRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
-): AsyncIterable<ResponseOutgoing> {
-  const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
-
-  // In sidecars by root request, it can be expected that sidecar requests will be come
-  // clustured by blockroots, and this helps us save db lookups once we load sidecars
-  // for a root
-  let lastFetchedSideCars: {blockRoot: RootHex; bytes: Uint8Array} | null = null;
-
-  for (const blobIdentifier of requestBody) {
-    const {blockRoot, index} = blobIdentifier;
-    const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
-
-    // NOTE: Only support non-finalized blocks.
-    // SPEC: Clients MUST support requesting blocks and sidecars since the latest finalized epoch.
-    // https://github.com/ethereum/consensus-specs/blob/11a037fd9227e29ee809c9397b09f8cc3383a8c0/specs/eip4844/p2p-interface.md#beaconblockandblobssidecarbyroot-v1
-    if (!block || block.slot <= finalizedSlot) {
-      continue;
-    }
-
-    // Check if we need to load sidecars for a new block root
-    if (lastFetchedSideCars === null || lastFetchedSideCars.blockRoot !== blockRootHex) {
-      const blobSideCarsBytesWrapped = await db.blobSidecars.getBinary(fromHex(block.blockRoot));
-      if (!blobSideCarsBytesWrapped) {
-        // Handle the same to onBeaconBlocksByRange
-        throw new ResponseError(RespStatus.SERVER_ERROR, `No item for root ${block.blockRoot} slot ${block.slot}`);
-      }
-      const blobSideCarsBytes = blobSideCarsBytesWrapped.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
-
-      lastFetchedSideCars = {blockRoot: blockRootHex, bytes: blobSideCarsBytes};
-    }
-
-    const blobSidecarBytes = lastFetchedSideCars.bytes.slice(
-      index * BLOBSIDECAR_FIXED_SIZE,
-      (index + 1) * BLOBSIDECAR_FIXED_SIZE
-    );
-    if (blobSidecarBytes.length !== BLOBSIDECAR_FIXED_SIZE) {
-      throw Error(
-        `Inconsistent state, blobSidecar blockRoot=${blockRootHex} index=${index} blobSidecarBytes=${blobSidecarBytes.length} expected=${BLOBSIDECAR_FIXED_SIZE}`
-      );
-    }
-
-    yield {
-      data: blobSidecarBytes,
-      boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
-    };
-  }
-}

package/src/network/reqresp/handlers/dataColumnSidecarsByRange.ts

@@ -1,144 +0,0 @@
-import {ChainConfig} from "@lodestar/config";
-import {GENESIS_SLOT} from "@lodestar/params";
-import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {ColumnIndex, fulu} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
-import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {
-  handleColumnSidecarUnavailability,
-  validateRequestedDataColumns,
-} from "../utils/dataColumnResponseValidation.js";
-
-export async function* onDataColumnSidecarsByRange(
-  request: fulu.DataColumnSidecarsByRangeRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
-): AsyncIterable<ResponseOutgoing> {
-  // Non-finalized range of columns
-  const {startSlot, count, columns: requestedColumns} = validateDataColumnSidecarsByRangeRequest(chain.config, request);
-  const availableColumns = validateRequestedDataColumns(chain, requestedColumns);
-  const endSlot = startSlot + count;
-
-  if (availableColumns.length === 0) {
-    return;
-  }
-
-  const finalized = db.dataColumnSidecarArchive;
-  const unfinalized = db.dataColumnSidecar;
-  const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
-
-  // Finalized range of columns
-  if (startSlot <= finalizedSlot) {
-    for (let slot = startSlot; slot < endSlot; slot++) {
-      const dataColumnSidecars = await finalized.getManyBinary(slot, availableColumns);
-
-      const unavailableColumnIndices: ColumnIndex[] = [];
-      for (let i = 0; i < dataColumnSidecars.length; i++) {
-        const dataColumnSidecarBytes = dataColumnSidecars[i];
-        if (dataColumnSidecarBytes) {
-          yield {
-            data: dataColumnSidecarBytes,
-            boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(slot)),
-          };
-        }
-
-        // TODO: Check blobs for that block and respond resource_unavailable
-        // After we have consensus from other teams on the specs
-        else {
-          unavailableColumnIndices.push(availableColumns[i]);
-        }
-      }
-
-      if (unavailableColumnIndices.length) {
-        await handleColumnSidecarUnavailability({
-          chain,
-          db,
-          metrics: chain.metrics,
-          unavailableColumnIndices,
-          slot,
-          requestedColumns,
-          availableColumns,
-        });
-      }
-    }
-  }
-
-  // Non-finalized range of columns
-  if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
-
-    // Iterate head chain with ascending block numbers
-    for (let i = headChain.length - 1; i >= 0; i--) {
-      const block = headChain[i];
-
-      // Must include only columns in the range requested
-      if (block.slot >= startSlot && block.slot < endSlot) {
-        // Note: Here the forkChoice head may change due to a re-org, so the headChain reflects the canonical chain
-        // at the time of the start of the request. Spec is clear the chain of columns must be consistent, but on
-        // re-org there's no need to abort the request
-        // Spec: https://github.com/ethereum/consensus-specs/blob/ad36024441cf910d428d03f87f331fbbd2b3e5f1/specs/fulu/p2p-interface.md#L425-L429
-        const dataColumnSidecars = await unfinalized.getManyBinary(fromHex(block.blockRoot), availableColumns);
-
-        const unavailableColumnIndices: ColumnIndex[] = [];
-        for (let i = 0; i < dataColumnSidecars.length; i++) {
-          const dataColumnSidecarBytes = dataColumnSidecars[i];
-          if (dataColumnSidecarBytes) {
-            yield {
-              data: dataColumnSidecarBytes,
-              boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
-            };
-          }
-
-          // TODO: Check blobs for that block and respond resource_unavailable
-          // After we have consensus from other teams on the specs
-          else {
-            unavailableColumnIndices.push(availableColumns[i]);
-          }
-        }
-
-        if (unavailableColumnIndices.length) {
-          await handleColumnSidecarUnavailability({
-            chain,
-            db,
-            metrics: chain.metrics,
-            unavailableColumnIndices,
-            blockRoot: fromHex(block.blockRoot),
-            slot: block.slot,
-            requestedColumns,
-            availableColumns,
-          });
-        }
-      }
-
-      // If block is after endSlot, stop iterating
-      else if (block.slot >= endSlot) {
-        break;
-      }
-    }
-  }
-}
-
-export function validateDataColumnSidecarsByRangeRequest(
-  config: ChainConfig,
-  request: fulu.DataColumnSidecarsByRangeRequest
-): fulu.DataColumnSidecarsByRangeRequest {
-  const {startSlot, columns} = request;
-  let {count} = request;
-
-  if (count < 1) {
-    throw new ResponseError(RespStatus.INVALID_REQUEST, "count < 1");
-  }
-  // TODO: validate against MIN_EPOCHS_FOR_BLOCK_REQUESTS
-  if (startSlot < GENESIS_SLOT) {
-    throw new ResponseError(RespStatus.INVALID_REQUEST, "startSlot < genesis");
-  }
-
-  if (count > config.MAX_REQUEST_BLOCKS_DENEB) {
-    count = config.MAX_REQUEST_BLOCKS_DENEB;
-  }
-
-  return {startSlot, count, columns};
-}

package/src/network/reqresp/handlers/dataColumnSidecarsByRoot.ts

@@ -1,88 +0,0 @@
-import {ResponseOutgoing} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {ColumnIndex} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
-import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {DataColumnSidecarsByRootRequest} from "../../../util/types.js";
-import {
-  handleColumnSidecarUnavailability,
-  validateRequestedDataColumns,
-} from "../utils/dataColumnResponseValidation.js";
-
-export async function* onDataColumnSidecarsByRoot(
-  requestBody: DataColumnSidecarsByRootRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
-): AsyncIterable<ResponseOutgoing> {
-  // SPEC: minimum_request_epoch = max(current_epoch - MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS, FULU_FORK_EPOCH)
-  const currentEpoch = chain.clock.currentEpoch;
-  const minimumRequestEpoch = Math.max(
-    currentEpoch - chain.config.MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS,
-    chain.config.FULU_FORK_EPOCH
-  );
-
-  for (const dataColumnsByRootIdentifier of requestBody) {
-    const {blockRoot, columns: requestedColumns} = dataColumnsByRootIdentifier;
-    const availableColumns = validateRequestedDataColumns(chain, requestedColumns);
-    if (availableColumns.length === 0) {
-      return;
-    }
-
-    const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
-    // If the block is not in fork choice, it may be finalized. Attempt to find its slot in block archive
-    const slot = block ? block.slot : await db.blockArchive.getSlotByRoot(blockRoot);
-
-    if (slot === null) {
-      // We haven't seen the block
-      continue;
-    }
-
-    const requestedEpoch = computeEpochAtSlot(slot);
-
-    // SPEC: Clients MUST support requesting sidecars since minimum_request_epoch.
-    // If any root in the request content references a block earlier than minimum_request_epoch, peers MAY respond with
-    // error code 3: ResourceUnavailable or not include the data column sidecar in the response.
-    // https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.5/specs/fulu/p2p-interface.md#datacolumnsidecarsbyroot-v1
-    if (requestedEpoch < minimumRequestEpoch) {
-      continue;
-    }
-
-    const dataColumns = block
-      ? // Non-finalized sidecars are stored by block root
-        await db.dataColumnSidecar.getManyBinary(blockRoot, availableColumns)
-      : // Finalized sidecars are archived and stored by slot
-        await db.dataColumnSidecarArchive.getManyBinary(slot, availableColumns);
-
-    const unavailableColumnIndices: ColumnIndex[] = [];
-    for (let i = 0; i < dataColumns.length; i++) {
-      const dataColumnBytes = dataColumns[i];
-      if (dataColumnBytes) {
-        yield {
-          data: dataColumnBytes,
-          boundary: chain.config.getForkBoundaryAtEpoch(requestedEpoch),
-        };
-      }
-
-      // TODO: Check blobs for that block and respond resource_unavailable
-      // After we have consensus from other teams on the specs
-      else {
-        unavailableColumnIndices.push(availableColumns[i]);
-      }
-    }
-
-    if (unavailableColumnIndices.length) {
-      await handleColumnSidecarUnavailability({
-        chain,
-        db,
-        metrics: chain.metrics,
-        slot,
-        blockRoot,
-        unavailableColumnIndices,
-        requestedColumns,
-        availableColumns,
-      });
-    }
-  }
-}

package/src/network/reqresp/handlers/index.ts

@@ -1,78 +0,0 @@
-import {ProtocolHandler} from "@lodestar/reqresp";
-import {ssz} from "@lodestar/types";
-import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {
-  BeaconBlocksByRootRequestType,
-  BlobSidecarsByRootRequestType,
-  DataColumnSidecarsByRootRequestType,
-} from "../../../util/types.js";
-import {GetReqRespHandlerFn, ReqRespMethod} from "../types.js";
-import {onBeaconBlocksByRange} from "./beaconBlocksByRange.js";
-import {onBeaconBlocksByRoot} from "./beaconBlocksByRoot.js";
-import {onBlobSidecarsByRange} from "./blobSidecarsByRange.js";
-import {onBlobSidecarsByRoot} from "./blobSidecarsByRoot.js";
-import {onDataColumnSidecarsByRange} from "./dataColumnSidecarsByRange.js";
-import {onDataColumnSidecarsByRoot} from "./dataColumnSidecarsByRoot.js";
-import {onLightClientBootstrap} from "./lightClientBootstrap.js";
-import {onLightClientFinalityUpdate} from "./lightClientFinalityUpdate.js";
-import {onLightClientOptimisticUpdate} from "./lightClientOptimisticUpdate.js";
-import {onLightClientUpdatesByRange} from "./lightClientUpdatesByRange.js";
-
-function notImplemented(method: ReqRespMethod): ProtocolHandler {
-  return () => {
-    throw Error(`Handler not implemented for ${method}`);
-  };
-}
-
-/**
- * The ReqRespHandler module handles app-level requests / responses from other peers,
- * fetching state from the chain and database as needed.
- */
-export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconChain}): GetReqRespHandlerFn {
-  const handlers: Record<ReqRespMethod, ProtocolHandler> = {
-    [ReqRespMethod.Status]: notImplemented(ReqRespMethod.Status),
-    [ReqRespMethod.Goodbye]: notImplemented(ReqRespMethod.Goodbye),
-    [ReqRespMethod.Ping]: notImplemented(ReqRespMethod.Ping),
-    [ReqRespMethod.Metadata]: notImplemented(ReqRespMethod.Metadata),
-    [ReqRespMethod.BeaconBlocksByRange]: (req) => {
-      const body = ssz.phase0.BeaconBlocksByRangeRequest.deserialize(req.data);
-      return onBeaconBlocksByRange(body, chain, db);
-    },
-    [ReqRespMethod.BeaconBlocksByRoot]: (req) => {
-      const fork = chain.config.getForkName(chain.clock.currentSlot);
-      const body = BeaconBlocksByRootRequestType(fork, chain.config).deserialize(req.data);
-      return onBeaconBlocksByRoot(body, chain, db);
-    },
-    [ReqRespMethod.BlobSidecarsByRoot]: (req) => {
-      const fork = chain.config.getForkName(chain.clock.currentSlot);
-      const body = BlobSidecarsByRootRequestType(fork, chain.config).deserialize(req.data);
-      return onBlobSidecarsByRoot(body, chain, db);
-    },
-    [ReqRespMethod.BlobSidecarsByRange]: (req) => {
-      const body = ssz.deneb.BlobSidecarsByRangeRequest.deserialize(req.data);
-      return onBlobSidecarsByRange(body, chain, db);
-    },
-    [ReqRespMethod.DataColumnSidecarsByRange]: (req) => {
-      const body = ssz.fulu.DataColumnSidecarsByRangeRequest.deserialize(req.data);
-      return onDataColumnSidecarsByRange(body, chain, db);
-    },
-    [ReqRespMethod.DataColumnSidecarsByRoot]: (req) => {
-      const body = DataColumnSidecarsByRootRequestType(chain.config).deserialize(req.data);
-      return onDataColumnSidecarsByRoot(body, chain, db);
-    },
-
-    [ReqRespMethod.LightClientBootstrap]: (req) => {
-      const body = ssz.Root.deserialize(req.data);
-      return onLightClientBootstrap(body, chain);
-    },
-    [ReqRespMethod.LightClientUpdatesByRange]: (req) => {
-      const body = ssz.altair.LightClientUpdatesByRange.deserialize(req.data);
-      return onLightClientUpdatesByRange(body, chain);
-    },
-    [ReqRespMethod.LightClientFinalityUpdate]: () => onLightClientFinalityUpdate(chain),
-    [ReqRespMethod.LightClientOptimisticUpdate]: () => onLightClientOptimisticUpdate(chain),
-  };
-
-  return (method) => handlers[method];
-}

package/src/network/reqresp/handlers/lightClientBootstrap.ts

@@ -1,31 +0,0 @@
-import {
-  LightClientServerError,
-  LightClientServerErrorCode,
-  RespStatus,
-  ResponseError,
-  ResponseOutgoing,
-} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {Root} from "@lodestar/types";
-import {IBeaconChain} from "../../../chain/index.js";
-import {assertLightClientServer} from "../../../node/utils/lightclient.js";
-import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
-
-export async function* onLightClientBootstrap(requestBody: Root, chain: IBeaconChain): AsyncIterable<ResponseOutgoing> {
-  assertLightClientServer(chain.lightClientServer);
-
-  try {
-    const bootstrap = await chain.lightClientServer.getBootstrap(requestBody);
-    const boundary = chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(bootstrap.header.beacon.slot));
-    const type = responseSszTypeByMethod[ReqRespMethod.LightClientBootstrap](boundary.fork, 0);
-    yield {
-      data: type.serialize(bootstrap),
-      boundary,
-    };
-  } catch (e) {
-    if ((e as LightClientServerError).type?.code === LightClientServerErrorCode.RESOURCE_UNAVAILABLE) {
-      throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, (e as Error).message);
-    }
-    throw new ResponseError(RespStatus.SERVER_ERROR, (e as Error).message);
-  }
-}

package/src/network/reqresp/handlers/lightClientFinalityUpdate.ts

@@ -1,21 +0,0 @@
-import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {IBeaconChain} from "../../../chain/index.js";
-import {assertLightClientServer} from "../../../node/utils/lightclient.js";
-import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
-
-export async function* onLightClientFinalityUpdate(chain: IBeaconChain): AsyncIterable<ResponseOutgoing> {
-  assertLightClientServer(chain.lightClientServer);
-
-  const update = chain.lightClientServer.getFinalityUpdate();
-  if (update === null) {
-    throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, "No latest finality update available");
-  }
-
-  const boundary = chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(update.signatureSlot));
-  const type = responseSszTypeByMethod[ReqRespMethod.LightClientFinalityUpdate](boundary.fork, 0);
-  yield {
-    data: type.serialize(update),
-    boundary,
-  };
-}

package/src/network/reqresp/handlers/lightClientOptimisticUpdate.ts

@@ -1,21 +0,0 @@
-import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {IBeaconChain} from "../../../chain/index.js";
-import {assertLightClientServer} from "../../../node/utils/lightclient.js";
-import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
-
-export async function* onLightClientOptimisticUpdate(chain: IBeaconChain): AsyncIterable<ResponseOutgoing> {
-  assertLightClientServer(chain.lightClientServer);
-
-  const update = chain.lightClientServer.getOptimisticUpdate();
-  if (update === null) {
-    throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, "No latest optimistic update available");
-  }
-
-  const boundary = chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(update.signatureSlot));
-  const type = responseSszTypeByMethod[ReqRespMethod.LightClientOptimisticUpdate](boundary.fork, 0);
-  yield {
-    data: type.serialize(update),
-    boundary,
-  };
-}

package/src/network/reqresp/handlers/lightClientUpdatesByRange.ts

@@ -1,39 +0,0 @@
-import {MAX_REQUEST_LIGHT_CLIENT_UPDATES} from "@lodestar/params";
-import {
-  LightClientServerError,
-  LightClientServerErrorCode,
-  RespStatus,
-  ResponseError,
-  ResponseOutgoing,
-} from "@lodestar/reqresp";
-import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {altair} from "@lodestar/types";
-import {IBeaconChain} from "../../../chain/index.js";
-import {assertLightClientServer} from "../../../node/utils/lightclient.js";
-import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
-
-export async function* onLightClientUpdatesByRange(
-  requestBody: altair.LightClientUpdatesByRange,
-  chain: IBeaconChain
-): AsyncIterable<ResponseOutgoing> {
-  assertLightClientServer(chain.lightClientServer);
-
-  const count = Math.min(MAX_REQUEST_LIGHT_CLIENT_UPDATES, requestBody.count);
-  for (let period = requestBody.startPeriod; period < requestBody.startPeriod + count; period++) {
-    try {
-      const update = await chain.lightClientServer.getUpdate(period);
-      const boundary = chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(update.signatureSlot));
-      const type = responseSszTypeByMethod[ReqRespMethod.LightClientUpdatesByRange](boundary.fork, 0);
-
-      yield {
-        data: type.serialize(update),
-        boundary,
-      };
-    } catch (e) {
-      if ((e as LightClientServerError).type?.code === LightClientServerErrorCode.RESOURCE_UNAVAILABLE) {
-        throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, (e as Error).message);
-      }
-      throw new ResponseError(RespStatus.SERVER_ERROR, (e as Error).message);
-    }
-  }
-}

package/src/network/reqresp/index.ts

@@ -1,2 +0,0 @@
-export * from "./interface.js";
-export * from "./ReqRespBeaconNode.js";

package/src/network/reqresp/interface.ts

@@ -1,45 +0,0 @@
-import {PeerId} from "@libp2p/interface";
-
-/**
- * Rate limiter interface for inbound and outbound requests.
- */
-export interface RateLimiter {
-  /** Allow to request or response based on rate limit params configured. */
-  allowRequest(peerId: PeerId): boolean;
-  /** Rate limit check for block count */
-  allowBlockByRequest(peerId: PeerId, numBlock: number): boolean;
-
-  /**
-   * Prune by peer id
-   */
-  prune(peerId: PeerId): void;
-  start(): void;
-  stop(): void;
-}
-
-//  Request/Response constants
-export enum RespStatus {
-  /**
-   * A normal response follows, with contents matching the expected message schema and encoding specified in the request
-   */
-  SUCCESS = 0,
-  /**
-   * The contents of the request are semantically invalid, or the payload is malformed,
-   * or could not be understood. The response payload adheres to the ErrorMessage schema
-   */
-  INVALID_REQUEST = 1,
-  /**
-   * The responder encountered an error while processing the request. The response payload adheres to the ErrorMessage schema
-   */
-  SERVER_ERROR = 2,
-  /**
-   * The responder does not have requested resource.  The response payload adheres to the ErrorMessage schema (described below). Note: This response code is only valid as a response to BlocksByRange
-   */
-  RESOURCE_UNAVAILABLE = 3,
-  /**
-   * Our node does not have bandwidth to serve requests due to either per-peer quota or total quota.
-   */
-  RATE_LIMITED = 139,
-}
-
-export type RpcResponseStatusError = Exclude<RespStatus, RespStatus.SUCCESS>;

package/src/network/reqresp/protocols.ts

@@ -1,146 +0,0 @@
-import {BeaconConfig} from "@lodestar/config";
-import {ForkName} from "@lodestar/params";
-import {ContextBytesFactory, ContextBytesType, Encoding} from "@lodestar/reqresp";
-import {rateLimitQuotas} from "./rateLimit.js";
-import {ProtocolNoHandler, ReqRespMethod, Version, requestSszTypeByMethod, responseSszTypeByMethod} from "./types.js";
-
-export const Goodbye = toProtocol({
-  method: ReqRespMethod.Goodbye,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const Metadata = toProtocol({
-  method: ReqRespMethod.Metadata,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const MetadataV2 = toProtocol({
-  method: ReqRespMethod.Metadata,
-  version: Version.V2,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const MetadataV3 = toProtocol({
-  method: ReqRespMethod.Metadata,
-  version: Version.V3,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const Ping = toProtocol({
-  method: ReqRespMethod.Ping,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const Status = toProtocol({
-  method: ReqRespMethod.Status,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const StatusV2 = toProtocol({
-  method: ReqRespMethod.Status,
-  version: Version.V2,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const BeaconBlocksByRange = toProtocol({
-  method: ReqRespMethod.BeaconBlocksByRange,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const BeaconBlocksByRangeV2 = toProtocol({
-  method: ReqRespMethod.BeaconBlocksByRange,
-  version: Version.V2,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const BeaconBlocksByRoot = toProtocol({
-  method: ReqRespMethod.BeaconBlocksByRoot,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.Empty,
-});
-
-export const BeaconBlocksByRootV2 = toProtocol({
-  method: ReqRespMethod.BeaconBlocksByRoot,
-  version: Version.V2,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const BlobSidecarsByRange = toProtocol({
-  method: ReqRespMethod.BlobSidecarsByRange,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const BlobSidecarsByRoot = toProtocol({
-  method: ReqRespMethod.BlobSidecarsByRoot,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const DataColumnSidecarsByRange = toProtocol({
-  method: ReqRespMethod.DataColumnSidecarsByRange,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const DataColumnSidecarsByRoot = toProtocol({
-  method: ReqRespMethod.DataColumnSidecarsByRoot,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const LightClientBootstrap = toProtocol({
-  method: ReqRespMethod.LightClientBootstrap,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const LightClientFinalityUpdate = toProtocol({
-  method: ReqRespMethod.LightClientFinalityUpdate,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const LightClientOptimisticUpdate = toProtocol({
-  method: ReqRespMethod.LightClientOptimisticUpdate,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const LightClientUpdatesByRange = toProtocol({
-  method: ReqRespMethod.LightClientUpdatesByRange,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-type ProtocolSummary = {
-  method: ReqRespMethod;
-  version: Version;
-  contextBytesType: ContextBytesType;
-};
-
-function toProtocol(protocol: ProtocolSummary) {
-  return (fork: ForkName, config: BeaconConfig): ProtocolNoHandler => ({
-    method: protocol.method,
-    version: protocol.version,
-    encoding: Encoding.SSZ_SNAPPY,
-    contextBytes: toContextBytes(protocol.contextBytesType, config),
-    inboundRateLimits: rateLimitQuotas(fork, config)[protocol.method],
-    requestSizes: requestSszTypeByMethod(fork, config)[protocol.method],
-    responseSizes: (fork) => responseSszTypeByMethod[protocol.method](fork, protocol.version),
-  });
-}
-
-function toContextBytes(type: ContextBytesType, config: BeaconConfig): ContextBytesFactory {
-  switch (type) {
-    case ContextBytesType.Empty:
-      return {type: ContextBytesType.Empty};
-    case ContextBytesType.ForkDigest:
-      return {type: ContextBytesType.ForkDigest, config};
-  }
-}