@lodestar/beacon-node 1.43.0-dev.3d6ae250a4 → 1.43.0-dev.4358217e12

package/src/chain/errors/blockError.ts

@@ -74,6 +74,8 @@ export enum BlockErrorCode {
   PARENT_EXECUTION_INVALID = "BLOCK_ERROR_PARENT_EXECUTION_INVALID",
   /** The block's parent execution payload (defined by bid.parent_block_hash) has not been seen */
   PARENT_PAYLOAD_UNKNOWN = "BLOCK_ERROR_PARENT_PAYLOAD_UNKNOWN",
+  /** An execution payload envelope in the chain segment references a block root that does not match its slot's block */
+  ENVELOPE_BLOCK_ROOT_MISMATCH = "BLOCK_ERROR_ENVELOPE_BLOCK_ROOT_MISMATCH",
 }
 
 type ExecutionErrorStatus = Exclude<
@@ -107,6 +109,7 @@ export type BlockErrorType =
   | {code: BlockErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
   | {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS}
   | {code: BlockErrorCode.NON_LINEAR_SLOTS}
+  | {code: BlockErrorCode.ENVELOPE_BLOCK_ROOT_MISMATCH; envelopeBlockRoot: RootHex; blockRoot: RootHex}
   | {code: BlockErrorCode.PER_BLOCK_PROCESSING_ERROR; error: Error}
   | {code: BlockErrorCode.BEACON_CHAIN_ERROR; error: Error}
   | {code: BlockErrorCode.KNOWN_BAD_BLOCK}
@@ -120,7 +123,7 @@ export type BlockErrorType =
   | {code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS; blobKzgCommitmentsLen: number; commitmentLimit: number}
   | {code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH; bidParentRoot: RootHex; blockParentRoot: RootHex}
   | {code: BlockErrorCode.PARENT_EXECUTION_INVALID; parentRoot: RootHex}
-  | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentBlockHash: RootHex};
+  | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentRoot: RootHex; parentBlockHash: RootHex};
 
 export class BlockGossipError extends GossipActionError<BlockErrorType> {}
 

package/src/chain/errors/index.ts

@@ -8,6 +8,7 @@ export * from "./executionPayloadBid.js";
 export * from "./executionPayloadEnvelope.js";
 export * from "./gossipValidation.js";
 export * from "./payloadAttestation.js";
+export * from "./proposerPreferences.js";
 export * from "./proposerSlashingError.js";
 export * from "./syncCommitteeError.js";
 export * from "./voluntaryExitError.js";

package/src/chain/errors/proposerPreferences.ts

@@ -0,0 +1,39 @@
+import {Slot, ValidatorIndex} from "@lodestar/types";
+import {GossipActionError} from "./gossipValidation.js";
+
+export enum ProposerPreferencesErrorCode {
+  INVALID_EPOCH = "PROPOSER_PREFERENCES_ERROR_INVALID_EPOCH",
+  PROPOSAL_SLOT_PASSED = "PROPOSER_PREFERENCES_ERROR_PROPOSAL_SLOT_PASSED",
+  INVALID_PROPOSER = "PROPOSER_PREFERENCES_ERROR_INVALID_PROPOSER",
+  ALREADY_KNOWN = "PROPOSER_PREFERENCES_ERROR_ALREADY_KNOWN",
+  INVALID_SIGNATURE = "PROPOSER_PREFERENCES_ERROR_INVALID_SIGNATURE",
+}
+
+export type ProposerPreferencesErrorType =
+  | {
+      code: ProposerPreferencesErrorCode.INVALID_EPOCH;
+      proposalSlot: Slot;
+      currentEpoch: number;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.PROPOSAL_SLOT_PASSED;
+      proposalSlot: Slot;
+      currentSlot: Slot;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.INVALID_PROPOSER;
+      proposalSlot: Slot;
+      validatorIndex: ValidatorIndex;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.ALREADY_KNOWN;
+      proposalSlot: Slot;
+      validatorIndex: ValidatorIndex;
+    }
+  | {
+      code: ProposerPreferencesErrorCode.INVALID_SIGNATURE;
+      proposalSlot: Slot;
+      validatorIndex: ValidatorIndex;
+    };
+
+export class ProposerPreferencesError extends GossipActionError<ProposerPreferencesErrorType> {}

package/src/chain/interface.ts

@@ -61,6 +61,7 @@ import {
   SeenContributionAndProof,
   SeenExecutionPayloadBids,
   SeenPayloadAttesters,
+  SeenProposerPreferences,
   SeenSyncCommitteeMessages,
 } from "./seenCache/index.js";
 import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
