@lodestar/beacon-node 1.36.0-dev.f657221d88 → 1.36.0-dev.fe5f423da3

package/src/network/gossip/gossipsub.ts

@@ -6,7 +6,6 @@ import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
 import {SubnetID} from "@lodestar/types";
 import {Logger, Map2d, Map2dArr} from "@lodestar/utils";
-import {GOSSIP_MAX_SIZE, GOSSIP_MAX_SIZE_BELLATRIX} from "../../constants/network.js";
 import {RegistryMetricCreator} from "../../metrics/index.js";
 import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {NetworkEvent, NetworkEventBus, NetworkEventData} from "../events.js";
@@ -117,15 +116,7 @@ export class Eth2Gossipsub extends GossipSub {
       fastMsgIdFn: fastMsgIdFn,
       msgIdFn: msgIdFn.bind(msgIdFn, gossipTopicCache),
       msgIdToStrFn: msgIdToStrFn,
-      // Use the bellatrix max size if the merge is configured. pre-merge using this size
-      // could only be an issue on outgoing payloads, its highly unlikely we will send out
-      // a chunk bigger than GOSSIP_MAX_SIZE pre merge even on mainnet network.
-      //
-      // TODO: figure out a way to dynamically transition to the size
-      dataTransform: new DataTransformSnappy(
-        gossipTopicCache,
-        Number.isFinite(config.BELLATRIX_FORK_EPOCH) ? GOSSIP_MAX_SIZE_BELLATRIX : GOSSIP_MAX_SIZE
-      ),
+      dataTransform: new DataTransformSnappy(gossipTopicCache, config.MAX_PAYLOAD_SIZE),
       metricsRegister: metricsRegister as MetricsRegister | null,
       metricsTopicStrToLabel: metricsRegister
         ? getMetricsTopicStrToLabel(networkConfig, {disableLightClientServer: opts.disableLightClientServer ?? false})

package/src/network/network.ts

@@ -236,6 +236,7 @@ export class Network implements INetwork {
     this.chain.emitter.off(routes.events.EventType.lightClientOptimisticUpdate, this.onLightClientOptimisticUpdate);
     this.chain.emitter.off(ChainEvent.updateTargetCustodyGroupCount, this.onTargetGroupCountUpdated);
     this.chain.emitter.off(ChainEvent.publishDataColumns, this.onPublishDataColumns);
+    this.chain.emitter.off(ChainEvent.publishBlobSidecars, this.onPublishBlobSidecars);
     this.chain.emitter.off(ChainEvent.updateStatus, this.onUpdateStatus);
     await this.core.close();
 

package/src/network/processor/gossipHandlers.ts

@@ -556,6 +556,16 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           metrics?.dataColumns.elapsedTimeTillReceived.observe({receivedOrder: receivedColumns}, delaySec);
           break;
       }
+
+      if (!blockInput.hasAllData()) {
+        // immediately attempt fetch of data columns from execution engine
+        chain.getBlobsTracker.triggerGetBlobs(blockInput);
+        // if we've received at least half of the columns, trigger reconstruction of the rest
+        if (blockInput.columnCount >= NUMBER_OF_COLUMNS / 2) {
+          chain.columnReconstructionTracker.triggerColumnReconstruction(blockInput);
+        }
+      }
+
       if (!blockInput.hasBlockAndAllData()) {
         const cutoffTimeMs = getCutoffTimeMs(chain, dataColumnSlot, BLOCK_AVAILABILITY_CUTOFF_MS);
         chain.logger.debug("Received gossip data column, waiting for full data availability", {
@@ -578,12 +588,6 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
             source: BlockInputSource.gossip,
           });
         });
-        // immediately attempt fetch of data columns from execution engine
-        chain.getBlobsTracker.triggerGetBlobs(blockInput);
-        // if we've received at least half of the columns, trigger reconstruction of the rest
-        if (blockInput.columnCount >= NUMBER_OF_COLUMNS / 2) {
-          chain.columnReconstructionTracker.triggerColumnReconstruction(blockInput);
-        }
       }
     },
 

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

@@ -1,5 +1,5 @@
 import {ChainConfig} from "@lodestar/config";
