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

package/src/network/reqresp/rateLimit.ts

@@ -1,112 +0,0 @@
-import {BeaconConfig} from "@lodestar/config";
-import {ForkName, MAX_REQUEST_LIGHT_CLIENT_UPDATES, isForkPostDeneb, isForkPostElectra} from "@lodestar/params";
-import {InboundRateLimitQuota} from "@lodestar/reqresp";
-import {ReqRespMethod, RequestBodyByMethod, requestSszTypeByMethod} from "./types.js";
-
-export const rateLimitQuotas: (fork: ForkName, config: BeaconConfig) => Record<ReqRespMethod, InboundRateLimitQuota> = (
-  fork,
-  config
-) => ({
-  [ReqRespMethod.Status]: {
-    // Rationale: https://github.com/sigp/lighthouse/blob/bf533c8e42cc73c35730e285c21df8add0195369/beacon_node/lighthouse_network/src/rpc/mod.rs#L118-L130
-    byPeer: {quota: 5, quotaTimeMs: 15_000},
-  },
-  [ReqRespMethod.Goodbye]: {
-    // Rationale: https://github.com/sigp/lighthouse/blob/bf533c8e42cc73c35730e285c21df8add0195369/beacon_node/lighthouse_network/src/rpc/mod.rs#L118-L130
-    byPeer: {quota: 1, quotaTimeMs: 10_000},
-  },
-  [ReqRespMethod.Ping]: {
-    // Rationale: https://github.com/sigp/lighthouse/blob/bf533c8e42cc73c35730e285c21df8add0195369/beacon_node/lighthouse_network/src/rpc/mod.rs#L118-L130
-    byPeer: {quota: 2, quotaTimeMs: 10_000},
-  },
-  [ReqRespMethod.Metadata]: {
-    // Rationale: https://github.com/sigp/lighthouse/blob/bf533c8e42cc73c35730e285c21df8add0195369/beacon_node/lighthouse_network/src/rpc/mod.rs#L118-L130
-    byPeer: {quota: 2, quotaTimeMs: 5_000},
-  },
-  // Do not matter
-  [ReqRespMethod.BeaconBlocksByRange]: {
-    // Rationale: https://github.com/sigp/lighthouse/blob/bf533c8e42cc73c35730e285c21df8add0195369/beacon_node/lighthouse_network/src/rpc/mod.rs#L118-L130
-    byPeer: {
-      quota: isForkPostDeneb(fork) ? config.MAX_REQUEST_BLOCKS_DENEB : config.MAX_REQUEST_BLOCKS,
-      quotaTimeMs: 10_000,
-    },
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BeaconBlocksByRange, (req) => req.count),
-  },
-  [ReqRespMethod.BeaconBlocksByRoot]: {
-    // Rationale: https://github.com/sigp/lighthouse/blob/bf533c8e42cc73c35730e285c21df8add0195369/beacon_node/lighthouse_network/src/rpc/mod.rs#L118-L130
-    byPeer: {
-      quota: isForkPostDeneb(fork) ? config.MAX_REQUEST_BLOCKS_DENEB : config.MAX_REQUEST_BLOCKS,
-      quotaTimeMs: 10_000,
-    },
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BeaconBlocksByRoot, (req) => req.length),
-  },
-  [ReqRespMethod.BlobSidecarsByRange]: {
-    // Rationale: MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK
-    byPeer: {
-      quota: isForkPostElectra(fork) ? config.MAX_REQUEST_BLOB_SIDECARS_ELECTRA : config.MAX_REQUEST_BLOB_SIDECARS,
-      quotaTimeMs: 10_000,
-    },
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BlobSidecarsByRange, (req) => req.count),
-  },
-  [ReqRespMethod.BlobSidecarsByRoot]: {
-    // Rationale: quota of BeaconBlocksByRoot * MAX_BLOBS_PER_BLOCK
-    byPeer: {
-      quota: isForkPostElectra(fork) ? config.MAX_REQUEST_BLOB_SIDECARS_ELECTRA : config.MAX_REQUEST_BLOB_SIDECARS,
-      quotaTimeMs: 10_000,
-    },
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BlobSidecarsByRoot, (req) => req.length),
-  },
-  [ReqRespMethod.DataColumnSidecarsByRange]: {
-    // Rationale: MAX_REQUEST_BLOCKS_DENEB * NUMBER_OF_COLUMNS
-    byPeer: {quota: config.MAX_REQUEST_DATA_COLUMN_SIDECARS, quotaTimeMs: 10_000},
-    getRequestCount: getRequestCountFn(
-      fork,
-      config,
-      ReqRespMethod.DataColumnSidecarsByRange,
-      (req) => req.count * req.columns.length
-    ),
-  },
-  [ReqRespMethod.DataColumnSidecarsByRoot]: {
-    // Rationale: quota of BeaconBlocksByRoot * NUMBER_OF_COLUMNS
-    byPeer: {quota: config.MAX_REQUEST_DATA_COLUMN_SIDECARS, quotaTimeMs: 10_000},
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.DataColumnSidecarsByRoot, (req) =>
-      req.reduce((total, item) => total + item.columns.length, 0)
-    ),
-  },
-  [ReqRespMethod.LightClientBootstrap]: {
-    // As similar in the nature of `Status` protocol so we use the same rate limits.
-    byPeer: {quota: 5, quotaTimeMs: 15_000},
-  },
-  [ReqRespMethod.LightClientUpdatesByRange]: {
-    // Same rationale as for BeaconBlocksByRange
-    byPeer: {quota: MAX_REQUEST_LIGHT_CLIENT_UPDATES, quotaTimeMs: 10_000},
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.LightClientUpdatesByRange, (req) => req.count),
-  },
-  [ReqRespMethod.LightClientFinalityUpdate]: {
-    // Finality updates should not be requested more than once per epoch.
-    // Allow 2 per slot and a very safe bound until there's more testing of real usage.
-    byPeer: {quota: 2, quotaTimeMs: 12_000},
-  },
-  [ReqRespMethod.LightClientOptimisticUpdate]: {
-    // Optimistic updates should not be requested more than once per slot.
-    // Allow 2 per slot and a very safe bound until there's more testing of real usage.
-    byPeer: {quota: 2, quotaTimeMs: 12_000},
-  },
-});
-
-// Helper to produce a getRequestCount function
-function getRequestCountFn<T extends ReqRespMethod>(
-  fork: ForkName,
-  config: BeaconConfig,
-  method: T,
-  fn: (req: RequestBodyByMethod[T]) => number
-): (reqData: Uint8Array) => number {
-  const type = requestSszTypeByMethod(fork, config)[method];
-  return (reqData: Uint8Array) => {
-    try {
-      return (type && fn(type.deserialize(reqData))) ?? 1;
-    } catch (_e) {
-      return 1;
-    }
-  };
-}

