@lodestar/beacon-node 1.43.0 → 1.44.0-dev.055b83cb3d

package/src/chain/opPools/payloadAttestationPool.ts

@@ -57,7 +57,7 @@ export class PayloadAttestationPool {
   add(
     message: gloas.PayloadAttestationMessage,
     payloadAttDataRootHex: RootHex,
-    validatorCommitteeIndex: number
+    validatorCommitteeIndices: number[]
   ): InsertOutcome {
     const slot = message.data.slot;
     const lowestPermissibleSlot = this.lowestPermissibleSlot;
@@ -85,10 +85,10 @@ export class PayloadAttestationPool {
     const aggregate = aggregateByDataRoot.get(payloadAttDataRootHex);
     if (aggregate) {
       // Aggregate msg into aggregate
-      return aggregateMessageInto(message, validatorCommitteeIndex, aggregate);
+      return aggregateMessageInto(message, validatorCommitteeIndices, aggregate);
     }
     // Create a new aggregate with data
-    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndex));
+    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndices));
 
     return InsertOutcome.NewData;
   }
@@ -150,25 +150,49 @@ export class PayloadAttestationPool {
   }
 }
 
-function messageToAggregate(message: gloas.PayloadAttestationMessage, validatorCommitteeIndex: number): AggregateFast {
+function messageToAggregate(
+  message: gloas.PayloadAttestationMessage,
+  validatorCommitteeIndices: number[]
+): AggregateFast {
+  const aggregationBits = BitArray.fromBitLen(PTC_SIZE);
+  for (const index of validatorCommitteeIndices) {
+    aggregationBits.set(index, true);
+  }
+  const sig = signatureFromBytesNoCheck(message.signature);
+  // The validator signed once but occupies `validatorCommitteeIndices.length` PTC positions.
+  // Verification aggregates the pubkey once per set bit, so the signature must be aggregated
+  // the same number of times for the BLS check to balance — same pattern as sync committee.
+  const signature =
+    validatorCommitteeIndices.length === 1
+      ? sig
+      : aggregateSignatures(new Array(validatorCommitteeIndices.length).fill(sig));
   return {
-    aggregationBits: BitArray.fromSingleBit(PTC_SIZE, validatorCommitteeIndex),
+    aggregationBits,
     data: message.data,
-    signature: signatureFromBytesNoCheck(message.signature),
+    signature,
   };
 }
 
 function aggregateMessageInto(
   message: gloas.PayloadAttestationMessage,
-  validatorCommitteeIndex: number,
+  validatorCommitteeIndices: number[],
   aggregate: AggregateFast
 ): InsertOutcome {
-  if (aggregate.aggregationBits.get(validatorCommitteeIndex) === true) {
+  // Gossip dedup via `seenPayloadAttesters` is keyed by (epoch, validatorIndex), so the same
+  // validator's message is never processed twice — all of its bits are set together or none.
+  // Checking the first index is sufficient.
+  if (aggregate.aggregationBits.get(validatorCommitteeIndices[0]) === true) {
     return InsertOutcome.AlreadyKnown;
   }
 
-  aggregate.aggregationBits.set(validatorCommitteeIndex, true);
-  aggregate.signature = aggregateSignatures([aggregate.signature, signatureFromBytesNoCheck(message.signature)]);
+  for (const index of validatorCommitteeIndices) {
+    aggregate.aggregationBits.set(index, true);
+  }
+  const sig = signatureFromBytesNoCheck(message.signature);
+  aggregate.signature = aggregateSignatures([
+    aggregate.signature,
+    ...new Array(validatorCommitteeIndices.length).fill(sig),
+  ]);
 
   return InsertOutcome.Aggregated;
 }

package/src/chain/opPools/proposerPreferencesPool.ts

@@ -0,0 +1,59 @@
+import {RootHex, Slot, gloas} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+
+/**
+ * Pool of validated `SignedProposerPreferences` indexed by `(slot, dependent_root)`.
+ *
+ * The primary consumer is `validateExecutionPayloadBid`, which looks up the matching
+ * preferences via `get(bid.slot, dependent_root)` to enforce the IGNORE-existence and
+ * REJECT-equality rules from the gloas spec. The beacon API `/pool/proposer_preferences`
+ * GET endpoint reads from the same pool via `getAll`.
+ *
+ * `validator_index` is intentionally not part of the key: gossip validation enforces
+ * `proposers[proposalSlot % SLOTS_PER_EPOCH] === validatorIndex` against the shuffling
+ * implied by `dependent_root`, so once a preference has been validated `(slot, dependent_root)`
+ * already pins down the validator.
+ */
+export class ProposerPreferencesPool {
+  private readonly bySlot = new Map<Slot, Map<RootHex, gloas.SignedProposerPreferences>>();
+
+  /** Lookup for bid validation: matches `(bid.slot, get_proposer_dependent_root(parent_state, ...))`. */
+  get(slot: Slot, dependentRootHex: RootHex): gloas.SignedProposerPreferences | null {
+    return this.bySlot.get(slot)?.get(dependentRootHex) ?? null;
+  }
+
+  add(signed: gloas.SignedProposerPreferences): void {
+    const {proposalSlot, dependentRoot} = signed.message;
+    const rootHex = toRootHex(dependentRoot);
+    let byRoot = this.bySlot.get(proposalSlot);
+    if (!byRoot) {
+      byRoot = new Map();
+      this.bySlot.set(proposalSlot, byRoot);
+    }
+    byRoot.set(rootHex, signed);
+  }
+
+  /** API read-out: flatten across branches, optionally filtered by slot. */
+  getAll(slot?: Slot): gloas.SignedProposerPreferences[] {
+    if (slot !== undefined) {
+      const byRoot = this.bySlot.get(slot);
+      return byRoot ? Array.from(byRoot.values()) : [];
+    }
+    const out: gloas.SignedProposerPreferences[] = [];
+    for (const byRoot of this.bySlot.values()) {
+      for (const v of byRoot.values()) out.push(v);
+    }
+    return out;
+  }
+
+  /**
+   * Entries are only load-bearing while `proposal_slot >= current_slot`. Once the slot has
+   * passed the `[IGNORE] proposal_slot > current_slot` gossip rule takes over, so drop them
+   * on each slot tick.
+   */
+  prune(currentSlot: Slot): void {
+    for (const slot of this.bySlot.keys()) {
+      if (slot < currentSlot) this.bySlot.delete(slot);
+    }
+  }
+}

package/src/chain/prepareNextSlot.ts

@@ -169,7 +169,8 @@ export class PrepareNextSlotScheduler {
         // Apply parent payload once here as it's reused by EL prep and SSE emit below
         let stateAfterParentPayload: IBeaconStateViewBellatrix = updatedPrepareState;
         if (isStatePostGloas(updatedPrepareState)) {
-          if (this.chain.forkChoice.shouldExtendPayload(updatedHead.blockRoot)) {
+          // Spec: should_build_on_full(store, head) — see produceBlockBody.ts for context.
+          if (this.chain.forkChoice.shouldBuildOnFull(updatedHead)) {
             parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.blockHash;
             // Skip applying parent payload unless we're proposing the next slot or have to emit payload_attributes events
             if (feeRecipient !== undefined || this.chain.opts.emitPayloadAttributes === true) {

package/src/chain/produceBlock/produceBlockBody.ts

@@ -18,7 +18,9 @@ import {
   G2_POINT_AT_INFINITY,
   IBeaconStateView,
   type IBeaconStateViewBellatrix,
+  computeEpochAtSlot,
   computeTimeAtSlot,
+  getExpectedGasLimit,
   isStatePostBellatrix,
   isStatePostCapella,
   isStatePostGloas,
@@ -48,20 +50,16 @@ import {
   gloas,
   ssz,
 } from "@lodestar/types";
-import {Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
+import {GWEI_TO_WEI, Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
-import {
-  IExecutionBuilder,
-  IExecutionEngine,
-  PayloadAttributes,
-  PayloadId,
-  getExpectedGasLimit,
-} from "../../execution/index.js";
+import {IExecutionBuilder, IExecutionEngine, PayloadAttributes, PayloadId} from "../../execution/index.js";
+import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {fromGraffitiBytes} from "../../util/graffiti.js";
 import {kzg} from "../../util/kzg.js";
 import type {BeaconChain} from "../chain.js";
 import {CommonBlockBody} from "../interface.js";
+import {ProposerPreferencesPool} from "../opPools/index.js";
 import {validateBlobsAndKzgCommitments, validateCellsAndKzgCommitments} from "./validateBlobsAndKzgCommitments.js";
 
 // Time to provide the EL to generate a payload from new payload id
@@ -93,6 +91,8 @@ export type BlockAttributes = {
   slot: Slot;
   parentBlock: ProtoBlock;
   feeRecipient?: string;
+  /** When provided, build block with this builder bid instead of a self-build bid */
+  builderBid?: gloas.SignedExecutionPayloadBid;
 };
 
 export enum BlockType {
@@ -152,6 +152,28 @@ export type ProduceResult =
   | ProduceFullPhase0
   | ProduceBlinded;
 
+/**
+ * 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.
+ *
+ * `getStateAfterParentPayload` is a thunk so the post-apply state is only materialized when
+ * actually needed (i.e. when extending the parent payload and there are exits to filter).
+ */
+function maybeFilterInvalidatedVoluntaryExits(
+  commonBlockBody: CommonBlockBody,
+  isExtendingPayload: boolean,
+  getStateAfterParentPayload: () => IBeaconStateViewBellatrix
+): CommonBlockBody["voluntaryExits"] {
+  if (!isExtendingPayload || commonBlockBody.voluntaryExits.length === 0) {
+    return commonBlockBody.voluntaryExits;
+  }
+  const state = getStateAfterParentPayload();
+  return commonBlockBody.voluntaryExits.filter((signedVoluntaryExit) =>
+    state.isValidVoluntaryExit(signedVoluntaryExit, false)
+  );
+}
+
 export async function produceBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,
@@ -174,6 +196,7 @@ export async function produceBlockBody<T extends BlockType>(
     proposerIndex,
     proposerPubKey,
     commonBlockBodyPromise,
+    builderBid,
   } = blockAttr;
   let executionPayloadValue: Wei;
   let blockBody: AssembledBodyType<T>;
@@ -194,7 +217,43 @@ export async function produceBlockBody<T extends BlockType>(
   };
   this.logger.verbose("Producing beacon block body", logMeta);
 
-  if (isForkPostGloas(fork)) {
+  if (builderBid !== undefined) {
+    if (!isStatePostGloas(currentState)) {
+      throw new Error("Expected Gloas state for builder bid block production");
+    }
+
+    const isExtendingPayload = byteArrayEquals(
+      builderBid.message.parentBlockHash,
+      currentState.latestExecutionPayloadBid.blockHash
+    );
+    const parentExecutionRequests = isExtendingPayload
+      ? await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot)
+      : ssz.electra.ExecutionRequests.defaultValue();
+    executionPayloadValue = BigInt(builderBid.message.value) * GWEI_TO_WEI;
+
+    const commonBlockBody = await commonBlockBodyPromise;
+    const gloasBody = Object.assign({}, commonBlockBody) as gloas.BeaconBlockBody;
+    gloasBody.signedExecutionPayloadBid = builderBid;
+    gloasBody.payloadAttestations = this.payloadAttestationPool.getPayloadAttestationsForBlock(
+      parentBlock.blockRoot,
+      blockSlot - 1
+    );
+    gloasBody.parentExecutionRequests = parentExecutionRequests;
+    gloasBody.voluntaryExits = maybeFilterInvalidatedVoluntaryExits(commonBlockBody, isExtendingPayload, () =>
+      currentState.withParentPayloadApplied(parentExecutionRequests)
+    );
+    blockBody = gloasBody as AssembledBodyType<T>;
+
+    this.logger.verbose("Produced block with builder bid", {
+      slot: blockSlot,
+      builderIndex: builderBid.message.builderIndex,
+      bidValue: builderBid.message.value,
+      parentBlockHash: toRootHex(builderBid.message.parentBlockHash),
+      parentBlockRoot: toRootHex(builderBid.message.parentBlockRoot),
+      blockHash: toRootHex(builderBid.message.blockHash),
+      isExtendingPayload,
+    });
+  } else if (isForkPostGloas(fork)) {
     if (!isStatePostGloas(currentState)) {
       throw new Error("Expected Gloas state for Gloas block production");
     }
@@ -204,23 +263,23 @@ export async function produceBlockBody<T extends BlockType>(
     // this into a completely separate function and have pre/post gloas more separated
     const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
     const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+    // TODO GLOAS: post-Gloas, proposer feeRecipient is also carried (signed) in
+    // ProposerPreferencesPool. Consider using this unified cache instead
+    // see https://github.com/ChainSafe/lodestar/issues/9379
     const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
 
     const endExecutionPayload = this.metrics?.executionBlockProductionTimeSteps.startTimer();
 
-    this.logger.verbose("Preparing execution payload from engine", {
-      slot: blockSlot,
-      parentBlockRoot: toRootHex(parentBlockRoot),
-      feeRecipient,
-    });
-
     // 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));
-    if (isExtendingPayload) {
+    // Spec: should_build_on_full(store, head). `parentBlock` is the proposer's head
+    // (set by chain.getProposerHead(slot)). Returns false when the PTC majority
+    // signalled the blob data is not available, forcing a build on EMPTY (reorg).
+    const isBuildingOnFull = this.forkChoice.shouldBuildOnFull(parentBlock);
+    if (isBuildingOnFull) {
       parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
       parentExecutionRequests = await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot);
       stateAfterParentPayload = currentState.withParentPayloadApplied(parentExecutionRequests);
@@ -243,6 +302,16 @@ export async function produceBlockBody<T extends BlockType>(
     const {prepType, payloadId} = prepareRes;
     Object.assign(logMeta, {executionPayloadPrepType: prepType});
 
+    this.logger.verbose("Prepared execution payload from engine", {
+      slot: blockSlot,
+      parentBlockRoot: toRootHex(parentBlockRoot),
+      parentBlockHash: toRootHex(parentBlockHash),
+      feeRecipient,
+      prepType,
+      payloadId,
+      isBuildingOnFull,
+    });
+
     if (prepType !== PayloadPreparationType.Cached) {
       await sleep(PAYLOAD_GENERATION_TIME_MS);
     }
@@ -296,14 +365,11 @@ export async function produceBlockBody<T extends BlockType>(
       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)
-      );
-    }
+    gloasBody.voluntaryExits = maybeFilterInvalidatedVoluntaryExits(
+      commonBlockBody,
+      isBuildingOnFull,
+      () => stateAfterParentPayload
+    );
     blockBody = gloasBody as AssembledBodyType<T>;
 
     // Store execution payload data required to construct execution payload envelope later
@@ -324,6 +390,7 @@ export async function produceBlockBody<T extends BlockType>(
       fetchedTime,
       executionBlockHash: toRootHex(executionPayload.blockHash),
       blobs: blobsBundle.commitments.length,
+      gasLimit: executionPayload.gasLimit,
     });
 
     Object.assign(logMeta, {
@@ -633,6 +700,8 @@ export async function prepareExecutionPayload(
   chain: {
     executionEngine: IExecutionEngine;
     config: ChainForkConfig;
+    forkChoice: IForkChoice;
+    proposerPreferencesPool: ProposerPreferencesPool;
   },
   logger: Logger,
   fork: ForkPostBellatrix,
@@ -733,6 +802,7 @@ export function getPayloadAttributesForSSE(
   chain: {
     config: ChainForkConfig;
     forkChoice: IForkChoice;
+    proposerPreferencesPool: ProposerPreferencesPool;
   },
   {
     prepareState,
@@ -789,6 +859,8 @@ function preparePayloadAttributes(
   fork: ForkPostBellatrix,
   chain: {
     config: ChainForkConfig;
+    forkChoice: IForkChoice;
+    proposerPreferencesPool: ProposerPreferencesPool;
   },
   {
     prepareState,
@@ -851,12 +923,73 @@ function preparePayloadAttributes(
   }
 
   if (ForkSeq[fork] >= ForkSeq.gloas) {
+    if (!isStatePostGloas(prepareState)) {
+      throw new Error("Expected Gloas state for Gloas payload attributes");
+    }
     (payloadAttributes as gloas.SSEPayloadAttributes["payloadAttributes"]).slotNumber = prepareSlot;
+    (payloadAttributes as gloas.SSEPayloadAttributes["payloadAttributes"]).targetGasLimit = getProposerTargetGasLimit(
+      chain,
+      prepareSlot,
+      parentBlockRoot,
+      parentBlockHash
+    );
   }
 
   return payloadAttributes;
 }
 
+/**
+ * Resolve the proposer's preferred (target) gas limit for the Gloas `PayloadAttributesV4`
+ * `targetGasLimit` field (consensus-specs#5235, execution-apis#796).
+ *
+ * Sourced from the `SignedProposerPreferences` the proposer's VC submitted to the pool
+ * (same `(slot, dependent_root)` lookup as gossip bid validation). When no matching
+ * preferences are pooled, target the parent payload's gas limit so the gas limit stays
+ * unchanged (`is_gas_limit_target_compatible` then requires `gas_limit == parent_gas_limit`).
+ *
+ * The parent payload's gas_limit is read from fork choice — the variant matching
+ * `(parentBlockRoot, parentBlockHash)` carries the correct value for both FULL parents
+ * (FULL.executionPayloadGasLimit = delivered payload's gas_limit) and EMPTY parents
+ * (EMPTY.executionPayloadGasLimit = inherited grandparent's gas_limit).
+ */
+function getProposerTargetGasLimit(
+  chain: {forkChoice: IForkChoice; proposerPreferencesPool: ProposerPreferencesPool},
+  prepareSlot: Slot,
+  parentBlockRoot: Root,
+  parentBlockHash: Bytes32
+): number {
+  const parentBlockRootHex = toRootHex(parentBlockRoot);
+  const parentBlock = chain.forkChoice.getBlockHexDefaultStatus(parentBlockRootHex);
+  const dependentRootHex = (() => {
+    if (parentBlock === null) {
+      return null;
+    }
+    try {
+      return getShufflingDependentRoot(
+        chain.forkChoice,
+        computeEpochAtSlot(prepareSlot),
+        computeEpochAtSlot(parentBlock.slot),
+        parentBlock
+      );
+    } catch {
+      return null;
+    }
+  })();
+
+  const pref = dependentRootHex !== null ? chain.proposerPreferencesPool.get(prepareSlot, dependentRootHex) : null;
+  if (pref !== null) {
+    return pref.message.targetGasLimit;
+  }
+
+  const parentPayloadVariant = chain.forkChoice.getBlockHexAndBlockHash(parentBlockRootHex, toRootHex(parentBlockHash));
+  if (parentPayloadVariant === null || parentPayloadVariant.executionPayloadBlockHash === null) {
+    throw new Error(
+      `Cannot resolve parent payload gas_limit for proposer targetGasLimit fallback parentBlockRoot=${parentBlockRootHex} parentBlockHash=${toRootHex(parentBlockHash)}`
+    );
+  }
+  return parentPayloadVariant.executionPayloadGasLimit;
+}
+
 export async function produceCommonBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,

package/src/chain/validation/executionPayloadBid.ts

@@ -4,10 +4,12 @@ import {
   createSingleSignatureSetFromComponents,
   getExecutionPayloadBidSigningRoot,
   isActiveBuilder,
+  isGasLimitTargetCompatible,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {gloas} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {ValidatorIndex, gloas} from "@lodestar/types";
+import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
+import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {ExecutionPayloadBidError, ExecutionPayloadBidErrorCode, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
 import {RegenCaller} from "../regen/index.js";
@@ -15,21 +17,21 @@ import {RegenCaller} from "../regen/index.js";
 export async function validateApiExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
-): Promise<void> {
+): Promise<{proposerIndex: ValidatorIndex}> {
   return validateExecutionPayloadBid(chain, signedExecutionPayloadBid);
 }
 
 export async function validateGossipExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
-): Promise<void> {
+): Promise<{proposerIndex: ValidatorIndex}> {
   return validateExecutionPayloadBid(chain, signedExecutionPayloadBid);
 }
 
 async function validateExecutionPayloadBid(
   chain: IBeaconChain,
   signedExecutionPayloadBid: gloas.SignedExecutionPayloadBid
-): Promise<void> {
+): Promise<{proposerIndex: ValidatorIndex}> {
   const bid = signedExecutionPayloadBid.message;
   const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
   const parentBlockHashHex = toRootHex(bid.parentBlockHash);
@@ -48,12 +50,55 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // [IGNORE] `bid.parent_block_root` is the hash tree root of a known beacon block in fork choice.
+  // Moved earlier than the spec ordering so we can derive the proposer dependent root for the
+  // proposer-preferences lookup below from a known fork-choice block.
+  const parentBlock = chain.forkChoice.getBlockHexDefaultStatus(parentBlockRootHex);
+  if (parentBlock === null) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT,
+      parentBlockRoot: parentBlockRootHex,
+    });
+  }
+
   // [IGNORE] A `SignedProposerPreferences` matching `bid.slot` and the bid's branch has been
   // seen — i.e. `proposal_slot == bid.slot` AND `dependent_root ==
-  // get_proposer_dependent_root(parent_state, compute_epoch_at_slot(bid.slot))`,
-  // where `parent_state` is the post-state of `bid.parent_block_root`.
-  // This is the message referenced as `proposer_preferences` in the following REJECT rules.
-  // TODO GLOAS: Implement once a ProposerPreferencesPool exists.
+  // get_proposer_dependent_root(parent_state, compute_epoch_at_slot(bid.slot))`.
+  const bidEpoch = computeEpochAtSlot(bid.slot);
+  // gloas is always post-Fulu, so `get_proposer_dependent_root` is the post-Fulu (deterministic
+  // proposer lookahead) form `block_root_at(start_slot(epoch - MIN_SEED_LOOKAHEAD) - 1)` with
+  // `MIN_SEED_LOOKAHEAD == 1` — identical to the attester-shuffling dependent root for the same
+  // epoch (both 1-epoch lookahead), hence `getShufflingDependentRoot`. `null` on a
+  // unknown/finalized-pruned ancestor or genesis edge → degrade to IGNORE below instead of
+  // letting a raw `ForkChoiceError` escape the `GossipActionError` contract.
+  const dependentRootHex = (() => {
+    try {
+      return getShufflingDependentRoot(chain.forkChoice, bidEpoch, computeEpochAtSlot(parentBlock.slot), parentBlock);
+    } catch {
+      return null;
+    }
+  })();
+
+  if (dependentRootHex === null) {
+    // Could not derive the dependent root for this branch (unknown/finalized-pruned ancestor,
+    // genesis edge, etc.) → definitionally no matching `SignedProposerPreferences`.
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.NO_MATCHING_PROPOSER_PREFERENCES,
+      slot: bid.slot,
+      parentBlockRoot: parentBlockRootHex,
+      dependentRoot: "unknown",
+    });
+  }
+
+  const proposerPreferences = chain.proposerPreferencesPool.get(bid.slot, dependentRootHex);
+  if (proposerPreferences === null) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.NO_MATCHING_PROPOSER_PREFERENCES,
+      slot: bid.slot,
+      parentBlockRoot: parentBlockRootHex,
+      dependentRoot: dependentRootHex,
+    });
+  }
 
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
@@ -75,10 +120,44 @@ async function validateExecutionPayloadBid(
   }
 
   // [REJECT] `bid.fee_recipient == proposer_preferences.fee_recipient`.
-  // [REJECT] `bid.gas_limit == proposer_preferences.gas_limit`.
-  // Both compared against the matching `proposer_preferences` defined above (same branch
-  // via dependent_root, same proposal_slot).
-  // TODO GLOAS: Implement once a ProposerPreferencesPool exists.
+  if (!byteArrayEquals(bid.feeRecipient, proposerPreferences.message.feeRecipient)) {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.PROPOSER_PREFERENCES_FEE_RECIPIENT_MISMATCH,
+      builderIndex: bid.builderIndex,
+      bidFeeRecipient: toHex(bid.feeRecipient),
+      expectedFeeRecipient: toHex(proposerPreferences.message.feeRecipient),
+    });
+  }
+
+  // [IGNORE] `bid.parent_block_hash` is the block hash of a known execution payload in fork
+  // choice. Looks up the variant of `bid.parent_block_root` whose payload hash matches
+  // `bid.parent_block_hash` — works for both FULL parents (FULL variant carries the delivered
+  // payload's hash) and EMPTY parents (EMPTY/PENDING variants carry the inherited parent
+  // payload's hash, since the new block doesn't have its own payload). Variant carries the
+  // executed payload's gas_limit, which we use as `parent_gas_limit` below.
+  const parentPayloadVariant = chain.forkChoice.getBlockHexAndBlockHash(parentBlockRootHex, parentBlockHashHex);
+  if (parentPayloadVariant === null || parentPayloadVariant.executionPayloadBlockHash === null) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.UNKNOWN_PARENT_BLOCK_HASH,
+      parentBlockHash: parentBlockHashHex,
+    });
+  }
+
+  // [IGNORE] `is_gas_limit_target_compatible(parent_gas_limit, bid.gas_limit, target_gas_limit)`,
+  // where `parent_gas_limit` is the `gas_limit` of the parent execution payload and
+  // `target_gas_limit` is `proposer_preferences.target_gas_limit`.
+  const bidGasLimit = Number(bid.gasLimit);
+  const parentGasLimit = parentPayloadVariant.executionPayloadGasLimit;
+  const targetGasLimit = proposerPreferences.message.targetGasLimit;
+  if (!isGasLimitTargetCompatible(parentGasLimit, bidGasLimit, targetGasLimit)) {
+    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+      code: ExecutionPayloadBidErrorCode.PROPOSER_PREFERENCES_GAS_LIMIT_MISMATCH,
+      builderIndex: bid.builderIndex,
+      bidGasLimit,
+      parentGasLimit,
+      targetGasLimit,
+    });
+  }
 
   // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in the
   // consensus layer -- i.e. validate that
@@ -107,11 +186,11 @@ async function validateExecutionPayloadBid(
   // [IGNORE] this bid is the highest value bid seen for the tuple
   // `(bid.slot, bid.parent_block_hash, bid.parent_block_root)`.
   const bestBid = chain.executionPayloadBidPool.getBestBid(bid.slot, parentBlockHashHex, parentBlockRootHex);
-  if (bestBid !== null && bestBid.value >= bid.value) {
+  if (bestBid !== null && bestBid.message.value >= bid.value) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_LOW,
       bidValue: bid.value,
-      currentHighestBid: bestBid.value,
+      currentHighestBid: bestBid.message.value,
     });
   }
   // [IGNORE] `bid.value` is less or equal than the builder's excess balance --
@@ -124,19 +203,6 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] `bid.parent_block_hash` is the block hash of a known execution
-  // payload in fork choice.
-  // TODO GLOAS: implement this
-
-  // [IGNORE] `bid.parent_block_root` is the hash tree root of a known beacon
-  // block in fork choice.
-  if (!chain.forkChoice.hasBlock(bid.parentBlockRoot)) {
-    throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
-      code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT,
-      parentBlockRoot: parentBlockRootHex,
-    });
-  }
-
   // [REJECT] `signed_execution_payload_bid.signature` is valid with respect to the `bid.builder_index`.
   const signatureSet = createSingleSignatureSetFromComponents(
     PublicKey.fromBytes(builder.pubkey),
@@ -154,4 +220,6 @@ async function validateExecutionPayloadBid(
 
   // Valid
   chain.seenExecutionPayloadBids.add(bid.slot, bid.builderIndex);
+
+  return {proposerIndex: proposerPreferences.message.validatorIndex};
 }

package/src/chain/validation/payloadAttestationMessage.ts

@@ -11,7 +11,7 @@ import {IBeaconChain} from "../index.js";
 
 export type PayloadAttestationValidationResult = {
   attDataRootHex: RootHex;
-  validatorCommitteeIndex: number;
+  validatorCommitteeIndices: number[];
 };
 
 export async function validateApiPayloadAttestationMessage(
@@ -80,9 +80,11 @@ async function validatePayloadAttestationMessage(
   // [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 validatorCommitteeIndex = state.getIndexInPayloadTimelinessCommittee(validatorIndex, data.slot);
+  // The validator may occupy multiple PTC positions because `compute_ptc` samples
+  // by effective balance — collect all of them so duplicate votes are counted.
+  const validatorCommitteeIndices = state.getIndicesInPayloadTimelinessCommittee(validatorIndex, data.slot);
 
-  if (validatorCommitteeIndex === -1) {
+  if (validatorCommitteeIndices.length === 0) {
     throw new PayloadAttestationError(GossipAction.REJECT, {
       code: PayloadAttestationErrorCode.INVALID_ATTESTER,
       attesterIndex: validatorIndex,
@@ -115,6 +117,6 @@ async function validatePayloadAttestationMessage(
 
   return {
     attDataRootHex: toRootHex(ssz.gloas.PayloadAttestationData.hashTreeRoot(data)),
-    validatorCommitteeIndex,
+    validatorCommitteeIndices,
   };
 }