@lodestar/beacon-node 1.51.0-dev.8d5cdd33be → 1.51.0-dev.8fdbd61e7e

package/src/chain/validation/aggregateAndProof.ts

@@ -72,7 +72,7 @@ async function validateAggregateAndProof(
   const attSlot = attData.slot;
 
   let committeeIndex: number | null;
-  if (ForkSeq[fork] >= ForkSeq.gloas) {
+  if (ForkSeq[fork] >= ForkSeq.gloas && chain.config.getForkSeq(attSlot) >= ForkSeq.gloas) {
     // [REJECT] `aggregate.data.index < 2`.
     if (attData.index >= 2) {
       throw new AttestationError(GossipAction.REJECT, {

package/src/chain/validation/attestation.ts

@@ -291,7 +291,7 @@ async function validateAttestationNoSignatureCheck(
       // api or first time validation of a gossip attestation
       committeeIndex = attestationOrCache.attestation.committeeIndex;
 
-      if (isForkPostGloas(fork)) {
+      if (isForkPostGloas(fork) && isForkPostGloas(chain.config.getForkName(attSlot))) {
         // [REJECT] `attestation.data.index < 2`.
         if (attData.index >= 2) {
           throw new AttestationError(GossipAction.REJECT, {

package/src/chain/validation/syncCommittee.ts

@@ -1,7 +1,8 @@
 import {SYNC_COMMITTEE_SUBNET_COUNT, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {IBeaconStateView, isStatePostAltair} from "@lodestar/state-transition";
-import {SubnetID, altair} from "@lodestar/types";
+import {RootHex, Slot, SubnetID, ValidatorIndex, altair} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
+import {Metrics} from "../../metrics/metrics.js";
 import {GossipAction, SyncCommitteeError, SyncCommitteeErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../interface.js";
 import {getSyncCommitteeSignatureSet} from "./signatureSets/index.js";
@@ -32,6 +33,33 @@ export async function validateGossipSyncCommittee(
 
   // [IGNORE] There has been no other valid sync committee signature for the declared slot for the validator referenced
   // by sync_committee_signature.validator_index.
+  assertSyncCommitteeMessageNotKnown(chain, slot, subnet, validatorIndex, messageRoot, chain.metrics);
+
+  // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state, sync_committee_signature.validator_index).
+  // Note this validation implies the validator is part of the broader current sync committee along with the correct subcommittee.
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  // [REJECT] The signature is valid for the message beacon_block_root for the validator referenced by validator_index.
+  await validateSyncCommitteeSigOnly(chain, headState, syncCommittee);
+
+  // Re-check after the await: concurrent messages from the same validator all pass the check above.
+  // Metrics were already counted by the first check.
+  assertSyncCommitteeMessageNotKnown(chain, slot, subnet, validatorIndex, messageRoot, null);
+
+  // Register this valid item as seen
+  chain.seenSyncCommitteeMessages.add(slot, subnet, validatorIndex, messageRoot);
+
+  return {indicesInSubcommittee};
+}
+
+function assertSyncCommitteeMessageNotKnown(
+  chain: IBeaconChain,
+  slot: Slot,
+  subnet: SubnetID,
+  validatorIndex: ValidatorIndex,
+  messageRoot: RootHex,
+  metrics: Metrics | null
+): void {
   const prevRoot = chain.seenSyncCommitteeMessages.get(slot, subnet, validatorIndex);
   if (prevRoot) {
     let shouldIgnore = false;
@@ -39,9 +67,9 @@ export async function validateGossipSyncCommittee(
       shouldIgnore = true;
     } else {
       const headRoot = chain.forkChoice.getHeadRoot();
-      chain.metrics?.gossipSyncCommittee.equivocationCount.inc();
+      metrics?.gossipSyncCommittee.equivocationCount.inc();
       if (messageRoot === headRoot) {
-        chain.metrics?.gossipSyncCommittee.equivocationToHeadCount.inc();
+        metrics?.gossipSyncCommittee.equivocationToHeadCount.inc();
       } else {
         shouldIgnore = true;
       }
@@ -57,18 +85,6 @@ export async function validateGossipSyncCommittee(
       });
     }
   }
-
-  // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state, sync_committee_signature.validator_index).
-  // Note this validation implies the validator is part of the broader current sync committee along with the correct subcommittee.
-  // > Checked in validateGossipSyncCommitteeExceptSig()
-
-  // [REJECT] The signature is valid for the message beacon_block_root for the validator referenced by validator_index.
-  await validateSyncCommitteeSigOnly(chain, headState, syncCommittee);
-
-  // Register this valid item as seen
-  chain.seenSyncCommitteeMessages.add(slot, subnet, validatorIndex, messageRoot);
-
-  return {indicesInSubcommittee};
 }
 
 export async function validateApiSyncCommittee(

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -92,6 +92,19 @@ export async function validateSyncCommitteeGossipContributionAndProof(
     });
   }
 
+  // Re-check after the await: concurrent contributions from the same aggregator all pass the checks above
+  if (chain.seenContributionAndProof.isAggregatorKnown(slot, subcommitteeIndex, aggregatorIndex)) {
+    throw new SyncCommitteeError(GossipAction.IGNORE, {
+      code: SyncCommitteeErrorCode.SYNC_COMMITTEE_AGGREGATOR_ALREADY_KNOWN,
+    });
+  }
+
+  if (!skipValidationKnownParticipants && chain.seenContributionAndProof.participantsKnown(contribution)) {
+    throw new SyncCommitteeError(GossipAction.IGNORE, {
+      code: SyncCommitteeErrorCode.SYNC_COMMITTEE_PARTICIPANTS_ALREADY_KNOWN,
+    });
+  }
+
   // no need to add to seenSyncCommittteeContributionCache here, gossip handler will do that
   chain.seenContributionAndProof.add(contributionAndProof, syncCommitteeParticipantIndices.length);
 

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

@@ -23,7 +23,7 @@ export async function* onBeaconBlocksByHead(
   let blockRootHex = requestedRootHex;
   const minimumRequestEpoch = Math.max(
     GENESIS_EPOCH,
-    chain.clock.currentEpoch - chain.config.MIN_EPOCHS_FOR_BLOCK_REQUESTS
+    chain.clock.currentEpoch - chain.config.getMinEpochsForBlockRequests(chain.clock.currentEpoch)
   );
   const minimumRequestSlot = computeStartSlotAtEpoch(minimumRequestEpoch);
 

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.