@lodestar/beacon-node 1.37.0 → 1.38.0-dev.255e56fb68

package/src/chain/blocks/verifyBlock.ts

@@ -7,7 +7,7 @@ import {
   computeEpochAtSlot,
   isStateValidatorsNodesPopulated,
 } from "@lodestar/state-transition";
-import {bellatrix, deneb} from "@lodestar/types";
+import {IndexedAttestation, bellatrix, deneb} from "@lodestar/types";
 import {Logger, toRootHex} from "@lodestar/utils";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
@@ -47,6 +47,7 @@ export async function verifyBlocksInEpoch(
   proposerBalanceDeltas: number[];
   segmentExecStatus: SegmentExecStatus;
   dataAvailabilityStatuses: DataAvailabilityStatus[];
+  indexedAttestationsByBlock: IndexedAttestation[][];
 }> {
   const blocks = blockInputs.map((blockInput) => blockInput.getBlock());
   const lastBlock = blocks.at(-1);
@@ -65,6 +66,9 @@ export async function verifyBlocksInEpoch(
     }
   }
 
+  // All blocks are in the same epoch
+  const fork = this.config.getForkSeq(block0.message.slot);
+
   // TODO: Skip in process chain segment
   // Retrieve preState from cache (regen)
   const preState0 = await this.regen
