@lodestar/beacon-node 1.36.0 → 1.37.0-dev.0c3b3f119c

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -60,7 +60,19 @@ export async function writeBlockInputToDb(this: BeaconChain, blocksInputs: IBloc
         );
       }
 
-      fnPromises.push(this.db.dataColumnSidecar.putMany(blockRoot, dataColumnSidecars));
+      const binaryPuts = [];
+      const nonbinaryPuts = [];
+      for (const dataColumnSidecar of dataColumnSidecars) {
+        // skip reserializing column if we already have it
+        const serialized = this.serializedCache.get(dataColumnSidecar);
+        if (serialized) {
+          binaryPuts.push({key: dataColumnSidecar.index, value: serialized});
+        } else {
+          nonbinaryPuts.push(dataColumnSidecar);
+        }
+      }
+      fnPromises.push(this.db.dataColumnSidecar.putManyBinary(blockRoot, binaryPuts));
+      fnPromises.push(this.db.dataColumnSidecar.putMany(blockRoot, nonbinaryPuts));
       this.logger.debug("Persisted dataColumnSidecars to hot DB", {
         slot: block.message.slot,
         root: blockRootHex,

package/src/chain/prepareNextSlot.ts

@@ -1,5 +1,6 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
+import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
 import {
   BeaconStateElectra,
@@ -166,7 +167,7 @@ export class PrepareNextSlotScheduler {
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
           this.metrics?.blockPayload.payloadAdvancePrepTime.observe(preparationTime);
 
-          const safeBlockHash = this.chain.forkChoice.getJustifiedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+          const safeBlockHash = getSafeExecutionBlockHash(this.chain.forkChoice);
           const finalizedBlockHash =
             this.chain.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
           // awaiting here instead of throwing an async call because there is no other task

package/src/chain/produceBlock/produceBlockBody.ts

@@ -1,4 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
+import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {
   ForkName,
   ForkPostBellatrix,
@@ -191,7 +192,7 @@ export async function produceBlockBody<T extends BlockType>(
 
     // We don't deal with blinded blocks, execution engine, blobs and execution requests post-gloas
   } else if (isForkPostBellatrix(fork)) {
-    const safeBlockHash = this.forkChoice.getJustifiedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
     const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
     const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
     const feeRecipientType = requestedFeeRecipient

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -2,8 +2,8 @@ import {ChainForkConfig} from "@lodestar/config";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {ForkName, ForkPostFulu, ForkPreGloas, isForkPostDeneb, isForkPostFulu, isForkPostGloas} from "@lodestar/params";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
-import {LodestarError, Logger} from "@lodestar/utils";
+import {BLSSignature, RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {LodestarError, Logger, pruneSetToMax} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {CustodyConfig} from "../../util/dataColumns.js";
@@ -83,6 +83,10 @@ export class SeenBlockInput {
   private readonly metrics: Metrics | null;
   private readonly logger?: Logger;
   private blockInputs = new Map<RootHex, IBlockInput>();
+  // using a Map of slot helps it more convenient to prune
+  // there should only 1 block root per slot but we need to always compare against rootHex
+  // and the signature to ensure we only skip verification if both match
+  private verifiedProposerSignatures = new Map<Slot, Map<RootHex, BLSSignature>>();
 
   constructor({config, custodyConfig, clock, chainEvents, signal, metrics, logger}: SeenBlockInputCacheModules) {
     this.config = config;
@@ -330,6 +334,32 @@ export class SeenBlockInput {
     return blockInput;
   }
 
+  /**
+   * Check if a proposer signature has already been verified for this slot and block root.
+   */
+  isVerifiedProposerSignature(slot: Slot, blockRootHex: RootHex, signature: BLSSignature): boolean {
+    const seenMap = this.verifiedProposerSignatures.get(slot);
+    const cachedSignature = seenMap?.get(blockRootHex);
+    if (!cachedSignature) {
+      return false;
+    }
+    // Only consider verified if the signature matches
+    return Buffer.compare(cachedSignature, signature) === 0;
+  }
+
+  /**
+   * Mark that the proposer signature for this slot and block root has been verified
+   * so that we only verify it once per slot
+   */
+  markVerifiedProposerSignature(slot: Slot, blockRootHex: RootHex, signature: BLSSignature): void {
+    let seenMap = this.verifiedProposerSignatures.get(slot);
+    if (!seenMap) {
+      seenMap = new Map<RootHex, BLSSignature>();
+      this.verifiedProposerSignatures.set(slot, seenMap);
+    }
+    seenMap.set(blockRootHex, signature);
+  }
+
   private buildCommonProps(slot: Slot): {
     daOutOfRange: boolean;
     forkName: ForkName;
@@ -356,6 +386,7 @@ export class SeenBlockInput {
         if (itemsToDelete <= 0) return;
       }
     }
+    pruneSetToMax(this.verifiedProposerSignatures, MAX_BLOCK_INPUT_CACHE_SIZE);
   }
 }
 

package/src/chain/validation/blobSidecar.ts

@@ -135,15 +135,20 @@ export async function validateGossipBlobSidecar(
     });
 
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
-  const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(blockState, blobSidecar.signedBlockHeader);
-  // Don't batch so verification is not delayed
-  if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
-    throw new BlobSidecarGossipError(GossipAction.REJECT, {
-      code: BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
-      blockRoot: blockHex,
-      index: blobSidecar.index,
-      slot: blobSlot,
-    });
+  const signature = blobSidecar.signedBlockHeader.signature;
+  if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blobSlot, blockHex, signature)) {
+    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(blockState, blobSidecar.signedBlockHeader);
+    // Don't batch so verification is not delayed
+    if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
+      throw new BlobSidecarGossipError(GossipAction.REJECT, {
+        code: BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
+        blockRoot: blockHex,
+        index: blobSidecar.index,
+        slot: blobSlot,
+      });
+    }
+
+    chain.seenBlockInputCache.markVerifiedProposerSignature(blobSlot, blockHex, signature);
   }
 
   // verify if the blob inclusion proof is correct
@@ -231,22 +236,26 @@ export async function validateBlockBlobSidecars(
   }
 
   if (chain !== null) {
-    const headState = await chain.getHeadState();
-    const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+    const blockRootHex = toRootHex(blockRoot);
+    const signature = firstSidecarSignedBlockHeader.signature;
+    if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRootHex, signature)) {
+      const headState = await chain.getHeadState();
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
 
-    if (
-      !(await chain.bls.verifySignatureSets([signatureSet], {
-        batchable: true,
-        priority: true,
-        verifyOnMainThread: false,
-      }))
-    ) {
-      throw new BlobSidecarValidationError({
-        code: BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
-        blockRoot: toRootHex(blockRoot),
-        slot: blockSlot,
-        index: blobSidecars[0].index,
-      });
+      if (
+        !(await chain.bls.verifySignatureSets([signatureSet], {
+          verifyOnMainThread: true,
+        }))
+      ) {
+        throw new BlobSidecarValidationError({
+          code: BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
+          blockRoot: blockRootHex,
+          slot: blockSlot,
+          index: blobSidecars[0].index,
+        });
+      }
+
+      chain.seenBlockInputCache.markVerifiedProposerSignature(blockSlot, blockRootHex, signature);
     }
   }
 

package/src/chain/validation/block.ts

@@ -153,13 +153,17 @@ export async function validateGossipBlock(
   }
 
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
-  const signatureSet = getBlockProposerSignatureSet(blockState, signedBlock);
-  // Don't batch so verification is not delayed
-  if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
-    throw new BlockGossipError(GossipAction.REJECT, {
-      code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID,
-      blockSlot,
-    });
+  if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRoot, signedBlock.signature)) {
+    const signatureSet = getBlockProposerSignatureSet(blockState, signedBlock);
+    // Don't batch so verification is not delayed
+    if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
+      throw new BlockGossipError(GossipAction.REJECT, {
+        code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID,
+        blockSlot,
+      });
+    }
+
+    chain.seenBlockInputCache.markVerifiedProposerSignature(blockSlot, blockRoot, signedBlock.signature);
   }
 
   // [REJECT] The block is proposed by the expected proposer_index for the block's slot in the context of the current

