@lodestar/beacon-node 1.51.0-dev.8d8efcbf5f → 1.51.0-dev.8fdbd61e7e

package/src/sync/utils/downloadByRoot.ts

@@ -1,22 +1,13 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {
-  ForkPostDeneb,
-  ForkPostFulu,
-  ForkPostGloas,
-  ForkPreFulu,
-  isForkPostDeneb,
-  isForkPostFulu,
-  isForkPostGloas,
-} from "@lodestar/params";
-import {BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ForkPostFulu, ForkPostGloas, isForkPostFulu, isForkPostGloas} from "@lodestar/params";
+import {ColumnIndex, SignedBeaconBlock, Slot, fulu} from "@lodestar/types";
 import {LodestarError, byteArrayEquals, fromHex, prettyPrintIndices, toHex, toRootHex} from "@lodestar/utils";
-import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
+import {isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../../chain/blocks/blockInput/types.js";
 import {PayloadEnvelopeInputSource} from "../../chain/blocks/payloadEnvelopeInput/index.js";
 import {ChainEventEmitter} from "../../chain/emitter.js";
 import {IBeaconChain} from "../../chain/interface.js";
-import {validateBlockBlobSidecars} from "../../chain/validation/blobSidecar.js";
 import {validateFuluBlockDataColumnSidecars} from "../../chain/validation/dataColumnSidecar.js";
 import {INetwork} from "../../network/interface.js";
 import {PeerSyncMeta} from "../../network/peers/peersData.js";
@@ -46,12 +37,6 @@ export type FetchByRootAndValidateBlockProps = Omit<FetchByRootCoreProps, "peerM
   peerIdStr: PeerIdStr;
   blockRoot: Uint8Array;
 };
