@lodestar/state-transition 1.35.0-dev.e18102ed8c → 1.35.0-dev.f45a2be721

package/src/block/processSyncCommittee.ts

@@ -0,0 +1,117 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
+import {altair, ssz} from "@lodestar/types";
+import {G2_POINT_AT_INFINITY} from "../constants/index.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {
+  ISignatureSet,
+  SignatureSetType,
+  computeSigningRoot,
+  decreaseBalance,
+  increaseBalance,
+  verifySignatureSet,
+} from "../util/index.js";
+
+export function processSyncAggregate(
+  state: CachedBeaconStateAllForks,
+  block: altair.BeaconBlock,
+  verifySignatures = true
+): void {
+  const committeeIndices = state.epochCtx.currentSyncCommitteeIndexed.validatorIndices;
+
+  // different from the spec but not sure how to get through signature verification for default/empty SyncAggregate in the spec test
+  if (verifySignatures) {
+    // This is to conform to the spec - we want the signature to be verified
+    const participantIndices = block.body.syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
+    const signatureSet = getSyncCommitteeSignatureSet(state, block, participantIndices);
+    // When there's no participation we consider the signature valid and just ignore i
+    if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
+      throw Error("Sync committee signature invalid");
+    }
+  }
+
+  const {syncParticipantReward, syncProposerReward} = state.epochCtx;
+  const {syncCommitteeBits} = block.body.syncAggregate;
+  const proposerIndex = state.epochCtx.getBeaconProposer(state.slot);
+  let proposerBalance = state.balances.get(proposerIndex);
+
+  for (let i = 0; i < SYNC_COMMITTEE_SIZE; i++) {
+    const index = committeeIndices[i];
+
+    if (syncCommitteeBits.get(i)) {
+      // Positive rewards for participants
+      if (index === proposerIndex) {
+        proposerBalance += syncParticipantReward;
+      } else {
+        increaseBalance(state, index, syncParticipantReward);
+      }
+      // Proposer reward
+      proposerBalance += syncProposerReward;
+      state.proposerRewards.syncAggregate += syncProposerReward;
+    } else {
+      // Negative rewards for non participants
+      if (index === proposerIndex) {
+        proposerBalance = Math.max(0, proposerBalance - syncParticipantReward);
+      } else {
+        decreaseBalance(state, index, syncParticipantReward);
+      }
+    }
+  }
+
+  // Apply proposer balance
+  state.balances.set(proposerIndex, proposerBalance);
+}
+
+export function getSyncCommitteeSignatureSet(
+  state: CachedBeaconStateAllForks,
+  block: altair.BeaconBlock,
+  /** Optional parameter to prevent computing it twice */
+  participantIndices?: number[]
+): ISignatureSet | null {
+  const {epochCtx} = state;
+  const {syncAggregate} = block.body;
+  const signature = syncAggregate.syncCommitteeSignature;
+
+  // The spec uses the state to get the previous slot
+  // ```python
+  // previous_slot = max(state.slot, Slot(1)) - Slot(1)
+  // ```
+  // However we need to run the function getSyncCommitteeSignatureSet() for all the blocks in a epoch
+  // with the same state when verifying blocks in batch on RangeSync. Therefore we use the block.slot.
+  const previousSlot = Math.max(block.slot, 1) - 1;
+
+  // The spec uses the state to get the root at previousSlot
+  // ```python
+  // get_block_root_at_slot(state, previous_slot)
+  // ```
+  // However we need to run the function getSyncCommitteeSignatureSet() for all the blocks in a epoch
+  // with the same state when verifying blocks in batch on RangeSync.
+  //
+  // On skipped slots state block roots just copy the latest block, so using the parentRoot here is equivalent.
+  // So getSyncCommitteeSignatureSet() can be called with a state in any slot (with the correct shuffling)
+  const rootSigned = block.parentRoot;
+
+  if (!participantIndices) {
+    const committeeIndices = state.epochCtx.currentSyncCommitteeIndexed.validatorIndices;
+    participantIndices = syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
+  }
+
+  // When there's no participation we consider the signature valid and just ignore it
+  if (participantIndices.length === 0) {
+    // Must set signature as G2_POINT_AT_INFINITY when participating bits are empty
+    // https://github.com/ethereum/eth2.0-specs/blob/30f2a076377264677e27324a8c3c78c590ae5e20/specs/altair/bls.md#eth2_fast_aggregate_verify
+    if (byteArrayEquals(signature, G2_POINT_AT_INFINITY)) {
+      return null;
+    }
+    throw Error("Empty sync committee signature is not infinity");
+  }
+
+  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, previousSlot);
+
+  return {
+    type: SignatureSetType.aggregate,
+    pubkeys: participantIndices.map((i) => epochCtx.index2pubkey[i]),
+    signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
+    signature,
+  };
+}

