@lodestar/beacon-node 1.43.0-dev.38479366cc → 1.43.0-dev.3bcc6d0ad5

package/src/chain/produceBlock/produceBlockBody.ts

@@ -49,7 +49,7 @@ import {
   ssz,
 } from "@lodestar/types";
 import {Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
+import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
 import {
   IExecutionBuilder,
@@ -214,19 +214,19 @@ export async function produceBlockBody<T extends BlockType>(
     });
 
     // Get execution payload from EL
+    let parentBlockHash: Bytes32;
+    let parentExecutionRequests: electra.ExecutionRequests;
+    // Apply parent payload once here as it's reused by EL prep and voluntary exit filtering below
+    let stateAfterParentPayload: IBeaconStateViewBellatrix = currentState;
     const isExtendingPayload = this.forkChoice.shouldExtendPayload(toRootHex(parentBlockRoot));
-    let parentBlockHash = isExtendingPayload
-      ? currentState.latestExecutionPayloadBid.blockHash
-      : currentState.latestExecutionPayloadBid.parentBlockHash;
-    // At gloas genesis the committed bid has no prior EL block to reference
-    // (`bid.parentBlockHash` is zero). Fall back to `bid.blockHash` (= eth1 genesis hash) so the
-    // FCU to the EL carries a valid head. Post-genesis bids always reference a non-zero parent.
-    if (isStatePostGloas(currentState) && byteArrayEquals(parentBlockHash, ZERO_HASH)) {
+    if (isExtendingPayload) {
       parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
+      parentExecutionRequests = await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot);
+      stateAfterParentPayload = currentState.withParentPayloadApplied(parentExecutionRequests);
+    } else {
+      parentBlockHash = currentState.latestExecutionPayloadBid.parentBlockHash;
+      parentExecutionRequests = ssz.electra.ExecutionRequests.defaultValue();
     }
-    const parentExecutionRequests = isExtendingPayload
-      ? await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot)
-      : ssz.electra.ExecutionRequests.defaultValue();
     const prepareRes = await prepareExecutionPayload(
       this,
       this.logger,
@@ -235,9 +235,8 @@ export async function produceBlockBody<T extends BlockType>(
       parentBlockHash,
       safeBlockHash,
       finalizedBlockHash ?? ZERO_HASH_HEX,
-      currentState,
-      feeRecipient,
-      parentExecutionRequests
+      stateAfterParentPayload,
+      feeRecipient
     );
 
     const {prepType, payloadId} = prepareRes;
@@ -291,9 +290,19 @@ export async function produceBlockBody<T extends BlockType>(
     const commonBlockBody = await commonBlockBodyPromise;
     const gloasBody = Object.assign({}, commonBlockBody) as gloas.BeaconBlockBody;
     gloasBody.signedExecutionPayloadBid = signedBid;
-    // TODO GLOAS: Get payload attestations from pool for previous slot
-    gloasBody.payloadAttestations = [];
+    gloasBody.payloadAttestations = this.payloadAttestationPool.getPayloadAttestationsForBlock(
+      parentBlock.blockRoot,
+      blockSlot - 1
+    );
     gloasBody.parentExecutionRequests = parentExecutionRequests;
+    // Drop voluntary exits that parent_execution_requests have invalidated (e.g. a withdrawal
+    // request initiating an exit on the same validator). Op pool selected against the unapplied
+    // state, so re-validate against the post-apply state to avoid producing an invalid block.
+    if (isExtendingPayload && commonBlockBody.voluntaryExits.length > 0) {
+      gloasBody.voluntaryExits = commonBlockBody.voluntaryExits.filter((signedVoluntaryExit) =>
+        stateAfterParentPayload.isValidVoluntaryExit(signedVoluntaryExit, false)
+      );
+    }
     blockBody = gloasBody as AssembledBodyType<T>;
 
     // Store execution payload data required to construct execution payload envelope later
@@ -629,9 +638,12 @@ export async function prepareExecutionPayload(
   parentBlockHash: Bytes32,
   safeBlockHash: RootHex,
   finalizedBlockHash: RootHex,
+  /**
+   * Post-gloas, when extending a full parent, callers must apply
+   * parent execution payload first (see `withParentPayloadApplied`).
+   */
   state: IBeaconStateViewBellatrix,
-  suggestedFeeRecipient: string,
-  parentExecutionRequests?: electra.ExecutionRequests
+  suggestedFeeRecipient: string
 ): Promise<{prepType: PayloadPreparationType; payloadId: PayloadId}> {
   const timestamp = computeTimeAtSlot(chain.config, state.slot, state.genesisTime);
   const prevRandao = state.getRandaoMix(state.epoch);
@@ -668,7 +680,6 @@ export async function prepareExecutionPayload(
       parentBlockRoot,
       parentBlockHash,
       feeRecipient: suggestedFeeRecipient,
-      parentExecutionRequests,
     });
 
     payloadId = await chain.executionEngine.notifyForkchoiceUpdate(
@@ -727,14 +738,16 @@ export function getPayloadAttributesForSSE(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
-    parentExecutionRequests,
   }: {
+    /**
+     * Post-gloas, when extending a full parent, callers must apply
+     * parent execution payload first (see `withParentPayloadApplied`).
+     */
     prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
     feeRecipient: string;
-    parentExecutionRequests?: electra.ExecutionRequests;
   }
 ): SSEPayloadAttributes {
   const payloadAttributes = preparePayloadAttributes(fork, chain, {
@@ -743,7 +756,6 @@ export function getPayloadAttributesForSSE(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
-    parentExecutionRequests,
   });
 
   let parentBlockNumber: number;
@@ -782,14 +794,16 @@ function preparePayloadAttributes(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
-    parentExecutionRequests,
   }: {
+    /**
+     * Post-gloas, when extending a full parent, callers must apply
+     * parent execution payload first (see `withParentPayloadApplied`).
+     */
     prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
     feeRecipient: string;
-    parentExecutionRequests?: electra.ExecutionRequests;
   }
 ): SSEPayloadAttributes["payloadAttributes"] {
   const timestamp = computeTimeAtSlot(chain.config, prepareSlot, prepareState.genesisTime);
@@ -808,11 +822,13 @@ function preparePayloadAttributes(
     if (isStatePostGloas(prepareState)) {
       const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
       if (isExtendingPayload) {
-        if (parentExecutionRequests === undefined) {
-          throw new Error("parentExecutionRequests required when extending full parent");
+        // applyParentExecutionPayload sets latestBlockHash = parentBid.blockHash, so a mismatch
+        // here means the caller did not apply parent payload to prepareState
+        if (!byteArrayEquals(prepareState.latestBlockHash, prepareState.latestExecutionPayloadBid.blockHash)) {
+          throw new Error("Expected state with parent execution payload applied for withdrawals");
         }
         (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
-          prepareState.getExpectedWithdrawalsForFullParent(parentExecutionRequests);
+          prepareState.getExpectedWithdrawals().expectedWithdrawals;
       } else {
         // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
         // already deducted from CL balances but never credited on the EL (the envelope

package/src/chain/regen/interface.ts

@@ -21,6 +21,7 @@ export enum RegenCaller {
   validateGossipAttestation = "validateGossipAttestation",
   validateGossipVoluntaryExit = "validateGossipVoluntaryExit",
   validateGossipExecutionPayloadBid = "validateGossipExecutionPayloadBid",
+  validateGossipProposerPreferences = "validateGossipProposerPreferences",
   onForkChoiceFinalized = "onForkChoiceFinalized",
   restApi = "restApi",
 }

package/src/chain/seenCache/index.ts

@@ -5,3 +5,4 @@ export {SeenContributionAndProof} from "./seenCommitteeContribution.js";
 export {SeenExecutionPayloadBids} from "./seenExecutionPayloadBids.js";
 export {SeenBlockInput} from "./seenGossipBlockInput.js";
 export {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenPayloadEnvelopeInput.js";
+export {SeenProposerPreferences} from "./seenProposerPreferences.js";

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -1,9 +1,12 @@
+import {ChainForkConfig} from "@lodestar/config";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {RootHex, Slot} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
+import {IClock} from "../../util/clock.js";
 import {SerializedCache} from "../../util/serializedCache.js";
+import {isDaOutOfRange} from "../blocks/blockInput/index.js";
 import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
 
@@ -11,6 +14,8 @@ export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/ind
 export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 
 export type SeenPayloadEnvelopeInputModules = {
+  config: ChainForkConfig;
+  clock: IClock;
   chainEvents: ChainEventEmitter;
   signal: AbortSignal;
   serializedCache: SerializedCache;
@@ -32,6 +37,8 @@ export type SeenPayloadEnvelopeInputModules = {
  * ticks; subsequent ticks settle it back.
  */
 export class SeenPayloadEnvelopeInput {
+  private readonly config: ChainForkConfig;
+  private readonly clock: IClock;
   private readonly chainEvents: ChainEventEmitter;
   private readonly signal: AbortSignal;
   private readonly serializedCache: SerializedCache;
@@ -39,7 +46,9 @@ export class SeenPayloadEnvelopeInput {
   private readonly logger?: Logger;
   private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
 
-  constructor({chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+  constructor({config, clock, chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+    this.config = config;
+    this.clock = clock;
     this.chainEvents = chainEvents;
     this.signal = signal;
     this.serializedCache = serializedCache;
@@ -68,13 +77,24 @@ export class SeenPayloadEnvelopeInput {
     this.pruneBelow(computeStartSlotAtEpoch(checkpoint.epoch));
   };
 
-  add(props: CreateFromBlockProps): PayloadEnvelopeInput {
-    if (this.payloadInputs.has(props.blockRootHex)) {
-      throw new Error(`PayloadEnvelopeInput already exists for block ${props.blockRootHex}`);
+  add(props: Omit<CreateFromBlockProps, "daOutOfRange">): PayloadEnvelopeInput {
+    const existing = this.payloadInputs.get(props.blockRootHex);
+    if (existing !== undefined) {
+      this.logger?.verbose("SeenPayloadEnvelopeInput.add reused existing entry", {
+        slot: existing.slot,
+        root: props.blockRootHex,
+      });
+      return existing;
     }
-    const input = PayloadEnvelopeInput.createFromBlock(props);
+    const daOutOfRange = isDaOutOfRange(this.config, props.forkName, props.block.message.slot, this.clock.currentEpoch);
+    const input = PayloadEnvelopeInput.createFromBlock({...props, daOutOfRange});
     this.payloadInputs.set(props.blockRootHex, input);
     this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
+    this.logger?.verbose("SeenPayloadEnvelopeInput.add created new entry", {
+      slot: input.slot,
+      root: props.blockRootHex,
+      daOutOfRange,
+    });
     return input;
   }
 

package/src/chain/seenCache/seenProposerPreferences.ts

@@ -0,0 +1,29 @@
+import {Slot, ValidatorIndex} from "@lodestar/types";
+import {MapDef} from "@lodestar/utils";
+
+/**
+ * Tracks signed proposer preferences we've already seen per (proposal_slot, validator_index).
+ */
+export class SeenProposerPreferences {
+  private readonly validatorIndexesBySlot = new MapDef<Slot, Set<ValidatorIndex>>(() => new Set<ValidatorIndex>());
+
+  isKnown(proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
+    return this.validatorIndexesBySlot.get(proposalSlot)?.has(validatorIndex) === true;
+  }
+
+  add(proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
+    this.validatorIndexesBySlot.getOrDefault(proposalSlot).add(validatorIndex);
+  }
+
+  /**
+   * Entries are only load-bearing while `proposal_slot > state.slot`. Once the slot has passed the
+   * `[IGNORE] proposal_slot > state.slot` gossip rule takes over, so drop them on each slot tick.
+   */
+  prune(currentSlot: Slot): void {
+    for (const slot of this.validatorIndexesBySlot.keys()) {
+      if (slot < currentSlot) {
+        this.validatorIndexesBySlot.delete(slot);
+      }
+    }
+  }
+}

package/src/chain/validation/proposerPreferences.ts

@@ -0,0 +1,91 @@
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {
+  computeEpochAtSlot,
+  createSingleSignatureSetFromComponents,
+  getProposerPreferencesSigningRoot,
+  isStatePostGloas,
+} from "@lodestar/state-transition";
+import {gloas} from "@lodestar/types";
+import {GossipAction, ProposerPreferencesError, ProposerPreferencesErrorCode} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+import {RegenCaller} from "../regen/index.js";
+
+/**
+ * Validates a gossiped `SignedProposerPreferences` per
+ * https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/p2p-interface.md#proposer_preferences
+ */
+export async function validateGossipProposerPreferences(
+  chain: IBeaconChain,
+  signedProposerPreferences: gloas.SignedProposerPreferences
+): Promise<void> {
+  const preferences = signedProposerPreferences.message;
+  const {proposalSlot, validatorIndex} = preferences;
+  const proposalEpoch = computeEpochAtSlot(proposalSlot);
+
+  // [IGNORE] `preferences.proposal_slot` is in the current or next epoch.
+  const currentEpoch = chain.clock.currentEpoch;
+  if (proposalEpoch < currentEpoch || proposalEpoch > currentEpoch + 1) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.INVALID_EPOCH,
+      proposalSlot,
+      currentEpoch,
+    });
+  }
+
+  // [IGNORE] `preferences.proposal_slot` has not already passed.
+  const currentSlot = chain.clock.currentSlot;
+  if (proposalSlot <= currentSlot) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.PROPOSAL_SLOT_PASSED,
+      proposalSlot,
+      currentSlot,
+    });
+  }
+
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipProposerPreferences);
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for proposer preferences validation, got fork=${state.forkName}`);
+  }
+
+  // [REJECT] `preferences.validator_index` is present at the correct slot in the current or next
+  // epoch's portion of `state.proposer_lookahead` — i.e. `is_valid_proposal_slot(state, preferences)`
+  // returns True.
+  const epochOffset = proposalEpoch - state.epoch;
+  const proposers = epochOffset === 0 ? state.currentProposers : state.nextProposers;
+  const expectedProposer = proposers[proposalSlot % SLOTS_PER_EPOCH];
+  if (epochOffset < 0 || epochOffset > 1 || expectedProposer !== validatorIndex) {
+    throw new ProposerPreferencesError(GossipAction.REJECT, {
+      code: ProposerPreferencesErrorCode.INVALID_PROPOSER,
+      proposalSlot,
+      validatorIndex,
+    });
+  }
+
+  // [IGNORE] The `signed_proposer_preferences` is the first valid message received from the validator
+  // with index `preferences.validator_index` and the given slot `preferences.proposal_slot`.
+  if (chain.seenProposerPreferences.isKnown(proposalSlot, validatorIndex)) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.ALREADY_KNOWN,
+      proposalSlot,
+      validatorIndex,
+    });
+  }
+
+  // [REJECT] `signed_proposer_preferences.signature` is valid with respect to the validator's public key.
+  const signatureSet = createSingleSignatureSetFromComponents(
+    chain.pubkeyCache.getOrThrow(validatorIndex),
+    getProposerPreferencesSigningRoot(chain.config, preferences),
+    signedProposerPreferences.signature
+  );
+
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true}))) {
+    throw new ProposerPreferencesError(GossipAction.REJECT, {
+      code: ProposerPreferencesErrorCode.INVALID_SIGNATURE,
+      proposalSlot,
+      validatorIndex,
+    });
+  }
+
+  // Valid
+  chain.seenProposerPreferences.add(proposalSlot, validatorIndex);
+}

package/src/network/gossip/interface.ts

@@ -41,6 +41,7 @@ export enum GossipType {
   execution_payload = "execution_payload",
   payload_attestation_message = "payload_attestation_message",
   execution_payload_bid = "execution_payload_bid",
+  proposer_preferences = "proposer_preferences",
 }
 
 export type SequentialGossipType = Exclude<GossipType, GossipType.beacon_attestation>;
@@ -78,6 +79,7 @@ export type GossipTopicTypeMap = {
   [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};
+  [GossipType.proposer_preferences]: {type: GossipType.proposer_preferences};
 };
 
 export type GossipTopicMap = {
@@ -110,6 +112,7 @@ export type GossipTypeMap = {
   [GossipType.execution_payload]: gloas.SignedExecutionPayloadEnvelope;
   [GossipType.payload_attestation_message]: gloas.PayloadAttestationMessage;
   [GossipType.execution_payload_bid]: gloas.SignedExecutionPayloadBid;
+  [GossipType.proposer_preferences]: gloas.SignedProposerPreferences;
 };
 
 export type GossipFnByType = {
@@ -141,6 +144,9 @@ export type GossipFnByType = {
     payloadAttestationMessage: gloas.PayloadAttestationMessage
   ) => Promise<void> | void;
   [GossipType.execution_payload_bid]: (executionPayloadBid: gloas.SignedExecutionPayloadBid) => Promise<void> | void;
+  [GossipType.proposer_preferences]: (
+    signedProposerPreferences: gloas.SignedProposerPreferences
+  ) => Promise<void> | void;
 };
 
 export type GossipFn = GossipFnByType[keyof GossipFnByType];

package/src/network/gossip/scoringParameters.ts

@@ -27,6 +27,7 @@ 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 PROPOSER_PREFERENCES_WEIGHT = 0.05;
 
 const beaconAttestationSubnetWeight = 1 / ATTESTATION_SUBNET_COUNT;
 const maxPositiveScore =
@@ -40,7 +41,8 @@ const maxPositiveScore =
     BLS_TO_EXECUTION_CHANGE_WEIGHT +
     EXECUTION_PAYLOAD_WEIGHT +
     PAYLOAD_ATTESTATION_WEIGHT +
-    EXECUTION_PAYLOAD_BID_WEIGHT);
+    EXECUTION_PAYLOAD_BID_WEIGHT +
+    PROPOSER_PREFERENCES_WEIGHT);
 
 /**
  * The following params is implemented by Lighthouse at
@@ -198,6 +200,17 @@ function getAllTopicsScoreParams(
       expectedMessageRate: 1024, // TODO GLOAS: Need an estimate for this
       firstMessageDecayTime: epochDurationMs * 100,
     });
+    topicsParams[
+      stringifyGossipTopic(config, {
+        type: GossipType.proposer_preferences,
+        boundary,
+      })
+    ] = getTopicScoreParams(config, precomputedParams, {
+      topicWeight: PROPOSER_PREFERENCES_WEIGHT,
+      // Upper bound ~64 messages per epoch: one per proposer across the current + next epoch.
+      expectedMessageRate: 64 / SLOTS_PER_EPOCH,
+      firstMessageDecayTime: epochDurationMs * 100,
+    });
 
     // other topics
     topicsParams[

package/src/network/gossip/topic.ts

@@ -73,6 +73,7 @@ function stringifyGossipTopicType(topic: GossipTopic): string {
     case GossipType.execution_payload:
     case GossipType.payload_attestation_message:
     case GossipType.execution_payload_bid:
+    case GossipType.proposer_preferences:
       return topic.type;
     case GossipType.beacon_attestation:
     case GossipType.sync_committee:
@@ -124,6 +125,8 @@ export function getGossipSSZType(topic: GossipTopic) {
       return ssz.gloas.PayloadAttestationMessage;
     case GossipType.execution_payload_bid:
       return ssz.gloas.SignedExecutionPayloadBid;
+    case GossipType.proposer_preferences:
+      return ssz.gloas.SignedProposerPreferences;
   }
 }
 
@@ -203,6 +206,7 @@ export function parseGossipTopic(forkDigestContext: ForkDigestContext, topicStr:
       case GossipType.execution_payload:
       case GossipType.payload_attestation_message:
       case GossipType.execution_payload_bid:
+      case GossipType.proposer_preferences:
         return {type: gossipTypeStr, boundary, encoding};
     }
 
@@ -257,6 +261,7 @@ export function getCoreTopicsAtFork(
     topics.push({type: GossipType.execution_payload});
     topics.push({type: GossipType.payload_attestation_message});
     topics.push({type: GossipType.execution_payload_bid});
+    topics.push({type: GossipType.proposer_preferences});
   }
 
   // After fulu also track data_column_sidecar_{index}
@@ -351,4 +356,5 @@ export const gossipTopicIgnoreDuplicatePublishError: Record<GossipType, boolean>
   [GossipType.execution_payload]: true,
   [GossipType.payload_attestation_message]: true,
   [GossipType.execution_payload_bid]: true,
+  [GossipType.proposer_preferences]: true,
 };

package/src/network/interface.ts

@@ -112,6 +112,7 @@ export interface INetwork extends INetworkCorePublic {
   publishLightClientFinalityUpdate(update: LightClientFinalityUpdate): Promise<number>;
   publishLightClientOptimisticUpdate(update: LightClientOptimisticUpdate): Promise<number>;
   publishSignedExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope): Promise<number>;
+  publishPayloadAttestationMessage(payloadAttestationMessage: gloas.PayloadAttestationMessage): Promise<number>;
 
   // Debug
   dumpGossipQueue(gossipType: GossipType): Promise<PendingGossipsubMessage[]>;

package/src/network/network.ts

@@ -515,6 +515,17 @@ export class Network implements INetwork {
     );
   }
 
+  async publishPayloadAttestationMessage(payloadAttestationMessage: gloas.PayloadAttestationMessage): Promise<number> {
+    const epoch = computeEpochAtSlot(payloadAttestationMessage.data.slot);
+    const boundary = this.config.getForkBoundaryAtEpoch(epoch);
+
+    return this.publishGossip<GossipType.payload_attestation_message>(
+      {type: GossipType.payload_attestation_message, boundary},
+      payloadAttestationMessage,
+      {ignoreDuplicatePublishError: true}
+    );
+  }
+
   private async publishGossip<K extends GossipType>(
     topic: GossipTopicMap[K],
     object: GossipTypeMap[K],

package/src/network/processor/gossipHandlers.ts

@@ -52,6 +52,8 @@ import {
   ExecutionPayloadEnvelopeErrorCode,
   GossipAction,
   GossipActionError,
+  PayloadAttestationError,
+  PayloadAttestationErrorCode,
   SyncCommitteeError,
 } from "../../chain/errors/index.js";
 import {IBeaconChain} from "../../chain/interface.js";
@@ -79,6 +81,7 @@ import {
 import {validateLightClientFinalityUpdate} from "../../chain/validation/lightClientFinalityUpdate.js";
 import {validateLightClientOptimisticUpdate} from "../../chain/validation/lightClientOptimisticUpdate.js";
 import {validateGossipPayloadAttestationMessage} from "../../chain/validation/payloadAttestationMessage.js";
+import {validateGossipProposerPreferences} from "../../chain/validation/proposerPreferences.js";
 import {OpSource} from "../../chain/validatorMonitor.js";
 import {Metrics} from "../../metrics/index.js";
 import {kzgCommitmentToVersionedHash} from "../../util/blobs.js";
@@ -182,6 +185,18 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     });
     try {
       await validateGossipBlock(config, chain, signedBlock, fork);
+
+      if (isForkPostGloas(fork)) {
+        chain.seenPayloadEnvelopeInputCache.add({
+          blockRootHex,
+          block: signedBlock as SignedBeaconBlock<ForkPostGloas>,
+          forkName: fork,
+          sampledColumns: chain.custodyConfig.sampledColumns,
+          custodyColumns: chain.custodyConfig.custodyColumns,
+          timeCreatedSec: seenTimestampSec,
+        });
+      }
+
       const blockInputMeta = blockInput.getLogMeta();
 
       const recvToValidation = Date.now() / 1000 - seenTimestampSec;
@@ -1060,10 +1075,8 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       const signedEnvelope = sszDeserialize(topic, serializedData);
       const envelope = signedEnvelope.message;
 
-      // TODO GLOAS: consider optimistically create PayloadEnvelopeInput here similar to how we do that for beacon_block
-      // so that UnknownBlockSync can handle backward sync
-      // the problem now is we cannot create a PayloadEnvelopeInput without the beacon block being known, we need at least the proposer index
-      // we can achieve that by looking into the EpochCache
+      // unlike BlockInput, we send the envelope into UnknownBlockInput sync
+      // inside the sync it'll reconcile into PayloadEnvelopeInput and share the same cache with gossip
       try {
         await validateGossipExecutionPayloadEnvelope(chain, signedEnvelope);
       } catch (e) {
@@ -1071,14 +1084,6 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           const {beaconBlockRoot} = signedEnvelope.message;
           const slot = signedEnvelope.message.payload.slotNumber;
           logger.debug("Gossip envelope has error", {slot, root: toRootHex(beaconBlockRoot), code: e.type.code});
-          if (e.type.code === ExecutionPayloadEnvelopeErrorCode.BLOCK_ROOT_UNKNOWN) {
-            // TODO GLOAS: UnknownBlockSync to handle this
-            chain.emitter.emit(ChainEvent.envelopeUnknownBlock, {
-              envelope: signedEnvelope,
-              peer: peerIdStr,
-              source: BlockInputSource.gossip,
-            });
-          }
 
           if (e.action === GossipAction.REJECT) {
             chain.persistInvalidSszValue(
@@ -1173,6 +1178,14 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         data: executionPayloadBid,
       });
     },
+    [GossipType.proposer_preferences]: async ({
+      gossipData,
+      topic,
+    }: GossipHandlerParamGeneric<GossipType.proposer_preferences>) => {
+      const {serializedData} = gossipData;
+      const signedProposerPreferences = sszDeserialize(topic, serializedData);
+      await validateGossipProposerPreferences(chain, signedProposerPreferences);
+    },
   };
 }
 
@@ -1295,10 +1308,12 @@ export async function validateGossipFnRetryUnknownRoot<T>(
     try {
       return await fn();
     } catch (e) {
-      if (
-        e instanceof AttestationError &&
-        e.type.code === AttestationErrorCode.UNKNOWN_OR_PREFINALIZED_BEACON_BLOCK_ROOT
-      ) {
+      const isUnknownAttestationRoot =
+        e instanceof AttestationError && e.type.code === AttestationErrorCode.UNKNOWN_OR_PREFINALIZED_BEACON_BLOCK_ROOT;
+      const isUnknownPayloadAttestationRoot =
+        e instanceof PayloadAttestationError && e.type.code === PayloadAttestationErrorCode.UNKNOWN_BLOCK_ROOT;
+
+      if (isUnknownAttestationRoot || isUnknownPayloadAttestationRoot) {
         if (unknownBlockRootRetries === 0) {
           // Trigger unknown block root search here
           const rootHex = toRootHex(blockRoot);

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

@@ -83,6 +83,11 @@ const linearGossipQueueOpts: {
     type: QueueType.FIFO,
     dropOpts: {type: DropType.count, count: 1},
   },
+  [GossipType.proposer_preferences]: {
+    maxLength: 1024,
+    type: QueueType.FIFO,
+    dropOpts: {type: DropType.count, count: 1},
+  },
 };
 
 const indexedGossipQueueOpts: {

package/src/network/processor/index.ts

@@ -76,6 +76,7 @@ type WorkOpts = {
  */
 const executeGossipWorkOrderObj: Record<GossipType, WorkOpts> = {
   [GossipType.beacon_block]: {bypassQueue: true},
+  [GossipType.execution_payload]: {bypassQueue: true},
   [GossipType.blob_sidecar]: {bypassQueue: true},
   [GossipType.data_column_sidecar]: {bypassQueue: true},
   [GossipType.beacon_aggregate_and_proof]: {},
@@ -88,9 +89,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]: {},
+  [GossipType.proposer_preferences]: {},
 };
 const executeGossipWorkOrder = Object.keys(executeGossipWorkOrderObj) as (keyof typeof executeGossipWorkOrderObj)[];
 
@@ -443,8 +444,7 @@ export class NetworkProcessor {
         }
         case GossipType.execution_payload: {
           // extractBlockSlotRootFn does not return a root for this topic.
-          // Extract beacon_block_root directly and proactively trigger block sync if missing.
-          // Do NOT await the block — the handler runs immediately; BlockInputSync handles recovery.
+          // Extract beacon_block_root directly
           const blockRoot = getBeaconBlockRootFromExecutionPayloadEnvelopeSerialized(message.msg.data);
           if (blockRoot && !this.chain.forkChoice.hasBlockHexUnsafe(blockRoot)) {
             this.searchUnknownBlock(
@@ -452,9 +452,10 @@ export class NetworkProcessor {
               BlockInputSource.network_processor,
               message.propagationSource.toString()
             );
+            // We always want to await the block
+            // This allows us to properly forward the payload envelope
+            preprocessResult = {action: PreprocessAction.AwaitBlock, root: blockRoot};
           }
-          // do not await the block, we want UnknownBlockSync to handle it.
-          preprocessResult = {action: PreprocessAction.PushToQueue};
           break;
         }
         case GossipType.execution_payload_bid: {