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

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -0,0 +1,373 @@
+import {PeerId} from "@libp2p/interface";
+import {Libp2p} from "libp2p";
+import {BeaconConfig, ForkBoundary} from "@lodestar/config";
+import {ForkName, ForkSeq, GENESIS_EPOCH} from "@lodestar/params";
+import {
+  Encoding,
+  ProtocolDescriptor,
+  ProtocolHandler,
+  ReqResp,
+  ReqRespOpts,
+  ReqRespRequest,
+  RequestError,
+  ResponseIncoming,
+  ResponseOutgoing,
+} from "@lodestar/reqresp";
+import {Metadata, Status, phase0, ssz} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {callInNextEventLoop} from "../../util/eventLoop.js";
+import {NetworkCoreMetrics} from "../core/metrics.js";
+import {INetworkEventBus, NetworkEvent} from "../events.js";
+import {MetadataController} from "../metadata.js";
+import {PeersData} from "../peers/peersData.js";
+import {IPeerRpcScoreStore, PeerAction} from "../peers/score/index.js";
+import {StatusCache} from "../statusCache.js";
+import * as protocols from "./protocols.js";
+import {onOutgoingReqRespError} from "./score.js";
+import {
+  GetReqRespHandlerFn,
+  ProtocolNoHandler,
+  ReqRespMethod,
+  RequestTypedContainer,
+  Version,
+  requestSszTypeByMethod,
+  responseSszTypeByMethod,
+} from "./types.js";
+import {collectExactOneTyped} from "./utils/collect.js";
+
+export {getReqRespHandlers} from "./handlers/index.js";
+export {ReqRespMethod, type RequestTypedContainer} from "./types.js";
+
+export interface ReqRespBeaconNodeModules {
+  libp2p: Libp2p;
+  peersData: PeersData;
+  logger: Logger;
+  config: BeaconConfig;
+  metrics: NetworkCoreMetrics | null;
+  metadata: MetadataController;
+  peerRpcScores: IPeerRpcScoreStore;
+  events: INetworkEventBus;
+  statusCache: StatusCache;
+  getHandler: GetReqRespHandlerFn;
+}
+
+export type ReqRespBeaconNodeOpts = ReqRespOpts & {disableLightClientServer?: boolean};
+
+/**
+ * Implementation of Ethereum Consensus p2p Req/Resp domain.
+ * For the spec that this code is based on, see:
+ * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#the-reqresp-domain
+ * https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#the-reqresp-domain
+ */
+export class ReqRespBeaconNode extends ReqResp {
+  private readonly metadataController: MetadataController;
+  private readonly peerRpcScores: IPeerRpcScoreStore;
+  private readonly networkEventBus: INetworkEventBus;
+  private readonly peersData: PeersData;
+  private readonly statusCache: StatusCache;
+  private readonly getHandler: GetReqRespHandlerFn;
+
+  /** Track registered fork to only send to known protocols */
+  private currentRegisteredFork: ForkSeq = ForkSeq.phase0;
+
+  private readonly config: BeaconConfig;
+  protected readonly logger: Logger;
+  protected readonly disableLightClientServer: boolean;
+
+  constructor(modules: ReqRespBeaconNodeModules, options: ReqRespBeaconNodeOpts = {}) {
+    const {events, peersData, peerRpcScores, metadata, metrics, logger} = modules;
+
+    super(
+      {
+        ...modules,
+        metricsRegister: metrics?.register ?? null,
+      },
+      {
+        ...options,
+        onRateLimit(peerId, method) {
+          logger.debug("Do not serve request due to rate limit", {peerId: peerId.toString()});
+          peerRpcScores.applyAction(peerId, PeerAction.Fatal, "rate_limit_rpc");
+          metrics?.reqResp.rateLimitErrors.inc({method});
+        },
+        getPeerLogMetadata(peerId) {
+          // this logs the whole agent version for unknown client which is good for debugging
+          return peersData.getPeerKind(peerId) ?? peersData.getAgentVersion(peerId);
+        },
+      }
+    );
+
+    this.disableLightClientServer = options.disableLightClientServer ?? false;
+    this.peerRpcScores = peerRpcScores;
+    this.peersData = peersData;
+    this.config = modules.config;
+    this.logger = logger;
+    this.metadataController = metadata;
+    this.networkEventBus = events;
+    this.statusCache = modules.statusCache;
+    this.getHandler = modules.getHandler;
+  }
+
+  async start(): Promise<void> {
+    await super.start();
+  }
+
+  async stop(): Promise<void> {
+    await super.stop();
+  }
+
+  // NOTE: Do not pruneOnPeerDisconnect. Persist peer rate limit data until pruned by time
+  // pruneOnPeerDisconnect(peerId: PeerId): void {
+  //   this.rateLimiter.prune(peerId);
+
+  registerProtocolsAtBoundary(boundary: ForkBoundary): void {
+    this.currentRegisteredFork = ForkSeq[boundary.fork];
+
+    const mustSubscribeProtocols = this.getProtocolsAtBoundary(boundary);
+    const mustSubscribeProtocolIDs = new Set(
+      mustSubscribeProtocols.map(([protocol]) => this.formatProtocolID(protocol))
+    );
+
+    // Un-subscribe not required protocols
+    for (const protocolID of this.getRegisteredProtocols()) {
+      if (!mustSubscribeProtocolIDs.has(protocolID)) {
+        // Async because of writing to peerstore -_- should never throw
+        this.unregisterProtocol(protocolID).catch((e) => {
+          this.logger.error("Error on ReqResp.unregisterProtocol", {protocolID}, e);
+        });
+      }
+    }
+
+    // Subscribe required protocols
+    for (const [protocol, handler] of mustSubscribeProtocols) {
+      this.registerProtocol({...protocol, handler}).catch((e) => {
+        this.logger.error("Error on ReqResp.registerProtocol", {protocolID: this.formatProtocolID(protocol)}, e);
+      });
+    }
+  }
+
+  sendRequestWithoutEncoding(
+    peerId: PeerId,
+    method: ReqRespMethod,
+    versions: number[],
+    requestData: Uint8Array
+  ): AsyncIterable<ResponseIncoming> {
+    // Remember preferred encoding
+    const encoding = this.peersData.getEncodingPreference(peerId.toString()) ?? Encoding.SSZ_SNAPPY;
+
+    // Overwrite placeholder requestData from main thread with correct sequenceNumber
+    if (method === ReqRespMethod.Ping) {
+      requestData = requestSszTypeByMethod(ForkName.phase0, this.config)[ReqRespMethod.Ping].serialize(
+        this.metadataController.seqNumber
+      );
+    }
+
+    // ReqResp outgoing request, emit from main thread to worker
+    return this.sendRequest(peerId, method, versions, encoding, requestData);
+  }
+
+  async sendPing(peerId: PeerId): Promise<phase0.Ping> {
+    return collectExactOneTyped(
+      // Ping method request data is overwritten in worker with correct sequence number
+      this.sendReqRespRequest(peerId, ReqRespMethod.Ping, [Version.V1], this.metadataController.seqNumber),
+      responseSszTypeByMethod[ReqRespMethod.Ping]
+    );
+  }
+
+  async sendStatus(peerId: PeerId, request: Status): Promise<Status> {
+    return collectExactOneTyped(
+      this.sendReqRespRequest(
+        peerId,
+        ReqRespMethod.Status,
+        this.currentRegisteredFork >= ForkSeq.fulu ? [Version.V2] : [Version.V1],
+        request
+      ),
+      responseSszTypeByMethod[ReqRespMethod.Status]
+    );
+  }
+
+  async sendGoodbye(peerId: PeerId, request: phase0.Goodbye): Promise<void> {
+    // TODO: Replace with "ignore response after request"
+    await collectExactOneTyped(
+      this.sendReqRespRequest(peerId, ReqRespMethod.Goodbye, [Version.V1], request),
+      responseSszTypeByMethod[ReqRespMethod.Goodbye]
+    );
+  }
+
+  async sendMetadata(peerId: PeerId): Promise<Metadata> {
+    return collectExactOneTyped(
+      this.sendReqRespRequest(
+        peerId,
+        ReqRespMethod.Metadata,
+        this.currentRegisteredFork >= ForkSeq.fulu
+          ? [Version.V3]
+          : this.currentRegisteredFork >= ForkSeq.altair
+            ? [Version.V3, Version.V2]
+            : [Version.V2, Version.V1],
+        null
+      ),
+      responseSszTypeByMethod[ReqRespMethod.Metadata]
+    );
+  }
+
+  private sendReqRespRequest<Req>(
+    peerId: PeerId,
+    method: ReqRespMethod,
+    versions: number[],
+    request: Req
+  ): AsyncIterable<ResponseIncoming> {
+    const fork = ForkName[ForkSeq[this.currentRegisteredFork] as ForkName];
+    const requestType = requestSszTypeByMethod(fork, this.config)[method];
+    const requestData = requestType ? requestType.serialize(request as never) : new Uint8Array();
+    return this.sendRequestWithoutEncoding(peerId, method, versions, requestData);
+  }
+
+  /**
+   * Returns the list of protocols that must be subscribed during a specific fork.
+   * Any protocol not in this list must be un-subscribed.
+   */
+  private getProtocolsAtBoundary(boundary: ForkBoundary): [ProtocolNoHandler, ProtocolHandler][] {
+    const {fork} = boundary;
+    const protocolsAtFork: [ProtocolNoHandler, ProtocolHandler][] = [
+      [protocols.Ping(fork, this.config), this.onPing.bind(this)],
+      [protocols.Goodbye(fork, this.config), this.onGoodbye.bind(this)],
+      // Support V3 methods as soon as implemented (for fulu)
+      // Follows pattern for altair:
+      // Ref https://github.com/ethereum/consensus-specs/blob/v1.2.0/specs/altair/p2p-interface.md#transitioning-from-v1-to-v2
+      [protocols.MetadataV3(fork, this.config), this.onMetadata.bind(this)],
+      [protocols.BeaconBlocksByRangeV2(fork, this.config), this.getHandler(ReqRespMethod.BeaconBlocksByRange)],
+      [protocols.BeaconBlocksByRootV2(fork, this.config), this.getHandler(ReqRespMethod.BeaconBlocksByRoot)],
+    ];
+
+    if (ForkSeq[fork] < ForkSeq.altair) {
+      // Unregister V1 topics at the fork boundary, so only declare for pre-altair
+      protocolsAtFork.push(
+        [protocols.Metadata(fork, this.config), this.onMetadata.bind(this)],
+        [protocols.BeaconBlocksByRange(fork, this.config), this.getHandler(ReqRespMethod.BeaconBlocksByRange)],
+        [protocols.BeaconBlocksByRoot(fork, this.config), this.getHandler(ReqRespMethod.BeaconBlocksByRoot)]
+      );
+    }
+
+    if (ForkSeq[fork] >= ForkSeq.altair && !this.disableLightClientServer) {
+      // Should be okay to enable before altair, but for consistency only enable afterwards
+      protocolsAtFork.push(
+        [protocols.LightClientBootstrap(fork, this.config), this.getHandler(ReqRespMethod.LightClientBootstrap)],
+        [
+          protocols.LightClientFinalityUpdate(fork, this.config),
+          this.getHandler(ReqRespMethod.LightClientFinalityUpdate),
+        ],
+        [
+          protocols.LightClientOptimisticUpdate(fork, this.config),
+          this.getHandler(ReqRespMethod.LightClientOptimisticUpdate),
+        ],
+        [
+          protocols.LightClientUpdatesByRange(fork, this.config),
+          this.getHandler(ReqRespMethod.LightClientUpdatesByRange),
+        ]
+      );
+    }
+
+    if (ForkSeq[fork] >= ForkSeq.deneb) {
+      protocolsAtFork.push(
+        [protocols.BlobSidecarsByRoot(fork, this.config), this.getHandler(ReqRespMethod.BlobSidecarsByRoot)],
+        [protocols.BlobSidecarsByRange(fork, this.config), this.getHandler(ReqRespMethod.BlobSidecarsByRange)]
+      );
+    }
+
+    if (ForkSeq[fork] < ForkSeq.fulu) {
+      // Unregister StatusV1, MetadataV2 at the fork boundary, so only declare for pre-fulu
+      protocolsAtFork.push(
+        [protocols.Status(fork, this.config), this.onStatus.bind(this)],
+        [protocols.MetadataV2(fork, this.config), this.onMetadata.bind(this)]
+      );
+    } else {
+      protocolsAtFork.push(
+        // We can't handle StatusV2 correctly pre-fulu as request type is selected based on fork
+        // instead of protocol version. This is not easily fixable with our current architecture.
+        // See https://github.com/ChainSafe/lodestar/pull/8168 for more details.
+        [protocols.StatusV2(fork, this.config), this.onStatus.bind(this)],
+        [
+          protocols.DataColumnSidecarsByRoot(fork, this.config),
+          this.getHandler(ReqRespMethod.DataColumnSidecarsByRoot),
+        ],
+        [
+          protocols.DataColumnSidecarsByRange(fork, this.config),
+          this.getHandler(ReqRespMethod.DataColumnSidecarsByRange),
+        ]
+      );
+    }
+
+    return protocolsAtFork;
+  }
+
+  protected onIncomingRequestBody(request: RequestTypedContainer, peer: PeerId): void {
+    // Allow onRequest to return and close the stream
+    // For Goodbye there may be a race condition where the listener of `receivedGoodbye`
+    // disconnects in the same synchronous call, preventing the stream from ending cleanly
+    callInNextEventLoop(() => this.networkEventBus.emit(NetworkEvent.reqRespRequest, {request, peer}));
+  }
+
+  protected onIncomingRequest(peerId: PeerId, protocol: ProtocolDescriptor): void {
+    // Remember preferred encoding
+    if (protocol.method === ReqRespMethod.Status) {
+      this.peersData.setEncodingPreference(peerId.toString(), protocol.encoding);
+    }
+  }
+
+  protected onOutgoingRequestError(peerId: PeerId, method: ReqRespMethod, error: RequestError): void {
+    const peerAction = onOutgoingReqRespError(error, method);
+    if (peerAction !== null) {
+      this.peerRpcScores.applyAction(peerId, peerAction, error.type.code);
+    }
+  }
+
+  private async *onStatus(req: ReqRespRequest, peerId: PeerId): AsyncIterable<ResponseOutgoing> {
+    // Fork is ignored in responseSszTypeByMethod, type is determined by protocol version that is negotiated
+    const type = responseSszTypeByMethod[ReqRespMethod.Status](ForkName.phase0, req.version);
+    // Request uses the same type as response
+    const body = type.deserialize(req.data);
+    this.onIncomingRequestBody({method: ReqRespMethod.Status, body}, peerId);
+
+    const status = this.statusCache.get();
+    yield {
+      data: type.serialize(status),
+      // Status topic is fork-agnostic
+      boundary: {fork: ForkName.phase0, epoch: GENESIS_EPOCH},
+    };
+  }
+
+  private async *onGoodbye(req: ReqRespRequest, peerId: PeerId): AsyncIterable<ResponseOutgoing> {
+    const body = ssz.phase0.Goodbye.deserialize(req.data);
+    this.onIncomingRequestBody({method: ReqRespMethod.Goodbye, body}, peerId);
+
+    yield {
+      data: ssz.phase0.Goodbye.serialize(BigInt(0)),
+      // Goodbye topic is fork-agnostic
+      boundary: {fork: ForkName.phase0, epoch: GENESIS_EPOCH},
+    };
+  }
+
+  private async *onPing(req: ReqRespRequest, peerId: PeerId): AsyncIterable<ResponseOutgoing> {
+    const body = ssz.phase0.Ping.deserialize(req.data);
+    this.onIncomingRequestBody({method: ReqRespMethod.Ping, body}, peerId);
+    yield {
+      data: ssz.phase0.Ping.serialize(this.metadataController.seqNumber),
+      // Ping topic is fork-agnostic
+      boundary: {fork: ForkName.phase0, epoch: GENESIS_EPOCH},
+    };
+  }
+
+  private async *onMetadata(req: ReqRespRequest, peerId: PeerId): AsyncIterable<ResponseOutgoing> {
+    this.onIncomingRequestBody({method: ReqRespMethod.Metadata, body: null}, peerId);
+
+    const metadata = this.metadataController.json;
+
+    // Fork is ignored in responseSszTypeByMethod, type is determined by protocol version that is negotiated
+    const type = responseSszTypeByMethod[ReqRespMethod.Metadata](ForkName.phase0, req.version);
+
+    yield {
+      data: type.serialize(metadata),
+      // Metadata topic is fork-agnostic
+      boundary: {fork: ForkName.phase0, epoch: GENESIS_EPOCH},
+    };
+  }
+}

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

