@lodestar/beacon-node 1.50.0-dev.6fb6c0bad4 → 1.50.0-dev.70314c9caa

package/src/chain/blocks/payloadEnvelopeInput/types.ts

@@ -22,8 +22,9 @@ export enum PayloadEnvelopeInputSource {
  * - finalized: below the finalized slot
  * - prune: explicit prune by root
  * - cap: insertion-order backstop cap (MAX_PAYLOAD_ENVELOPE_INPUT_CACHE_SIZE)
+ * - invalid: the cached envelope failed import with a definitive invalid verdict
  */
-export type PayloadEnvelopeInputPruneReason = "belowParent" | "finalized" | "remove" | "cap";
+export type PayloadEnvelopeInputPruneReason = "belowParent" | "finalized" | "remove" | "cap" | "invalid";
 
 export type SourceMeta = {
   source: PayloadEnvelopeInputSource;

package/src/chain/chain.ts

@@ -611,7 +611,7 @@ export class BeaconChain implements IBeaconChain {
   /** Populate in-memory caches with persisted data. Call at least once on startup */
   async loadFromDisk(): Promise<void> {
     await this.regen.init();
-    await this.opPool.fromPersisted(this.db);
+    await this.opPool.fromPersisted(this.db, this.getHeadState(), this.bls, this.clock.currentSlot);
   }
 
   /** Persist in-memory data to the DB. Call at least once before stopping the process */
@@ -1329,13 +1329,13 @@ export class BeaconChain implements IBeaconChain {
       };
 
       try {
-        await validateApiProposerSlashing(this, proposerSlashing);
+        const verifiedDomain = await validateApiProposerSlashing(this, proposerSlashing);
+        this.opPool.insertProposerSlashing(proposerSlashing, verifiedDomain);
       } catch (e) {
         this.logger.debug("Produced proposer slashing is not valid", {slot: blockSlot, proposerIndex}, e as Error);
         return;
       }
 
-      this.opPool.insertProposerSlashing(proposerSlashing);
       this.emitter.emit(routes.events.EventType.proposerSlashing, proposerSlashing);
       this.emitter.emit(ChainEvent.publishProposerSlashing, proposerSlashing);
       this.metrics?.opPool.proposerSlashingsProduced.inc();

package/src/chain/errors/gossipValidation.ts

@@ -9,6 +9,8 @@ export enum GossipErrorCode {
   INVALID_SERIALIZED_BYTES_ERROR_CODE = "GOSSIP_ERROR_INVALID_SERIALIZED_BYTES",
   PAST_SLOT = "GOSSIP_ERROR_PAST_SLOT",
   FUTURE_SLOT = "GOSSIP_ERROR_FUTURE_SLOT",
+  FATAL_PEER = "GOSSIP_ERROR_FATAL_PEER",
+  INVALID_SLOT = "GOSSIP_ERROR_INVALID_SLOT",
 }
 
 export class GossipActionError<T extends {code: string}> extends LodestarError<T> {

package/src/chain/initState.ts

@@ -1,14 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkPostGloas, ForkSeq, ZERO_HASH} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  BeaconStateGloas,
-  IBeaconStateView,
-  computeEpochAtSlot,
-  computeStartSlotAtEpoch,
-} from "@lodestar/state-transition";
+import {BeaconStateAllForks, IBeaconStateView, computeEpochAtSlot, isStatePostGloas} from "@lodestar/state-transition";
 import {SignedBeaconBlock, ssz} from "@lodestar/types";
-import {Logger, byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
+import {LodestarError, Logger, byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/index.js";
 import {IBeaconDb} from "../db/index.js";
 import {Metrics} from "../metrics/index.js";
@@ -17,7 +11,7 @@ import {getStateTypeFromBytes} from "../util/multifork.js";
 export async function persistAnchorState(
   config: ChainForkConfig,
   db: IBeaconDb,
-  anchorState: BeaconStateAllForks,
+  anchorState: IBeaconStateView,
   anchorStateBytes: Uint8Array
 ): Promise<void> {
   if (anchorState.slot === GENESIS_SLOT) {
@@ -33,7 +27,8 @@ export async function persistAnchorState(
     const latestBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(latestBlockHeader);
 
     if (!byteArrayEquals(blockRoot, latestBlockRoot)) {
-      throw Error(
+      throw new LodestarError(
+        {code: "GENESIS_BLOCK_ROOT_MISMATCH"},
         `Genesis block root ${toRootHex(blockRoot)} does not match genesis state latest block root ${toRootHex(latestBlockRoot)}`
       );
     }
@@ -48,16 +43,15 @@ export async function persistAnchorState(
   }
 }
 
-export function createGenesisBlock(config: ChainForkConfig, genesisState: BeaconStateAllForks): SignedBeaconBlock {
+export function createGenesisBlock(config: ChainForkConfig, genesisState: IBeaconStateView): SignedBeaconBlock {
   const types = config.getForkTypes(GENESIS_SLOT);
   const genesisBlock = types.SignedBeaconBlock.defaultValue();
   const stateRoot = genesisState.hashTreeRoot();
   genesisBlock.message.stateRoot = stateRoot;
 
-  if (config.getForkSeq(GENESIS_SLOT) >= ForkSeq.gloas) {
+  if (config.getForkSeq(GENESIS_SLOT) >= ForkSeq.gloas && isStatePostGloas(genesisState)) {
     const gloasBlock = genesisBlock as SignedBeaconBlock<ForkPostGloas>;
-    const gloasState = genesisState as BeaconStateGloas;
-    gloasBlock.message.body.signedExecutionPayloadBid.message = gloasState.latestExecutionPayloadBid.toValue();
+    gloasBlock.message.body.signedExecutionPayloadBid.message = genesisState.latestExecutionPayloadBid;
   }
 
   return genesisBlock;
@@ -86,52 +80,6 @@ export async function initStateFromDb(
   return state;
 }
 
-/**
- * Initialize and persist an anchor state (either weak subjectivity or genesis)
- */
-export async function checkAndPersistAnchorState(
-  config: ChainForkConfig,
-  db: IBeaconDb,
-  logger: Logger,
-  anchorState: BeaconStateAllForks,
-  anchorStateBytes: Uint8Array,
-  {
-    isWithinWeakSubjectivityPeriod,
-    isCheckpointState,
-  }: {isWithinWeakSubjectivityPeriod: boolean; isCheckpointState: boolean}
-): Promise<void> {
-  const expectedFork = config.getForkInfo(computeStartSlotAtEpoch(anchorState.fork.epoch));
-  const expectedForkVersion = toHex(expectedFork.version);
-  const stateFork = toHex(anchorState.fork.currentVersion);
-  if (stateFork !== expectedForkVersion) {
-    throw Error(
-      `State current fork version ${stateFork} not equal to current config ${expectedForkVersion}. Maybe caused by importing a state from a different network`
-    );
-  }
-
-  const stateInfo = isCheckpointState ? "checkpoint" : "db";
-  if (isWithinWeakSubjectivityPeriod) {
-    logger.info(`Initializing beacon from a valid ${stateInfo} state`, {
-      slot: anchorState.slot,
-      epoch: computeEpochAtSlot(anchorState.slot),
-      stateRoot: toRootHex(anchorState.hashTreeRoot()),
-      isWithinWeakSubjectivityPeriod,
-    });
-  } else {
-    logger.warn(`Initializing from a stale ${stateInfo} state vulnerable to long range attacks`, {
-      slot: anchorState.slot,
-      epoch: computeEpochAtSlot(anchorState.slot),
-      stateRoot: toRootHex(anchorState.hashTreeRoot()),
-      isWithinWeakSubjectivityPeriod,
-    });
-    logger.warn("Checkpoint sync recommended, please use --help to see checkpoint sync options");
-  }
-
-  if (isCheckpointState || anchorState.slot === GENESIS_SLOT) {
-    await persistAnchorState(config, db, anchorState, anchorStateBytes);
-  }
-}
-
 export function initBeaconMetrics(metrics: Metrics, state: IBeaconStateView): void {
   metrics.headSlot.set(state.slot);
   metrics.previousJustifiedEpoch.set(state.previousJustifiedCheckpoint.epoch);

package/src/chain/opPools/opPool.ts

@@ -12,38 +12,54 @@ import {
 } from "@lodestar/params";
 import {
   IBeaconStateView,
+  assertValidAttesterSlashing,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   getAttesterSlashableIndices,
+  getAttesterSlashingSignatureSets,
+  getProposerSlashingSignatureSets,
 } from "@lodestar/state-transition";
 import {
   AttesterSlashing,
+  Domain,
   Epoch,
   SignedBeaconBlock,
+  Slot,
   ValidatorIndex,
   capella,
   phase0,
+  ssz,
   sszTypesFor,
 } from "@lodestar/types";
-import {fromHex, toHex, toRootHex} from "@lodestar/utils";
+import {byteArrayEquals, fromHex, toHex, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
 import {Metrics} from "../../metrics/metrics.js";
 import {SignedBLSToExecutionChangeVersioned} from "../../util/types.js";
+import {IBlsVerifier} from "../bls/interface.js";
 import {BlockType} from "../interface.js";
 import {BlockProductionStep} from "../produceBlock/produceBlockBody.js";
-import {isValidBlsToExecutionChangeForBlockInclusion} from "./utils.js";
+import {
+  getAttesterSlashingSignatureDomains,
+  getProposerSlashingSignatureDomain,
+  isValidBlsToExecutionChangeForBlockInclusion,
+} from "./utils.js";
 
 type HexRoot = string;
 type AttesterSlashingCached = {
   attesterSlashing: AttesterSlashing;
   intersectingIndices: number[];
+  verifiedDomains: [Domain, Domain];
+};
+type ProposerSlashingCached = {
+  proposerSlashing: phase0.ProposerSlashing;
+  verifiedDomain: Domain;
 };
 
 export class OpPool {
   /** Map of uniqueId(AttesterSlashing) -> AttesterSlashing */
   private readonly attesterSlashings = new Map<HexRoot, AttesterSlashingCached>();
   /** Map of to slash validator index -> ProposerSlashing */
-  private readonly proposerSlashings = new Map<ValidatorIndex, phase0.ProposerSlashing>();
+  private readonly proposerSlashings = new Map<ValidatorIndex, ProposerSlashingCached>();
   /** Map of to exit validator index -> SignedVoluntaryExit */
   private readonly voluntaryExits = new Map<ValidatorIndex, phase0.SignedVoluntaryExit>();
   /** Set of seen attester slashing indexes. No need to prune */
@@ -68,7 +84,7 @@ export class OpPool {
     return this.blsToExecutionChanges.size;
   }
 
-  async fromPersisted(db: IBeaconDb): Promise<void> {
+  async fromPersisted(db: IBeaconDb, state: IBeaconStateView, bls: IBlsVerifier, currentSlot: Slot): Promise<void> {
     const [attesterSlashings, proposerSlashings, voluntaryExits, blsToExecutionChanges] = await Promise.all([
       db.attesterSlashing.entries(),
       db.proposerSlashing.values(),
@@ -76,11 +92,42 @@ export class OpPool {
       db.blsToExecutionChange.values(),
     ]);
 
-    for (const attesterSlashing of attesterSlashings) {
-      this.insertAttesterSlashing(ForkName.electra, attesterSlashing.value, attesterSlashing.key);
+    // Persisted operations have no verification context. Rebuild it before they can enter the pool.
+    // The startup anchor may precede a fork whose slashings are already persisted.
+    for (const {key, value: attesterSlashing} of attesterSlashings) {
+      try {
+        assertValidAttesterSlashing(this.config, currentSlot, state.validatorCount, attesterSlashing, false);
+      } catch {
+        continue;
+      }
+      const verifiedDomains = getAttesterSlashingSignatureDomains(this.config, currentSlot, attesterSlashing);
+      if (
+        !(await bls.verifySignatureSets(getAttesterSlashingSignatureSets(this.config, currentSlot, attesterSlashing)))
+      ) {
+        continue;
+      }
+      this.insertAttesterSlashing(ForkName.electra, attesterSlashing, verifiedDomains, key);
     }
     for (const proposerSlashing of proposerSlashings) {
-      this.insertProposerSlashing(proposerSlashing);
+      const header1 = proposerSlashing.signedHeader1.message;
+      const header2 = proposerSlashing.signedHeader2.message;
+      // Startup may restore a state from before activation. Current slashability is checked
+      // when selecting operations, so it must not prevent restoring an otherwise valid slashing.
+      if (
+        header1.slot !== header2.slot ||
+        header1.proposerIndex !== header2.proposerIndex ||
+        header1.proposerIndex >= state.validatorCount ||
+        ssz.phase0.BeaconBlockHeaderBigint.equals(header1, header2)
+      ) {
+        continue;
+      }
+      const verifiedDomain = getProposerSlashingSignatureDomain(this.config, currentSlot, proposerSlashing);
+      if (
+        !(await bls.verifySignatureSets(getProposerSlashingSignatureSets(this.config, currentSlot, proposerSlashing)))
+      ) {
+        continue;
+      }
+      this.insertProposerSlashing(proposerSlashing, verifiedDomain);
     }
     for (const voluntaryExit of voluntaryExits) {
       this.insertVoluntaryExit(voluntaryExit);
@@ -102,8 +149,12 @@ export class OpPool {
       ),
       persistDiff(
         db.proposerSlashing,
-        Array.from(this.proposerSlashings.entries()).map(([key, value]) => ({key, value})),
-        (index) => index
+        Array.from(this.proposerSlashings.entries()).map(([key, value]) => ({key, value: value.proposerSlashing})),
+        (index) => index,
+        // A slashing invalidated by a fork may remain on disk after eviction from the pool.
+        // A new valid slashing for that validator has the same database key, so comparing
+        // keys alone would retain the invalid slashing and lose the replacement on restart.
+        {updateExisting: true}
       ),
       persistDiff(
         db.voluntaryExit,
@@ -143,7 +194,12 @@ export class OpPool {
   }
 
   /** Must be validated beforehand */
-  insertAttesterSlashing(fork: ForkName, attesterSlashing: AttesterSlashing, rootHash?: Uint8Array): void {
+  insertAttesterSlashing(
+    fork: ForkName,
+    attesterSlashing: AttesterSlashing,
+    verifiedDomains: [Domain, Domain],
+    rootHash?: Uint8Array
+  ): void {
     if (!rootHash) {
       rootHash = sszTypesFor(fork).AttesterSlashing.hashTreeRoot(attesterSlashing);
     }
@@ -153,6 +209,7 @@ export class OpPool {
     this.attesterSlashings.set(toRootHex(rootHash), {
       attesterSlashing,
       intersectingIndices,
+      verifiedDomains,
     });
     for (const index of intersectingIndices) {
       this.attesterSlashingIndexes.add(index);
@@ -160,8 +217,11 @@ export class OpPool {
   }
 
   /** Must be validated beforehand */
-  insertProposerSlashing(proposerSlashing: phase0.ProposerSlashing): void {
-    this.proposerSlashings.set(proposerSlashing.signedHeader1.message.proposerIndex, proposerSlashing);
+  insertProposerSlashing(proposerSlashing: phase0.ProposerSlashing, verifiedDomain: Domain): void {
+    this.proposerSlashings.set(proposerSlashing.signedHeader1.message.proposerIndex, {
+      proposerSlashing,
+      verifiedDomain,
+    });
   }
 
   /** Must be validated beforehand */
@@ -204,7 +264,14 @@ export class OpPool {
         : metrics?.builderBlockProductionTimeSteps;
 
     const endProposerSlashing = stepsMetrics?.startTimer();
-    for (const proposerSlashing of this.proposerSlashings.values()) {
+    for (const [key, {proposerSlashing, verifiedDomain}] of this.proposerSlashings) {
+      // A fork can change the required domain even for verified slashings, including those with future-slot headers.
+      if (
+        !byteArrayEquals(verifiedDomain, getProposerSlashingSignatureDomain(this.config, state.slot, proposerSlashing))
+      ) {
+        this.proposerSlashings.delete(key);
+        continue;
+      }
       const index = proposerSlashing.signedHeader1.message.proposerIndex;
       const validator = state.getValidator(index);
       if (!validator.slashed && validator.activationEpoch <= stateEpoch && stateEpoch < validator.withdrawableEpoch) {
@@ -223,7 +290,12 @@ export class OpPool {
     const endAttesterSlashings = stepsMetrics?.startTimer();
     const attesterSlashings: AttesterSlashing[] = [];
     const maxAttesterSlashings = stateFork >= ForkSeq.electra ? MAX_ATTESTER_SLASHINGS_ELECTRA : MAX_ATTESTER_SLASHINGS;
-    attesterSlashing: for (const attesterSlashing of this.attesterSlashings.values()) {
+    attesterSlashing: for (const [key, attesterSlashing] of this.attesterSlashings) {
+      const domains = getAttesterSlashingSignatureDomains(this.config, state.slot, attesterSlashing.attesterSlashing);
+      if (!attesterSlashing.verifiedDomains.every((domain, i) => byteArrayEquals(domain, domains[i]))) {
+        this.attesterSlashings.delete(key);
+        continue;
+      }
       /** Indices slashable in this attester slashing */
       const slashableIndices = new Set<ValidatorIndex>();
       for (let i = 0; i < attesterSlashing.intersectingIndices.length; i++) {
@@ -303,7 +375,7 @@ export class OpPool {
 
   /** For beacon pool API */
   getAllProposerSlashings(): phase0.ProposerSlashing[] {
-    return Array.from(this.proposerSlashings.values());
+    return Array.from(this.proposerSlashings.values()).map(({proposerSlashing}) => proposerSlashing);
   }
 
   /** For beacon pool API */
@@ -356,7 +428,7 @@ export class OpPool {
    */
   private pruneProposerSlashings(headState: IBeaconStateView): void {
     const finalizedEpoch = headState.finalizedCheckpoint.epoch;
-    for (const [key, proposerSlashing] of this.proposerSlashings.entries()) {
+    for (const [key, {proposerSlashing}] of this.proposerSlashings.entries()) {
       const index = proposerSlashing.signedHeader1.message.proposerIndex;
       if (headState.getValidator(index).exitEpoch <= finalizedEpoch) {
         this.proposerSlashings.delete(key);
@@ -436,14 +508,15 @@ function isSlashableAtEpoch(validator: phase0.Validator, epoch: Epoch): boolean
 async function persistDiff<K extends Id, V>(
   dbRepo: Repository<K, V>,
   items: {key: K; value: V}[],
-  serializeKey: (key: K) => number | string
+  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 (!persistedKeysSerialized.has(serializeKey(item.key))) {
+    if (opts.updateExisting || !persistedKeysSerialized.has(serializeKey(item.key))) {
       batch.push({type: "put", key: item.key, value: item.value});
     }
   }

package/src/chain/opPools/utils.ts

@@ -1,9 +1,37 @@
 import {Signature} from "@chainsafe/lodestar-z/blst";
-import {BLS_WITHDRAWAL_PREFIX} from "@lodestar/params";
-import {IBeaconStateView} from "@lodestar/state-transition";
-import {Slot, capella} from "@lodestar/types";
+import {BeaconConfig} from "@lodestar/config";
+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";
 import {AggregateFast, AggregateFastElectra} from "./attestationPool.js";
 
+export function getProposerSlashingSignatureDomain(
+  config: BeaconConfig,
+  stateSlot: Slot,
+  slashing: phase0.ProposerSlashing
+): Domain {
+  return config.getDomain(stateSlot, DOMAIN_BEACON_PROPOSER, Number(slashing.signedHeader1.message.slot));
+}
+
+export function getAttesterSlashingSignatureDomains(
+  config: BeaconConfig,
+  stateSlot: Slot,
+  slashing: AttesterSlashing
+): [Domain, Domain] {
+  return [
+    config.getDomain(
+      stateSlot,
+      DOMAIN_BEACON_ATTESTER,
+      computeStartSlotAtEpoch(Number(slashing.attestation1.data.target.epoch))
+    ),
+    config.getDomain(
+      stateSlot,
+      DOMAIN_BEACON_ATTESTER,
+      computeStartSlotAtEpoch(Number(slashing.attestation2.data.target.epoch))
+    ),
+  ];
+}
+
 /**
  * Prune a Map indexed by slot to keep the most recent slots, up to `slotsRetained`
  */

package/src/chain/prepareNextSlot.ts

@@ -244,6 +244,10 @@ export class PrepareNextSlotScheduler {
           parentBlockHash = preparedState.latestExecutionPayloadHeader.blockHash;
         }
 
+        // The payload_attributes event must carry the same hashes we send to the EL
+        const safeBlockHash = getSafeExecutionBlockHash(this.chain.forkChoice, this.logger);
+        const finalizedBlockHash = getFinalizedExecutionBlockHash(this.chain.forkChoice);
+
         let payloadAttributes: PayloadAttributes | undefined;
         // If emitPayloadAttributes is true emit a SSE payloadAttributes event for
         // every slot. Without the flag, only emit the event if we are proposing in the next slot.
@@ -256,6 +260,8 @@ export class PrepareNextSlotScheduler {
             prepareSlot,
             parentBlockRoot: fromHex(updatedHead.blockRoot),
             parentBlockHash,
+            safeBlockHash,
+            finalizedBlockHash,
             feeRecipient: feeRecipient ?? "0x0000000000000000000000000000000000000000",
           });
           this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
@@ -267,9 +273,6 @@ export class PrepareNextSlotScheduler {
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
           this.metrics?.blockPayload.payloadAdvancePrepTime.observe(preparationTime);
 
-          const safeBlockHash = getSafeExecutionBlockHash(this.chain.forkChoice, this.logger);
-          const finalizedBlockHash = getFinalizedExecutionBlockHash(this.chain.forkChoice);
-
           // awaiting here instead of throwing an async call because there is no other task
           // left for scheduler and this gives nice semantics to catch and log errors in the
           // try/catch wrapper here.

package/src/chain/produceBlock/produceBlockBody.ts

@@ -845,6 +845,8 @@ export function getPayloadAttributesForSSE(
     prepareSlot,
     parentBlockRoot,
     parentBlockHash,
+    safeBlockHash,
+    finalizedBlockHash,
     feeRecipient,
   }: {
     /**
@@ -855,6 +857,8 @@ export function getPayloadAttributesForSSE(
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
+    safeBlockHash: RootHex;
+    finalizedBlockHash: RootHex;
     feeRecipient: string;
   }
 ): SSEPayloadAttributes {
@@ -874,7 +878,10 @@ export function getPayloadAttributesForSSE(
     payloadAttributes,
   } as SSEPayloadAttributes;
 
-  if (!isForkPostGloas(fork)) {
+  if (isForkPostGloas(fork)) {
+    (ssePayloadAttributes as gloas.SSEPayloadAttributes).safeBlockHash = fromHex(safeBlockHash);
+    (ssePayloadAttributes as gloas.SSEPayloadAttributes).finalizedBlockHash = fromHex(finalizedBlockHash);
+  } else {
     // Removed in Gloas, builders can get the block number from the EL via the block hash if required
     (ssePayloadAttributes as bellatrix.SSEPayloadAttributes).parentBlockNumber = prepareState.payloadBlockNumber;
   }

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -264,6 +264,17 @@ export class SeenPayloadEnvelopeInput {
     }
   }
 
+  /**
+   * Removes a PayloadEnvelopeInput whose envelope failed import with a definitive invalid verdict. The envelope
+   * cannot be replaced in place, sync recreates the entry via `getOrReload()` or `add()` to fetch another one.
+   * No-op if the cached entry is a different object, it may already be the recreated one.
+   */
+  removeInvalid(payloadInput: PayloadEnvelopeInput): void {
+    if (this.payloadInputs.get(payloadInput.blockRootHex) === payloadInput) {
+      this.evictPayloadInput(payloadInput, "invalid");
+    }
+  }
+
   pruneBelowParent(parentBlock: ProtoBlock): void {
     for (const block of this.forkChoice.getAllAncestorBlocks(parentBlock.blockRoot, parentBlock.payloadStatus)) {
       // Only evict once the payload is FULL (revealed/imported) — on an EMPTY/PENDING branch we may

package/src/chain/validation/attesterSlashing.ts

@@ -4,14 +4,15 @@ import {
   getAttesterSlashingSignatureSets,
   isSlashableValidator,
 } from "@lodestar/state-transition";
-import {AttesterSlashing} from "@lodestar/types";
+import {AttesterSlashing, Domain} from "@lodestar/types";
 import {AttesterSlashingError, AttesterSlashingErrorCode, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
+import {getAttesterSlashingSignatureDomains} from "../opPools/utils.js";
 
 export async function validateApiAttesterSlashing(
   chain: IBeaconChain,
   attesterSlashing: AttesterSlashing
-): Promise<void> {
+): Promise<[Domain, Domain]> {
   const prioritizeBls = true;
   return validateAttesterSlashing(chain, attesterSlashing, prioritizeBls);
 }
@@ -19,7 +20,7 @@ export async function validateApiAttesterSlashing(
 export async function validateGossipAttesterSlashing(
   chain: IBeaconChain,
   attesterSlashing: AttesterSlashing
-): Promise<void> {
+): Promise<[Domain, Domain]> {
   return validateAttesterSlashing(chain, attesterSlashing);
 }
 
@@ -27,7 +28,7 @@ export async function validateAttesterSlashing(
   chain: IBeaconChain,
   attesterSlashing: AttesterSlashing,
   prioritizeBls = false
-): Promise<void> {
+): Promise<[Domain, Domain]> {
   // [IGNORE] At least one index in the intersection of the attesting indices of each attestation has not yet been seen
   // in any prior attester_slashing (i.e.
   //   attester_slashed_indices = set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices
@@ -61,9 +62,11 @@ export async function validateAttesterSlashing(
   }
 
   const signatureSets = getAttesterSlashingSignatureSets(chain.config, state.slot, attesterSlashing);
+  const verifiedDomains = getAttesterSlashingSignatureDomains(chain.config, state.slot, attesterSlashing);
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID_SIGNATURE,
     });
   }
+  return verifiedDomains;
 }

package/src/chain/validation/proposerSlashing.ts

@@ -1,12 +1,13 @@
 import {assertValidProposerSlashing, getProposerSlashingSignatureSets} from "@lodestar/state-transition";
-import {phase0} from "@lodestar/types";
+import {Domain, phase0} from "@lodestar/types";
 import {GossipAction, ProposerSlashingError, ProposerSlashingErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
+import {getProposerSlashingSignatureDomain} from "../opPools/utils.js";
 
 export async function validateApiProposerSlashing(
   chain: IBeaconChain,
   proposerSlashing: phase0.ProposerSlashing
-): Promise<void> {
+): Promise<Domain> {
   const prioritizeBls = true;
   return validateProposerSlashing(chain, proposerSlashing, prioritizeBls);
 }
@@ -14,7 +15,7 @@ export async function validateApiProposerSlashing(
 export async function validateGossipProposerSlashing(
   chain: IBeaconChain,
   proposerSlashing: phase0.ProposerSlashing
-): Promise<void> {
+): Promise<Domain> {
   return validateProposerSlashing(chain, proposerSlashing);
 }
 
@@ -22,7 +23,7 @@ async function validateProposerSlashing(
   chain: IBeaconChain,
   proposerSlashing: phase0.ProposerSlashing,
   prioritizeBls = false
-): Promise<void> {
+): Promise<Domain> {
   // [IGNORE] The proposer slashing is the first valid proposer slashing received for the proposer with index
   // proposer_slashing.signed_header_1.message.proposer_index.
   if (chain.opPool.hasSeenProposerSlashing(proposerSlashing.signedHeader1.message.proposerIndex)) {
@@ -46,9 +47,11 @@ async function validateProposerSlashing(
   }
 
   const signatureSets = getProposerSlashingSignatureSets(chain.config, state.slot, proposerSlashing);
+  const verifiedDomain = getProposerSlashingSignatureDomain(chain.config, state.slot, proposerSlashing);
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new ProposerSlashingError(GossipAction.REJECT, {
       code: ProposerSlashingErrorCode.INVALID_SIGNATURE,
     });
   }
+  return verifiedDomain;
 }

package/src/db/beacon.ts

@@ -122,6 +122,8 @@ export class BeaconDb implements IBeaconDb {
   async pruneHotDb(): Promise<void> {
     // Prune all hot blobs
     await this.blobSidecars.batchDelete(await this.blobSidecars.keys());
+    // New columns are persisted in flat files, so this bucket only contains legacy hot data.
+    await this.deleteBucketData(Bucket.allForks_dataColumnSidecars);
     // Prune all hot blocks
     // TODO: Enable once it's deemed safe
     // await this.block.batchDelete(await this.block.keys());

package/src/db/repositories/proposerSlashing.ts

@@ -1,6 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, Repository} from "@lodestar/db";
+import {BUCKET_LENGTH, Db, Repository} from "@lodestar/db";
 import {ValidatorIndex, phase0, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 export class ProposerSlashingRepository extends Repository<ValidatorIndex, phase0.ProposerSlashing> {
@@ -12,4 +13,8 @@ export class ProposerSlashingRepository extends Repository<ValidatorIndex, phase
   getId(value: phase0.ProposerSlashing): ValidatorIndex {
     return value.signedHeader1.message.proposerIndex;
   }
+
+  decodeKey(data: Uint8Array): ValidatorIndex {
+    return bytesToInt(data.subarray(BUCKET_LENGTH), "be");
+  }
 }

package/src/execution/engine/http.ts

@@ -516,12 +516,13 @@ export class ExecutionEngineHttp implements IExecutionEngine {
   ): Promise<(BlobAndProof | null)[]>;
   async getBlobs(
     fork: ForkName,
-    versionedHashes: VersionedHashes
+    versionedHashes: VersionedHashes,
+    buffers?: Uint8Array[]
   ): Promise<BlobAndProofV2[] | (BlobAndProof | null)[] | null> {
     assertReqSizeLimit(versionedHashes.length, MAX_VERSIONED_HASHES);
     const versionedHashesHex = versionedHashes.map(bytesToData);
     if (isForkPostFulu(fork)) {
-      return await this.getBlobsV2(versionedHashesHex);
+      return await this.getBlobsV2(versionedHashesHex, buffers);
     }
     return await this.getBlobsV1(versionedHashesHex);
   }
@@ -551,8 +552,9 @@ export class ExecutionEngineHttp implements IExecutionEngine {
 
   private async getBlobsV2(versionedHashesHex: string[], buffers?: Uint8Array[]) {
     if (buffers) {
-      if (buffers.length !== versionedHashesHex.length) {
-        throw Error(`Invalid buffers length=${buffers.length} versionedHashes=${versionedHashesHex.length}`);
+      // Callers preallocate one buffer per max blobs of the epoch, only the first entries are used
+      if (buffers.length < versionedHashesHex.length) {
+        throw Error(`Not enough buffers length=${buffers.length} versionedHashes=${versionedHashesHex.length}`);
       }
 
       for (const [i, buffer] of buffers.entries()) {

package/src/index.ts

@@ -2,7 +2,7 @@
 
 export type {RestApiServerMetrics, RestApiServerModules, RestApiServerOpts} from "./api/rest/base.js";
 export {RestApiServer} from "./api/rest/base.js";
-export {checkAndPersistAnchorState} from "./chain/index.js";
+export {persistAnchorState} from "./chain/index.js";
 export {DbCPStateDatastore} from "./chain/stateCache/datastore/db.js";
 export {FileCPStateDatastore} from "./chain/stateCache/datastore/file.js";
 export {BeaconDb, type IBeaconDb} from "./db/index.js";