@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/chain/validation/signatureSets/syncCommittee.ts

@@ -0,0 +1,22 @@
+import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
+import {
+  CachedBeaconStateAllForks,
+  ISignatureSet,
+  SignatureSetType,
+  computeSigningRoot,
+} from "@lodestar/state-transition";
+import {altair, ssz} from "@lodestar/types";
+
+export function getSyncCommitteeSignatureSet(
+  state: CachedBeaconStateAllForks,
+  syncCommittee: altair.SyncCommitteeMessage
+): ISignatureSet {
+  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);
+
+  return {
+    type: SignatureSetType.single,
+    pubkey: state.epochCtx.index2pubkey[syncCommittee.validatorIndex],
+    signingRoot: computeSigningRoot(ssz.Root, syncCommittee.beaconBlockRoot, domain),
+    signature: syncCommittee.signature,
+  };
+}

package/src/chain/validation/signatureSets/syncCommitteeContribution.ts

@@ -0,0 +1,18 @@
+import {PublicKey} from "@chainsafe/blst";
+import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
+import {CachedBeaconStateAltair, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
+import {altair, ssz} from "@lodestar/types";
+
+export function getSyncCommitteeContributionSignatureSet(
+  state: CachedBeaconStateAltair,
+  contribution: altair.SyncCommitteeContribution,
+  pubkeys: PublicKey[]
+): ISignatureSet {
+  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, contribution.slot);
+  return {
+    type: SignatureSetType.aggregate,
+    pubkeys,
+    signingRoot: computeSigningRoot(ssz.Root, contribution.beaconBlockRoot, domain),
+    signature: contribution.signature,
+  };
+}

package/src/chain/validation/signatureSets/syncCommitteeSelectionProof.ts

@@ -0,0 +1,27 @@
+import {DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF} from "@lodestar/params";
+import {
+  CachedBeaconStateAllForks,
+  ISignatureSet,
+  SignatureSetType,
+  computeSigningRoot,
+} from "@lodestar/state-transition";
+import {altair, ssz} from "@lodestar/types";
+
+export function getSyncCommitteeSelectionProofSignatureSet(
+  state: CachedBeaconStateAllForks,
+  contributionAndProof: altair.ContributionAndProof
+): ISignatureSet {
+  const {epochCtx, config} = state;
+  const slot = contributionAndProof.contribution.slot;
+  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF, slot);
+  const signingData: altair.SyncAggregatorSelectionData = {
+    slot,
+    subcommitteeIndex: contributionAndProof.contribution.subcommitteeIndex,
+  };
+  return {
+    type: SignatureSetType.single,
+    pubkey: epochCtx.index2pubkey[contributionAndProof.aggregatorIndex],
+    signingRoot: computeSigningRoot(ssz.altair.SyncAggregatorSelectionData, signingData, domain),
+    signature: contributionAndProof.selectionProof,
+  };
+}

package/src/chain/validation/syncCommittee.ts

