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

package/src/network/subnets/attnetsService.ts

@@ -20,6 +20,7 @@ const gossipType = GossipType.beacon_attestation;
 export enum SubnetSource {
   committee = "committee",
   longLived = "long_lived",
+  beforeProposal = "before_proposal",
 }
 
 // map of subnet to time to form stable mesh as seconds, null if not yet formed
@@ -40,7 +41,7 @@ export class AttnetsService implements IAttnetsService {
   /** Committee subnets - PeerManager must find peers for those */
   private committeeSubnets = new SubnetMap();
   /**
-   * All currently subscribed short-lived subnets, for attestation aggregation
+   * All currently subscribed short-lived subnets, for attestation aggregation and before local block proposals
    * This class will tell gossip to subscribe and un-subscribe
    * If a value exists for `SubscriptionId` it means that gossip subscription is active in network.gossip
    */
@@ -52,6 +53,11 @@ export class AttnetsService implements IAttnetsService {
    * Used to determine if we should process an attestation.
    */
   private aggregatorSlotSubnet = new MapDef<Slot, AggregatorDutyInfo>(() => new Map());
+  /**
+   * Block proposal slots of validators connected to this node.
+   * Used to subscribe to all subnets `slotsToSubscribeBeforeProposalDuty` slots before, see onSlot
+   */
+  private localProposalSlots = new Set<Slot>();
 
   constructor(
     private readonly config: BeaconConfig,
@@ -119,6 +125,22 @@ export class AttnetsService implements IAttnetsService {
     }
   }
 
+  /**
+   * Called from the main thread with upcoming block proposal slots of connected validators.
+   * Tracked here, the subscription happens in onSlot like aggregator duties, or right away for a proposal learned
+   * after its subscription slot (node restart, newly connected validator)
+   */
+  addLocalProposalSlots(slots: Slot[]): void {
+    const clockSlot = this.clock.currentSlot;
+    for (const proposalSlot of slots) {
+      this.localProposalSlots.add(proposalSlot);
+      // not from the slot before the proposal, its votes are published before a mesh could form
+      if (proposalSlot - this.opts.slotsToSubscribeBeforeProposalDuty <= clockSlot && clockSlot < proposalSlot - 1) {
+        this.subscribeAllSubnetsUntilProposal(proposalSlot);
+      }
+    }
+  }
+
   /**
    * Check if a subscription is still active before handling a gossip object
    */
@@ -158,7 +180,8 @@ export class AttnetsService implements IAttnetsService {
 
   /**
    * Run per slot.
-   * - Subscribe to gossip subnets 2 slots in advance
+   * - Subscribe to gossip subnets 2 slots in advance of aggregator duties
+   * - Subscribe to all subnets `slotsToSubscribeBeforeProposalDuty` slots in advance of local block proposals
    * - Unsubscribe from expired subnets
    * - Track time to stable mesh if not yet formed
    */
@@ -186,19 +209,76 @@ export class AttnetsService implements IAttnetsService {
         this.trackTimeToStableMesh(clockSlot, dutiedSlot, dutiedInfo);
       }
 
+      // Must run before unsubscribeExpiredCommitteeSubnets so that a subnet whose subscription expires in this slot
+      // gets its ttl extended instead of being unsubscribed and subscribed again
+      this.subscribeAllSubnetsBeforeProposal(clockSlot);
+
       this.unsubscribeExpiredCommitteeSubnets(clockSlot);
       this.pruneExpiredAggregator(clockSlot);
+      this.pruneExpiredLocalProposals(clockSlot);
     } catch (e) {
       this.logger.error("Error on AttnetsService.onSlot", {slot: clockSlot}, e as Error);
     }
   };
 
   private onHalfSlot = (clockSlot: Slot): void => {
-    for (const [dutiedSlot, dutiedInfo] of this.aggregatorSlotSubnet.entries()) {
-      this.trackTimeToStableMesh(clockSlot, dutiedSlot, dutiedInfo);
+    try {
+      for (const [dutiedSlot, dutiedInfo] of this.aggregatorSlotSubnet.entries()) {
+        this.trackTimeToStableMesh(clockSlot, dutiedSlot, dutiedInfo);
+      }
+
+      this.unsubscribeAllSubnetsBeforeProposal(clockSlot);
+    } catch (e) {
+      this.logger.error("Error on AttnetsService.onHalfSlot", {slot: clockSlot}, e as Error);
     }
   };
 
+  /**
+   * Subscribe to all subnets `slotsToSubscribeBeforeProposalDuty` slots before a block proposal of a connected
+   * validator, so that single attestations of those slots can be packed into the block. The subscription expires in
+   * the slot before the proposal, see unsubscribeAllSubnetsBeforeProposal
+   */
+  private subscribeAllSubnetsBeforeProposal(clockSlot: Slot): void {
+    for (const proposalSlot of this.localProposalSlots) {
+      if (proposalSlot === clockSlot + this.opts.slotsToSubscribeBeforeProposalDuty) {
+        this.subscribeAllSubnetsUntilProposal(proposalSlot);
+      }
+    }
+  }
+
+  private subscribeAllSubnetsUntilProposal(proposalSlot: Slot): void {
+    if (this.opts.slotsToSubscribeBeforeProposalDuty === 0 || this.opts.subscribeAllSubnets) {
+      return;
+    }
+
+    const subnets = Array.from({length: ATTESTATION_SUBNET_COUNT}, (_, subnet) => subnet);
+    // Same as aggregator duties: trigger gossip subscription first, then register the subscriptions.
+    // Do not add to committeeSubnets: it drives peer discovery, we only use the peers we already have
+    this.subscribeToSubnets(subnets, SubnetSource.beforeProposal);
+    for (const subnet of subnets) {
+      this.shortLivedSubscriptions.request({subnet, toSlot: proposalSlot - 1});
+    }
+  }
+
+  /**
+   * Unsubscribe from subnets of subscribeAllSubnetsBeforeProposal at half of the slot before the proposal instead of
+   * the proposal slot start, so the proposal slot does not carry their traffic. Single attestations are published at
+   * 1/3 of the slot so they have arrived by then.
+   * Short-lived subscriptions are either aggregator duties or these, an aggregator duty ends in its dutied slot and is
+   * kept here (aggregates are due later), it expires at the next slot start in onSlot as before. So only subnets of
+   * subscribeAllSubnetsBeforeProposal are unsubscribed here.
+   */
+  private unsubscribeAllSubnetsBeforeProposal(clockSlot: Slot): void {
+    const aggregatorSubnets = this.aggregatorSlotSubnet.get(clockSlot);
+    const expiring = this.shortLivedSubscriptions.getExpired(
+      clockSlot + 1,
+      (subnet) => aggregatorSubnets?.has(subnet) === true
+    );
+    if (expiring.length > 0) {
+      this.unsubscribeSubnets(expiring, clockSlot + 1, SubnetSource.beforeProposal);
+    }
+  }
+
   /**
    * Track time to form stable mesh if not yet formed
    */
@@ -291,8 +371,8 @@ export class AttnetsService implements IAttnetsService {
   }
 
   /**
-   * Unsubscribe to a committee subnet from subscribedCommitteeSubnets.
-   * If a random subnet is present, we do not unsubscribe from it.
+   * Unsubscribe from short-lived subnets whose subscription expired.
+   * If a long-lived subnet is present, we do not unsubscribe from it.
    */
   private unsubscribeExpiredCommitteeSubnets(slot: Slot): void {
     const expired = this.shortLivedSubscriptions.getExpired(slot);
@@ -313,6 +393,14 @@ export class AttnetsService implements IAttnetsService {
     }
   }
 
+  private pruneExpiredLocalProposals(currentSlot: Slot): void {
+    for (const proposalSlot of this.localProposalSlots) {
+      if (currentSlot > proposalSlot) {
+        this.localProposalSlots.delete(proposalSlot);
+      }
+    }
+  }
+
   /** Update ENR */
   private updateMetadata(): void {
     const subnets = ssz.phase0.AttestationSubnets.defaultValue();

package/src/network/subnets/interface.ts

@@ -25,6 +25,8 @@ export type SubnetsService = {
 
 export interface IAttnetsService extends SubnetsService {
   shouldProcess(subnet: SubnetID, slot: Slot): boolean;
+  /** Block proposal slots of validators connected to this node, see `slotsToSubscribeBeforeProposalDuty` */
+  addLocalProposalSlots(slots: Slot[]): void;
 }
 
 export type RandBetweenFn = (min: number, max: number) => number;
@@ -33,6 +35,11 @@ export type ShuffleFn = <T>(arr: T[]) => T[];
 export type SubnetsServiceOpts = {
   subscribeAllSubnets?: boolean;
   slotsToSubscribeBeforeAggregatorDuty: number;
+  /**
+   * Subscribe to all attestation subnets this many slots before a block proposal of a connected validator, so that
+   * its single attestations can be packed into the block. In `[0, SLOTS_PER_EPOCH]`, 0 disables
+   */
+  slotsToSubscribeBeforeProposalDuty: number;
 };
 
 export type SubnetsServiceTestOpts = {

package/src/node/nodejs.ts

@@ -20,7 +20,7 @@ import {
   isStatePostGloas,
 } from "@lodestar/state-transition";
 import {Slot} from "@lodestar/types";
-import {sleep, toRootHex} from "@lodestar/utils";
+import {defer, sleep, toRootHex} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
 import {BeaconRestApiServer, getApi} from "../api/index.js";
 import {getDataColumnSidecarsMinEpoch} from "../chain/archiveStore/utils/archiveBlocks.js";
@@ -117,6 +117,7 @@ export class BeaconNode {
 
   status: BeaconNodeStatus;
   private controller?: AbortController;
+  private closePromise: Promise<void> | undefined;
 
   constructor({
     opts,
@@ -297,6 +298,7 @@ export class BeaconNode {
         : undefined,
       builderApiClientOpts: {
         timeout: opts.executionBuilder.timeout,
+        bidDeadline: opts.executionBuilder.bidDeadline,
         // Sent with all builder api requests, unless the node runs in private mode
         userAgent: opts.executionBuilder.userAgent,
       },
@@ -392,23 +394,40 @@ export class BeaconNode {
   /**
    * Stop beacon node and its sub-components.
    */
-  async close(): Promise<void> {
-    if (this.status === BeaconNodeStatus.started) {
-      this.status = BeaconNodeStatus.closing;
-      this.sync.close();
-      if (this.restApi) await this.restApi.close();
-      await this.network.close();
-      if (this.metricsServer) await this.metricsServer.close();
-      if (this.monitoring) await this.monitoring.close();
-      await this.chain.persistToDisk();
-      await this.chain.close();
+  close(): Promise<void> {
+    if (this.closePromise !== undefined) return this.closePromise;
+    const completion = defer<void>();
+    this.closePromise = completion.promise;
+    this.status = BeaconNodeStatus.closing;
+    void this.closeInternal().then(completion.resolve, completion.reject);
+    return this.closePromise;
+  }
+
+  private async closeInternal(): Promise<void> {
+    const errors: unknown[] = [];
+    for (const cleanup of [
+      () => this.sync.close(),
+      () => this.restApi?.close(),
+      () => this.network.close(),
+      () => this.metricsServer?.close(),
+      () => this.monitoring?.close(),
+      () => this.chain.persistToDisk(),
+      () => this.chain.close(),
       // Abort signal last: close() calls above clear intervals/timeouts so no new
       // operations get scheduled. If we aborted first, a still-pending interval could
       // fire and schedule a new operation after abort, leaving it stuck and delaying shutdown.
-      if (this.controller) this.controller.abort();
-      await sleep(DELAY_BEFORE_CLOSING_DB_MS);
-      await this.db.close();
-      this.status = BeaconNodeStatus.closed;
+      () => this.controller?.abort(),
+      () => sleep(DELAY_BEFORE_CLOSING_DB_MS),
+      () => this.db.close(),
+    ]) {
+      try {
+        await cleanup();
+      } catch (error) {
+        errors.push(error);
+      }
     }
+    this.status = BeaconNodeStatus.closed;
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) throw new AggregateError(errors, "Beacon node cleanup failed");
   }
 }

package/src/node/options.ts

@@ -1,7 +1,9 @@
+import {BLOCK_PRODUCTION_RACE_CUTOFF_GLOAS_BPS} from "../api/impl/validator/index.js";
 import {ApiOptions, defaultApiOptions} from "../api/options.js";
 import {ArchiveMode, DEFAULT_ARCHIVE_MODE, IChainOptions, defaultChainOptions} from "../chain/options.js";
 import {ValidatorMonitorOpts, defaultValidatorMonitorOpts} from "../chain/validatorMonitor.js";
 import {DatabaseOptions, defaultDbOptions} from "../db/options.js";
+import {BUILDER_BID_LAG_BUFFER_MS} from "../execution/builder/apiClient.js";
 import {
   EngineApiMode,
   ExecutionBuilderOpts,
@@ -20,9 +22,11 @@ import {SyncOptions, defaultSyncOptions} from "../sync/options.js";
 // Re-export so the CLI doesn't need to depend on lodestar-api
 export {allNamespaces} from "../api/rest/index.js";
 export type {EngineApiMode};
-// Re-export to use as default values in CLI args
+// Re-export to use as default values and for validation in CLI args
 export {
   ArchiveMode,
+  BLOCK_PRODUCTION_RACE_CUTOFF_GLOAS_BPS,
+  BUILDER_BID_LAG_BUFFER_MS,
   DEFAULT_ARCHIVE_MODE,
   defaultExecutionBuilderHttpOpts,
   defaultExecutionEngineHttpOpts,

package/src/sync/range/batch.ts

@@ -1,5 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkName, isForkPostDeneb, isForkPostFulu, isForkPostGloas} from "@lodestar/params";
+import {ForkName, isForkPostFulu, isForkPostGloas} from "@lodestar/params";
 import {Epoch, RootHex, SignedBeaconBlock, Slot, gloas, phase0} from "@lodestar/types";
 import {LodestarError, byteArrayEquals, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
@@ -112,7 +112,6 @@ export type BatchMetadata = {
   // Per-type outstanding request shapes; only present when that sub-request exists.
   // Format: "startSlot=<n>,count=<n>" (plus ",cols=<indices>" for columns).
   blocksReq?: string;
-  blobsReq?: string;
   columnsReq?: string;
   envelopesReq?: string;
 
@@ -159,7 +158,7 @@ export class Batch {
   readonly startSlot: Slot;
   readonly count: number;
 
-  /** Block, blob and column requests that are used to determine the best peer and are used in downloadByRange */
+  /** Block, column and envelope requests that are used to determine the best peer and are used in downloadByRange */
   requests: DownloadByRangeRequests;
   /** State of the batch. */
   state: BatchState = {status: BatchStatus.AwaitingDownload, blocks: [], payloadEnvelopes: null};
@@ -224,7 +223,7 @@ export class Batch {
   }
 
   /**
-   * Builds ByRange requests for block, blobs and columns
+   * Builds ByRange requests for block, columns and envelopes
    */
   private getRequests(blocks: IBlockInput[]): DownloadByRangeRequests {
     const withinValidRequestWindow = !isDaOutOfRange(
@@ -254,8 +253,6 @@ export class Batch {
           count: this.count,
           columns: this.custodyConfig.sampledColumns,
         };
-      } else if (isForkPostDeneb(this.forkName) && withinValidRequestWindow) {
-        requests.blobsRequest = {startSlot: this.startSlot, count: this.count};
       }
 
       return requests;
@@ -334,23 +331,15 @@ export class Batch {
     if (dataStartSlot <= endSlot) {
       // range of 40 - 63, startSlot will be inclusive but subtraction will exclusive so need to + 1
       const count = endSlot - dataStartSlot + 1;
-      if (isForkPostFulu(this.forkName) && withinValidRequestWindow) {
-        // Skip the column re-request when we have no specific column indices outstanding.
-        // Peer rejects an empty `columns` list
-        if (neededColumns.size > 0) {
-          requests.columnsRequest = {
-            count,
-            startSlot: dataStartSlot,
-            columns: Array.from(neededColumns),
-          };
-        }
-      } else if (isForkPostDeneb(this.forkName) && withinValidRequestWindow) {
-        requests.blobsRequest = {
+      // Peer rejects an empty `columns` list
+      if (isForkPostFulu(this.forkName) && withinValidRequestWindow && neededColumns.size > 0) {
+        requests.columnsRequest = {
           count,
           startSlot: dataStartSlot,
+          columns: Array.from(neededColumns),
         };
       }
-      // dataSlot will still have a value but do not create a request for preDeneb forks
+      // dataSlot will still have a value but do not create a request for pre-fulu forks
     }
 
     if (isForkPostGloas(this.forkName) && envelopeStartSlot <= endSlot) {
@@ -471,7 +460,7 @@ export class Batch {
   }
 
   getMetadata(): BatchMetadata {
-    const {blocksRequest, blobsRequest, columnsRequest, envelopesRequest} = this.requests;
+    const {blocksRequest, columnsRequest, envelopesRequest} = this.requests;
     const failedProcessingPeerList = this.failedProcessingAttempts.flatMap((a) => a.peers);
     const executionErrorPeerList = this.executionErrorAttempts.flatMap((a) => a.peers);
     return {
@@ -480,7 +469,6 @@ export class Batch {
       count: this.count,
       status: this.state.status,
       ...(blocksRequest && {blocksReq: formatRangeReq(blocksRequest)}),
-      ...(blobsRequest && {blobsReq: formatRangeReq(blobsRequest)}),
       ...(columnsRequest && {columnsReq: formatColumnsReq(columnsRequest)}),
       ...(envelopesRequest && {envelopesReq: formatRangeReq(envelopesRequest)}),
       downloadAttempts: this.failedDownloadAttempts.length,

package/src/sync/range/chain.ts

@@ -1,11 +1,10 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Epoch, Root, Slot} from "@lodestar/types";
 import {ErrorAborted, LodestarError, Logger, prettyPrintIndices, toRootHex} from "@lodestar/utils";
-import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
+import {isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputErrorCode} from "../../chain/blocks/blockInput/errors.js";
 import {IBlockInput} from "../../chain/blocks/blockInput/types.js";
 import {PayloadEnvelopeInput} from "../../chain/blocks/payloadEnvelopeInput/payloadEnvelopeInput.js";
-import {BlobSidecarErrorCode} from "../../chain/errors/blobSidecarError.js";
 import {DataColumnSidecarErrorCode} from "../../chain/errors/dataColumnSidecarError.js";
 import {Metrics} from "../../metrics/metrics.js";
 import {PeerAction, prettyPrintPeerIdStr} from "../../network/index.js";
@@ -569,12 +568,8 @@ export class SyncChain {
           // The below cases indicate the peer may be on a different chain, so are not penalized during head sync.
           switch (errCode) {
             case BlockInputErrorCode.MISMATCHED_ROOT_HEX:
-            case DownloadByRangeErrorCode.MISSING_BLOBS:
-            case DownloadByRangeErrorCode.EXTRA_BLOBS:
             case DownloadByRangeErrorCode.MISSING_COLUMNS:
             case DownloadByRangeErrorCode.EXTRA_COLUMNS:
-            case BlobSidecarErrorCode.INCORRECT_SIDECAR_COUNT:
-            case BlobSidecarErrorCode.INCORRECT_BLOCK:
             case DataColumnSidecarErrorCode.INCORRECT_SIDECAR_COUNT:
             case DataColumnSidecarErrorCode.INCORRECT_BLOCK:
               this.reportPeer(peer.peerId, PeerAction.LowToleranceError, res.err.message);
@@ -589,8 +584,6 @@ export class SyncChain {
           case DownloadByRangeErrorCode.INVALID_ENVELOPE_BLOCK_HASH:
           case DownloadByRangeErrorCode.INVALID_ENVELOPE_SLOT:
           case DownloadByRangeErrorCode.INVALID_CHAIN_SEGMENT:
-          case BlobSidecarErrorCode.INCLUSION_PROOF_INVALID:
-          case BlobSidecarErrorCode.INVALID_KZG_PROOF_BATCH:
           case DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT:
           case DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT:
           case DataColumnSidecarErrorCode.INVALID_KZG_PROOF_BATCH:
@@ -638,12 +631,7 @@ export class SyncChain {
         }
 
         for (const block of downloadSuccessOutput.blocks) {
-          if (isBlockInputBlobs(block)) {
-            const blockLogMeta = block.getLogMeta();
-            const expectedBlobs = typeof blockLogMeta.expectedBlobs === "number" ? blockLogMeta.expectedBlobs : 0;
-            logMeta.expectedBlobCount = (logMeta.expectedBlobCount ?? 0) + expectedBlobs;
-            logMeta.receivedBlobCount = (logMeta.receivedBlobCount ?? 0) + blockLogMeta.receivedBlobs;
-          } else if (isBlockInputColumns(block)) {
+          if (isBlockInputColumns(block)) {
             logMeta.columnCount = (logMeta.columnCount ?? 0) + block.getLogMeta().receivedColumns;
           }
         }

package/src/sync/sync.ts

@@ -33,6 +33,8 @@ export class BeaconSync implements IBeaconSync {
   /** For metrics only */
   private readonly peerSyncType = new Map<string, PeerSyncType>();
   private readonly slotImportTolerance: Slot;
+  /** The requested subscription state, set while a change is being applied */
+  private pendingGossipSubscribed: boolean | undefined;
 
   constructor(opts: SyncOptions, modules: SyncModules) {
     const {config, chain, db, metrics, network, logger} = modules;
@@ -89,6 +91,7 @@ export class BeaconSync implements IBeaconSync {
   }
 
   close(): void {
+    this.pendingGossipSubscribed = undefined;
     this.network.events.off(NetworkEvent.peerConnected, this.addPeer);
     this.network.events.off(NetworkEvent.peerDisconnected, this.removePeer);
     this.chain.clock.off(ClockEvent.epoch, this.onClockEpoch);
@@ -296,17 +299,7 @@ export class BeaconSync implements IBeaconSync {
     if (state === SyncState.Synced && this.chain.clock.currentEpoch >= MIN_EPOCH_TO_START_GOSSIP) {
       this.chain.forkChoice.resumeFastConfirmation();
 
-      if (!this.network.isSubscribedToGossipCoreTopics()) {
-        this.network
-          .subscribeGossipCoreTopics()
-          .then(() => {
-            this.metrics?.syncSwitchGossipSubscriptions.inc({action: "subscribed"});
-            this.logger.info("Subscribed gossip core topics");
-          })
-          .catch((e) => {
-            this.logger.error("Error subscribing to gossip core topics", {}, e);
-          });
-      }
+      this.setGossipSubscription(true);
 
       // also start searching for unknown blocks
       if (!this.unknownBlockSync.isSubscribedToNetwork()) {
@@ -322,17 +315,8 @@ export class BeaconSync implements IBeaconSync {
         // Same debounce as gossip: transient blips keep the rule running, only a real gap pauses it
         this.chain.forkChoice.pauseFastConfirmation();
 
-        if (this.network.isSubscribedToGossipCoreTopics()) {
-          this.logger.warn(`Node sync has fallen behind by ${syncDiff} slots`);
-          this.network
-            .unsubscribeGossipCoreTopics()
-            .then(() => {
-              this.metrics?.syncSwitchGossipSubscriptions.inc({action: "unsubscribed"});
-              this.logger.info("Un-subscribed gossip core topics");
-            })
-            .catch((e) => {
-              this.logger.error("Error unsubscribing to gossip core topics", {}, e);
-            });
+        if (this.setGossipSubscription(false)) {
+          this.logger.warn("Node sync has fallen behind", {slots: syncDiff});
         }
 
         // also stop searching for unknown blocks
@@ -344,6 +328,43 @@ export class BeaconSync implements IBeaconSync {
     }
   };
 
+  private setGossipSubscription(subscribe: boolean): boolean {
+    if ((this.pendingGossipSubscribed ?? this.network.isSubscribedToGossipCoreTopics()) === subscribe) return false;
+    const applying = this.pendingGossipSubscribed !== undefined;
+    this.pendingGossipSubscribed = subscribe;
+    if (!applying) void this.applyGossipSubscription();
+    return true;
+  }
+
+  /**
+   * Applies the latest requested state one request at a time. Network skips a subscribe issued while an unsubscribe is
+   * in flight, so opposite requests must not overlap.
+   */
+  private async applyGossipSubscription(): Promise<void> {
+    for (;;) {
+      const subscribe = this.pendingGossipSubscribed;
+      if (subscribe === undefined || subscribe === this.network.isSubscribedToGossipCoreTopics()) break;
+      try {
+        await (subscribe ? this.network.subscribeGossipCoreTopics() : this.network.unsubscribeGossipCoreTopics());
+      } catch (e) {
+        this.logger.error(
+          subscribe ? "Error subscribing to gossip core topics" : "Error unsubscribing to gossip core topics",
+          {},
+          e as Error
+        );
+        // Leave a retry of the same request to the next sync state update
+        if (this.pendingGossipSubscribed === subscribe) break;
+        continue;
+      }
+      if (this.pendingGossipSubscribed === undefined || this.network.isSubscribedToGossipCoreTopics() !== subscribe) {
+        break;
+      }
+      this.metrics?.syncSwitchGossipSubscriptions.inc({action: subscribe ? "subscribed" : "unsubscribed"});
+      this.logger.info(subscribe ? "Subscribed gossip core topics" : "Un-subscribed gossip core topics");
+    }
+    this.pendingGossipSubscribed = undefined;
+  }
+
   private onClockEpoch = (): void => {
     // If a node witness the genesis event consider starting gossip
     // Also, ensure that updateSyncState is run at least once per epoch.

package/src/sync/unknownBlock.ts

@@ -6,7 +6,7 @@ import {RequestError, RequestErrorCode} from "@lodestar/reqresp";
 import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {RootHex, Slot, gloas} from "@lodestar/types";
 import {Logger, fromHex, isErrorAborted, prettyPrintIndices, pruneSetToMax, sleep, 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 {PayloadError, PayloadErrorCode} from "../chain/blocks/importExecutionPayload.js";
 import {PayloadEnvelopeInput, PayloadEnvelopeInputSource} from "../chain/blocks/payloadEnvelopeInput/index.js";
@@ -1910,13 +1910,6 @@ export class BlockInputSync {
       throw new Error(`${message} Block was not found.`);
     }
 
-    if (isBlockInputBlobs(cacheItem.blockInput)) {
-      const missing = cacheItem.blockInput.getMissingBlobMeta().map((b) => b.index);
-      if (missing.length) {
-        throw new Error(`${message} Missing blob indices=${prettyPrintIndices(missing)}.`);
-      }
-    }
-
     if (isBlockInputColumns(cacheItem.blockInput)) {
       const missing = cacheItem.blockInput.getMissingSampledColumnMeta().missing;
       if (missing.length) {