package/src/block/processVoluntaryExit.ts

@@ -0,0 +1,55 @@
+import {FAR_FUTURE_EPOCH, ForkSeq} from "@lodestar/params";
+import {phase0} from "@lodestar/types";
+import {verifyVoluntaryExitSignature} from "../signatureSets/index.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
+import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/index.js";
+import {initiateValidatorExit} from "./index.js";
+
+/**
+ * Process a VoluntaryExit operation. Initiates the exit of a validator.
+ *
+ * PERF: Work depends on number of VoluntaryExit per block. On regular networks the average is 0 / block.
+ */
+export function processVoluntaryExit(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit,
+  verifySignature = true
+): void {
+  if (!isValidVoluntaryExit(fork, state, signedVoluntaryExit, verifySignature)) {
+    throw Error(`Invalid voluntary exit at forkSeq=${fork}`);
+  }
+
+  const validator = state.validators.get(signedVoluntaryExit.message.validatorIndex);
+  initiateValidatorExit(fork, state, validator);
+}
+
+export function isValidVoluntaryExit(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  signedVoluntaryExit: phase0.SignedVoluntaryExit,
+  verifySignature = true
+): boolean {
+  const {config, epochCtx} = state;
+  const voluntaryExit = signedVoluntaryExit.message;
+  const validator = state.validators.get(voluntaryExit.validatorIndex);
+  const currentEpoch = epochCtx.epoch;
+
+  return (
+    // verify the validator is active
+    isActiveValidator(validator, currentEpoch) &&
+    // verify exit has not been initiated
+    validator.exitEpoch === FAR_FUTURE_EPOCH &&
+    // exits must specify an epoch when they become valid; they are not valid before then
+    currentEpoch >= voluntaryExit.epoch &&
+    // verify the validator had been active long enough
+    currentEpoch >= validator.activationEpoch + config.SHARD_COMMITTEE_PERIOD &&
+    (fork >= ForkSeq.electra
+      ? // only exit validator if it has no pending withdrawals in the queue
+        getPendingBalanceToWithdraw(state as CachedBeaconStateElectra, voluntaryExit.validatorIndex) === 0
+      : // there are no pending withdrawals in previous forks
+        true) &&
+    // verify signature
+    (!verifySignature || verifyVoluntaryExitSignature(state, signedVoluntaryExit))
+  );
+}

package/src/block/processWithdrawalRequest.ts

