@lodestar/beacon-node 1.51.0-dev.c6e566f915 → 1.51.0-dev.cda05d18f1

package/src/network/processor/gossipQueues/index.ts

@@ -25,12 +25,6 @@ const linearGossipQueueOpts: {
 } = {
   // validation gossip block asap
   [GossipType.beacon_block]: {maxLength: 1024, type: QueueType.FIFO, dropOpts: {type: DropType.count, count: 1}},
-  // gossip length for blob is beacon block length * max blobs per block = 4096
-  [GossipType.blob_sidecar]: {
-    maxLength: 4096,
-    type: QueueType.FIFO,
-    dropOpts: {type: DropType.count, count: 1},
-  },
   [GossipType.data_column_sidecar]: {
     maxLength: 4096,
     type: QueueType.FIFO,

package/src/network/processor/gossipValidatorFn.ts

@@ -5,7 +5,6 @@ import {
   AttestationError,
   AttestationErrorCode,
   AttesterSlashingErrorCode,
-  BlobSidecarErrorCode,
   BlockErrorCode,
   BlsToExecutionChangeErrorCode,
   DataColumnSidecarErrorCode,
@@ -55,10 +54,6 @@ const gossipRejectPeerAction: Record<GossipType, RejectPeerActionRule> = {
     default: PeerAction.LowToleranceError,
     byCode: {[BlockErrorCode.PROPOSAL_SIGNATURE_INVALID]: PeerAction.Fatal},
   },
-  [GossipType.blob_sidecar]: {
-    default: PeerAction.LowToleranceError,
-    byCode: {[BlobSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID]: PeerAction.Fatal},
-  },
   [GossipType.data_column_sidecar]: {
     default: PeerAction.LowToleranceError,
     byCode: {[DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID]: PeerAction.Fatal},

package/src/network/processor/index.ts

@@ -125,7 +125,6 @@ type WorkOpts = {
 const executeGossipWorkOrderObj: Record<GossipType, WorkOpts> = {
   [GossipType.beacon_block]: {bypassQueue: true},
   [GossipType.execution_payload]: {bypassQueue: true},
-  [GossipType.blob_sidecar]: {bypassQueue: true},
   [GossipType.data_column_sidecar]: {bypassQueue: true},
   [GossipType.beacon_aggregate_and_proof]: {},
   [GossipType.voluntary_exit]: {},
@@ -244,6 +243,12 @@ type SearchUnknownRootTarget =
  * Such that enough work is processed to fill either one of the queue.
  */
 export class NetworkProcessor {
+  private stopped = false;
+  /**
+   * Replaced by dropAllJobs(). Loops that yield while re-queueing awaiting messages compare it after each yield
+   * and stop, so no message is queued after a drop.
+   */
+  private jobGeneration = Symbol();
   private readonly chain: IBeaconChain;
   private readonly core: INetworkCore;
   private readonly events: NetworkEventBus;
@@ -335,16 +340,27 @@ export class NetworkProcessor {
   }
 
   async stop(): Promise<void> {
+    if (this.stopped) return;
+    this.stopped = true;
     this.events.off(NetworkEvent.pendingGossipsubMessage, this.onPendingGossipsubMessage);
     this.chain.emitter.off(routes.events.EventType.block, this.onBlockProcessed);
     this.chain.emitter.off(routes.events.EventType.executionPayload, this.onPayloadEnvelopeProcessed);
-    this.chain.emitter.off(ClockEvent.slot, this.onClockSlot);
+    this.chain.clock.off(ClockEvent.slot, this.onClockSlot);
+    this.dropAllJobs();
   }
 
   dropAllJobs(): void {
+    this.jobGeneration = Symbol();
     for (const topic of executeGossipWorkOrder) {
       this.gossipQueues[topic].clear();
     }
+    this.awaitingMessagesByBlockRoot.clear();
+    this.awaitingBlockMessageCount = 0;
+    this.awaitingMessagesByPayloadBlockRoot.clear();
+    this.awaitingPayloadMessageCount = 0;
+    this.searchedRootsBySlot.clear();
+    this.bufferedRootsBySlot.clear();
+    this.fatalPeers.clear();
   }
 
   dumpGossipQueue(topic: GossipType): PendingGossipsubMessage[] {
@@ -364,7 +380,7 @@ export class NetworkProcessor {
    * prefer them as by-root download candidates.
    */
   searchUnknownBlock({slot, root}: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void {
-    if (this.chain.seenBlock(root)) {
+    if (this.stopped || this.chain.seenBlock(root)) {
       return;
     }
     const entry = this.searchedRootsBySlot.getOrDefault(slot).getOrDefault(root);
@@ -398,7 +414,7 @@ export class NetworkProcessor {
     peer?: PeerIdStr,
     slotIsPayloadSlot = false
   ): void {
-    if (this.chain.seenPayloadEnvelope(root)) {
+    if (this.stopped || this.chain.seenPayloadEnvelope(root)) {
       return;
     }
     const entry = this.searchedRootsBySlot.getOrDefault(slot).getOrDefault(root);
@@ -801,6 +817,7 @@ export class NetworkProcessor {
       this.awaitingBlockMessageCount -= total;
     }
 
+    const generation = this.jobGeneration;
     const nowSec = Date.now() / 1000;
     let count = 0;
     // TODO: we can group attestations to process in batches but since we have the SeenAttestationDatas
@@ -819,6 +836,7 @@ export class NetworkProcessor {
         if (count === MAX_AWAITING_GOSSIP_OBJECTS_PER_TICK) {
           count = 0;
           await sleep(AWAITING_GOSSIP_OBJECTS_YIELD_EVERY_MS);
+          if (generation !== this.jobGeneration) return;
         }
       }
     }
@@ -843,6 +861,7 @@ export class NetworkProcessor {
       this.awaitingPayloadMessageCount -= total;
     }
 
+    const generation = this.jobGeneration;
     const nowSec = Date.now() / 1000;
     let count = 0;
     for (const messages of messagesByTopic.values()) {
@@ -858,6 +877,7 @@ export class NetworkProcessor {
         if (count === MAX_AWAITING_GOSSIP_OBJECTS_PER_TICK) {
           count = 0;
           await sleep(AWAITING_GOSSIP_OBJECTS_YIELD_EVERY_MS);
+          if (generation !== this.jobGeneration) return;
         }
       }
     }
@@ -867,19 +887,20 @@ export class NetworkProcessor {
     const nowSec = Date.now() / 1000;
     const minSlot = clockSlot - MAX_UNKNOWN_ROOTS_SLOT_CACHE_SIZE;
 
-    for (const [slot, searchedRoots] of this.searchedRootsBySlot) {
+    for (const [slot, bufferedRoots] of this.bufferedRootsBySlot) {
       if (slot > minSlot) continue;
 
-      // expire messages awaiting an unknown block for these roots. Only roots this slot did a BLOCK search
-      // for (blockPeerIds set) have block waits keyed here; skipping the rest avoids deleting a payload wait
-      // that a newer slot created for the same root (block/envelope searches share searchedRootsBySlot).
-      for (const [rootHex, entry] of searchedRoots) {
-        if (entry.blockPeerIds === undefined) continue;
+      for (const rootHex of bufferedRoots) {
         const messagesByTopic = this.awaitingMessagesByBlockRoot.get(rootHex);
         if (messagesByTopic === undefined) continue;
-        let removed = 0;
+        let remaining = 0;
         for (const messages of messagesByTopic.values()) {
           for (const message of messages) {
+            // the same root may be buffered again from a newer slot, keep those messages.
+            // msgSlot is always set before buffering, a missing one expires rather than leaks
+            if ((message.msgSlot ?? minSlot) > minSlot) continue;
+            messages.delete(message);
+            this.awaitingBlockMessageCount--;
             const topicType = message.topic.type;
             this.metrics?.awaitingBlockGossipMessages.reject.inc({
               topic: topicType,
@@ -891,22 +912,22 @@ export class NetworkProcessor {
             );
             // No need to report the dropped job to gossip. It will be eventually pruned from the mcache
           }
-          removed += messages.size;
-        }
-        if (this.awaitingMessagesByBlockRoot.delete(rootHex)) {
-          this.awaitingBlockMessageCount -= removed;
+          remaining += messages.size;
         }
+        if (remaining === 0) this.awaitingMessagesByBlockRoot.delete(rootHex);
       }
 
-      // expire messages awaiting an unknown payload envelope for these roots. Symmetric to the block pass:
-      // only roots this slot did an ENVELOPE search for (envelopePeerIds set) have payload waits keyed here.
-      for (const [rootHex, entry] of searchedRoots) {
-        if (entry.envelopePeerIds === undefined) continue;
+      for (const rootHex of bufferedRoots) {
         const messagesByTopic = this.awaitingMessagesByPayloadBlockRoot.get(rootHex);
         if (messagesByTopic === undefined) continue;
-        let removed = 0;
+        let remaining = 0;
         for (const messages of messagesByTopic.values()) {
           for (const message of messages) {
+            // the same root may be buffered again from a newer slot, keep those messages.
+            // msgSlot is always set before buffering, a missing one expires rather than leaks
+            if ((message.msgSlot ?? minSlot) > minSlot) continue;
+            messages.delete(message);
+            this.awaitingPayloadMessageCount--;
             const topicType = message.topic.type;
             this.metrics?.awaitingPayloadGossipMessages.reject.inc({
               topic: topicType,
@@ -918,18 +939,16 @@ export class NetworkProcessor {
             );
             // No need to report the dropped job to gossip. It will be eventually pruned from the mcache
           }
-          removed += messages.size;
-        }
-        if (this.awaitingMessagesByPayloadBlockRoot.delete(rootHex)) {
-          this.awaitingPayloadMessageCount -= removed;
+          remaining += messages.size;
         }
+        if (remaining === 0) this.awaitingMessagesByPayloadBlockRoot.delete(rootHex);
       }
 
-      this.searchedRootsBySlot.delete(slot);
+      this.bufferedRootsBySlot.delete(slot);
     }
 
-    for (const slot of this.bufferedRootsBySlot.keys()) {
-      if (slot <= minSlot) this.bufferedRootsBySlot.delete(slot);
+    for (const slot of this.searchedRootsBySlot.keys()) {
+      if (slot <= minSlot) this.searchedRootsBySlot.delete(slot);
     }
 
     for (const [peer, slot] of this.fatalPeers) {
@@ -938,6 +957,7 @@ export class NetworkProcessor {
   };
 
   private executeWork(): void {
+    if (this.stopped) return;
     // TODO: Maybe de-bounce by timing the last time executeWork was run
 
     this.metrics?.networkProcessor.executeWorkCalls.inc();

package/src/network/processor/types.ts

@@ -11,7 +11,7 @@ export type GossipAttestationsWork = {
 export type PendingGossipsubMessage = {
   topic: GossipTopic;
   msg: Message;
-  // only available for beacon_attestation and aggregate_and_proof
+  // set for every topic with a slot, held messages expire by it
   msgSlot?: Slot;
   msgId: string;
   propagationSource: PeerIdStr;

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -267,13 +267,6 @@ export class ReqRespBeaconNode extends ReqResp {
       );
     }
 
-    if (ForkSeq[fork] >= ForkSeq.deneb) {
-      protocolsAtFork.push(
-        [protocols.BlobSidecarsByRoot(fork, this.config), this.getHandler(ReqRespMethod.BlobSidecarsByRoot)],
-        [protocols.BlobSidecarsByRange(fork, this.config), this.getHandler(ReqRespMethod.BlobSidecarsByRange)]
-      );
-    }
-
     if (ForkSeq[fork] < ForkSeq.fulu) {
       // Unregister StatusV1, MetadataV2 at the fork boundary, so only declare for pre-fulu
       protocolsAtFork.push(

package/src/network/reqresp/handlers/beaconBlocksByRange.ts

@@ -3,7 +3,7 @@ import {BeaconConfig} from "@lodestar/config";
 import {GENESIS_SLOT, isForkPostDeneb} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {deneb, phase0} from "@lodestar/types";
+import {phase0} from "@lodestar/types";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {prettyPrintPeerId} from "../../util.js";
@@ -104,7 +104,7 @@ export async function* onBeaconBlocksByRange(
 export function validateBeaconBlocksByRangeRequest(
   config: BeaconConfig,
   request: phase0.BeaconBlocksByRangeRequest
-): deneb.BlobSidecarsByRangeRequest {
+): Pick<phase0.BeaconBlocksByRangeRequest, "startSlot" | "count"> {
   const {startSlot} = request;
   let {count} = request;
 

package/src/network/reqresp/handlers/index.ts

@@ -5,7 +5,6 @@ import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {
   BeaconBlocksByRootRequestType,
-  BlobSidecarsByRootRequestType,
   DataColumnSidecarsByRootRequestType,
   ExecutionPayloadEnvelopesByRootRequestType,
 } from "../../../util/types.js";
@@ -13,8 +12,6 @@ import {GetReqRespHandlerFn, ReqRespMethod} from "../types.js";
 import {onBeaconBlocksByHead} from "./beaconBlocksByHead.js";
 import {onBeaconBlocksByRange} from "./beaconBlocksByRange.js";
 import {onBeaconBlocksByRoot} from "./beaconBlocksByRoot.js";
-import {onBlobSidecarsByRange} from "./blobSidecarsByRange.js";
-import {onBlobSidecarsByRoot} from "./blobSidecarsByRoot.js";
 import {onDataColumnSidecarsByRange} from "./dataColumnSidecarsByRange.js";
 import {onDataColumnSidecarsByRoot} from "./dataColumnSidecarsByRoot.js";
 import {onExecutionPayloadEnvelopesByRange} from "./executionPayloadEnvelopesByRange.js";
@@ -90,20 +87,6 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
       const body = deserializeRequestBody(ssz.fulu.BeaconBlocksByHeadRequest, req.data);
       return onBeaconBlocksByHead(body, chain, peerId, peerClient);
     },
-    [ReqRespMethod.BlobSidecarsByRoot]: (req) => {
-      const fork = chain.config.getForkName(chain.clock.currentSlot);
-      const body = deserializeRequestBody(BlobSidecarsByRootRequestType(fork, chain.config), req.data);
-      return onBlobSidecarsByRoot(body, chain);
-    },
-    [ReqRespMethod.BlobSidecarsByRange]: (req) => {
-      const body = deserializeRequestBody(ssz.deneb.BlobSidecarsByRangeRequest, req.data);
-      return trackByRangeResponse(
-        chain,
-        ReqRespMethod.BlobSidecarsByRange,
-        body.count,
-        onBlobSidecarsByRange(body, chain, db)
-      );
-    },
     [ReqRespMethod.DataColumnSidecarsByRange]: (req, peerId, peerClient) => {
       const body = deserializeRequestBody(ssz.fulu.DataColumnSidecarsByRangeRequest, req.data);
       return trackByRangeResponse(

package/src/network/reqresp/protocols.ts

@@ -77,18 +77,6 @@ export const BeaconBlocksByHead = toProtocol({
   contextBytesType: ContextBytesType.ForkDigest,
 });
 
-export const BlobSidecarsByRange = toProtocol({
-  method: ReqRespMethod.BlobSidecarsByRange,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
-export const BlobSidecarsByRoot = toProtocol({
-  method: ReqRespMethod.BlobSidecarsByRoot,
-  version: Version.V1,
-  contextBytesType: ContextBytesType.ForkDigest,
-});
-
 export const DataColumnSidecarsByRange = toProtocol({
   method: ReqRespMethod.DataColumnSidecarsByRange,
   version: Version.V1,

package/src/network/reqresp/rateLimit.ts

@@ -1,5 +1,5 @@
 import {BeaconConfig} from "@lodestar/config";
-import {ForkName, MAX_REQUEST_LIGHT_CLIENT_UPDATES, isForkPostDeneb, isForkPostElectra} from "@lodestar/params";
+import {ForkName, MAX_REQUEST_LIGHT_CLIENT_UPDATES, isForkPostDeneb} from "@lodestar/params";
 import {InboundRateLimitQuota} from "@lodestar/reqresp";
 import {ReqRespMethod, RequestBodyByMethod, requestSszTypeByMethod} from "./types.js";
 
@@ -44,22 +44,6 @@ export const rateLimitQuotas: (fork: ForkName, config: BeaconConfig) => Record<R
     byPeer: {quota: config.MAX_REQUEST_BLOCKS_DENEB, quotaTimeMs: 10_000},
     getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BeaconBlocksByHead, (req) => req.count),
   },
-  [ReqRespMethod.BlobSidecarsByRange]: {
-    // Rationale: MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK
-    byPeer: {
-      quota: isForkPostElectra(fork) ? config.MAX_REQUEST_BLOB_SIDECARS_ELECTRA : config.MAX_REQUEST_BLOB_SIDECARS,
-      quotaTimeMs: 10_000,
-    },
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BlobSidecarsByRange, (req) => req.count),
-  },
-  [ReqRespMethod.BlobSidecarsByRoot]: {
-    // Rationale: quota of BeaconBlocksByRoot * MAX_BLOBS_PER_BLOCK
-    byPeer: {
-      quota: isForkPostElectra(fork) ? config.MAX_REQUEST_BLOB_SIDECARS_ELECTRA : config.MAX_REQUEST_BLOB_SIDECARS,
-      quotaTimeMs: 10_000,
-    },
-    getRequestCount: getRequestCountFn(fork, config, ReqRespMethod.BlobSidecarsByRoot, (req) => req.length),
-  },
   [ReqRespMethod.DataColumnSidecarsByRange]: {
     // Rationale: MAX_REQUEST_BLOCKS_DENEB * NUMBER_OF_COLUMNS
     byPeer: {quota: config.MAX_REQUEST_DATA_COLUMN_SIDECARS, quotaTimeMs: 10_000},

package/src/network/reqresp/types.ts

@@ -13,7 +13,6 @@ import {
   SignedBeaconBlock,
   Status,
   altair,
-  deneb,
   fulu,
   gloas,
   heze,
@@ -24,8 +23,6 @@ import {
 import {
   BeaconBlocksByRootRequest,
   BeaconBlocksByRootRequestType,
-  BlobSidecarsByRootRequest,
-  BlobSidecarsByRootRequestType,
   DataColumnSidecarsByRootRequest,
   DataColumnSidecarsByRootRequestType,
   ExecutionPayloadEnvelopesByRootRequest,
@@ -44,8 +41,6 @@ export enum ReqRespMethod {
   BeaconBlocksByRange = "beacon_blocks_by_range",
   BeaconBlocksByRoot = "beacon_blocks_by_root",
   BeaconBlocksByHead = "beacon_blocks_by_head",
-  BlobSidecarsByRange = "blob_sidecars_by_range",
-  BlobSidecarsByRoot = "blob_sidecars_by_root",
   DataColumnSidecarsByRange = "data_column_sidecars_by_range",
   DataColumnSidecarsByRoot = "data_column_sidecars_by_root",
   ExecutionPayloadEnvelopesByRoot = "execution_payload_envelopes_by_root",
@@ -66,8 +61,6 @@ export type RequestBodyByMethod = {
   [ReqRespMethod.BeaconBlocksByRange]: phase0.BeaconBlocksByRangeRequest;
   [ReqRespMethod.BeaconBlocksByRoot]: BeaconBlocksByRootRequest;
   [ReqRespMethod.BeaconBlocksByHead]: fulu.BeaconBlocksByHeadRequest;
-  [ReqRespMethod.BlobSidecarsByRange]: deneb.BlobSidecarsByRangeRequest;
-  [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequest;
   [ReqRespMethod.DataColumnSidecarsByRange]: fulu.DataColumnSidecarsByRangeRequest;
   [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecarsByRootRequest;
   [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: ExecutionPayloadEnvelopesByRootRequest;
@@ -88,8 +81,6 @@ type ResponseBodyByMethod = {
   [ReqRespMethod.BeaconBlocksByRange]: SignedBeaconBlock;
   [ReqRespMethod.BeaconBlocksByRoot]: SignedBeaconBlock;
   [ReqRespMethod.BeaconBlocksByHead]: SignedBeaconBlock;
-  [ReqRespMethod.BlobSidecarsByRange]: deneb.BlobSidecar;
-  [ReqRespMethod.BlobSidecarsByRoot]: deneb.BlobSidecar;
   [ReqRespMethod.DataColumnSidecarsByRange]: DataColumnSidecar;
   [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecar;
   [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: gloas.SignedExecutionPayloadEnvelope;
@@ -119,8 +110,6 @@ export const requestSszTypeByMethod: (
   [ReqRespMethod.BeaconBlocksByRange]: ssz.phase0.BeaconBlocksByRangeRequest,
   [ReqRespMethod.BeaconBlocksByRoot]: BeaconBlocksByRootRequestType(fork, config),
   [ReqRespMethod.BeaconBlocksByHead]: ssz.fulu.BeaconBlocksByHeadRequest,
-  [ReqRespMethod.BlobSidecarsByRange]: ssz.deneb.BlobSidecarsByRangeRequest,
-  [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequestType(fork, config),
   [ReqRespMethod.DataColumnSidecarsByRange]: ssz.fulu.DataColumnSidecarsByRangeRequest,
   [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecarsByRootRequestType(config),
   [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: ExecutionPayloadEnvelopesByRootRequestType(config),
@@ -152,8 +141,6 @@ export const responseSszTypeByMethod: {[K in ReqRespMethod]: ResponseTypeGetter<
   [ReqRespMethod.BeaconBlocksByRange]: blocksResponseType,
   [ReqRespMethod.BeaconBlocksByRoot]: blocksResponseType,
   [ReqRespMethod.BeaconBlocksByHead]: (fork) => ssz[fork].SignedBeaconBlock,
-  [ReqRespMethod.BlobSidecarsByRange]: () => ssz.deneb.BlobSidecar,
-  [ReqRespMethod.BlobSidecarsByRoot]: () => ssz.deneb.BlobSidecar,
   [ReqRespMethod.LightClientBootstrap]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientBootstrap,
   [ReqRespMethod.LightClientUpdatesByRange]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientUpdate,
   [ReqRespMethod.LightClientFinalityUpdate]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientFinalityUpdate,

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 = {