package/src/chain/validation/dataColumnSidecar.ts

@@ -32,6 +32,7 @@ export async function validateGossipDataColumnSidecar(
   metrics: Metrics | null
 ): Promise<void> {
   const blockHeader = dataColumnSidecar.signedBlockHeader.message;
+  const blockRootHex = toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(blockHeader));
 
   // 1) [REJECT] The sidecar is valid as verified by verify_data_column_sidecar
   verifyDataColumnSidecar(chain.config, dataColumnSidecar);
@@ -131,24 +132,28 @@ export async function validateGossipDataColumnSidecar(
   }
 
   // 5) [REJECT] The proposer signature of sidecar.signed_block_header, is valid with respect to the block_header.proposer_index pubkey.
-  const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
-    blockState,
-    dataColumnSidecar.signedBlockHeader
-  );
-  // Don't batch so verification is not delayed
-  if (
-    !(await chain.bls.verifySignatureSets([signatureSet], {
-      verifyOnMainThread: blockHeader.slot > chain.forkChoice.getHead().slot,
-    }))
-  ) {
-    const blockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(dataColumnSidecar.signedBlockHeader.message);
-    const blockRootHex = toRootHex(blockRoot);
-    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
-      code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
-      blockRoot: blockRootHex,
-      index: dataColumnSidecar.index,
-      slot: blockHeader.slot,
-    });
+  const signature = dataColumnSidecar.signedBlockHeader.signature;
+  if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature)) {
+    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      blockState,
+      dataColumnSidecar.signedBlockHeader
+    );
+
+    if (
+      !(await chain.bls.verifySignatureSets([signatureSet], {
+        // verify on main thread so that we only need to verify block proposer signature once per block
+        verifyOnMainThread: true,
+      }))
+    ) {
+      throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+        code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
+        blockRoot: blockRootHex,
+        index: dataColumnSidecar.index,
+        slot: blockHeader.slot,
+      });
+    }
+
+    chain.seenBlockInputCache.markVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature);
   }
 
   // 9) [REJECT] The current finalized_checkpoint is an ancestor of the sidecar's block
