@lodestar/beacon-node 1.51.0-dev.d422f387ac → 1.51.0-dev.d5620be4a1

package/src/execution/engine/types.ts

@@ -26,7 +26,6 @@ import {
   ssz,
   sszTypesFor,
 } from "@lodestar/types";
-import {BlobAndProof} from "@lodestar/types/deneb";
 import {BlobAndProofV2} from "@lodestar/types/fulu";
 import {
   ExecutionPayloadStatus,
@@ -102,7 +101,6 @@ export type EngineApiRpcParamTypes = {
    */
   engine_getClientVersionV1: [ClientVersionRpc];
 
-  engine_getBlobsV1: [DATA[]];
   engine_getBlobsV2: [DATA[]];
 
   engine_getInclusionListV1: [];
@@ -161,7 +159,6 @@ export type EngineApiRpcReturnTypes = {
 
   engine_getClientVersionV1: ClientVersionRpc[];
 
-  engine_getBlobsV1: (BlobAndProofRpc | null)[];
   engine_getBlobsV2: BlobAndProofV2Rpc[] | null;
 
   engine_getInclusionListV1: InclusionListRpc;
@@ -248,11 +245,6 @@ export type ConsolidationRequestsRpc = DATA;
 export type BuilderDepositRequestsRpc = DATA;
 export type BuilderExitRequestsRpc = DATA;
 
-export type BlobAndProofRpc = {
-  blob: DATA;
-  proof: DATA;
-};
-
 export type BlobAndProofV2Rpc = {
   blob: DATA;
   proofs: DATA[];
@@ -701,15 +693,6 @@ export function serializeExecutionPayloadBody(data: ExecutionPayloadBody | null)
     : null;
 }
 
-export function deserializeBlobAndProofs(data: BlobAndProofRpc | null): BlobAndProof | null {
-  return data
-    ? {
-        blob: dataToBytes(data.blob, BLOB_BYTES),
-        proof: dataToBytes(data.proof, PROOF_BYTES),
-      }
-    : null;
-}
-
 export function deserializeBlobAndProofsV2(data: BlobAndProofV2Rpc): BlobAndProofV2 {
   return {
     blob: dataToBytes(data.blob, BLOB_BYTES),

package/src/execution/engine/utils.ts

@@ -169,14 +169,16 @@ function getExecutionEngineStateForPayloadStatus(payloadStatus: ExecutionPayload
       return ExecutionEngineState.SYNCED;
 
     case ExecutionPayloadStatus.ELERROR:
-    case ExecutionPayloadStatus.INVALID:
     case ExecutionPayloadStatus.SYNCING:
-    case ExecutionPayloadStatus.INVALID_BLOCK_HASH:
       return ExecutionEngineState.SYNCING;
 
     case ExecutionPayloadStatus.UNAVAILABLE:
       return ExecutionEngineState.OFFLINE;
 
+    case ExecutionPayloadStatus.INVALID:
+    case ExecutionPayloadStatus.INVALID_BLOCK_HASH:
+      return ExecutionEngineState.ONLINE;
+
     default:
       // In case we can't determine the state, we assume it stays in old state
       // This assumption is better than considering offline, because the offline state may trigger some notifications

package/src/index.ts

@@ -7,7 +7,7 @@ export {DbCPStateDatastore} from "./chain/stateCache/datastore/db.js";
 export {FileCPStateDatastore} from "./chain/stateCache/datastore/file.js";
 export {BeaconDb, type IBeaconDb} from "./db/index.js";
 // Export execution engine to make it usable by builder
-export {initializeExecutionEngine} from "./execution/index.js";
+export {ExecutionPayloadStatus, initializeExecutionEngine} from "./execution/index.js";
 // Export metrics utilities to de-duplicate validator metrics
 export {
   type HttpMetricsServer,

package/src/metrics/metrics/beacon.ts

@@ -186,36 +186,6 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
       }),
     },
 
-    blobs: {
-      getBlobsV1Requests: register.gauge({
-        name: "beacon_get_blobs_v1_calls_total",
-        help: "Number of getBlobsV1 requests that get made",
-      }),
-      getBlobsV1RequestedBlobCount: register.gauge({
-        name: "beacon_get_blobs_v1_requested_blobs_count_total",
-        help: "Number of versioned hashes that get sent in getBlobsV1 request",
-      }),
-      getBlobsV1Error: register.gauge({
-        name: "beacon_get_blobs_v1_response_error_total",
-        help: "Number of getBlobsV1 calls that errored ",
-      }),
-      getBlobsV1Miss: register.gauge({
-        name: "beacon_get_blobs_v1_missing_blob_response_total",
-        help: "Number of getBlobsV1 misses where a versioned hash returns a null",
-      }),
-      getBlobsV1Hit: register.gauge({
-        name: "beacon_get_blobs_v1_blob_returned_response_total",
-        help: "Number of getBlobsV1 hits where a versioned hash returns blob",
-      }),
-      getBlobsV1HitButArrivedWhileWaiting: register.gauge({
-        name: "beacon_get_blobs_v1_blob_returned_but_arrived_during_response_total",
-        help: "Number of getBlobsV1 hits where a versioned hash returns blob but the blob already arrived via gossip",
-      }),
-      getBlobsV1HitUseful: register.gauge({
-        name: "beacon_get_blobs_v1_blob_useful_response_total",
-        help: "Number of getBlobsV1 hits where a versioned hash returns blob and the blob is needed so call is useful",
-      }),
-    },
     payloadEnvelopeReconstruction: {
       envelopes: register.counter<{result: "success" | "unavailable" | "mismatch"}>({
         name: "beacon_payload_envelope_reconstruction_envelopes_total",

package/src/metrics/metrics/lodestar.ts

@@ -1013,6 +1013,11 @@ export function createLodestarMetrics(
         help: "Time elapsed between block received and fully verified state, signatures and payload",
         buckets: [0.05, 0.1, 0.3, 0.5, 0.7, 1, 1.3, 1.6, 2, 2.5, 3, 3.5, 4],
       }),
+      receivedToConsensusVerifiedTime: register.histogram({
+        name: "lodestar_gossip_block_received_to_consensus_verified_seconds",
+        help: "Time from gossip block arrival until both the state transition and all block signature verifications are complete, excluding execution payload verification",
+        buckets: [0.01, 0.015, 0.02, 0.025, 0.03, 0.04, 0.5, 1],
+      }),
       verifiedToBlobsAvailabiltyTime: register.histogram<{numBlobs: number}>({
         name: "lodestar_gossip_block_verified_to_blobs_availability_time",
         help: "Time elapsed between block verified and blobs became available",
@@ -1049,10 +1054,6 @@ export function createLodestarMetrics(
         help: "Time elapsed for blob validation",
         buckets: [0.05, 0.1, 0.2, 0.5, 1, 1.5, 2, 4],
       }),
-      publishedFromEngine: register.counter({
-        name: "lodestar_gossip_blob_published_from_engine_total",
-        help: "Total number of blobs retrieved from execution engine and published to gossip",
-      }),
     },
     // Gossip execution payload envelope
     gossipExecutionPayloadEnvelope: {
@@ -1174,11 +1175,6 @@ export function createLodestarMetrics(
         help: "Total number of imported blocks by source",
         labelNames: ["source"],
       }),
-      blobsBySource: register.gauge<{blobsSource: BlockInputSource}>({
-        name: "lodestar_import_blobs_by_source_total",
-        help: "Total number of imported blobs by source",
-        labelNames: ["blobsSource"],
-      }),
       notOverrideFcuReason: register.counter<{reason: NotReorgedReason}>({
         name: "lodestar_import_block_not_override_fcu_reason_total",
         help: "Reason why the fcu call is not suppressed during block import",
@@ -1342,8 +1338,67 @@ export function createLodestarMetrics(
             name: "lodestar_oppool_aggregated_attestation_pool_packed_attestations_missing_shuffling_committees_total",
             help: "Total number of committees skipped due to missing shuffling when producing packed attestations",
           }),
+          attestationValue: register.counter<{source: "aggregate" | "single"}>({
+            name: "lodestar_oppool_packed_attestation_value_total",
+            help: "Sum of new seen effective balance increments times participation flag weight of packed attestations, by source",
+            labelNames: ["source"],
+          }),
+          blockNewSeenAttesters: register.gauge({
+            name: "lodestar_oppool_packed_attestations_block_new_seen_attesters",
+            help: "Total number of new seen attesters across all packed attestations of the last produced block",
+          }),
+          singlesValueRatio: register.histogram({
+            name: "lodestar_oppool_packed_attestations_singles_value_ratio",
+            help: "Ratio of attestation value contributed by single attestations per produced block",
+            buckets: [0, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1],
+          }),
+          singlesNewSeenAttesters: register.histogram({
+            name: "lodestar_oppool_packed_attestations_singles_new_seen_attesters",
+            help: "Number of attesters newly included only thanks to single attestations per produced block",
+            buckets: [0, 1, 5, 10, 25, 50, 100, 250, 500, 1000, 1024],
+          }),
+          singlesNewSeenAttestersByInclusionDistance: register.gauge<{inclusionDistance: number}>({
+            name: "lodestar_oppool_packed_attestations_singles_new_seen_attesters_by_inclusion_distance",
+            help: "Number of attesters newly included only thanks to single attestations in the last produced block, by inclusion distance",
+            labelNames: ["inclusionDistance"],
+          }),
+          singlesNewSeenEffectiveBalance: register.histogram({
+            name: "lodestar_oppool_packed_attestations_singles_new_seen_effective_balance",
+            help: "Effective balance increments of attesters newly included only thanks to single attestations per produced block",
+            buckets: [0, 32, 160, 320, 800, 1600, 3200, 8000, 32000],
+          }),
+          singlesOnlyConsolidations: register.histogram({
+            name: "lodestar_oppool_packed_attestations_singles_only_consolidations",
+            help: "Number of packed attestations built only from single attestations per produced block",
+            buckets: [0, 1, 2, 4, 8],
+          }),
+          singlesFoldedCommittees: register.histogram({
+            name: "lodestar_oppool_packed_attestations_singles_folded_committees",
+            help: "Number of committees in packed attestations that received single attestations per produced block",
+            buckets: [0, 1, 2, 4, 8, 16, 32, 64],
+          }),
         },
       },
+      singleAttestationPool: {
+        size: register.gauge({
+          name: "lodestar_oppool_single_attestation_pool_size",
+          help: "Current number of single attestations in the SingleAttestationPool",
+        }),
+        gossipInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_single_attestation_pool_gossip_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding a single attestation from gossip to the SingleAttestationPool",
+          labelNames: ["insertOutcome"],
+        }),
+        apiInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_single_attestation_pool_api_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding a single attestation from api to the SingleAttestationPool",
+          labelNames: ["insertOutcome"],
+        }),
+        deletedByBlock: register.counter({
+          name: "lodestar_oppool_single_attestation_pool_deleted_by_block_total",
+          help: "Total number of single attestations deleted because a canonical block includes them",
+        }),
+      },
       attestationPool: {
         size: register.gauge({
           name: "lodestar_oppool_attestation_pool_size",
@@ -1492,6 +1547,17 @@ export function createLodestarMetrics(
       },
     },
 
+    proposerTracker: {
+      proposalSlots: register.gauge({
+        name: "lodestar_proposer_tracker_proposal_slots",
+        help: "Current number of upcoming block proposals of connected validators tracked by the ProposerTracker",
+      }),
+      collectableSlot: register.gauge({
+        name: "lodestar_proposer_tracker_collectable_slot",
+        help: "1 if single attestations of the clock slot are collected for an upcoming local proposal, 0 otherwise",
+      }),
+    },
+
     chain: {
       blacklistedBlocks: register.gauge({
         name: "lodestar_blacklisted_blocks_total",
@@ -1788,11 +1854,6 @@ export function createLodestarMetrics(
           help: "Total number of duplicate blocks that pass validation and attempt to be cached but are known",
           labelNames: ["source"],
         }),
-        duplicateBlobCount: register.counter<{source: BlockInputSource}>({
-          name: "lodestar_seen_block_input_cache_duplicate_blob_total",
-          help: "Total number of duplicate blobs that pass validation and attempt to be cached but are known",
-          labelNames: ["source"],
-        }),
         duplicateColumnCount: register.counter<{source: BlockInputSource}>({
           name: "lodestar_seen_block_input_cache_duplicate_column_total",
           help: "Total number of duplicate columns that pass validation and attempt to be cached but are known",
@@ -1802,10 +1863,6 @@ export function createLodestarMetrics(
           name: "lodestar_seen_block_input_cache_items_created_by_block_total",
           help: "Number of BlockInputs created via a block being seen first",
         }),
-        createdByBlob: register.counter({
-          name: "lodestar_seen_block_input_cache_items_created_by_blob_total",
-          help: "Number of BlockInputs created via a blob being seen first",
-        }),
         createdByColumn: register.counter({
           name: "lodestar_seen_block_input_cache_items_created_by_column_total",
           help: "Number of BlockInputs created via a data column being seen first",

package/src/metrics/server/http.ts

@@ -44,16 +44,16 @@ export async function getHttpMetricsServer(
   ): Promise<void> {
     if (req.method === "GET" && req.url && req.url.includes("/metrics")) {
       const timer = scrapeTimeMetric.startTimer();
-      const metricsRes = await Promise.all([wrapError(register.metrics()), getOtherMetrics()]);
-      timer({status: metricsRes[0].err ? RequestStatus.error : RequestStatus.success});
+      const metricsRes = await wrapError(Promise.all([register.metrics(), getOtherMetrics()]));
+      timer({status: metricsRes.err ? RequestStatus.error : RequestStatus.success});
 
       // Ensure we only writeHead once
-      if (metricsRes[0].err) {
-        res.writeHead(500, {"content-type": "text/plain"}).end(metricsRes[0].err.stack);
+      if (metricsRes.err) {
+        res.writeHead(500, {"content-type": "text/plain"}).end(metricsRes.err.stack);
       } else {
         // Get scrape time metrics
         const httpServerMetrics = await httpServerRegister.metrics();
-        const metrics = [metricsRes[0].result, httpServerMetrics, ...metricsRes[1]];
+        const metrics = [metricsRes.result[0], httpServerMetrics, ...metricsRes.result[1]];
         const metricsStr = metrics.join("\n\n");
         res.writeHead(200, {"content-type": register.contentType}).end(metricsStr);
       }

package/src/network/core/networkCore.ts

@@ -8,7 +8,7 @@ import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";
 import {isForkPostFulu} from "@lodestar/params";
 import {ResponseIncoming} from "@lodestar/reqresp";
-import {Epoch, Status, fulu, sszTypesFor} from "@lodestar/types";
+import {Epoch, Slot, Status, fulu, sszTypesFor} from "@lodestar/types";
 import {formatNodePeer} from "../../api/impl/node/utils.js";
 import {GoodByeReasonCode} from "../../constants/index.js";
 import {RegistryMetricCreator} from "../../metrics/index.js";
@@ -345,6 +345,11 @@ export class NetworkCore implements INetworkCore {
     if (subscriptions.length > 0) this.peerManager.onCommitteeSubscriptions();
   }
 
+  async addLocalProposalSlots(slots: Slot[]): Promise<void> {
+    // no peerManager.onCommitteeSubscriptions(): the extra subscription relies on connected peers, no discovery
+    this.attnetsService.addLocalProposalSlots(slots);
+  }
+
   async prepareSyncCommitteeSubnets(subscriptions: CommitteeSubscription[]): Promise<void> {
     this.syncnetsService.addCommitteeSubscriptions(subscriptions);
     if (subscriptions.length > 0) this.peerManager.onCommitteeSubscriptions();

package/src/network/core/networkCoreWorker.ts

@@ -136,6 +136,7 @@ const libp2pWorkerApi: NetworkWorkerApi = {
 
   prepareBeaconCommitteeSubnets: (subscriptions) => core.prepareBeaconCommitteeSubnets(subscriptions),
   prepareSyncCommitteeSubnets: (subscriptions) => core.prepareSyncCommitteeSubnets(subscriptions),
+  addLocalProposalSlots: (slots) => core.addLocalProposalSlots(slots),
   reportPeer: (peer, action, actionName) => core.reportPeer(peer, action, actionName),
   reStatusPeers: (peers) => core.reStatusPeers(peers),
   goodbyeAndDisconnect: (peer, reason) => core.goodbyeAndDisconnect(peer, reason),

package/src/network/core/networkCoreWorkerHandler.ts

@@ -9,7 +9,7 @@ import {routes} from "@lodestar/api";
 import {BeaconConfig, chainConfigToJson} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";
 import {ResponseIncoming, ResponseOutgoing} from "@lodestar/reqresp";
-import {Status} from "@lodestar/types";
+import {Slot, Status} from "@lodestar/types";
 import {withTimeout} from "@lodestar/utils";
 import {GoodByeReasonCode} from "../../constants/index.js";
 import {Metrics} from "../../metrics/index.js";
@@ -220,6 +220,9 @@ export class WorkerNetworkCore implements INetworkCore {
   prepareSyncCommitteeSubnets(subscriptions: CommitteeSubscription[]): Promise<void> {
     return this.getApi().prepareSyncCommitteeSubnets(subscriptions);
   }
+  addLocalProposalSlots(slots: Slot[]): Promise<void> {
+    return this.getApi().addLocalProposalSlots(slots);
+  }
   subscribeGossipCoreTopics(): Promise<void> {
     return this.getApi().subscribeGossipCoreTopics();
   }

package/src/network/core/types.ts

@@ -4,7 +4,7 @@ import {routes} from "@lodestar/api";
 import {SpecJson} from "@lodestar/config";
 import {LoggerNodeOpts} from "@lodestar/logger/node";
 import {ResponseIncoming} from "@lodestar/reqresp";
-import {Status} from "@lodestar/types";
+import {Slot, Status} from "@lodestar/types";
 import {GoodByeReasonCode} from "../../constants/index.js";
 import {PeerIdStr} from "../../util/peerId.js";
 import {NetworkOptions} from "../options.js";
@@ -62,6 +62,8 @@ export interface INetworkCore extends INetworkCorePublic {
 
   /** Chain must push status updates to the network core */
   updateStatus(status: Status): Promise<void>;
+  /** Block proposal slots of connected validators, used to subscribe to all attestation subnets before them */
+  addLocalProposalSlots(slots: Slot[]): Promise<void>;
 
   setTargetGroupCount(count: number): Promise<void>;
   /** Opens stream to handle ReqResp outgoing request */
@@ -111,6 +113,7 @@ export type NetworkWorkerApi = INetworkCorePublic & {
   getConnectedPeers(): Promise<PeerIdStr[]>;
   getConnectedPeerCount(): Promise<number>;
   updateStatus(status: Status): Promise<void>;
+  addLocalProposalSlots(slots: Slot[]): Promise<void>;
 
   setTargetGroupCount(count: number): Promise<void>;
 

package/src/network/gossip/gossipsub.ts

@@ -108,6 +108,7 @@ type GossipSubInternal = GossipSub & {
   score: {score: (peerIdStr: string) => number};
   direct: Set<string>;
   topics: Map<string, Set<string>>;
+  streamsOutbound: ReadonlyMap<string, unknown>;
   start: () => Promise<void>;
   stop: () => Promise<void>;
   publish: (topic: TopicStr, data: Uint8Array, opts?: PublishOpts) => Promise<PublishResult>;
@@ -248,6 +249,16 @@ export class Eth2Gossipsub {
     return this.gossipsub.getMeshPeers(topic);
   }
 
+  getSubscribersWithOutboundStream(topic: GossipTopic): Set<string> {
+    const topicStr = stringifyGossipTopic(this.config, topic);
+    const peers = new Set<string>();
+    for (const peer of this.gossipsub.getSubscribers(topicStr)) {
+      const id = peer.toString();
+      if (this.gossipsub.streamsOutbound.has(id)) peers.add(id);
+    }
+    return peers;
+  }
+
   publish(topic: TopicStr, data: Uint8Array, opts?: PublishOpts): Promise<PublishResult> {
     return this.gossipsub.publish(topic, data, opts);
   }

package/src/network/gossip/interface.ts

@@ -14,7 +14,6 @@ import {
   SubnetID,
   altair,
   capella,
-  deneb,
   gloas,
   heze,
   phase0,
@@ -27,7 +26,6 @@ import {JobItemQueue} from "../../util/queue/index.js";
 
 export enum GossipType {
   beacon_block = "beacon_block",
-  blob_sidecar = "blob_sidecar",
   data_column_sidecar = "data_column_sidecar",
   beacon_aggregate_and_proof = "beacon_aggregate_and_proof",
   beacon_attestation = "beacon_attestation",
@@ -64,7 +62,6 @@ export interface IGossipTopic {
 
 export type GossipTopicTypeMap = {
   [GossipType.beacon_block]: {type: GossipType.beacon_block};
-  [GossipType.blob_sidecar]: {type: GossipType.blob_sidecar; subnet: SubnetID};
   [GossipType.data_column_sidecar]: {type: GossipType.data_column_sidecar; subnet: SubnetID};
   [GossipType.beacon_aggregate_and_proof]: {type: GossipType.beacon_aggregate_and_proof};
   [GossipType.beacon_attestation]: {type: GossipType.beacon_attestation; subnet: SubnetID};
@@ -100,7 +97,6 @@ export type SSZTypeOfGossipTopic<T extends GossipTopic> = T extends {type: infer
 
 export type GossipTypeMap = {
   [GossipType.beacon_block]: SignedBeaconBlock;
-  [GossipType.blob_sidecar]: deneb.BlobSidecar;
   [GossipType.beacon_aggregate_and_proof]: SignedAggregateAndProof;
   [GossipType.beacon_attestation]: SingleAttestation;
   [GossipType.data_column_sidecar]: DataColumnSidecar;
@@ -121,7 +117,6 @@ export type GossipTypeMap = {
 
 export type GossipFnByType = {
   [GossipType.beacon_block]: (signedBlock: SignedBeaconBlock) => Promise<void> | void;
-  [GossipType.blob_sidecar]: (blobSidecar: deneb.BlobSidecar) => Promise<void> | void;
   [GossipType.beacon_aggregate_and_proof]: (aggregateAndProof: SignedAggregateAndProof) => Promise<void> | void;
   [GossipType.beacon_attestation]: (attestation: SingleAttestation) => Promise<void> | void;
   [GossipType.data_column_sidecar]: (dataColumnSidecar: DataColumnSidecar) => Promise<void> | void;

package/src/network/gossip/topic.ts

@@ -97,8 +97,6 @@ function stringifyGossipTopicType(topic: GossipTopic): string {
     case GossipType.beacon_attestation:
     case GossipType.sync_committee:
       return `${topic.type}_${topic.subnet}`;
-    case GossipType.blob_sidecar:
-      return `${topic.type}_${topic.subnet}`;
     case GossipType.data_column_sidecar:
       return `${topic.type}_${topic.subnet}`;
   }
@@ -110,8 +108,6 @@ export function getGossipSSZType(topic: GossipTopic) {
     case GossipType.beacon_block:
       // beacon_block is updated in altair to support the updated SignedBeaconBlock type
       return ssz[fork].SignedBeaconBlock;
-    case GossipType.blob_sidecar:
-      return ssz.deneb.BlobSidecar;
     case GossipType.data_column_sidecar:
       return isForkPostFulu(fork) ? sszTypesFor(fork).DataColumnSidecar : ssz.fulu.DataColumnSidecar;
     case GossipType.beacon_aggregate_and_proof:
@@ -255,13 +251,6 @@ export function parseGossipTopic(forkDigestContext: ForkDigestContext, topicStr:
       }
     }
 
-    if (gossipTypeStr.startsWith(GossipType.blob_sidecar)) {
-      const subnetStr = gossipTypeStr.slice(GossipType.blob_sidecar.length + 1); // +1 for '_' concatenating the topic name and the subnet
-      const subnet = parseInt(subnetStr, 10);
-      if (Number.isNaN(subnet)) throw Error(`subnet ${subnetStr} is not a number`);
-      return {type: GossipType.blob_sidecar, subnet, boundary, encoding};
-    }
-
     if (gossipTypeStr.startsWith(GossipType.data_column_sidecar)) {
       const subnetStr = gossipTypeStr.slice(GossipType.data_column_sidecar.length + 1); // +1 for '_' concatenating the topic name and the subnet
       const subnet = parseInt(subnetStr, 10);
@@ -309,18 +298,6 @@ export function getCoreTopicsAtFork(
     topics.push(...getDataColumnSidecarTopics(networkConfig, opts.subscribeAllColumnSubnets));
   }
 
-  // After Deneb and before Fulu also track blob_sidecar_{subnet_id}
-  if (ForkSeq[fork] >= ForkSeq.deneb && ForkSeq[fork] < ForkSeq.fulu) {
-    const {config} = networkConfig;
-    const subnetCount = isForkPostElectra(fork)
-      ? config.BLOB_SIDECAR_SUBNET_COUNT_ELECTRA
-      : config.BLOB_SIDECAR_SUBNET_COUNT;
-
-    for (let subnet = 0; subnet < subnetCount; subnet++) {
-      topics.push({type: GossipType.blob_sidecar, subnet});
-    }
-  }
-
   // capella
   if (ForkSeq[fork] >= ForkSeq.capella) {
     topics.push({type: GossipType.bls_to_execution_change});
@@ -405,7 +382,6 @@ function parseEncodingStr(encodingStr: string): GossipEncoding {
 // TODO: Review which yes, and which not
 export const gossipTopicIgnoreDuplicatePublishError: Record<GossipType, boolean> = {
   [GossipType.beacon_block]: true,
-  [GossipType.blob_sidecar]: true,
   [GossipType.data_column_sidecar]: true,
   [GossipType.beacon_aggregate_and_proof]: true,
   [GossipType.beacon_attestation]: true,
@@ -438,7 +414,6 @@ export const gossipTopicIgnoreDuplicatePublishError: Record<GossipType, boolean>
  */
 export const gossipTopicAllowPublishToZeroPeers: Record<GossipType, boolean> = {
   [GossipType.beacon_block]: false,
-  [GossipType.blob_sidecar]: false,
   // data_column_sidecar: we ensure having all topic peers via prioritizePeers(). Even with 0 peers on the
   // topic the overall publish can still succeed, because a supernode rebuilds and publishes the missing
   // columns for us, so track sent peers as 0 instead of raising

package/src/network/interface.ts

@@ -30,7 +30,6 @@ import {
   SubnetID,
   altair,
   capella,
-  deneb,
   fulu,
   gloas,
   heze,
@@ -42,7 +41,6 @@ import {CustodyConfig} from "../util/dataColumns.js";
 import {PeerIdStr} from "../util/peerId.js";
 import {
   BeaconBlocksByRootRequest,
-  BlobSidecarsByRootRequest,
   DataColumnSidecarsByRootRequest,
   ExecutionPayloadEnvelopesByRootRequest,
 } from "../util/types.js";
@@ -82,8 +80,6 @@ export interface INetwork extends INetworkCorePublic {
   sendBeaconBlocksByRange(peerId: PeerIdStr, request: phase0.BeaconBlocksByRangeRequest): Promise<SignedBeaconBlock[]>;
   sendBeaconBlocksByRoot(peerId: PeerIdStr, request: BeaconBlocksByRootRequest): Promise<SignedBeaconBlock[]>;
   sendBeaconBlocksByHead(peerId: PeerIdStr, request: fulu.BeaconBlocksByHeadRequest): Promise<SignedBeaconBlock[]>;
-  sendBlobSidecarsByRange(peerId: PeerIdStr, request: deneb.BlobSidecarsByRangeRequest): Promise<deneb.BlobSidecar[]>;
-  sendBlobSidecarsByRoot(peerId: PeerIdStr, request: BlobSidecarsByRootRequest): Promise<deneb.BlobSidecar[]>;
   sendDataColumnSidecarsByRange(
     peerId: PeerIdStr,
     request: fulu.DataColumnSidecarsByRangeRequest
@@ -103,7 +99,6 @@ export interface INetwork extends INetworkCorePublic {
 
   // Gossip
   publishBeaconBlock(signedBlock: SignedBeaconBlock): Promise<number>;
-  publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
   publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number>;
   publishBeaconAttestation(attestation: SingleAttestation, subnet: SubnetID): Promise<number>;
   publishDataColumnSidecar(