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

package/src/chain/errors/executionPayloadBid.ts

@@ -5,6 +5,7 @@ export enum ExecutionPayloadBidErrorCode {
   BUILDER_NOT_ELIGIBLE = "EXECUTION_PAYLOAD_BID_ERROR_BUILDER_NOT_ELIGIBLE",
   INVALID_BUILDER_VERSION = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_BUILDER_VERSION",
   NON_ZERO_EXECUTION_PAYMENT = "EXECUTION_PAYLOAD_BID_ERROR_NON_ZERO_EXECUTION_PAYMENT",
+  INCOMPATIBLE_WITH_HEAD = "EXECUTION_PAYLOAD_BID_ERROR_INCOMPATIBLE_WITH_HEAD",
   BID_ALREADY_KNOWN = "EXECUTION_PAYLOAD_BID_ERROR_BID_ALREADY_KNOWN",
   BID_TOO_LOW = "EXECUTION_PAYLOAD_BID_ERROR_BID_TOO_LOW",
   BID_TOO_HIGH = "EXECUTION_PAYLOAD_BID_ERROR_BID_TOO_HIGH",
@@ -31,7 +32,14 @@ export type ExecutionPayloadBidErrorType =
   | {
       code: ExecutionPayloadBidErrorCode.NON_ZERO_EXECUTION_PAYMENT;
       builderIndex: BuilderIndex;
-      executionPayment: number;
+      executionPayment: bigint;
+    }
+  | {
+      code: ExecutionPayloadBidErrorCode.INCOMPATIBLE_WITH_HEAD;
+      slot: Slot;
+      parentBlockRoot: RootHex;
+      parentBlockHash: RootHex;
+      headBlockRoot: RootHex;
     }
   | {
       code: ExecutionPayloadBidErrorCode.BID_ALREADY_KNOWN;

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -234,6 +234,7 @@ export class AggregatedAttestationPool {
     const stateEpoch = state.epoch;
     const statePrevEpoch = stateEpoch - 1;
     const rootCache = new RootCache(state);
+    const gloasState = isStatePostGloas(state) ? state : null;
 
     const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, shufflingCache, state);
     const validateAttestationDataFn = getValidateAttestationDataFn(forkChoice, state);
@@ -361,7 +362,8 @@ export class AggregatedAttestationPool {
             inclusionDistance,
             stateEpoch,
             rootCache,
-            isStatePostGloas(state) ? state.executionPayloadAvailability : null
+            gloasState?.executionPayloadAvailability ?? null,
+            gloasState?.latestExecutionPayloadBid.slot ?? null
           );
 
           const weight =

package/src/chain/prepareNextSlot.ts

@@ -173,7 +173,7 @@ export class PrepareNextSlotScheduler {
         // Apply parent payload once here as it's reused by EL prep and SSE emit below
         let stateAfterParentPayload: IBeaconStateViewBellatrix = updatedPrepareState;
         if (isStatePostGloas(updatedPrepareState)) {
-          // Spec: should_build_on_full(store, head) — see produceBlockBody.ts for context.
+          // Spec: should_build_on_full(store, head, slot) - see produceBlockBody.ts for context.
           if (this.chain.forkChoice.shouldBuildOnFull(updatedHead, prepareSlot)) {
             parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.blockHash;
             // Skip applying parent payload unless we're proposing the next slot or have to emit payload_attributes events

package/src/chain/produceBlock/produceBlockBody.ts

@@ -276,7 +276,7 @@ export async function produceBlockBody<T extends BlockType>(
     let parentExecutionRequests: gloas.ExecutionRequests;
     // Apply parent payload once here as it's reused by EL prep and voluntary exit filtering below
     let stateAfterParentPayload: IBeaconStateViewBellatrix = currentState;
-    // Spec: should_build_on_full(store, head). `parentBlock` is the proposer's head
+    // Spec: should_build_on_full(store, head, slot). `parentBlock` is the proposer's head
     // (set by chain.getProposerHead(slot)). Returns false when the PTC majority signalled
     // the blob data is not available or the payload was not timely, forcing a build on EMPTY (reorg).
     const isBuildingOnFull = this.forkChoice.shouldBuildOnFull(parentBlock, blockSlot);
@@ -345,11 +345,11 @@ export async function produceBlockBody<T extends BlockType>(
       blockHash: executionPayload.blockHash,
       prevRandao: currentState.getRandaoMix(currentState.epoch),
       feeRecipient: executionPayload.feeRecipient,
-      gasLimit: executionPayload.gasLimit,
+      gasLimit: BigInt(executionPayload.gasLimit),
       builderIndex: BUILDER_INDEX_SELF_BUILD,
       slot: blockSlot,
       value: 0,
-      executionPayment: 0,
+      executionPayment: 0n,
       blobKzgCommitments: blobsBundle.commitments,
       executionRequestsRoot: ssz.gloas.ExecutionRequests.hashTreeRoot(executionRequests as gloas.ExecutionRequests),
     };

package/src/chain/seenCache/seenExecutionPayloadBids.ts

@@ -1,4 +1,4 @@
-import {BuilderIndex, Slot} from "@lodestar/types";
+import {BuilderIndex, RootHex, Slot} from "@lodestar/types";
 import {MapDef} from "@lodestar/utils";
 
 /**
@@ -7,29 +7,42 @@ import {MapDef} from "@lodestar/utils";
 const SLOTS_RETAINED = 2;
 
 /**
- * Tracks execution payload bids we've already seen per (slot, builder).
+ * Tracks execution payload bids we've already seen per
+ * (slot, builder, parent block hash, parent block root).
  */
 export class SeenExecutionPayloadBids {
-  private readonly builderIndexesBySlot = new MapDef<Slot, Set<BuilderIndex>>(() => new Set<BuilderIndex>());
+  private readonly branchesByBuilderBySlot = new MapDef<Slot, MapDef<BuilderIndex, Set<string>>>(
+    () => new MapDef<BuilderIndex, Set<string>>(() => new Set<string>())
+  );
   private lowestPermissibleSlot: Slot = 0;
 
-  isKnown(slot: Slot, builderIndex: BuilderIndex): boolean {
-    return this.builderIndexesBySlot.get(slot)?.has(builderIndex) === true;
+  isKnown(slot: Slot, builderIndex: BuilderIndex, parentBlockHash: RootHex, parentBlockRoot: RootHex): boolean {
+    return (
+      this.branchesByBuilderBySlot.get(slot)?.get(builderIndex)?.has(branchKey(parentBlockHash, parentBlockRoot)) ===
+      true
+    );
   }
 
-  add(slot: Slot, builderIndex: BuilderIndex): void {
+  add(slot: Slot, builderIndex: BuilderIndex, parentBlockHash: RootHex, parentBlockRoot: RootHex): void {
     if (slot < this.lowestPermissibleSlot) {
       throw Error(`slot ${slot} < lowestPermissibleSlot ${this.lowestPermissibleSlot}`);
     }
-    this.builderIndexesBySlot.getOrDefault(slot).add(builderIndex);
+    this.branchesByBuilderBySlot
+      .getOrDefault(slot)
+      .getOrDefault(builderIndex)
+      .add(branchKey(parentBlockHash, parentBlockRoot));
   }
 
   prune(currentSlot: Slot): void {
     this.lowestPermissibleSlot = Math.max(currentSlot - SLOTS_RETAINED, 0);
-    for (const slot of this.builderIndexesBySlot.keys()) {
+    for (const slot of this.branchesByBuilderBySlot.keys()) {
       if (slot < this.lowestPermissibleSlot) {
-        this.builderIndexesBySlot.delete(slot);
+        this.branchesByBuilderBySlot.delete(slot);
       }
     }
   }
 }
+
+function branchKey(parentBlockHash: RootHex, parentBlockRoot: RootHex): string {
+  return `${parentBlockHash}:${parentBlockRoot}`;
+}

package/src/chain/validation/blobSidecar.ts

@@ -111,7 +111,7 @@ export async function validateGossipBlobSidecar(
 
   // [REJECT] The blob is from a higher slot than its parent.
   if (parentBlock.slot >= blobSlot) {
-    throw new BlobSidecarGossipError(GossipAction.IGNORE, {
+    throw new BlobSidecarGossipError(GossipAction.REJECT, {
       code: BlobSidecarErrorCode.NOT_LATER_THAN_PARENT,
       parentSlot: parentBlock.slot,
       slot: blobSlot,

package/src/chain/validation/executionPayloadBid.ts

@@ -1,4 +1,5 @@
 import {PublicKey} from "@chainsafe/blst";
+import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {PAYLOAD_BUILDER_VERSION} from "@lodestar/params";
 import {
   computeEpochAtSlot,
@@ -8,7 +9,7 @@ import {
   isGasLimitTargetCompatible,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {ValidatorIndex, gloas} from "@lodestar/types";
+import {RootHex, Slot, ValidatorIndex, gloas} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {ExecutionPayloadBidError, ExecutionPayloadBidErrorCode, GossipAction} from "../errors/index.js";
@@ -36,12 +37,45 @@ const BID_INCREMENT_CAP_GWEI = 10_000_000;
  * Return the minimum value a new bid must have to be forwarded given the current highest bid.
  * Division before multiplication to stay within safe integer range for max gwei values.
  */
-export function getMinBidValue(currentHighestBid: number): number {
+function getMinBidValue(currentHighestBid: number): number {
   const relativeIncrement = Math.floor(currentHighestBid / 10_000) * BID_INCREMENT_BPS;
   const increment = Math.min(Math.max(BID_INCREMENT_FLOOR_GWEI, relativeIncrement), BID_INCREMENT_CAP_GWEI);
   return currentHighestBid + increment;
 }
 
+/**
+ * Check whether a bid builds on one of the paths compatible with the local head branch.
+ *
+ * The direct parent path is always allowed for proposer-boost reorgs. Otherwise the bid
+ * must build on the local head's full or empty payload variant, as selected for its slot.
+ */
+function isBidCompatibleWithHead(
+  forkChoice: IForkChoice,
+  head: ProtoBlock,
+  bidSlot: Slot,
+  bidParentBlockRoot: RootHex,
+  bidParentBlockHash: RootHex
+): boolean {
+  const buildsOnParentBlock = bidParentBlockRoot === head.parentRoot;
+  const buildsOnParentPayload = bidParentBlockHash === head.parentBlockHash;
+
+  if (buildsOnParentBlock && buildsOnParentPayload) {
+    return true;
+  }
+
+  if (bidParentBlockRoot !== head.blockRoot) {
+    return false;
+  }
+
+  const buildsOnHeadPayload = bidParentBlockHash === head.executionPayloadBlockHash;
+
+  if (forkChoice.shouldBuildOnFull(head, bidSlot)) {
+    return buildsOnHeadPayload;
+  }
+
+  return buildsOnParentPayload;
+}
+
 export async function validateApiExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
@@ -61,8 +95,8 @@ async function validateExecutionPayloadBid(
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
 ): Promise<{proposerIndex: ValidatorIndex}> {
   const bid = signedExecutionPayloadBid.message;
-  const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
-  const parentBlockHashHex = toRootHex(bid.parentBlockHash);
+  const bidParentBlockRoot = toRootHex(bid.parentBlockRoot);
+  const bidParentBlockHash = toRootHex(bid.parentBlockHash);
 
   // [IGNORE] `bid.slot` is the current slot, or the next slot (`bid.slot - 1` is current), allowing for `MAXIMUM_GOSSIP_CLOCK_DISPARITY`.
   if (
@@ -76,14 +110,40 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // [IGNORE] The bid is compatible with the current head branch.
+  const head = chain.forkChoice.getHead();
+  if (!isBidCompatibleWithHead(chain.forkChoice, head, bid.slot, bidParentBlockRoot, bidParentBlockHash)) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.INCOMPATIBLE_WITH_HEAD,
+      slot: bid.slot,
+      parentBlockRoot: bidParentBlockRoot,
+      parentBlockHash: bidParentBlockHash,
+      headBlockRoot: head.blockRoot,
+    });
+  }
+
+  // [IGNORE] this is the first signed bid seen with a valid signature from the given builder for
+  // the tuple `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
+  // Entries are only added after signature verification, so known tuples can be dropped before
+  // state regeneration and the other expensive validation steps.
+  if (chain.seenExecutionPayloadBids.isKnown(bid.slot, bid.builderIndex, bidParentBlockHash, bidParentBlockRoot)) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.BID_ALREADY_KNOWN,
+      builderIndex: bid.builderIndex,
+      slot: bid.slot,
+      parentBlockRoot: bidParentBlockRoot,
+      parentBlockHash: bidParentBlockHash,
+    });
+  }
+
   // [IGNORE] `bid.parent_block_root` is the hash tree root of a known beacon block in fork choice.
   // Moved earlier than the spec ordering so we can derive the proposer dependent root for the
   // proposer-preferences lookup below from a known fork-choice block.
-  const parentBlock = chain.forkChoice.getBlockHexDefaultStatus(parentBlockRootHex);
+  const parentBlock = chain.forkChoice.getBlockHexDefaultStatus(bidParentBlockRoot);
   if (parentBlock === null) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT,
-      parentBlockRoot: parentBlockRootHex,
+      parentBlockRoot: bidParentBlockRoot,
     });
   }
 
@@ -122,7 +182,7 @@ async function validateExecutionPayloadBid(
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.NO_MATCHING_PROPOSER_PREFERENCES,
       slot: bid.slot,
-      parentBlockRoot: parentBlockRootHex,
+      parentBlockRoot: bidParentBlockRoot,
       dependentRoot: "unknown",
     });
   }
@@ -132,7 +192,7 @@ async function validateExecutionPayloadBid(
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.NO_MATCHING_PROPOSER_PREFERENCES,
       slot: bid.slot,
-      parentBlockRoot: parentBlockRootHex,
+      parentBlockRoot: bidParentBlockRoot,
       dependentRoot: dependentRootHex,
     });
   }
@@ -143,7 +203,7 @@ async function validateExecutionPayloadBid(
     .catch(() => {
       throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
         code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT,
-        parentBlockRoot: parentBlockRootHex,
+        parentBlockRoot: bidParentBlockRoot,
       });
     });
 
@@ -184,7 +244,7 @@ async function validateExecutionPayloadBid(
   }
 
   // [REJECT] `bid.execution_payment` is zero.
-  if (bid.executionPayment !== 0) {
+  if (bid.executionPayment !== 0n) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.NON_ZERO_EXECUTION_PAYMENT,
       builderIndex: bid.builderIndex,
@@ -208,18 +268,18 @@ async function validateExecutionPayloadBid(
   // payload's hash) and EMPTY parents (EMPTY/PENDING variants carry the inherited parent
   // payload's hash, since the new block doesn't have its own payload). Variant carries the
   // executed payload's gas_limit, which we use as `parent_gas_limit` below.
-  const parentPayloadVariant = chain.forkChoice.getBlockHexAndBlockHash(parentBlockRootHex, parentBlockHashHex);
+  const parentPayloadVariant = chain.forkChoice.getBlockHexAndBlockHash(bidParentBlockRoot, bidParentBlockHash);
   if (parentPayloadVariant === null || parentPayloadVariant.executionPayloadBlockHash === null) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.UNKNOWN_PARENT_BLOCK_HASH,
-      parentBlockHash: parentBlockHashHex,
+      parentBlockHash: bidParentBlockHash,
     });
   }
 
   // [IGNORE] `is_gas_limit_target_compatible(parent_gas_limit, bid.gas_limit, target_gas_limit)`,
   // where `parent_gas_limit` is the `gas_limit` of the parent execution payload and
   // `target_gas_limit` is `proposer_preferences.target_gas_limit`.
-  const bidGasLimit = bid.gasLimit;
+  const bidGasLimit = Number(bid.gasLimit);
   const parentGasLimit = parentPayloadVariant.executionPayloadGasLimit;
   const targetGasLimit = proposerPreferences.message.targetGasLimit;
   if (!isGasLimitTargetCompatible(parentGasLimit, bidGasLimit, targetGasLimit)) {
@@ -245,23 +305,12 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] this is the first signed bid seen with a valid signature from the given builder for this slot.
-  if (chain.seenExecutionPayloadBids.isKnown(bid.slot, bid.builderIndex)) {
-    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
-      code: ExecutionPayloadBidErrorCode.BID_ALREADY_KNOWN,
-      builderIndex: bid.builderIndex,
-      slot: bid.slot,
-      parentBlockRoot: parentBlockRootHex,
-      parentBlockHash: parentBlockHashHex,
-    });
-  }
-
   // [IGNORE] this bid is the highest value bid seen for the tuple
   // `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
   // As a DoS prevention measure, the bid must also exceed the current highest bid by a minimum
   // increment, see https://github.com/ethereum/consensus-specs/pull/4831. This prevents spam
   // from builders submitting numerous bids with minimal value increments.
-  const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, parentBlockHashHex, parentBlockRootHex);
+  const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, bidParentBlockHash, bidParentBlockRoot);
   if (bestBid !== null && bid.value < getMinBidValue(bestBid.message.value)) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
@@ -306,8 +355,20 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // Repeat the seen check after the awaited signature verification to prevent concurrent bids
+  // for the same builder and tuple from both passing validation.
+  if (chain.seenExecutionPayloadBids.isKnown(bid.slot, bid.builderIndex, bidParentBlockHash, bidParentBlockRoot)) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.BID_ALREADY_KNOWN,
+      builderIndex: bid.builderIndex,
+      slot: bid.slot,
+      parentBlockRoot: bidParentBlockRoot,
+      parentBlockHash: bidParentBlockHash,
+    });
+  }
+
   // Valid