@@ -326,22 +331,27 @@ export async function validateBlockDataColumnSidecars(
   }
 
   if (chain !== null) {
-    const headState = await chain.getHeadState();
-    const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+    const rootHex = toRootHex(blockRoot);
+    const slot = firstSidecarSignedBlockHeader.message.slot;
+    const signature = firstSidecarSignedBlockHeader.signature;
+    if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
+      const headState = await chain.getHeadState();
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+
+      if (
+        !(await chain.bls.verifySignatureSets([signatureSet], {
+          verifyOnMainThread: true,
+        }))
+      ) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
+          blockRoot: rootHex,
+          slot: blockSlot,
+          index: dataColumnSidecars[0].index,
+        });
+      }
 
-    if (
-      !(await chain.bls.verifySignatureSets([signatureSet], {
-        batchable: true,
-        priority: true,
-        verifyOnMainThread: false,
-      }))
-    ) {
-      throw new DataColumnSidecarValidationError({
-        code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
-        blockRoot: toRootHex(blockRoot),
-        slot: blockSlot,
-        index: dataColumnSidecars[0].index,
-      });
+      chain.seenBlockInputCache.markVerifiedProposerSignature(slot, rootHex, signature);
     }
   }
 

package/src/network/gossip/encoding.ts

@@ -1,12 +1,14 @@
 import {Message} from "@libp2p/interface";
+// snappyjs is better for compression for smaller payloads
+import {compress, uncompress} from "snappyjs";
 import xxhashFactory from "xxhash-wasm";
-import {compress, uncompress} from "#snappy";
 import {digest} from "@chainsafe/as-sha256";
 import {RPC} from "@chainsafe/libp2p-gossipsub/message";
 import {DataTransform} from "@chainsafe/libp2p-gossipsub/types";
 import {ForkName} from "@lodestar/params";
 import {intToBytes} from "@lodestar/utils";
 import {MESSAGE_DOMAIN_VALID_SNAPPY} from "./constants.js";
+import {Eth2GossipsubMetrics} from "./metrics.js";
 import {GossipTopicCache, getGossipSSZType} from "./topic.js";
 
 // Load WASM
