@lodestar/beacon-node 1.40.0-dev.63c5c3e7f7 → 1.40.0-dev.9defa5c09b

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -0,0 +1,122 @@
+import {PublicKey} from "@chainsafe/blst";
+import {
+  CachedBeaconStateGloas,
+  computeStartSlotAtEpoch,
+  createSingleSignatureSetFromComponents,
+  getExecutionPayloadEnvelopeSigningRoot,
+} from "@lodestar/state-transition";
+import {gloas} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {ExecutionPayloadEnvelopeError, ExecutionPayloadEnvelopeErrorCode, GossipAction} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+
+export async function validateApiExecutionPayloadEnvelope(
+  chain: IBeaconChain,
+  executionPayloadEnvelope: gloas.SignedExecutionPayloadEnvelope
+): Promise<void> {
+  return validateExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
+}
+
+export async function validateGossipExecutionPayloadEnvelope(
+  chain: IBeaconChain,
+  executionPayloadEnvelope: gloas.SignedExecutionPayloadEnvelope
+): Promise<void> {
+  return validateExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
+}
+
+async function validateExecutionPayloadEnvelope(
+  chain: IBeaconChain,
+  executionPayloadEnvelope: gloas.SignedExecutionPayloadEnvelope
+): Promise<void> {
+  const envelope = executionPayloadEnvelope.message;
+  const {payload} = envelope;
+  const blockRootHex = toRootHex(envelope.beaconBlockRoot);
+
+  // [IGNORE] The envelope's block root `envelope.block_root` has been seen (via
+  // gossip or non-gossip sources) (a client MAY queue payload for processing once
+  // the block is retrieved).
+  // TODO GLOAS: Need to review this
+  const block = chain.forkChoice.getBlock(envelope.beaconBlockRoot);
+  if (block === null) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+      code: ExecutionPayloadEnvelopeErrorCode.BLOCK_ROOT_UNKNOWN,
+      blockRoot: blockRootHex,
+    });
+  }
+
+  // [IGNORE] The node has not seen another valid
+  // `SignedExecutionPayloadEnvelope` for this block root from this builder.
+  if (chain.seenExecutionPayloadEnvelopes.isKnown(blockRootHex)) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+      code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN,
+      blockRoot: blockRootHex,
+      slot: envelope.slot,
+    });
+  }
+
+  // [IGNORE] The envelope is from a slot greater than or equal to the latest finalized slot -- i.e. validate that `envelope.slot >= compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)`
+  const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
+  const finalizedSlot = computeStartSlotAtEpoch(finalizedCheckpoint.epoch);
+  if (envelope.slot < finalizedSlot) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+      code: ExecutionPayloadEnvelopeErrorCode.BELONG_TO_FINALIZED_BLOCK,
+      envelopeSlot: envelope.slot,
+      finalizedSlot,
+    });
+  }
+
+  // [REJECT] `block` passes validation.
+  // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
+  // it is possible that the block didn't pass the validation
+
+  // [REJECT] `block.slot` equals `envelope.slot`.
+  if (block.slot !== envelope.slot) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+      code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH,
+      envelopeSlot: envelope.slot,
+      blockSlot: block.slot,
+    });
+  }
+
+  if (block.builderIndex === undefined || block.blockHashHex === undefined) {
+    // This indicates this block is a pre-gloas block which is wrong
+    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+      code: ExecutionPayloadEnvelopeErrorCode.CACHE_FAIL,
+      blockRoot: blockRootHex,
+    });
+  }
+
+  // [REJECT] `envelope.builder_index == bid.builder_index`
+  if (envelope.builderIndex !== block.builderIndex) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+      code: ExecutionPayloadEnvelopeErrorCode.BUILDER_INDEX_MISMATCH,
+      envelopeBuilderIndex: envelope.builderIndex,
+      bidBuilderIndex: block.builderIndex,
+    });
+  }
+
+  // [REJECT] `payload.block_hash == bid.block_hash`
+  if (toRootHex(payload.blockHash) !== block.blockHashHex) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+      code: ExecutionPayloadEnvelopeErrorCode.BLOCK_HASH_MISMATCH,
+      envelopeBlockHash: toRootHex(payload.blockHash),
+      bidBlockHash: block.blockHashHex,
+    });
+  }
+
+  // [REJECT] `signed_execution_payload_envelope.signature` is valid with respect to the builder's public key.
+  const state = chain.getHeadState() as CachedBeaconStateGloas;
+  const signatureSet = createSingleSignatureSetFromComponents(
+    PublicKey.fromBytes(state.builders.getReadonly(envelope.builderIndex).pubkey),
+    getExecutionPayloadEnvelopeSigningRoot(chain.config, envelope),
+    executionPayloadEnvelope.signature
+  );
+
+  if (!(await chain.bls.verifySignatureSets([signatureSet]))) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.REJECT, {
+      code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE,
+    });
+  }
+
+  chain.seenExecutionPayloadEnvelopes.add(blockRootHex, envelope.slot);
+}

