@lodestar/beacon-node 1.42.0-dev.4411584fd8 → 1.42.0-dev.47afaa6bb7

package/src/util/sszBytes.ts

@@ -8,6 +8,7 @@ import {
   ForkSeq,
   MAX_COMMITTEES_PER_SLOT,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {BLSSignature, CommitteeIndex, RootHex, Slot, ValidatorIndex, ssz} from "@lodestar/types";
 
@@ -16,6 +17,8 @@ export type BlockRootHex = RootHex;
 export type AttDataBase64 = string;
 // electra, CommitteeBits
 export type CommitteeBitsBase64 = string;
+/** `attestation.data.index` from gossip-serialized attestations / aggregates */
+export type AttDataIndex = number;
 
 // pre-electra
 // class Attestation(Container):
@@ -56,6 +59,7 @@ const SIGNATURE_SIZE = 96;
 const SINGLE_ATTESTATION_ATTDATA_OFFSET = 8 + 8;
 const SINGLE_ATTESTATION_SLOT_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET;
 const SINGLE_ATTESTATION_COMMITTEE_INDEX_OFFSET = 0;
+const SINGLE_ATTESTATION_DATA_INDEX_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET + 8;
 const SINGLE_ATTESTATION_ATTESTER_INDEX_OFFSET = 8;
 const SINGLE_ATTESTATION_BEACON_BLOCK_ROOT_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET + 8 + 8;
 const SINGLE_ATTESTATION_SIGNATURE_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET + ATTESTATION_DATA_SIZE;
@@ -179,7 +183,7 @@ export function getSlotFromSingleAttestationSerialized(data: Uint8Array): Slot |
 
 /**
  * Extract committee index from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract slot.
+ * Return null if data is not long enough to extract the committee index.
  */
 export function getCommitteeIndexFromSingleAttestationSerialized(
   fork: ForkName,
@@ -200,6 +204,29 @@ export function getCommitteeIndexFromSingleAttestationSerialized(
   return getIndexFromOffset(data, VARIABLE_FIELD_OFFSET + SLOT_SIZE);
 }
 
+/**
+ * Extract data index from SingleAttestation serialized bytes.
+ * Post-gloas, `data.index` field is repurposed:
+ *   - 0 - payload was not available (or attestation is same-slot, where availability is not yet known)
+ *   - 1 - payload was available
+ * Return null if data is not long enough to extract the index.
+ */
+export function getDataIndexFromSingleAttestationSerialized(fork: ForkName, data: Uint8Array): AttDataIndex | null {
+  if (isForkPostElectra(fork)) {
+    if (data.length !== SINGLE_ATTESTATION_SIZE) {
+      return null;
+    }
+
+    return getIndexFromOffset(data, SINGLE_ATTESTATION_DATA_INDEX_OFFSET);
+  }
+
+  if (data.length < VARIABLE_FIELD_OFFSET + SLOT_SIZE + COMMITTEE_INDEX_SIZE) {
+    return null;
+  }
+
+  return getIndexFromOffset(data, VARIABLE_FIELD_OFFSET + SLOT_SIZE);
+}
+
 /**
  * Extract attester index from SingleAttestation serialized bytes.
  * Return null if data is not long enough to extract index.
@@ -268,6 +295,7 @@ export function getSignatureFromSingleAttestationSerialized(data: Uint8Array): B
 const AGGREGATE_AND_PROOF_OFFSET = 4 + 96;
 const AGGREGATE_OFFSET = AGGREGATE_AND_PROOF_OFFSET + 8 + 4 + 96;
 const SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET = AGGREGATE_OFFSET + VARIABLE_FIELD_OFFSET;
+const SIGNED_AGGREGATE_AND_PROOF_ATTESTATION_DATA_INDEX_OFFSET = SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + SLOT_SIZE;
 const SIGNED_AGGREGATE_AND_PROOF_BLOCK_ROOT_OFFSET = SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + 8 + 8;
 
 /**
@@ -302,6 +330,19 @@ export function getBlockRootFromSignedAggregateAndProofSerialized(data: Uint8Arr
   return "0x" + blockRootBuf.toString("hex");
 }
 
+/**
+ * Extract data index from signed aggregate and proof serialized bytes.
+ * Return null if data is not long enough to extract the index.
+ * This works for both phase0 + electra (index is in attestation data at the same offset).
+ */
+export function getDataIndexFromSignedAggregateAndProofSerialized(data: Uint8Array): AttDataIndex | null {
+  if (data.length < SIGNED_AGGREGATE_AND_PROOF_ATTESTATION_DATA_INDEX_OFFSET + COMMITTEE_INDEX_SIZE) {
+    return null;
+  }
+
+  return getIndexFromOffset(data, SIGNED_AGGREGATE_AND_PROOF_ATTESTATION_DATA_INDEX_OFFSET);
+}
+
 /**
  * Extract AttestationData base64 from SignedAggregateAndProof for electra
  * Return null if data is not long enough
@@ -368,6 +409,8 @@ export function getAttDataFromSignedAggregateAndProofPhase0(data: Uint8Array): A
  * ```
  */
 const SLOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK = VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE;
+// proposer_index is ValidatorIndex = uint64 = 8 bytes
+const PARENT_ROOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK = VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE + SLOT_SIZE + 8;
 
 export function getSlotFromSignedBeaconBlockSerialized(data: Uint8Array): Slot | null {
   if (data.length < SLOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK + SLOT_SIZE) {
@@ -377,6 +420,68 @@ export function getSlotFromSignedBeaconBlockSerialized(data: Uint8Array): Slot |
   return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK);
 }
 
+export function getParentRootFromSignedBeaconBlockSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < PARENT_ROOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK + ROOT_SIZE) {
+    return null;
+  }
+  blockRootBuf.set(
+    data.subarray(
+      PARENT_ROOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK,
+      PARENT_ROOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK + ROOT_SIZE
+    )
+  );
+  return `0x${blockRootBuf.toString("hex")}`;
+}
+
+/**
+ * Extract parentBlockHash from a GLOAS SignedBeaconBlock by navigating the SSZ offset pointer
+ * to the embedded SignedExecutionPayloadBid.
+ *
+ * Layout (bytes from start of SignedBeaconBlock):
+ *   [0..4)    message offset
+ *   [4..100)  signature (96 B)
+ *   [100..184) BeaconBlock fixed section: slot(8)+proposer_index(8)+parent_root(32)+state_root(32)+body_offset(4)
+ *   [184..)   BeaconBlockBody
+ *
+ * BeaconBlockBody (GLOAS) fixed section before signedExecutionPayloadBid offset pointer:
+ *   randaoReveal(96) + eth1Data(72) + graffiti(32)
+ *   + proposerSlashings(4) + attesterSlashings(4) + attestations(4) + deposits(4) + voluntaryExits(4)
+ *   + syncAggregate(160) + blsToExecutionChanges(4) = 384 bytes
+ *
+ * The 4-byte pointer at byte 568 (= 184+384) gives the offset of SignedExecutionPayloadBid
+ * within BeaconBlockBody. parentBlockHash is at that bid's byte 100 (after offset+sig).
+ */
+// BeaconBlock body starts after: msg_offset(4) + sig(96) + slot(8) + proposer_index(8) + parent_root(32) + state_root(32) + body_offset_ptr(4)
+const GLOAS_BODY_START_IN_SIGNED_BEACON_BLOCK =
+  VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE + SLOT_SIZE + 8 + ROOT_SIZE + ROOT_SIZE + VARIABLE_FIELD_OFFSET; // = 184
+const GLOAS_SIGNED_BID_OFFSET_POINTER_IN_BODY = 96 + 72 + 32 + 4 + 4 + 4 + 4 + 4 + 160 + 4; // = 384
+const GLOAS_SIGNED_BID_OFFSET_POINTER_IN_SIGNED_BEACON_BLOCK =
+  GLOAS_BODY_START_IN_SIGNED_BEACON_BLOCK + GLOAS_SIGNED_BID_OFFSET_POINTER_IN_BODY; // = 568
+// Within SignedExecutionPayloadBid, parentBlockHash is at byte 100 (msg_offset:4 + sig:96)
+const PARENT_BLOCK_HASH_OFFSET_IN_SIGNED_BID = VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE; // = 100
+
+// CAUTION: update offsets if BeaconBlockBody fixed fields change after Gloas
+export function getParentBlockHashFromGloasSignedBeaconBlockSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < GLOAS_SIGNED_BID_OFFSET_POINTER_IN_SIGNED_BEACON_BLOCK + VARIABLE_FIELD_OFFSET) {
+    return null;
+  }
+  const bidOffset =
+    data[GLOAS_SIGNED_BID_OFFSET_POINTER_IN_SIGNED_BEACON_BLOCK] |
+    (data[GLOAS_SIGNED_BID_OFFSET_POINTER_IN_SIGNED_BEACON_BLOCK + 1] << 8) |
+    (data[GLOAS_SIGNED_BID_OFFSET_POINTER_IN_SIGNED_BEACON_BLOCK + 2] << 16) |
+    (data[GLOAS_SIGNED_BID_OFFSET_POINTER_IN_SIGNED_BEACON_BLOCK + 3] << 24);
+
+  const parentBlockHashStart =
+    GLOAS_BODY_START_IN_SIGNED_BEACON_BLOCK + bidOffset + PARENT_BLOCK_HASH_OFFSET_IN_SIGNED_BID;
+
+  if (data.length < parentBlockHashStart + ROOT_SIZE) {
+    return null;
+  }
+
+  blockRootBuf.set(data.subarray(parentBlockHashStart, parentBlockHashStart + ROOT_SIZE));
+  return `0x${blockRootBuf.toString("hex")}`;
+}
+
 /**
  * class BlobSidecar(Container):
  *  index: BlobIndex [fixed - 8 bytes ],
@@ -398,23 +503,102 @@ export function getSlotFromBlobSidecarSerialized(data: Uint8Array): Slot | null
 }
 
 /**
+ * Pre-Gloas DataColumnSidecar:
+ * {
+ *   index: ColumnIndex [fixed - 8 bytes],
+ *   column: DataColumn (offset - 4 bytes),
+ *   kzgCommitments: (offset - 4 bytes),
+ *   kzgProofs: (offset - 4 bytes),
+ *   signedBlockHeader: (offset - 4 bytes) -> slot at variable offset after fixed header
+ *   kzgCommitmentsInclusionProof: (offset - 4 bytes),
+ * }
+ * Post-Gloas DataColumnSidecar:
  * {
-    index: ColumnIndex [ fixed - 8 bytes],
-    column: DataColumn BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_CELL * <some non fixed length>,
-    kzgCommitments: denebSsz.BlobKzgCommitments,
-    kzgProofs: denebSsz.KZGProofs,
-    signedBlockHeader: phase0Ssz.SignedBeaconBlockHeader,
-    kzgCommitmentsInclusionProof: KzgCommitmentsInclusionProof,
+ *   index: ColumnIndex [8 bytes],
+ *   column: DataColumn (offset - 4 bytes),
+ *   kzgProofs: (offset - 4 bytes),
+ *   slot: Slot [8 bytes] - at offset 16,
+ *   beaconBlockRoot: Root [32 bytes] - at offset 24,
+ * }
+ */
+const SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR_PRE_GLOAS = 20;
+const SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR_POST_GLOAS = 16;
+const BEACON_BLOCK_ROOT_POSITION_IN_GLOAS_DATA_COLUMN_SIDECAR = 24;
+
+export function getSlotFromDataColumnSidecarSerialized(data: Uint8Array, fork: ForkName): Slot | null {
+  const offset = isForkPostGloas(fork)
+    ? SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR_POST_GLOAS
+    : SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR_PRE_GLOAS;
+
+  if (data.length < offset + SLOT_SIZE) {
+    return null;
   }
+
+  return getSlotFromOffset(data, offset);
+}
+
+export function getBeaconBlockRootFromDataColumnSidecarSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < BEACON_BLOCK_ROOT_POSITION_IN_GLOAS_DATA_COLUMN_SIDECAR + ROOT_SIZE) {
+    return null;
+  }
+
+  blockRootBuf.set(
+    data.subarray(
+      BEACON_BLOCK_ROOT_POSITION_IN_GLOAS_DATA_COLUMN_SIDECAR,
+      BEACON_BLOCK_ROOT_POSITION_IN_GLOAS_DATA_COLUMN_SIDECAR + ROOT_SIZE
+    )
+  );
+  return "0x" + blockRootBuf.toString("hex");
+}
+
+/**
+ * SignedExecutionPayloadEnvelope SSZ Layout:
+ * ├─ 4 bytes: message offset (points to byte 100)
+ * ├─ 96 bytes: signature
+ * └─ ExecutionPayloadEnvelope (starts at byte 100):
+ *    ├─ 4 bytes: payload offset
+ *    ├─ 4 bytes: executionRequests offset
+ *    ├─ 8 bytes: builderIndex        (offset 108-115)
+ *    ├─ 32 bytes: beaconBlockRoot    (offset 116-147)
+ *    ├─ 8 bytes: slot                (offset 148-155)
+ *    └─ 32 bytes: stateRoot          (offset 156-187)
  */
