---
# System prepended metadata

title: Rewards and Penalties
tags: [rewards]

---

---
tags: rewards
---

# Rewards and Penalties

# награды

#### BaseReward

базовая награда за аттестацию включенную в блок, вычисляется для каждой аттестации

*BaseReward takes state and validator index and calculate individual validator's base reward.*



$BaseReward = {validator.EffectiveBalance() \over cfg.EffectiveBalanceIncrement} * {cfg.EffectiveBalanceIncrement * cfg.BaseRewardFactor \over \sqrt{activeBalance}}$


>validator.EffectiveBalance - баланс заданного валидатора
>activeBalance - сумма EffectiveBalance всех активных валидаторов
>EffectiveBalanceIncrement=1 * 1e9
>BaseRewardFactor=64

## награда за создание блока в координирующей сети

### proposerReward := proposerRewardNumerator / d

$proposerReward := {proposerRewardNumerator \over d}$


>proposerReward=687281 
proposerRewardNumerator=307901952
d=448

__где:__
__d__ - denominator
$d:= {{(cfg.WeightDenominator - cfg.ProposerWeight) * cfg.WeightDenominator} \over cfg.ProposerWeight}$

>cfg.ProposerWeight=8 
cfg.WeightDenominator=64 

__proposerRewardNumerator__

$proposerRewardNumerator = \sum_{i=1}^{len(bl.atts)} SourceReward_i + TargetReward_i + HeadReward_i$


__где:__
 Сумма значений вычисляемых для каждой аттестации включенной в блок
 
 $SourceReward_i = BaseReward_i * cfg.TimelySourceWeight * SourceCondition_i$
 $TargetReward_i = BaseReward_i * cfg.TimelyTargetWeight * TargetCondition_i$
 $HeadReward_i = BaseReward_i * cfg.TimelyHeadWeight * HeadCondition_i$
    
 
$BaseReward_i$ - базовая награда за аттестацию включенную в блок, вычисляется для каждой аттестации


>$cfg.TimelySourceWeight$=14 (TIMELY_SOURCE_WEIGHT is the factor of how much source rewards receives) 
$cfg.TimelyTargetWeight$=26 (TIMELY_TARGET_WEIGHT is the factor of how much target rewards receives)
$cfg.TimelyHeadWeight$=14 (TIMELY_HEAD_WEIGHT is the factor of how much head rewards receives)
$SourceCondition_i, TargetCondition_i, HeadCondition_i ∈ \{0, 1\}$ - условие начисления. зависит от наличие соотв. данных в аттестации (тут не очень понятен механизм) и добавлялись ли данные ранее (чтобы исключить повторное добавление уже добавленных)




## награда за агрегацию аттестаций в координирующей сети
Нет


## награда за аттестацию в координирующей сети

Cрабатывает в конце эпохи.


$reward = SourceReward_i + TargetReward_i  + HeadReward_i$

__где:__

$SourceReward_i ={
BaseReward_i * cfg.TimelySourceWeight * {bal.PrevEpochAttested \over cfg.EffectiveBalanceIncrement}
\over {activeIncrement * cfg.WeightDenominator}} * rwdSourceCondition_i$

$TargetReward_i ={
BaseReward * cfg.TimelyTargetWeight * {bal.PrevEpochTargetAttested \over cfg.EffectiveBalanceIncrement}
\over {activeIncrement * cfg.WeightDenominator}} * rwdTargetCondition_i$


$HeadReward_i ={
BaseReward * cfg.TimelyHeadWeight * {bal.PrevEpochHeadAttested \over cfg.EffectiveBalanceIncrement}
\over {activeIncrement * cfg.WeightDenominator}} * rwdHeadCondition_i$

__где:__

$activeIncrement := {bal.ActiveCurrentEpoch \over cfg.EffectiveBalanceIncrement}$

