@lodestar/beacon-node 1.43.0-dev.2fba242f5d → 1.43.0-dev.35940ffd61

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -1,7 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {CheckpointWithHex, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, Slot} from "@lodestar/types";
+import {RootHex} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
@@ -16,6 +16,7 @@ export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 export type SeenPayloadEnvelopeInputModules = {
   config: ChainForkConfig;
   clock: IClock;
+  forkChoice: IForkChoice;
   chainEvents: ChainEventEmitter;
   signal: AbortSignal;
   serializedCache: SerializedCache;
@@ -39,6 +40,7 @@ export type SeenPayloadEnvelopeInputModules = {
 export class SeenPayloadEnvelopeInput {
   private readonly config: ChainForkConfig;
   private readonly clock: IClock;
+  private readonly forkChoice: IForkChoice;
   private readonly chainEvents: ChainEventEmitter;
   private readonly signal: AbortSignal;
   private readonly serializedCache: SerializedCache;
@@ -46,9 +48,19 @@ export class SeenPayloadEnvelopeInput {
   private readonly logger?: Logger;
   private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
 
-  constructor({config, clock, chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+  constructor({
+    config,
+    clock,
+    forkChoice,
+    chainEvents,
+    signal,
+    serializedCache,
+    metrics,
+    logger,
+  }: SeenPayloadEnvelopeInputModules) {
     this.config = config;
     this.clock = clock;
+    this.forkChoice = forkChoice;
     this.chainEvents = chainEvents;
     this.signal = signal;
     this.serializedCache = serializedCache;
@@ -67,14 +79,27 @@ export class SeenPayloadEnvelopeInput {
       });
     }
 
-    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.pruneFinalized);
     this.signal.addEventListener("abort", () => {
-      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.onFinalized);
+      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.pruneFinalized);
     });
   }
 
-  private onFinalized = (checkpoint: CheckpointWithHex): void => {
-    this.pruneBelow(computeStartSlotAtEpoch(checkpoint.epoch));
+  private pruneFinalized = (checkpoint: CheckpointWithHex): void => {
+    const finalizedSlot = computeStartSlotAtEpoch(checkpoint.epoch);
+    let deletedCount = 0;
+    for (const [, input] of this.payloadInputs) {
+      if (input.slot < finalizedSlot) {
+        this.evictPayloadInput(input);
+        deletedCount++;
+      }
+    }
+
+    this.logger?.debug("SeenPayloadEnvelopeInput.pruneFinalized deleted entries", {
+      finalizedSlot,
+      finalizedRoot: checkpoint.rootHex,
+      deletedCount,
+    });
   };
 
   add(props: Omit<CreateFromBlockProps, "daOutOfRange">): PayloadEnvelopeInput {
@@ -110,15 +135,19 @@ export class SeenPayloadEnvelopeInput {
     return this.payloadInputs.size;
   }
 
-  pruneBelow(slot: Slot): void {
-    let deletedCount = 0;
-    for (const [, input] of this.payloadInputs) {
-      if (input.slot < slot) {
-        this.evictPayloadInput(input);
-        deletedCount++;
+  pruneBelowParent(parentBlock: ProtoBlock): void {
+    for (const block of this.forkChoice.getAllAncestorBlocks(parentBlock.blockRoot, parentBlock.payloadStatus)) {
+      if (block.slot < parentBlock.slot) {
+        const input = this.payloadInputs.get(block.blockRoot);
+        if (input) {
+          this.evictPayloadInput(input);
+          this.logger?.verbose("SeenPayloadEnvelopeInput.pruneBelowParent deleted", {
+            slot: block.slot,
+            root: block.blockRoot,
+          });
+        }
       }
     }
-    this.logger?.debug("SeenPayloadEnvelopeInput.pruneBelow deleted entries", {slot, deletedCount});
   }
 
   private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {

package/src/chain/seenCache/seenProposerPreferences.ts

@@ -1,28 +1,31 @@
-import {Slot, ValidatorIndex} from "@lodestar/types";
+import {RootHex, Slot, ValidatorIndex} from "@lodestar/types";
 import {MapDef} from "@lodestar/utils";
 
 /**
- * Tracks signed proposer preferences we've already seen per (proposal_slot, validator_index).
+ * Tracks signed proposer preferences we've already seen per (dependent_root, proposal_slot, validator_index).
  */
 export class SeenProposerPreferences {
-  private readonly validatorIndexesBySlot = new MapDef<Slot, Set<ValidatorIndex>>(() => new Set<ValidatorIndex>());
+  private readonly validatorByDependentRootBySlot = new MapDef<Slot, Map<RootHex, ValidatorIndex>>(
+    () => new Map<RootHex, ValidatorIndex>()
+  );
 
-  isKnown(proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
-    return this.validatorIndexesBySlot.get(proposalSlot)?.has(validatorIndex) === true;
+  isKnown(dependentRoot: RootHex, proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
+    return this.validatorByDependentRootBySlot.get(proposalSlot)?.get(dependentRoot) === validatorIndex;
   }
 
-  add(proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
-    this.validatorIndexesBySlot.getOrDefault(proposalSlot).add(validatorIndex);
+  add(dependentRoot: RootHex, proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
+    this.validatorByDependentRootBySlot.getOrDefault(proposalSlot).set(dependentRoot, 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.
+   * 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.validatorIndexesBySlot.keys()) {
+    for (const slot of this.validatorByDependentRootBySlot.keys()) {
       if (slot < currentSlot) {
-        this.validatorIndexesBySlot.delete(slot);
+        this.validatorByDependentRootBySlot.delete(slot);
       }
     }
   }

package/src/chain/validation/executionPayloadBid.ts

@@ -48,9 +48,12 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] the `SignedProposerPreferences` where `preferences.proposal_slot`
-  // is equal to `bid.slot` has been seen.
-  // TODO GLOAS: Implement this along with proposer preference
+  // [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.
 
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
@@ -71,11 +74,11 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [REJECT] `bid.fee_recipient` matches the `fee_recipient` from the proposer's
-  // `SignedProposerPreferences` associated with `bid.slot`.
-  // [REJECT] `bid.gas_limit` matches the `gas_limit` from the proposer's
-  // `SignedProposerPreferences` associated with `bid.slot`.
-  // TODO GLOAS: Implement this along with proposer preference
+  // [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.
 
   // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in the
   // consensus layer -- i.e. validate that

package/src/chain/validation/proposerPreferences.ts

@@ -3,12 +3,11 @@ import {
   computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
   getProposerPreferencesSigningRoot,
-  isStatePostGloas,
 } from "@lodestar/state-transition";
-import {gloas} from "@lodestar/types";
+import {ValidatorIndex, gloas} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
 import {GossipAction, ProposerPreferencesError, ProposerPreferencesErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
-import {RegenCaller} from "../regen/index.js";
 
 /**
  * Validates a gossiped `SignedProposerPreferences` per
@@ -19,7 +18,8 @@ export async function validateGossipProposerPreferences(
   signedProposerPreferences: gloas.SignedProposerPreferences
 ): Promise<void> {
   const preferences = signedProposerPreferences.message;
-  const {proposalSlot, validatorIndex} = preferences;
+  const {proposalSlot, validatorIndex, dependentRoot} = preferences;
+  const dependentRootHex = toRootHex(dependentRoot);
   const proposalEpoch = computeEpochAtSlot(proposalSlot);
 
   // [IGNORE] `preferences.proposal_slot` is in the current or next epoch.
@@ -42,32 +42,51 @@ export async function validateGossipProposerPreferences(
     });
   }
 
-  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipProposerPreferences);
-  if (!isStatePostGloas(state)) {
-    throw new Error(`Expected gloas+ state for proposer preferences validation, got fork=${state.forkName}`);
+  // [IGNORE] The block with root `dependent_root` has been seen by the node.
+  // Resolve the proposer lookahead for the message's branch via head state (fast path) or
+  // the previous-root checkpoint state (populated by `processSlotsToNearestCheckpoint` for
+  // any imported branch crossing into `proposalEpoch - 1`). The head-state path also handles
+  // narrow timing windows where the checkpoint state isn't yet populated.
+  const headState = chain.getHeadState();
+  let proposers: ValidatorIndex[] | null = null;
+  if (headState.epoch === proposalEpoch && headState.currentDecisionRoot === dependentRootHex) {
+    proposers = headState.currentProposers;
+  } else if (headState.epoch === proposalEpoch - 1 && headState.nextDecisionRoot === dependentRootHex) {
+    proposers = headState.nextProposers;
+  } else {
+    // Sync lookup only to not trigger disk reload from gossip input.
+    const checkpointState = chain.regen.getCheckpointStateSync({epoch: proposalEpoch - 1, rootHex: dependentRootHex});
+    if (checkpointState !== null) {
+      // State is at `proposalEpoch - 1`, so proposers for `proposalSlot` (next epoch from
+      // the state's perspective) live in `nextProposers`.
+      proposers = checkpointState.nextProposers;
+    }
+  }
+  if (proposers === null) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.UNKNOWN_DEPENDENT_ROOT,
+      proposalSlot,
+      dependentRoot: dependentRootHex,
+    });
   }
 
-  // [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) {
+  // [REJECT] `is_valid_proposal_slot(state, preferences)` returns True.
+  if (proposers[proposalSlot % SLOTS_PER_EPOCH] !== validatorIndex) {
     throw new ProposerPreferencesError(GossipAction.REJECT, {
       code: ProposerPreferencesErrorCode.INVALID_PROPOSER,
       proposalSlot,
       validatorIndex,
+      dependentRoot: dependentRootHex,
     });
   }
 
-  // [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)) {
+  // [IGNORE] First valid message for (dependent_root, proposal_slot, validator_index).
+  if (chain.seenProposerPreferences.isKnown(dependentRootHex, proposalSlot, validatorIndex)) {
     throw new ProposerPreferencesError(GossipAction.IGNORE, {
       code: ProposerPreferencesErrorCode.ALREADY_KNOWN,
       proposalSlot,
       validatorIndex,
+      dependentRoot: dependentRootHex,
     });
   }
 
@@ -87,5 +106,5 @@ export async function validateGossipProposerPreferences(
   }
 
   // Valid
-  chain.seenProposerPreferences.add(proposalSlot, validatorIndex);
+  chain.seenProposerPreferences.add(dependentRootHex, proposalSlot, validatorIndex);
 }

package/src/sync/range/batch.ts

@@ -202,6 +202,7 @@ export class Batch {
     const envelopesBySlot = this.state.payloadEnvelopes ?? new Map<Slot, PayloadEnvelopeInput>();
 
     // ensure blocks are in slot-wise order
+    const isPostGloas = isForkPostGloas(this.forkName);
     for (const blockInput of blocks) {
       const blockSlot = blockInput.slot;
       // check if block/data is present (hasBlock/hasAllData). If present then check if startSlot is the same as
@@ -217,21 +218,36 @@ export class Batch {
       if (blockInput.hasBlock() && blockStartSlot === blockSlot) {
         blockStartSlot = blockSlot + 1;
       }
-      if (
-        blockInput.hasBlock() &&
-        envelopeStartSlot === blockSlot &&
-        envelopesBySlot.get(blockSlot)?.hasPayloadEnvelope()
-      ) {
-        envelopeStartSlot = blockSlot + 1;
-      }
-      if (!blockInput.hasAllData()) {
-        if (isBlockInputColumns(blockInput)) {
-          for (const index of blockInput.getMissingSampledColumnMeta().missing) {
+
+      // Range sync uses hasComputedAllData (all sampled columns physically present), not hasAllData
+      // which flips at the reconstruction threshold. Sync never triggers reconstruction, so accepting
+      // a half-downloaded block here makes writeBlockInputToDb later block on waitForComputedAllData.
+      if (isPostGloas) {
+        // Post-Gloas: column data lives on PayloadEnvelopeInput, not on BlockInputNoData.
+        const payloadInput = envelopesBySlot.get(blockSlot);
+        if (blockInput.hasBlock() && envelopeStartSlot === blockSlot && payloadInput?.hasPayloadEnvelope()) {
+          envelopeStartSlot = blockSlot + 1;
+        }
+        if (payloadInput && !payloadInput.hasComputedAllData()) {
+          for (const index of payloadInput.getMissingSampledColumnMeta().missing) {
             neededColumns.add(index);
           }
+        } else if (payloadInput?.hasComputedAllData() && dataStartSlot === blockSlot) {
+          // Only advance dataStartSlot when we know columns for this slot are complete. If
+          // payloadInput is missing entirely we cannot tell, so stop here so the next round
+          // re-requests columns (and envelopes) starting at this slot.
+          dataStartSlot = blockSlot + 1;
+        }
+      } else {
+        if (isBlockInputColumns(blockInput) ? !blockInput.hasComputedAllData() : !blockInput.hasAllData()) {
+          if (isBlockInputColumns(blockInput)) {
+            for (const index of blockInput.getMissingSampledColumnMeta().missing) {
+              neededColumns.add(index);
+            }
+          }
+        } else if (dataStartSlot === blockSlot) {
+          dataStartSlot = blockSlot + 1;
         }
-      } else if (dataStartSlot === blockSlot) {
-        dataStartSlot = blockSlot + 1;
       }
     }
 
@@ -251,11 +267,15 @@ export class Batch {
       // range of 40 - 63, startSlot will be inclusive but subtraction will exclusive so need to + 1
       const count = endSlot - dataStartSlot + 1;
       if (isForkPostFulu(this.forkName) && withinValidRequestWindow) {
-        requests.columnsRequest = {
-          count,
-          startSlot: dataStartSlot,
-          columns: Array.from(neededColumns),
-        };
+        // Skip the column re-request when we have no specific column indices outstanding.
+        // Peer rejects an empty `columns` list
+        if (neededColumns.size > 0) {
+          requests.columnsRequest = {
+            count,
+            startSlot: dataStartSlot,
+            columns: Array.from(neededColumns),
+          };
+        }
       } else if (isForkPostDeneb(this.forkName) && withinValidRequestWindow) {
         requests.blobsRequest = {
           count,
@@ -379,7 +399,11 @@ export class Batch {
     const slots = new Set<number>();
     for (const block of blocks) {
       slots.add(block.slot);
-      if (!block.hasBlockAndAllData()) {
+      const dataComplete = isBlockInputColumns(block)
+        ? // by_range needs to download all columns
+          block.hasBlock() && block.hasComputedAllData()
+        : block.hasBlockAndAllData();
+      if (!dataComplete) {
         allComplete = false;
       }
     }
@@ -395,11 +419,22 @@ export class Batch {
     }
     const newPayloadEnvelopes = payloadEnvelopes ?? this.state.payloadEnvelopes;
 
+    if (allComplete && isForkPostGloas(this.forkName)) {
+      for (const block of blocks) {
+        const payloadInput = newPayloadEnvelopes?.get(block.slot);
+        // by_range needs to download all columns
+        if (!payloadInput?.hasPayloadEnvelope() || !payloadInput.hasComputedAllData()) {
+          allComplete = false;
+          break;
+        }
+      }
+    }
+
     if (allComplete) {
       this.state = {status: BatchStatus.AwaitingProcessing, blocks, payloadEnvelopes: newPayloadEnvelopes};
     } else {
-      this.requests = this.getRequests(blocks);
       this.state = {status: BatchStatus.AwaitingDownload, blocks, payloadEnvelopes: newPayloadEnvelopes};
+      this.requests = this.getRequests(blocks);
     }
 
     return this.state as DownloadSuccessState;

package/src/sync/utils/downloadByRange.ts

@@ -202,12 +202,10 @@ export function cacheByRangeResponses({
     });
   }
 
-  // Attach envelopes to entries whose envelope was returned by the peer. The returned
-  // payloadEnvelopes map only contains entries with envelopes ready for importExecutionPayload.
-  let payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null = null;
+  let payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null =
+    existingPayloadEnvelopes !== null ? new Map(existingPayloadEnvelopes) : null;
   if (downloadedPayloadEnvelopes !== null) {
-    payloadEnvelopes = new Map(existingPayloadEnvelopes ?? []);
-
+    payloadEnvelopes ??= new Map();
     for (const [slot, envelope] of downloadedPayloadEnvelopes) {
       const blockInput = updatedBatchBlocks.get(slot);
       if (!blockInput?.hasBlock() || !isForkPostGloas(blockInput.forkName)) {

package/src/util/sszBytes.ts

@@ -558,9 +558,10 @@ export function getBeaconBlockRootFromDataColumnSidecarSerialized(data: Uint8Arr
  * └─ ExecutionPayloadEnvelope (starts at byte 100):
  *    ├─ 4 bytes: payload offset
  *    ├─ 4 bytes: executionRequests offset
- *    ├─ 8 bytes: builderIndex        (offset 108-115)
- *    ├─ 32 bytes: beaconBlockRoot    (offset 116-147)
- *    └─ variable: payload data (starts at envelope + 48)
+ *    ├─ 8 bytes: builderIndex          (offset 108-115)
+ *    ├─ 32 bytes: beaconBlockRoot      (offset 116-147)
+ *    ├─ 32 bytes: parentBeaconBlockRoot (offset 148-179) — new in Gloas alpha.6 (consensus-specs#5152)
+ *    └─ variable: payload data (starts at envelope + 80)
  *       └─ ExecutionPayload fixed portion includes slotNumber at offset 532
  */
 const SIGNED_EXECUTION_PAYLOAD_ENVELOPE_MESSAGE_OFFSET = 4;
@@ -576,12 +577,13 @@ const BEACON_BLOCK_ROOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
   EXECUTION_PAYLOAD_ENVELOPE_REQUESTS_OFFSET +
   EXECUTION_PAYLOAD_ENVELOPE_BUILDER_INDEX_SIZE; // 116
 
-// Envelope fixed portion (without slot): payload_offset(4) + requests_offset(4) + builderIndex(8) + beaconBlockRoot(32) = 48
+// Envelope fixed portion: payload_offset(4) + requests_offset(4) + builderIndex(8) + beaconBlockRoot(32) + parentBeaconBlockRoot(32) = 80
 const EXECUTION_PAYLOAD_ENVELOPE_FIXED_SIZE =
   EXECUTION_PAYLOAD_ENVELOPE_PAYLOAD_OFFSET +
   EXECUTION_PAYLOAD_ENVELOPE_REQUESTS_OFFSET +
   EXECUTION_PAYLOAD_ENVELOPE_BUILDER_INDEX_SIZE +
-  ROOT_SIZE; // 48
+  ROOT_SIZE +
+  ROOT_SIZE; // 80
 
 // slotNumber offset within ExecutionPayload fixed portion:
 // parentHash(32) + feeRecipient(20) + stateRoot(32) + receiptsRoot(32) + logsBloom(256) +
@@ -595,7 +597,7 @@ const ENVELOPE_START_IN_SIGNED =
   SIGNED_EXECUTION_PAYLOAD_ENVELOPE_MESSAGE_OFFSET + SIGNED_EXECUTION_PAYLOAD_ENVELOPE_SIGNATURE_SIZE; // 100
 
 const SLOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE =
-  ENVELOPE_START_IN_SIGNED + EXECUTION_PAYLOAD_ENVELOPE_FIXED_SIZE + SLOT_NUMBER_OFFSET_IN_EXECUTION_PAYLOAD; // 100 + 48 + 532 = 680
+  ENVELOPE_START_IN_SIGNED + EXECUTION_PAYLOAD_ENVELOPE_FIXED_SIZE + SLOT_NUMBER_OFFSET_IN_EXECUTION_PAYLOAD; // 100 + 80 + 532 = 712
 
 export function getSlotFromExecutionPayloadEnvelopeSerialized(data: Uint8Array): Slot | null {
   if (data.length < SLOT_OFFSET_IN_SIGNED_EXECUTION_PAYLOAD_ENVELOPE + SLOT_SIZE) {