package/src/network/reqresp/score.ts

@@ -1,70 +0,0 @@
-import {RequestError, RequestErrorCode} from "@lodestar/reqresp";
-import {PeerAction} from "../peers/score/index.js";
-import {ReqRespMethod} from "./types.js";
-
-/**
- * libp2p-ts does not include types for the error codes.
- * When libp2p has native types, this object won't be necessary.
- * https://github.com/libp2p/js-libp2p/blob/6350a187c7c207086e42436ccbcabd59af6f5e3d/src/errors.js#L32
- */
-const libp2pErrorCodes = {
-  ERR_UNSUPPORTED_PROTOCOL: "ERR_UNSUPPORTED_PROTOCOL",
-};
-
-/**
- * Multi stream select error code
- * https://github.com/multiformats/js-multistream-select/blame/cf4e297b362a43bde2ea117085ceba78cbce1c12/src/select.js#L50
- */
-const multiStreamSelectErrorCodes = {
-  protocolSelectionFailed: "protocol selection failed",
-};
-
-export function onOutgoingReqRespError(e: RequestError, method: ReqRespMethod): PeerAction | null {
-  switch (e.type.code) {
-    case RequestErrorCode.INVALID_REQUEST:
-    case RequestErrorCode.INVALID_RESPONSE_SSZ:
-    case RequestErrorCode.SSZ_OVER_MAX_SIZE:
-      return PeerAction.LowToleranceError;
-
-    case RequestErrorCode.SERVER_ERROR:
-      return PeerAction.MidToleranceError;
-    case RequestErrorCode.UNKNOWN_ERROR_STATUS:
-      return PeerAction.HighToleranceError;
-
-    case RequestErrorCode.DIAL_TIMEOUT:
-    case RequestErrorCode.DIAL_ERROR:
-      return e.message.includes(multiStreamSelectErrorCodes.protocolSelectionFailed) && method === ReqRespMethod.Ping
-        ? PeerAction.Fatal
-        : PeerAction.LowToleranceError;
-    // TODO: Detect SSZDecodeError and return PeerAction.Fatal
-
-    case RequestErrorCode.TTFB_TIMEOUT:
-    case RequestErrorCode.RESP_TIMEOUT:
-      switch (method) {
-        case ReqRespMethod.Ping:
-        case ReqRespMethod.Status:
-        case ReqRespMethod.Metadata:
-          return PeerAction.LowToleranceError;
-        case ReqRespMethod.BeaconBlocksByRange:
-        case ReqRespMethod.BeaconBlocksByRoot:
-          return PeerAction.MidToleranceError;
-        default:
-          return null;
-      }
-  }
-
-  if (e.message.includes(libp2pErrorCodes.ERR_UNSUPPORTED_PROTOCOL)) {
-    switch (method) {
-      case ReqRespMethod.Ping:
-        return PeerAction.Fatal;
-      case ReqRespMethod.Metadata:
-      case ReqRespMethod.Status:
-        return PeerAction.LowToleranceError;
-      default:
-        return null;
-    }
-  }
-
-  // other errors like RequestErrorCode.RESP_RATE_LIMITED could come from ourself, not the peer so we should not penalize them
-  return null;
-}