@@ -0,0 +1,165 @@
+import {SYNC_COMMITTEE_SUBNET_COUNT, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
+import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {SubnetID, altair} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {GossipAction, SyncCommitteeError, SyncCommitteeErrorCode} from "../errors/index.js";
+import {IBeaconChain} from "../interface.js";
+import {getSyncCommitteeSignatureSet} from "./signatureSets/index.js";
+
+type IndexInSubcommittee = number;
+
+/**
+ * Spec v1.1.0-alpha.8
+ */
+export async function validateGossipSyncCommittee(
+  chain: IBeaconChain,
+  syncCommittee: altair.SyncCommitteeMessage,
+  subnet: SubnetID
+): Promise<{indexInSubcommittee: IndexInSubcommittee}> {
+  const {slot, validatorIndex, beaconBlockRoot} = syncCommittee;
+  const messageRoot = toRootHex(beaconBlockRoot);
+
+  const headState = chain.getHeadState();
+  const indexInSubcommittee = validateGossipSyncCommitteeExceptSig(chain, headState, subnet, syncCommittee);
+
+  // [IGNORE] The signature's slot is for the current slot, i.e. sync_committee_signature.slot == current_slot.
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state,
+  // sync_committee_message.validator_index). Note this validation implies the validator is part of the broader current
+  // sync committee along with the correct subcommittee.
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  // [IGNORE] There has been no other valid sync committee signature for the declared slot for the validator referenced
+  // by sync_committee_signature.validator_index.
+  const prevRoot = chain.seenSyncCommitteeMessages.get(slot, subnet, validatorIndex);
+  if (prevRoot) {
+    let shouldIgnore = false;
+    if (prevRoot === messageRoot) {
+      shouldIgnore = true;
+    } else {
+      const headRoot = chain.forkChoice.getHeadRoot();
+      chain.metrics?.gossipSyncCommittee.equivocationCount.inc();
+      if (messageRoot === headRoot) {
+        chain.metrics?.gossipSyncCommittee.equivocationToHeadCount.inc();
+      } else {
+        shouldIgnore = true;
+      }
+    }
+
+    if (shouldIgnore) {
+      throw new SyncCommitteeError(GossipAction.IGNORE, {
+        code: SyncCommitteeErrorCode.SYNC_COMMITTEE_MESSAGE_KNOWN,
+        validatorIndex,
+        slot,
+        prevRoot,
+        newRoot: messageRoot,
+      });
+    }
+  }
+
+  // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state, sync_committee_signature.validator_index).
+  // Note this validation implies the validator is part of the broader current sync committee along with the correct subcommittee.
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  // [REJECT] The signature is valid for the message beacon_block_root for the validator referenced by validator_index.
+  await validateSyncCommitteeSigOnly(chain, headState, syncCommittee);
+
+  // Register this valid item as seen
+  chain.seenSyncCommitteeMessages.add(slot, subnet, validatorIndex, messageRoot);
+
+  return {indexInSubcommittee};
+}
+
+export async function validateApiSyncCommittee(
+  chain: IBeaconChain,
+  headState: CachedBeaconStateAllForks,
+  syncCommittee: altair.SyncCommitteeMessage
+): Promise<void> {
+  const prioritizeBls = true;
+  return validateSyncCommitteeSigOnly(chain, headState, syncCommittee, prioritizeBls);
+}
+
+/**
+ * Abstracted so it can be re-used in API validation.
+ */
+async function validateSyncCommitteeSigOnly(
+  chain: IBeaconChain,
+  headState: CachedBeaconStateAllForks,
+  syncCommittee: altair.SyncCommitteeMessage,
+  prioritizeBls = false
+): Promise<void> {
+  const signatureSet = getSyncCommitteeSignatureSet(headState, syncCommittee);
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
+    throw new SyncCommitteeError(GossipAction.REJECT, {
+      code: SyncCommitteeErrorCode.INVALID_SIGNATURE,
+    });
+  }
+}
+
+/**
+ * Spec v1.1.0-alpha.8
+ */
+export function validateGossipSyncCommitteeExceptSig(
+  chain: IBeaconChain,
+  headState: CachedBeaconStateAllForks,
+  subnet: SubnetID,
+  data: Pick<altair.SyncCommitteeMessage, "slot" | "validatorIndex">
+): IndexInSubcommittee {
+  const {slot, validatorIndex} = data;
+  // [IGNORE] The signature's slot is for the current slot, i.e. sync_committee_signature.slot == current_slot.
+  // (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
+  if (!chain.clock.isCurrentSlotGivenGossipDisparity(slot)) {
+    throw new SyncCommitteeError(GossipAction.IGNORE, {
+      code: SyncCommitteeErrorCode.NOT_CURRENT_SLOT,
+      currentSlot: chain.clock.currentSlot,
+      slot,
+    });
+  }
+
+  // [REJECT] The subcommittee index is in the allowed range, i.e. contribution.subcommittee_index < SYNC_COMMITTEE_SUBNET_COUNT.
+  if (subnet >= SYNC_COMMITTEE_SUBNET_COUNT) {
+    throw new SyncCommitteeError(GossipAction.REJECT, {
+      code: SyncCommitteeErrorCode.INVALID_SUBCOMMITTEE_INDEX,
+      subcommitteeIndex: subnet,
+    });
+  }
+
+  // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state, sync_committee_signature.validator_index).
+  // Note this validation implies the validator is part of the broader current sync committee along with the correct subcommittee.
+  const indexInSubcommittee = getIndexInSubcommittee(headState, subnet, data);
+  if (indexInSubcommittee === null) {
+    throw new SyncCommitteeError(GossipAction.REJECT, {
+      code: SyncCommitteeErrorCode.VALIDATOR_NOT_IN_SYNC_COMMITTEE,
+      validatorIndex,
+    });
+  }
+
+  return indexInSubcommittee;
+}
+
+/**
+ * Returns the IndexInSubcommittee of the given `subnet`.
+ * Returns `null` if not part of the sync committee or not part of the given `subnet`
+ */
+function getIndexInSubcommittee(
+  headState: CachedBeaconStateAllForks,
+  subnet: SubnetID,
+  data: Pick<altair.SyncCommitteeMessage, "slot" | "validatorIndex">
+): IndexInSubcommittee | null {
+  const syncCommittee = headState.epochCtx.getIndexedSyncCommittee(data.slot);
+  const indexesInCommittee = syncCommittee.validatorIndexMap.get(data.validatorIndex);
+  if (indexesInCommittee === undefined) {
+    // Not part of the sync committee
+    return null;
+  }
+
+  for (const indexInCommittee of indexesInCommittee) {
+    if (Math.floor(indexInCommittee / SYNC_COMMITTEE_SUBNET_SIZE) === subnet) {
+      return indexInCommittee % SYNC_COMMITTEE_SUBNET_SIZE;
+    }
+  }
+
+  // Not part of this specific subnet
+  return null;
+}

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -0,0 +1,122 @@
+import {SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
+import {CachedBeaconStateAltair, isSyncCommitteeAggregator} from "@lodestar/state-transition";
+import {ValidatorIndex, altair} from "@lodestar/types";
+import {GossipAction, SyncCommitteeError, SyncCommitteeErrorCode} from "../errors/index.js";
+import {IBeaconChain} from "../interface.js";
+import {
+  getContributionAndProofSignatureSet,
+  getSyncCommitteeContributionSignatureSet,
+  getSyncCommitteeSelectionProofSignatureSet,
+} from "./signatureSets/index.js";
+import {validateGossipSyncCommitteeExceptSig} from "./syncCommittee.js";
+
+/**
+ * Spec v1.1.0-beta.2
+ */
+export async function validateSyncCommitteeGossipContributionAndProof(
+  chain: IBeaconChain,
+  signedContributionAndProof: altair.SignedContributionAndProof,
+  skipValidationKnownParticipants = false
+): Promise<{syncCommitteeParticipantIndices: ValidatorIndex[]}> {
+  const contributionAndProof = signedContributionAndProof.message;
+  const {contribution, aggregatorIndex} = contributionAndProof;
+  const {subcommitteeIndex, slot} = contribution;
+
+  const headState = chain.getHeadState();
+  validateGossipSyncCommitteeExceptSig(chain, headState, subcommitteeIndex, {
+    slot,
+    validatorIndex: contributionAndProof.aggregatorIndex,
+  });
+
+  // [IGNORE] The contribution's slot is for the current slot, i.e. contribution.slot == current_slot.
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  // [REJECT] The aggregator's validator index is in the declared subcommittee of the current sync committee
+  // -- i.e. state.validators[contribution_and_proof.aggregator_index].pubkey in
+  // get_sync_subcommittee_pubkeys(state, contribution.subcommittee_index).
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  // _[IGNORE]_ A valid sync committee contribution with equal `slot`, `beacon_block_root` and `subcommittee_index` whose
+  // `aggregation_bits` is non-strict superset has _not_ already been seen.
+  if (!skipValidationKnownParticipants && chain.seenContributionAndProof.participantsKnown(contribution)) {
+    throw new SyncCommitteeError(GossipAction.IGNORE, {
+      code: SyncCommitteeErrorCode.SYNC_COMMITTEE_PARTICIPANTS_ALREADY_KNOWN,
+    });
+  }
+
+  // [IGNORE] The sync committee contribution is the first valid contribution received for the aggregator with index
+  // contribution_and_proof.aggregator_index for the slot contribution.slot and subcommittee index contribution.subcommittee_index.
+  if (chain.seenContributionAndProof.isAggregatorKnown(slot, subcommitteeIndex, aggregatorIndex)) {
+    throw new SyncCommitteeError(GossipAction.IGNORE, {
+      code: SyncCommitteeErrorCode.SYNC_COMMITTEE_AGGREGATOR_ALREADY_KNOWN,
+    });
+  }
+
+  // [REJECT] The contribution has participants -- that is, any(contribution.aggregation_bits)
+  const syncCommitteeParticipantIndices = getContributionIndices(headState as CachedBeaconStateAltair, contribution);
+  if (syncCommitteeParticipantIndices.length === 0) {
+    throw new SyncCommitteeError(GossipAction.REJECT, {
+      code: SyncCommitteeErrorCode.NO_PARTICIPANT,
+    });
+  }
+
+  // [REJECT] contribution_and_proof.selection_proof selects the validator as an aggregator for the slot --
+  // i.e. is_sync_committee_aggregator(contribution_and_proof.selection_proof) returns True.
+  if (!isSyncCommitteeAggregator(contributionAndProof.selectionProof)) {
+    throw new SyncCommitteeError(GossipAction.REJECT, {
+      code: SyncCommitteeErrorCode.INVALID_AGGREGATOR,
+      aggregatorIndex: contributionAndProof.aggregatorIndex,
+    });
+  }
+
+  // [REJECT] The aggregator's validator index is in the declared subcommittee of the current sync committee --
+  // i.e. state.validators[contribution_and_proof.aggregator_index].pubkey in get_sync_subcommittee_pubkeys(state, contribution.subcommittee_index).
+  // > Checked in validateGossipSyncCommitteeExceptSig()
+
+  const participantPubkeys = syncCommitteeParticipantIndices.map(
+    (validatorIndex) => headState.epochCtx.index2pubkey[validatorIndex]
+  );
+  const signatureSets = [
+    // [REJECT] The contribution_and_proof.selection_proof is a valid signature of the SyncAggregatorSelectionData
+    // derived from the contribution by the validator with index contribution_and_proof.aggregator_index.
+    getSyncCommitteeSelectionProofSignatureSet(headState, contributionAndProof),
+
+    // [REJECT] The aggregator signature, signed_contribution_and_proof.signature, is valid.
+    getContributionAndProofSignatureSet(headState, signedContributionAndProof),
+
+    // [REJECT] The aggregate signature is valid for the message beacon_block_root and aggregate pubkey derived from
+    // the participation info in aggregation_bits for the subcommittee specified by the contribution.subcommittee_index.
+    getSyncCommitteeContributionSignatureSet(headState as CachedBeaconStateAltair, contribution, participantPubkeys),
+  ];
+
+  if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true}))) {
+    throw new SyncCommitteeError(GossipAction.REJECT, {
+      code: SyncCommitteeErrorCode.INVALID_SIGNATURE,
+    });
+  }
+
+  // no need to add to seenSyncCommittteeContributionCache here, gossip handler will do that
+  chain.seenContributionAndProof.add(contributionAndProof, syncCommitteeParticipantIndices.length);
+
+  return {syncCommitteeParticipantIndices};
+}
+
+/**
+ * Retrieve pubkeys in contribution aggregate using epochCtx:
+ * - currSyncCommitteeIndexes cache
+ * - index2pubkey cache
+ */
+function getContributionIndices(
+  state: CachedBeaconStateAltair,
+  contribution: altair.SyncCommitteeContribution
+): ValidatorIndex[] {
+  const startIndex = contribution.subcommitteeIndex * SYNC_COMMITTEE_SUBNET_SIZE;
+
+  const syncCommittee = state.epochCtx.getIndexedSyncCommittee(contribution.slot);
+  // The bits in contribution.aggregationBits select validatorIndexes in the subcommittee starting at startIndex
+  const subcommitteeValidatorIndices = syncCommittee.validatorIndices.slice(
+    startIndex,
+    startIndex + SYNC_COMMITTEE_SUBNET_SIZE
+  );
+  return contribution.aggregationBits.intersectValues(subcommitteeValidatorIndices);
+}