@@ -69,7 +71,8 @@ export function msgIdFn(gossipTopicCache: GossipTopicCache, msg: Message): Uint8
 export class DataTransformSnappy implements DataTransform {
   constructor(
     private readonly gossipTopicCache: GossipTopicCache,
-    private readonly maxSizePerMessage: number
+    private readonly maxSizePerMessage: number,
+    private readonly metrics: Eth2GossipsubMetrics | null
   ) {}
 
   /**
@@ -86,6 +89,7 @@ export class DataTransformSnappy implements DataTransform {
     const uncompressedDataLength = uncompressedData.length;
     const topic = this.gossipTopicCache.getTopic(topicStr);
     const sszType = getGossipSSZType(topic);
+    this.metrics?.dataTransform.inbound.inc({type: topic.type});
 
     if (uncompressedDataLength < sszType.minSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} < ${sszType.minSize}`);
@@ -101,7 +105,9 @@ export class DataTransformSnappy implements DataTransform {
    * Takes the data to be published (a topic and associated data) transforms the data. The
    * transformed data will then be used to create a `RawGossipsubMessage` to be sent to peers.
    */
-  outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
+  outboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
+    const topic = this.gossipTopicCache.getTopic(topicStr);
+    this.metrics?.dataTransform.outbound.inc({type: topic.type});
     if (data.length > this.maxSizePerMessage) {
       throw Error(`ssz_snappy encoded data length ${data.length} > ${this.maxSizePerMessage}`);
     }

package/src/network/gossip/gossipsub.ts

@@ -89,6 +89,13 @@ export class Eth2Gossipsub extends GossipSub {
     const gossipTopicCache = new GossipTopicCache(config);
 
     const scoreParams = computeGossipPeerScoreParams({config, eth2Context: modules.eth2Context});
+    let metrics: Eth2GossipsubMetrics | null = null;
+    if (metricsRegister) {
+      metrics = createEth2GossipsubMetrics(metricsRegister);
+      metrics.gossipMesh.peersByType.addCollect(() =>
+        this.onScrapeLodestarMetrics(metrics as Eth2GossipsubMetrics, networkConfig)
+      );
+    }
 
     // Gossipsub parameters defined here:
     // https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#the-gossip-domain-gossipsub
@@ -116,7 +123,7 @@ export class Eth2Gossipsub extends GossipSub {
       fastMsgIdFn: fastMsgIdFn,
       msgIdFn: msgIdFn.bind(msgIdFn, gossipTopicCache),
       msgIdToStrFn: msgIdToStrFn,
-      dataTransform: new DataTransformSnappy(gossipTopicCache, config.MAX_PAYLOAD_SIZE),
+      dataTransform: new DataTransformSnappy(gossipTopicCache, config.MAX_PAYLOAD_SIZE, metrics),
       metricsRegister: metricsRegister as MetricsRegister | null,
       metricsTopicStrToLabel: metricsRegister
         ? getMetricsTopicStrToLabel(networkConfig, {disableLightClientServer: opts.disableLightClientServer ?? false})
@@ -141,11 +148,6 @@ export class Eth2Gossipsub extends GossipSub {
     this.events = events;
     this.gossipTopicCache = gossipTopicCache;
 
-    if (metricsRegister) {
-      const metrics = createEth2GossipsubMetrics(metricsRegister);
-      metrics.gossipMesh.peersByType.addCollect(() => this.onScrapeLodestarMetrics(metrics, networkConfig));
-    }
-
     this.addEventListener("gossipsub:message", this.onGossipsubMessage.bind(this));
     this.events.on(NetworkEvent.gossipMessageValidationResult, this.onValidationResult.bind(this));
 

package/src/network/gossip/metrics.ts

@@ -67,5 +67,17 @@ export function createEth2GossipsubMetrics(register: RegistryMetricCreator) {
         labelNames: ["subnet", "boundary"],
       }),
     },
+    dataTransform: {
+      inbound: register.counter<{type: GossipType}>({
+        name: "lodestar_gossip_data_transform_inbound_total",
+        help: "Total number of inbound data transforms by gossip type",
+        labelNames: ["type"],
+      }),
+      outbound: register.counter<{type: GossipType}>({
+        name: "lodestar_gossip_data_transform_outbound_total",
+        help: "Total number of outbound data transforms by gossip type",
+        labelNames: ["type"],
+      }),
+    },
   };
 }

package/src/network/interface.ts