@@ -0,0 +1,101 @@
+import {BeaconConfig} from "@lodestar/config";
+import {GENESIS_SLOT, isForkPostDeneb} from "@lodestar/params";
+import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {deneb, phase0} from "@lodestar/types";
+import {fromHex} from "@lodestar/utils";
+import {IBeaconChain} from "../../../chain/index.js";
+import {IBeaconDb} from "../../../db/index.js";
+
+// TODO: Unit test
+
+export async function* onBeaconBlocksByRange(
+  request: phase0.BeaconBlocksByRangeRequest,
+  chain: IBeaconChain,
+  db: IBeaconDb
+): AsyncIterable<ResponseOutgoing> {
+  const {startSlot, count} = validateBeaconBlocksByRangeRequest(chain.config, request);
+  const endSlot = startSlot + count;
+
+  const finalized = db.blockArchive;
+  const unfinalized = db.block;
+  const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
+
+  // Finalized range of blocks
+  if (startSlot <= finalizedSlot) {
+    // Chain of blobs won't change
+    for await (const {key, value} of finalized.binaryEntriesStream({gte: startSlot, lt: endSlot})) {
+      yield {
+        data: value,
+        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(finalized.decodeKey(key))),
+      };
+    }
+  }
+
+  // Non-finalized range of blocks
+  if (endSlot > finalizedSlot) {
+    const headRoot = chain.forkChoice.getHeadRoot();
+    // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    // getAllAncestorBlocks response includes the head node, so it's the full chain.
+
+    // Iterate head chain with ascending block numbers
+    for (let i = headChain.length - 1; i >= 0; i--) {
+      const block = headChain[i];
+
+      // Must include only blocks 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 blobs must be consistent, but on
+        // re-org there's no need to abort the request
+        // Spec: https://github.com/ethereum/consensus-specs/blob/a1e46d1ae47dd9d097725801575b46907c12a1f8/specs/eip4844/p2p-interface.md#blobssidecarsbyrange-v1
+
+        const blockBytes = await unfinalized.getBinary(fromHex(block.blockRoot));
+        if (!blockBytes) {
+          throw new ResponseError(
+            RespStatus.SERVER_ERROR,
+            `No block for root ${block.blockRoot} slot ${block.slot}, startSlot=${startSlot} endSlot=${endSlot} finalizedSlot=${finalizedSlot}`
+          );
+        }
+
+        yield {
+          data: blockBytes,
+          boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
+        };
+      }
+
+      // If block is after endSlot, stop iterating
+      else if (block.slot >= endSlot) {
+        break;
+      }
+    }
+  }
+}
+
+export function validateBeaconBlocksByRangeRequest(
+  config: BeaconConfig,
+  request: phase0.BeaconBlocksByRangeRequest
+): deneb.BlobSidecarsByRangeRequest {
+  const {startSlot} = 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");
+  }
+
+  // step > 1 is deprecated, see https://github.com/ethereum/consensus-specs/pull/2856
+
+  const maxRequestBlocks = isForkPostDeneb(config.getForkName(startSlot))
+    ? config.MAX_REQUEST_BLOCKS_DENEB
+    : config.MAX_REQUEST_BLOCKS;
+
+  if (count > maxRequestBlocks) {
+    count = maxRequestBlocks;
+  }
+
+  return {startSlot, count};
+}

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