@@ -131,6 +132,7 @@ export interface IBeaconChain {
   readonly seenPayloadAttesters: SeenPayloadAttesters;
   readonly seenAggregatedAttestations: SeenAggregatedAttestations;
   readonly seenExecutionPayloadBids: SeenExecutionPayloadBids;
+  readonly seenProposerPreferences: SeenProposerPreferences;
   readonly seenBlockProposers: SeenBlockProposers;
   readonly seenSyncCommitteeMessages: SeenSyncCommitteeMessages;
   readonly seenContributionAndProof: SeenContributionAndProof;
@@ -250,7 +252,11 @@ export interface IBeaconChain {
   /** Process a block until complete */
   processBlock(block: IBlockInput, opts?: ImportBlockOpts): Promise<void>;
   /** Process a chain of blocks until complete */
-  processChainSegment(blocks: IBlockInput[], opts?: ImportBlockOpts): Promise<void>;
+  processChainSegment(
+    blocks: IBlockInput[],
+    payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+    opts?: ImportBlockOpts
+  ): Promise<void>;
 
   /** Process execution payload envelope: verify, import to fork choice, and persist to DB */
   processExecutionPayload(payloadInput: PayloadEnvelopeInput, opts?: ImportPayloadOpts): Promise<void>;

package/src/chain/opPools/payloadAttestationPool.ts

@@ -1,7 +1,7 @@
 import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
-import {MAX_COMMITTEES_PER_SLOT, PTC_SIZE} from "@lodestar/params";
+import {MAX_COMMITTEES_PER_SLOT, MAX_PAYLOAD_ATTESTATIONS, PTC_SIZE} from "@lodestar/params";
 import {RootHex, Slot, gloas} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
@@ -95,13 +95,9 @@ export class PayloadAttestationPool {
 
   /**
    * Get payload attestations to be included in a block.
-   * Pick the top `maxAttestation` number of attestations with the most votes
+   * Pick the top `MAX_PAYLOAD_ATTESTATIONS` aggregates with the most votes.
    */
-  getPayloadAttestationsForBlock(
-    beaconBlockRoot: BlockRootHex,
-    slot: Slot,
-    maxAttestation: number
-  ): gloas.PayloadAttestation[] {
+  getPayloadAttestationsForBlock(beaconBlockRoot: BlockRootHex, slot: Slot): gloas.PayloadAttestation[] {
     const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.get(slot);
 
     if (!aggregateByDataRootByBlockRoot) {
@@ -119,7 +115,7 @@ export class PayloadAttestationPool {
     return Array.from(aggregateByDataRoot.values())
       .slice()
       .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
-      .slice(0, maxAttestation)
+      .slice(0, MAX_PAYLOAD_ATTESTATIONS)
       .map(fastToPayloadAttestation);
   }
 

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_HEX} from "../../constants/index.js";
+import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
 import {
   IExecutionBuilder,
@@ -215,9 +215,15 @@ export async function produceBlockBody<T extends BlockType>(
 
     // Get execution payload from EL
     const isExtendingPayload = this.forkChoice.shouldExtendPayload(toRootHex(parentBlockRoot));
-    const parentBlockHash = isExtendingPayload
+    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)) {
+      parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
+    }
     const parentExecutionRequests = isExtendingPayload
       ? await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot)
       : ssz.electra.ExecutionRequests.defaultValue();
@@ -285,8 +291,10 @@ 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;
     blockBody = gloasBody as AssembledBodyType<T>;
 

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/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/block.ts

@@ -103,6 +103,7 @@ export async function validateGossipBlock(
     if (chain.forkChoice.getBlockHexAndBlockHash(parentRoot, parentBlockHashHex) === null) {
       throw new BlockGossipError(GossipAction.IGNORE, {
         code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+        parentRoot,
         parentBlockHash: parentBlockHashHex,
       });
     }

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/metrics/metrics/lodestar.ts

@@ -613,6 +613,10 @@ export function createLodestarMetrics(
         name: "lodestar_sync_unknown_block_pending_blocks_size",
         help: "Current size of UnknownBlockSync pending blocks cache",
       }),
+      pendingPayloads: register.gauge({
+        name: "lodestar_sync_unknown_block_pending_payloads_size",
+        help: "Current size of UnknownBlockSync pending payloads cache",
+      }),
       knownBadBlocks: register.gauge({
         name: "lodestar_sync_unknown_block_known_bad_blocks_size",
         help: "Current size of UnknownBlockSync known bad blocks cache",

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/processor/gossipHandlers.ts

@@ -79,6 +79,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";
@@ -198,7 +199,10 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     } catch (e) {
       if (e instanceof BlockGossipError) {
         logger.debug("Gossip block has error", {slot, root: blockShortHex, code: e.type.code});
-        if (e.type.code === BlockErrorCode.PARENT_UNKNOWN && blockInput) {
+        if (
+          (e.type.code === BlockErrorCode.PARENT_UNKNOWN || e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
+          blockInput
+        ) {
           chain.emitter.emit(ChainEvent.blockUnknownParent, {
             blockInput,
             peer: peerIdStr,
@@ -1057,10 +1061,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) {
@@ -1069,7 +1071,6 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           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,
@@ -1170,6 +1171,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);
+    },
   };
 }
 

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

@@ -91,6 +91,7 @@ const executeGossipWorkOrderObj: Record<GossipType, WorkOpts> = {
   [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)[];
 

package/src/network/reqresp/handlers/beaconBlocksByRange.ts

@@ -24,6 +24,10 @@ export async function* onBeaconBlocksByRange(
   // in the case of initializing from a non-finalized state, we don't have the finalized block so this api does not work
   // chain.forkChoice.getFinalizeBlock().slot
   const finalizedSlot = chain.forkChoice.getFinalizedCheckpointSlot();
+  // Blocks are migrated to blockArchive at finalization (including the finalized block itself),
+  // so the archive loop serves up to AND INCLUDING finalizedSlot and the headChain loop
+  // starts above it to avoid duplicate yields. See archiveBlocks.ts for the migration logic.
+  const archiveMaxSlot = finalizedSlot;
 
   const forkName = chain.config.getForkName(startSlot);
   if (isForkPostFulu(forkName) && startSlot < chain.earliestAvailableSlot) {
@@ -35,9 +39,12 @@ export async function* onBeaconBlocksByRange(
   }
 
   // Finalized range of blocks
-  if (startSlot <= finalizedSlot) {
+  if (startSlot <= archiveMaxSlot) {
     // Chain of blobs won't change
-    for await (const {key, value} of finalized.binaryEntriesStream({gte: startSlot, lt: endSlot})) {
+    for await (const {key, value} of finalized.binaryEntriesStream({
+      gte: startSlot,
+      lt: Math.min(endSlot, archiveMaxSlot + 1),
+    })) {
       yield {
         data: value,
         boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(finalized.decodeKey(key))),
@@ -46,19 +53,20 @@ export async function* onBeaconBlocksByRange(
   }
 
   // Non-finalized range of blocks
-  if (endSlot > finalizedSlot) {
+  if (endSlot > archiveMaxSlot) {
     const headBlock = chain.forkChoice.getHead();
     const headRoot = headBlock.blockRoot;
     // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
     const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
-    // getAllAncestorBlocks response includes the head node, so it's the full chain.
+    // `getAllAncestorBlocks` includes both the head and the previous-finalized boundary.
 
     // Iterate head chain with ascending block numbers
     for (let i = headChain.length - 1; i >= 0; i--) {
       const block = headChain[i];
 
-      // Must include only blocks in the range requested
-      if (block.slot >= startSlot && block.slot < endSlot) {
+      // Must include only blocks in the range requested, and skip anything the archive loop
+      // above already served via the block.slot > archiveMaxSlot filter.
+      if (block.slot > archiveMaxSlot && block.slot >= startSlot && block.slot < endSlot) {
         // Note: Here the forkChoice head may change due to a re-org, so the headChain reflects the canonical chain
         // at the time of the start of the request. Spec is clear the chain of blobs must be consistent, but on
         // re-org there's no need to abort the request

package/src/network/reqresp/handlers/blobSidecarsByRange.ts

@@ -20,31 +20,37 @@ export async function* onBlobSidecarsByRange(
   const finalized = db.blobSidecarsArchive;
   const unfinalized = db.blobSidecars;
   const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
+  // Blobs are migrated to blobSidecarsArchive at finalization (including the finalized block
+  // itself), so the archive loop serves up to AND INCLUDING finalizedSlot and the headChain
+  // loop starts above it to avoid duplicate yields. See archiveBlocks.ts for the migration logic.
+  const archiveMaxSlot = finalizedSlot;
 
   // Finalized range of blobs
-  if (startSlot <= finalizedSlot) {
+  if (startSlot <= archiveMaxSlot) {
     // Chain of blobs won't change
     for await (const {key, value: blobSideCarsBytesWrapped} of finalized.binaryEntriesStream({
       gte: startSlot,
-      lt: endSlot,
+      lt: Math.min(endSlot, archiveMaxSlot + 1),
     })) {
       yield* iterateBlobBytesFromWrapper(chain, blobSideCarsBytesWrapped, finalized.decodeKey(key));
     }
   }
 
   // Non-finalized range of blobs
-  if (endSlot > finalizedSlot) {
+  if (endSlot > archiveMaxSlot) {
     const headBlock = chain.forkChoice.getHead();
     const headRoot = headBlock.blockRoot;
     // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
     const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
+    // `getAllAncestorBlocks` includes both the head and the previous-finalized boundary.
 
     // Iterate head chain with ascending block numbers
     for (let i = headChain.length - 1; i >= 0; i--) {
       const block = headChain[i];
 
-      // Must include only blobs in the range requested
-      if (block.slot >= startSlot && block.slot < endSlot) {
+      // Must include only blobs in the range requested, and skip anything the archive loop
+      // above already served via the block.slot > archiveMaxSlot filter.
+      if (block.slot > archiveMaxSlot && block.slot >= startSlot && block.slot < endSlot) {
         // Note: Here the forkChoice head may change due to a re-org, so the headChain reflects the canonical chain
         // at the time of the start of the request. Spec is clear the chain of blobs must be consistent, but on
         // re-org there's no need to abort the request