@@ -27,7 +27,6 @@ import {
   Slot,
   SlotRootHex,
   SubnetID,
-  WithBytes,
   altair,
   capella,
   deneb,
@@ -69,14 +68,8 @@ export interface INetwork extends INetworkCorePublic {
   reStatusPeers(peers: PeerIdStr[]): Promise<void>;
   searchUnknownSlotRoot(slotRoot: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void;
   // ReqResp
-  sendBeaconBlocksByRange(
-    peerId: PeerIdStr,
-    request: phase0.BeaconBlocksByRangeRequest
-  ): Promise<WithBytes<SignedBeaconBlock>[]>;
-  sendBeaconBlocksByRoot(
-    peerId: PeerIdStr,
-    request: BeaconBlocksByRootRequest
-  ): Promise<WithBytes<SignedBeaconBlock>[]>;
+  sendBeaconBlocksByRange(peerId: PeerIdStr, request: phase0.BeaconBlocksByRangeRequest): Promise<SignedBeaconBlock[]>;
+  sendBeaconBlocksByRoot(peerId: PeerIdStr, request: BeaconBlocksByRootRequest): Promise<SignedBeaconBlock[]>;
   sendBlobSidecarsByRange(peerId: PeerIdStr, request: deneb.BlobSidecarsByRangeRequest): Promise<deneb.BlobSidecar[]>;
   sendBlobSidecarsByRoot(peerId: PeerIdStr, request: BlobSidecarsByRootRequest): Promise<deneb.BlobSidecar[]>;
   sendDataColumnSidecarsByRange(

package/src/network/network.ts

@@ -20,7 +20,6 @@ import {
   SingleAttestation,
   SlotRootHex,
   SubnetID,
-  WithBytes,
   altair,
   capella,
   deneb,
@@ -513,7 +512,7 @@ export class Network implements INetwork {
   async sendBeaconBlocksByRange(
     peerId: PeerIdStr,
     request: phase0.BeaconBlocksByRangeRequest
-  ): Promise<WithBytes<SignedBeaconBlock>[]> {
+  ): Promise<SignedBeaconBlock[]> {
     return collectSequentialBlocksInRange(
       this.sendReqRespRequest(
         peerId,
@@ -526,10 +525,7 @@ export class Network implements INetwork {
     );
   }
 
-  async sendBeaconBlocksByRoot(
-    peerId: PeerIdStr,
-    request: BeaconBlocksByRootRequest
-  ): Promise<WithBytes<SignedBeaconBlock>[]> {
+  async sendBeaconBlocksByRoot(peerId: PeerIdStr, request: BeaconBlocksByRootRequest): Promise<SignedBeaconBlock[]> {
     return collectMaxResponseTypedWithBytes(
       this.sendReqRespRequest(
         peerId,
@@ -539,7 +535,8 @@ export class Network implements INetwork {
         request
       ),
       request.length,
-      responseSszTypeByMethod[ReqRespMethod.BeaconBlocksByRoot]
+      responseSszTypeByMethod[ReqRespMethod.BeaconBlocksByRoot],
+      this.chain.serializedCache
     );
   }
 
@@ -592,7 +589,8 @@ export class Network implements INetwork {
     return collectMaxResponseTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.BlobSidecarsByRoot, [Version.V1], request),
       request.length,
-      responseSszTypeByMethod[ReqRespMethod.BlobSidecarsByRoot]
+      responseSszTypeByMethod[ReqRespMethod.BlobSidecarsByRoot],
+      this.chain.serializedCache
     );
   }
 
@@ -614,7 +612,8 @@ export class Network implements INetwork {
     return collectMaxResponseTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.DataColumnSidecarsByRoot, [Version.V1], request),
       request.reduce((total, {columns}) => total + columns.length, 0),
-      responseSszTypeByMethod[ReqRespMethod.DataColumnSidecarsByRoot]
+      responseSszTypeByMethod[ReqRespMethod.DataColumnSidecarsByRoot],
+      this.chain.serializedCache
     );
   }
 

package/src/network/processor/gossipHandlers.ts

@@ -516,6 +516,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         throw new GossipActionError(GossipAction.REJECT, {code: "PRE_DENEB_BLOCK"});
       }
       const blockInput = await validateBeaconBlob(blobSidecar, topic.subnet, peerIdStr, seenTimestampSec);
+      chain.serializedCache.set(blobSidecar, serializedData);
       if (!blockInput.hasBlockAndAllData()) {
         const cutoffTimeMs = getCutoffTimeMs(chain, blobSlot, BLOCK_AVAILABILITY_CUTOFF_MS);
         chain.logger.debug("Received gossip blob, waiting for full data availability", {
@@ -562,6 +563,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         peerIdStr,
         seenTimestampSec
       );
+      chain.serializedCache.set(dataColumnSidecar, serializedData);
       const blockInputMeta = blockInput.getLogMeta();
       const {receivedColumns} = blockInputMeta;
       // it's not helpful to track every single column received

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

@@ -1,6 +1,6 @@
 import {Type} from "@chainsafe/ssz";
 import {RequestError, RequestErrorCode, ResponseIncoming} from "@lodestar/reqresp";
-import {WithBytes} from "@lodestar/types";
+import {SerializedCache} from "../../../util/serializedCache.ts";
 import {ResponseTypeGetter} from "../types.js";
 
 /**
@@ -32,13 +32,16 @@ export async function collectExactOneTyped<T>(
 export async function collectMaxResponseTyped<T>(
   source: AsyncIterable<ResponseIncoming>,
   maxResponses: number,
-  typeFn: ResponseTypeGetter<T>
+  typeFn: ResponseTypeGetter<T>,
+  serializedCache?: SerializedCache
 ): 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);
+    // optionally cache the serialized response if the cache is available
+    serializedCache?.set(response as object, chunk.data);
     responses.push(response);
 
     if (maxResponses !== undefined && responses.length >= maxResponses) {
@@ -58,14 +61,17 @@ export async function collectMaxResponseTyped<T>(
 export async function collectMaxResponseTypedWithBytes<T>(
   source: AsyncIterable<ResponseIncoming>,
   maxResponses: number,
-  typeFn: ResponseTypeGetter<T>
-): Promise<WithBytes<T>[]> {
+  typeFn: ResponseTypeGetter<T>,
+  serializedCache?: SerializedCache
+): Promise<T[]> {
   // else: zero or more responses
-  const responses: WithBytes<T>[] = [];
+  const responses: 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});
+    responses.push(data);
+    // optionally cache the serialized response if the cache is available
+    serializedCache?.set(data as object, chunk.data);
 
     if (maxResponses !== undefined && responses.length >= maxResponses) {
       break;

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

@@ -1,6 +1,7 @@
 import {ResponseIncoming} from "@lodestar/reqresp";
-import {SignedBeaconBlock, WithBytes, phase0} from "@lodestar/types";
+import {SignedBeaconBlock, phase0} from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
+import {SerializedCache} from "../../../util/serializedCache.ts";
 import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
 import {sszDeserializeResponse} from "./collect.js";
 
@@ -10,9 +11,10 @@ import {sszDeserializeResponse} from "./collect.js";
  */
 export async function collectSequentialBlocksInRange(
   blockStream: AsyncIterable<ResponseIncoming>,
-  {count, startSlot}: Pick<phase0.BeaconBlocksByRangeRequest, "count" | "startSlot">
-): Promise<WithBytes<SignedBeaconBlock>[]> {
-  const blocks: WithBytes<SignedBeaconBlock>[] = [];
+  {count, startSlot}: Pick<phase0.BeaconBlocksByRangeRequest, "count" | "startSlot">,
+  serializedCache?: SerializedCache
+): Promise<SignedBeaconBlock[]> {
+  const blocks: SignedBeaconBlock[] = [];
 
   for await (const chunk of blockStream) {
     const blockType = responseSszTypeByMethod[ReqRespMethod.BeaconBlocksByRange](chunk.fork, chunk.protocolVersion);
@@ -30,11 +32,13 @@ export async function collectSequentialBlocksInRange(
     }
 
     const prevBlock = blocks.at(-1);
-    if (prevBlock && prevBlock.data.message.slot >= blockSlot) {
+    if (prevBlock && prevBlock.message.slot >= blockSlot) {
       throw new BlocksByRangeError({code: BlocksByRangeErrorCode.BAD_SEQUENCE});
     }
 
-    blocks.push({data: block, bytes: chunk.data});
+    blocks.push(block);
+    // optionally cache the serialized response if the cache is available
+    serializedCache?.set(block, chunk.data);
     if (blocks.length >= count) {
       break; // Done, collected all blocks
     }