@lodestar/state-transition 1.35.0-dev.98d359db41 → 1.35.0-dev.a70bac5bd3

package/src/block/processWithdrawals.ts

@@ -1,207 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

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

package/src/cache/effectiveBalanceIncrements.ts

@@ -1,39 +0,0 @@
-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;
-}