$rwdSourceCondition_i, rwdTargetCondition_i, rwdHeadCondition_i  ∈ \{0, 1\}$ - условие начисления соотв. награды

```
rwdSourceCondition_i = val.IsPrevEpochSourceAttester && !val.IsSlashed && !inactivityLeak && eligible ? 1 : 0

rwdTargetCondition_i = val.IsPrevEpochTargetAttester && !val.IsSlashed && !inactivityLeak && eligible ? 1 : 0

rwdHeadCondition_i = val.IsPrevEpochHeadAttester && !val.IsSlashed && !inactivityLeak && eligible ? 1 : 0


// if the validator was active prev epoch or slashed
eligible = val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch) 
```

## SyncCommittee: награда за агрегацию аттестаций рута стейта предшествующего слота (currentSlot - 1) для поддержки LightClient
Нет


## SyncCommittee: награда за аттестацию рута стейта предшествующего слота (currentSlot - 1) для поддержки LightClient

Cрабатывает на каждом слоте начиная с __Альтаир__.



$participantReward = {{BaseReward * cfg.SyncRewardWeight} \over {cfg.WeightDenominator * cfg.SlotsPerEpoch * cfg.SyncCommitteeSize}}$


> SyncRewardWeight=2 (SYNC_REWARD_WEIGHT is the factor of how much sync committee rewards receives)
> WeightDenominator=64 
> SlotsPerEpoch=32 (SLOTS_PER_EPOCH is the number of slots in an epoch)
> SyncCommitteeSize=512 (SYNC_COMMITTEE_SIZE for light client sync committee size)


## SyncCommittee: награда пропозеру за включение аттестаций рута стейта предшествующего слота (currentSlot - 1) для поддержки LightClient

Начисляется только за голосовавших участников

$reward = \sum_{i=1}^{bl.SyncAggregate.Len()} proposerReward * IsVotedIndex_i$


__где:__

$proposerReward = {{participantReward * cfg.ProposerWeight} \over {cfg.WeightDenominator - cfg.ProposerWeight}}$


> ProposerWeight=8 (PROPOSER_WEIGHT is the factor of how much proposer rewards receives)
> WeightDenominator=64 (WEIGHT_DENOMINATOR accounts for total rewards denomination)


## награда за Слэшинг в координирующей сети

> whistleBlower (обличитель) - устанавливает факт слэшинг-нарушения
> In phase 0, the proposer is the whistleblower
> тот же функционал используется и для Альтаира

для расчетов используется значение

##### whistleblowerReward := slashValidator.EffectiveBalance / cfg.WhistleBlowerRewardQuotient
> WhistleBlowerRewardQuotient=512


награда состоит состоит из двух частей (ресипиент один и тот же):

### 1. пропозеру за слешинг (одного валидатора)
#### proposerReward := whistleblowerReward / cfg.ProposerRewardQuotient

> ProposerRewardQuotient=8

### 2. обличителю за слешинг (одного валидатора)
#### whistleblowerReward := whistleblowerReward - proposerReward



# штрафы

## штраф за пропуск аттестации

Cрабатывает в конце эпохи.


$penalty = SourcePenalty_i + TargetPenalty_i  + InactivityPenalty_i$

__где:__

$SourcePenalty_i ={{baseReward * cfg.TimelySourceWeight} \over cfg.WeightDenominator} * penaltySourceCondition_i$

$TargetPenalty_i ={{baseReward * cfg.TimelyTargetWeight} \over cfg.WeightDenominator} * penaltyTargetCondition_i$

$InactivityPenalty_i = {{val.effectiveBalance * val.InactivityScore} \over {cfg.InactivityScoreBias * cfg.InactivityPenaltyQuotientAltair}} * penaltyInactivityCondition_i$



__где:__


$penaltySourceCondition_i, penaltyTargetCondition_i, penaltyInactivityCondition_i  ∈ \{0, 1\}$ - условие начисления соотв. штрафа