@@ -0,0 +1,98 @@
+import {
+  FAR_FUTURE_EPOCH,
+  FULL_EXIT_REQUEST_AMOUNT,
+  ForkSeq,
+  MIN_ACTIVATION_BALANCE,
+  PENDING_PARTIAL_WITHDRAWALS_LIMIT,
+} from "@lodestar/params";
+import {electra, phase0, ssz} from "@lodestar/types";
+import {toHex} from "@lodestar/utils";
+import {CachedBeaconStateElectra} from "../types.js";
+import {hasCompoundingWithdrawalCredential, hasExecutionWithdrawalCredential} from "../util/electra.js";
+import {computeExitEpochAndUpdateChurn} from "../util/epoch.js";
+import {getPendingBalanceToWithdraw, isActiveValidator} from "../util/validator.js";
+import {initiateValidatorExit} from "./initiateValidatorExit.js";
+
+export function processWithdrawalRequest(
+  fork: ForkSeq,
+  state: CachedBeaconStateElectra,
+  withdrawalRequest: electra.WithdrawalRequest
+): void {
+  const amount = Number(withdrawalRequest.amount);
+  const {pendingPartialWithdrawals, validators, epochCtx} = state;
+  // no need to use unfinalized pubkey cache from 6110 as validator won't be active anyway
+  const {pubkey2index, config} = epochCtx;
+  const isFullExitRequest = amount === FULL_EXIT_REQUEST_AMOUNT;
+
+  // If partial withdrawal queue is full, only full exits are processed
+  if (pendingPartialWithdrawals.length >= PENDING_PARTIAL_WITHDRAWALS_LIMIT && !isFullExitRequest) {
+    return;
+  }
+
+  // bail out if validator is not in beacon state
+  // note that we don't need to check for 6110 unfinalized vals as they won't be eligible for withdraw/exit anyway
+  const validatorIndex = pubkey2index.get(withdrawalRequest.validatorPubkey);
+  if (validatorIndex === null) {
+    return;
+  }
+
+  const validator = validators.get(validatorIndex);
+  if (!isValidatorEligibleForWithdrawOrExit(validator, withdrawalRequest.sourceAddress, state)) {
+    return;
+  }
+
+  // TODO Electra: Consider caching pendingPartialWithdrawals
+  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(state, validatorIndex);
+  const validatorBalance = state.balances.get(validatorIndex);
+
+  if (isFullExitRequest) {
+    // only exit validator if it has no pending withdrawals in the queue
+    if (pendingBalanceToWithdraw === 0) {
+      initiateValidatorExit(fork, state, validator);
+    }
+    return;
+  }
+
+  // partial withdrawal request
+  const hasSufficientEffectiveBalance = validator.effectiveBalance >= MIN_ACTIVATION_BALANCE;
+  const hasExcessBalance = validatorBalance > MIN_ACTIVATION_BALANCE + pendingBalanceToWithdraw;
+
+  // Only allow partial withdrawals with compounding withdrawal credentials
+  if (
+    hasCompoundingWithdrawalCredential(validator.withdrawalCredentials) &&
+    hasSufficientEffectiveBalance &&
+    hasExcessBalance
+  ) {
+    const amountToWithdraw = BigInt(
+      Math.min(validatorBalance - MIN_ACTIVATION_BALANCE - pendingBalanceToWithdraw, amount)
+    );
+    const exitQueueEpoch = computeExitEpochAndUpdateChurn(state, amountToWithdraw);
+    const withdrawableEpoch = exitQueueEpoch + config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY;
+
+    const pendingPartialWithdrawal = ssz.electra.PendingPartialWithdrawal.toViewDU({
+      validatorIndex,
+      amount: amountToWithdraw,
+      withdrawableEpoch,
+    });
+    state.pendingPartialWithdrawals.push(pendingPartialWithdrawal);
+  }
+}
+
+function isValidatorEligibleForWithdrawOrExit(
+  validator: phase0.Validator,
+  sourceAddress: Uint8Array,
+  state: CachedBeaconStateElectra
+): boolean {
+  const {withdrawalCredentials} = validator;
+  const addressStr = toHex(withdrawalCredentials.subarray(12));
+  const sourceAddressStr = toHex(sourceAddress);
+  const {epoch: currentEpoch, config} = state.epochCtx;
+
+  return (
+    hasExecutionWithdrawalCredential(withdrawalCredentials) &&
+    addressStr === sourceAddressStr &&
+    isActiveValidator(validator, currentEpoch) &&
+    validator.exitEpoch === FAR_FUTURE_EPOCH &&
+    currentEpoch >= validator.activationEpoch + config.SHARD_COMMITTEE_PERIOD
+  );
+}

package/src/block/processWithdrawals.ts

