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

package/src/chain/shufflingCache.ts

@@ -7,14 +7,12 @@ import {
   getIndexedAttestation,
 } from "@lodestar/state-transition";
 import {Attestation, CommitteeIndex, Epoch, IndexedAttestation, RootHex, Slot} from "@lodestar/types";
-import {LodestarError, Logger, MapDef, pruneSetToMax} from "@lodestar/utils";
+import {LodestarError, Logger, MapDef} from "@lodestar/utils";
 import {Metrics} from "../metrics/metrics.js";
 
 /**
- * Same value to CheckpointBalancesCache, with the assumption that we don't have to use it for old epochs. In the worse case:
- * - when loading state bytes from disk, we need to compute shuffling for all epochs (~1s as of Sep 2023)
- * - don't have shuffling to verify attestations, need to do 1 epoch transition to add shuffling to this cache. This never happens
- * with default chain option of maxSkipSlots = 32
+ * Lookahead duties, gossip validation, and block production need epochs n-1, n, and n+1 for current epoch n.
+ * Keep the 4 highest epochs so that it works for epoch rotation.
  **/
 const MAX_EPOCHS = 4;
 
@@ -37,24 +35,29 @@ type ShufflingCacheItem = {
 type PromiseCacheItem = {
   type: CacheItemType.promise;
   timeInsertedMs: number;
-  promise: Promise<EpochShuffling>;
-  resolveFn: (shuffling: EpochShuffling) => void;
+  /** Resolves to null if the promise is cancelled */
+  promise: Promise<EpochShuffling | null>;
+  resolveFn: (shuffling: EpochShuffling | null) => void;
 };
 
 type CacheItem = ShufflingCacheItem | PromiseCacheItem;
 
+export enum ShufflingPromiseCancelReason {
+  regenError = "regen_error",
+  decisionRootMismatch = "decision_root_mismatch",
+  pruned = "pruned",
+}
+
 export type ShufflingCacheOpts = {
   maxShufflingCacheEpochs?: number;
 };
 
 /**
- * A shuffling cache to help:
- * - get committee quickly for attestation verification
- * - if a shuffling is not available (which does not happen with default chain option of maxSkipSlots = 32), track a promise to make sure we don't compute the same shuffling twice
- * - skip computing shuffling when loading state bytes from disk
+ * Cache recent epoch shufflings for lookahead duties, gossip validation, and block production.
+ * Pending promises deduplicate computation of missing shufflings.
  */
 export class ShufflingCache {
-  /** LRU cache implemented as a map, pruned every time we add an item */
+  /** Pruned to the `maxEpochs` highest epochs every time we add a shuffling */
   private readonly itemsByDecisionRootByEpoch: MapDef<Epoch, Map<RootHex, CacheItem>> = new MapDef(
     () => new Map<RootHex, CacheItem>()
   );
@@ -73,6 +76,9 @@ export class ShufflingCache {
           Array.from(this.itemsByDecisionRootByEpoch.values()).reduce((total, innerMap) => total + innerMap.size, 0)
         )
       );
+      metrics.shufflingCache.epochs.addCollect(() =>
+        metrics.shufflingCache.epochs.set(this.itemsByDecisionRootByEpoch.size)
+      );
     }
 
     this.maxEpochs = opts.maxShufflingCacheEpochs ?? MAX_EPOCHS;
@@ -97,8 +103,8 @@ export class ShufflingCache {
         `Too many shuffling promises: ${promiseCount}, shufflingEpoch: ${epoch}, decisionRootHex: ${decisionRoot}`
       );
     }