```
penaltySourceCondition_i = val.IsPrevEpochSourceAttester && !val.IsSlashed && eligible ? 0 : 1

penaltyTargetCondition_i = val.IsPrevEpochTargetAttester && !val.IsSlashed &&  eligible ? 0 : 1

$penaltyInactivityCondition_i = (!val.IsPrevEpochTargetAttester || val.IsSlashed) && eligible ? 1 : 0


// if the validator was active prev epoch or slashed
eligible = val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch) 
```










/*
 2.1. source penalty: 
 condition !(validator.IsPrevEpochSourceAttester && !validator.IsSlashed) 
 penalty = baseReward * cfg.TimelySourceWeight / cfg.WeightDenominator

2.2. target penalty: 
condition !(validator.IsPrevEpochTargetAttester && !validator.IsSlashed) 
 penalty = baseReward * cfg.TimelyTargetWeight / cfg.WeightDenominator

#### 2.3. an additional penalty to validators that did not vote on the correct target or slashed: 
##### condition (!validator.IsPrevEpochTargetAttester || validator.IsSlashed) 
##### penalty = (validator.CurrentEpochEffectiveBalance *  validator.InactivityScore) / (cfg.InactivityScoreBias * cfg.InactivityPenaltyQuotientAltair)

*/


## SyncCommittee: штраф за пропуск аттестации рута предшествующего блока

*такой же как и соотв. награда за аттестацию рута*

$participantReward = {{BaseReward * cfg.SyncRewardWeight} \over {cfg.WeightDenominator * cfg.SlotsPerEpoch * cfg.SyncCommitteeSize}}$



> SyncRewardWeight=2 (SYNC_REWARD_WEIGHT is the factor of how much sync committee rewards receives)
> WeightDenominator=64 
> SlotsPerEpoch=32 (SLOTS_PER_EPOCH is the number of slots in an epoch)
> SyncCommitteeSize=512 (SYNC_COMMITTEE_SIZE for light client sync committee size)


## Штраф за Слэшинг в координирующей сети (первоначальный - начисляется сразу по факту обнаружения) 

> The slashing amount is represented by epochs per slashing vector. The validator's effective balance is then applied to that amount.

#### penalty = slashValidator.EffectiveBalance/cfg.MinSlashingPenaltyQuotientAltair

> MinSlashingPenaltyQuotientAltair=64



## Штраф за Слэшинг в координирующей сети (каждую эпоху) версия 1 *(проверить)*
> `beacon-chain/core/epoch/epoch_processing.go:169`
> `func ProcessSlashings(state state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error)`


> ProcessSlashings processes the slashed validators during epoch processing,

##### minSlashing := math.Min(totalSlashedValidators * cfg.ProportionalSlashingMultiplierAltair, totalActiveValidatorBalance)

> ProportionalSlashingMultiplierAltair=2
> totalActiveValidatorBalance - суммарный баланс всех активных валидаторов

### penalty := (slashValidator.EffectiveBalance / cfg.EffectiveBalanceIncrement * minSlashing) / totalActiveValidatorBalance * cfg.EffectiveBalanceIncrement


## Штраф за Слэшинг в координирующей сети (каждую эпоху) версия 2 *(проверить)*
> `beacon-chain/core/epoch/precompute/slashing.go:15`
> `// This is an optimized version by passing in precomputed total epoch balances.`
> `func ProcessSlashingsPrecompute(s state.BeaconState, pBal *Balance) error`

##### minSlashing := math.Min(totalSlashedValidators * cfg.ProportionalSlashingMultiplier, pBal.ActiveCurrentEpoch)

> Balance.ActiveCurrentEpoch - is the total effective balance of all active validators during current epoch.

### penalty :=  (slashValidator.EffectiveBalance / cfg.EffectiveBalanceIncrement * minSlashing) / pBal.ActiveCurrentEpoch * cfg.EffectiveBalanceIncrement