@@ -0,0 +1,207 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {
+  FAR_FUTURE_EPOCH,
+  ForkSeq,
+  MAX_EFFECTIVE_BALANCE,
+  MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
+  MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP,
+  MAX_WITHDRAWALS_PER_PAYLOAD,
+  MIN_ACTIVATION_BALANCE,
+} from "@lodestar/params";
+import {ValidatorIndex, capella, ssz} from "@lodestar/types";
+import {MapDef, toRootHex} from "@lodestar/utils";
+import {CachedBeaconStateCapella, CachedBeaconStateElectra} from "../types.js";
+import {
+  decreaseBalance,
+  getMaxEffectiveBalance,
+  hasEth1WithdrawalCredential,
+  hasExecutionWithdrawalCredential,
+  isCapellaPayloadHeader,
+} from "../util/index.js";
+
+export function processWithdrawals(
+  fork: ForkSeq,
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra,
+  payload: capella.FullOrBlindedExecutionPayload
+): void {
+  // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+  const {withdrawals: expectedWithdrawals, processedPartialWithdrawalsCount} = getExpectedWithdrawals(fork, state);
+  const numWithdrawals = expectedWithdrawals.length;
+
+  if (isCapellaPayloadHeader(payload)) {
+    const expectedWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(expectedWithdrawals);
+    const actualWithdrawalsRoot = payload.withdrawalsRoot;
+    if (!byteArrayEquals(expectedWithdrawalsRoot, actualWithdrawalsRoot)) {
+      throw Error(
+        `Invalid withdrawalsRoot of executionPayloadHeader, expected=${toRootHex(
+          expectedWithdrawalsRoot
+        )}, actual=${toRootHex(actualWithdrawalsRoot)}`
+      );
+    }
+  } else {
+    if (expectedWithdrawals.length !== payload.withdrawals.length) {
+      throw Error(`Invalid withdrawals length expected=${numWithdrawals} actual=${payload.withdrawals.length}`);
+    }
+    for (let i = 0; i < numWithdrawals; i++) {
+      const withdrawal = expectedWithdrawals[i];
+      if (!ssz.capella.Withdrawal.equals(withdrawal, payload.withdrawals[i])) {
+        throw Error(`Withdrawal mismatch at index=${i}`);
+      }
+    }
+  }
+
+  for (let i = 0; i < numWithdrawals; i++) {
+    const withdrawal = expectedWithdrawals[i];
+    decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
+  }
+
+  if (fork >= ForkSeq.electra) {
+    const stateElectra = state as CachedBeaconStateElectra;
+    stateElectra.pendingPartialWithdrawals = stateElectra.pendingPartialWithdrawals.sliceFrom(
+      processedPartialWithdrawalsCount
+    );
+  }
+
+  // Update the nextWithdrawalIndex
+  const latestWithdrawal = expectedWithdrawals.at(-1);
+  if (latestWithdrawal) {
+    state.nextWithdrawalIndex = latestWithdrawal.index + 1;
+  }
+
+  // Update the nextWithdrawalValidatorIndex
+  if (latestWithdrawal && expectedWithdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
+    // All slots filled, nextWithdrawalValidatorIndex should be validatorIndex having next turn
+    state.nextWithdrawalValidatorIndex = (latestWithdrawal.validatorIndex + 1) % state.validators.length;
+  } else {
+    // expected withdrawals came up short in the bound, so we move nextWithdrawalValidatorIndex to
+    // the next post the bound
+    state.nextWithdrawalValidatorIndex =
+      (state.nextWithdrawalValidatorIndex + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP) % state.validators.length;
+  }
+}
+
+export function getExpectedWithdrawals(
+  fork: ForkSeq,
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra
+): {
+  withdrawals: capella.Withdrawal[];
+  sampledValidators: number;
+  processedPartialWithdrawalsCount: number;
+} {
+  if (fork < ForkSeq.capella) {
+    throw new Error(`getExpectedWithdrawals not supported at forkSeq=${fork} < ForkSeq.capella`);
+  }
+
+  const epoch = state.epochCtx.epoch;
+  let withdrawalIndex = state.nextWithdrawalIndex;
+  const {validators, balances, nextWithdrawalValidatorIndex} = state;
+
+  const withdrawals: capella.Withdrawal[] = [];
+  const withdrawnBalances = new MapDef<ValidatorIndex, number>(() => 0);
+  const isPostElectra = fork >= ForkSeq.electra;
+  // partialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+  let processedPartialWithdrawalsCount = 0;
+
+  if (isPostElectra) {
+    const stateElectra = state as CachedBeaconStateElectra;
+
+    // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
+    // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
+    // also we may break early if withdrawableEpoch > epoch
+    const allPendingPartialWithdrawals =
+      stateElectra.pendingPartialWithdrawals.length <= MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
+        ? stateElectra.pendingPartialWithdrawals.getAllReadonly()
+        : null;
+
+    // EIP-7002: Execution layer triggerable withdrawals
+    for (let i = 0; i < stateElectra.pendingPartialWithdrawals.length; i++) {
+      const withdrawal = allPendingPartialWithdrawals
+        ? allPendingPartialWithdrawals[i]
+        : stateElectra.pendingPartialWithdrawals.getReadonly(i);
+      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length === MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP) {
+        break;
+      }
+
+      const validator = validators.getReadonly(withdrawal.validatorIndex);
+      const totalWithdrawn = withdrawnBalances.getOrDefault(withdrawal.validatorIndex);
+      const balance = state.balances.get(withdrawal.validatorIndex) - totalWithdrawn;
+
+      if (
+        validator.exitEpoch === FAR_FUTURE_EPOCH &&
+        validator.effectiveBalance >= MIN_ACTIVATION_BALANCE &&
+        balance > MIN_ACTIVATION_BALANCE
+      ) {
+        const balanceOverMinActivationBalance = BigInt(balance - MIN_ACTIVATION_BALANCE);
+        const withdrawableBalance =
+          balanceOverMinActivationBalance < withdrawal.amount ? balanceOverMinActivationBalance : withdrawal.amount;
+        withdrawals.push({
+          index: withdrawalIndex,
+          validatorIndex: withdrawal.validatorIndex,
+          address: validator.withdrawalCredentials.subarray(12),
+          amount: withdrawableBalance,
+        });
+        withdrawalIndex++;
+        withdrawnBalances.set(withdrawal.validatorIndex, totalWithdrawn + Number(withdrawableBalance));
+      }
+      processedPartialWithdrawalsCount++;
+    }
+  }
+
+  const bound = Math.min(validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
+  let n = 0;
+  // Just run a bounded loop max iterating over all withdrawals
+  // however breaks out once we have MAX_WITHDRAWALS_PER_PAYLOAD
+  for (n = 0; n < bound; n++) {
+    // Get next validator in turn
+    const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
+
+    const validator = validators.getReadonly(validatorIndex);
+    const withdrawnBalance = withdrawnBalances.getOrDefault(validatorIndex);
+    const balance = isPostElectra
+      ? // Deduct partially withdrawn balance already queued above
+        balances.get(validatorIndex) - withdrawnBalance
+      : balances.get(validatorIndex);
+    const {withdrawableEpoch, withdrawalCredentials, effectiveBalance} = validator;
+    const hasWithdrawableCredentials = isPostElectra
+      ? hasExecutionWithdrawalCredential(withdrawalCredentials)
+      : hasEth1WithdrawalCredential(withdrawalCredentials);
+    // early skip for balance = 0 as its now more likely that validator has exited/slashed with
+    // balance zero than not have withdrawal credentials set
+    if (balance === 0 || !hasWithdrawableCredentials) {
+      continue;
+    }
+
+    // capella full withdrawal
+    if (withdrawableEpoch <= epoch) {
+      withdrawals.push({
+        index: withdrawalIndex,
+        validatorIndex,
+        address: validator.withdrawalCredentials.subarray(12),
+        amount: BigInt(balance),
+      });
+      withdrawalIndex++;
+      withdrawnBalances.set(validatorIndex, withdrawnBalance + balance);
+    } else if (
+      effectiveBalance === (isPostElectra ? getMaxEffectiveBalance(withdrawalCredentials) : MAX_EFFECTIVE_BALANCE) &&
+      balance > effectiveBalance
+    ) {
+      // capella partial withdrawal
+      const partialAmount = balance - effectiveBalance;
+      withdrawals.push({
+        index: withdrawalIndex,
+        validatorIndex,
+        address: validator.withdrawalCredentials.subarray(12),
+        amount: BigInt(partialAmount),
+      });
+      withdrawalIndex++;
+      withdrawnBalances.set(validatorIndex, withdrawnBalance + partialAmount);
+    }
+
+    // Break if we have enough to pack the block
+    if (withdrawals.length >= MAX_WITHDRAWALS_PER_PAYLOAD) {
+      break;
+    }
+  }
+
+  return {withdrawals, sampledValidators: n, processedPartialWithdrawalsCount};
+}