+const SIGNED_EXECUTION_PAYLOAD_ENVELOPE_MESSAGE_OFFSET = 4;
+const SIGNED_EXECUTION_PAYLOAD_ENVELOPE_SIGNATURE_SIZE = 96;
+const EXECUTION_PAYLOAD_ENVELOPE_PAYLOAD_OFFSET = 4;
+const EXECUTION_PAYLOAD_ENVELOPE_REQUESTS_OFFSET = 4;
+const EXECUTION_PAYLOAD_ENVELOPE_BUILDER_INDEX_SIZE = 8;
+
+const BEACON_BLOCK_ROOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
+  SIGNED_EXECUTION_PAYLOAD_ENVELOPE_MESSAGE_OFFSET +
+  SIGNED_EXECUTION_PAYLOAD_ENVELOPE_SIGNATURE_SIZE +
+  EXECUTION_PAYLOAD_ENVELOPE_PAYLOAD_OFFSET +
+  EXECUTION_PAYLOAD_ENVELOPE_REQUESTS_OFFSET +
+  EXECUTION_PAYLOAD_ENVELOPE_BUILDER_INDEX_SIZE; // 116
+
+const SLOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
+  BEACON_BLOCK_ROOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + ROOT_SIZE; // 148
+
+export function getSlotFromExecutionPayloadEnvelopeSerialized(data: Uint8Array): Slot | null {
+  if (data.length < SLOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + SLOT_SIZE) {
+    return null;
+  }
 
-const SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR = 20;
-export function getSlotFromDataColumnSidecarSerialized(data: Uint8Array): Slot | null {
-  if (data.length < SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR + SLOT_SIZE) {
+  return getSlotFromOffset(data, SLOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE);
+}
+
+export function getBeaconBlockRootFromExecutionPayloadEnvelopeSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < BEACON_BLOCK_ROOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + ROOT_SIZE) {
     return null;
   }
 
-  return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR);
+  blockRootBuf.set(
+    data.subarray(
+      BEACON_BLOCK_ROOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE,
+      BEACON_BLOCK_ROOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + ROOT_SIZE
+    )
+  );
+  return "0x" + blockRootBuf.toString("hex");
 }
 
 /**
@@ -447,6 +631,104 @@ export function getSlotFromBeaconStateSerialized(data: Uint8Array): Slot | null
   return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_BEACON_STATE);
 }
 
+/**
+ * PayloadAttestationMessage: {
+ *   validatorIndex: ValidatorIndex (8 bytes)
+ *   data: PayloadAttestationData {
+ *     beaconBlockRoot: Root (32 bytes)  ← offset 8
+ *     slot: Slot (8 bytes)              ← offset 40
+ *     payloadPresent: Boolean (1 byte)
+ *     blobDataAvailable: Boolean (1 byte)
+ *   }
+ *   signature: BLSSignature (96 bytes)
+ * }
+ * Fully fixed-size container, no offset table.
+ */
+const PAYLOAD_ATTESTATION_MESSAGE_BEACON_BLOCK_ROOT_OFFSET = 8;
+const PAYLOAD_ATTESTATION_MESSAGE_SLOT_OFFSET = 8 + ROOT_SIZE; // 40
+const PAYLOAD_ATTESTATION_MESSAGE_PAYLOAD_PRESENT_OFFSET = PAYLOAD_ATTESTATION_MESSAGE_SLOT_OFFSET + SLOT_SIZE; // 48
+
+export function getSlotFromPayloadAttestationMessageSerialized(data: Uint8Array): Slot | null {
+  if (data.length < PAYLOAD_ATTESTATION_MESSAGE_SLOT_OFFSET + SLOT_SIZE) {
+    return null;
+  }
+  return getSlotFromOffset(data, PAYLOAD_ATTESTATION_MESSAGE_SLOT_OFFSET);
+}
+
+export function getPayloadPresentFromPayloadAttestationMessageSerialized(data: Uint8Array): boolean | null {
+  if (data.length < PAYLOAD_ATTESTATION_MESSAGE_PAYLOAD_PRESENT_OFFSET + 1) {
+    return null;
+  }
+  return data[PAYLOAD_ATTESTATION_MESSAGE_PAYLOAD_PRESENT_OFFSET] !== 0;
+}
+
+export function getBlockRootFromPayloadAttestationMessageSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < PAYLOAD_ATTESTATION_MESSAGE_BEACON_BLOCK_ROOT_OFFSET + ROOT_SIZE) {
+    return null;
+  }
+  blockRootBuf.set(
+    data.subarray(
+      PAYLOAD_ATTESTATION_MESSAGE_BEACON_BLOCK_ROOT_OFFSET,
+      PAYLOAD_ATTESTATION_MESSAGE_BEACON_BLOCK_ROOT_OFFSET + ROOT_SIZE
+    )
+  );
+  return `0x${blockRootBuf.toString("hex")}`;
+}
+
+/**
+ * SignedExecutionPayloadBid: {message: ExecutionPayloadBid (variable), signature: BLSSignature (96 bytes)}
+ *   Fixed part: 4-byte offset + 96-byte signature = 100 bytes
+ *   message data starts at byte 100
+ *
+ * ExecutionPayloadBid fixed fields (in order):
+ *   parentBlockHash: Bytes32      (32 bytes)
+ *   parentBlockRoot: Root         (32 bytes)
+ *   blockHash: Bytes32            (32 bytes)
+ *   prevRandao: Bytes32           (32 bytes)
+ *   feeRecipient: ExecutionAddress(20 bytes)
+ *   gasLimit: UintBn64            (8 bytes)
+ *   builderIndex: BuilderIndex    (8 bytes)
+ *   slot: Slot                    (8 bytes)  ← absolute offset 264
+ */
+const SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_HASH_OFFSET = VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE; // 100
+const SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_ROOT_OFFSET =
+  SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_HASH_OFFSET + ROOT_SIZE; // 132
+const SIGNED_EXECUTION_PAYLOAD_BID_SLOT_OFFSET =
+  VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE + 32 + 32 + 32 + 32 + 20 + 8 + 8; // 264
+
+export function getSlotFromSignedExecutionPayloadBidSerialized(data: Uint8Array): Slot | null {
+  if (data.length < SIGNED_EXECUTION_PAYLOAD_BID_SLOT_OFFSET + SLOT_SIZE) {
+    return null;
+  }
+  return getSlotFromOffset(data, SIGNED_EXECUTION_PAYLOAD_BID_SLOT_OFFSET);
+}
+
+export function getParentBlockHashFromSignedExecutionPayloadBidSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_HASH_OFFSET + ROOT_SIZE) {
+    return null;
+  }
+  blockRootBuf.set(
+    data.subarray(
+      SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_HASH_OFFSET,
+      SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_HASH_OFFSET + ROOT_SIZE
+    )
+  );
+  return `0x${blockRootBuf.toString("hex")}`;
+}
+
+export function getParentBlockRootFromSignedExecutionPayloadBidSerialized(data: Uint8Array): RootHex | null {
+  if (data.length < SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_ROOT_OFFSET + ROOT_SIZE) {
+    return null;
+  }
+  blockRootBuf.set(
+    data.subarray(
+      SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_ROOT_OFFSET,
+      SIGNED_EXECUTION_PAYLOAD_BID_PARENT_BLOCK_ROOT_OFFSET + ROOT_SIZE
+    )
+  );
+  return `0x${blockRootBuf.toString("hex")}`;
+}
+
 /**
  * Read only the first 4 bytes of Slot, max value is 4,294,967,295 will be reached 1634 years after genesis
  *
@@ -482,9 +764,49 @@ export function getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized(
   if (slot === null) throw new Error("Can not parse the slot from block bytes");
 
   if (config.getForkSeq(slot) < ForkSeq.deneb) return 0;
+  const forkName = config.getForkName(slot);
+
+  if (isForkPostGloas(forkName)) {
+    // Gloas stores commitments under signedExecutionPayloadBid.message.blobKzgCommitments.
+    // Navigate the offset chain: SignedBeaconBlock → message → body → signedExecutionPayloadBid → message → blobKzgCommitments
+    const {SignedBeaconBlock: GloasSignedBlock, BeaconBlock: GloasBlock, BeaconBlockBody: GloasBody} = ssz[forkName];
+    const {SignedExecutionPayloadBid, ExecutionPayloadBid} = ssz[forkName];
+    const commitmentSize = ssz.deneb.KZGCommitment.fixedSize;
+
+    const view = new DataView(blockBytes.buffer, blockBytes.byteOffset, blockBytes.byteLength);
+
+    const signedBlockRanges = GloasSignedBlock.getFieldRanges(view, 0, blockBytes.length);
+    const messageIdx = Object.keys(GloasSignedBlock.fields).indexOf("message");
+    const messageRange = signedBlockRanges[messageIdx];
+
+    const blockRanges = GloasBlock.getFieldRanges(view, messageRange.start, messageRange.end);
+    const bodyIdx = Object.keys(GloasBlock.fields).indexOf("body");
+    const bodyRange = blockRanges[bodyIdx];
+    const bodyStart = messageRange.start + bodyRange.start;
+    const bodyEnd = messageRange.start + bodyRange.end;
+
+    const bodyRanges = GloasBody.getFieldRanges(view, bodyStart, bodyEnd);
+    const bidIdx = Object.keys(GloasBody.fields).indexOf("signedExecutionPayloadBid");
+    const bidRange = bodyRanges[bidIdx];
+    const bidStart = bodyStart + bidRange.start;
+    const bidEnd = bodyStart + bidRange.end;
+
+    const bidRanges = SignedExecutionPayloadBid.getFieldRanges(view, bidStart, bidEnd);
+    const bidMsgIdx = Object.keys(SignedExecutionPayloadBid.fields).indexOf("message");
+    const bidMsgRange = bidRanges[bidMsgIdx];
+    const bidMsgStart = bidStart + bidMsgRange.start;
+    const bidMsgEnd = bidStart + bidMsgRange.end;
+
+    const execBidRanges = ExecutionPayloadBid.getFieldRanges(view, bidMsgStart, bidMsgEnd);
+    const commitmentsIdx = Object.keys(ExecutionPayloadBid.fields).indexOf("blobKzgCommitments");
+    const commitmentsRange = execBidRanges[commitmentsIdx];
+
+    const start = bidMsgStart + commitmentsRange.start;
+    const end = bidMsgStart + commitmentsRange.end;
+    return Math.round(((end > blockBytes.byteLength ? blockBytes.byteLength : end) - start) / commitmentSize);
+  }
 
-  const {SignedBeaconBlock, BeaconBlock, BeaconBlockBody, KZGCommitment} =
-    ssz[config.getForkName(slot) as ForkPostDeneb];
+  const {SignedBeaconBlock, BeaconBlock, BeaconBlockBody, KZGCommitment} = ssz[forkName as ForkPostDeneb];
 
   const view = new DataView(blockBytes.buffer, blockBytes.byteOffset, blockBytes.byteLength);
   const singedBlockFieldRanges = SignedBeaconBlock.getFieldRanges(view, 0, blockBytes.length);

package/src/util/types.ts

@@ -29,3 +29,9 @@ export type BlobSidecarsByRootRequest = ValueOf<ReturnType<typeof BlobSidecarsBy
 export const DataColumnSidecarsByRootRequestType = (config: BeaconConfig) =>
   new ListCompositeType(ssz.fulu.DataColumnsByRootIdentifier, config.MAX_REQUEST_BLOCKS_DENEB);
 export type DataColumnSidecarsByRootRequest = ValueOf<ReturnType<typeof DataColumnSidecarsByRootRequestType>>;
+
+export const ExecutionPayloadEnvelopesByRootRequestType = (config: BeaconConfig) =>
+  new ListCompositeType(ssz.Root, config.MAX_REQUEST_PAYLOADS);
+export type ExecutionPayloadEnvelopesByRootRequest = ValueOf<
+  ReturnType<typeof ExecutionPayloadEnvelopesByRootRequestType>
+>;

package/lib/chain/seenCache/seenExecutionPayloadEnvelope.d.ts

@@ -1,15 +0,0 @@
-import { RootHex, Slot } from "@lodestar/types";
-/**
- * Cache to prevent processing multiple execution payload envelopes for the same block root.
- * Only one builder qualifies to submit an execution payload for a given slot.
- * We only keep track of envelopes of unfinalized slots.
- * [IGNORE] The node has not seen another valid `SignedExecutionPayloadEnvelope` for this block root.
- */
-export declare class SeenExecutionPayloadEnvelopes {
-    private readonly slotByBlockRoot;
-    private finalizedSlot;
-    isKnown(blockRoot: RootHex): boolean;
-    add(blockRoot: RootHex, slot: Slot): void;
-    prune(finalizedSlot: Slot): void;
-}
-//# sourceMappingURL=seenExecutionPayloadEnvelope.d.ts.map

