@lodestar/beacon-node 1.50.0-dev.c02b971f5b → 1.50.0-dev.c24762bc60

package/src/chain/beaconProposerCache.ts

@@ -6,7 +6,7 @@ const PROPOSER_PRESERVE_EPOCHS = 2;
 export type ProposerPreparationData = routes.validator.ProposerPreparationData;
 
 export class BeaconProposerCache {
-  private readonly feeRecipientByValidatorIndex: Map<number, {epoch: Epoch; feeRecipient: string}>;
+  private readonly feeRecipientByValidatorIndex: Map<number, {epoch: Epoch; feeRecipient?: string}>;
   constructor(readonly opts: {suggestedFeeRecipient: string}) {
     this.feeRecipientByValidatorIndex = new Map();
   }
@@ -15,6 +15,24 @@ export class BeaconProposerCache {
     this.feeRecipientByValidatorIndex.set(validatorIndex, {epoch, feeRecipient});
   }
 
+  /**
+   * Track a validator that uses this node for duties, keeping the fee recipient it may have
+   * registered. Returns true if the validator was not tracked before.
+   */
+  track(epoch: Epoch, validatorIndex: number): boolean {
+    const entry = this.feeRecipientByValidatorIndex.get(validatorIndex);
+    if (entry !== undefined) {
+      entry.epoch = epoch;
+      return false;
+    }
+    this.feeRecipientByValidatorIndex.set(validatorIndex, {epoch});
+    return true;
+  }
+
+  has(validatorIndex: number): boolean {
+    return this.feeRecipientByValidatorIndex.has(validatorIndex);
+  }
+
   prune(epoch: Epoch): void {
     // This is not so optimized function, but could maintain a 2d array may be?
     for (const [validatorIndex, feeRecipientEntry] of this.feeRecipientByValidatorIndex.entries()) {

package/src/chain/blocks/importBlock.ts

@@ -22,6 +22,7 @@ import {
   RootCache,
   computeEpochAtSlot,
   computeTimeAtSlot,
+  getBeaconCommittees,
   isStatePostAltair,
   isStatePostBellatrix,
 } from "@lodestar/state-transition";
@@ -406,9 +407,8 @@ export async function importBlock(
     const proposalSlot = blockSlot + 1;
     try {
       const proposerIndex = postState.getBeaconProposer(proposalSlot);
-      const feeRecipient = this.beaconProposerCache.get(proposerIndex);
 
-      if (feeRecipient) {
+      if (this.beaconProposerCache.has(proposerIndex)) {
         // We would set this to true if
         //  1) This is a gossip block
         //  2) We are proposer of next slot
@@ -663,8 +663,12 @@ export function addAttestationPostElectra(
   } else {
     const attSlot = attestation.data.slot;
     const attEpoch = computeEpochAtSlot(attSlot);
-    const decisionRoot = state.getShufflingDecisionRoot(attEpoch);
-    const committees = this.shufflingCache.getBeaconCommittees(attEpoch, decisionRoot, attSlot, committeeIndices);
+    // calling getShufflingAtEpoch may take some time for NativeBeaconStateView
+    // we should have the shuffling inside ShufflingCache most of the time
+    const shuffling =
+      this.shufflingCache.getSync(attEpoch, state.getShufflingDecisionRoot(attEpoch)) ??
+      state.getShufflingAtEpoch(attEpoch);
+    const committees = getBeaconCommittees(shuffling, attSlot, committeeIndices);
     const aggregationBools = attestation.aggregationBits.toBoolArray();
     let offset = 0;
     for (let i = 0; i < committees.length; i++) {

package/src/chain/blocks/verifyBlock.ts

@@ -4,6 +4,7 @@ import {
   DataAvailabilityStatus,
   IBeaconStateView,
   computeEpochAtSlot,
+  getIndexedAttestation,
   signedBlockToSignedHeader,
 } from "@lodestar/state-transition";
 import {IndexedAttestation, Slot, deneb} from "@lodestar/types";
@@ -81,10 +82,6 @@ export async function verifyBlocksInEpoch(
       throw new BlockError(block0, {code: BlockErrorCode.PRESTATE_MISSING, error: e as Error});
     });
 
-  // in forky condition, make sure to populate ShufflingCache with regened state
-  // otherwise it may fail to get indexed attestations from shuffling cache later
-  this.shufflingCache.processState(preState0);
-
   if (!preState0.isStateValidatorsNodesPopulated()) {
     this.logger.verbose("verifyBlocksInEpoch preState0 SSZ cache stats", {
       slot: preState0.slot,
@@ -117,8 +114,12 @@ export async function verifyBlocksInEpoch(
     for (const [i, block] of blocks.entries()) {
       indexedAttestationsByBlock[i] = block.message.body.attestations.map((attestation) => {
         const attEpoch = computeEpochAtSlot(attestation.data.slot);
-        const decisionRoot = preState0.getShufflingDecisionRoot(attEpoch);
-        return this.shufflingCache.getIndexedAttestation(attEpoch, decisionRoot, fork, attestation);
+        // calling getShufflingAtEpoch may take some time for NativeBeaconStateView
+        // we should have the shuffling inside ShufflingCache most of the time
+        const shuffling =
+          this.shufflingCache.getSync(attEpoch, preState0.getShufflingDecisionRoot(attEpoch)) ??
+          preState0.getShufflingAtEpoch(attEpoch);
+        return getIndexedAttestation(shuffling, fork, attestation);
       });
     }
 

package/src/chain/chain.ts

@@ -128,7 +128,7 @@ import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
 import {SeenAttestationDatas} from "./seenCache/seenAttestationData.js";
 import {SeenBlockAttesters} from "./seenCache/seenBlockAttesters.js";
 import {SeenBlockInput} from "./seenCache/seenGossipBlockInput.js";
-import {ShufflingCache} from "./shufflingCache.js";
+import {ShufflingCache, ShufflingPromiseCancelReason} from "./shufflingCache.js";
 import {DbCPStateDatastore, checkpointToDatastoreKey} from "./stateCache/datastore/db.js";
 import {FileCPStateDatastore} from "./stateCache/datastore/file.js";
 import {CPStateDatastore} from "./stateCache/datastore/types.js";
@@ -620,12 +620,14 @@ export class BeaconChain implements IBeaconChain {
   async loadFromDisk(): Promise<void> {
     await this.regen.init();
     await this.opPool.fromPersisted(this.db, this.getHeadState(), this.bls, this.clock.currentSlot);
+    await this.proposerPreferencesPool.fromPersisted(this.db, this.clock.currentSlot);
   }
 
   /** Persist in-memory data to the DB. Call at least once before stopping the process */
   async persistToDisk(): Promise<void> {
     await this.archiveStore.persistToDisk();
     await this.opPool.toPersisted(this.db);
+    await this.proposerPreferencesPool.toPersisted(this.db);
   }
 
   getHeadState(): IBeaconStateView {
@@ -1629,21 +1631,48 @@ export class BeaconChain implements IBeaconChain {
     const blockEpoch = computeEpochAtSlot(attHeadBlock.slot);
 
     let state: IBeaconStateView;
-    if (blockEpoch < attEpoch - 1) {
-      // thanks to one epoch look ahead, we don't need to dial up to attEpoch
-      const targetSlot = computeStartSlotAtEpoch(attEpoch - 1);
-      this.metrics?.gossipAttestation.useHeadBlockStateDialedToTargetEpoch.inc({caller: regenCaller});
-      state = await this.regen.getBlockSlotState(attHeadBlock, targetSlot, {dontTransferCache: true}, regenCaller);
-    } else if (blockEpoch > attEpoch) {
-      // should not happen, handled inside attestation verification code
-      throw Error(`Block epoch ${blockEpoch} is after attestation epoch ${attEpoch}`);
-    } else {
-      // should use either current or next shuffling of head state
-      // it's not likely to hit this since these shufflings are cached already
-      // so handle just in case
-      this.metrics?.gossipAttestation.useHeadBlockState.inc({caller: regenCaller});
-      state = await this.regen.getState(attHeadBlock.stateRoot, regenCaller);
+    try {
+      if (blockEpoch < attEpoch - 1) {
+        // thanks to one epoch look ahead, we don't need to dial up to attEpoch
+        const targetSlot = computeStartSlotAtEpoch(attEpoch - 1);
+        this.metrics?.gossipAttestation.useHeadBlockStateDialedToTargetEpoch.inc({caller: regenCaller});
+        state = await this.regen.getBlockSlotState(attHeadBlock, targetSlot, {dontTransferCache: true}, regenCaller);
+      } else if (blockEpoch > attEpoch) {
+        // should not happen, handled inside attestation verification code
+        throw Error(`Block epoch ${blockEpoch} is after attestation epoch ${attEpoch}`);
+      } else {
+        // should use either current or next shuffling of head state
+        // it's not likely to hit this since these shufflings are cached already
+        // so handle just in case
+        this.metrics?.gossipAttestation.useHeadBlockState.inc({caller: regenCaller});
+        state = await this.regen.getState(attHeadBlock.stateRoot, regenCaller);
+      }
+    } catch (e) {
+      this.shufflingCache.cancelPromise(attEpoch, shufflingDependentRoot, ShufflingPromiseCancelReason.regenError);
+      throw e;
+    }
+
+    const stateDecisionRoot = state.getShufflingDecisionRoot(attEpoch);
+    if (stateDecisionRoot !== shufflingDependentRoot) {
+      // the promise would never be resolved by the state's shuffling
+      this.shufflingCache.cancelPromise(
+        attEpoch,
+        shufflingDependentRoot,
+        ShufflingPromiseCancelReason.decisionRootMismatch
+      );
+      this.logger.debug("Shuffling decision root mismatch on attestation regen", {
+        slot: attHeadBlock.slot,
+        root: attHeadBlock.blockRoot,
+        epoch: attEpoch,
+        shufflingDependentRoot,
+        stateDecisionRoot,
+      });
+
+      throw Error(
+        `Shuffling decision root mismatch epoch=${attEpoch} slot=${attHeadBlock.slot} root=${attHeadBlock.blockRoot} expected=${shufflingDependentRoot} actual=${stateDecisionRoot}`
+      );
     }
+
     // resolve the promise to unblock other calls of the same epoch and dependent root
     this.shufflingCache.processState(state);
     return state.getShufflingAtEpoch(attEpoch);
@@ -1907,6 +1936,21 @@ export class BeaconChain implements IBeaconChain {
     }
   }
 
+  async updateAttachedValidators(epoch: Epoch, validatorIndices: ValidatorIndex[]): Promise<void> {
+    let hasNewValidators = false;
+    for (const validatorIndex of validatorIndices) {
+      if (this.beaconProposerCache.track(epoch, validatorIndex)) {
+        hasNewValidators = true;
+      }
+    }
+
+    // Only update validator custody if we discovered new validators
+    if (hasNewValidators) {
+      const finalizedCheckpoint = this.forkChoice.getFinalizedCheckpoint();
+      await this.updateValidatorsCustodyRequirement(finalizedCheckpoint);
+    }
+  }
+
   private async updateValidatorsCustodyRequirement(finalizedCheckpoint: CheckpointWithHex): Promise<void> {
     if (this.custodyConfig.targetCustodyGroupCount === this.config.NUMBER_OF_CUSTODY_GROUPS) {
       // Custody requirements can only be increased, we can disable dynamic custody updates

package/src/chain/interface.ts

@@ -288,6 +288,8 @@ export interface IBeaconChain {
   waitForBlock(slot: Slot, root: RootHex): Promise<boolean>;
 
   updateBeaconProposerData(epoch: Epoch, proposers: ProposerPreparationData[]): Promise<void>;
+  /** Track validators that use this node for duties, e.g. by subscribing to attestation subnets */
+  updateAttachedValidators(epoch: Epoch, validatorIndices: ValidatorIndex[]): Promise<void>;
 
   persistBlock(data: BeaconBlock | BlindedBeaconBlock, suffix?: string): void;
   persistExecutionPayloadEnvelope(envelope: gloas.ExecutionPayloadEnvelope): void;

package/src/chain/opPools/opPool.ts

@@ -1,5 +1,4 @@
 import {BeaconConfig} from "@lodestar/config";
-import {DbBatch, Id, Repository} from "@lodestar/db";
 import {
   BLS_WITHDRAWAL_PREFIX,
   ForkName,
@@ -42,6 +41,7 @@ import {
   getAttesterSlashingSignatureDomains,
   getProposerSlashingSignatureDomain,
   isValidBlsToExecutionChangeForBlockInclusion,
+  persistDiff,
 } from "./utils.js";
 
 type HexRoot = string;
@@ -500,33 +500,3 @@ function isVoluntaryExitSignatureIncludable(stateFork: ForkSeq, voluntaryExitFor
 function isSlashableAtEpoch(validator: phase0.Validator, epoch: Epoch): boolean {
   return !validator.slashed && validator.activationEpoch <= epoch && epoch < validator.withdrawableEpoch;
 }
-
-/**
- * Persist target items `items` in `dbRepo` doing minimum put and delete writes.
- * Reads all keys in repository to compute the diff between current persisted data and target data.
- */
-async function persistDiff<K extends Id, V>(
-  dbRepo: Repository<K, V>,
-  items: {key: K; value: V}[],
-  serializeKey: (key: K) => number | string,
-  opts: {updateExisting?: boolean} = {}
-): Promise<void> {
-  const persistedKeys = await dbRepo.keys();
-  const batch: DbBatch<K, V> = [];
-
-  const persistedKeysSerialized = new Set(persistedKeys.map(serializeKey));
-  for (const item of items) {
-    if (opts.updateExisting || !persistedKeysSerialized.has(serializeKey(item.key))) {
-      batch.push({type: "put", key: item.key, value: item.value});
-    }
-  }
-
-  const targetKeysSerialized = new Set(items.map((item) => serializeKey(item.key)));
-  for (const persistedKey of persistedKeys) {
-    if (!targetKeysSerialized.has(serializeKey(persistedKey))) {
-      batch.push({type: "del", key: persistedKey});
-    }
-  }
-
-  if (batch.length > 0) await dbRepo.batch(batch);
-}

package/src/chain/opPools/proposerPreferencesPool.ts

@@ -1,5 +1,7 @@
 import {RootHex, Slot, ValidatorIndex, gloas} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {toHex, toRootHex} from "@lodestar/utils";
+import {IBeaconDb} from "../../db/index.js";
+import {persistDiff} from "./utils.js";
 
 /**
  * Pool of validated `SignedProposerPreferences` indexed by `(slot, dependent_root)`.
@@ -64,4 +66,21 @@ export class ProposerPreferencesPool {
       if (slot < currentSlot) this.bySlot.delete(slot);
     }
   }
+
+  /** Restore the preferences of upcoming slots, they were validated before they were persisted */
+  async fromPersisted(db: IBeaconDb, currentSlot: Slot): Promise<void> {
+    for (const signed of await db.proposerPreferences.values()) {
+      if (signed.message.proposalSlot >= currentSlot) {
+        this.add(signed);
+      }
+    }
+  }
+
+  async toPersisted(db: IBeaconDb): Promise<void> {
+    await persistDiff(
+      db.proposerPreferences,
+      this.getAll().map((signed) => ({key: db.proposerPreferences.getId(signed), value: signed})),
+      toHex
+    );
+  }
 }

package/src/chain/opPools/utils.ts

@@ -1,5 +1,6 @@
 import {Signature} from "@chainsafe/lodestar-z/blst";
 import {BeaconConfig} from "@lodestar/config";
+import {DbBatch, Id, Repository} from "@lodestar/db";
 import {BLS_WITHDRAWAL_PREFIX, DOMAIN_BEACON_ATTESTER, DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {IBeaconStateView, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {AttesterSlashing, Domain, Slot, capella, phase0} from "@lodestar/types";
@@ -91,3 +92,33 @@ export function isValidBlsToExecutionChangeForBlockInclusion(
 export function isElectraAggregate(aggregate: AggregateFast): aggregate is AggregateFastElectra {
   return (aggregate as AggregateFastElectra).committeeBits !== undefined;
 }
+
+/**
+ * Persist target items `items` in `dbRepo` doing minimum put and delete writes.
+ * Reads all keys in repository to compute the diff between current persisted data and target data.
+ */
+export async function persistDiff<K extends Id, V>(
+  dbRepo: Repository<K, V>,
+  items: {key: K; value: V}[],
+  serializeKey: (key: K) => number | string,
+  opts: {updateExisting?: boolean} = {}
+): Promise<void> {
+  const persistedKeys = await dbRepo.keys();
+  const batch: DbBatch<K, V> = [];
+
+  const persistedKeysSerialized = new Set(persistedKeys.map(serializeKey));
+  for (const item of items) {
+    if (opts.updateExisting || !persistedKeysSerialized.has(serializeKey(item.key))) {
+      batch.push({type: "put", key: item.key, value: item.value});
+    }
+  }
+
+  const targetKeysSerialized = new Set(items.map((item) => serializeKey(item.key)));
+  for (const persistedKey of persistedKeys) {
+    if (!targetKeysSerialized.has(serializeKey(persistedKey))) {
+      batch.push({type: "del", key: persistedKey});
+    }
+  }
+
+  if (batch.length > 0) await dbRepo.batch(batch);
+}

package/src/chain/prepareNextSlot.ts

@@ -22,7 +22,7 @@ import {
   isStatePostGloas,
 } from "@lodestar/state-transition";
 import {Bytes32, Slot, ValidatorIndex} from "@lodestar/types";
-import {Logger, fromHex, isErrorAborted, sleep} from "@lodestar/utils";
+import {Logger, fromHex, isErrorAborted, sleep, toHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/constants.js";
 import {BuilderStatus} from "../execution/builder/http.js";
 import {PayloadAttributes} from "../execution/index.js";
@@ -31,7 +31,11 @@ import {ClockEvent} from "../util/clock.js";
 import {isQueueErrorAborted} from "../util/queue/index.js";
 import {ForkchoiceCaller} from "./forkChoice/index.js";
 import {IBeaconChain} from "./interface.js";
-import {getPayloadAttributesForSSE, prepareExecutionPayload} from "./produceBlock/produceBlockBody.js";
+import {
+  getPayloadAttributesForSSE,
+  getPooledProposerPreferences,
+  prepareExecutionPayload,
+} from "./produceBlock/produceBlockBody.js";
 import {RegenCaller} from "./regen/index.js";
 
 // TODO GLOAS: re-evaluate this timing
@@ -158,7 +162,15 @@ export class PrepareNextSlotScheduler {
         };
 
         const proposerIndex = await getProposerIndex();
-        feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
+        if (this.chain.beaconProposerCache.has(proposerIndex)) {
+          const pooledPreferences = isForkPostGloas(fork)
+            ? getPooledProposerPreferences(this.chain, prepareSlot, headRoot)
+            : null;
+          feeRecipient =
+            pooledPreferences !== null
+              ? toHex(pooledPreferences.feeRecipient)
+              : this.chain.beaconProposerCache.getOrDefault(proposerIndex);
+        }
 
         // Predict the proposer head of the next slot when either:
         //  - we are proposing the next slot (single-slot proposer-boost-reorg), or

package/src/chain/produceBlock/produceBlockBody.ts

@@ -77,6 +77,7 @@ import {IExecutionBuilder, IExecutionEngine, PayloadAttributes, PayloadId} from
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {fromGraffitiBytes} from "../../util/graffiti.js";
 import {kzg} from "../../util/kzg.js";
+import {BeaconProposerCache} from "../beaconProposerCache.js";
 import type {BeaconChain} from "../chain.js";
 import {CommonBlockBody} from "../interface.js";
 import {ProposerPreferencesPool} from "../opPools/index.js";
@@ -286,10 +287,13 @@ 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, this.logger);
     const finalizedBlockHash = getFinalizedExecutionBlockHash(this.forkChoice);
-    // 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 {feeRecipient, feeRecipientType} = getProposerFeeRecipient(
+      requestedFeeRecipient,
+      getPooledProposerPreferences(this, blockSlot, parentBlock.blockRoot),
+      this.beaconProposerCache,
+      proposerIndex
+    );
+    Object.assign(logMeta, {feeRecipientType, feeRecipient});
 
     const endExecutionPayload = this.metrics?.executionBlockProductionTimeSteps.startTimer();
 
@@ -442,13 +446,12 @@ export async function produceBlockBody<T extends BlockType>(
 
     const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice, this.logger);
     const finalizedBlockHash = getFinalizedExecutionBlockHash(this.forkChoice);
-    const feeRecipient = requestedFeeRecipient ?? this.beaconProposerCache.getOrDefault(proposerIndex);
-    const feeRecipientType = requestedFeeRecipient
-      ? "requested"
-      : this.beaconProposerCache.get(proposerIndex)
-        ? "cached"
-        : "default";
-
+    const {feeRecipient, feeRecipientType} = getProposerFeeRecipient(
+      requestedFeeRecipient,
+      null,
+      this.beaconProposerCache,
+      proposerIndex
+    );
     Object.assign(logMeta, {feeRecipientType, feeRecipient});
 
     if (blockType === BlockType.Blinded) {
@@ -974,9 +977,8 @@ function preparePayloadAttributes(
  * 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
+ * Sourced from the `SignedProposerPreferences` the proposer's VC submitted to the pool. 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
@@ -991,26 +993,9 @@ function getProposerTargetGasLimit(
   parentBlockHash: Bytes32
 ): bigint {
   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 preferences = getPooledProposerPreferences(chain, prepareSlot, parentBlockRootHex);
+  if (preferences !== null) {
+    return preferences.targetGasLimit;
   }
 
   const parentPayloadVariant = chain.forkChoice.getBlockHexAndBlockHash(parentBlockRootHex, toRootHex(parentBlockHash));
@@ -1022,6 +1007,55 @@ function getProposerTargetGasLimit(
   return BigInt(parentPayloadVariant.executionPayloadGasLimit);
 }
 
+/** The proposer's request wins over its signed preferences, which win over its registered proposer data */
+function getProposerFeeRecipient(
+  requestedFeeRecipient: string | undefined,
+  pooledPreferences: gloas.ProposerPreferences | null,
+  beaconProposerCache: BeaconProposerCache,
+  proposerIndex: ValidatorIndex
+): {feeRecipient: string; feeRecipientType: "requested" | "preferences" | "cached" | "default"} {
+  if (requestedFeeRecipient !== undefined) {
+    return {feeRecipient: requestedFeeRecipient, feeRecipientType: "requested"};
+  }
+  if (pooledPreferences !== null) {
+    return {feeRecipient: toHex(pooledPreferences.feeRecipient), feeRecipientType: "preferences"};
+  }
+  const cachedFeeRecipient = beaconProposerCache.get(proposerIndex);
+  if (cachedFeeRecipient !== undefined) {
+    return {feeRecipient: cachedFeeRecipient, feeRecipientType: "cached"};
+  }
+  return {feeRecipient: beaconProposerCache.getOrDefault(proposerIndex), feeRecipientType: "default"};
+}
+
+/**
+ * The preferences the proposer of `slot` signed for the branch of `parentBlockRoot`, the same
+ * `(slot, dependent_root)` lookup as gossip bid validation. Null if none are pooled.
+ */
+export function getPooledProposerPreferences(
+  chain: {forkChoice: IForkChoice; proposerPreferencesPool: ProposerPreferencesPool},
+  slot: Slot,
+  parentBlockRootHex: RootHex
+): gloas.ProposerPreferences | null {
+  const parentBlock = chain.forkChoice.getBlockHexDefaultStatus(parentBlockRootHex);
+  if (parentBlock === null) {
+    return null;
+  }
+
+  let dependentRootHex: RootHex;
+  try {
+    dependentRootHex = getShufflingDependentRoot(
+      chain.forkChoice,
+      computeEpochAtSlot(slot),
+      computeEpochAtSlot(parentBlock.slot),
+      parentBlock
+    );
+  } catch {
+    return null;
+  }
+
+  return chain.proposerPreferencesPool.get(slot, dependentRootHex)?.message ?? null;
+}
+
 export async function produceCommonBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,