-export type FetchByRootAndValidateBlobsProps = FetchByRootAndValidateBlockProps & {
-  forkName: ForkPreFulu;
-  block: SignedBeaconBlock<ForkPostDeneb>;
-  blockRoot: Uint8Array;
-  missing: BlobIndex[];
-};
 export type FetchByRootAndValidateColumnsProps = FetchByRootCoreProps & {
   blockRoot: Uint8Array;
   forkName: ForkPostFulu;
@@ -60,7 +45,6 @@ export type FetchByRootAndValidateColumnsProps = FetchByRootCoreProps & {
 };
 export type FetchByRootResponses = {
   block: SignedBeaconBlock;
-  blobSidecars?: deneb.BlobSidecars;
   columnSidecars?: fulu.DataColumnSidecar[];
 };
 
@@ -83,7 +67,7 @@ export async function downloadByRoot({
   const {peerId: peerIdStr} = peerMeta;
 
   const {
-    result: {block, blobSidecars, columnSidecars},
+    result: {block, columnSidecars},
     warnings,
   } = await fetchByRoot({
     config,
@@ -130,44 +114,6 @@ export async function downloadByRoot({
 
   const hasAllDataPreDownload = blockInput.hasBlockAndAllData();
 
-  if (isBlockInputBlobs(blockInput) && !hasAllDataPreDownload) {
-    // blobSidecars could be undefined if gossip resulted in full block+blobs so we don't download any
-    if (!blobSidecars) {
-      throw new DownloadByRootError({
-        code: DownloadByRootErrorCode.MISSING_BLOB_RESPONSE,
-        blockRoot: rootHex,
-        peer: peerIdStr,
-      });
-    }
-    for (const blobSidecar of blobSidecars) {
-      if (blockInput.hasBlob(blobSidecar.index)) {
-        // the same BlobSidecar may be added by gossip while waiting for fetchByRoot
-        // TODO(fulu): add metric here to track this
-        continue;
-      }
-
-      blockInput.addBlob({
-        blobSidecar,
-        blockRootHex: rootHex,
-        seenTimestampSec: Date.now() / 1000,
-        source: BlockInputSource.byRoot,
-        peerIdStr,
-      });
-
-      if (emitter.listenerCount(routes.events.EventType.blobSidecar)) {
-        const versionedHashes = blockInput.getVersionedHashes();
-
-        emitter.emit(routes.events.EventType.blobSidecar, {
-          blockRoot: rootHex,
-          slot: blockInput.slot,
-          index: blobSidecar.index,
-          kzgCommitment: toHex(blobSidecar.kzgCommitment),
-          versionedHash: toHex(versionedHashes[blobSidecar.index]),
-        });
-      }
-    }
-  }
-
   if (isBlockInputColumns(blockInput) && !hasAllDataPreDownload) {
     // columnSidecars could be undefined if gossip resulted in full block+columns so we don't download any
     if (!columnSidecars) {
@@ -233,7 +179,6 @@ export async function fetchByRoot({
   cacheItem,
 }: FetchByRootProps): Promise<WarnResult<FetchByRootResponses, DownloadByRootError>> {
   let block: SignedBeaconBlock;
-  let blobSidecars: deneb.BlobSidecars | undefined;
   let columnSidecarResult: WarnResult<fulu.DataColumnSidecar[], DownloadByRootError> | undefined;
   const {peerId: peerIdStr} = peerMeta;
 
@@ -250,31 +195,17 @@ export async function fetchByRoot({
     }
 
     const forkName = config.getForkName(block.message.slot);
-    if (!cacheItem.blockInput.hasAllData()) {
-      if (isBlockInputBlobs(cacheItem.blockInput)) {
-        blobSidecars = await fetchAndValidateBlobs({
-          config,
-          chain,
-          network,
-          peerIdStr,
-          forkName: forkName as ForkPreFulu,
-          block: block as SignedBeaconBlock<ForkPostDeneb>,
-          blockRoot,
-          missing: cacheItem.blockInput.getMissingBlobMeta().map(({index}) => index),
-        });
-      }
-      if (isBlockInputColumns(cacheItem.blockInput)) {
-        columnSidecarResult = await fetchAndValidateColumns({
-          config,
-          chain,
-          network,
-          peerMeta,
-          forkName: forkName as ForkPostFulu,
-          block: block as SignedBeaconBlock<ForkPostFulu>,
-          blockRoot,
-          missing: cacheItem.blockInput.getMissingSampledColumnMeta().missing,
-        });
-      }
+    if (!cacheItem.blockInput.hasAllData() && isBlockInputColumns(cacheItem.blockInput)) {
+      columnSidecarResult = await fetchAndValidateColumns({
+        config,
+        chain,
+        network,
+        peerMeta,
+        forkName: forkName as ForkPostFulu,
+        block: block as SignedBeaconBlock<ForkPostFulu>,
+        blockRoot,
+        missing: cacheItem.blockInput.getMissingSampledColumnMeta().missing,
+      });
     }
   } else {
     block = await fetchAndValidateBlock({
@@ -298,26 +229,12 @@ export async function fetchByRoot({
         block: block as SignedBeaconBlock<ForkPostFulu>,
         missing: network.custodyConfig.sampledColumns,
       });
-    } else if (isForkPostDeneb(forkName)) {
-      const commitments = (block as SignedBeaconBlock<ForkPostDeneb & ForkPreFulu>).message.body.blobKzgCommitments;
-      const blobCount = commitments.length;
-      blobSidecars = await fetchAndValidateBlobs({
-        config,
-        chain,
-        network,
-        peerIdStr,
-        forkName: forkName as ForkPreFulu,
-        blockRoot,
-        block: block as SignedBeaconBlock<ForkPostDeneb>,
-        missing: Array.from({length: blobCount}, (_, i) => i),
-      });
     }
   }
 
   return {
     result: {
       block,
-      blobSidecars,
       columnSidecars: columnSidecarResult?.result,
     },
     warnings: columnSidecarResult?.warnings ?? null,
@@ -354,44 +271,6 @@ export async function fetchAndValidateBlock({
   return block;
 }
 
-export async function fetchAndValidateBlobs({
-  chain,
-  network,
-  peerIdStr,
-  blockRoot,
-  block,
-  missing,
-}: FetchByRootAndValidateBlobsProps): Promise<deneb.BlobSidecars> {
-  const blobSidecars: deneb.BlobSidecars = await fetchBlobsByRoot({
-    network,
-    peerIdStr,
-    blockRoot,
-    missing,
-  });
-
-  await validateBlockBlobSidecars(chain, block.message.slot, blockRoot, missing.length, blobSidecars);
-
-  return blobSidecars;
-}
-
-export async function fetchBlobsByRoot({
-  network,
-  peerIdStr,
-  blockRoot,
-  missing,
-  indicesInPossession = [],
-}: Pick<FetchByRootAndValidateBlobsProps, "network" | "peerIdStr" | "blockRoot" | "missing"> & {
-  indicesInPossession?: number[];
-}): Promise<deneb.BlobSidecars> {
-  const blobsRequest = missing
-    .filter((index) => !indicesInPossession.includes(index))
-    .map((index) => ({blockRoot, index}));
-  if (!blobsRequest.length) {
-    return [];
-  }
-  return await network.sendBlobSidecarsByRoot(peerIdStr, blobsRequest);
-}
-
 export async function fetchAndValidateColumns({
   chain,
   network,
@@ -494,7 +373,6 @@ export enum DownloadByRootErrorCode {
   INVALID_INCLUSION_PROOF = "DOWNLOAD_BY_ROOT_ERROR_INVALID_INCLUSION_PROOF",
   INVALID_KZG_PROOF = "DOWNLOAD_BY_ROOT_ERROR_INVALID_KZG_PROOF",
   MISSING_BLOCK_RESPONSE = "DOWNLOAD_BY_ROOT_ERROR_MISSING_BLOCK_RESPONSE",
-  MISSING_BLOB_RESPONSE = "DOWNLOAD_BY_ROOT_ERROR_MISSING_BLOB_RESPONSE",
   MISSING_COLUMN_RESPONSE = "DOWNLOAD_BY_ROOT_ERROR_MISSING_COLUMN_RESPONSE",
   Z = "DOWNLOAD_BY_ROOT_ERROR_Z",
 }
@@ -541,11 +419,6 @@ export type DownloadByRootErrorType =
       peer: string;
       blockRoot: string;
     }
-  | {
-      code: DownloadByRootErrorCode.MISSING_BLOB_RESPONSE;
-      peer: string;
-      blockRoot: string;
-    }
   | {
       code: DownloadByRootErrorCode.MISSING_COLUMN_RESPONSE;
       peer: string;

package/src/util/blobs.ts

@@ -1,6 +1,5 @@
 import {digest as sha256Digest} from "@chainsafe/as-sha256";
 import {Tree} from "@chainsafe/persistent-merkle-tree";
-import {ChainForkConfig} from "@lodestar/config";
 import {
   BYTES_PER_CELL,
   BYTES_PER_FIELD_ELEMENT,
@@ -12,12 +11,10 @@ import {
   NUMBER_OF_COLUMNS,
   VERSIONED_HASH_VERSION_KZG,
 } from "@lodestar/params";
-import {signedBlockToSignedHeader} from "@lodestar/state-transition";
 import {
   BeaconBlockBody,
   DataColumnSidecar,
   SSZTypesFor,
-  SignedBeaconBlock,
   deneb,
   fulu,
   gloas,
@@ -45,37 +42,6 @@ export function computePreFuluKzgCommitmentsInclusionProof(
   return new Tree(bodyView.node).getSingleProof(BigInt(commitmentGindex));
 }
 
-/**
- * SPEC FUNCTION get_blob_sidecars
- * https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/deneb/validator.md#sidecar
- */
-export function getBlobSidecars(
-  config: ChainForkConfig,
-  signedBlock: SignedBeaconBlock,
-  blobs: deneb.Blobs,
-  proofs: deneb.KZGProofs
-): deneb.BlobSidecars {
-  const blobKzgCommitments = (signedBlock as deneb.SignedBeaconBlock).message.body.blobKzgCommitments;
-  if (blobKzgCommitments === undefined) {
-    throw Error("Invalid block with missing blobKzgCommitments for computeBlobSidecars");
-  }
-
-  const signedBlockHeader = signedBlockToSignedHeader(config, signedBlock);
-  const fork = config.getForkName(signedBlockHeader.message.slot);
-
-  return blobKzgCommitments.map((kzgCommitment, index) => {
-    const blob = blobs[index];
-    const kzgProof = proofs[index];
-    const kzgCommitmentInclusionProof = computePreFuluKzgCommitmentsInclusionProof(
-      fork,
-      signedBlock.message.body,
-      index
-    );
-
-    return {index, blob, kzgCommitment, kzgProof, signedBlockHeader, kzgCommitmentInclusionProof};
-  });
-}
-
 /**
  * If the node obtains 50%+ of all the columns, it SHOULD reconstruct the full data matrix via the recover_matrix helper
  * See https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/das-core.md#recover_matrix

package/src/util/execution.ts

@@ -1,10 +1,9 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkPostFulu, ForkPreFulu} from "@lodestar/params";
-import {signedBlockToSignedHeader} from "@lodestar/state-transition";
-import {DataColumnSidecar, SignedBeaconBlock, Slot, deneb, gloas, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
+import {ForkPostFulu} from "@lodestar/params";
+import {DataColumnSidecar, SignedBeaconBlock, Slot, gloas, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
 import {Logger, fromHex, toHex, toRootHex} from "@lodestar/utils";
-import {isBlockInputBlobs, isBlockInputColumns} from "../chain/blocks/blockInput/blockInput.js";
+import {isBlockInputColumns} from "../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../chain/blocks/blockInput/types.js";
 import {PayloadEnvelopeInput, PayloadEnvelopeInputSource} from "../chain/blocks/payloadEnvelopeInput/index.js";
 import {ChainEvent, ChainEventEmitter} from "../chain/emitter.js";
@@ -16,7 +15,6 @@ import {IBeaconDb} from "../db/index.js";
 import {ArchivedEnvelope, decodeArchivedEnvelope} from "../db/repositories/index.js";
 import {IExecutionEngine} from "../execution/index.js";
 import {Metrics} from "../metrics/index.js";
-import {computePreFuluKzgCommitmentsInclusionProof} from "./blobs.js";
 import {
   getCellsAndProofs,
   getDataColumnSidecarsFromBlock,
@@ -40,98 +38,6 @@ export enum DataColumnEngineResult {
   Failed = "failed",
 }
 
-export async function getBlobSidecarsFromExecution(
-  config: ChainForkConfig,
-  executionEngine: IExecutionEngine,
-  metrics: Metrics | null,
-  emitter: ChainEventEmitter,
-  blockInput: IBlockInput
-) {
-  if (!isBlockInputBlobs(blockInput)) {
-    return;
-  }
-
-  if (blockInput.hasAllData()) {
-    return;
-  }
-
-  const forkName = blockInput.forkName as ForkPreFulu;
-  const blobMeta = blockInput.getMissingBlobMeta();
-
-  metrics?.blobs.getBlobsV1Requests.inc();
-  metrics?.blobs.getBlobsV1RequestedBlobCount.inc(blobMeta.length);
-  const enginedResponse = await executionEngine
-    .getBlobs(
-      forkName,
-      blobMeta.map(({versionedHash}) => versionedHash)
-    )
-    .catch((_e) => {
-      // TODO(fulu): this should only count as a single error? need to update the promql to reflect this
-      metrics?.blobs.getBlobsV1Error.inc(blobMeta.length);
-      return null;
-    });
-
-  if (enginedResponse === null) {
-    return;
-  }
-
-  const block = blockInput.getBlock();
-
-  const blobSidecars: deneb.BlobSidecars = [];
-  // response.length should always match blobMeta.length and they should be in the same order
-  for (let i = 0; i < blobMeta.length; i++) {
-    const blobAndProof = enginedResponse[i];
-
-    if (!blobAndProof) {
-      metrics?.blobs.getBlobsV1Miss.inc();
-    } else {
-      metrics?.blobs.getBlobsV1Hit.inc();
-
-      if (blockInput.hasBlob(blobMeta[i].index)) {
-        // blob arrived and was cached while waiting for API response
-        metrics?.blobs.getBlobsV1HitButArrivedWhileWaiting.inc();
-        continue;
-      }
-
-      metrics?.blobs.getBlobsV1HitUseful.inc();
-      const {blob, proof} = blobAndProof;
-      const index = blobMeta[i].index;
-      const kzgCommitment = block.message.body.blobKzgCommitments[index];
-      const blobSidecar: deneb.BlobSidecar = {
-        index,
-        blob,
-        kzgProof: proof,
-        kzgCommitment,
-        // TODO(fulu): refactor this to only calculate the root inside these following two functions once
-        kzgCommitmentInclusionProof: computePreFuluKzgCommitmentsInclusionProof(forkName, block.message.body, index),
-        signedBlockHeader: signedBlockToSignedHeader(config, block),
-      };
-
-      blockInput.addBlob({
-        blobSidecar,
-        blockRootHex: blockInput.blockRootHex,
-        seenTimestampSec: Date.now() / 1000,
-        source: BlockInputSource.engine,
-      });
-
-      if (emitter.listenerCount(routes.events.EventType.blobSidecar)) {
-        emitter.emit(routes.events.EventType.blobSidecar, {
-          blockRoot: blockInput.blockRootHex,
-          slot: blockInput.slot,
-          index,
-          kzgCommitment: toHex(kzgCommitment),
-          versionedHash: toHex(blobMeta[i].versionedHash),
-        });
-      }
-
-      blobSidecars.push(blobSidecar);
-    }
-  }
-
-  emitter.emit(ChainEvent.publishBlobSidecars, blobSidecars);
-  metrics?.gossipBlob.publishedFromEngine.inc(blobSidecars.length);
-}
-
 /**
  * Call getBlobsV2 from execution engine once per slot to fetch blobs and compute data columns.
  *
@@ -140,7 +46,7 @@ export async function getBlobSidecarsFromExecution(
  */
 export async function getDataColumnSidecarsFromExecution(
   config: ChainForkConfig,
-  executionEngine: IExecutionEngine,
+  executionEngine: Pick<IExecutionEngine, "getBlobs">,
   emitter: ChainEventEmitter,
   input: IBlockInput | PayloadEnvelopeInput,
   metrics: Metrics | null,
@@ -289,7 +195,7 @@ export type RebuildMiss = {slot: Slot; reason: "unavailable" | "mismatch"; error
  */
 export async function* reconstructExecutionPayloadEnvelopesByRange(
   db: IBeaconDb,
-  executionEngine: IExecutionEngine,
+  executionEngine: Pick<IExecutionEngine, "getPayloadBodiesByHashV2">,
   logger: Logger,
   metrics: Metrics | null,
   startSlot: Slot,
@@ -315,7 +221,7 @@ export async function* reconstructExecutionPayloadEnvelopesByRange(
  * RANGE_UNSERVABLE for it
  */
 async function* reconstructBatch(
-  executionEngine: IExecutionEngine,
+  executionEngine: Pick<IExecutionEngine, "getPayloadBodiesByHashV2">,
   logger: Logger,
   metrics: Metrics | null,
   batch: RangeEntry[]
@@ -355,7 +261,7 @@ async function* reconstructBatch(
  * on its path. Throws ENGINE_UNAVAILABLE only.
  */
 export async function reconstructExecutionPayloadEnvelopes(
-  executionEngine: IExecutionEngine,
+  executionEngine: Pick<IExecutionEngine, "getPayloadBodiesByHashV2">,
   metrics: Metrics | null,
   headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[]
 ): Promise<(gloas.SignedExecutionPayloadEnvelope | RebuildMiss)[]> {
@@ -382,7 +288,7 @@ export function isRebuildMiss(result: gloas.SignedExecutionPayloadEnvelope | Reb
  * incremented once, in this function.
  */
 async function reconstructEnvelopesBatch(
-  executionEngine: IExecutionEngine,
+  executionEngine: Pick<IExecutionEngine, "getPayloadBodiesByHashV2">,
   metrics: Metrics | null,
   headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[]
 ): Promise<(gloas.SignedExecutionPayloadEnvelope | RebuildMiss)[]> {

package/src/util/file.ts

@@ -1,25 +1,24 @@
-import fs from "node:fs";
-import {promisify} from "node:util";
+import {readFile as fsReadFile, mkdir, readdir, stat, unlink, writeFile} from "node:fs/promises";
 
 /** Ensure a directory exists */
 export async function ensureDir(path: string): Promise<void> {
   try {
-    await promisify(fs.stat)(path);
+    await stat(path);
   } catch (_) {
     // not exists
-    await promisify(fs.mkdir)(path, {recursive: true});
+    await mkdir(path, {recursive: true});
   }
 }
 
 /** Write data to a file if it does not exist */
 export async function writeIfNotExist(filepath: string, bytes: Uint8Array): Promise<boolean> {
   try {
-    await promisify(fs.stat)(filepath);
+    await stat(filepath);
     return false;
     // file exists, do nothing
   } catch (_) {
     // not exists
-    await promisify(fs.writeFile)(filepath, bytes);
+    await writeFile(filepath, bytes);
     return true;
   }
 }
@@ -27,7 +26,7 @@ export async function writeIfNotExist(filepath: string, bytes: Uint8Array): Prom
 /** Remove a file if it exists */
 export async function removeFile(path: string): Promise<boolean> {
   try {
-    await promisify(fs.unlink)(path);
+    await unlink(path);
     return true;
   } catch (_) {
     // may not exists
@@ -37,7 +36,7 @@ export async function removeFile(path: string): Promise<boolean> {
 
 export async function readFile(path: string): Promise<Uint8Array | null> {
   try {
-    return await fs.promises.readFile(path);
+    return await fsReadFile(path);
   } catch (_) {
     return null;
   }
@@ -45,7 +44,7 @@ export async function readFile(path: string): Promise<Uint8Array | null> {
 
 export async function readFileNames(folderPath: string): Promise<string[]> {
   try {
-    return await fs.promises.readdir(folderPath);
+    return await readdir(folderPath);
   } catch (_) {
     return [];
   }

package/src/util/sszBytes.ts

@@ -2,8 +2,6 @@ import {BitArray, deserializeUint8ArrayBitListFromBytes} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {
   BYTES_PER_CELL,
-  BYTES_PER_FIELD_ELEMENT,
-  FIELD_ELEMENTS_PER_BLOB,
   ForkName,
   ForkPostDeneb,
   ForkPostGloas,
@@ -496,26 +494,6 @@ export function getParentBlockHashFromGloasSignedBeaconBlockSerialized(
   return `0x${blockRootBuf.toString("hex")}`;
 }
 
-/**
- * class BlobSidecar(Container):
- *  index: BlobIndex [fixed - 8 bytes ],
- *  blob: Blob, BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB
- *  kzgCommitment: Bytes48,
- *  kzgProof: Bytes48,
- *  signedBlockHeader:
- *    slot: 8 bytes
- */
-
-const SLOT_BYTES_POSITION_IN_SIGNED_BLOB_SIDECAR = 8 + BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB + 48 + 48;
-
-export function getSlotFromBlobSidecarSerialized(data: Uint8Array): Slot | null {
-  if (data.length < SLOT_BYTES_POSITION_IN_SIGNED_BLOB_SIDECAR + SLOT_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_SIGNED_BLOB_SIDECAR);
-}
-
 /**
  * Pre-Gloas DataColumnSidecar:
  * {
@@ -652,6 +630,46 @@ export function getBeaconBlockRootFromExecutionPayloadEnvelopeSerialized(data: U
   return "0x" + blockRootBuf.toString("hex");
 }
 
+// transactions offset within ExecutionPayload fixed portion, see SLOT_NUMBER_OFFSET_IN_EXECUTION_PAYLOAD:
+// everything up to and including blockHash(32) = 504, followed by withdrawals_offset(4)
+const PAYLOAD_START_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
+  ENVELOPE_START_IN_SIGNED + EXECUTION_PAYLOAD_ENVELOPE_FIXED_SIZE; // 180
+const TRANSACTIONS_OFFSET_POSITION_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
+  PAYLOAD_START_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + 504; // 684
+const WITHDRAWALS_OFFSET_POSITION_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
+  TRANSACTIONS_OFFSET_POSITION_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + 4; // 688
+
+/**
+ * Transaction count of the payload, read from the SSZ offsets without deserializing the envelope.
+ * Returns null on malformed offsets, deserialization reports the exact error.
+ */
+export function getTransactionCountFromExecutionPayloadEnvelopeSerialized(data: Uint8Array): number | null {
+  if (data.length < WITHDRAWALS_OFFSET_POSITION_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + 4) {
+    return null;
+  }
+
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const transactionsOffset = view.getUint32(TRANSACTIONS_OFFSET_POSITION_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE, true);
+  const withdrawalsOffset = view.getUint32(WITHDRAWALS_OFFSET_POSITION_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE, true);
+  if (transactionsOffset > withdrawalsOffset) {
+    return null;
+  }
+  if (transactionsOffset === withdrawalsOffset) {
+    return 0;
+  }
+
+  const transactionsStart = PAYLOAD_START_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + transactionsOffset;
+  if (transactionsStart + 4 > data.length) {
+    return null;
+  }
+  // first offset of a non-empty list is the size of its offset table, 4 bytes per element
+  const firstTransactionOffset = view.getUint32(transactionsStart, true);
+  if (firstTransactionOffset % 4 !== 0 || firstTransactionOffset > withdrawalsOffset - transactionsOffset) {
+    return null;
+  }
+  return firstTransactionOffset / 4;
+}
+
 /**
  * BeaconState of all forks (up until Electra, check with new forks)
  * class BeaconState(Container):

package/src/util/types.ts

@@ -1,6 +1,6 @@
 import {ContainerType, ListCompositeType, ValueOf} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {ForkName, isForkPostDeneb, isForkPostElectra} from "@lodestar/params";
+import {ForkName, isForkPostDeneb} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 
 // Misc SSZ types used only in the beacon-node package, no need to upstream to types
@@ -19,13 +19,6 @@ export const BeaconBlocksByRootRequestType = (fork: ForkName, config: BeaconConf
   new ListCompositeType(ssz.Root, isForkPostDeneb(fork) ? config.MAX_REQUEST_BLOCKS_DENEB : config.MAX_REQUEST_BLOCKS);
 export type BeaconBlocksByRootRequest = ValueOf<ReturnType<typeof BeaconBlocksByRootRequestType>>;
 
-export const BlobSidecarsByRootRequestType = (fork: ForkName, config: BeaconConfig) =>
-  new ListCompositeType(
-    ssz.deneb.BlobIdentifier,
-    isForkPostElectra(fork) ? config.MAX_REQUEST_BLOB_SIDECARS_ELECTRA : config.MAX_REQUEST_BLOB_SIDECARS
-  );
-export type BlobSidecarsByRootRequest = ValueOf<ReturnType<typeof BlobSidecarsByRootRequestType>>;
-
 export const DataColumnSidecarsByRootRequestType = (config: BeaconConfig) =>
   new ListCompositeType(ssz.fulu.DataColumnsByRootIdentifier, config.MAX_REQUEST_BLOCKS_DENEB);
 export type DataColumnSidecarsByRootRequest = ValueOf<ReturnType<typeof DataColumnSidecarsByRootRequestType>>;