package/src/chain/validation/voluntaryExit.ts

@@ -0,0 +1,58 @@
+import {getVoluntaryExitSignatureSet, isValidVoluntaryExit} from "@lodestar/state-transition";
+import {phase0} from "@lodestar/types";
+import {GossipAction, VoluntaryExitError, VoluntaryExitErrorCode} from "../errors/index.js";
+import {IBeaconChain} from "../index.js";
+import {RegenCaller} from "../regen/index.js";
+
+export async function validateApiVoluntaryExit(
+  chain: IBeaconChain,
+  voluntaryExit: phase0.SignedVoluntaryExit
+): Promise<void> {
+  const prioritizeBls = true;
+  return validateVoluntaryExit(chain, voluntaryExit, prioritizeBls);
+}
+
+export async function validateGossipVoluntaryExit(
+  chain: IBeaconChain,
+  voluntaryExit: phase0.SignedVoluntaryExit
+): Promise<void> {
+  return validateVoluntaryExit(chain, voluntaryExit);
+}
+
+async function validateVoluntaryExit(
+  chain: IBeaconChain,
+  voluntaryExit: phase0.SignedVoluntaryExit,
+  prioritizeBls = false
+): Promise<void> {
+  // [IGNORE] The voluntary exit is the first valid voluntary exit received for the validator with index
+  // signed_voluntary_exit.message.validator_index.
+  if (chain.opPool.hasSeenVoluntaryExit(voluntaryExit.message.validatorIndex)) {
+    throw new VoluntaryExitError(GossipAction.IGNORE, {
+      code: VoluntaryExitErrorCode.ALREADY_EXISTS,
+    });
+  }
+
+  // What state should the voluntaryExit validate against?
+  //
+  // The only condition that is time sensitive and may require a non-head state is
+  // -> Validator is active && validator has not initiated exit
+  // The voluntaryExit.epoch must be in the past but the validator's status may change in recent epochs.
+  // We dial the head state to the current epoch to get the current status of the validator. This is
+  // relevant on periods of many skipped slots.
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipVoluntaryExit);
+
+  // [REJECT] All of the conditions within process_voluntary_exit pass validation.
+  // verifySignature = false, verified in batch below
+  if (!isValidVoluntaryExit(chain.config.getForkSeq(state.slot), state, voluntaryExit, false)) {
+    throw new VoluntaryExitError(GossipAction.REJECT, {
+      code: VoluntaryExitErrorCode.INVALID,
+    });
+  }
+
+  const signatureSet = getVoluntaryExitSignatureSet(state, voluntaryExit);
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
+    throw new VoluntaryExitError(GossipAction.REJECT, {
+      code: VoluntaryExitErrorCode.INVALID_SIGNATURE,
+    });
+  }
+}