@lodestar/beacon-node 1.50.0-dev.fda8006fc3 → 1.50.0-dev.fe4e7408b4

package/src/chain/produceBlock/produceBlockBody.ts

@@ -20,6 +20,7 @@ import {
   isForkPostAltair,
   isForkPostBellatrix,
   isForkPostGloas,
+  isForkPostHeze,
 } from "@lodestar/params";
 import {
   G2_POINT_AT_INFINITY,
@@ -77,6 +78,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 +288,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 +447,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) {
@@ -681,12 +685,11 @@ export async function produceBlockBody<T extends BlockType>(
     executionPayloadValue = BigInt(0);
   }
 
-  const {graffiti, attestations, deposits, voluntaryExits, attesterSlashings, proposerSlashings} = blockBody;
+  const {graffiti, attestations, voluntaryExits, attesterSlashings, proposerSlashings} = blockBody;
 
   Object.assign(logMeta, {
     graffiti: fromGraffitiBytes(graffiti),
     attestations: attestations.length,
-    deposits: deposits.length,
     voluntaryExits: voluntaryExits.length,
     attesterSlashings: attesterSlashings.length,
     proposerSlashings: proposerSlashings.length,
@@ -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,
@@ -1072,16 +1106,21 @@ export async function produceCommonBlockBody<T extends BlockType>(
   });
 
   // Live proposal production is supported from Fulu onward.
-  return {
+  const commonBlockBody: CommonBlockBody = {
     randaoReveal,
     graffiti,
-    eth1Data: currentState.eth1Data,
     proposerSlashings: this.opts.disableProposerSlashings === true ? [] : proposerSlashings,
     attesterSlashings,
     attestations,
-    deposits: [],
     voluntaryExits,
     blsToExecutionChanges,
     syncAggregate,
   };
+
+  if (!isForkPostHeze(fork)) {
+    commonBlockBody.eth1Data = currentState.eth1Data;
+    commonBlockBody.deposits = [];
+  }
+
+  return commonBlockBody;
 }

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -4,6 +4,7 @@ import {
   ForkName,
   ForkPostFulu,
   ForkPostGloas,
+  ForkPreDeneb,
   ForkPreGloas,
   SLOTS_PER_EPOCH,
   isForkPostDeneb,
@@ -111,6 +112,9 @@ export class SeenBlockInput {
   // there should only 1 block root per slot but we need to always compare against rootHex
   // and the signature to ensure we only skip verification if both match
   private verifiedProposerSignatures = new Map<Slot, Map<RootHex, BLSSignature>>();
+  // Roots of gossip blocks under validation, counted because blocks with the same root but different signatures
+  // can be validated concurrently
+  private validatingBlockRoots = new Map<RootHex, number>();
 
   constructor({
     config,
@@ -153,6 +157,26 @@ export class SeenBlockInput {
     return this.blockInputs.get(rootHex)?.hasBlock() ?? false;
   }
 
+  /**
+   * Mark a gossip block root as under validation, every call MUST be paired with `unmarkValidatingBlock()`
+   */
+  markValidatingBlock(rootHex: RootHex): void {
+    this.validatingBlockRoots.set(rootHex, (this.validatingBlockRoots.get(rootHex) ?? 0) + 1);
+  }
+
+  unmarkValidatingBlock(rootHex: RootHex): void {
+    const count = this.validatingBlockRoots.get(rootHex) ?? 0;
+    if (count <= 1) {
+      this.validatingBlockRoots.delete(rootHex);
+    } else {
+      this.validatingBlockRoots.set(rootHex, count - 1);
+    }
+  }
+
+  isValidatingBlock(rootHex: RootHex): boolean {
+    return this.validatingBlockRoots.has(rootHex);
+  }
+
   get(rootHex: RootHex): IBlockInput | undefined {
     return this.blockInputs.get(rootHex);
   }
@@ -217,7 +241,7 @@ export class SeenBlockInput {
       } else if (!isForkPostDeneb(forkName)) {
         // Pre-deneb
         blockInput = BlockInputPreData.createFromBlock({
-          block,
+          block: block as SignedBeaconBlock<ForkPreDeneb>,
           blockRootHex,
           daOutOfRange,
           forkName,

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,
@@ -205,6 +228,11 @@ export class ShufflingCache {
     return this.getBeaconCommittees(epoch, decisionRoot, slot, [index])[0];
   }
 
+  getBeaconCommitteeOrNull(epoch: number, decisionRoot: string, slot: Slot, index: CommitteeIndex): Uint32Array | null {
+    const shuffling = this.getSync(epoch, decisionRoot);
+    return shuffling === null ? null : getBeaconCommittees(shuffling, slot, [index])[0];
+  }
+
   getBeaconCommittees(epoch: number, decisionRoot: string, slot: Slot, indices: CommitteeIndex[]): Uint32Array[] {
     const shuffling = this.getShufflingOrThrow(epoch, decisionRoot);
     return getBeaconCommittees(shuffling, slot, indices);
@@ -243,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

@@ -8,6 +8,7 @@ import {FlatFileStore} from "./flatFileStore/flatFileStore.js";
 import type {FlatFileStoreMetrics} from "./flatFileStore/metrics.js";
 import {IBeaconDb} from "./interface.js";
 import {CheckpointStateRepository} from "./repositories/checkpointState.js";
+import {EarliestAvailableSlotRepository} from "./repositories/earliestAvailableSlot.js";
 import {
   AttesterSlashingRepository,
   BLSToExecutionChangeRepository,
@@ -21,6 +22,7 @@ import {
   DataColumnSidecarRepository,
   ExecutionPayloadEnvelopeArchiveRepository,
   ExecutionPayloadEnvelopeRepository,
+  ProposerPreferencesRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -48,9 +50,11 @@ export class BeaconDb implements IBeaconDb {
 
   stateArchive: StateArchiveRepository;
   checkpointState: CheckpointStateRepository;
+  earliestAvailableSlot: EarliestAvailableSlotRepository;
 
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
+  proposerPreferences: ProposerPreferencesRepository;
   attesterSlashing: AttesterSlashingRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 
@@ -83,9 +87,11 @@ export class BeaconDb implements IBeaconDb {
 
     this.stateArchive = new StateArchiveRepository(config, db);
     this.checkpointState = new CheckpointStateRepository(config, db);
+    this.earliestAvailableSlot = new EarliestAvailableSlotRepository(db);
     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

@@ -72,6 +72,8 @@ 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

@@ -3,6 +3,7 @@ import {Slot} from "@lodestar/types";
 import type {IDataColumnStore} from "./dataColumnStore.js";
 import type {FlatFileStoreMetrics} from "./flatFileStore/metrics.js";
 import {CheckpointStateRepository} from "./repositories/checkpointState.js";
+import {EarliestAvailableSlotRepository} from "./repositories/earliestAvailableSlot.js";
 import {
   AttesterSlashingRepository,
   BLSToExecutionChangeRepository,
@@ -16,6 +17,7 @@ import {
   DataColumnSidecarRepository,
   ExecutionPayloadEnvelopeArchiveRepository,
   ExecutionPayloadEnvelopeRepository,
+  ProposerPreferencesRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -46,10 +48,12 @@ export interface IBeaconDb {
   stateArchive: StateArchiveRepository;
   // checkpoint states
   checkpointState: CheckpointStateRepository;
+  earliestAvailableSlot: EarliestAvailableSlotRepository;
 
   // op pool
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
+  proposerPreferences: ProposerPreferencesRepository;
   attesterSlashing: AttesterSlashingRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 

package/src/db/repositories/blockArchive.ts

@@ -184,7 +184,7 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   async remove(value: SignedBeaconBlock): Promise<void> {
     await Promise.all([
       super.remove(value),
-      deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value),
+      deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).BeaconBlock, value),
       deleteParentRootIndex(this.db, value),
     ]);
   }
@@ -193,7 +193,7 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
     await Promise.all([
       super.batchRemove(values),
       ...values.map((value) =>
-        deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value)
+        deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).BeaconBlock, value)
       ),
       ...values.map((value) => deleteParentRootIndex(this.db, value)),
     ]);

package/src/db/repositories/blockArchiveIndex.ts

@@ -1,6 +1,6 @@
 import {Db, encodeKey} from "@lodestar/db";
 import {ForkAll} from "@lodestar/params";
-import {Root, SSZTypesFor, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
+import {Root, SSZTypesFor, SignedBeaconBlock, Slot} from "@lodestar/types";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 export const rootIndexBucketId = getBucketNameByValue(Bucket.index_blockArchiveRootIndex);
@@ -16,10 +16,9 @@ export async function getParentRootIndex(db: Db, parentRoot: Root): Promise<Uint
 
 export async function deleteRootIndex(
   db: Db,
-  signedBeaconBlockType: SSZTypesFor<ForkAll, "SignedBeaconBlock">,
+  beaconBlockType: SSZTypesFor<ForkAll, "BeaconBlock">,
   block: SignedBeaconBlock
 ): Promise<void> {
-  const beaconBlockType = (signedBeaconBlockType as typeof ssz.phase0.SignedBeaconBlock).fields.message;
   return db.delete(getRootIndexKey(beaconBlockType.hashTreeRoot(block.message)), {bucketId: rootIndexBucketId});
 }
 

package/src/db/repositories/earliestAvailableSlot.ts

@@ -0,0 +1,19 @@
+import {Db, encodeKey} from "@lodestar/db";
+import {Slot, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class EarliestAvailableSlotRepository {
+  private readonly key = encodeKey(Bucket.earliestAvailableSlot, 0);
+  private readonly opts = {bucketId: getBucketNameByValue(Bucket.earliestAvailableSlot)};
+
+  constructor(private readonly db: Db) {}
+
+  async get(): Promise<Slot | null> {
+    const bytes = await this.db.get(this.key, this.opts);
+    return bytes === null ? null : ssz.Slot.deserialize(bytes);
+  }
+
+  async set(slot: Slot): Promise<void> {
+    await this.db.put(this.key, ssz.Slot.serialize(slot), this.opts);
+  }
+}

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