@lodestar/beacon-node 1.36.0-dev.9dbc67b579 → 1.36.0-dev.9f2bb12ea7

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.36.0-dev.9dbc67b579",
+  "version": "1.36.0-dev.9f2bb12ea7",
   "type": "module",
   "exports": {
     ".": {
@@ -83,6 +83,10 @@
     "#datastore-wrapper": {
       "bun": "./src/network/peers/datastore_bun.ts",
       "default": "datastore-level"
+    },
+    "#snappy": {
+      "bun": "./src/network/gossip/snappy_bun.ts",
+      "default": "snappyjs"
     }
   },
   "files": [
@@ -140,18 +144,19 @@
     "@libp2p/peer-id": "^5.1.0",
     "@libp2p/prometheus-metrics": "^4.3.15",
     "@libp2p/tcp": "^10.1.8",
-    "@lodestar/api": "1.36.0-dev.9dbc67b579",
-    "@lodestar/config": "1.36.0-dev.9dbc67b579",
-    "@lodestar/db": "1.36.0-dev.9dbc67b579",
-    "@lodestar/fork-choice": "1.36.0-dev.9dbc67b579",
-    "@lodestar/light-client": "1.36.0-dev.9dbc67b579",
-    "@lodestar/logger": "1.36.0-dev.9dbc67b579",
-    "@lodestar/params": "1.36.0-dev.9dbc67b579",
-    "@lodestar/reqresp": "1.36.0-dev.9dbc67b579",
-    "@lodestar/state-transition": "1.36.0-dev.9dbc67b579",
-    "@lodestar/types": "1.36.0-dev.9dbc67b579",
-    "@lodestar/utils": "1.36.0-dev.9dbc67b579",
-    "@lodestar/validator": "1.36.0-dev.9dbc67b579",
+    "@lodestar/api": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/bun": "git+https://github.com/ChainSafe/lodestar-bun.git",
+    "@lodestar/config": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/db": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/fork-choice": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/light-client": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/logger": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/params": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/reqresp": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/state-transition": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/types": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/utils": "1.36.0-dev.9f2bb12ea7",
+    "@lodestar/validator": "1.36.0-dev.9f2bb12ea7",
     "@multiformats/multiaddr": "^12.1.3",
     "datastore-core": "^10.0.2",
     "datastore-fs": "^10.0.6",
@@ -187,5 +192,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "3f729ae94a582b5f66f65f3dd9149e64137436bd"
+  "gitHead": "c7d8a024f794f71d2d91d371c68201273356a226"
 }

package/src/api/impl/beacon/blocks/index.ts

@@ -654,18 +654,21 @@ export function getBeaconBlockApi({
             );
           }
 
-          const blobs = await reconstructBlobs(dataColumnSidecars);
+          for (const index of indices ?? []) {
+            if (index < 0 || index >= blobCount) {
+              throw new ApiError(400, `Invalid blob index ${index}, must be between 0 and ${blobCount - 1}`);
+            }
+          }
+
+          const indicesToReconstruct = indices ?? Array.from({length: blobCount}, (_, i) => i);
+          const blobs = await reconstructBlobs(dataColumnSidecars, indicesToReconstruct);
           const signedBlockHeader = signedBlockToSignedHeader(config, block);
-          const requestedIndices = indices ?? Array.from({length: blobKzgCommitments.length}, (_, i) => i);
 
           data = await Promise.all(
-            requestedIndices.map(async (index) => {
+            indicesToReconstruct.map(async (index, i) => {
               // Reconstruct blob sidecar from blob
               const kzgCommitment = blobKzgCommitments[index];
-              if (kzgCommitment === undefined) {
-                throw new ApiError(400, `Blob index ${index} not found in block`);
-              }
-              const blob = blobs[index];
+              const blob = blobs[i]; // Use i since blobs only contains requested indices
               const kzgProof = await kzg.asyncComputeBlobKzgProof(blob, kzgCommitment);
               const kzgCommitmentInclusionProof = computePreFuluKzgCommitmentsInclusionProof(
                 fork,
@@ -724,7 +727,8 @@ export function getBeaconBlockApi({
           );
         }
 
-        const blobCount = (block.message.body as deneb.BeaconBlockBody).blobKzgCommitments.length;
+        const blobKzgCommitments = (block.message.body as deneb.BeaconBlockBody).blobKzgCommitments;
+        const blobCount = blobKzgCommitments.length;
 
         if (blobCount > 0) {
           let dataColumnSidecars = await fromAsync(db.dataColumnSidecar.valuesStream(blockRoot));
@@ -739,7 +743,25 @@ export function getBeaconBlockApi({
             );
           }
 
-          blobs = await reconstructBlobs(dataColumnSidecars);
+          let indicesToReconstruct: number[];
+          if (versionedHashes) {
+            const blockVersionedHashes = blobKzgCommitments.map((commitment) =>
+              toHex(kzgCommitmentToVersionedHash(commitment))
+            );
+            indicesToReconstruct = [];
+            for (const requestedHash of versionedHashes) {
+              const index = blockVersionedHashes.findIndex((hash) => hash === requestedHash);
+              if (index === -1) {
+                throw new ApiError(400, `Versioned hash ${requestedHash} not found in block`);
+              }
+              indicesToReconstruct.push(index);
+            }
+            indicesToReconstruct.sort((a, b) => a - b);
+          } else {
+            indicesToReconstruct = Array.from({length: blobCount}, (_, i) => i);
+          }
+
+          blobs = await reconstructBlobs(dataColumnSidecars, indicesToReconstruct);
         } else {
           blobs = [];
         }
@@ -757,27 +779,27 @@ export function getBeaconBlockApi({
         }
 
         blobs = blobSidecars.sort((a, b) => a.index - b.index).map(({blob}) => blob);
-      } else {
-        blobs = [];
-      }
 
-      if (blobs.length && versionedHashes?.length) {
-        const kzgCommitments = (block as deneb.SignedBeaconBlock).message.body.blobKzgCommitments;
+        if (blobs.length && versionedHashes) {
+          const kzgCommitments = (block as deneb.SignedBeaconBlock).message.body.blobKzgCommitments;
 
-        const blockVersionedHashes = kzgCommitments.map((commitment) =>
-          toHex(kzgCommitmentToVersionedHash(commitment))
-        );
+          const blockVersionedHashes = kzgCommitments.map((commitment) =>
+            toHex(kzgCommitmentToVersionedHash(commitment))
+          );
 
-        const requestedIndices: number[] = [];
-        for (const requestedHash of versionedHashes) {
-          const index = blockVersionedHashes.findIndex((hash) => hash === requestedHash);
-          if (index === -1) {
-            throw new ApiError(400, `Versioned hash ${requestedHash} not found in block`);
+          const requestedIndices: number[] = [];
+          for (const requestedHash of versionedHashes) {
+            const index = blockVersionedHashes.findIndex((hash) => hash === requestedHash);
+            if (index === -1) {
+              throw new ApiError(400, `Versioned hash ${requestedHash} not found in block`);
+            }
+            requestedIndices.push(index);
           }
-          requestedIndices.push(index);
-        }
 
-        blobs = requestedIndices.sort((a, b) => a - b).map((index) => blobs[index]);
+          blobs = requestedIndices.sort((a, b) => a - b).map((index) => blobs[index]);
+        }
+      } else {
+        blobs = [];
       }
 
       return {

package/src/chain/chain.ts

@@ -271,8 +271,7 @@ export class BeaconChain implements IBeaconChain {
     this.seenAttestationDatas = new SeenAttestationDatas(metrics, this.opts?.attDataCacheSlotDistance);
 
     const nodeId = computeNodeIdFromPrivateKey(privateKey);
-    const initialCustodyGroupCount =
-      opts.initialCustodyGroupCount ?? (opts.supernode ? config.NUMBER_OF_CUSTODY_GROUPS : config.CUSTODY_REQUIREMENT);
+    const initialCustodyGroupCount = opts.initialCustodyGroupCount ?? config.CUSTODY_REQUIREMENT;
     this.metrics?.peerDas.targetCustodyGroupCount.set(initialCustodyGroupCount);
     this.custodyConfig = new CustodyConfig({
       nodeId,
@@ -1241,9 +1240,10 @@ export class BeaconChain implements IBeaconChain {
   }
 
   private async updateValidatorsCustodyRequirement(finalizedCheckpoint: CheckpointWithHex): Promise<void> {
-    if (this.opts.supernode) {
-      // Disable dynamic custody updates for supernodes since they must maintain custody
-      // of all custody groups regardless of validator effective balances
+    if (this.custodyConfig.targetCustodyGroupCount === this.config.NUMBER_OF_CUSTODY_GROUPS) {
+      // Custody requirements can only be increased, we can disable dynamic custody updates
+      // if the node already maintains custody of all custody groups in case it is configured
+      // as a supernode or has validators attached with a total effective balance of at least 4096 ETH.
       return;
     }
 

package/src/chain/errors/dataColumnSidecarError.ts

@@ -12,10 +12,14 @@ export enum DataColumnSidecarErrorCode {
 
   // Validation errors when validating against an existing block
 
+  /** Block and sidecars header root mismatch */
+  INCORRECT_HEADER_ROOT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_HEADER_ROOT",
   /** Block and sidecars data column count mismatch */
   INCORRECT_SIDECAR_COUNT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_SIDECAR_COUNT",
   /** Sidecar doesn't match block */
   INCORRECT_BLOCK = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_BLOCK",
+  /** Sidecar cell count not as expected */
+  INCORRECT_CELL_COUNT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_CELL_COUNT",
   /** Sidecar kzg proof count not as expected */
   INCORRECT_KZG_COMMITMENTS_COUNT = "DATA_COLUMN_SIDECAR_ERROR_INCORRECT_KZG_COMMITMENTS_COUNT",
   /** Sidecar kzg proof count not as expected */
@@ -35,49 +39,51 @@ export enum DataColumnSidecarErrorCode {
 }
 
 export type DataColumnSidecarErrorType =
-  | {code: DataColumnSidecarErrorCode.INVALID_INDEX; slot: Slot; columnIdx: number}
-  | {code: DataColumnSidecarErrorCode.NO_COMMITMENTS; slot: Slot; columnIdx: number}
+  | {code: DataColumnSidecarErrorCode.INVALID_INDEX; slot: Slot; columnIndex: number}
+  | {code: DataColumnSidecarErrorCode.NO_COMMITMENTS; slot: Slot; columnIndex: number}
   | {
       code: DataColumnSidecarErrorCode.MISMATCHED_LENGTHS;
       columnLength: number;
       commitmentsLength: number;
       proofsLength: number;
     }
-  | {code: DataColumnSidecarErrorCode.INVALID_SUBNET; columnIdx: number; gossipSubnet: SubnetID}
+  | {code: DataColumnSidecarErrorCode.INVALID_SUBNET; columnIndex: number; gossipSubnet: SubnetID}
   | {
       code: DataColumnSidecarErrorCode.TOO_MANY_KZG_COMMITMENTS;
       slot: number;
-      columnIdx: number;
+      columnIndex: number;
       count: number;
       limit: number;
     }
-  | {code: DataColumnSidecarErrorCode.ALREADY_KNOWN; columnIdx: number; slot: Slot}
+  | {code: DataColumnSidecarErrorCode.ALREADY_KNOWN; columnIndex: number; slot: Slot}
   | {code: DataColumnSidecarErrorCode.FUTURE_SLOT; blockSlot: Slot; currentSlot: Slot}
   | {code: DataColumnSidecarErrorCode.WOULD_REVERT_FINALIZED_SLOT; blockSlot: Slot; finalizedSlot: Slot}
   | {code: DataColumnSidecarErrorCode.PARENT_UNKNOWN; parentRoot: RootHex}
   | {code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID}
   | {code: DataColumnSidecarErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
-  | {code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID; slot: Slot; columnIdx: number}
-  | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF; slot: Slot; columnIdx: number}
+  | {code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID; slot: Slot; columnIndex: number}
+  | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF; slot: Slot; columnIndex: number}
   | {code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_COUNT; slot: number; expected: number; actual: number}
   | {
       code: DataColumnSidecarErrorCode.INCORRECT_BLOCK;
       slot: number;
-      columnIdx: number;
+      columnIndex: number;
       expected: string;
       actual: string;
     }
   | {
-      code: DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT;
+      code: DataColumnSidecarErrorCode.INCORRECT_HEADER_ROOT;
       slot: number;
-      columnIdx: number;
-      expected: number;
-      actual: number;
+      expected: string;
+      actual: string;
     }
   | {
-      code: DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT;
+      code:
+        | DataColumnSidecarErrorCode.INCORRECT_CELL_COUNT
+        | DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT
+        | DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT;
       slot: number;
-      columnIdx: number;
+      columnIndex: number;
       expected: number;
       actual: number;
     }

package/src/chain/options.ts

@@ -8,6 +8,7 @@ import {ShufflingCacheOpts} from "./shufflingCache.js";
 import {DEFAULT_MAX_BLOCK_STATES, FIFOBlockStateCacheOpts} from "./stateCache/fifoBlockStateCache.js";
 import {
   DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY,
+  DEFAULT_MAX_CP_STATE_ON_DISK,
   PersistentCheckpointStateCacheOpts,
 } from "./stateCache/persistentCheckpointsCache.js";
 import {ValidatorMonitorOpts} from "./validatorMonitor.js";
@@ -41,8 +42,6 @@ export type IChainOptions = BlockProcessOpts &
     maxCachedBlobSidecars?: number;
     /** Max number of produced block roots (blinded or full) cached for broadcast validations */
     maxCachedProducedRoots?: number;
-    /** Subscribe to and custody all data column sidecar subnets */
-    supernode?: boolean;
     initialCustodyGroupCount?: number;
     broadcastValidationStrictness?: string;
     minSameMessageSignatureSetsToBatch: number;
@@ -118,7 +117,6 @@ export const defaultChainOptions: IChainOptions = {
   archiveMode: DEFAULT_ARCHIVE_MODE,
   pruneHistory: false,
   emitPayloadAttributes: false,
-  supernode: false,
   // for gossip block validation, it's unlikely we see a reorg with 32 slots
   // for attestation validation, having this value ensures we don't have to regen states most of the time
   maxSkipSlots: 32,
@@ -135,4 +133,5 @@ export const defaultChainOptions: IChainOptions = {
   nHistoricalStatesFileDataStore: true,
   maxBlockStates: DEFAULT_MAX_BLOCK_STATES,
   maxCPStateEpochsInMemory: DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY,
+  maxCPStateEpochsOnDisk: DEFAULT_MAX_CP_STATE_ON_DISK,
 };

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -17,8 +17,10 @@ import {MapTracker} from "./mapMetrics.js";
 import {BlockStateCache, CacheItemType, CheckpointHex, CheckpointStateCache} from "./types.js";
 
 export type PersistentCheckpointStateCacheOpts = {
-  /** Keep max n states in memory, persist the rest to disk */
+  /** Keep max n state epochs in memory, persist the rest to disk */
   maxCPStateEpochsInMemory?: number;
+  /** Keep max n state epochs on disk */
+  maxCPStateEpochsOnDisk?: number;
 };
 
 type PersistentCheckpointStateCacheModules = {
@@ -58,6 +60,14 @@ type LoadedStateBytesData = {persistedKey: DatastoreKey; stateBytes: Uint8Array}
  */
 export const DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY = 3;
 
+/**
+ * By default we don't prune any persistent checkpoint states as it's not safe to delete them during
+ * long non-finality as we don't know the state of the chain and there could be a deep (hundreds of epochs) reorg
+ * if there two competing chains with similar weight but we wouldn't have a close enough state to pivot to this chain
+ * and instead require a resync from last finalized checkpoint state which could be very far in the past.
+ */
+export const DEFAULT_MAX_CP_STATE_ON_DISK = Infinity;
+
 // TODO GLOAS: re-evaluate this timing
 const PROCESS_CHECKPOINT_STATES_BPS = 6667;
 
@@ -104,6 +114,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   private preComputedCheckpoint: string | null = null;
   private preComputedCheckpointHits: number | null = null;
   private readonly maxEpochsInMemory: number;
+  private readonly maxEpochsOnDisk: number;
   private readonly datastore: CPStateDatastore;
   private readonly blockStateCache: BlockStateCache;
   private readonly bufferPool?: BufferPool | null;
@@ -139,10 +150,16 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     this.logger = logger;
     this.clock = clock;
     this.signal = signal;
+
     if (opts.maxCPStateEpochsInMemory !== undefined && opts.maxCPStateEpochsInMemory < 0) {
       throw new Error("maxEpochsInMemory must be >= 0");
     }
+    if (opts.maxCPStateEpochsOnDisk !== undefined && opts.maxCPStateEpochsOnDisk < 0) {
+      throw new Error("maxCPStateEpochsOnDisk must be >= 0");
+    }
+
     this.maxEpochsInMemory = opts.maxCPStateEpochsInMemory ?? DEFAULT_MAX_CP_STATE_EPOCHS_IN_MEMORY;
+    this.maxEpochsOnDisk = opts.maxCPStateEpochsOnDisk ?? DEFAULT_MAX_CP_STATE_ON_DISK;
     // Specify different datastore for testing
     this.datastore = datastore;
     this.blockStateCache = blockStateCache;
@@ -324,6 +341,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       this.logger.verbose("Added checkpoint state to memory", {epoch: cp.epoch, rootHex: cpHex.rootHex});
     }
     this.epochIndex.getOrDefault(cp.epoch).add(cpHex.rootHex);
+    this.prunePersistedStates();
   }
 
   /**
@@ -766,13 +784,38 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       this.cache.delete(key);
     }
     this.epochIndex.delete(epoch);
-    this.logger.verbose("Pruned finalized checkpoints states for epoch", {
+    this.logger.verbose("Pruned checkpoint states for epoch", {
       epoch,
       persistCount,
       rootHexes: Array.from(rootHexes).join(","),
     });
   }
 
+  /**
+   * Prune persisted checkpoint states from disk.
+   * Note that this should handle all possible errors and not throw.
+   */
+  private prunePersistedStates(): void {
+    //                epochsOnDisk                                   epochsInMemory
+    // |----------------------------------------------------------|----------------------|
+    const maxTrackedEpochs = this.maxEpochsOnDisk + this.maxEpochsInMemory;
+    if (this.epochIndex.size <= maxTrackedEpochs) {
+      return;
+    }
+
+    const sortedEpochs = Array.from(this.epochIndex.keys()).sort((a, b) => a - b);
+    const pruneEpochs = sortedEpochs.slice(0, sortedEpochs.length - maxTrackedEpochs);
+    for (const epoch of pruneEpochs) {
+      this.deleteAllEpochItems(epoch).catch((e) =>
+        this.logger.debug(
+          "Error delete all epoch items",
+          {epoch, maxEpochsOnDisk: this.maxEpochsOnDisk, maxEpochsInMemory: this.maxEpochsInMemory},
+          e as Error
+        )
+      );
+    }
+  }
+
   /**
    * Serialize validators to bytes leveraging the buffer pool to save memory allocation.
    *   - As monitored on holesky as of Jan 2024, it helps save ~500ms state reload time (4.3s vs 3.8s)

package/src/chain/validation/dataColumnSidecar.ts

@@ -39,7 +39,7 @@ export async function validateGossipDataColumnSidecar(
   if (computeSubnetForDataColumnSidecar(chain.config, dataColumnSidecar) !== gossipSubnet) {
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.INVALID_SUBNET,
-      columnIdx: dataColumnSidecar.index,
+      columnIndex: dataColumnSidecar.index,
       gossipSubnet: gossipSubnet,
     });
   }
@@ -156,7 +156,7 @@ export async function validateGossipDataColumnSidecar(
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID,
       slot: dataColumnSidecar.signedBlockHeader.message.slot,
-      columnIdx: dataColumnSidecar.index,
+      columnIndex: dataColumnSidecar.index,
     });
   }
 
@@ -173,7 +173,7 @@ export async function validateGossipDataColumnSidecar(
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF,
       slot: blockHeader.slot,
-      columnIdx: dataColumnSidecar.index,
+      columnIndex: dataColumnSidecar.index,
     });
   } finally {
     kzgProofTimer?.();
@@ -193,7 +193,7 @@ function verifyDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: ful
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.INVALID_INDEX,
       slot: dataColumnSidecar.signedBlockHeader.message.slot,
-      columnIdx: dataColumnSidecar.index,
+      columnIndex: dataColumnSidecar.index,
     });
   }
 
@@ -201,7 +201,7 @@ function verifyDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: ful
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.NO_COMMITMENTS,
       slot: dataColumnSidecar.signedBlockHeader.message.slot,
-      columnIdx: dataColumnSidecar.index,
+      columnIndex: dataColumnSidecar.index,
     });
   }
 
@@ -212,7 +212,7 @@ function verifyDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: ful
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.TOO_MANY_KZG_COMMITMENTS,
       slot: dataColumnSidecar.signedBlockHeader.message.slot,
-      columnIdx: dataColumnSidecar.index,
+      columnIndex: dataColumnSidecar.index,
       count: dataColumnSidecar.kzgCommitments.length,
       limit: maxBlobsPerBlock,
     });
@@ -293,7 +293,6 @@ export async function validateBlockDataColumnSidecars(
       "Block has no blob commitments but data column sidecars were provided"
     );
   }
-
   // Hash the first sidecar block header and compare the rest via (cheaper) equality
   const firstSidecarBlockHeader = dataColumnSidecars[0].signedBlockHeader.message;
   const firstBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(firstSidecarBlockHeader);
@@ -302,7 +301,7 @@ export async function validateBlockDataColumnSidecars(
       {
         code: DataColumnSidecarErrorCode.INCORRECT_BLOCK,
         slot: blockSlot,
-        columnIdx: 0,
+        columnIndex: 0,
         expected: toRootHex(blockRoot),
         actual: toRootHex(firstBlockRoot),
       },
@@ -317,33 +316,52 @@ export async function validateBlockDataColumnSidecars(
   for (let i = 0; i < dataColumnSidecars.length; i++) {
     const columnSidecar = dataColumnSidecars[i];
 
+    if (!ssz.phase0.BeaconBlockHeader.equals(firstSidecarBlockHeader, columnSidecar.signedBlockHeader.message)) {
+      throw new DataColumnSidecarValidationError({
+        code: DataColumnSidecarErrorCode.INCORRECT_HEADER_ROOT,
+        slot: blockSlot,
+        expected: toRootHex(blockRoot),
+        actual: toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(columnSidecar.signedBlockHeader.message)),
+      });
+    }
+
     if (columnSidecar.index >= NUMBER_OF_COLUMNS) {
       throw new DataColumnSidecarValidationError(
         {
           code: DataColumnSidecarErrorCode.INVALID_INDEX,
           slot: blockSlot,
-          columnIdx: columnSidecar.index,
+          columnIndex: columnSidecar.index,
         },
         "DataColumnSidecar has invalid index"
       );
     }
 
-    if (columnSidecar.kzgCommitments.length !== blockBlobCount) {
+    if (columnSidecar.column.length !== blockBlobCount) {
       throw new DataColumnSidecarValidationError({
-        code: DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT,
+        code: DataColumnSidecarErrorCode.INCORRECT_CELL_COUNT,
         slot: blockSlot,
-        columnIdx: columnSidecar.index,
+        columnIndex: columnSidecar.index,
         expected: blockBlobCount,
+        actual: columnSidecar.column.length,
+      });
+    }
+
+    if (columnSidecar.column.length !== columnSidecar.kzgCommitments.length) {
+      throw new DataColumnSidecarValidationError({
+        code: DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT,
+        slot: blockSlot,
+        columnIndex: columnSidecar.index,
+        expected: columnSidecar.column.length,
         actual: columnSidecar.kzgCommitments.length,
       });
     }
 
-    if (columnSidecar.kzgProofs.length !== columnSidecar.kzgCommitments.length) {
+    if (columnSidecar.column.length !== columnSidecar.kzgProofs.length) {
       throw new DataColumnSidecarValidationError({
         code: DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT,
         slot: blockSlot,
-        columnIdx: columnSidecar.index,
-        expected: columnSidecar.kzgCommitments.length,
+        columnIndex: columnSidecar.index,
+        expected: columnSidecar.column.length,
         actual: columnSidecar.kzgProofs.length,
       });
     }
@@ -353,7 +371,7 @@ export async function validateBlockDataColumnSidecars(
         {
           code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID,
           slot: blockSlot,
-          columnIdx: columnSidecar.index,
+          columnIndex: columnSidecar.index,
         },
         "DataColumnSidecar has invalid inclusion proof"
       );

package/src/network/core/networkCore.ts

@@ -553,7 +553,11 @@ export class NetworkCore implements INetworkCore {
           // On fork boundary transition
           if (epoch === nextBoundaryEpoch) {
             // updateEth2Field() MUST be called with clock epoch, onEpoch event is emitted in response to clock events
-            this.metadata.updateEth2Field(epoch);
+            const {forkDigest} = this.metadata.updateEth2Field(epoch);
+            // Update local status to reflect the new fork digest, otherwise we will disconnect peers that re-status us
+            // right after the fork transition due to incompatible forks as our fork digest is stale since we only
+            // update it once we import a new head or when emitting update status event.
+            this.statusCache.update({...this.statusCache.get(), forkDigest});
             this.reqResp.registerProtocolsAtBoundary(nextBoundary);
           }
 

package/src/network/core/networkCoreWorker.ts

@@ -98,8 +98,13 @@ const core = await NetworkCore.init({
   metricsRegistry: metricsRegister,
   events,
   clock,
-  getReqRespHandler: (method) => (req, peerId) =>
-    reqRespBridgeRespCaller.getAsyncIterable({method, req, peerId: peerIdToString(peerId)}),
+  getReqRespHandler: (method) => (req, peerId, peerClient) =>
+    reqRespBridgeRespCaller.getAsyncIterable({
+      method,
+      req,
+      peerId: peerIdToString(peerId),
+      peerClient,
+    }),
   activeValidatorCount: workerData.activeValidatorCount,
   initialStatus: workerData.initialStatus,
   initialCustodyGroupCount: workerData.initialCustodyGroupCount,

package/src/network/core/networkCoreWorkerHandler.ts

@@ -73,7 +73,7 @@ export class WorkerNetworkCore implements INetworkCore {
     // Handles ReqResp response from worker and calls async generator in main thread
     this.reqRespBridgeRespHandler = new AsyncIterableBridgeHandler(
       getReqRespBridgeRespEvents(this.reqRespBridgeEventBus),
-      (data) => modules.getReqRespHandler(data.method)(data.req, peerIdFromString(data.peerId))
+      (data) => modules.getReqRespHandler(data.method)(data.req, peerIdFromString(data.peerId), data.peerClient)
     );
 
     wireEventsOnMainThread<NetworkEventData>(

package/src/network/events.ts

@@ -29,7 +29,7 @@ export type NetworkEventData = {
     clientAgent: string;
   };
   [NetworkEvent.peerDisconnected]: {peer: PeerIdStr};
-  [NetworkEvent.reqRespRequest]: {request: RequestTypedContainer; peer: PeerId};
+  [NetworkEvent.reqRespRequest]: {request: RequestTypedContainer; peer: PeerId; peerClient: string};
   [NetworkEvent.pendingGossipsubMessage]: PendingGossipsubMessage;
   [NetworkEvent.gossipMessageValidationResult]: {
     msgId: string;

package/src/network/gossip/encoding.ts

@@ -1,6 +1,6 @@
 import {Message} from "@libp2p/interface";
-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";

package/src/network/gossip/snappy_bun.ts

@@ -0,0 +1,2 @@
+import {snappy} from "@lodestar/bun";
+export const {compress, uncompress} = snappy;

package/src/network/metadata.ts

@@ -126,7 +126,7 @@ export class MetadataController {
    * 2. Network MUST call this method on fork transition.
    *    Current Clock implementation ensures no race conditions, epoch is correct if re-fetched
    */
-  updateEth2Field(epoch: Epoch): void {
+  updateEth2Field(epoch: Epoch): phase0.ENRForkID {
     const config = this.networkConfig.config;
     const enrForkId = getENRForkID(config, epoch);
     const {forkDigest, nextForkVersion, nextForkEpoch} = enrForkId;
@@ -143,6 +143,8 @@ export class MetadataController {
         : ssz.ForkDigest.defaultValue();
     this.onSetValue(ENRKey.nfd, nextForkDigest);
     this.logger.debug("Updated nfd field in ENR", {nextForkDigest: toHex(nextForkDigest)});
+
+    return enrForkId;
   }
 }
 

package/src/network/options.ts

@@ -23,7 +23,6 @@ export interface NetworkOptions
   useWorker?: boolean;
   maxYoungGenerationSizeMb?: number;
   disableLightClientServer?: boolean;
-  supernode?: boolean;
 
   /**
    * During E2E tests observe a lot of following `missing stream`:

package/src/network/processor/gossipHandlers.ts

@@ -307,7 +307,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         });
         throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
           code: DataColumnSidecarErrorCode.ALREADY_KNOWN,
-          columnIdx: dataColumnSidecar.index,
+          columnIndex: dataColumnSidecar.index,
           slot,
         });
       }