@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/network/reqresp/rateLimit.ts

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,174 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,17 @@
+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;
+  }
+}