@@ -0,0 +1,49 @@
+import {ResponseOutgoing} from "@lodestar/reqresp";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {Slot} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {IBeaconChain} from "../../../chain/index.js";
+import {IBeaconDb} from "../../../db/index.js";
+import {getSlotFromSignedBeaconBlockSerialized} from "../../../util/sszBytes.js";
+import {BeaconBlocksByRootRequest} from "../../../util/types.js";
+
+export async function* onBeaconBlocksByRoot(
+  requestBody: BeaconBlocksByRootRequest,
+  chain: IBeaconChain,
+  db: IBeaconDb
+): AsyncIterable<ResponseOutgoing> {
+  for (const blockRoot of requestBody) {
+    const root = blockRoot;
+    const summary = chain.forkChoice.getBlock(root);
+    let blockBytes: Uint8Array | null = null;
+
+    // finalized block has summary in forkchoice but it stays in blockArchive db
+    if (summary) {
+      blockBytes = await db.block.getBinary(root);
+    }
+
+    let slot: Slot | undefined = undefined;
+    if (!blockBytes) {
+      const blockEntry = await db.blockArchive.getBinaryEntryByRoot(root);
+      if (blockEntry) {
+        slot = blockEntry.key;
+        blockBytes = blockEntry.value;
+      }
+    }
+
+    if (blockBytes) {
+      if (slot === undefined) {
+        const slotFromBytes = getSlotFromSignedBeaconBlockSerialized(blockBytes);
+        if (slotFromBytes === null) {
+          throw Error(`Invalid block bytes for block root ${toRootHex(root)}`);
+        }
+        slot = slotFromBytes;
+      }
+
+      yield {
+        data: blockBytes,
+        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(slot)),
+      };
+    }
+  }
+}

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