package/src/block/slashValidator.ts

@@ -0,0 +1,98 @@
+import {
+  EFFECTIVE_BALANCE_INCREMENT,
+  EPOCHS_PER_SLASHINGS_VECTOR,
+  ForkSeq,
+  MIN_SLASHING_PENALTY_QUOTIENT,
+  MIN_SLASHING_PENALTY_QUOTIENT_ALTAIR,
+  MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX,
+  MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA,
+  PROPOSER_REWARD_QUOTIENT,
+  PROPOSER_WEIGHT,
+  TIMELY_TARGET_FLAG_INDEX,
+  WEIGHT_DENOMINATOR,
+  WHISTLEBLOWER_REWARD_QUOTIENT,
+  WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA,
+} from "@lodestar/params";
+import {ValidatorIndex} from "@lodestar/types";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
+import {decreaseBalance, increaseBalance} from "../util/index.js";
+import {initiateValidatorExit} from "./initiateValidatorExit.js";
+
+/** Same to https://github.com/ethereum/eth2.0-specs/blob/v1.1.0-alpha.5/specs/altair/beacon-chain.md#has_flag */
+const TIMELY_TARGET = 1 << TIMELY_TARGET_FLAG_INDEX;
+
+export function slashValidator(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  slashedIndex: ValidatorIndex,
+  whistleblowerIndex?: ValidatorIndex
+): void {
+  const {epochCtx} = state;
+  const {epoch, effectiveBalanceIncrements} = epochCtx;
+  const validator = state.validators.get(slashedIndex);
+
+  // TODO: Bellatrix initiateValidatorExit validators.update() with the one below
+  initiateValidatorExit(fork, state, validator);
+
+  validator.slashed = true;
+  validator.withdrawableEpoch = Math.max(validator.withdrawableEpoch, epoch + EPOCHS_PER_SLASHINGS_VECTOR);
+
+  const {effectiveBalance} = validator;
+
+  // state.slashings is initially a Gwei (BigInt) vector, however since Nov 2023 it's converted to UintNum64 (number) vector in the state transition because:
+  //  - state.slashings[nextEpoch % EPOCHS_PER_SLASHINGS_VECTOR] is reset per epoch in processSlashingsReset()
+  //  - max slashed validators per epoch is SLOTS_PER_EPOCH * MAX_ATTESTER_SLASHINGS * MAX_VALIDATORS_PER_COMMITTEE which is 32 * 2 * 2048 = 131072 on mainnet
+  //  - with that and 32_000_000_000 MAX_EFFECTIVE_BALANCE or 2048_000_000_000 MAX_EFFECTIVE_BALANCE_ELECTRA, it still fits in a number given that Math.floor(Number.MAX_SAFE_INTEGER / 32_000_000_000) = 281474
+  //  - we don't need to compute the total slashings from state.slashings, it's handled by totalSlashingsByIncrement in EpochCache
+  const slashingIndex = epoch % EPOCHS_PER_SLASHINGS_VECTOR;
+  state.slashings.set(slashingIndex, (state.slashings.get(slashingIndex) ?? 0) + effectiveBalance);
+  epochCtx.totalSlashingsByIncrement += effectiveBalanceIncrements[slashedIndex];
+
+  const minSlashingPenaltyQuotient =
+    fork === ForkSeq.phase0
+      ? MIN_SLASHING_PENALTY_QUOTIENT
+      : fork === ForkSeq.altair
+        ? MIN_SLASHING_PENALTY_QUOTIENT_ALTAIR
+        : fork < ForkSeq.electra // no change from bellatrix to deneb
+          ? MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX
+          : MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA;
+  decreaseBalance(state, slashedIndex, Math.floor(effectiveBalance / minSlashingPenaltyQuotient));
+
+  // apply proposer and whistleblower rewards
+  const whistleblowerReward =
+    fork < ForkSeq.electra
+      ? Math.floor(effectiveBalance / WHISTLEBLOWER_REWARD_QUOTIENT)
+      : Math.floor(effectiveBalance / WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA);
+  const proposerReward =
+    fork === ForkSeq.phase0
+      ? Math.floor(whistleblowerReward / PROPOSER_REWARD_QUOTIENT)
+      : Math.floor((whistleblowerReward * PROPOSER_WEIGHT) / WEIGHT_DENOMINATOR);
+
+  const proposerIndex = epochCtx.getBeaconProposer(state.slot);
+  if (whistleblowerIndex === undefined || !Number.isSafeInteger(whistleblowerIndex)) {
+    // Call increaseBalance() once with `(whistleblowerReward - proposerReward) + proposerReward`
+    increaseBalance(state, proposerIndex, whistleblowerReward);
+    state.proposerRewards.slashing += whistleblowerReward;
+  } else {
+    increaseBalance(state, proposerIndex, proposerReward);
+    increaseBalance(state, whistleblowerIndex, whistleblowerReward - proposerReward);
+    state.proposerRewards.slashing += proposerReward;
+  }
+
+  // TODO: describe issue. Compute progressive target balances
+  // if a validator is slashed, lookup their participation and remove from the cumulative values
+  if (fork >= ForkSeq.altair) {
+    const {previousEpochParticipation, currentEpochParticipation} = state as CachedBeaconStateAltair;
+
+    if ((previousEpochParticipation.get(slashedIndex) & TIMELY_TARGET) === TIMELY_TARGET) {
+      state.epochCtx.previousTargetUnslashedBalanceIncrements -= Math.floor(
+        effectiveBalance / EFFECTIVE_BALANCE_INCREMENT
+      );
+    }
+    if ((currentEpochParticipation.get(slashedIndex) & TIMELY_TARGET) === TIMELY_TARGET) {
+      state.epochCtx.currentTargetUnslashedBalanceIncrements -= Math.floor(
+        effectiveBalance / EFFECTIVE_BALANCE_INCREMENT
+      );
+    }
+  }
+}

