@lodestar/beacon-node 1.45.0 → 1.46.0-dev.1cd9a671ea

package/src/chain/validation/proposerPreferences.ts

@@ -1,17 +1,19 @@
-import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {GENESIS_SLOT, MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   computeEpochAtSlot,
+  computeStartSlotAtEpoch,
   createSingleSignatureSetFromComponents,
   getProposerPreferencesSigningRoot,
 } from "@lodestar/state-transition";
-import {ValidatorIndex, gloas} from "@lodestar/types";
+import {Epoch, Slot, ValidatorIndex, gloas} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {GossipAction, ProposerPreferencesError, ProposerPreferencesErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
 
 /**
  * Validates a gossiped `SignedProposerPreferences` per
- * https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/p2p-interface.md#proposer_preferences
+ * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.13/specs/gloas/p2p-interface.md#new-proposer_preferences
  */
 export async function validateGossipProposerPreferences(
   chain: IBeaconChain,
@@ -22,9 +24,9 @@ export async function validateGossipProposerPreferences(
   const dependentRootHex = toRootHex(dependentRoot);
   const proposalEpoch = computeEpochAtSlot(proposalSlot);
 
-  // [IGNORE] `preferences.proposal_slot` is in the current or next epoch.
+  // [IGNORE] `preferences.proposal_slot` is within the proposer lookahead.
   const currentEpoch = chain.clock.currentEpoch;
-  if (proposalEpoch < currentEpoch || proposalEpoch > currentEpoch + 1) {
+  if (proposalEpoch < currentEpoch || proposalEpoch > currentEpoch + MIN_SEED_LOOKAHEAD) {
     throw new ProposerPreferencesError(GossipAction.IGNORE, {
       code: ProposerPreferencesErrorCode.INVALID_EPOCH,
       proposalSlot,
@@ -44,21 +46,56 @@ export async function validateGossipProposerPreferences(
   }
 
   // [IGNORE] The block with root `dependent_root` has been seen by the node.
+  const dependentBlock = chain.forkChoice.getBlockHexDefaultStatus(dependentRootHex);
+  if (dependentBlock === null) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.UNKNOWN_DEPENDENT_ROOT,
+      proposalSlot,
+      dependentRoot: dependentRootHex,
+    });
+  }
+
+  const dependentEpoch = proposalEpoch - MIN_SEED_LOOKAHEAD;
+  const dependentRootSlot = getDependentRootSlot(dependentEpoch);
+
+  // [REJECT] The slot of the block with root `preferences.dependent_root` is strictly less than
+  // `compute_start_slot_at_epoch(compute_epoch_at_slot(preferences.proposal_slot) - MIN_SEED_LOOKAHEAD)`.
+  if (dependentBlock.slot > dependentRootSlot) {
+    throw new ProposerPreferencesError(GossipAction.REJECT, {
+      code: ProposerPreferencesErrorCode.INVALID_DEPENDENT_ROOT_SLOT,
+      dependentRoot: dependentRootHex,
+      dependentBlockSlot: dependentBlock.slot,
+      dependentRootSlot,
+      dependentEpoch,
+    });
+  }
+
+  // [IGNORE] `is_valid_dependent_root(store, preferences.dependent_root, epoch)` returns `True`,
+  // where `epoch` is `compute_epoch_at_slot(preferences.proposal_slot) - MIN_SEED_LOOKAHEAD`.
+  if (!isValidDependentRoot(chain.forkChoice, dependentBlock, dependentEpoch)) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.INVALID_DEPENDENT_ROOT,
+      dependentRoot: dependentRootHex,
+      dependentBlockSlot: dependentBlock.slot,
+      dependentEpoch,
+    });
+  }
+
   // Resolve the proposer lookahead for the message's branch via head state (fast path) or
   // the previous-root checkpoint state (populated by `processSlotsToNearestCheckpoint` for
-  // any imported branch crossing into `proposalEpoch - 1`). The head-state path also handles
+  // any imported branch crossing into `dependentEpoch`). The head-state path also handles
   // narrow timing windows where the checkpoint state isn't yet populated.
   const headState = chain.getHeadState();
   let proposers: ValidatorIndex[] | null = null;
   if (headState.epoch === proposalEpoch && headState.currentDecisionRoot === dependentRootHex) {
     proposers = headState.currentProposers;
-  } else if (headState.epoch === proposalEpoch - 1 && headState.nextDecisionRoot === dependentRootHex) {
+  } else if (headState.epoch === dependentEpoch && headState.nextDecisionRoot === dependentRootHex) {
     proposers = headState.nextProposers;
   } else {
     // Sync lookup only to not trigger disk reload from gossip input.
-    const checkpointState = chain.regen.getCheckpointStateSync({epoch: proposalEpoch - 1, rootHex: dependentRootHex});
+    const checkpointState = chain.regen.getCheckpointStateSync({epoch: dependentEpoch, rootHex: dependentRootHex});
     if (checkpointState !== null) {
-      // State is at `proposalEpoch - 1`, so proposers for `proposalSlot` (next epoch from
+      // State is at `dependentEpoch`, so proposers for `proposalSlot` (next epoch from
       // the state's perspective) live in `nextProposers`.
       proposers = checkpointState.nextProposers;
     }
@@ -118,3 +155,28 @@ export async function validateGossipProposerPreferences(
 
   chain.proposerPreferencesPool.add(signedProposerPreferences);
 }
+
+/**
+ * Check whether `dependentBlock` is a viable shuffling-dependent root for `epoch`:
+ * it is before the epoch boundary and either has a direct child at or after
+ * the boundary, or is the current fork-choice head.
+ */
+export function isValidDependentRoot(forkChoice: IForkChoice, dependentBlock: ProtoBlock, epoch: Epoch): boolean {
+  const epochStartSlot = computeStartSlotAtEpoch(epoch);
+  if (dependentBlock.slot > getDependentRootSlot(epoch)) {
+    return false;
+  }
+
+  for (const block of forkChoice.getBlockSummariesByParentRoot(dependentBlock.blockRoot)) {
+    if (block.slot >= epochStartSlot) {
+      return true;
+    }
+  }
+
+  return dependentBlock.blockRoot === forkChoice.getHeadRoot();
+}
+
+/** Return the slot used to select a dependent root for `epoch`, clamped to genesis. */
+function getDependentRootSlot(epoch: Epoch): Slot {
+  return Math.max(GENESIS_SLOT, computeStartSlotAtEpoch(epoch) - 1);
+}

package/src/chain/validation/signatureSets/aggregateAndProof.ts

@@ -1,7 +1,7 @@
 import {BeaconConfig} from "@lodestar/config";
-import {DOMAIN_AGGREGATE_AND_PROOF, ForkSeq} from "@lodestar/params";
+import {DOMAIN_AGGREGATE_AND_PROOF} from "@lodestar/params";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Epoch, SignedAggregateAndProof, ValidatorIndex, ssz} from "@lodestar/types";
+import {Epoch, SignedAggregateAndProof, ValidatorIndex} from "@lodestar/types";
 
 export function getAggregateAndProofSigningRoot(
   config: BeaconConfig,
@@ -14,7 +14,7 @@ export function getAggregateAndProofSigningRoot(
   const slot = computeStartSlotAtEpoch(epoch);
   const fork = config.getForkName(slot);
   const aggregatorDomain = config.getDomainAtFork(fork, DOMAIN_AGGREGATE_AND_PROOF);
-  const sszType = ForkSeq[fork] >= ForkSeq.electra ? ssz.electra.AggregateAndProof : ssz.phase0.AggregateAndProof;
+  const sszType = config.getForkTypes(slot).AggregateAndProof;
   return computeSigningRoot(sszType, aggregateAndProof.message, aggregatorDomain);
 }
 

package/src/db/repositories/lightclientSyncCommitteeWitness.ts

@@ -1,14 +1,16 @@
 import {ContainerType, VectorCompositeType} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {DatabaseController, Repository} from "@lodestar/db";
+import {CURRENT_SYNC_COMMITTEE_DEPTH_GLOAS, NEXT_SYNC_COMMITTEE_DEPTH_GLOAS} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {SyncCommitteeWitness} from "../../chain/lightClient/types.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
-// We add a 1-byte prefix where 0 means pre-electra and 1 means post-electra
+// We add a 1-byte prefix where 0 means pre-Electra, 1 means post-Electra, and 2 means post-Gloas.
 enum PrefixByte {
   PRE_ELECTRA = 0,
   POST_ELECTRA = 1,
+  POST_GLOAS = 2,
 }
 
 export const NUM_WITNESS = 4;
@@ -35,6 +37,35 @@ export class SyncCommitteeWitnessRepository extends Repository<Uint8Array, SyncC
   // Overrides for multi-fork
   encodeValue(value: SyncCommitteeWitness): Uint8Array {
     const numWitness = value.witness.length;
+    const hasGloasBranches =
+      value.currentSyncCommitteeBranch !== undefined || value.nextSyncCommitteeBranch !== undefined;
+
+    if (hasGloasBranches) {
+      if (
+        value.currentSyncCommitteeBranch?.length !== CURRENT_SYNC_COMMITTEE_DEPTH_GLOAS ||
+        value.nextSyncCommitteeBranch?.length !== NEXT_SYNC_COMMITTEE_DEPTH_GLOAS
+      ) {
+        throw Error(
+          `Invalid post-Gloas sync committee branch lengths current=${value.currentSyncCommitteeBranch?.length} next=${value.nextSyncCommitteeBranch?.length}`
+        );
+      }
+
+      const type = new ContainerType({
+        currentSyncCommitteeBranch: new VectorCompositeType(ssz.Root, CURRENT_SYNC_COMMITTEE_DEPTH_GLOAS),
+        nextSyncCommitteeBranch: new VectorCompositeType(ssz.Root, NEXT_SYNC_COMMITTEE_DEPTH_GLOAS),
+        currentSyncCommitteeRoot: ssz.Root,
+        nextSyncCommitteeRoot: ssz.Root,
+      });
+
+      const valueBytes = type.serialize({
+        currentSyncCommitteeBranch: value.currentSyncCommitteeBranch,
+        nextSyncCommitteeBranch: value.nextSyncCommitteeBranch,
+        currentSyncCommitteeRoot: value.currentSyncCommitteeRoot,
+        nextSyncCommitteeRoot: value.nextSyncCommitteeRoot,
+      });
+
+      return prefixData(PrefixByte.POST_GLOAS, valueBytes);
+    }
 
     if (numWitness !== NUM_WITNESS && numWitness !== NUM_WITNESS_ELECTRA) {
       throw Error(`Number of witness can only be 4 pre-electra or 5 post-electra numWitness=${numWitness}`);
@@ -51,19 +82,25 @@ export class SyncCommitteeWitnessRepository extends Repository<Uint8Array, SyncC
     // We need to differentiate between post-electra and pre-electra witness
     // such that we can deserialize correctly
     const isPostElectra = numWitness === NUM_WITNESS_ELECTRA;
-    const prefixByte = new Uint8Array(1);
-    prefixByte[0] = isPostElectra ? PrefixByte.POST_ELECTRA : PrefixByte.PRE_ELECTRA;
-
-    const prefixedData = new Uint8Array(1 + valueBytes.length);
-    prefixedData.set(prefixByte, 0);
-    prefixedData.set(valueBytes, 1);
-
-    return prefixedData;
+    return prefixData(isPostElectra ? PrefixByte.POST_ELECTRA : PrefixByte.PRE_ELECTRA, valueBytes);
   }
 
   decodeValue(data: Uint8Array): SyncCommitteeWitness {
     // First byte is written
     const prefix = data.subarray(0, 1);
+    const isPostGloas = prefix[0] === PrefixByte.POST_GLOAS;
+
+    if (isPostGloas) {
+      const type = new ContainerType({
+        currentSyncCommitteeBranch: new VectorCompositeType(ssz.Root, CURRENT_SYNC_COMMITTEE_DEPTH_GLOAS),
+        nextSyncCommitteeBranch: new VectorCompositeType(ssz.Root, NEXT_SYNC_COMMITTEE_DEPTH_GLOAS),
+        currentSyncCommitteeRoot: ssz.Root,
+        nextSyncCommitteeRoot: ssz.Root,
+      });
+
+      return {witness: [], ...type.deserialize(data.subarray(1))};
+    }
+
     const isPostElectra = prefix[0] === PrefixByte.POST_ELECTRA;
 
     const type = new ContainerType({
@@ -75,3 +112,14 @@ export class SyncCommitteeWitnessRepository extends Repository<Uint8Array, SyncC
     return type.deserialize(data.subarray(1));
   }
 }
+
+function prefixData(prefix: PrefixByte, valueBytes: Uint8Array): Uint8Array {
+  const prefixByte = new Uint8Array(1);
+  prefixByte[0] = prefix;
+
+  const prefixedData = new Uint8Array(1 + valueBytes.length);
+  prefixedData.set(prefixByte, 0);
+  prefixedData.set(valueBytes, 1);
+
+  return prefixedData;
+}

package/src/network/gossip/encoding.ts

@@ -9,7 +9,7 @@ import {ForkName} from "@lodestar/params";
 import {intToBytes} from "@lodestar/utils";
 import {MESSAGE_DOMAIN_VALID_SNAPPY} from "./constants.js";
 import {Eth2GossipsubMetrics} from "./metrics.js";
-import {GossipTopicCache, getGossipSSZType} from "./topic.js";
+import {GossipTopicCache, getGossipSSZMaxSize, getGossipSSZType} from "./topic.js";
 
 // Load WASM
 const xxhash = await xxhashFactory();
@@ -98,7 +98,7 @@ export function msgIdFn(gossipTopicCache: GossipTopicCache, msg: Message): Uint8
 export class DataTransformSnappy implements DataTransform {
   constructor(
     private readonly gossipTopicCache: GossipTopicCache,
-    private readonly maxSizePerMessage: number,
+    private readonly maxPayloadSize: number,
     private readonly metrics: Eth2GossipsubMetrics | null
   ) {}
 
@@ -111,17 +111,18 @@ export class DataTransformSnappy implements DataTransform {
   inboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
     // check uncompressed data length before we actually decompress
     const uncompressedDataLength = snappyWasm.decompress_len(data);
-    if (uncompressedDataLength > this.maxSizePerMessage) {
-      throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${this.maxSizePerMessage}`);
-    }
 
     const topic = this.gossipTopicCache.getTopic(topicStr);
     const sszType = getGossipSSZType(topic);
+    const maxSize = getGossipSSZMaxSize(topic, this.maxPayloadSize, sszType);
     this.metrics?.dataTransform.inbound.inc({type: topic.type});
 
     if (uncompressedDataLength < sszType.minSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} < ${sszType.minSize}`);
     }
+    if (uncompressedDataLength > maxSize) {
+      throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${maxSize}`);
+    }
     if (uncompressedDataLength > sszType.maxSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${sszType.maxSize}`);
     }
@@ -139,9 +140,14 @@ export class DataTransformSnappy implements DataTransform {
    */
   outboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
     const topic = this.gossipTopicCache.getTopic(topicStr);
+    const sszType = getGossipSSZType(topic);
+    const maxSize = getGossipSSZMaxSize(topic, this.maxPayloadSize, sszType);
     this.metrics?.dataTransform.outbound.inc({type: topic.type});
-    if (data.length > this.maxSizePerMessage) {
-      throw Error(`ssz_snappy encoded data length ${data.length} > ${this.maxSizePerMessage}`);
+    if (data.length > maxSize) {
+      throw Error(`ssz_snappy encoded data length ${data.length} > ${maxSize}`);
+    }
+    if (data.length > sszType.maxSize) {
+      throw Error(`ssz_snappy encoded data length ${data.length} > ${sszType.maxSize}`);
     }
 
     // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments

package/src/network/gossip/gossipsub.ts

@@ -15,7 +15,12 @@ import {type Multiaddr, multiaddr} from "@multiformats/multiaddr";
 import {ENR} from "@chainsafe/enr";
 import {routes} from "@lodestar/api";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
-import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
+import {
+  ATTESTATION_SUBNET_COUNT,
+  MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
+  SLOTS_PER_EPOCH,
+  SYNC_COMMITTEE_SUBNET_COUNT,
+} from "@lodestar/params";
 import {SubnetID} from "@lodestar/types";
 import {Logger, Map2d, Map2dArr} from "@lodestar/utils";
 import {RegistryMetricCreator} from "../../metrics/index.js";
@@ -179,7 +184,7 @@ export class Eth2Gossipsub {
       // Only send IDONTWANT messages if the message size is larger than this
       // This should be large enough to not send IDONTWANT for "small" messages
       // See https://github.com/ChainSafe/lodestar/pull/7077#issuecomment-2383679472
-      idontwantMinDataSize: 16829,
+      idontwantMinDataSize: MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
     })(modules.libp2p.services.components) as GossipSubInternal;
 
     if (metrics) {

package/src/network/gossip/topic.ts

@@ -1,12 +1,18 @@
+import {type CompositeTypeAny} from "@chainsafe/ssz";
 import {ForkDigestContext} from "@lodestar/config";
 import {
   ATTESTATION_SUBNET_COUNT,
   ForkName,
   ForkSeq,
+  MAX_ATTESTER_SLASHING_SIZE,
+  MAX_DATA_COLUMN_SIDECAR_SIZE,
+  MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
+  MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE,
   SYNC_COMMITTEE_SUBNET_COUNT,
   isForkPostAltair,
   isForkPostElectra,
   isForkPostFulu,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {Attestation, SingleAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {GossipAction, GossipActionError, GossipErrorCode} from "../../chain/errors/gossipValidation.js";
@@ -130,6 +136,30 @@ export function getGossipSSZType(topic: GossipTopic) {
   }
 }
 
+/**
+ * Return the maximum uncompressed SSZ byte length accepted for a gossip object.
+ */
+export function getGossipSSZMaxSize(topic: GossipTopic, maxPayloadSize: number, sszType?: CompositeTypeAny): number {
+  const {fork} = topic.boundary;
+  // Gloas progressive containers have broad theoretical SSZ max sizes; use the preset p2p bounds instead.
+  switch (topic.type) {
+    case GossipType.beacon_block:
+      return maxPayloadSize;
+    case GossipType.beacon_aggregate_and_proof:
+      return isForkPostGloas(fork) ? MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.attester_slashing:
+      return isForkPostGloas(fork) ? MAX_ATTESTER_SLASHING_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.data_column_sidecar:
+      return isForkPostGloas(fork) ? MAX_DATA_COLUMN_SIDECAR_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.execution_payload:
+      return maxPayloadSize;
+    case GossipType.execution_payload_bid:
+      return MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE;
+    default:
+      return (sszType ?? getGossipSSZType(topic)).maxSize;
+  }
+}
+
 /**
  * Deserialize a gossip serialized data into an ssz object.
  */

package/src/network/interface.ts

@@ -103,7 +103,9 @@ export interface INetwork extends INetworkCorePublic {
   publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
   publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number>;
   publishBeaconAttestation(attestation: SingleAttestation, subnet: SubnetID): Promise<number>;
-  publishDataColumnSidecar(dataColumnSideCar: DataColumnSidecar): Promise<number>;
+  publishDataColumnSidecar(
+    dataColumnSideCar: DataColumnSidecar
+  ): Promise<{sentPeers: number; alreadyPublished: boolean}>;
   publishVoluntaryExit(voluntaryExit: phase0.SignedVoluntaryExit): Promise<number>;
   publishBlsToExecutionChange(blsToExecutionChange: capella.SignedBLSToExecutionChange): Promise<number>;
   publishProposerSlashing(proposerSlashing: phase0.ProposerSlashing): Promise<number>;

package/src/network/network.ts

@@ -65,7 +65,7 @@ import {
 } from "./reqresp/utils/collect.js";
 import {collectSequentialBlocksInRange} from "./reqresp/utils/collectSequentialBlocksInRange.js";
 import {CommitteeSubscription} from "./subnets/index.js";
-import {isPublishToZeroPeersError, prettyPrintPeerIdStr} from "./util.js";
+import {isPublishDuplicateError, isPublishToZeroPeersError, prettyPrintPeerIdStr} from "./util.js";
 
 type NetworkModules = {
   opts: NetworkOptions;
@@ -366,7 +366,9 @@ export class Network implements INetwork {
     });
   }
 
-  async publishDataColumnSidecar(dataColumnSidecar: DataColumnSidecar): Promise<number> {
+  async publishDataColumnSidecar(
+    dataColumnSidecar: DataColumnSidecar
+  ): Promise<{sentPeers: number; alreadyPublished: boolean}> {
     const slot = isGloasDataColumnSidecar(dataColumnSidecar)
       ? dataColumnSidecar.slot
       : dataColumnSidecar.signedBlockHeader.message.slot;
@@ -374,18 +376,25 @@ export class Network implements INetwork {
     const boundary = this.config.getForkBoundaryAtEpoch(epoch);
 
     const subnet = computeSubnetForDataColumnSidecar(this.config, dataColumnSidecar);
-    return this.publishGossip<GossipType.data_column_sidecar>(
-      {type: GossipType.data_column_sidecar, boundary, subnet},
-      dataColumnSidecar,
-      {
-        ignoreDuplicatePublishError: true,
-        // we ensure having all topic peers via prioritizePeers() function
-        // in the worse case, if there is 0 peer on the topic, the overall publish operation could be still a success
-        // because supernode will rebuild and publish missing data column sidecars for us
-        // hence we want to track sent peers as 0 instead of an error
-        allowPublishToZeroTopicPeers: true,
+    try {
+      const sentPeers = await this.publishGossip<GossipType.data_column_sidecar>(
+        {type: GossipType.data_column_sidecar, boundary, subnet},
+        dataColumnSidecar,
+        {
+          // we ensure having all topic peers via prioritizePeers() function
+          // in the worse case, if there is 0 peer on the topic, the overall publish operation could be still a success
+          // because supernode will rebuild and publish missing data column sidecars for us
+          // hence we want to track sent peers as 0 instead of an error
+          allowPublishToZeroTopicPeers: true,
+        }
+      );
+      return {sentPeers, alreadyPublished: false};
+    } catch (e) {
+      if (isPublishDuplicateError(e as Error)) {
+        return {sentPeers: 0, alreadyPublished: true};
       }
-    );
+      throw e;
+    }
   }
 
   async publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number> {
@@ -860,8 +869,8 @@ export class Network implements INetwork {
     this.core.setTargetGroupCount(count);
   };
 
-  private onPublishDataColumns = (sidecars: DataColumnSidecar[]): Promise<number[]> => {
-    return promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
+  private onPublishDataColumns = async (sidecars: DataColumnSidecar[]): Promise<void> => {
+    await promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
   };
 
   private onPublishBlobSidecars = (sidecars: deneb.BlobSidecar[]): Promise<number[]> => {

package/src/network/processor/gossipHandlers.ts

@@ -176,7 +176,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
 
     // optimistically add gossip block to the seen cache
     // if validation fails, we will NOT forward this gossip block to peers
-    //   - if PARENT_UNKNOWN error, blockInput will then be queued inside BlockInputSync. If the gossip block is really invalid, it will be pruned there
+    //   - if PARENT_BLOCK_UNKNOWN error, blockInput will then be queued inside BlockInputSync. If the gossip block is really invalid, it will be pruned there
     //   - if other validator errors, blockInput will stay in the seen cache and will be pruned on finalization
     const blockInput = chain.seenBlockInputCache.getByBlock({
       block: signedBlock,
@@ -187,7 +187,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     });
 
     // Optimistically seed the payload-envelope cache too, mirroring seenBlockInputCache above.
-    // This ensures we have PayloadEnvelopeInput, even through "PARENT_UNKNOWN" error
+    // This ensures we have PayloadEnvelopeInput, even through "PARENT_BLOCK_UNKNOWN" error
     // see https://github.com/ChainSafe/lodestar/issues/9475
     if (isForkPostGloas(fork)) {
       chain.seenPayloadEnvelopeInputCache.add({
@@ -227,7 +227,8 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       if (e instanceof BlockGossipError) {
         logger.debug("Gossip block has error", {slot, root: blockShortHex, code: e.type.code});
         if (
-          (e.type.code === BlockErrorCode.PARENT_UNKNOWN || e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
+          (e.type.code === BlockErrorCode.PARENT_BLOCK_UNKNOWN ||
+            e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
           blockInput
         ) {
           chain.emitter.emit(ChainEvent.blockUnknownParent, {
@@ -661,14 +662,19 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
               break;
             }
             // ALREADY_KNOWN should not happen with ignoreIfKnown=true above
-            // PARENT_UNKNOWN should not happen, we handled this in validateBeaconBlock() function above
+            // PARENT_BLOCK_UNKNOWN should not happen, we handled this in validateBeaconBlock() function above
             case BlockErrorCode.ALREADY_KNOWN:
-            case BlockErrorCode.PARENT_UNKNOWN:
+            case BlockErrorCode.PARENT_BLOCK_UNKNOWN:
             case BlockErrorCode.PRESTATE_MISSING:
             case BlockErrorCode.EXECUTION_ENGINE_ERROR:
-              // Errors might indicate an issue with our node or the connected EL client
+              // Errors might indicate an issue with our node or the connected EL client.
               logLevel = LogLevel.error;
               break;
+            case BlockErrorCode.EXECUTION_ENGINE_INVALID:
+              // the peer served a bad block
+              core.reportPeer(peerIdStr, PeerAction.LowToleranceError, "ExecutionEngineInvalid");
+              logLevel = LogLevel.warn;
+              break;
             default:
               // TODO: Should it use PeerId or string?
               core.reportPeer(peerIdStr, PeerAction.LowToleranceError, "BadGossipBlock");

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