@@ -0,0 +1,114 @@
+import {ChainConfig} from "@lodestar/config";
+import {BLOBSIDECAR_FIXED_SIZE, GENESIS_SLOT} from "@lodestar/params";
+import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {Slot, deneb} from "@lodestar/types";
+import {fromHex} 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";
+
+export async function* onBlobSidecarsByRange(
+  request: deneb.BlobSidecarsByRangeRequest,
+  chain: IBeaconChain,
+  db: IBeaconDb
+): AsyncIterable<ResponseOutgoing> {
+  // Non-finalized range of blobs
+  const {startSlot, count} = validateBlobSidecarsByRangeRequest(chain.config, request);
+  const endSlot = startSlot + count;
+
+  const finalized = db.blobSidecarsArchive;
+  const unfinalized = db.blobSidecars;
+  const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
+
+  // Finalized range of blobs
+  if (startSlot <= finalizedSlot) {
+    // Chain of blobs won't change
+    for await (const {key, value: blobSideCarsBytesWrapped} of finalized.binaryEntriesStream({
+      gte: startSlot,
+      lt: endSlot,
+    })) {
+      yield* iterateBlobBytesFromWrapper(chain, blobSideCarsBytesWrapped, finalized.decodeKey(key));
+    }
+  }
+
+  // Non-finalized range of blobs
+  if (endSlot > finalizedSlot) {
+    const headRoot = chain.forkChoice.getHeadRoot();
+    // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
+    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 blobs 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 blobs must be consistent, but on
+        // re-org there's no need to abort the request
+        // Spec: https://github.com/ethereum/consensus-specs/blob/a1e46d1ae47dd9d097725801575b46907c12a1f8/specs/eip4844/p2p-interface.md#blobssidecarsbyrange-v1
+
+        const blobSideCarsBytesWrapped = await unfinalized.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}`);
+        }
+        yield* iterateBlobBytesFromWrapper(chain, blobSideCarsBytesWrapped, block.slot);
+      }
+
+      // If block is after endSlot, stop iterating
+      else if (block.slot >= endSlot) {
+        break;
+      }
+    }
+  }
+}
+
+export function* iterateBlobBytesFromWrapper(
+  chain: IBeaconChain,
+  blobSideCarsBytesWrapped: Uint8Array,
+  blockSlot: Slot
+): Iterable<ResponseOutgoing> {
+  const allBlobSideCarsBytes = blobSideCarsBytesWrapped.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
+  const blobsLen = allBlobSideCarsBytes.length / BLOBSIDECAR_FIXED_SIZE;
+
+  for (let index = 0; index < blobsLen; index++) {
+    const blobSideCarBytes = allBlobSideCarsBytes.slice(
+      index * BLOBSIDECAR_FIXED_SIZE,
+      (index + 1) * BLOBSIDECAR_FIXED_SIZE
+    );
+    if (blobSideCarBytes.length !== BLOBSIDECAR_FIXED_SIZE) {
+      throw new ResponseError(
+        RespStatus.SERVER_ERROR,
+        `Invalid blobSidecar index=${index} bytes length=${blobSideCarBytes.length} expected=${BLOBSIDECAR_FIXED_SIZE} for slot ${blockSlot} blobsLen=${blobsLen}`
+      );
+    }
+    yield {
+      data: blobSideCarBytes,
+      boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(blockSlot)),
+    };
+  }
+}
+
+export function validateBlobSidecarsByRangeRequest(
+  config: ChainConfig,
+  request: deneb.BlobSidecarsByRangeRequest
+): deneb.BlobSidecarsByRangeRequest {
+  const {startSlot} = 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};
+}