@lodestar/beacon-node 1.39.1 → 1.40.0-dev.1020f27ca9

package/src/chain/validatorMonitor.ts

@@ -24,7 +24,7 @@ import {
   altair,
   deneb,
 } from "@lodestar/types";
-import {LogData, LogHandler, LogLevel, Logger, MapDef, MapDefMax, toRootHex} from "@lodestar/utils";
+import {LogData, LogHandler, LogLevel, Logger, MapDef, MapDefMax, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/constants.js";
 import {RegistryMetricCreator} from "../metrics/index.js";
 
@@ -39,7 +39,8 @@ const MAX_CACHED_DISTINCT_TARGETS = 4;
 const LATE_ATTESTATION_SUBMISSION_BPS = 5000;
 const LATE_BLOCK_SUBMISSION_BPS = 2500;
 
-const RETAIN_REGISTERED_VALIDATORS_MS = 1 * 3600 * 1000; // 1 hour
+/** Number of epochs to retain registered validators after their last registration */
+const RETAIN_REGISTERED_VALIDATORS_EPOCHS = 2;
 
 type Seconds = number;
 export enum OpSource {
@@ -97,6 +98,8 @@ export type ValidatorMonitor = {
   ): void;
   onceEveryEndOfEpoch(state: CachedBeaconStateAllForks): void;
   scrapeMetrics(slotClock: Slot): void;
+  /** Returns the list of validator indices currently being monitored */
+  getMonitoredValidatorIndices(): ValidatorIndex[];
 };
 
 export type ValidatorMonitorOpts = {
@@ -284,6 +287,9 @@ export function createValidatorMonitor(
     logger[logLevel](message, context);
   };
 
+  // Calculate retain time dynamically based on slot duration (2 epochs)
+  const retainRegisteredValidatorsMs = SLOTS_PER_EPOCH * config.SLOT_DURATION_MS * RETAIN_REGISTERED_VALIDATORS_EPOCHS;
+
   /** The validators that require additional monitoring. */
   const validators = new MapDef<ValidatorIndex, MonitoredValidator>(() => ({
     summaries: new Map<Epoch, EpochSummary>(),
@@ -306,11 +312,19 @@ export function createValidatorMonitor(
 
   let lastRegisteredStatusEpoch = -1;
 
+  // Track validator additions/removals per epoch for logging
+  const addedValidatorsInEpoch: Set<ValidatorIndex> = new Set();
+  const removedValidatorsInEpoch: Set<ValidatorIndex> = new Set();
+
   const validatorMonitorMetrics = metricsRegister ? createValidatorMonitorMetrics(metricsRegister) : null;
 
   const validatorMonitor: ValidatorMonitor = {
     registerLocalValidator(index) {
+      const isNewValidator = !validators.has(index);
       validators.getOrDefault(index).lastRegisteredTimeMs = Date.now();
+      if (isNewValidator) {
+        addedValidatorsInEpoch.add(index);
+      }
     },
 
     registerLocalValidatorInSyncCommittee(index, untilEpoch) {
@@ -333,6 +347,9 @@ export function createValidatorMonitor(
         return;
       }
 
+      // Track total balance instead of per-validator balance to reduce metric cardinality
+      let totalBalance = 0;
+
       for (const [index, monitoredValidator] of validators.entries()) {
         // We subtract two from the state of the epoch that generated these summaries.
         //
@@ -391,7 +408,7 @@ export function createValidatorMonitor(
 
         const balance = balances?.[index];
         if (balance !== undefined) {
-          validatorMonitorMetrics?.prevEpochOnChainBalance.set({index}, balance);
+          totalBalance += balance;
         }
 
         if (!summary.isPrevSourceAttester || !summary.isPrevTargetAttester || !summary.isPrevHeadAttester) {
@@ -406,6 +423,10 @@ export function createValidatorMonitor(
           });
         }
       }
+
+      if (balances !== undefined) {
+        validatorMonitorMetrics?.prevEpochOnChainBalance.set(totalBalance);
+      }
     },
 
     registerBeaconBlock(src, delaySec, block) {
@@ -673,11 +694,29 @@ export function createValidatorMonitor(
 
       // Prune validators not seen in a while
       for (const [index, validator] of validators.entries()) {
-        if (Date.now() - validator.lastRegisteredTimeMs > RETAIN_REGISTERED_VALIDATORS_MS) {
+        if (Date.now() - validator.lastRegisteredTimeMs > retainRegisteredValidatorsMs) {
           validators.delete(index);
+          removedValidatorsInEpoch.add(index);
         }
       }
 
+      // Log validator monitor status every epoch
+      const allIndices = Array.from(validators.keys()).sort((a, b) => a - b);
+      const addedIndices = Array.from(addedValidatorsInEpoch).sort((a, b) => a - b);
+      const removedIndices = Array.from(removedValidatorsInEpoch).sort((a, b) => a - b);
+
+      log("Validator monitor status", {
+        epoch: computeEpochAtSlot(headState.slot),
+        added: addedIndices.length > 0 ? prettyPrintIndices(addedIndices) : "none",
+        removed: removedIndices.length > 0 ? prettyPrintIndices(removedIndices) : "none",
+        total: validators.size,
+        indices: prettyPrintIndices(allIndices),
+      });
+
+      // Clear tracking sets for next epoch
+      addedValidatorsInEpoch.clear();
+      removedValidatorsInEpoch.clear();
+
       // Compute summaries of previous epoch attestation performance
       const prevEpoch = computeEpochAtSlot(headState.slot) - 1;
 
@@ -736,6 +775,13 @@ export function createValidatorMonitor(
     scrapeMetrics(slotClock) {
       validatorMonitorMetrics?.validatorsConnected.set(validators.size);
 
+      // Update static metric with connected validator indices
+      if (validatorMonitorMetrics?.validatorsConnectedIndices) {
+        validatorMonitorMetrics.validatorsConnectedIndices.reset();
+        const allIndices = Array.from(validators.keys()).sort((a, b) => a - b);
+        validatorMonitorMetrics.validatorsConnectedIndices.set({indices: prettyPrintIndices(allIndices)}, 1);
+      }
+
       const epoch = computeEpochAtSlot(slotClock);
       const slotInEpoch = slotClock % SLOTS_PER_EPOCH;
 
@@ -815,6 +861,10 @@ export function createValidatorMonitor(
       validatorMonitorMetrics?.prevEpochSyncCommitteeHits.set(prevEpochSyncCommitteeHits);
       validatorMonitorMetrics?.prevEpochSyncCommitteeMisses.set(prevEpochSyncCommitteeMisses);
     },
+
+    getMonitoredValidatorIndices() {
+      return Array.from(validators.keys()).sort((a, b) => a - b);
+    },
   };
 
   // Register a single collect() function to run all validatorMonitor metrics
@@ -1098,17 +1148,21 @@ function createValidatorMonitorMetrics(register: RegistryMetricCreator) {
       help: "Count of validators that are specifically monitored by this beacon node",
     }),
 
+    validatorsConnectedIndices: register.gauge<{indices: string}>({
+      name: "validator_monitor_indices",
+      help: "Static metric with connected validator indices as label, value is always 1",
+      labelNames: ["indices"],
+    }),
+
     validatorsInSyncCommittee: register.gauge({
       name: "validator_monitor_validators_in_sync_committee",
       help: "Count of validators monitored by this beacon node that are part of sync committee",
     }),
 
     // Validator Monitor Metrics (per-epoch summaries)
-    // Only track prevEpochOnChainBalance per index
-    prevEpochOnChainBalance: register.gauge<{index: number}>({
+    prevEpochOnChainBalance: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_balance",
-      help: "Balance of validator after an epoch",
-      labelNames: ["index"],
+      help: "Total balance of all monitored validators after an epoch",
     }),
     prevEpochOnChainAttesterHit: register.gauge({
       name: "validator_monitor_prev_epoch_on_chain_attester_hit_total",

package/src/db/repositories/checkpointState.ts

@@ -1,31 +1,15 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, Repository} from "@lodestar/db";
-import {BeaconStateAllForks} from "@lodestar/state-transition";
-import {ssz} from "@lodestar/types";
+import {BinaryRepository, Db} from "@lodestar/db";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 /**
  * Store temporary checkpoint states.
  * We should only put/get binary data from this repository, consumer will load it into an existing state ViewDU object.
  */
-export class CheckpointStateRepository extends Repository<Uint8Array, BeaconStateAllForks> {
+export class CheckpointStateRepository extends BinaryRepository<Uint8Array> {
   constructor(config: ChainForkConfig, db: Db) {
-    // Pick some type but won't be used. Casted to any because no type can match `BeaconStateAllForks`
-    const type = ssz.phase0.BeaconState;
     const bucket = Bucket.allForks_checkpointState;
-    // biome-ignore lint/suspicious/noExplicitAny: The type is complex to specify a proper override
-    super(config, db, bucket, type as any, getBucketNameByValue(bucket));
-  }
-
-  getId(): Uint8Array {
-    throw Error("CheckpointStateRepository does not work with value");
-  }
-
-  encodeValue(): Uint8Array {
-    throw Error("CheckpointStateRepository does not work with value");
-  }
 
-  decodeValue(): BeaconStateAllForks {
-    throw Error("CheckpointStateRepository does not work with value");
+    super(config, db, bucket, getBucketNameByValue(bucket));
   }
 }

package/src/db/repositories/stateArchive.ts

@@ -1,39 +1,25 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, Repository} from "@lodestar/db";
-import {BeaconStateAllForks} from "@lodestar/state-transition";
-import {Epoch, Root, RootHex, Slot, ssz} from "@lodestar/types";
+import {BinaryRepository, Db} from "@lodestar/db";
+import {Root, RootHex, Slot} from "@lodestar/types";
 import {bytesToInt, toHex} from "@lodestar/utils";
-import {getStateTypeFromBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 import {getRootIndex, getRootIndexKey, storeRootIndex} from "./stateArchiveIndex.js";
 
-export class StateArchiveRepository extends Repository<Slot, BeaconStateAllForks> {
+export type BeaconStateArchive = {
+  serialize(): Uint8Array;
+  hashTreeRoot(): Root;
+};
+
+export class StateArchiveRepository extends BinaryRepository<Slot> {
   constructor(config: ChainForkConfig, db: Db) {
-    // Pick some type but won't be used. Casted to any because no type can match `BeaconStateAllForks`
-    // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
-    const type = ssz.phase0.BeaconState as any;
     const bucket = Bucket.allForks_stateArchive;
-    super(config, db, bucket, type, getBucketNameByValue(bucket));
-  }
-
-  // Overrides for multi-fork
-
-  encodeValue(value: BeaconStateAllForks): Uint8Array {
-    return value.serialize();
-  }
-
-  decodeValue(data: Uint8Array): BeaconStateAllForks {
-    return getStateTypeFromBytes(this.config, data).deserializeToViewDU(data);
+    super(config, db, bucket, getBucketNameByValue(bucket));
   }
 
   // Handle key as slot
 
-  async put(key: Slot, value: BeaconStateAllForks): Promise<void> {
-    await Promise.all([super.put(key, value), storeRootIndex(this.db, key, value.hashTreeRoot())]);
-  }
-
-  getId(state: BeaconStateAllForks): Epoch {
-    return state.slot;
+  async put(key: Slot, value: BeaconStateArchive): Promise<void> {
+    await Promise.all([super.putBinary(key, value.serialize()), storeRootIndex(this.db, key, value.hashTreeRoot())]);
   }
 
   decodeKey(data: Uint8Array): number {
@@ -42,10 +28,10 @@ export class StateArchiveRepository extends Repository<Slot, BeaconStateAllForks
 
   // Index Root -> Slot
 
-  async getByRoot(stateRoot: Root): Promise<BeaconStateAllForks | null> {
+  async getBinaryByRoot(stateRoot: Root): Promise<Uint8Array | null> {
     const slot = await this.getSlotByRoot(stateRoot);
     if (slot !== null && Number.isInteger(slot)) {
-      return this.get(slot);
+      return this.getBinary(slot);
     }
     return null;
   }

package/src/execution/engine/mock.ts

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import {ChainConfig} from "@lodestar/config";
 import {
   BLOB_TX_TYPE,
   BYTES_PER_FIELD_ELEMENT,
@@ -7,7 +8,9 @@ import {
   ForkPostBellatrix,
   ForkPostCapella,
   ForkSeq,
+  SLOTS_PER_EPOCH,
 } from "@lodestar/params";
+import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {ExecutionPayload, RootHex, bellatrix, deneb, ssz} from "@lodestar/types";
 import {fromHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
@@ -34,14 +37,11 @@ const INTEROP_GAS_LIMIT = 30e6;
 const PRUNE_PAYLOAD_ID_AFTER_MS = 5000;
 
 export type ExecutionEngineMockOpts = {
-  genesisBlockHash: string;
+  genesisBlockHash?: string;
   eth1BlockHash?: string;
   onlyPredefinedResponses?: boolean;
-  capellaForkTimestamp?: number;
-  denebForkTimestamp?: number;
-  electraForkTimestamp?: number;
-  fuluForkTimestamp?: number;
-  gloasForkTimestamp?: number;
+  genesisTime?: number;
+  config?: ChainConfig;
 };
 
 type ExecutionBlock = {
@@ -74,17 +74,21 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
   /** Preparing payloads to be retrieved via engine_getPayloadV1 */
   private readonly preparingPayloads = new Map<number, PreparedPayload>();
   private readonly payloadsForDeletion = new Map<number, number>();
-
   private readonly predefinedPayloadStatuses = new Map<RootHex, PayloadStatus>();
 
   private payloadId = 0;
+  private capellaForkTimestamp: number;
+  private denebForkTimestamp: number;
+  private electraForkTimestamp: number;
+  private fuluForkTimestamp: number;
+  private gloasForkTimestamp: number;
 
   readonly handlers: {
     [K in keyof EngineApiRpcParamTypes]: (...args: EngineApiRpcParamTypes[K]) => EngineApiRpcReturnTypes[K];
   };
 
   constructor(private readonly opts: ExecutionEngineMockOpts) {
-    this.validBlocks.set(opts.genesisBlockHash, {
+    this.validBlocks.set(opts.genesisBlockHash ?? ZERO_HASH_HEX, {
       parentHash: ZERO_HASH_HEX,
       blockHash: ZERO_HASH_HEX,
       timestamp: 0,
@@ -100,6 +104,29 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
       blockNumber: 1,
     });
 
+    const {config} = opts;
+
+    this.capellaForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.CAPELLA_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.denebForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.DENEB_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.electraForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.ELECTRA_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.fuluForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.FULU_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.gloasForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.GLOAS_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+
     this.handlers = {
       engine_newPayloadV1: this.notifyNewPayload.bind(this),
       engine_newPayloadV2: this.notifyNewPayload.bind(this),
@@ -448,11 +475,11 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
   }
 
   private timestampToFork(timestamp: number): ForkPostBellatrix {
-    if (timestamp >= (this.opts.gloasForkTimestamp ?? Infinity)) return ForkName.gloas;
-    if (timestamp >= (this.opts.fuluForkTimestamp ?? Infinity)) return ForkName.fulu;
-    if (timestamp >= (this.opts.electraForkTimestamp ?? Infinity)) return ForkName.electra;
-    if (timestamp >= (this.opts.denebForkTimestamp ?? Infinity)) return ForkName.deneb;
-    if (timestamp >= (this.opts.capellaForkTimestamp ?? Infinity)) return ForkName.capella;
+    if (timestamp >= this.gloasForkTimestamp) return ForkName.gloas;
+    if (timestamp >= this.fuluForkTimestamp) return ForkName.fulu;
+    if (timestamp >= this.electraForkTimestamp) return ForkName.electra;
+    if (timestamp >= this.denebForkTimestamp) return ForkName.deneb;
+    if (timestamp >= this.capellaForkTimestamp) return ForkName.capella;
     return ForkName.bellatrix;
   }
 }

package/src/index.ts

@@ -2,7 +2,7 @@
 
 export type {RestApiServerMetrics, RestApiServerModules, RestApiServerOpts} from "./api/rest/base.js";
 export {RestApiServer} from "./api/rest/base.js";
-export {checkAndPersistAnchorState, initStateFromDb} from "./chain/index.js";
+export {checkAndPersistAnchorState} from "./chain/index.js";
 export {DbCPStateDatastore} from "./chain/stateCache/datastore/db.js";
 export {FileCPStateDatastore} from "./chain/stateCache/datastore/file.js";
 export {BeaconDb, type IBeaconDb} from "./db/index.js";

package/src/metrics/metrics/lodestar.ts

@@ -212,6 +212,31 @@ export function createLodestarMetrics(
       }),
     },
 
+    unfinalizedBlockWritesQueue: {
+      length: register.gauge({
+        name: "lodestar_unfinalized_block_writes_queue_length",
+        help: "Count of total unfinalized block writes queue length",
+      }),
+      droppedJobs: register.gauge({
+        name: "lodestar_unfinalized_block_writes_queue_dropped_jobs_total",
+        help: "Count of total unfinalized block writes queue dropped jobs",
+      }),
+      jobTime: register.histogram({
+        name: "lodestar_unfinalized_block_writes_queue_job_time_seconds",
+        help: "Time to process unfinalized block writes queue job in seconds",
+        buckets: [0.01, 0.1, 1, 4, 12],
+      }),
+      jobWaitTime: register.histogram({
+        name: "lodestar_unfinalized_block_writes_queue_job_wait_time_seconds",
+        help: "Time from job added to the unfinalized block writes queue to starting in seconds",
+        buckets: [0.01, 0.1, 1, 4, 12],
+      }),
+      concurrency: register.gauge({
+        name: "lodestar_unfinalized_block_writes_queue_concurrency",
+        help: "Current concurrency of unfinalized block writes queue",
+      }),
+    },
+
     engineHttpProcessorQueue: {
       length: register.gauge({
         name: "lodestar_engine_http_processor_queue_length",
@@ -1116,6 +1141,46 @@ export function createLodestarMetrics(
           help: "Total number of empty returns in SyncContributionAndProofPool.getAggregate(slot, root)",
         }),
       },
+      payloadAttestationPool: {
+        size: register.gauge({
+          name: "lodestar_oppool_payload_attestation_pool_size",
+          help: "Current size of the PayloadAttestationPool = total payload attestations unique by data and slot",
+        }),
+        payloadAttDataPerSlot: register.gauge({
+          name: "lodestar_oppool_payload_attestation_pool_payload_attestation_data_per_slot_total",
+          help: "Total number of payload attestation data per slot in PayloadAttestationPool",
+        }),
+        gossipInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_payload_attestation_pool_gossip_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding a payload attestation message from gossip to the pool",
+          labelNames: ["insertOutcome"],
+        }),
+        apiInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_payload_attestation_pool_api_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding a payload attestation message from api to the pool",
+          labelNames: ["insertOutcome"],
+        }),
+        getPayloadAttestationsCacheMisses: register.counter({
+          name: "lodestar_oppool_payload_attestation_pool_get_payload_attestations_cache_misses_total",
+          help: "Total number of getPayloadAttestationsForBlock calls with no aggregate for slot and payload attestation data root",
+        }),
+      },
+      executionPayloadBidPool: {
+        size: register.gauge({
+          name: "lodestar_oppool_execution_payload_bid_pool_size",
+          help: "Current size of the ExecutionPayloadBidPool = total number of bids",
+        }),
+        gossipInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_execution_payload_bid_pool_gossip_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding an execution payload bid from gossip to the pool",
+          labelNames: ["insertOutcome"],
+        }),
+        apiInsertOutcome: register.counter<{insertOutcome: InsertOutcome}>({
+          name: "lodestar_oppool_execution_payload_bid_pool_api_insert_outcome_total",
+          help: "Total number of InsertOutcome as a result of adding an execution payload bid from api to the pool",
+          labelNames: ["insertOutcome"],
+        }),
+      },
     },
 
     chain: {
@@ -1308,33 +1373,19 @@ export function createLodestarMetrics(
         name: "lodestar_shuffling_cache_miss_count",
         help: "Count of shuffling cache miss",
       }),
-      shufflingBuiltMultipleTimes: register.gauge({
-        name: "lodestar_shuffling_cache_recalculated_shuffling_count",
-        help: "Count of shuffling that were build multiple times",
-      }),
-      shufflingPromiseNotResolvedAndThrownAway: register.gauge({
-        name: "lodestar_shuffling_cache_promise_not_resolved_and_thrown_away_count",
-        help: "Count of shuffling cache promises that were discarded and the shuffling was built synchronously",
+      shufflingSetMultipleTimes: register.gauge({
+        name: "lodestar_shuffling_cache_set_multiple_times_count",
+        help: "Count of shuffling that were set multiple times",
       }),
       shufflingPromiseNotResolved: register.gauge({
         name: "lodestar_shuffling_cache_promise_not_resolved_count",
         help: "Count of shuffling cache promises that were requested before the promise was resolved",
       }),
-      nextShufflingNotOnEpochCache: register.gauge({
-        name: "lodestar_shuffling_cache_next_shuffling_not_on_epoch_cache",
-        help: "The next shuffling was not on the epoch cache before the epoch transition",
-      }),
       shufflingPromiseResolutionTime: register.histogram({
         name: "lodestar_shuffling_cache_promise_resolution_time_seconds",
         help: "Time from promise insertion until promise resolution when shuffling was ready in seconds",
         buckets: [0.5, 1, 1.5, 2],
       }),
-      shufflingCalculationTime: register.histogram<{source: "build" | "getSync"}>({
-        name: "lodestar_shuffling_cache_shuffling_calculation_time_seconds",
-        help: "Run time of shuffling calculation",
-        buckets: [0.5, 0.75, 1, 1.25, 1.5],
-        labelNames: ["source"],
-      }),
     },
 
     seenCache: {

package/src/network/gossip/interface.ts

@@ -15,6 +15,7 @@ import {
   capella,
   deneb,
   fulu,
+  gloas,
   phase0,
 } from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
@@ -37,6 +38,9 @@ export enum GossipType {
   light_client_finality_update = "light_client_finality_update",
   light_client_optimistic_update = "light_client_optimistic_update",
   bls_to_execution_change = "bls_to_execution_change",
+  execution_payload = "execution_payload",
+  payload_attestation_message = "payload_attestation_message",
+  execution_payload_bid = "execution_payload_bid",
 }
 
 export type SequentialGossipType = Exclude<GossipType, GossipType.beacon_attestation>;
@@ -71,6 +75,9 @@ export type GossipTopicTypeMap = {
   [GossipType.light_client_finality_update]: {type: GossipType.light_client_finality_update};
   [GossipType.light_client_optimistic_update]: {type: GossipType.light_client_optimistic_update};
   [GossipType.bls_to_execution_change]: {type: GossipType.bls_to_execution_change};
+  [GossipType.execution_payload]: {type: GossipType.execution_payload};
+  [GossipType.payload_attestation_message]: {type: GossipType.payload_attestation_message};
+  [GossipType.execution_payload_bid]: {type: GossipType.execution_payload_bid};
 };
 
 export type GossipTopicMap = {
@@ -100,6 +107,9 @@ export type GossipTypeMap = {
   [GossipType.light_client_finality_update]: LightClientFinalityUpdate;
   [GossipType.light_client_optimistic_update]: LightClientOptimisticUpdate;
   [GossipType.bls_to_execution_change]: capella.SignedBLSToExecutionChange;
+  [GossipType.execution_payload]: gloas.SignedExecutionPayloadEnvelope;
+  [GossipType.payload_attestation_message]: gloas.PayloadAttestationMessage;
+  [GossipType.execution_payload_bid]: gloas.SignedExecutionPayloadBid;
 };
 
 export type GossipFnByType = {
@@ -124,6 +134,13 @@ export type GossipFnByType = {
   [GossipType.bls_to_execution_change]: (
     blsToExecutionChange: capella.SignedBLSToExecutionChange
   ) => Promise<void> | void;
+  [GossipType.execution_payload]: (
+    executionPayloadEnvelope: gloas.SignedExecutionPayloadEnvelope
+  ) => Promise<void> | void;
+  [GossipType.payload_attestation_message]: (
+    payloadAttestationMessage: gloas.PayloadAttestationMessage
+  ) => Promise<void> | void;
+  [GossipType.execution_payload_bid]: (executionPayloadBid: gloas.SignedExecutionPayloadBid) => Promise<void> | void;
 };
 
 export type GossipFn = GossipFnByType[keyof GossipFnByType];

package/src/network/gossip/scoringParameters.ts

@@ -5,7 +5,7 @@ import {
   defaultTopicScoreParams,
 } from "@chainsafe/libp2p-gossipsub/score";
 import {BeaconConfig} from "@lodestar/config";
-import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, TARGET_AGGREGATORS_PER_COMMITTEE} from "@lodestar/params";
+import {ATTESTATION_SUBNET_COUNT, PTC_SIZE, SLOTS_PER_EPOCH, TARGET_AGGREGATORS_PER_COMMITTEE} from "@lodestar/params";
 import {computeCommitteeCount} from "@lodestar/state-transition";
 import {getActiveForkBoundaries} from "../forks.js";
 import {Eth2Context} from "./gossipsub.js";
@@ -24,6 +24,9 @@ const VOLUNTARY_EXIT_WEIGHT = 0.05;
 const PROPOSER_SLASHING_WEIGHT = 0.05;
 const ATTESTER_SLASHING_WEIGHT = 0.05;
 const BLS_TO_EXECUTION_CHANGE_WEIGHT = 0.05;
+const EXECUTION_PAYLOAD_WEIGHT = 0.5;
+const PAYLOAD_ATTESTATION_WEIGHT = 0.05;
+const EXECUTION_PAYLOAD_BID_WEIGHT = 0.05;
 
 const beaconAttestationSubnetWeight = 1 / ATTESTATION_SUBNET_COUNT;
 const maxPositiveScore =
@@ -34,7 +37,10 @@ const maxPositiveScore =
     VOLUNTARY_EXIT_WEIGHT +
     PROPOSER_SLASHING_WEIGHT +
     ATTESTER_SLASHING_WEIGHT +
-    BLS_TO_EXECUTION_CHANGE_WEIGHT);
+    BLS_TO_EXECUTION_CHANGE_WEIGHT +
+    EXECUTION_PAYLOAD_WEIGHT +
+    PAYLOAD_ATTESTATION_WEIGHT +
+    EXECUTION_PAYLOAD_BID_WEIGHT);
 
 /**
  * The following params is implemented by Lighthouse at
@@ -172,6 +178,26 @@ function getAllTopicsScoreParams(
       expectedMessageRate: 1 / 5 / SLOTS_PER_EPOCH,
       firstMessageDecayTime: epochDurationMs * 100,
     });
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.payload_attestation_message,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: PAYLOAD_ATTESTATION_WEIGHT,
+      expectedMessageRate: PTC_SIZE,
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.execution_payload_bid,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: EXECUTION_PAYLOAD_BID_WEIGHT,
+      expectedMessageRate: 1024, // TODO GLOAS: Need an estimate for this
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
 
     // other topics
     topicsParams[
@@ -190,6 +216,22 @@ function getAllTopicsScoreParams(
         currentSlot: eth2Context.currentSlot,
       },
     });
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.execution_payload,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: EXECUTION_PAYLOAD_WEIGHT,
+      expectedMessageRate: 1,
+      firstMessageDecayTime: epochDurationMs * 20,
+      meshMessageInfo: {
+        decaySlots: SLOTS_PER_EPOCH * 5,
+        capFactor: 3,
+        activationWindow: epochDurationMs,
+        currentSlot: eth2Context.currentSlot,
+      },
+    });
 
     const activeValidatorCount = eth2Context.activeValidatorCount;
     const {aggregatorsPerslot, committeesPerSlot} = expectedAggregatorCountPerSlot(activeValidatorCount);