package/src/network/reqresp/types.ts

@@ -1,174 +0,0 @@
-import {Type} from "@chainsafe/ssz";
-import {BeaconConfig} from "@lodestar/config";
-import {ForkName, ForkPostAltair, isForkPostAltair} from "@lodestar/params";
-import {Protocol, ProtocolHandler, ReqRespRequest} from "@lodestar/reqresp";
-import {
-  LightClientBootstrap,
-  LightClientFinalityUpdate,
-  LightClientOptimisticUpdate,
-  LightClientUpdate,
-  Metadata,
-  Root,
-  SignedBeaconBlock,
-  Status,
-  altair,
-  deneb,
-  fulu,
-  phase0,
-  ssz,
-  sszTypesFor,
-} from "@lodestar/types";
-import {
-  BeaconBlocksByRootRequest,
-  BeaconBlocksByRootRequestType,
-  BlobSidecarsByRootRequest,
-  BlobSidecarsByRootRequestType,
-  DataColumnSidecarsByRootRequest,
-  DataColumnSidecarsByRootRequestType,
-} from "../../util/types.js";
-
-export type ProtocolNoHandler = Omit<Protocol, "handler">;
-
-/** ReqResp protocol names or methods. Each ReqRespMethod can have multiple versions and encodings */
-export enum ReqRespMethod {
-  // Phase 0
-  Status = "status",
-  Goodbye = "goodbye",
-  Ping = "ping",
-  Metadata = "metadata",
-  BeaconBlocksByRange = "beacon_blocks_by_range",
-  BeaconBlocksByRoot = "beacon_blocks_by_root",
-  BlobSidecarsByRange = "blob_sidecars_by_range",
-  BlobSidecarsByRoot = "blob_sidecars_by_root",
-  DataColumnSidecarsByRange = "data_column_sidecars_by_range",
-  DataColumnSidecarsByRoot = "data_column_sidecars_by_root",
-  LightClientBootstrap = "light_client_bootstrap",
-  LightClientUpdatesByRange = "light_client_updates_by_range",
-  LightClientFinalityUpdate = "light_client_finality_update",
-  LightClientOptimisticUpdate = "light_client_optimistic_update",
-}
-
-// To typesafe events to network
-export type RequestBodyByMethod = {
-  [ReqRespMethod.Status]: Status;
-  [ReqRespMethod.Goodbye]: phase0.Goodbye;
-  [ReqRespMethod.Ping]: phase0.Ping;
-  [ReqRespMethod.Metadata]: null;
-  [ReqRespMethod.BeaconBlocksByRange]: phase0.BeaconBlocksByRangeRequest;
-  [ReqRespMethod.BeaconBlocksByRoot]: BeaconBlocksByRootRequest;
-  [ReqRespMethod.BlobSidecarsByRange]: deneb.BlobSidecarsByRangeRequest;
-  [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequest;
-  [ReqRespMethod.DataColumnSidecarsByRange]: fulu.DataColumnSidecarsByRangeRequest;
-  [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecarsByRootRequest;
-  [ReqRespMethod.LightClientBootstrap]: Root;
-  [ReqRespMethod.LightClientUpdatesByRange]: altair.LightClientUpdatesByRange;
-  [ReqRespMethod.LightClientFinalityUpdate]: null;
-  [ReqRespMethod.LightClientOptimisticUpdate]: null;
-};
-
-type ResponseBodyByMethod = {
-  [ReqRespMethod.Status]: Status;
-  [ReqRespMethod.Goodbye]: phase0.Goodbye;
-  [ReqRespMethod.Ping]: phase0.Ping;
-  [ReqRespMethod.Metadata]: Metadata;
-  // Do not matter
-  [ReqRespMethod.BeaconBlocksByRange]: SignedBeaconBlock;
-  [ReqRespMethod.BeaconBlocksByRoot]: SignedBeaconBlock;
-  [ReqRespMethod.BlobSidecarsByRange]: deneb.BlobSidecar;
-  [ReqRespMethod.BlobSidecarsByRoot]: deneb.BlobSidecar;
-  [ReqRespMethod.DataColumnSidecarsByRange]: fulu.DataColumnSidecar;
-  [ReqRespMethod.DataColumnSidecarsByRoot]: fulu.DataColumnSidecar;
-
-  [ReqRespMethod.LightClientBootstrap]: LightClientBootstrap;
-  [ReqRespMethod.LightClientUpdatesByRange]: LightClientUpdate;
-  [ReqRespMethod.LightClientFinalityUpdate]: LightClientFinalityUpdate;
-  [ReqRespMethod.LightClientOptimisticUpdate]: LightClientOptimisticUpdate;
-};
-
-/** Request SSZ type for each method and ForkName */
-export const requestSszTypeByMethod: (
-  fork: ForkName,
-  config: BeaconConfig
-) => {
-  [K in ReqRespMethod]: RequestBodyByMethod[K] extends null ? null : Type<RequestBodyByMethod[K]>;
-} = (fork, config) => ({
-  // Status type should ideally be determined by protocol version and not fork but since
-  // we only start using the new status version after the fork this is not an issue
-  [ReqRespMethod.Status]: sszTypesFor(fork).Status,
-  [ReqRespMethod.Goodbye]: ssz.phase0.Goodbye,
-  [ReqRespMethod.Ping]: ssz.phase0.Ping,
-  [ReqRespMethod.Metadata]: null,
-
-  [ReqRespMethod.BeaconBlocksByRange]: ssz.phase0.BeaconBlocksByRangeRequest,
-  [ReqRespMethod.BeaconBlocksByRoot]: BeaconBlocksByRootRequestType(fork, config),
-  [ReqRespMethod.BlobSidecarsByRange]: ssz.deneb.BlobSidecarsByRangeRequest,
-  [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequestType(fork, config),
-  [ReqRespMethod.DataColumnSidecarsByRange]: ssz.fulu.DataColumnSidecarsByRangeRequest,
-  [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecarsByRootRequestType(config),
-
-  [ReqRespMethod.LightClientBootstrap]: ssz.Root,
-  [ReqRespMethod.LightClientUpdatesByRange]: ssz.altair.LightClientUpdatesByRange,
-  [ReqRespMethod.LightClientFinalityUpdate]: null,
-  [ReqRespMethod.LightClientOptimisticUpdate]: null,
-});
-
-export type ResponseTypeGetter<T> = (fork: ForkName, version: number) => Type<T>;
-
-const blocksResponseType: ResponseTypeGetter<SignedBeaconBlock> = (fork, version) => {
-  if (version === Version.V1) {
-    return ssz.phase0.SignedBeaconBlock;
-  }
-
-  return ssz[fork].SignedBeaconBlock;
-};
-
-export const responseSszTypeByMethod: {[K in ReqRespMethod]: ResponseTypeGetter<ResponseBodyByMethod[K]>} = {
-  [ReqRespMethod.Status]: (_, version) => (version === Version.V2 ? ssz.fulu.Status : ssz.phase0.Status),
-  [ReqRespMethod.Goodbye]: () => ssz.phase0.Goodbye,
-  [ReqRespMethod.Ping]: () => ssz.phase0.Ping,
-  [ReqRespMethod.Metadata]: (_, version) =>
-    version === Version.V1 ? ssz.phase0.Metadata : version === Version.V2 ? ssz.altair.Metadata : ssz.fulu.Metadata,
-  [ReqRespMethod.BeaconBlocksByRange]: blocksResponseType,
-  [ReqRespMethod.BeaconBlocksByRoot]: blocksResponseType,
-  [ReqRespMethod.BlobSidecarsByRange]: () => ssz.deneb.BlobSidecar,
-  [ReqRespMethod.BlobSidecarsByRoot]: () => ssz.deneb.BlobSidecar,
-  [ReqRespMethod.LightClientBootstrap]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientBootstrap,
-  [ReqRespMethod.LightClientUpdatesByRange]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientUpdate,
-  [ReqRespMethod.LightClientFinalityUpdate]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientFinalityUpdate,
-  [ReqRespMethod.DataColumnSidecarsByRange]: () => ssz.fulu.DataColumnSidecar,
-  [ReqRespMethod.DataColumnSidecarsByRoot]: () => ssz.fulu.DataColumnSidecar,
-  [ReqRespMethod.LightClientOptimisticUpdate]: (fork) =>
-    sszTypesFor(onlyPostAltairFork(fork)).LightClientOptimisticUpdate,
-};
-
-function onlyPostAltairFork(fork: ForkName): ForkPostAltair {
-  if (isForkPostAltair(fork)) {
-    return fork;
-  }
-  throw Error(`Not a post-altair fork ${fork}`);
-}
-
-export type RequestTypedContainer = {
-  [K in ReqRespMethod]: {method: K; body: RequestBodyByMethod[K]};
-}[ReqRespMethod];
-
-export enum Version {
-  V1 = 1,
-  V2 = 2,
-  V3 = 3,
-}
-
-export type OutgoingRequestArgs = {
-  peerId: string;
-  method: ReqRespMethod;
-  versions: number[];
-  requestData: Uint8Array;
-};
-
-export type IncomingRequestArgs = {
-  method: ReqRespMethod;
-  req: ReqRespRequest;
-  peerId: string;
-};
-
-export type GetReqRespHandlerFn = (method: ReqRespMethod) => ProtocolHandler;

package/src/network/reqresp/utils/collect.ts

@@ -1,84 +0,0 @@
-import {Type} from "@chainsafe/ssz";
-import {RequestError, RequestErrorCode, ResponseIncoming} from "@lodestar/reqresp";
-import {WithBytes} from "@lodestar/types";
-import {ResponseTypeGetter} from "../types.js";
-
-/**
- * Sink for `<response_chunk>*`, from
- * ```bnf
- * response ::= <response_chunk>*
- * ```
- * Expects exactly one response
- */
-export async function collectExactOneTyped<T>(
-  source: AsyncIterable<ResponseIncoming>,
-  typeFn: ResponseTypeGetter<T>
-): Promise<T> {
-  for await (const chunk of source) {
-    const type = typeFn(chunk.fork, chunk.protocolVersion);
-    const response = sszDeserializeResponse(type, chunk.data);
-    return response;
-  }
-  throw new RequestError({code: RequestErrorCode.EMPTY_RESPONSE});
-}
-
-/**
- * Sink for `<response_chunk>*`, from
- * ```bnf
- * response ::= <response_chunk>*
- * ```
- * Collects a bounded list of responses up to `maxResponses`
- */
-export async function collectMaxResponseTyped<T>(
-  source: AsyncIterable<ResponseIncoming>,
-  maxResponses: number,
-  typeFn: ResponseTypeGetter<T>
-): Promise<T[]> {
-  // else: zero or more responses
-  const responses: T[] = [];
-  for await (const chunk of source) {
-    const type = typeFn(chunk.fork, chunk.protocolVersion);
-    const response = sszDeserializeResponse(type, chunk.data);
-    responses.push(response);
-
-    if (maxResponses !== undefined && responses.length >= maxResponses) {
-      break;
-    }
-  }
-  return responses;
-}
-
-/**
- * Sink for `<response_chunk>*`, from
- * ```bnf
- * response ::= <response_chunk>*
- * ```
- * Collects a bounded list of responses up to `maxResponses`
- */
-export async function collectMaxResponseTypedWithBytes<T>(
-  source: AsyncIterable<ResponseIncoming>,
-  maxResponses: number,
-  typeFn: ResponseTypeGetter<T>
-): Promise<WithBytes<T>[]> {
-  // else: zero or more responses
-  const responses: WithBytes<T>[] = [];
-  for await (const chunk of source) {
-    const type = typeFn(chunk.fork, chunk.protocolVersion);
-    const data = sszDeserializeResponse(type, chunk.data);
-    responses.push({data, bytes: chunk.data});
-
-    if (maxResponses !== undefined && responses.length >= maxResponses) {
-      break;
-    }
-  }
-  return responses;
-}
-
-/** Light wrapper on type to wrap deserialize errors */
-export function sszDeserializeResponse<T>(type: Type<T>, bytes: Uint8Array): T {
-  try {
-    return type.deserialize(bytes);
-  } catch (e) {
-    throw new RequestError({code: RequestErrorCode.INVALID_RESPONSE_SSZ, errorMessage: (e as Error).message});
-  }
-}

package/src/network/reqresp/utils/collectSequentialBlocksInRange.ts

@@ -1,57 +0,0 @@
-import {ResponseIncoming} from "@lodestar/reqresp";
-import {SignedBeaconBlock, WithBytes, phase0} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
-import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
-import {sszDeserializeResponse} from "./collect.js";
-
-/**
- * Asserts a response from BeaconBlocksByRange respects the request and is sequential
- * Note: MUST allow missing block for skipped slots.
- */
-export async function collectSequentialBlocksInRange(
-  blockStream: AsyncIterable<ResponseIncoming>,
-  {count, startSlot}: Pick<phase0.BeaconBlocksByRangeRequest, "count" | "startSlot">
-): Promise<WithBytes<SignedBeaconBlock>[]> {
-  const blocks: WithBytes<SignedBeaconBlock>[] = [];
-
-  for await (const chunk of blockStream) {
-    const blockType = responseSszTypeByMethod[ReqRespMethod.BeaconBlocksByRange](chunk.fork, chunk.protocolVersion);
-    const block = sszDeserializeResponse(blockType, chunk.data);
-
-    const blockSlot = block.message.slot;
-
-    // Note: step is deprecated and assumed to be 1
-    if (blockSlot >= startSlot + count) {
-      throw new BlocksByRangeError({code: BlocksByRangeErrorCode.OVER_MAX_SLOT});
-    }
-
-    if (blockSlot < startSlot) {
-      throw new BlocksByRangeError({code: BlocksByRangeErrorCode.UNDER_START_SLOT});
-    }
-
-    const prevBlock = blocks.at(-1);
-    if (prevBlock && prevBlock.data.message.slot >= blockSlot) {
-      throw new BlocksByRangeError({code: BlocksByRangeErrorCode.BAD_SEQUENCE});
-    }
-
-    blocks.push({data: block, bytes: chunk.data});
-    if (blocks.length >= count) {
-      break; // Done, collected all blocks
-    }
-  }
-
-  return blocks;
-}
-
-export enum BlocksByRangeErrorCode {
-  UNDER_START_SLOT = "BLOCKS_BY_RANGE_ERROR_UNDER_START_SLOT",
-  OVER_MAX_SLOT = "BLOCKS_BY_RANGE_ERROR_OVER_MAX_SLOT",
-  BAD_SEQUENCE = "BLOCKS_BY_RANGE_ERROR_BAD_SEQUENCE",
-}
-
-type BlocksByRangeErrorType =
-  | {code: BlocksByRangeErrorCode.UNDER_START_SLOT}
-  | {code: BlocksByRangeErrorCode.OVER_MAX_SLOT}
-  | {code: BlocksByRangeErrorCode.BAD_SEQUENCE};
-
-export class BlocksByRangeError extends LodestarError<BlocksByRangeErrorType> {}

package/src/network/reqresp/utils/dataColumnResponseValidation.ts

@@ -1,99 +0,0 @@
-import {LogData} from "@lodestar/logger";
-import {RespStatus, ResponseError} from "@lodestar/reqresp";
-import {ColumnIndex, Slot} from "@lodestar/types";
-import {prettyBytes, prettyPrintIndices, toRootHex} from "@lodestar/utils";
-import {IBeaconChain} from "../../../chain/interface.js";
-import {IBeaconDb} from "../../../db/interface.js";
-import {Metrics} from "../../../metrics/metrics.js";
-import {getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized} from "../../../util/sszBytes.js";
-
-export async function handleColumnSidecarUnavailability({
-  chain,
-  db,
-  metrics,
-  unavailableColumnIndices,
-  requestedColumns,
-  availableColumns,
-  slot,
-  blockRoot,
-}: {
-  chain: IBeaconChain;
-  db: IBeaconDb;
-  metrics: Metrics | null;
-  slot: Slot;
-  blockRoot?: Uint8Array;
-  unavailableColumnIndices: ColumnIndex[];
-  requestedColumns: ColumnIndex[];
-  availableColumns: ColumnIndex[];
-}): Promise<void> {
-  const logData: LogData = {
-    slot,
-    unavailableColumnIndices: prettyPrintIndices(unavailableColumnIndices),
-    requestedColumns: prettyPrintIndices(requestedColumns),
-    availableColumns: prettyPrintIndices(availableColumns),
-  };
-  if (blockRoot) {
-    logData.blockRoot = prettyBytes(blockRoot);
-  }
-
-  chain.logger.debug("dataColumnSidecar requested unavailable", logData);
-
-  const blockBytes = blockRoot ? await db.block.getBinary(blockRoot) : await db.blockArchive.getBinary(slot);
-  if (!blockBytes) {
-    chain.logger.verbose(
-      `Expected ${blockRoot ? "unfinalized" : "finalized"} block not found while handling unavailable dataColumnSidecar`,
-      {
-        slot,
-        blockRoot: blockRoot ? toRootHex(blockRoot) : "unknown",
-        earliestAvailableSlot: chain.earliestAvailableSlot,
-      }
-    );
-    return;
-  }
-
-  // Check for blob count in actual block
-  const blobsCount = getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized(chain.config, blockBytes);
-
-  // There are zero blobs for that column index, so we can safely return without any error
-  if (blobsCount > 0) return;
-
-  // There are blobs for that column index so we should have synced for it
-  // We need to inform to peers that we don't have that expected data
-  metrics?.dataColumns.missingCustodyColumns.inc(unavailableColumnIndices.length);
-  chain.logger.verbose("dataColumnSidecar requested and within custody but not available", {
-    unavailableColumnIndices: prettyPrintIndices(unavailableColumnIndices),
-    blockRoot: blockRoot ? prettyBytes(blockRoot) : "unknown",
-  });
-}
-
-export function validateRequestedDataColumns(chain: IBeaconChain, requestedColumns: ColumnIndex[]): ColumnIndex[] {
-  if (requestedColumns.length === 0) {
-    throw new ResponseError(RespStatus.INVALID_REQUEST, "dataColumnSidecar requested without column indices");
-  }
-
-  const custodyColumns = chain.custodyConfig.custodyColumns;
-  const availableColumns = requestedColumns.filter((c) => custodyColumns.includes(c));
-  const missingColumns = requestedColumns.filter((c) => !custodyColumns.includes(c));
-
-  if (missingColumns.length > 0) {
-    chain.logger.verbose("Requested dataColumnSidecar for non-custody columns", {
-      requestedColumns: prettyPrintIndices(requestedColumns),
-      custodyColumns: prettyPrintIndices(custodyColumns),
-      availableColumns: prettyPrintIndices(availableColumns),
-      missingColumns: prettyPrintIndices(missingColumns),
-    });
-
-    // TODO: We should throw error and only respond to valid requests
-    // A peer must check what we announced in our custody and only ask for those columns
-    // throw new ResponseError(RespStatus.INVALID_REQUEST, "dataColumnSidecar requested for non-custody columns");
-  }
-
-  if (availableColumns.length === 0) {
-    chain.logger.verbose("Requested dataColumnSidecars not available", {
-      requestedColumns: prettyPrintIndices(requestedColumns),
-      custodyColumns: prettyPrintIndices(custodyColumns),
-    });
-  }
-
-  return availableColumns;
-}

package/src/network/statusCache.ts

@@ -1,17 +0,0 @@
-import {Status} from "@lodestar/types";
-
-export interface StatusCache {
-  get(): Status;
-}
-
-export class LocalStatusCache implements StatusCache {
-  constructor(private status: Status) {}
-
-  get(): Status {
-    return this.status;
-  }
-
-  update(localStatus: Status): void {
-    this.status = localStatus;
-  }
-}