@lodestar/beacon-node 1.49.0 → 1.50.0-dev.023ad6c012

package/src/api/impl/beacon/state/index.ts

@@ -441,5 +441,41 @@ export function getBeaconStateApi({
         meta: {executionOptimistic, finalized, version: fork},
       };
     },
+
+    async getBuilderPendingPayments({stateId}, context) {
+      const {state, executionOptimistic, finalized} = await getState(stateId);
+      const fork = state.forkName;
+
+      if (!isStatePostGloas(state)) {
+        throw new ApiError(400, `Cannot retrieve pending builder payments for pre-gloas state fork=${fork}`);
+      }
+
+      const builderPendingPayments = state.builderPendingPayments;
+
+      return {
+        data: context?.returnBytes
+          ? ssz.gloas.BuilderPendingPayments.serialize(builderPendingPayments)
+          : builderPendingPayments,
+        meta: {executionOptimistic, finalized, version: fork},
+      };
+    },
+
+    async getBuilderPendingWithdrawals({stateId}, context) {
+      const {state, executionOptimistic, finalized} = await getState(stateId);
+      const fork = state.forkName;
+
+      if (!isStatePostGloas(state)) {
+        throw new ApiError(400, `Cannot retrieve pending builder withdrawals for pre-gloas state fork=${fork}`);
+      }
+
+      const builderPendingWithdrawals = state.builderPendingWithdrawals;
+
+      return {
+        data: context?.returnBytes
+          ? ssz.gloas.BuilderPendingWithdrawals.serialize(builderPendingWithdrawals)
+          : builderPendingWithdrawals,
+        meta: {executionOptimistic, finalized, version: fork},
+      };
+    },
   };
 }

package/src/chain/archiveStore/archiveStore.ts

