@lodestar/beacon-node 1.41.0-dev.983b1a457b → 1.41.0-dev.9939b12b53

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

@@ -6,7 +6,7 @@ import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {DataColumnSidecarsByRootRequest} from "../../../util/types.js";
-import {prettyPrintPeerId} from "../../util.ts";
+import {prettyPrintPeerId} from "../../util.js";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -34,7 +34,7 @@ export async function* onDataColumnSidecarsByRoot(
     }
 
     const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
+    const block = chain.forkChoice.getBlockHexDefaultStatus(blockRootHex);
     // If the block is not in fork choice, it may be finalized. Attempt to find its slot in block archive
     const slot = block ? block.slot : await db.blockArchive.getSlotByRoot(blockRoot);
 

package/src/network/reqresp/score.ts

@@ -38,7 +38,6 @@ export function onOutgoingReqRespError(e: RequestError, method: ReqRespMethod):
         : PeerAction.LowToleranceError;
     // TODO: Detect SSZDecodeError and return PeerAction.Fatal
 
-    case RequestErrorCode.TTFB_TIMEOUT:
     case RequestErrorCode.RESP_TIMEOUT:
       switch (method) {
         case ReqRespMethod.Ping:

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

@@ -1,6 +1,6 @@
 import {Type} from "@chainsafe/ssz";
 import {RequestError, RequestErrorCode, ResponseIncoming} from "@lodestar/reqresp";
-import {SerializedCache} from "../../../util/serializedCache.ts";
+import {SerializedCache} from "../../../util/serializedCache.js";
 import {ResponseTypeGetter} from "../types.js";
 
 /**

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

@@ -1,7 +1,7 @@
 import {ResponseIncoming} from "@lodestar/reqresp";
 import {SignedBeaconBlock, phase0} from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
-import {SerializedCache} from "../../../util/serializedCache.ts";
+import {SerializedCache} from "../../../util/serializedCache.js";
 import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
 import {sszDeserializeResponse} from "./collect.js";
 

package/src/network/util.ts

@@ -23,7 +23,7 @@ export function getConnection(libp2p: Libp2p, peerIdStr: string): Connection | u
   return getConnectionsMap(libp2p).get(peerIdStr)?.value[0] ?? undefined;
 }
 
-// https://github.com/ChainSafe/js-libp2p-gossipsub/blob/3475242ed254f7647798ab7f36b21909f6cb61da/src/index.ts#L2009
+// https://github.com/libp2p/js-libp2p/blob/f87cba928991736d9646b3e054c367f55cab315c/packages/gossipsub/src/gossipsub.ts#L2076
 export function isPublishToZeroPeersError(e: Error): boolean {
-  return e.message.includes("PublishError.InsufficientPeers");
+  return e.message.includes("PublishError.NoPeersSubscribedToTopic");
 }

package/src/node/nodejs.ts

@@ -2,12 +2,11 @@ import {setMaxListeners} from "node:events";
 import {PrivateKey} from "@libp2p/interface";
 import {Registry} from "prom-client";
 import {hasher} from "@chainsafe/persistent-merkle-tree";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconApiMethods} from "@lodestar/api/beacon/server";
 import {BeaconConfig} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";
 import {ZERO_HASH_HEX} from "@lodestar/params";
-import {CachedBeaconStateAllForks, Index2PubkeyCache, isExecutionCachedStateType} from "@lodestar/state-transition";
+import {CachedBeaconStateAllForks, PubkeyCache, isExecutionCachedStateType} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
 import {sleep, toRootHex} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
@@ -47,8 +46,7 @@ export type BeaconNodeModules = {
 export type BeaconNodeInitModules = {
   opts: IBeaconNodeOptions;
   config: BeaconConfig;
-  pubkey2index: PubkeyIndexMap;
-  index2pubkey: Index2PubkeyCache;
+  pubkeyCache: PubkeyCache;
   db: IBeaconDb;
   logger: LoggerNode;
   processShutdownCallback: ProcessShutdownCallback;
@@ -150,8 +148,7 @@ export class BeaconNode {
   static async init<T extends BeaconNode = BeaconNode>({
     opts,
     config,
-    pubkey2index,
-    index2pubkey,
+    pubkeyCache,
     db,
     logger,
     processShutdownCallback,
@@ -240,8 +237,7 @@ export class BeaconNode {
       privateKey,
       config,
       clock,
-      pubkey2index,
-      index2pubkey,
+      pubkeyCache,
       dataDir,
       db,
       dbName: opts.db.name,
@@ -364,9 +360,12 @@ export class BeaconNode {
       if (this.restApi) await this.restApi.close();
       await this.network.close();
       if (this.metricsServer) await this.metricsServer.close();
-      if (this.monitoring) this.monitoring.close();
+      if (this.monitoring) await this.monitoring.close();
       await this.chain.persistToDisk();
       await this.chain.close();
+      // Abort signal last: close() calls above clear intervals/timeouts so no new
+      // operations get scheduled. If we aborted first, a still-pending interval could
+      // fire and schedule a new operation after abort, leaving it stuck and delaying shutdown.
       if (this.controller) this.controller.abort();
       await sleep(DELAY_BEFORE_CLOSING_DB_MS);
       await this.db.close();

package/src/sync/range/range.ts

@@ -206,6 +206,7 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
       logger: this.logger,
       peerIdStr: peer.peerId,
       batchBlocks,
+      peerDasMetrics: this.chain.metrics?.peerDas,
       ...batch.getRequestsForPeer(peer),
     });
     const cached = cacheByRangeResponses({

package/src/sync/utils/downloadByRange.ts

@@ -12,6 +12,7 @@ import {
 import {SeenBlockInput} from "../../chain/seenCache/seenGossipBlockInput.js";
 import {validateBlockBlobSidecars} from "../../chain/validation/blobSidecar.js";
 import {validateBlockDataColumnSidecars} from "../../chain/validation/dataColumnSidecar.js";
+import {BeaconMetrics} from "../../metrics/metrics/beacon.js";
 import {INetwork} from "../../network/index.js";
 import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {PeerIdStr} from "../../util/peerId.js";
@@ -35,6 +36,7 @@ export type DownloadAndCacheByRangeProps = DownloadByRangeRequests & {
   logger: Logger;
   peerIdStr: string;
   batchBlocks?: IBlockInput[];
+  peerDasMetrics?: BeaconMetrics["peerDas"] | null;
 };
 
 export type CacheByRangeResponsesProps = {
@@ -196,6 +198,7 @@ export async function downloadByRange({
   blocksRequest,
   blobsRequest,
   columnsRequest,
+  peerDasMetrics,
 }: DownloadAndCacheByRangeProps): Promise<WarnResult<ValidatedResponses, DownloadByRangeError>> {
   let response: DownloadByRangeResponses;
   try {
@@ -220,6 +223,7 @@ export async function downloadByRange({
     blocksRequest,
     blobsRequest,
     columnsRequest,
+    peerDasMetrics,
     ...response,
   });
 
@@ -290,10 +294,12 @@ export async function validateResponses({
   blocks,
   blobSidecars,
   columnSidecars,
+  peerDasMetrics,
 }: DownloadByRangeRequests &
   DownloadByRangeResponses & {
     config: ChainForkConfig;
     batchBlocks?: IBlockInput[];
+    peerDasMetrics?: BeaconMetrics["peerDas"] | null;
   }): Promise<WarnResult<ValidatedResponses, DownloadByRangeError>> {
   // Blocks are always required for blob/column validation
   // If a blocksRequest is provided, blocks have just been downloaded
@@ -372,7 +378,8 @@ export async function validateResponses({
       config,
       columnsRequest,
       blocksForDataValidation,
-      columnSidecars
+      columnSidecars,
+      peerDasMetrics
     );
     validatedResponses.validatedColumnSidecars = validatedColumnSidecarsResult.result;
     warnings = validatedColumnSidecarsResult.warnings;
@@ -608,7 +615,8 @@ export async function validateColumnsByRangeResponse(
   config: ChainForkConfig,
   request: fulu.DataColumnSidecarsByRangeRequest,
   blocks: ValidatedBlock[],
-  columnSidecars: fulu.DataColumnSidecars
+  columnSidecars: fulu.DataColumnSidecars,
+  peerDasMetrics?: BeaconMetrics["peerDas"] | null
 ): Promise<WarnResult<ValidatedColumnSidecars[], DownloadByRangeError>> {
   const warnings: DownloadByRangeError[] = [];
 
@@ -764,7 +772,8 @@ export async function validateColumnsByRangeResponse(
         slot,
         blockRoot,
         blobCount,
-        columnSidecars
+        columnSidecars,
+        peerDasMetrics
       ).then(() => ({
         blockRoot,
         columnSidecars,

package/src/sync/utils/downloadByRoot.ts

@@ -6,7 +6,7 @@ import {LodestarError, byteArrayEquals, fromHex, prettyPrintIndices, toHex, toRo
 import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../../chain/blocks/blockInput/types.js";
 import {ChainEventEmitter} from "../../chain/emitter.js";
-import {IBeaconChain} from "../../chain/interface.ts";
+import {IBeaconChain} from "../../chain/interface.js";
 import {validateBlockBlobSidecars} from "../../chain/validation/blobSidecar.js";
 import {validateBlockDataColumnSidecars} from "../../chain/validation/dataColumnSidecar.js";
 import {INetwork} from "../../network/interface.js";
@@ -440,7 +440,7 @@ export async function fetchAndValidateColumns({
     );
   }
 
-  await validateBlockDataColumnSidecars(chain, slot, blockRoot, blobCount, columnSidecars);
+  await validateBlockDataColumnSidecars(chain, slot, blockRoot, blobCount, columnSidecars, chain?.metrics?.peerDas);
 
   return {result: columnSidecars, warnings: warnings.length > 0 ? warnings : null};
 }

package/src/sync/utils/remoteSyncType.ts

@@ -1,7 +1,7 @@
 import {IForkChoice} from "@lodestar/fork-choice";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Slot, Status} from "@lodestar/types";
-import {IBeaconChain} from "../../chain/interface.ts";
+import {IBeaconChain} from "../../chain/interface.js";
 import {ChainTarget} from "../range/utils/index.js";
 
 /** The type of peer relative to our current state */

package/src/util/blobs.ts

@@ -13,7 +13,7 @@ import {
   VERSIONED_HASH_VERSION_KZG,
 } from "@lodestar/params";
 import {signedBlockToSignedHeader} from "@lodestar/state-transition";
-import {BeaconBlockBody, SSZTypesFor, SignedBeaconBlock, deneb, fulu, ssz} from "@lodestar/types";
+import {BeaconBlockBody, DataColumnSidecars, SSZTypesFor, SignedBeaconBlock, deneb, fulu, ssz} from "@lodestar/types";
 import {kzg} from "./kzg.js";
 
 type VersionHash = Uint8Array;
@@ -149,7 +149,7 @@ export async function dataColumnMatrixRecovery(
  * Reconstruct blobs from a set of data columns, at least 50%+ of all the columns
  * must be provided to allow to reconstruct the full data matrix
  */
-export async function reconstructBlobs(sidecars: fulu.DataColumnSidecars, indices?: number[]): Promise<deneb.Blobs> {
+export async function reconstructBlobs(sidecars: DataColumnSidecars, indices?: number[]): Promise<deneb.Blobs> {
   if (sidecars.length < NUMBER_OF_COLUMNS / 2) {
     throw Error(
       `Expected at least ${NUMBER_OF_COLUMNS / 2} data columns to reconstruct blobs, received ${sidecars.length}`
@@ -188,7 +188,7 @@ export async function reconstructBlobs(sidecars: fulu.DataColumnSidecars, indice
  * Recover cells for specific blob indices from a set of data columns
  */
 async function recoverBlobCells(
-  partialSidecars: fulu.DataColumnSidecar[],
+  partialSidecars: DataColumnSidecars,
   blobIndices: number[]
 ): Promise<Map<number, fulu.Cell[]> | null> {
   const columnCount = partialSidecars.length;

package/src/util/clock.ts

@@ -92,15 +92,17 @@ export class Clock extends EventEmitter implements IClock {
     }
     return slot;
   }
-
   /**
    * If it's too close to next slot given MAXIMUM_GOSSIP_CLOCK_DISPARITY, return currentSlot + 1.
    * Otherwise return currentSlot
+   *
+   * Spec: phase0/p2p-interface.md - gossip validation uses `current_time + MAXIMUM_GOSSIP_CLOCK_DISPARITY < message_time`
+   * to reject future messages (strict `<`), so the boundary (exactly equal) is accepted, hence `<=` here.
    */
   get currentSlotWithGossipDisparity(): Slot {
     const currentSlot = this.currentSlot;
     const nextSlotTime = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime) * 1000;
-    return nextSlotTime - Date.now() < this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY ? currentSlot + 1 : currentSlot;
+    return nextSlotTime - Date.now() <= this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY ? currentSlot + 1 : currentSlot;
   }
 
   get currentEpoch(): Epoch {
@@ -121,6 +123,9 @@ export class Clock extends EventEmitter implements IClock {
 
   /**
    * Check if a slot is current slot given MAXIMUM_GOSSIP_CLOCK_DISPARITY.
+   *
+   * Uses `<=` for disparity checks because the spec rejects with strict `<`
+   * (phase0/p2p-interface.md), meaning the boundary (exactly equal) is accepted.
    */
   isCurrentSlotGivenGossipDisparity(slot: Slot): boolean {
     const currentSlot = this.currentSlot;
@@ -129,12 +134,12 @@ export class Clock extends EventEmitter implements IClock {
     }
     const nextSlotTime = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime) * 1000;
     // we're too close to next slot, accept next slot
-    if (nextSlotTime - Date.now() < this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
+    if (nextSlotTime - Date.now() <= this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
       return slot === currentSlot + 1;
     }
     const currentSlotTime = computeTimeAtSlot(this.config, currentSlot, this.genesisTime) * 1000;
     // we've just passed the current slot, accept previous slot
-    if (Date.now() - currentSlotTime < this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
+    if (Date.now() - currentSlotTime <= this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
       return slot === currentSlot - 1;
     }
     return false;

package/src/util/dataColumns.ts

@@ -4,6 +4,7 @@ import {ChainForkConfig} from "@lodestar/config";
 import {
   ForkAll,
   ForkName,
+  ForkPostDeneb,
   ForkPostFulu,
   ForkPreGloas,
   KZG_COMMITMENTS_GINDEX,
@@ -15,9 +16,11 @@ import {
   BeaconBlockBody,
   ColumnIndex,
   CustodyIndex,
+  Root,
   SSZTypesFor,
   SignedBeaconBlock,
   SignedBeaconBlockHeader,
+  Slot,
   deneb,
   fulu,
   gloas,
@@ -269,7 +272,7 @@ export async function getCellsAndProofs(
  */
 export function getBlobKzgCommitments(
   fork: ForkName,
-  signedBlock: SignedBeaconBlock<ForkPostFulu>
+  signedBlock: SignedBeaconBlock<ForkPostDeneb>
 ): deneb.KZGCommitment[] {
   if (isForkPostGloas(fork)) {
     return (signedBlock as gloas.SignedBeaconBlock).message.body.signedExecutionPayloadBid.message.blobKzgCommitments;
@@ -359,6 +362,39 @@ export function getDataColumnSidecarsFromColumnSidecar(
   );
 }
 
+/**
+ * In Gloas, data column sidecars have a simplified structure with `slot` and `beaconBlockRoot`
+ * instead of `signedBlockHeader`, `kzgCommitments`, and `kzgCommitmentsInclusionProof`.
+ */
+export function getDataColumnSidecarsForGloas(
+  slot: Slot,
+  beaconBlockRoot: Root,
+  cellsAndKzgProofs: {cells: Uint8Array[]; proofs: Uint8Array[]}[]
+): gloas.DataColumnSidecars {
+  // No need to create data column sidecars if there are no blobs
+  if (cellsAndKzgProofs.length === 0) {
+    return [];
+  }
+
+  const sidecars: gloas.DataColumnSidecars = [];
+  for (let columnIndex = 0; columnIndex < NUMBER_OF_COLUMNS; columnIndex++) {
+    const column: Uint8Array[] = [];
+    const kzgProofs: Uint8Array[] = [];
+    for (const {cells, proofs} of cellsAndKzgProofs) {
+      column.push(cells[columnIndex]);
+      kzgProofs.push(proofs[columnIndex]);
+    }
+    sidecars.push({
+      index: columnIndex,
+      column,
+      kzgProofs,
+      slot,
+      beaconBlockRoot,
+    });
+  }
+  return sidecars;
+}
+
 /**
  * If we receive more than half of NUMBER_OF_COLUMNS (64) we should recover all remaining columns
  */
@@ -389,7 +425,8 @@ export async function recoverDataColumnSidecars(
     partialSidecars.set(columnSidecar.index, columnSidecar);
   }
 
-  const timer = metrics?.recoverDataColumnSidecars.recoverTime.startTimer();
+  const timer = metrics?.peerDas.dataColumnsReconstructionTime.startTimer();
+
   // if this function throws, we catch at the consumer side
   const fullSidecars = await dataColumnMatrixRecovery(partialSidecars).catch(() => null);
   timer?.();
@@ -399,6 +436,7 @@ export async function recoverDataColumnSidecars(
 
   if (blockInput.getAllColumns().length === NUMBER_OF_COLUMNS) {
     // either gossip or getBlobsV2 resolved availability while we were recovering
+    metrics?.dataColumns.alreadyAdded.inc(fullSidecars.length);
     return DataColumnReconstructionCode.SuccessLate;
   }
 
@@ -422,8 +460,10 @@ export async function recoverDataColumnSidecars(
       sidecarsToPublish.push(columnSidecar);
     }
   }
+  metrics?.peerDas.reconstructedColumns.inc(sidecarsToPublish.length);
+  metrics?.dataColumns.bySource.inc({source: BlockInputSource.recovery}, sidecarsToPublish.length);
   emitter.emit(ChainEvent.publishDataColumns, sidecarsToPublish);
-
+  // TODO: Can we record dataColumns.sentPeersPerSubnet metric somehow
   return DataColumnReconstructionCode.SuccessResolved;
 }
 

package/src/util/execution.ts

@@ -173,16 +173,21 @@ export async function getDataColumnSidecarsFromExecution(
   }
 
   let dataColumnSidecars: fulu.DataColumnSidecars;
-  const cellsAndProofs = await getCellsAndProofs(blobs);
-  if (blockInput.hasBlock()) {
-    dataColumnSidecars = getDataColumnSidecarsFromBlock(
-      config,
-      blockInput.getBlock() as fulu.SignedBeaconBlock,
-      cellsAndProofs
-    );
-  } else {
-    const firstSidecar = blockInput.getAllColumns()[0];
-    dataColumnSidecars = getDataColumnSidecarsFromColumnSidecar(firstSidecar, cellsAndProofs);
+  const compTimer = metrics?.peerDas.dataColumnSidecarComputationTime.startTimer();
+  try {
+    const cellsAndProofs = await getCellsAndProofs(blobs);
+    if (blockInput.hasBlock()) {
+      dataColumnSidecars = getDataColumnSidecarsFromBlock(
+        config,
+        blockInput.getBlock() as fulu.SignedBeaconBlock,
+        cellsAndProofs
+      );
+    } else {
+      const firstSidecar = blockInput.getAllColumns()[0];
+      dataColumnSidecars = getDataColumnSidecarsFromColumnSidecar(firstSidecar, cellsAndProofs);
+    }
+  } finally {
+    compTimer?.();
   }
 
   // Publish columns if and only if subscribed to them
@@ -191,13 +196,15 @@ export async function getDataColumnSidecarsFromExecution(
 
   // for columns that we already seen, it will be ignored through `ignoreDuplicatePublishError` gossip option
   emitter.emit(ChainEvent.publishDataColumns, sampledColumns);
+  // TODO: Can we record dataColumns.sentPeersPerSubnet metric here somehow
 
   // add all sampled columns to the block input, even if we didn't sample them
   const seenTimestampSec = Date.now() / 1000;
+  let alreadyAddedColumnsCount = 0;
   for (const columnSidecar of sampledColumns) {
     if (blockInput.hasColumn(columnSidecar.index)) {
       // columns may have been added while waiting
-      // TODO(fulu): add metrics for this condition
+      alreadyAddedColumnsCount++;
       continue;
     }
 
@@ -217,7 +224,11 @@ export async function getDataColumnSidecarsFromExecution(
       });
     }
   }
+  metrics?.dataColumns.alreadyAdded.inc(alreadyAddedColumnsCount);
 
-  metrics?.dataColumns.bySource.inc({source: BlockInputSource.engine}, previouslyMissingColumns.length);
+  metrics?.dataColumns.bySource.inc(
+    {source: BlockInputSource.engine},
+    previouslyMissingColumns.length - alreadyAddedColumnsCount
+  );
   return DataColumnEngineResult.SuccessResolved;
 }

package/src/util/multifork.ts

@@ -9,6 +9,11 @@ import {getSlotFromSignedBeaconBlockSerialized} from "./sszBytes.js";
  */
 const SLOT_BYTE_COUNT = 8;
 
+/**
+ * SSZ offset uint32
+ */
+const OFFSET_BYTE_COUNT = 4;
+
 /**
  * 8 + 32 = 40
  * ```
@@ -67,3 +72,43 @@ export function getLightClientHeaderTypeFromBytes(
   );
   return config.getPostAltairForkTypes(slot).LightClientHeader;
 }
+
+/**
+ * Position of first offset in DataColumnSidecar (after index field)
+ *
+ * Fulu DataColumnSidecar (6 fields):
+ *   index: uint64 [fixed - 8 bytes]
+ *   column: List [variable - 4-byte offset]
+ *   kzgCommitments: List [variable - 4-byte offset]
+ *   kzgProofs: List [variable - 4-byte offset]
+ *   signedBlockHeader: Container [fixed - 208 bytes]
+ *   kzgCommitmentsInclusionProof: Vector[Bytes32, 4] [fixed - 128 bytes]
+ *   => First offset value = 8 + 4 + 4 + 4 + 208 + 128 = 356
+ *
+ * Gloas DataColumnSidecar (5 fields):
+ *   index: uint64 [fixed - 8 bytes]
+ *   column: List [variable - 4-byte offset]
+ *   kzgProofs: List [variable - 4-byte offset]
+ *   slot: uint64 [fixed - 8 bytes]
+ *   beaconBlockRoot: Bytes32 [fixed - 32 bytes]
+ *   => First offset value = 8 + 4 + 4 + 8 + 32 = 56
+ */
+const FIRST_OFFSET_POSITION_IN_DATA_COLUMN_SIDECAR = 8;
+const GLOAS_DATA_COLUMN_SIDECAR_FIRST_OFFSET = 56;
+
+/**
+ * Determines if DataColumnSidecar bytes are from Gloas fork by checking the SSZ offset structure.
+ *
+ * The first offset (bytes 8-12) indicates where variable-size data begins:
+ * - Gloas: 56 (small fixed section)
+ * - Fulu: 356
+ */
+export function isGloasDataColumnSidecarBytes(bytes: Uint8Array): boolean {
+  const firstOffset = bytesToInt(
+    bytes.subarray(
+      FIRST_OFFSET_POSITION_IN_DATA_COLUMN_SIDECAR,
+      FIRST_OFFSET_POSITION_IN_DATA_COLUMN_SIDECAR + OFFSET_BYTE_COUNT
+    )
+  );
+  return firstOffset === GLOAS_DATA_COLUMN_SIDECAR_FIRST_OFFSET;
+}

package/src/util/serializedCache.ts

@@ -4,7 +4,7 @@
  * This is a thin wrapper around WeakMap
  */
 export class SerializedCache {
-  map: WeakMap<object, Uint8Array> = new WeakMap();
+  private map: WeakMap<object, Uint8Array> = new WeakMap();
 
   get(obj: object): Uint8Array | undefined {
     return this.map.get(obj);
@@ -15,11 +15,13 @@ export class SerializedCache {
   }
 
   /**
-   * Replace the internal WeakMap to force GC of all cached entries.
-   * Must only be called after all DB writes that may read from this cache have completed,
+   * Delete cached serialized entries for the provided object references.
+   * Must only be called after all DB writes that read from this cache for these objects have completed,
    * otherwise cached serialized bytes will be unavailable and data will be re-serialized unnecessarily.
    */
-  clear(): void {
-    this.map = new WeakMap();
+  delete(objs: object[]): void {
+    for (const obj of objs) {
+      this.map.delete(obj);
+    }
   }
 }

package/src/util/workerEvents.ts

@@ -1,5 +1,5 @@
 import {MessagePort, Worker} from "node:worker_threads";
-import {Message} from "@libp2p/interface";
+import type {Message} from "@libp2p/gossipsub";
 import {Thread} from "@chainsafe/threads";
 import {Logger} from "@lodestar/logger";
 import {sleep} from "@lodestar/utils";