package/lib/chain/seenCache/seenExecutionPayloadEnvelope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"seenExecutionPayloadEnvelope.d.ts","sourceRoot":"","sources":["../../../src/chain/seenCache/seenExecutionPayloadEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,iBAAiB,CAAC;AAE9C;;;;;GAKG;AACH,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA4B;IAC5D,OAAO,CAAC,aAAa,CAAW;IAEhC,OAAO,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAEnC;IAED,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAMxC;IAED,KAAK,CAAC,aAAa,EAAE,IAAI,GAAG,IAAI,CAQ/B;CACF"}

package/lib/chain/seenCache/seenExecutionPayloadEnvelope.js

@@ -1,28 +0,0 @@
-/**
- * Cache to prevent processing multiple execution payload envelopes for the same block root.
- * Only one builder qualifies to submit an execution payload for a given slot.
- * We only keep track of envelopes of unfinalized slots.
- * [IGNORE] The node has not seen another valid `SignedExecutionPayloadEnvelope` for this block root.
- */
-export class SeenExecutionPayloadEnvelopes {
-    slotByBlockRoot = new Map();
-    finalizedSlot = 0;
-    isKnown(blockRoot) {
-        return this.slotByBlockRoot.has(blockRoot);
-    }
-    add(blockRoot, slot) {
-        if (slot < this.finalizedSlot) {
-            throw Error(`slot ${slot} < finalizedSlot ${this.finalizedSlot}`);
-        }
-        this.slotByBlockRoot.set(blockRoot, slot);
-    }
-    prune(finalizedSlot) {
-        this.finalizedSlot = finalizedSlot;
-        for (const [blockRoot, slot] of this.slotByBlockRoot.entries()) {
-            if (slot < finalizedSlot) {
-                this.slotByBlockRoot.delete(blockRoot);
-            }
-        }
-    }
-}
-//# sourceMappingURL=seenExecutionPayloadEnvelope.js.map