-  chain.seenExecutionPayloadBids.add(bid.slot, bid.builderIndex);
+  chain.seenExecutionPayloadBids.add(bid.slot, bid.builderIndex, bidParentBlockHash, bidParentBlockRoot);
 
   return {proposerIndex: proposerPreferences.message.validatorIndex};
 }

package/src/chain/validation/proposerPreferences.ts

@@ -1,5 +1,5 @@
 import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
-import {GENESIS_SLOT, MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {GENESIS_EPOCH, GENESIS_SLOT, MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
@@ -24,9 +24,10 @@ export async function validateGossipProposerPreferences(
   const dependentRootHex = toRootHex(dependentRoot);
   const proposalEpoch = computeEpochAtSlot(proposalSlot);
 
-  // [IGNORE] `preferences.proposal_slot` is within the proposer lookahead.
-  const currentEpoch = chain.clock.currentEpoch;
-  if (proposalEpoch < currentEpoch || proposalEpoch > currentEpoch + MIN_SEED_LOOKAHEAD) {
+  // [IGNORE] `preferences.proposal_slot` is within the proposer lookahead,
+  // allowing for `MAXIMUM_GOSSIP_CLOCK_DISPARITY`.
+  const currentEpoch = computeEpochAtSlot(chain.clock.currentSlotWithGossipDisparity);
+  if (proposalEpoch > currentEpoch + MIN_SEED_LOOKAHEAD) {
     throw new ProposerPreferencesError(GossipAction.IGNORE, {
       code: ProposerPreferencesErrorCode.INVALID_EPOCH,
       proposalSlot,
@@ -36,12 +37,11 @@ export async function validateGossipProposerPreferences(
 
   // [IGNORE] `preferences.proposal_slot` has not already passed, i.e. `proposal_slot > current_slot`,
   // allowing for `MAXIMUM_GOSSIP_CLOCK_DISPARITY`.
-  const currentSlot = chain.clock.currentSlotWithGossipDisparity;
-  if (proposalSlot <= currentSlot) {
+  if (chain.clock.msFromSlot(proposalSlot) > chain.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
     throw new ProposerPreferencesError(GossipAction.IGNORE, {
       code: ProposerPreferencesErrorCode.PROPOSAL_SLOT_PASSED,
       proposalSlot,
-      currentSlot,
+      currentSlot: chain.clock.currentSlot,
     });
   }
 
@@ -55,7 +55,7 @@ export async function validateGossipProposerPreferences(
     });
   }
 
-  const dependentEpoch = proposalEpoch - MIN_SEED_LOOKAHEAD;
+  const dependentEpoch = Math.max(GENESIS_EPOCH, proposalEpoch - MIN_SEED_LOOKAHEAD);
   const dependentRootSlot = getDependentRootSlot(dependentEpoch);
 
   // [REJECT] The slot of the block with root `preferences.dependent_root` is strictly less than

package/src/chain/validatorMonitor.ts

@@ -469,7 +469,7 @@ export function createValidatorMonitor(
         proposerIndex,
         src,
         builderIndex: bid.builderIndex,
-        gasLimit: bid.gasLimit,
+        gasLimit: Number(bid.gasLimit),
         value: bid.value.toString(),
         parentBlockRoot: toRootHex(bid.parentBlockRoot),
         parentBlockHash: toRootHex(bid.parentBlockHash),

package/src/metrics/nodeJsMetrics.ts

@@ -1,5 +1,5 @@
 import {Registry, collectDefaultMetrics} from "prom-client";
-import {gcStats} from "#prometheus-gc-stats-wrapper";
+import {gcStats} from "@chainsafe/prometheus-gc-stats";
 
 export function collectNodeJSMetrics(register: Registry, prefix?: string): () => void {
   collectDefaultMetrics({

package/src/network/core/networkCoreWorkerHandler.ts

@@ -132,10 +132,6 @@ export class WorkerNetworkCore implements INetworkCore {
 
     const workerOpts: ConstructorParameters<typeof Worker>[1] = {
       workerData,
-    };
-    if (globalThis.Bun) {
-      workerOpts.suppressTranspileTS = true;
-    } else {
       /**
        * maxYoungGenerationSizeMb defaults to 152mb through the cli option defaults.
        * That default value was determined via https://github.com/ChainSafe/lodestar/issues/2115 and
@@ -147,8 +143,8 @@ export class WorkerNetworkCore implements INetworkCore {
        * showed that there is a pretty big window of "correct" values but we can always tune as
        * necessary
        */
-      workerOpts.resourceLimits = {maxYoungGenerationSizeMb: opts.maxYoungGenerationSizeMb};
-    }
+      resourceLimits: {maxYoungGenerationSizeMb: opts.maxYoungGenerationSizeMb},
+    };
 
     const worker = new Worker(path.join(workerDir, "networkCoreWorker.js"), workerOpts);
 

package/src/network/discv5/index.ts

@@ -51,10 +51,7 @@ export class Discv5Worker extends (EventEmitter as {new (): StrictEventEmitter<E
       loggerOpts: opts.logger.toOpts(),
       genesisTime: opts.genesisTime,
     };
-    const worker = new Worker("./worker.js", {
-      suppressTranspileTS: Boolean(globalThis.Bun),
-      workerData,
-    } as ConstructorParameters<typeof Worker>[1]);
+    const worker = new Worker("./worker.js", {workerData} as ConstructorParameters<typeof Worker>[1]);
 
     const workerApi = await spawn<Discv5WorkerApi>(worker, {
       // A Lodestar Node may do very expensive task at start blocking the event loop and causing

package/src/network/libp2p/index.ts

@@ -9,7 +9,7 @@ import {Libp2pInit, createLibp2p} from "libp2p";
 import {Registry} from "prom-client";
 import {ENR} from "@chainsafe/enr";
 import {noise} from "@chainsafe/libp2p-noise";
-import {asCrypto, defaultCrypto} from "@chainsafe/libp2p-noise/crypto";
+import {defaultCrypto} from "@chainsafe/libp2p-noise/crypto";
 import {quic} from "@chainsafe/libp2p-quic";
 import {Libp2p, LodestarComponents} from "../interface.js";
 import {NetworkOptions, defaultNetworkOptions} from "../options.js";
@@ -111,14 +111,6 @@ export async function createNodeJsLibp2p(
     }
   }
 
-  const noiseCrypto = {
-    ...defaultCrypto,
-  };
-  if (globalThis.Bun) {
-    noiseCrypto.chaCha20Poly1305Decrypt = asCrypto.chaCha20Poly1305Decrypt;
-    noiseCrypto.chaCha20Poly1305Encrypt = asCrypto.chaCha20Poly1305Encrypt;
-  }
-
   return createLibp2p({
     privateKey,
     nodeInfo: {
@@ -130,7 +122,7 @@ export async function createNodeJsLibp2p(
       listen: localMultiaddrs,
       announce: [],
     },
-    connectionEncrypters: [noise({crypto: noiseCrypto})],
+    connectionEncrypters: [noise({crypto: defaultCrypto})],
     transports,
     streamMuxers: [mplex({disconnectThreshold})],
     peerDiscovery,

package/src/network/peers/datastore.ts

@@ -1,7 +1,7 @@
 import {AbortOptions} from "@libp2p/interface";
 import {BaseDatastore} from "datastore-core";
+import {LevelDatastore} from "datastore-level";
 import {Key, KeyQuery, Pair, Query} from "interface-datastore";
-import {LevelDatastore} from "#datastore-wrapper";
 
 type MemoryItem = {
   lastAccessedMs: number;

package/src/network/processor/index.ts

@@ -461,7 +461,8 @@ export class NetworkProcessor {
           break;
         }
         case GossipType.execution_payload_bid: {
-          // instead of searching for the message root, this searches for the parent root
+          // Search for the parent independently of current head compatibility. A bid may arrive
+          // before its parent block, so compatibility is checked later during gossip validation.
           const parentBlockRoot = getParentBlockRootFromSignedExecutionPayloadBidSerialized(message.msg.data);
           const parentBlockHash = getParentBlockHashFromSignedExecutionPayloadBidSerialized(message.msg.data);
           if (

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

@@ -19,8 +19,12 @@ export async function* onLightClientUpdatesByRange(
   assertLightClientServer(chain.lightClientServer);
 
   const count = Math.min(MAX_REQUEST_LIGHT_CLIENT_UPDATES, requestBody.count);
+  if (!Number.isSafeInteger(requestBody.startPeriod)) {
+    throw new ResponseError(RespStatus.INVALID_REQUEST, "startPeriod out of range");
+  }
   let started = false;
-  for (let period = requestBody.startPeriod; period < requestBody.startPeriod + count; period++) {
+  for (let i = 0; i < count; i++) {
+    const period = requestBody.startPeriod + i;
     try {
       const update = await chain.lightClientServer.getUpdate(period);
       const boundary = chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(update.signatureSlot));

package/src/sync/constants.ts

@@ -15,12 +15,13 @@ export const MAX_BATCH_DOWNLOAD_ATTEMPTS = 5;
 export const RATE_LIMITED_PEER_BACKOFF_MS = 5_000;
 
 /**
- * Consider batch faulty after downloading and processing this number of times
- * as in https://github.com/ChainSafe/lodestar/issues/8147 we cannot proceed the sync chain if there is unknown parent
- * from prior batch. For example a peer may send us a non-canonical chain segment or not returning all blocks
- * in that case we should throw error and `RangeSync` should remove that error chain and add a new one.
+ * Consider a batch faulty once its failed processing attempts EXCEED this number, i.e. the batch is
+ * processed up to `MAX_BATCH_PROCESSING_ATTEMPTS + 1` times before teardown (the check is `>`, same
+ * convention as `MAX_BATCH_DOWNLOAD_ATTEMPTS`).
+ * Some processing failures can be caused by a different batch, so range sync classifies the fault
+ * before deciding which batch to redownload.
  **/
-export const MAX_BATCH_PROCESSING_ATTEMPTS = 0;
+export const MAX_BATCH_PROCESSING_ATTEMPTS = 3;
 
 /**
  * Number of slots to offset batches.

package/src/sync/range/batch.ts

@@ -64,6 +64,7 @@ export type DownloadSuccessState = {
   status: BatchStatus.AwaitingProcessing;
   blocks: IBlockInput[];
   payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null;
+  attempt: Attempt;
 };
 
 export type BatchState =
@@ -589,7 +590,11 @@ export class Batch {
     }
 
     if (allComplete) {
-      this.state = {status: BatchStatus.AwaitingProcessing, blocks, payloadEnvelopes: newPayloadEnvelopes};
+      const attempt: Attempt = {
+        peers: this.getSuccessfulPeers(),
+        hash: hashBlocks(blocks, this.config),
+      };
+      this.state = {status: BatchStatus.AwaitingProcessing, blocks, payloadEnvelopes: newPayloadEnvelopes, attempt};
     } else {
       this.state = {status: BatchStatus.AwaitingDownload, blocks, payloadEnvelopes: newPayloadEnvelopes};
       this.requests = this.getRequests(blocks);
@@ -646,15 +651,11 @@ export class Batch {
       throw new BatchError(this.wrongStatusErrorType(BatchStatus.AwaitingProcessing));
     }
 
-    const blocks = this.state.blocks;
-    const payloadEnvelopes = this.state.payloadEnvelopes;
-    const hash = hashBlocks(blocks, this.config); // tracks blocks to report peer on processing error
-    // Reset successfulDownloads in case another download attempt needs to be made. When Attempt is successful or not
-    // the peers that the data came from will be handled by the Attempt that goes for processing.
-    const peers = this.getSuccessfulPeers();
+    const {blocks, payloadEnvelopes, attempt} = this.state;
+    // No need to track successfulDownloads anymore, the batch goes to Processing status.
     this.successfulDownloads.clear();
-    this.state = {status: BatchStatus.Processing, blocks, payloadEnvelopes, attempt: {peers, hash}};
-    return {blocks, payloadEnvelopes, peers};
+    this.state = {status: BatchStatus.Processing, blocks, payloadEnvelopes, attempt};
+    return {blocks, payloadEnvelopes, peers: attempt.peers};
   }
 
   /**
@@ -673,6 +674,26 @@ export class Batch {
     };
   }
 
+  /**
+   * Processing -> AwaitingProcessing
+   *
+   * The batch's own blocks are valid but processing failed because a previous batch did not
+   * deliver the parent. Keep the downloaded blocks and process them again once the previous
+   * batch is repaired.
+   */
+  retainForReprocessing(): void {
+    if (this.state.status !== BatchStatus.Processing) {
+      throw new BatchError(this.wrongStatusErrorType(BatchStatus.Processing));
+    }
+
+    this.state = {
+      status: BatchStatus.AwaitingProcessing,
+      blocks: this.state.blocks,
+      payloadEnvelopes: this.state.payloadEnvelopes,
+      attempt: this.state.attempt,
+    };
+  }
+
   /**
    * Processing -> AwaitingDownload
    */
@@ -750,7 +771,7 @@ export enum BatchErrorCode {
   INVALID_COUNT = "BATCH_ERROR_INVALID_COUNT",
   MAX_DOWNLOAD_ATTEMPTS = "BATCH_ERROR_MAX_DOWNLOAD_ATTEMPTS",
   MAX_PROCESSING_ATTEMPTS = "BATCH_ERROR_MAX_PROCESSING_ATTEMPTS",
-  MAX_EXECUTION_ENGINE_ERROR_ATTEMPTS = "MAX_EXECUTION_ENGINE_ERROR_ATTEMPTS",
+  MAX_EXECUTION_ENGINE_ERROR_ATTEMPTS = "BATCH_ERROR_MAX_EXECUTION_ENGINE_ERROR_ATTEMPTS",
 }
 
 type BatchErrorType =