package/src/chain/validation/payloadAttestationMessage.ts

@@ -0,0 +1,109 @@
+import {
+  CachedBeaconStateGloas,
+  computeEpochAtSlot,
+  createSingleSignatureSetFromComponents,
+  getPayloadAttestationDataSigningRoot,
+} from "@lodestar/state-transition";
+import {RootHex, gloas, ssz} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {GossipAction, PayloadAttestationError, PayloadAttestationErrorCode} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+
+export type PayloadAttestationValidationResult = {
+  attDataRootHex: RootHex;
+  validatorCommitteeIndex: number;
+};
+
+export async function validateApiPayloadAttestationMessage(
+  chain: IBeaconChain,
+  payloadAttestationMessage: gloas.PayloadAttestationMessage
+): Promise<PayloadAttestationValidationResult> {
+  return validatePayloadAttestationMessage(chain, payloadAttestationMessage);
+}
+
+export async function validateGossipPayloadAttestationMessage(
+  chain: IBeaconChain,
+  payloadAttestationMessage: gloas.PayloadAttestationMessage
+): Promise<PayloadAttestationValidationResult> {
+  return validatePayloadAttestationMessage(chain, payloadAttestationMessage);
+}
+
+async function validatePayloadAttestationMessage(
+  chain: IBeaconChain,
+  payloadAttestationMessage: gloas.PayloadAttestationMessage
+): Promise<PayloadAttestationValidationResult> {
+  const {data, validatorIndex} = payloadAttestationMessage;
+  const epoch = computeEpochAtSlot(data.slot);
+
+  // [IGNORE] The message's slot is for the current slot (with a `MAXIMUM_GOSSIP_CLOCK_DISPARITY` allowance), i.e. `data.slot == current_slot`.
+  if (!chain.clock.isCurrentSlotGivenGossipDisparity(data.slot)) {
+    throw new PayloadAttestationError(GossipAction.IGNORE, {
+      code: PayloadAttestationErrorCode.NOT_CURRENT_SLOT,
+      currentSlot: chain.clock.currentSlot,
+      slot: data.slot,
+    });
+  }
+
+  // [IGNORE] The `payload_attestation_message` is the first valid message received
+  // from the validator with index `payload_attestation_message.validator_index`.
+  // A single validator can participate PTC at most once per epoch
+  if (chain.seenPayloadAttesters.isKnown(epoch, validatorIndex)) {
+    throw new PayloadAttestationError(GossipAction.IGNORE, {
+      code: PayloadAttestationErrorCode.PAYLOAD_ATTESTATION_ALREADY_KNOWN,
+      validatorIndex,
+      slot: data.slot,
+      blockRoot: toRootHex(data.beaconBlockRoot),
+    });
+  }
+
+  // [IGNORE] The message's block `data.beacon_block_root` has been seen (via
+  // gossip or non-gossip sources) (a client MAY queue attestation for processing
+  // once the block is retrieved. Note a client might want to request payload after).
+  const block = chain.forkChoice.getBlock(data.beaconBlockRoot);
+  if (block === null) {
+    throw new PayloadAttestationError(GossipAction.IGNORE, {
+      code: PayloadAttestationErrorCode.UNKNOWN_BLOCK_ROOT,
+      blockRoot: toRootHex(data.beaconBlockRoot),
+    });
+  }
+
+  const state = chain.getHeadState() as CachedBeaconStateGloas;
+
+  // [REJECT] The message's block `data.beacon_block_root` passes validation.
+  // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
+  // it is possible that the block didn't pass the validation
+
+  // [REJECT] The message's validator index is within the payload committee in
+  // `get_ptc(state, data.slot)`. The `state` is the head state corresponding to
+  // processing the block up to the current slot as determined by the fork choice.
+  const ptc = state.epochCtx.getPayloadTimelinessCommittee(data.slot);
+  const validatorCommitteeIndex = ptc.indexOf(validatorIndex);
+
+  if (validatorCommitteeIndex === -1) {
+    throw new PayloadAttestationError(GossipAction.REJECT, {
+      code: PayloadAttestationErrorCode.INVALID_ATTESTER,
+      attesterIndex: validatorIndex,
+    });
+  }
+
+  // [REJECT] `payload_attestation_message.signature` is valid with respect to the validator's public key.
+  const signatureSet = createSingleSignatureSetFromComponents(
+    chain.index2pubkey[validatorIndex],
+    getPayloadAttestationDataSigningRoot(state, data),
+    payloadAttestationMessage.signature
+  );
+
+  if (!(await chain.bls.verifySignatureSets([signatureSet]))) {
+    throw new PayloadAttestationError(GossipAction.REJECT, {
+      code: PayloadAttestationErrorCode.INVALID_SIGNATURE,
+    });
+  }
+
+  // Valid
+  chain.seenPayloadAttesters.add(epoch, validatorIndex);
+
+  return {
+    attDataRootHex: toRootHex(ssz.gloas.PayloadAttestationData.hashTreeRoot(data)),
+    validatorCommitteeIndex,
+  };
+}

