@lodestar/beacon-node 1.41.0-dev.983b1a457b → 1.41.0-dev.9939b12b53

package/src/db/repositories/blockArchive.ts

@@ -1,4 +1,3 @@
-import all from "it-all";
 import {ChainForkConfig} from "@lodestar/config";
 import {Db, FilterOptions, KeyValue, Repository} from "@lodestar/db";
 import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
@@ -121,7 +120,7 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   }
 
   async values(opts?: BlockFilterOptions): Promise<SignedBeaconBlock[]> {
-    return all(this.valuesStream(opts));
+    return await Array.fromAsync(this.valuesStream(opts));
   }
 
   // INDEX

package/src/db/repositories/dataColumnSidecar.ts

@@ -1,7 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Db, PrefixedRepository, decodeNumberForDbKey, encodeNumberForDbKey} from "@lodestar/db";
 import {NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {ColumnIndex, Root, fulu, ssz} from "@lodestar/types";
+import {ColumnIndex, DataColumnSidecar, Root, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
+import {isGloasDataColumnSidecarBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 const COLUMN_INDEX_BYTE_SIZE = 2;
@@ -15,7 +16,7 @@ type BlockRoot = Root;
  *
  * Indexed data by `blockRoot` + `columnIndex`
  */
-export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, fulu.DataColumnSidecar> {
+export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
     const bucket = Bucket.fulu_dataColumnSidecars;
     super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
@@ -24,10 +25,24 @@ export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, C
   /**
    * Id is hashTreeRoot of unsigned BeaconBlock
    */
-  getId(value: fulu.DataColumnSidecar): ColumnIndex {
+  getId(value: DataColumnSidecar): ColumnIndex {
     return value.index;
   }
 
+  encodeValue(value: DataColumnSidecar): Uint8Array {
+    if (isGloasDataColumnSidecar(value)) {
+      return ssz.gloas.DataColumnSidecar.serialize(value);
+    }
+    return ssz.fulu.DataColumnSidecar.serialize(value);
+  }
+
+  decodeValue(data: Uint8Array): DataColumnSidecar {
+    if (isGloasDataColumnSidecarBytes(data)) {
+      return ssz.gloas.DataColumnSidecar.deserialize(data);
+    }
+    return ssz.fulu.DataColumnSidecar.deserialize(data);
+  }
+
   encodeKeyRaw(prefix: BlockRoot, id: ColumnIndex): Uint8Array {
     return Buffer.concat([prefix, encodeNumberForDbKey(id, COLUMN_INDEX_BYTE_SIZE)]);
   }

package/src/db/repositories/dataColumnSidecarArchive.ts

@@ -1,7 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {Db, PrefixedRepository, decodeNumberForDbKey, encodeNumberForDbKey} from "@lodestar/db";
 import {NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {ColumnIndex, Slot, fulu, ssz} from "@lodestar/types";
+import {ColumnIndex, DataColumnSidecar, Slot, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
+import {isGloasDataColumnSidecarBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 const COLUMN_INDEX_BYTE_SIZE = 2;
@@ -13,7 +14,7 @@ const SLOT_BYTE_SIZE = 8;
  *
  * Indexed data by `slot` + `columnIndex`
  */
-export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, fulu.DataColumnSidecar> {
+export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
     const bucket = Bucket.fulu_dataColumnSidecarsArchive;
     super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
@@ -22,10 +23,24 @@ export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot,
   /**
    * Id is hashTreeRoot of unsigned BeaconBlock
    */
-  getId(value: fulu.DataColumnSidecar): ColumnIndex {
+  getId(value: DataColumnSidecar): ColumnIndex {
     return value.index;
   }
 
+  encodeValue(value: DataColumnSidecar): Uint8Array {
+    if (isGloasDataColumnSidecar(value)) {
+      return ssz.gloas.DataColumnSidecar.serialize(value);
+    }
+    return ssz.fulu.DataColumnSidecar.serialize(value);
+  }
+
+  decodeValue(data: Uint8Array): DataColumnSidecar {
+    if (isGloasDataColumnSidecarBytes(data)) {
+      return ssz.gloas.DataColumnSidecar.deserialize(data);
+    }
+    return ssz.fulu.DataColumnSidecar.deserialize(data);
+  }
+
   encodeKeyRaw(prefix: Slot, id: ColumnIndex): Uint8Array {
     return Buffer.concat([
       encodeNumberForDbKey(prefix, SLOT_BYTE_SIZE),

package/src/db/repositories/executionPayloadEnvelope.ts

@@ -0,0 +1,26 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {Root, gloas, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+type BlockRoot = Root;
+
+/**
+ * Used to store unfinalized `SignedExecutionPayloadEnvelope`
+ *
+ * Indexed by beacon block root (root of the beacon block that contains the bid)
+ */
+export class ExecutionPayloadEnvelopeRepository extends Repository<BlockRoot, gloas.SignedExecutionPayloadEnvelope> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.gloas_executionPayloadEnvelope;
+    super(config, db, bucket, ssz.gloas.SignedExecutionPayloadEnvelope, getBucketNameByValue(bucket));
+  }
+
+  /**
+   * Id is the beacon block root (not execution payload hash)
+   * This allows correlation with the block that contains the bid
+   */
+  getId(value: gloas.SignedExecutionPayloadEnvelope): BlockRoot {
+    return value.message.beaconBlockRoot;
+  }
+}

package/src/db/repositories/executionPayloadEnvelopeArchive.ts

@@ -0,0 +1,32 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {BUCKET_LENGTH, Db, Repository, encodeKey as encodeDbKey} from "@lodestar/db";
+import {Slot, gloas, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * Used to store finalized `SignedExecutionPayloadEnvelope`
+ *
+ * Indexed by slot for chronological archival
+ */
+export class ExecutionPayloadEnvelopeArchiveRepository extends Repository<Slot, gloas.SignedExecutionPayloadEnvelope> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.gloas_executionPayloadEnvelopeArchive;
+    super(config, db, bucket, ssz.gloas.SignedExecutionPayloadEnvelope, getBucketNameByValue(bucket));
+  }
+
+  /**
+   * Id is the slot from the envelope
+   */
+  getId(value: gloas.SignedExecutionPayloadEnvelope): Slot {
+    return value.message.slot;
+  }
+
+  encodeKey(id: Slot): Uint8Array {
+    return encodeDbKey(this.bucket, id);
+  }
+
+  decodeKey(data: Uint8Array): number {
+    return bytesToInt(data.subarray(BUCKET_LENGTH), "be");
+  }
+}

package/src/db/repositories/index.ts

@@ -8,6 +8,8 @@ export {BlockArchiveRepository} from "./blockArchive.js";
 export {BLSToExecutionChangeRepository} from "./blsToExecutionChange.js";
 export {DataColumnSidecarRepository} from "./dataColumnSidecar.js";
 export {DataColumnSidecarArchiveRepository} from "./dataColumnSidecarArchive.js";
+export {ExecutionPayloadEnvelopeRepository} from "./executionPayloadEnvelope.js";
+export {ExecutionPayloadEnvelopeArchiveRepository} from "./executionPayloadEnvelopeArchive.js";
 export {BestLightClientUpdateRepository} from "./lightclientBestUpdate.js";
 export {CheckpointHeaderRepository} from "./lightclientCheckpointHeader.js";
 export {SyncCommitteeRepository} from "./lightclientSyncCommittee.js";

package/src/execution/engine/http.ts

@@ -128,6 +128,7 @@ const getClientVersionOpts: ReqOpts = {routeId: "getClientVersion"};
  */
 export class ExecutionEngineHttp implements IExecutionEngine {
   private logger: Logger;
+  private metrics: Metrics | null;
 
   // The default state is ONLINE, it will be updated to SYNCING once we receive the first payload
   // This assumption is better than the OFFLINE state, since we can't be sure if the EL is offline and being offline may trigger some notifications
@@ -167,6 +168,7 @@ export class ExecutionEngineHttp implements IExecutionEngine {
       metrics?.engineHttpProcessorQueue
     );
     this.logger = logger;
+    this.metrics = metrics ?? null;
 
     this.rpc.emitter.on(JsonRpcHttpClientEvent.ERROR, ({error}) => {
       this.updateEngineState(getExecutionEngineState({payloadError: error, oldState: this.state}));
@@ -369,6 +371,7 @@ export class ExecutionEngineHttp implements IExecutionEngine {
     } = await request;
 
     this.updateEngineState(getExecutionEngineState({payloadStatus: status, oldState: this.state}));
+    this.metrics?.engineNotifyForkchoiceUpdateResult.inc({result: status});
 
     switch (status) {
       case ExecutionPayloadStatus.VALID:

package/src/metrics/metrics/beacon.ts

@@ -144,6 +144,11 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
         help: "Time for preparing payload in advance",
         buckets: [0.1, 1, 3, 5, 10],
       }),
+      executionPayloadEnvelopeProcessingTime: register.histogram({
+        name: "beacon_block_payload_envelope_processing_seconds",
+        help: "Time to process execution payload envelope during block production",
+        buckets: [0.005, 0.01, 0.05, 0.1, 0.2, 0.5, 1],
+      }),
       payloadFetchedTime: register.histogram<{prepType: PayloadPreparationType}>({
         name: "beacon_block_payload_fetched_time",
         help: "Time to fetch the payload from EL",
@@ -328,11 +333,13 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
         help: "Time taken to verify data_column sidecar inclusion proof",
         buckets: [0.002, 0.004, 0.006, 0.008, 0.01, 0.05, 1, 2],
       }),
+      // single verification
       dataColumnSidecarKzgProofsVerificationTime: register.histogram({
         name: "beacon_data_column_sidecar_kzg_proofs_verification_seconds",
-        help: "Time taken to verify data_column sidecar kzg proofs",
+        help: "Time taken to verify single data_column sidecar kzg proofs",
         buckets: [0.01, 0.02, 0.03, 0.04, 0.05, 0.1, 0.2, 0.5, 1],
       }),
+      // batch verification
       kzgVerificationDataColumnBatchTime: register.histogram({
         name: "beacon_kzg_verification_data_column_batch_seconds",
         help: "Runtime of batched data column kzg verification",
@@ -356,10 +363,14 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
         help: "Duration of engine_getBlobsV2 requests",
         buckets: [0.01, 0.05, 0.1, 0.5, 1, 2.5, 5, 7.5],
       }),
-      targetCustodyGroupCount: register.gauge({
-        name: "beacon_target_custody_group_count",
+      custodyGroupCount: register.gauge({
+        name: "beacon_custody_groups",
         help: "Total number of custody groups within a node",
       }),
+      custodyGroupsBackfilled: register.gauge({
+        name: "beacon_custody_groups_backfilled",
+        help: "Total number of custody groups backfilled by a node",
+      }),
       reconstructedColumns: register.counter({
         name: "beacon_data_availability_reconstructed_columns_total",
         help: "Total count of reconstructed columns",

package/src/metrics/metrics/lodestar.ts

@@ -827,20 +827,32 @@ export function createLodestarMetrics(
         help: "Total number of blobs retrieved from execution engine and published to gossip",
       }),
     },
-    recoverDataColumnSidecars: {
-      recoverTime: register.histogram({
-        name: "lodestar_recover_data_column_sidecar_recover_time_seconds",
-        help: "Time elapsed to recover data column sidecar",
-        buckets: [0.5, 1.0, 1.5, 2],
+    // Gossip execution payload envelope
+    gossipExecutionPayloadEnvelope: {
+      elapsedTimeTillReceived: register.histogram<{source: OpSource}>({
+        name: "lodestar_gossip_execution_payload_envelope_elapsed_time_till_received",
+        help: "Time elapsed between slot time and the time execution payload envelope received",
+        labelNames: ["source"],
+        buckets: [0.5, 1, 2, 4, 6, 12],
       }),
+    },
+    // recovery in the case of specific blob rows required
+    recoverBlobSidecars: {
+      blobsReconstructed: register.counter({
+        name: "lodestar_blobs_reconstructed_total",
+        help: "Total count of reconstructed blobs",
+      }),
+      reconstructionTime: register.histogram({
+        name: "lodestar_blob_reconstruction_seconds",
+        help: "Time taken to reconstruct blobs",
+        buckets: [0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 2, 5],
+      }),
+    },
+    recoverDataColumnSidecars: {
       custodyBeforeReconstruction: register.gauge({
         name: "lodestar_data_columns_in_custody_before_reconstruction",
         help: "Number of data columns in custody before reconstruction",
       }),
-      numberOfColumnsRecovered: register.gauge({
-        name: "lodestar_recover_data_column_sidecar_recovered_columns_total",
-        help: "Total number of columns that were recovered",
-      }),
       reconstructionResult: register.counter<{result: DataColumnReconstructionCode}>({
         name: "lodestar_data_column_sidecars_reconstruction_result",
         help: "Data column sidecars reconstruction result",
@@ -848,6 +860,10 @@ export function createLodestarMetrics(
       }),
     },
     dataColumns: {
+      alreadyAdded: register.counter({
+        name: "lodestar_data_column_sidecar_already_added",
+        help: "Total number of columns that were already added by other sources while waiting",
+      }),
       bySource: register.gauge<{source: BlockInputSource}>({
         name: "lodestar_data_columns_by_source",
         help: "Number of received data columns by source",
@@ -903,11 +919,6 @@ export function createLodestarMetrics(
         help: "Total number of imported blobs by source",
         labelNames: ["blobsSource"],
       }),
-      columnsBySource: register.gauge<{source: BlockInputSource}>({
-        name: "lodestar_import_columns_by_source_total",
-        help: "Total number of imported columns (sampled columns) by source",
-        labelNames: ["source"],
-      }),
       notOverrideFcuReason: register.counter<{reason: NotReorgedReason}>({
         name: "lodestar_import_block_not_override_fcu_reason_total",
         help: "Reason why the fcu call is not suppressed during block import",
@@ -919,6 +930,11 @@ export function createLodestarMetrics(
       help: "The total result of calling notifyNewPayload execution engine api",
       labelNames: ["result"],
     }),
+    engineNotifyForkchoiceUpdateResult: register.gauge<{result: ExecutionPayloadStatus}>({
+      name: "lodestar_execution_engine_notify_forkchoice_update_result_total",
+      help: "The total result of calling notifyForkchoiceUpdate execution engine api",
+      labelNames: ["result"],
+    }),
     backfillSync: {
       backfilledTillSlot: register.gauge({
         name: "lodestar_backfill_till_slot",
@@ -1447,29 +1463,37 @@ export function createLodestarMetrics(
           name: "lodestar_seen_block_input_cache_size",
           help: "Number of cached BlockInputs",
         }),
-        duplicateBlockCount: register.gauge<{source: BlockInputSource}>({
-          name: "lodestar_seen_block_input_cache_duplicate_block_count",
+        serializedObjectRefs: register.gauge({
+          name: "lodestar_seen_block_input_cache_serialized_object_refs",
+          help: "Number of serialized-cache object refs retained by cached BlockInputs",
+        }),
+        duplicateBlockCount: register.counter<{source: BlockInputSource}>({
+          name: "lodestar_seen_block_input_cache_duplicate_block_total",
           help: "Total number of duplicate blocks that pass validation and attempt to be cached but are known",
           labelNames: ["source"],
         }),
-        duplicateBlobCount: register.gauge<{source: BlockInputSource}>({
-          name: "lodestar_seen_block_input_cache_duplicate_blob_count",
+        duplicateBlobCount: register.counter<{source: BlockInputSource}>({
+          name: "lodestar_seen_block_input_cache_duplicate_blob_total",
           help: "Total number of duplicate blobs that pass validation and attempt to be cached but are known",
           labelNames: ["source"],
         }),
-        duplicateColumnCount: register.gauge<{source: BlockInputSource}>({
-          name: "lodestar_seen_block_input_cache_duplicate_column_count",
+        duplicateColumnCount: register.counter<{source: BlockInputSource}>({
+          name: "lodestar_seen_block_input_cache_duplicate_column_total",
           help: "Total number of duplicate columns that pass validation and attempt to be cached but are known",
           labelNames: ["source"],
         }),
-        createdByBlock: register.gauge({
-          name: "lodestar_seen_block_input_cache_items_created_by_block",
+        createdByBlock: register.counter({
+          name: "lodestar_seen_block_input_cache_items_created_by_block_total",
           help: "Number of BlockInputs created via a block being seen first",
         }),
-        createdByBlob: register.gauge({
-          name: "lodestar_seen_block_input_cache_items_created_by_blob",
+        createdByBlob: register.counter({
+          name: "lodestar_seen_block_input_cache_items_created_by_blob_total",
           help: "Number of BlockInputs created via a blob being seen first",
         }),
+        createdByColumn: register.counter({
+          name: "lodestar_seen_block_input_cache_items_created_by_column_total",
+          help: "Number of BlockInputs created via a data column being seen first",
+        }),
       },
     },
 

package/src/monitoring/service.ts

@@ -89,9 +89,9 @@ export class MonitoringService {
   }
 
   /**
-   * Stop sending client stats
+   * Stop sending client stats and wait for any pending request to complete
    */
-  close(): void {
+  async close(): Promise<void> {
     if (this.status === Status.Closed) return;
     this.status = Status.Closed;
 
@@ -103,6 +103,7 @@ export class MonitoringService {
     }
     if (this.pendingRequest) {
       this.fetchAbortController?.abort(FetchAbortReason.Close);
+      await this.pendingRequest;
     }
   }
 

package/src/network/core/networkCore.ts

@@ -1,8 +1,8 @@
-import {Connection, PrivateKey} from "@libp2p/interface";
+import type {PeerScoreStatsDump} from "@libp2p/gossipsub/score";
+import type {PublishOpts} from "@libp2p/gossipsub/types";
+import type {Connection, PrivateKey} from "@libp2p/interface";
 import {peerIdFromPrivateKey} from "@libp2p/peer-id";
 import {multiaddr} from "@multiformats/multiaddr";
-import {PeerScoreStatsDump} from "@chainsafe/libp2p-gossipsub/score";
-import {PublishOpts} from "@chainsafe/libp2p-gossipsub/types";
 import {routes} from "@lodestar/api";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";

package/src/network/core/networkCoreWorkerHandler.ts

@@ -1,9 +1,9 @@
 import path from "node:path";
 import workerThreads from "node:worker_threads";
 import {privateKeyToProtobuf} from "@libp2p/crypto/keys";
-import {PrivateKey} from "@libp2p/interface";
-import {PeerScoreStatsDump} from "@chainsafe/libp2p-gossipsub/score";
-import {PublishOpts} from "@chainsafe/libp2p-gossipsub/types";
+import type {PeerScoreStatsDump} from "@libp2p/gossipsub/score";
+import type {PublishOpts} from "@libp2p/gossipsub/types";
+import type {PrivateKey} from "@libp2p/interface";
 import {ModuleThread, Thread, Worker, spawn} from "@chainsafe/threads";
 import {routes} from "@lodestar/api";
 import {BeaconConfig, chainConfigToJson} from "@lodestar/config";

package/src/network/core/types.ts

@@ -1,5 +1,5 @@
-import {PeerScoreStatsDump} from "@chainsafe/libp2p-gossipsub/score";
-import {PublishOpts} from "@chainsafe/libp2p-gossipsub/types";
+import type {PeerScoreStatsDump} from "@libp2p/gossipsub/score";
+import type {PublishOpts} from "@libp2p/gossipsub/types";
 import {routes} from "@lodestar/api";
 import {SpecJson} from "@lodestar/config";
 import {LoggerNodeOpts} from "@lodestar/logger/node";

package/src/network/discv5/utils.ts

@@ -4,7 +4,7 @@ import {IClock} from "../../util/clock.js";
 import {ENRKey} from "../metadata.js";
 
 export enum ENRRelevance {
-  no_tcp = "no_tcp",
+  no_transport = "no_transport",
   no_eth2 = "no_eth2",
   // biome-ignore lint/style/useNamingConvention: Need to use the this name for network convention
   unknown_forkDigest = "unknown_forkDigest",
@@ -13,10 +13,11 @@ export enum ENRRelevance {
 }
 
 export function enrRelevance(enr: ENR, config: BeaconConfig, clock: IClock): ENRRelevance {
-  // We are not interested in peers that don't advertise their tcp addr
+  // We are not interested in peers that don't advertise at least one transport (tcp or quic)
   const multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
-  if (!multiaddrTCP) {
-    return ENRRelevance.no_tcp;
+  const multiaddrQUIC = enr.getLocationMultiaddr(ENRKey.quic);
+  if (!multiaddrTCP && !multiaddrQUIC) {
+    return ENRRelevance.no_transport;
   }
 
   // Check if the ENR.eth2 field matches and is of interest

package/src/network/events.ts

@@ -1,5 +1,6 @@
 import {EventEmitter} from "node:events";
-import {PeerId, TopicValidatorResult} from "@libp2p/interface";
+import type {TopicValidatorResult} from "@libp2p/gossipsub";
+import type {PeerId} from "@libp2p/interface";
 import {CustodyIndex, Status} from "@lodestar/types";
 import {PeerIdStr} from "../util/peerId.js";
 import {StrictEventEmitterSingleArg} from "../util/strictEvents.js";

package/src/network/gossip/encoding.ts

@@ -1,9 +1,9 @@
-import {Message} from "@libp2p/interface";
+import type {Message} from "@libp2p/gossipsub";
+import type {RPC} from "@libp2p/gossipsub/message";
+import type {DataTransform} from "@libp2p/gossipsub/types";
 // snappyjs is better for compression for smaller payloads
 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";