package/lib/chain/seenCache/seenExecutionPayloadEnvelope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"seenExecutionPayloadEnvelope.js","sourceRoot":"","sources":["../../../src/chain/seenCache/seenExecutionPayloadEnvelope.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,OAAO,6BAA6B;IACvB,eAAe,GAAG,IAAI,GAAG,EAAiB,CAAC;IACpD,aAAa,GAAS,CAAC,CAAC;IAEhC,OAAO,CAAC,SAAkB,EAAW;QACnC,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAAA,CAC5C;IAED,GAAG,CAAC,SAAkB,EAAE,IAAU,EAAQ;QACxC,IAAI,IAAI,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAC9B,MAAM,KAAK,CAAC,QAAQ,IAAI,oBAAoB,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QACpE,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAAA,CAC3C;IAED,KAAK,CAAC,aAAmB,EAAQ;QAC/B,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QAEnC,KAAK,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,EAAE,CAAC;YAC/D,IAAI,IAAI,GAAG,aAAa,EAAE,CAAC;gBACzB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACzC,CAAC;QACH,CAAC;IAAA,CACF;CACF"}

package/src/chain/seenCache/seenExecutionPayloadEnvelope.ts

@@ -1,34 +0,0 @@
-import {RootHex, Slot} from "@lodestar/types";
-
-/**
- * Cache to prevent processing multiple execution payload envelopes for the same block root.
- * Only one builder qualifies to submit an execution payload for a given slot.
- * We only keep track of envelopes of unfinalized slots.
- * [IGNORE] The node has not seen another valid `SignedExecutionPayloadEnvelope` for this block root.
- */
-export class SeenExecutionPayloadEnvelopes {
-  private readonly slotByBlockRoot = new Map<RootHex, Slot>();
-  private finalizedSlot: Slot = 0;
-
-  isKnown(blockRoot: RootHex): boolean {
-    return this.slotByBlockRoot.has(blockRoot);
-  }
-
-  add(blockRoot: RootHex, slot: Slot): void {
-    if (slot < this.finalizedSlot) {
-      throw Error(`slot ${slot} < finalizedSlot ${this.finalizedSlot}`);
-    }
-
-    this.slotByBlockRoot.set(blockRoot, slot);
-  }
-
-  prune(finalizedSlot: Slot): void {
-    this.finalizedSlot = finalizedSlot;
-
-    for (const [blockRoot, slot] of this.slotByBlockRoot.entries()) {
-      if (slot < finalizedSlot) {
-        this.slotByBlockRoot.delete(blockRoot);
-      }
-    }
-  }
-}