-import {BLOBSIDECAR_FIXED_SIZE, GENESIS_SLOT} from "@lodestar/params";
+import {BLOB_SIDECAR_FIXED_SIZE, GENESIS_SLOT} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {Slot, deneb} from "@lodestar/types";
@@ -71,17 +71,17 @@ export function* iterateBlobBytesFromWrapper(
   blockSlot: Slot
 ): Iterable<ResponseOutgoing> {
   const allBlobSideCarsBytes = blobSideCarsBytesWrapped.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
-  const blobsLen = allBlobSideCarsBytes.length / BLOBSIDECAR_FIXED_SIZE;
+  const blobsLen = allBlobSideCarsBytes.length / BLOB_SIDECAR_FIXED_SIZE;
 
   for (let index = 0; index < blobsLen; index++) {
     const blobSideCarBytes = allBlobSideCarsBytes.slice(
-      index * BLOBSIDECAR_FIXED_SIZE,
-      (index + 1) * BLOBSIDECAR_FIXED_SIZE
+      index * BLOB_SIDECAR_FIXED_SIZE,
+      (index + 1) * BLOB_SIDECAR_FIXED_SIZE
     );
-    if (blobSideCarBytes.length !== BLOBSIDECAR_FIXED_SIZE) {
+    if (blobSideCarBytes.length !== BLOB_SIDECAR_FIXED_SIZE) {
       throw new ResponseError(
         RespStatus.SERVER_ERROR,
-        `Invalid blobSidecar index=${index} bytes length=${blobSideCarBytes.length} expected=${BLOBSIDECAR_FIXED_SIZE} for slot ${blockSlot} blobsLen=${blobsLen}`
+        `Invalid blobSidecar index=${index} bytes length=${blobSideCarBytes.length} expected=${BLOB_SIDECAR_FIXED_SIZE} for slot ${blockSlot} blobsLen=${blobsLen}`
       );
     }
     yield {

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

@@ -1,4 +1,4 @@
-import {BLOBSIDECAR_FIXED_SIZE} from "@lodestar/params";
+import {BLOB_SIDECAR_FIXED_SIZE} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {RootHex} from "@lodestar/types";
@@ -45,12 +45,12 @@ export async function* onBlobSidecarsByRoot(
     }
 
     const blobSidecarBytes = lastFetchedSideCars.bytes.slice(
-      index * BLOBSIDECAR_FIXED_SIZE,
-      (index + 1) * BLOBSIDECAR_FIXED_SIZE
+      index * BLOB_SIDECAR_FIXED_SIZE,
+      (index + 1) * BLOB_SIDECAR_FIXED_SIZE
     );
-    if (blobSidecarBytes.length !== BLOBSIDECAR_FIXED_SIZE) {
+    if (blobSidecarBytes.length !== BLOB_SIDECAR_FIXED_SIZE) {
       throw Error(
-        `Inconsistent state, blobSidecar blockRoot=${blockRootHex} index=${index} blobSidecarBytes=${blobSidecarBytes.length} expected=${BLOBSIDECAR_FIXED_SIZE}`
+        `Inconsistent state, blobSidecar blockRoot=${blockRootHex} index=${index} blobSidecarBytes=${blobSidecarBytes.length} expected=${BLOB_SIDECAR_FIXED_SIZE}`
       );
     }
 

package/src/network/subnets/attnetsService.ts

@@ -1,5 +1,5 @@
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
-import {ATTESTATION_SUBNET_COUNT, EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {Epoch, Slot, SubnetID, ssz} from "@lodestar/types";
 import {Logger, MapDef} from "@lodestar/utils";
@@ -92,8 +92,8 @@ export class AttnetsService implements IAttnetsService {
     const shortLivedSubnets = this.committeeSubnets.getActiveTtl(this.clock.currentSlot);
 
     const longLivedSubscriptionsToSlot =
-      (Math.floor(this.clock.currentEpoch / EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION) + 1) *
-      EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION *
+      (Math.floor(this.clock.currentEpoch / this.config.EPOCHS_PER_SUBNET_SUBSCRIPTION) + 1) *
+      this.config.EPOCHS_PER_SUBNET_SUBSCRIPTION *
       SLOTS_PER_EPOCH;
     const longLivedSubnets = Array.from(this.longLivedSubscriptions).map((subnet) => ({
       subnet,
@@ -234,11 +234,11 @@ export class AttnetsService implements IAttnetsService {
 
   /**
    * Run per epoch, clean-up operations that are not urgent
-   * Subscribe to new random subnets every EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION epochs
+   * Subscribe to new random subnets every EPOCHS_PER_SUBNET_SUBSCRIPTION epochs
    */
   private onEpoch = (epoch: Epoch): void => {
     try {
-      if (epoch % EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION === 0) {
+      if (epoch % this.config.EPOCHS_PER_SUBNET_SUBSCRIPTION === 0) {
         this.recomputeLongLivedSubnets();
       }
     } catch (e) {
@@ -253,7 +253,7 @@ export class AttnetsService implements IAttnetsService {
     }
 
     const oldSubnets = this.longLivedSubscriptions;
-    const newSubnets = computeSubscribedSubnet(this.nodeId, this.clock.currentEpoch);
+    const newSubnets = computeSubscribedSubnet(this.config, this.nodeId, this.clock.currentEpoch);
     this.logger.verbose("Recomputing long-lived subscriptions", {
       epoch: this.clock.currentEpoch,
       oldSubnets: Array.from(oldSubnets).join(","),

package/src/network/subnets/util.ts

@@ -1,11 +1,6 @@
 import {digest} from "@chainsafe/as-sha256";
-import {
-  ATTESTATION_SUBNET_COUNT,
-  ATTESTATION_SUBNET_PREFIX_BITS,
-  EPOCHS_PER_SUBNET_SUBSCRIPTION,
-  NODE_ID_BITS,
-  SUBNETS_PER_NODE,
-} from "@lodestar/params";
+import {ChainConfig} from "@lodestar/config";
+import {ATTESTATION_SUBNET_COUNT, ATTESTATION_SUBNET_PREFIX_BITS, NODE_ID_BITS} from "@lodestar/params";
 import {computeShuffledIndex} from "@lodestar/state-transition";
 import {Epoch, ssz} from "@lodestar/types";
 import {NodeId} from "./interface.js";
@@ -13,10 +8,10 @@ import {NodeId} from "./interface.js";
 /**
  * Spec https://github.com/ethereum/consensus-specs/blob/v1.4.0-alpha.3/specs/phase0/p2p-interface.md
  */
-export function computeSubscribedSubnet(nodeId: NodeId, epoch: Epoch): number[] {
+export function computeSubscribedSubnet(config: ChainConfig, nodeId: NodeId, epoch: Epoch): number[] {
   const subnets: number[] = [];
-  for (let index = 0; index < SUBNETS_PER_NODE; index++) {
-    subnets.push(computeSubscribedSubnetByIndex(nodeId, epoch, index));
+  for (let index = 0; index < config.SUBNETS_PER_NODE; index++) {
+    subnets.push(computeSubscribedSubnetByIndex(config, nodeId, epoch, index));
   }
   return subnets;
 }
@@ -24,11 +19,16 @@ export function computeSubscribedSubnet(nodeId: NodeId, epoch: Epoch): number[]
 /**
  * Spec https://github.com/ethereum/consensus-specs/blob/v1.4.0-alpha.3/specs/phase0/p2p-interface.md
  */
-export function computeSubscribedSubnetByIndex(nodeId: NodeId, epoch: Epoch, index: number): number {
+export function computeSubscribedSubnetByIndex(
+  config: ChainConfig,
+  nodeId: NodeId,
+  epoch: Epoch,
+  index: number
+): number {
   const nodeIdPrefix = getNodeIdPrefix(nodeId);
   const nodeOffset = getNodeOffset(nodeId);
   const permutationSeed = digest(
-    ssz.UintNum64.serialize(Math.floor((epoch + nodeOffset) / EPOCHS_PER_SUBNET_SUBSCRIPTION))
+    ssz.UintNum64.serialize(Math.floor((epoch + nodeOffset) / config.EPOCHS_PER_SUBNET_SUBSCRIPTION))
   );
   const permutatedPrefix = computeShuffledIndex(nodeIdPrefix, 1 << ATTESTATION_SUBNET_PREFIX_BITS, permutationSeed);
   return (permutatedPrefix + index) % ATTESTATION_SUBNET_COUNT;

package/src/sync/utils/remoteSyncType.ts

@@ -134,8 +134,8 @@ export function getRangeSyncTarget(
   return {
     syncType: RangeSyncType.Head,
     // The new peer has the same finalized (earlier filters should prevent a peer with an
-    // earlier finalized chain from reaching here).
-    startEpoch: Math.min(computeEpochAtSlot(local.headSlot), remote.finalizedEpoch),
+    // earlier finalized chain from reaching here) and local head will always be >= local finalized.
+    startEpoch: computeEpochAtSlot(local.headSlot),
     target: {
       slot: remote.headSlot,
       root: remote.headRoot,

package/src/util/clock.ts

@@ -4,7 +4,6 @@ import {ChainForkConfig} from "@lodestar/config";
 import {computeEpochAtSlot, computeTimeAtSlot, getCurrentSlot} from "@lodestar/state-transition";
 import type {Epoch, Slot} from "@lodestar/types";
 import {ErrorAborted} from "@lodestar/utils";
-import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../constants/constants.js";
 
 export enum ClockEvent {
   /**
@@ -101,7 +100,7 @@ export class Clock extends EventEmitter implements IClock {
   get currentSlotWithGossipDisparity(): Slot {
     const currentSlot = this.currentSlot;
     const nextSlotTime = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime) * 1000;
-    return nextSlotTime - Date.now() < MAXIMUM_GOSSIP_CLOCK_DISPARITY ? currentSlot + 1 : currentSlot;
+    return nextSlotTime - Date.now() < this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY ? currentSlot + 1 : currentSlot;
   }
 
   get currentEpoch(): Epoch {
@@ -130,12 +129,12 @@ export class Clock extends EventEmitter implements IClock {
     }
     const nextSlotTime = computeTimeAtSlot(this.config, currentSlot + 1, this.genesisTime) * 1000;
     // we're too close to next slot, accept next slot
-    if (nextSlotTime - Date.now() < MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
+    if (nextSlotTime - Date.now() < this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
       return slot === currentSlot + 1;
     }
     const currentSlotTime = computeTimeAtSlot(this.config, currentSlot, this.genesisTime) * 1000;
     // we've just passed the current slot, accept previous slot
-    if (Date.now() - currentSlotTime < MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
+    if (Date.now() - currentSlotTime < this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY) {
       return slot === currentSlot - 1;
     }
     return false;