-    let resolveFn: ((shuffling: EpochShuffling) => void) | null = null;
-    const promise = new Promise<EpochShuffling>((resolve) => {
+    let resolveFn: ((shuffling: EpochShuffling | null) => void) | null = null;
+    const promise = new Promise<EpochShuffling | null>((resolve) => {
       resolveFn = resolve;
     });
     if (resolveFn === null) {
@@ -121,7 +127,7 @@ export class ShufflingCache {
    * Return null if we don't have a shuffling for this epoch and dependentRootHex.
    */
   async get(epoch: Epoch, decisionRoot: RootHex): Promise<EpochShuffling | null> {
-    const cacheItem = this.itemsByDecisionRootByEpoch.getOrDefault(epoch).get(decisionRoot);
+    const cacheItem = this.itemsByDecisionRootByEpoch.get(epoch)?.get(decisionRoot);
     if (cacheItem === undefined) {
       this.metrics?.shufflingCache.miss.inc();
       return null;
@@ -136,12 +142,10 @@ export class ShufflingCache {
   }
 
   /**
-   * Get a shuffling synchronously, return null if not present.
-   * The only time we have a promise cache item is when we regen shuffling for attestation, which never happens
-   * with default chain option.
+   * Get a shuffling synchronously, return null if not present or if it's still being computed.
    */
   getSync(epoch: Epoch, decisionRoot: RootHex): EpochShuffling | null {
-    const cacheItem = this.itemsByDecisionRootByEpoch.getOrDefault(epoch).get(decisionRoot);
+    const cacheItem = this.itemsByDecisionRootByEpoch.get(epoch)?.get(decisionRoot);
     if (cacheItem === undefined) {
       this.metrics?.shufflingCache.miss.inc();
       return null;
@@ -161,7 +165,7 @@ export class ShufflingCache {
    * `NativeBeaconStateView`.
    */
   has(epoch: Epoch, decisionRoot: RootHex): boolean {
-    const cacheItem = this.itemsByDecisionRootByEpoch.getOrDefault(epoch).get(decisionRoot);
+    const cacheItem = this.itemsByDecisionRootByEpoch.get(epoch)?.get(decisionRoot);
     return cacheItem !== undefined && isShufflingCacheItem(cacheItem);
   }
 
@@ -186,6 +190,25 @@ export class ShufflingCache {
     }
   }
 
+  /**
+   * Resolve a pending promise with null so that waiters don't hang, then remove it.
+   */
+  cancelPromise(epoch: Epoch, decisionRoot: RootHex, reason: ShufflingPromiseCancelReason): void {
+    const itemsByDecisionRoot = this.itemsByDecisionRootByEpoch.get(epoch);
+    const cacheItem = itemsByDecisionRoot?.get(decisionRoot);
+    if (itemsByDecisionRoot === undefined || cacheItem === undefined || !isPromiseCacheItem(cacheItem)) {
+      return;
+    }
+
+    cacheItem.resolveFn(null);
+    itemsByDecisionRoot.delete(decisionRoot);
+    if (itemsByDecisionRoot.size === 0) {
+      this.itemsByDecisionRootByEpoch.delete(epoch);
+    }
+    this.metrics?.shufflingCache.cancelledPromises.inc({reason});
+    this.logger?.debug("Cancelled shuffling promise", {epoch, decisionRoot, reason});
+  }
+
   getIndexedAttestation(
     epoch: number,
     decisionRoot: string,
@@ -248,8 +271,42 @@ export class ShufflingCache {
     }
     // set the shuffling
     shufflingAtEpoch.set(decisionRoot, {type: CacheItemType.shuffling, shuffling});
-    // prune the cache
-    pruneSetToMax(this.itemsByDecisionRootByEpoch, this.maxEpochs);
+    this.prune();
+  }
+
+  /**
+   * Keep the `maxEpochs` highest epochs, regardless of insertion order.
+   */
+  private prune(): void {
+    const toDelete = this.itemsByDecisionRootByEpoch.size - this.maxEpochs;
+    if (toDelete <= 0) {
+      return;
+    }
+
+    const prunedEpochs = Array.from(this.itemsByDecisionRootByEpoch.keys())
+      .sort((a, b) => a - b)
+      .slice(0, toDelete);
+    let prunedShufflings = 0;
+    for (const epoch of prunedEpochs) {
+      for (const cacheItem of this.itemsByDecisionRootByEpoch.get(epoch)?.values() ?? []) {
+        if (isPromiseCacheItem(cacheItem)) {
+          cacheItem.resolveFn(null);
+          this.metrics?.shufflingCache.cancelledPromises.inc({reason: ShufflingPromiseCancelReason.pruned});
+        } else {
+          prunedShufflings++;
+        }
+      }
+      this.itemsByDecisionRootByEpoch.delete(epoch);
+    }
+    this.metrics?.shufflingCache.prunedShufflings.inc(prunedShufflings);
+
+    this.logger?.verbose("Pruned shuffling cache", {
+      prunedEpochs: prunedEpochs.join(","),
+      prunedShufflings,
+      cachedEpochs: Array.from(this.itemsByDecisionRootByEpoch.keys())
+        .sort((a, b) => a - b)
+        .join(","),
+    });
   }
 }
 

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};
+}