package/src/db/repositories/checkpointState.ts

@@ -9,7 +9,7 @@ import {Bucket, getBucketNameByValue} from "../buckets.js";
 export class CheckpointStateRepository extends BinaryRepository<Uint8Array> {
   constructor(config: ChainForkConfig, db: Db) {
     const bucket = Bucket.allForks_checkpointState;
-    // biome-ignore lint/suspicious/noExplicitAny: The type is complex to specify a proper override
+
     super(config, db, bucket, getBucketNameByValue(bucket));
   }
 }

package/src/metrics/metrics/lodestar.ts

@@ -1141,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: {

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);

package/src/network/gossip/topic.ts

@@ -69,6 +69,9 @@ function stringifyGossipTopicType(topic: GossipTopic): string {
     case GossipType.light_client_finality_update:
     case GossipType.light_client_optimistic_update:
     case GossipType.bls_to_execution_change:
+    case GossipType.execution_payload:
+    case GossipType.payload_attestation_message:
+    case GossipType.execution_payload_bid:
       return topic.type;
     case GossipType.beacon_attestation:
     case GossipType.sync_committee:
@@ -114,6 +117,12 @@ export function getGossipSSZType(topic: GossipTopic) {
         : ssz.altair.LightClientFinalityUpdate;
     case GossipType.bls_to_execution_change:
       return ssz.capella.SignedBLSToExecutionChange;
+    case GossipType.execution_payload:
+      return ssz.gloas.SignedExecutionPayloadEnvelope;
+    case GossipType.payload_attestation_message:
+      return ssz.gloas.PayloadAttestationMessage;
+    case GossipType.execution_payload_bid:
+      return ssz.gloas.SignedExecutionPayloadBid;
   }
 }
 
@@ -190,6 +199,9 @@ export function parseGossipTopic(forkDigestContext: ForkDigestContext, topicStr:
       case GossipType.light_client_finality_update:
       case GossipType.light_client_optimistic_update:
       case GossipType.bls_to_execution_change:
+      case GossipType.execution_payload:
+      case GossipType.payload_attestation_message:
+      case GossipType.execution_payload_bid:
         return {type: gossipTypeStr, boundary, encoding};
     }
 
@@ -240,6 +252,12 @@ export function getCoreTopicsAtFork(
     {type: GossipType.attester_slashing},
   ];
 
+  if (ForkSeq[fork] >= ForkSeq.gloas) {
+    topics.push({type: GossipType.execution_payload});
+    topics.push({type: GossipType.payload_attestation_message});
+    topics.push({type: GossipType.execution_payload_bid});
+  }
+
   // After fulu also track data_column_sidecar_{index}
   if (ForkSeq[fork] >= ForkSeq.fulu) {
     topics.push(...getDataColumnSidecarTopics(networkConfig));
@@ -329,4 +347,7 @@ export const gossipTopicIgnoreDuplicatePublishError: Record<GossipType, boolean>
   [GossipType.light_client_finality_update]: false,
   [GossipType.light_client_optimistic_update]: false,
   [GossipType.bls_to_execution_change]: true,
+  [GossipType.execution_payload]: true,
+  [GossipType.payload_attestation_message]: true,
+  [GossipType.execution_payload_bid]: true,
 };

package/src/network/processor/gossipHandlers.ts

