@lodestar/beacon-node 1.45.0-dev.fadf0fbb1f → 1.46.0-dev.8fc4e297d2

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

@@ -107,8 +107,10 @@ export function validateExecutionPayloadEnvelopesByRangeRequest(
   // The gloas req/resp spec uses MIN_EPOCHS_FOR_BLOCK_REQUESTS to define the minimum range peers MUST serve.
   // Archival nodes may still serve older retained payloads to allow genesis sync.
 
-  if (count > config.MAX_REQUEST_BLOCKS_DENEB) {
-    count = config.MAX_REQUEST_BLOCKS_DENEB;
+  // Spec: EnvelopesByRange response is bounded by MAX_REQUEST_PAYLOADS (consensus-specs #5383),
+  // distinct from the MAX_REQUEST_BLOCKS_DENEB cap used for block-by-range.
+  if (count > config.MAX_REQUEST_PAYLOADS) {
+    count = config.MAX_REQUEST_PAYLOADS;
   }
 
   return {startSlot, count};

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

@@ -1,4 +1,5 @@
-import {ProtocolHandler} from "@lodestar/reqresp";
+import type {Type} from "@chainsafe/ssz";
+import {ProtocolHandler, RespStatus, ResponseError} from "@lodestar/reqresp";
 import {ssz} from "@lodestar/types";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
@@ -29,6 +30,14 @@ function notImplemented(method: ReqRespMethod): ProtocolHandler {
   };
 }
 
+function deserializeRequestBody<T>(type: Type<T>, data: Uint8Array): T {
+  try {
+    return type.deserialize(data);
+  } catch (e) {
+    throw new ResponseError(RespStatus.INVALID_REQUEST, e instanceof Error ? e.message : String(e));
+  }
+}
+
 /**
  * The ReqRespHandler module handles app-level requests / responses from other peers,
  * fetching state from the chain and database as needed.
@@ -40,51 +49,51 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
     [ReqRespMethod.Ping]: notImplemented(ReqRespMethod.Ping),
     [ReqRespMethod.Metadata]: notImplemented(ReqRespMethod.Metadata),
     [ReqRespMethod.BeaconBlocksByRange]: (req, peerId, peerClient) => {
-      const body = ssz.phase0.BeaconBlocksByRangeRequest.deserialize(req.data);
+      const body = deserializeRequestBody(ssz.phase0.BeaconBlocksByRangeRequest, req.data);
       return onBeaconBlocksByRange(body, chain, db, peerId, peerClient);
     },
     [ReqRespMethod.BeaconBlocksByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
-      const body = BeaconBlocksByRootRequestType(fork, chain.config).deserialize(req.data);
+      const body = deserializeRequestBody(BeaconBlocksByRootRequestType(fork, chain.config), req.data);
       return onBeaconBlocksByRoot(body, chain);
     },
     [ReqRespMethod.BeaconBlocksByHead]: (req, peerId, peerClient) => {
-      const body = ssz.fulu.BeaconBlocksByHeadRequest.deserialize(req.data);
+      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 = BlobSidecarsByRootRequestType(fork, chain.config).deserialize(req.data);
+      const body = deserializeRequestBody(BlobSidecarsByRootRequestType(fork, chain.config), req.data);
       return onBlobSidecarsByRoot(body, chain);
     },
     [ReqRespMethod.BlobSidecarsByRange]: (req) => {
-      const body = ssz.deneb.BlobSidecarsByRangeRequest.deserialize(req.data);
+      const body = deserializeRequestBody(ssz.deneb.BlobSidecarsByRangeRequest, req.data);
       return onBlobSidecarsByRange(body, chain, db);
     },
     [ReqRespMethod.DataColumnSidecarsByRange]: (req, peerId, peerClient) => {
-      const body = ssz.fulu.DataColumnSidecarsByRangeRequest.deserialize(req.data);
+      const body = deserializeRequestBody(ssz.fulu.DataColumnSidecarsByRangeRequest, req.data);
       return onDataColumnSidecarsByRange(body, chain, db, peerId, peerClient);
     },
     [ReqRespMethod.DataColumnSidecarsByRoot]: (req, peerId, peerClient) => {
-      const body = DataColumnSidecarsByRootRequestType(chain.config).deserialize(req.data);
+      const body = deserializeRequestBody(DataColumnSidecarsByRootRequestType(chain.config), req.data);
       return onDataColumnSidecarsByRoot(body, chain, db, peerId, peerClient);
     },
 
     [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: (req, peerId, peerClient) => {
-      const body = ExecutionPayloadEnvelopesByRootRequestType(chain.config).deserialize(req.data);
+      const body = deserializeRequestBody(ExecutionPayloadEnvelopesByRootRequestType(chain.config), req.data);
       return onExecutionPayloadEnvelopesByRoot(body, chain, db, peerId, peerClient);
     },
     [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: (req, peerId, peerClient) => {
-      const body = ssz.gloas.ExecutionPayloadEnvelopesByRangeRequest.deserialize(req.data);
+      const body = deserializeRequestBody(ssz.gloas.ExecutionPayloadEnvelopesByRangeRequest, req.data);
       return onExecutionPayloadEnvelopesByRange(body, chain, db, peerId, peerClient);
     },
 
     [ReqRespMethod.LightClientBootstrap]: (req) => {
-      const body = ssz.Root.deserialize(req.data);
+      const body = deserializeRequestBody(ssz.Root, req.data);
       return onLightClientBootstrap(body, chain);
     },
     [ReqRespMethod.LightClientUpdatesByRange]: (req) => {
-      const body = ssz.altair.LightClientUpdatesByRange.deserialize(req.data);
+      const body = deserializeRequestBody(ssz.altair.LightClientUpdatesByRange, req.data);
       return onLightClientUpdatesByRange(body, chain);
     },
     [ReqRespMethod.LightClientFinalityUpdate]: () => onLightClientFinalityUpdate(chain),

package/src/network/util.ts

@@ -27,3 +27,8 @@ export function getConnection(libp2p: Libp2p, peerIdStr: string): Connection | u
 export function isPublishToZeroPeersError(e: Error): boolean {
   return e.message.includes("PublishError.NoPeersSubscribedToTopic");
 }
+
+// https://github.com/libp2p/js-libp2p/blob/f87cba928991736d9646b3e054c367f55cab315c/packages/gossipsub/src/gossipsub.ts#L2076
+export function isPublishDuplicateError(e: Error): boolean {
+  return e.message.includes("PublishError.Duplicate");
+}

package/src/sync/sync.ts

@@ -75,6 +75,11 @@ export class BeaconSync implements IBeaconSync {
     if (metrics) {
       metrics.syncStatus.addCollect(() => this.scrapeMetrics(metrics));
     }
+
+    // A from-scratch or large-gap start boots not synced; updateSyncState resumes once synced
+    if (this.state !== SyncState.Synced) {
+      this.chain.forkChoice.pauseFastConfirmation();
+    }
   }
 
   close(): void {
@@ -228,6 +233,8 @@ export class BeaconSync implements IBeaconSync {
 
     // We have become synced, subscribe to all the gossip core topics
     if (state === SyncState.Synced && this.chain.clock.currentEpoch >= MIN_EPOCH_TO_START_GOSSIP) {
+      this.chain.forkChoice.resumeFastConfirmation();
+
       if (!this.network.isSubscribedToGossipCoreTopics()) {
         this.network
           .subscribeGossipCoreTopics()
@@ -251,6 +258,9 @@ export class BeaconSync implements IBeaconSync {
     else if (state !== SyncState.Synced) {
       const syncDiff = this.chain.clock.currentSlot - this.chain.forkChoice.getHead().slot;
       if (syncDiff > this.slotImportTolerance * 2) {
+        // 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

package/src/sync/unknownBlock.ts

@@ -819,7 +819,7 @@ export class BlockInputSync {
           // case BlockErrorCode.ALREADY_KNOWN:
           // case BlockErrorCode.GENESIS_BLOCK:
 
-          case BlockErrorCode.PARENT_UNKNOWN:
+          case BlockErrorCode.PARENT_BLOCK_UNKNOWN:
           case BlockErrorCode.PRESTATE_MISSING:
             // Should not happen, mark as downloaded to try again latter
             this.logger.debug("Attempted to process block but its parent was still unknown", errorData, res.err);
@@ -841,10 +841,16 @@ export class BlockInputSync {
 
           case BlockErrorCode.EXECUTION_ENGINE_ERROR:
             // Removing the block(s) without penalizing the peers, hoping for EL to
-            // recover on a latter download + verify attempt
+            // recover on a latter download + verify attempt.
             this.removeAllDescendants(pendingBlock);
             break;
 
+          case BlockErrorCode.EXECUTION_ENGINE_INVALID:
+            // the peer served a bad block
+            this.logger.debug("Execution engine rejected block from unknown parent sync", errorData, res.err);
+            this.removeAndDownScoreAllDescendants(pendingBlock);
+            break;
+
           default:
             // Block is not correct with respect to our chain. Log error loudly
             this.logger.debug("Error processing block from unknown parent sync", errorData, res.err);

package/src/util/execution.ts

@@ -199,7 +199,7 @@ export async function getDataColumnSidecarsFromExecution(
   const previouslyMissingColumns = input.getMissingSampledColumnMeta().missing;
   const sampledColumns = previouslyMissingColumns.map((columnIndex) => dataColumnSidecars[columnIndex]);
 
-  // for columns that we already seen, it will be ignored through `ignoreDuplicatePublishError` gossip option
+  // for columns we have already seen, publishDataColumnSidecar() catches PublishError.Duplicate and marks alreadyPublished=true
   emitter.emit(ChainEvent.publishDataColumns, sampledColumns);
   // TODO: Can we record dataColumns.sentPeersPerSubnet metric here somehow