@@ -1,6 +1,7 @@
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {Slot} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
@@ -47,6 +48,8 @@ export class ArchiveStore {
   private jobQueue: JobItemQueue<[CheckpointWithHex], void>;
 
   private archiveDataEpochs?: number;
+  // Finalized state writes are monotonic; reset on restart to include the newly persisted anchor.
+  private statePruneFromSlot: Slot = 0;
   private readonly statesArchiverStrategy: StateArchiveStrategy;
   private readonly chain: IBeaconChain;
   private readonly db: IBeaconDb;
@@ -103,7 +106,7 @@ export class ArchiveStore {
     if (this.opts.pruneHistory) {
       // prune ALL stale data before starting
       this.logger.info("Pruning historical data");
-      const blockCutoffSlot = await callFnWhenAwait(
+      const {stateCutoffSlot} = await callFnWhenAwait(
         pruneHistory(
           this.chain.config,
           this.db,
@@ -116,7 +119,27 @@ export class ArchiveStore {
         30_000,
         this.signal
       );
-      this.chain.earliestAvailableSlot = Math.max(this.chain.earliestAvailableSlot, blockCutoffSlot);
+      this.statePruneFromSlot = stateCutoffSlot;
+    }
+
+    // Initialize earliestAvailableSlot from the earliest block actually retained (after any pruning
+    // above), rather than the anchor state slot set in the constructor. On an in-place restart the DB
+    // still holds finalized history below the anchor; leaving the value at the anchor makes the node
+    // reject by_range requests (beacon_blocks, execution_payload_envelopes and data_column_sidecars
+    // all gate on this slot) for data it still retains. An empty archive (e.g. a fresh checkpoint
+    // sync with nothing below the anchor) leaves the constructor's anchor slot in place.
+    const earliestArchivedBlockSlot = await this.db.blockArchive.firstKey();
+    if (earliestArchivedBlockSlot != null) {
+      const oldEarliestAvailableSlot = this.chain.earliestAvailableSlot;
+      this.chain.earliestAvailableSlot = earliestArchivedBlockSlot;
+      this.logger.verbose("Initialized earliestAvailableSlot from retained block archive", {
+        oldEarliestAvailableSlot,
+        newEarliestAvailableSlot: earliestArchivedBlockSlot,
+      });
+    } else {
+      this.logger.verbose("Empty block archive on init, keeping anchor earliestAvailableSlot", {
+        earliestAvailableSlot: this.chain.earliestAvailableSlot,
+      });
     }
 
     if (this.opts.serveHistoricalState) {
@@ -236,14 +259,16 @@ export class ArchiveStore {
 
       if (this.opts.pruneHistory) {
         timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
-        const blockCutoffSlot = await pruneHistory(
+        const {blockCutoffSlot, stateCutoffSlot} = await pruneHistory(
           this.chain.config,
           this.db,
           this.logger,
           this.metrics,
           finalizedEpoch,
-          this.chain.clock.currentEpoch
+          this.chain.clock.currentEpoch,
+          this.statePruneFromSlot
         );
+        this.statePruneFromSlot = stateCutoffSlot;
         this.chain.earliestAvailableSlot = Math.max(this.chain.earliestAvailableSlot, blockCutoffSlot);
         timer?.({source: ArchiveStoreTask.PruneHistory});
       }

package/src/chain/archiveStore/utils/pruneHistory.ts

@@ -11,8 +11,9 @@ export async function pruneHistory(
   logger: Logger,
   metrics: Metrics | null | undefined,
   finalizedEpoch: Epoch,
-  currentEpoch: Epoch
-): Promise<Slot> {
+  currentEpoch: Epoch,
+  statePruneFromSlot: Slot = 0
+): Promise<{blockCutoffSlot: Slot; stateCutoffSlot: Slot}> {
   const blockCutoffEpoch = Math.min(
     // set by config, with underflow protection
     Math.max(currentEpoch - config.MIN_EPOCHS_FOR_BLOCK_REQUESTS, 0),
@@ -28,6 +29,7 @@ export async function pruneHistory(
     currentEpoch,
     finalizedEpoch,
     blockCutoffEpoch,
+    statePruneFromSlot,
     stateCutoffSlot,
   });
 
@@ -35,7 +37,7 @@ export async function pruneHistory(
   const [blocks, envelopes, states] = await Promise.all([
     db.blockArchive.keys({gte: 0, lt: blockCutoffSlot}),
     db.executionPayloadEnvelopeArchive.keys({gte: 0, lt: blockCutoffSlot}),
-    db.stateArchive.keys({gte: 0, lt: stateCutoffSlot}),
+    stateCutoffSlot > statePruneFromSlot ? db.stateArchive.keys({gte: statePruneFromSlot, lt: stateCutoffSlot}) : [],
   ]);
   step0?.();
 
@@ -64,5 +66,5 @@ export async function pruneHistory(
 
   metrics?.pruneHistory.pruneCount.inc();
 
-  return blockCutoffSlot;
+  return {blockCutoffSlot, stateCutoffSlot};
 }

package/src/chain/blocks/importBlock.ts

@@ -538,6 +538,10 @@ export async function importBlock(
           block: blockRootHex,
           slot: blockSlot,
           executionOptimistic: blockSummary != null && isOptimisticBlock(blockSummary),
+          ...(isGloasBeaconBlock(block.message) && {
+            blockHash: toRootHex(block.message.body.signedExecutionPayloadBid.message.blockHash),
+            builderIndex: block.message.body.signedExecutionPayloadBid.message.builderIndex,
+          }),
         });
       }
       if (this.emitter.listenerCount(routes.events.EventType.voluntaryExit)) {

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

@@ -71,7 +71,7 @@ import {BufferPool} from "../util/bufferPool.js";
 import {Clock, ClockEvent, IClock} from "../util/clock.js";
 import {CustodyConfig, getValidatorsCustodyRequirement} from "../util/dataColumns.js";
 import {callInNextEventLoop} from "../util/eventLoop.js";
-import {ReconstructMismatchPolicy, isRebuildMiss, reconstructExecutionPayloadEnvelopes} from "../util/execution.js";
+import {ReconstructMissPolicy, isRebuildMiss, reconstructExecutionPayloadEnvelopes} from "../util/execution.js";
 import {ensureDir, writeIfNotExist} from "../util/file.js";
 import {isOptimisticBlock} from "../util/forkChoice.js";
 import {JobItemQueue} from "../util/queue/itemQueue.js";
@@ -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 */
@@ -934,12 +934,13 @@ export class BeaconChain implements IBeaconChain {
 
   /**
    * Batch variant: archived header envelopes are rebuilt 32 per EL round-trip. Aligned with `requests`.
-   * A body root mismatch is a local inconsistency: `"throw"` surfaces it, `"omit"` logs it and
-   * returns null for that entry, for peer-facing paths where the spec allows omission.
+   * An archived envelope that cannot be rebuilt (EL-unavailable body or body root mismatch) is not the
+   * same as an unknown one: `"throw"` surfaces it, `"omit"` returns null for that entry, for
+   * peer-facing paths where the spec allows omission.
    */
   async getSerializedExecutionPayloadEnvelopes(
     requests: {blockSlot: Slot; blockRootHex: RootHex}[],
-    onMismatch: ReconstructMismatchPolicy = "throw"
+    onMiss: ReconstructMissPolicy = "throw"
   ): Promise<(Uint8Array | null)[]> {
     const out: (Uint8Array | null)[] = new Array(requests.length).fill(null);
     const headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[] = [];
@@ -978,14 +979,14 @@ export class BeaconChain implements IBeaconChain {
       for (let j = 0; j < rebuilt.length; j++) {
         const result = rebuilt[j];
         if (isRebuildMiss(result)) {
-          if (result.reason === "mismatch") {
-            if (onMismatch === "throw") throw result.error;
-            this.logger.debug(
-              "Archived envelope failed body root check against EL bodies",
-              {slot: result.slot},
-              result.error
-            );
-          }
+          if (onMiss === "throw") throw result.error;
+          this.logger.debug(
+            result.reason === "mismatch"
+              ? "Archived envelope failed body root check against EL bodies"
+              : "EL cannot serve bodies for archived envelope, omitting",
+            {slot: result.slot},
+            result.error
+          );
           continue;
         }
         out[headerEnvelopeIdxs[j]] = ssz.gloas.SignedExecutionPayloadEnvelope.serialize(result);
@@ -1016,10 +1017,7 @@ export class BeaconChain implements IBeaconChain {
     const [result] = await reconstructExecutionPayloadEnvelopes(this.executionEngine, this.metrics, [
       archived.headerEnvelope,
     ]);
-    if (isRebuildMiss(result)) {
-      if (result.reason === "mismatch") throw result.error;
-      return null;
-    }
+    if (isRebuildMiss(result)) throw result.error;
     return result;
   }
 
@@ -1329,13 +1327,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/envelopeReconstructionError.ts

@@ -4,6 +4,8 @@ import {LodestarError} from "@lodestar/utils";
 export enum EnvelopeReconstructionErrorCode {
   /** The EL failed to answer engine_getPayloadBodiesByHashV2 (transport / EL down). Transient. */
   ENGINE_UNAVAILABLE = "ENVELOPE_RECONSTRUCTION_ERROR_ENGINE_UNAVAILABLE",
+  /** The EL does not have the block or its block access list (pruned, or not yet re-indexed after a restart). May recover. */
+  BODY_UNAVAILABLE = "ENVELOPE_RECONSTRUCTION_ERROR_BODY_UNAVAILABLE",
   /** A body returned by the EL does not hash to the root stored in the header envelope. Local DB/EL inconsistency. */
   BODY_ROOT_MISMATCH = "ENVELOPE_RECONSTRUCTION_ERROR_BODY_ROOT_MISMATCH",
   /** A by-range stream stopped short at a slot that cannot be served; the response so far is still valid */
@@ -12,6 +14,7 @@ export enum EnvelopeReconstructionErrorCode {
 
 export type EnvelopeReconstructionErrorType =
   | {code: EnvelopeReconstructionErrorCode.ENGINE_UNAVAILABLE}
+  | {code: EnvelopeReconstructionErrorCode.BODY_UNAVAILABLE; slot: Slot}
   | {
       code: EnvelopeReconstructionErrorCode.BODY_ROOT_MISMATCH;
       slot: Slot;

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/interface.ts

@@ -30,7 +30,7 @@ import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
 import {IClock} from "../util/clock.js";
 import {CustodyConfig} from "../util/dataColumns.js";
-import {ReconstructMismatchPolicy} from "../util/execution.js";
+import {ReconstructMissPolicy} from "../util/execution.js";
 import {SerializedCache} from "../util/serializedCache.js";
 import {IArchiveStore} from "./archiveStore/interface.js";
 import {CheckpointBalancesCache} from "./balancesCache.js";
@@ -239,7 +239,7 @@ export interface IBeaconChain {
   getSerializedExecutionPayloadEnvelope(blockSlot: Slot, blockRootHex: string): Promise<Uint8Array | null>;
   getSerializedExecutionPayloadEnvelopes(
     requests: {blockSlot: Slot; blockRootHex: RootHex}[],
-    onMismatch?: ReconstructMismatchPolicy
+    onMiss?: ReconstructMissPolicy
   ): Promise<(Uint8Array | null)[]>;
   getExecutionPayloadEnvelope(
     blockSlot: Slot,

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