package/src/block/types.ts

@@ -0,0 +1,9 @@
+export interface ProcessBlockOpts {
+  verifySignatures?: boolean;
+}
+
+export enum ProposerRewardType {
+  attestation = "attestation",
+  syncAggregate = "sync_aggregate",
+  slashing = "slashing",
+}

package/src/cache/effectiveBalanceIncrements.ts

@@ -0,0 +1,39 @@
+import {EFFECTIVE_BALANCE_INCREMENT} from "@lodestar/params";
+import {BeaconStateAllForks} from "../types.js";
+
+/**
+ * Alias to allow easier refactoring.
+ */
+export type EffectiveBalanceIncrements = Uint16Array;
+
+/** Helper to prevent re-writting tests downstream if we change Uint16Array to number[] */
+export function getEffectiveBalanceIncrementsZeroed(len: number): EffectiveBalanceIncrements {
+  return new Uint16Array(len);
+}
+
+/**
+ * effectiveBalanceIncrements length will always be equal or greater than validatorCount. The
+ * getEffectiveBalanceIncrementsByteLen() modulo is used to reduce the frequency at which its Uint16Array is recreated.
+ * if effectiveBalanceIncrements has length greater than validatorCount it's not a problem since those values would
+ * never be accessed.
+ */
+export function getEffectiveBalanceIncrementsWithLen(validatorCount: number): EffectiveBalanceIncrements {
+  // TODO: Research what's the best number to minimize both memory cost and copy costs
+  const byteLen = 1024 * Math.ceil(validatorCount / 1024);
+
+  return new Uint16Array(byteLen);
+}
+
+/**
+ * Shows how EffectiveBalanceIncrements is meant to be populated.
+ * In practice this function should not be used, since it more efficient to loop the validators array once and do
+ * more tasks than only populating effectiveBalanceIncrements
+ */
+export function getEffectiveBalanceIncrements(state: BeaconStateAllForks): EffectiveBalanceIncrements {
+  const validatorsArr = state.validators.getAllReadonlyValues();
+  const effectiveBalanceIncrements = new Uint16Array(validatorsArr.length);
+  for (let i = 0; i < validatorsArr.length; i++) {
+    effectiveBalanceIncrements[i] = Math.floor(validatorsArr[i].effectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
+  }
+  return effectiveBalanceIncrements;
+}