@lodestar/beacon-node 1.50.0-dev.cea8fba405 → 1.50.0-dev.d86161f63c

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/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/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/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";

package/src/network/processor/gossipHandlers.ts

@@ -1065,12 +1065,12 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       const {serializedData} = gossipData;
       const {fork} = topic.boundary;
       const attesterSlashing = sszDeserialize(topic, serializedData);
-      await validateGossipAttesterSlashing(chain, attesterSlashing);
+      const verifiedDomains = await validateGossipAttesterSlashing(chain, attesterSlashing);
 
       // Handler - deferred to next event loop so the validation result propagates first
       callInNextEventLoop(() => {
         try {
-          chain.opPool.insertAttesterSlashing(fork, attesterSlashing);
+          chain.opPool.insertAttesterSlashing(fork, attesterSlashing, verifiedDomains);
           chain.forkChoice.onAttesterSlashing(attesterSlashing);
           chain.emitter.emit(routes.events.EventType.attesterSlashing, attesterSlashing);
         } catch (e) {
@@ -1089,12 +1089,12 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     }: GossipHandlerParamGeneric<GossipType.proposer_slashing>) => {
       const {serializedData} = gossipData;
       const proposerSlashing = sszDeserialize(topic, serializedData);
-      await validateGossipProposerSlashing(chain, proposerSlashing);
+      const verifiedDomain = await validateGossipProposerSlashing(chain, proposerSlashing);
 
       // Handler - deferred to next event loop so the validation result propagates first
       callInNextEventLoop(() => {
         try {
-          chain.opPool.insertProposerSlashing(proposerSlashing);
+          chain.opPool.insertProposerSlashing(proposerSlashing, verifiedDomain);
           chain.emitter.emit(routes.events.EventType.proposerSlashing, proposerSlashing);
         } catch (e) {
           logger.debug(