@lodestar/beacon-node 1.50.0-dev.b37917f96a → 1.50.0-dev.b726a05a4d

package/src/chain/chain.ts

@@ -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 {
@@ -1934,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,

package/src/db/beacon.ts

@@ -22,6 +22,7 @@ import {
   DataColumnSidecarRepository,
   ExecutionPayloadEnvelopeArchiveRepository,
   ExecutionPayloadEnvelopeRepository,
+  ProposerPreferencesRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -53,6 +54,7 @@ export class BeaconDb implements IBeaconDb {
 
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
+  proposerPreferences: ProposerPreferencesRepository;
   attesterSlashing: AttesterSlashingRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 
@@ -89,6 +91,7 @@ export class BeaconDb implements IBeaconDb {
     this.voluntaryExit = new VoluntaryExitRepository(config, db);
     this.blsToExecutionChange = new BLSToExecutionChangeRepository(config, db);
     this.proposerSlashing = new ProposerSlashingRepository(config, db);
+    this.proposerPreferences = new ProposerPreferencesRepository(config, db);
     this.attesterSlashing = new AttesterSlashingRepository(config, db);
 
     // lightclient

package/src/db/buckets.ts

@@ -73,6 +73,7 @@ export enum Bucket {
   gloas_executionPayloadEnvelope = 59, // GLOAS BeaconBlockRoot -> SignedExecutionPayloadEnvelope
   gloas_executionPayloadEnvelopeArchive = 60, // GLOAS Slot -> SignedExecutionPayloadEnvelope, or 0x00 + SignedExecutionPayloadHeaderEnvelope
   earliestAvailableSlot = 61, // singleton -> Slot
+  gloas_proposerPreferences = 62, // Slot || DependentRoot -> SignedProposerPreferences
 }
 
 export function getBucketNameByValue<T extends Bucket>(enumValue: T): keyof typeof Bucket {

package/src/db/interface.ts

@@ -17,6 +17,7 @@ import {
   DataColumnSidecarRepository,
   ExecutionPayloadEnvelopeArchiveRepository,
   ExecutionPayloadEnvelopeRepository,
+  ProposerPreferencesRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -52,6 +53,7 @@ export interface IBeaconDb {
   // op pool
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
+  proposerPreferences: ProposerPreferencesRepository;
   attesterSlashing: AttesterSlashingRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 

package/src/db/repositories/index.ts

@@ -18,6 +18,7 @@ export {BestLightClientUpdateRepository} from "./lightclientBestUpdate.js";
 export {CheckpointHeaderRepository} from "./lightclientCheckpointHeader.js";
 export {SyncCommitteeRepository} from "./lightclientSyncCommittee.js";
 export {SyncCommitteeWitnessRepository} from "./lightclientSyncCommitteeWitness.js";
+export {ProposerPreferencesRepository} from "./proposerPreferences.js";
 export {ProposerSlashingRepository} from "./proposerSlashing.js";
 export {StateArchiveRepository} from "./stateArchive.js";
 export {VoluntaryExitRepository} from "./voluntaryExit.js";

package/src/db/repositories/proposerPreferences.ts

@@ -0,0 +1,23 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {gloas, ssz} from "@lodestar/types";
+import {intToBytes} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * SignedProposerPreferences indexed by proposal slot and dependent root
+ *
+ * Added via gossip or api
+ * Removed once the proposal slot has passed
+ */
+export class ProposerPreferencesRepository extends Repository<Uint8Array, gloas.SignedProposerPreferences> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.gloas_proposerPreferences;
+    super(config, db, bucket, ssz.gloas.SignedProposerPreferences, getBucketNameByValue(bucket));
+  }
+
+  getId(value: gloas.SignedProposerPreferences): Uint8Array {
+    const {proposalSlot, dependentRoot} = value.message;
+    return Buffer.concat([intToBytes(proposalSlot, 8, "be"), dependentRoot]);
+  }
+}

package/src/execution/engine/blobVersionedHashes.ts

@@ -0,0 +1,72 @@
+import {byteArrayEquals} from "@lodestar/utils";
+import {VersionedHashes} from "./interface.js";
+
+/**
+ * Preserve Deneb's is_valid_versioned_hashes check when the REST envelope omits expected hashes.
+ * EIP-4844 encodes blob_versioned_hashes at index 10 of the signed type-3 transaction's RLP list.
+ * Skip unrelated fields without decoding or copying them, including untrusted nested access lists.
+ * The EL remains responsible for the other transaction validity checks.
+ */
+export function isValidBlobVersionedHashes(transactions: Uint8Array[], expected: VersionedHashes): boolean {
+  let index = 0;
+  for (const transaction of transactions) {
+    if (transaction.length === 0) return false;
+    if (transaction[0] !== 0x03) continue;
+
+    const outer = readRlpItem(transaction, 1, transaction.length);
+    if (!outer?.isList || outer.end !== transaction.length) return false;
+
+    let offset = outer.start;
+    for (let fieldIndex = 0; fieldIndex < 14; fieldIndex++) {
+      const field = readRlpItem(transaction, offset, outer.end);
+      if (field === null) return false;
+      if (fieldIndex === 10) {
+        if (!field.isList) return false;
+        // A canonical RLP-encoded Bytes32 is exactly the 0xa0 prefix followed by 32 bytes.
+        const count = (field.end - field.start) / 33;
+        if (!Number.isInteger(count) || index + count > expected.length) return false;
+        for (let hashOffset = field.start; hashOffset < field.end; hashOffset += 33) {
+          if (
+            transaction[hashOffset] !== 0xa0 ||
+            !byteArrayEquals(transaction.subarray(hashOffset + 1, hashOffset + 33), expected[index])
+          ) {
+            return false;
+          }
+          index++;
+        }
+      }
+      offset = field.end;
+    }
+    if (offset !== outer.end) return false;
+  }
+  return index === expected.length;
+}
+
+/** Read one RLP item's boundaries without descending into lists. */
+function readRlpItem(
+  bytes: Uint8Array,
+  offset: number,
+  limit: number
+): {start: number; end: number; isList: boolean} | null {
+  if (offset >= limit) return null;
+  const prefix = bytes[offset];
+  if (prefix < 0x80) return {start: offset, end: offset + 1, isList: false};
+
+  const isList = prefix >= 0xc0;
+  const lengthCode = prefix - (isList ? 0xc0 : 0x80);
+  let start = offset + 1;
+  let length = lengthCode;
+  if (lengthCode > 55) {
+    const lengthBytes = lengthCode - 55;
+    start += lengthBytes;
+    if (start > limit || bytes[offset + 1] === 0) return null;
+    length = 0;
+    for (let i = offset + 1; i < start; i++) {
+      length = length * 256 + bytes[i];
+    }
+    if (length <= 55) return null;
+  }
+  if (length > limit - start) return null;
+  if (!isList && length === 1 && bytes[start] < 0x80) return null;
+  return {start, end: start + length, isList};
+}