@@ -48,6 +48,8 @@ import {
 import {IBeaconChain} from "../../chain/interface.js";
 import {validateGossipBlobSidecar} from "../../chain/validation/blobSidecar.js";
 import {validateGossipDataColumnSidecar} from "../../chain/validation/dataColumnSidecar.js";
+import {validateGossipExecutionPayloadBid} from "../../chain/validation/executionPayloadBid.js";
+import {validateGossipExecutionPayloadEnvelope} from "../../chain/validation/executionPayloadEnvelope.js";
 import {
   AggregateAndProofValidationResult,
   GossipAttestation,
@@ -64,6 +66,7 @@ import {
 } from "../../chain/validation/index.js";
 import {validateLightClientFinalityUpdate} from "../../chain/validation/lightClientFinalityUpdate.js";
 import {validateLightClientOptimisticUpdate} from "../../chain/validation/lightClientOptimisticUpdate.js";
+import {validateGossipPayloadAttestationMessage} from "../../chain/validation/payloadAttestationMessage.js";
 import {OpSource} from "../../chain/validatorMonitor.js";
 import {Metrics} from "../../metrics/index.js";
 import {kzgCommitmentToVersionedHash} from "../../util/blobs.js";
@@ -815,6 +818,51 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
 
       chain.emitter.emit(routes.events.EventType.blsToExecutionChange, blsToExecutionChange);
     },
+    [GossipType.execution_payload]: async ({
+      gossipData,
+      topic,
+    }: GossipHandlerParamGeneric<GossipType.execution_payload>) => {
+      const {serializedData} = gossipData;
+      const executionPayloadEnvelope = sszDeserialize(topic, serializedData);
+      await validateGossipExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
+
+      // TODO GLOAS: Handle valid envelope. Need an import flow that calls `processExecutionPayloadEnvelope` and fork choice
+    },
+    [GossipType.payload_attestation_message]: async ({
+      gossipData,
+      topic,
+    }: GossipHandlerParamGeneric<GossipType.payload_attestation_message>) => {
+      const {serializedData} = gossipData;
+      const payloadAttestationMessage = sszDeserialize(topic, serializedData);
+      const validationResult = await validateGossipPayloadAttestationMessage(chain, payloadAttestationMessage);
+
+      try {
+        const insertOutcome = chain.payloadAttestationPool.add(
+          payloadAttestationMessage,
+          validationResult.attDataRootHex,
+          validationResult.validatorCommitteeIndex
+        );
+        metrics?.opPool.payloadAttestationPool.gossipInsertOutcome.inc({insertOutcome});
+      } catch (e) {
+        logger.error("Error adding to payloadAttestation pool", {}, e as Error);
+      }
+    },
+    [GossipType.execution_payload_bid]: async ({
+      gossipData,
+      topic,
+    }: GossipHandlerParamGeneric<GossipType.execution_payload_bid>) => {
+      const {serializedData} = gossipData;
+      const executionPayloadBid = sszDeserialize(topic, serializedData);
+      await validateGossipExecutionPayloadBid(chain, executionPayloadBid);
+
+      // Handle valid payload bid by storing in a bid pool
+      try {
+        const insertOutcome = chain.executionPayloadBidPool.add(executionPayloadBid.message);
+        metrics?.opPool.executionPayloadBidPool.gossipInsertOutcome.inc({insertOutcome});
+      } catch (e) {
+        logger.error("Error adding to executionPayloadBid pool", {}, e as Error);
+      }
+    },
   };
 }
 

package/src/network/processor/gossipQueues/index.ts

@@ -67,6 +67,22 @@ const linearGossipQueueOpts: {
     type: QueueType.FIFO,
     dropOpts: {type: DropType.count, count: 1},
   },
+  [GossipType.execution_payload]: {
+    maxLength: 1024,
+    type: QueueType.FIFO,
+    dropOpts: {type: DropType.count, count: 1},
+  },
+  [GossipType.payload_attestation_message]: {
+    maxLength: 1024,
+    type: QueueType.FIFO,
+    dropOpts: {type: DropType.count, count: 1},
+  },
+  // TODO GLOAS: It is hard to predict how many bids are there. Put 1024 for max length for now
+  [GossipType.execution_payload_bid]: {
+    maxLength: 1024,
+    type: QueueType.FIFO,
+    dropOpts: {type: DropType.count, count: 1},
+  },
 };
 
 const indexedGossipQueueOpts: {

package/src/network/processor/index.ts

@@ -78,6 +78,9 @@ const executeGossipWorkOrderObj: Record<GossipType, WorkOpts> = {
   [GossipType.sync_committee]: {},
   [GossipType.light_client_finality_update]: {},
   [GossipType.light_client_optimistic_update]: {},
+  [GossipType.execution_payload]: {bypassQueue: true},
+  [GossipType.payload_attestation_message]: {},
+  [GossipType.execution_payload_bid]: {},
 };
 const executeGossipWorkOrder = Object.keys(executeGossipWorkOrderObj) as (keyof typeof executeGossipWorkOrderObj)[];