@@ -92,6 +96,24 @@ export async function verifyBlocksInEpoch(
   const abortController = new AbortController();
 
   try {
+    // Start execution payload verification first (async request to execution client)
+    const verifyExecutionPayloadsPromise =
+      opts.skipVerifyExecutionPayload !== true
+        ? verifyBlocksExecutionPayload(this, parentBlock, blockInputs, preState0, abortController.signal, opts)
+        : Promise.resolve({
+            execAborted: null,
+            executionStatuses: blocks.map((_blk) => ExecutionStatus.Syncing),
+            mergeBlockFound: null,
+          } as SegmentExecStatus);
+
+    // Store indexed attestations for each block to avoid recomputing them during import
+    const indexedAttestationsByBlock: IndexedAttestation[][] = [];
+    for (const [i, block] of blocks.entries()) {
+      indexedAttestationsByBlock[i] = block.message.body.attestations.map((attestation) =>
+        preState0.epochCtx.getIndexedAttestation(fork, attestation)
+      );
+    }
+
     // batch all I/O operations to reduce overhead
     const [
       segmentExecStatus,
@@ -99,14 +121,7 @@ export async function verifyBlocksInEpoch(
       {postStates, proposerBalanceDeltas, verifyStateTime},
       {verifySignaturesTime},
     ] = await Promise.all([
-      // Execution payloads
-      opts.skipVerifyExecutionPayload !== true
-        ? verifyBlocksExecutionPayload(this, parentBlock, blockInputs, preState0, abortController.signal, opts)
-        : Promise.resolve({
-            execAborted: null,
-            executionStatuses: blocks.map((_blk) => ExecutionStatus.Syncing),
-            mergeBlockFound: null,
-          } as SegmentExecStatus),
+      verifyExecutionPayloadsPromise,
 
       // data availability for the blobs
       verifyBlocksDataAvailability(blockInputs, abortController.signal),
@@ -127,7 +142,15 @@ export async function verifyBlocksInEpoch(
 
       // All signatures at once
       opts.skipVerifyBlockSignatures !== true
-        ? verifyBlocksSignatures(this.bls, this.logger, this.metrics, preState0, blocks, opts)
+        ? verifyBlocksSignatures(
+            this.bls,
+            this.logger,
+            this.metrics,
+            preState0,
+            blocks,
+            indexedAttestationsByBlock,
+            opts
+          )
         : Promise.resolve({verifySignaturesTime: Date.now()}),
 
       // ideally we want to only persist blocks after verifying them however the reality is there are
@@ -222,7 +245,7 @@ export async function verifyBlocksInEpoch(
       );
     }
 
-    return {postStates, dataAvailabilityStatuses, proposerBalanceDeltas, segmentExecStatus};
+    return {postStates, dataAvailabilityStatuses, proposerBalanceDeltas, segmentExecStatus, indexedAttestationsByBlock};
   } finally {
     abortController.abort();
   }

package/src/chain/blocks/verifyBlocksSignatures.ts

@@ -1,5 +1,5 @@
 import {CachedBeaconStateAllForks, getBlockSignatureSets} from "@lodestar/state-transition";
-import {SignedBeaconBlock} from "@lodestar/types";
+import {IndexedAttestation, SignedBeaconBlock} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {nextEventLoop} from "../../util/eventLoop.js";
@@ -20,6 +20,7 @@ export async function verifyBlocksSignatures(
   metrics: Metrics | null,
   preState0: CachedBeaconStateAllForks,
   blocks: SignedBeaconBlock[],
+  indexedAttestationsByBlock: IndexedAttestation[][],
   opts: ImportBlockOpts
 ): Promise<{verifySignaturesTime: number}> {
   const isValidPromises: Promise<boolean>[] = [];
@@ -37,7 +38,7 @@ export async function verifyBlocksSignatures(
       : //
         // Verify signatures per block to track which block is invalid
         bls.verifySignatureSets(
-          getBlockSignatureSets(preState0, block, {
+          getBlockSignatureSets(preState0, block, indexedAttestationsByBlock[i], {
             skipProposerSignature: opts.validProposerSignature,
           })
         );

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -22,6 +22,7 @@ import {
 import {
   CachedBeaconStateAllForks,
   CachedBeaconStateAltair,
+  CachedBeaconStateGloas,
   CachedBeaconStatePhase0,
   EffectiveBalanceIncrements,
   RootCache,
@@ -486,7 +487,10 @@ export class AggregatedAttestationPool {
             consolidation.attData,
             inclusionDistance,
             stateEpoch,
-            rootCache
+            rootCache,
+            ForkSeq[fork] >= ForkSeq.gloas
+              ? (state as CachedBeaconStateGloas).executionPayloadAvailability.toBoolArray()
+              : null
           );
 
           const weight =

package/src/network/gossip/encoding.ts

@@ -1,13 +1,14 @@
 import {Message} from "@libp2p/interface";
 // snappyjs is better for compression for smaller payloads
-import {compress, uncompress} from "snappyjs";
 import xxhashFactory from "xxhash-wasm";
 import {digest} from "@chainsafe/as-sha256";
 import {RPC} from "@chainsafe/libp2p-gossipsub/message";
 import {DataTransform} from "@chainsafe/libp2p-gossipsub/types";
+import snappyWasm from "@chainsafe/snappy-wasm";
 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";
 
 // Load WASM
@@ -16,6 +17,10 @@ const xxhash = await xxhashFactory();
 // Use salt to prevent msgId from being mined for collisions
 const h64Seed = BigInt(Math.floor(Math.random() * 1e9));
 
+// create singleton snappy encoder + decoder
+const encoder = new snappyWasm.Encoder();
+const decoder = new snappyWasm.Decoder();
+
 // Shared buffer to convert msgId to string
 const sharedMsgIdBuf = Buffer.alloc(20);
 
@@ -70,7 +75,8 @@ export function msgIdFn(gossipTopicCache: GossipTopicCache, msg: Message): Uint8
 export class DataTransformSnappy implements DataTransform {
   constructor(
     private readonly gossipTopicCache: GossipTopicCache,
-    private readonly maxSizePerMessage: number
+    private readonly maxSizePerMessage: number,
+    private readonly metrics: Eth2GossipsubMetrics | null
   ) {}
 
   /**
@@ -80,13 +86,15 @@ export class DataTransformSnappy implements DataTransform {
    * - `outboundTransform()`: compress snappy payload
    */
   inboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
-    const uncompressedData = uncompress(data, this.maxSizePerMessage);
+    // 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}`);
+    }
 
-    // check uncompressed data length before we extract beacon block root, slot or
-    // attestation data at later steps
-    const uncompressedDataLength = uncompressedData.length;
     const topic = this.gossipTopicCache.getTopic(topicStr);
     const sszType = getGossipSSZType(topic);
+    this.metrics?.dataTransform.inbound.inc({type: topic.type});
 
     if (uncompressedDataLength < sszType.minSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} < ${sszType.minSize}`);
@@ -95,6 +103,10 @@ export class DataTransformSnappy implements DataTransform {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${sszType.maxSize}`);
     }
 
+    // Only after sanity length checks, we can decompress the data
+    // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments
+    const uncompressedData = Buffer.alloc(uncompressedDataLength);
+    decoder.decompress_into(data, uncompressedData);
     return uncompressedData;
   }
 
@@ -102,11 +114,16 @@ export class DataTransformSnappy implements DataTransform {
    * Takes the data to be published (a topic and associated data) transforms the data. The
    * transformed data will then be used to create a `RawGossipsubMessage` to be sent to peers.
    */
-  outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
+  outboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
+    const topic = this.gossipTopicCache.getTopic(topicStr);
+    this.metrics?.dataTransform.outbound.inc({type: topic.type});
     if (data.length > this.maxSizePerMessage) {
       throw Error(`ssz_snappy encoded data length ${data.length} > ${this.maxSizePerMessage}`);
     }
-    // No need to parse topic, everything is snappy compressed
-    return compress(data);
+
+    // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments
+    const compressedData = Buffer.alloc(snappyWasm.max_compress_len(data.length));
+    const compressedLen = encoder.compress_into(data, compressedData);
+    return compressedData.subarray(0, compressedLen);
   }
 }

package/src/network/gossip/gossipsub.ts

@@ -89,6 +89,13 @@ export class Eth2Gossipsub extends GossipSub {
     const gossipTopicCache = new GossipTopicCache(config);
 
     const scoreParams = computeGossipPeerScoreParams({config, eth2Context: modules.eth2Context});
+    let metrics: Eth2GossipsubMetrics | null = null;
+    if (metricsRegister) {
+      metrics = createEth2GossipsubMetrics(metricsRegister);
+      metrics.gossipMesh.peersByType.addCollect(() =>
+        this.onScrapeLodestarMetrics(metrics as Eth2GossipsubMetrics, networkConfig)
+      );
+    }
 
     // Gossipsub parameters defined here:
     // https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#the-gossip-domain-gossipsub
@@ -116,7 +123,7 @@ export class Eth2Gossipsub extends GossipSub {
       fastMsgIdFn: fastMsgIdFn,
       msgIdFn: msgIdFn.bind(msgIdFn, gossipTopicCache),
       msgIdToStrFn: msgIdToStrFn,
-      dataTransform: new DataTransformSnappy(gossipTopicCache, config.MAX_PAYLOAD_SIZE),
+      dataTransform: new DataTransformSnappy(gossipTopicCache, config.MAX_PAYLOAD_SIZE, metrics),
       metricsRegister: metricsRegister as MetricsRegister | null,
       metricsTopicStrToLabel: metricsRegister
         ? getMetricsTopicStrToLabel(networkConfig, {disableLightClientServer: opts.disableLightClientServer ?? false})
@@ -141,11 +148,6 @@ export class Eth2Gossipsub extends GossipSub {
     this.events = events;
     this.gossipTopicCache = gossipTopicCache;
 
-    if (metricsRegister) {
-      const metrics = createEth2GossipsubMetrics(metricsRegister);
-      metrics.gossipMesh.peersByType.addCollect(() => this.onScrapeLodestarMetrics(metrics, networkConfig));
-    }
-
     this.addEventListener("gossipsub:message", this.onGossipsubMessage.bind(this));
     this.events.on(NetworkEvent.gossipMessageValidationResult, this.onValidationResult.bind(this));
 

package/src/network/gossip/metrics.ts

@@ -67,5 +67,17 @@ export function createEth2GossipsubMetrics(register: RegistryMetricCreator) {
         labelNames: ["subnet", "boundary"],
       }),
     },
+    dataTransform: {
+      inbound: register.counter<{type: GossipType}>({
+        name: "lodestar_gossip_data_transform_inbound_total",
+        help: "Total number of inbound data transforms by gossip type",
+        labelNames: ["type"],
+      }),
+      outbound: register.counter<{type: GossipType}>({
+        name: "lodestar_gossip_data_transform_outbound_total",
+        help: "Total number of outbound data transforms by gossip type",
+        labelNames: ["type"],
+      }),
+    },
   };
 }