Reward distribution

Namada uses the automatically-compounding variant of F1 fee distribution.

Rewards are given to validators for voting on finalizing blocks: the fund for these rewards can come from minting (creating new tokens). The amount that is minted depends on how much is staked and our desired yearly inflation. When the total of the tokens staked is very low, the return rate per validator needs to increase, but as the total amount of stake rises, validators will receive less rewards. Once we have acquired the desired stake percentage, the amount minted will just be the desired yearly inflation.

The validator and the delegator must have agreed on a commission rate between themselves. Delegators pay out rewards to validators based on a mutually-determined commission rate that both parties must have agreed upon beforehand. The minted rewards are auto-bonded and only transferred when the funds are unbonded. Once we have calculated the total that needs to be minted at the end of the epoch, we split the minted tokens according to the stake the relevant validators and delegators contributed and distribute them to validators and their delegators. This is similar to what Cosmos does.

Basic algorithm

Consider a system with

a canonical singular staking unit of account.
a set of validators $V_{i}$ .
a set of delegations $D_{i, j}$ , each to a particular validator and in a particular (initial) amount.
epoched proof-of-stake, where changes are applied as follows:
- bonding after the pipeline length
- unbonding after the unbonding length
- rewards are paid out at the end of each epoch, to wit, in each epoch $e$ , $R_{e, i}$ is paid out to validator $V_{i}$
- slashing is applied as described in slashing.

We wish to approximate as exactly as possible the following ideal delegator reward distribution system:

At each epoch, for a validator $V$ , iterate over all of the delegations to that validator. Update each delegation $D$ , as follows. $D \to D (1 + r_{V} (e) / s_{V} (e))$ where $r_{V} (e)$ and $s_{V} (e)$ respectively denote the reward and stake of validator $V$ at epoch $e$ .
Similarly, multiply the validator's voting power by the same factor $(1 + r_{V} (e) / s_{V} (e))$ , which should now equal the sum of their revised-amount delegations.

In this system, rewards are automatically rebonded to delegations, increasing the delegation amounts and validator voting powers accordingly.

However, we wish to implement this without actually needing to iterate over all delegations each block, since this is too computationally expensive. We can exploit this constant multiplicative factor $(1 + r_{V} (e) / s_{V} (e))$ which does not vary per delegation to perform this calculation lazily, storing only a constant amount of data per validator per epoch, and calculate revised amounts for each individual delegation only when a delegation changes.

We will demonstrate this for a delegation $D$ to a validator $V$ . Let $s_{D} (e)$ denote the stake of $D$ at epoch $e$ .

For two epochs $m$ and $n$ with $m < n$ , define the function $p$ as

$p (n, m) = e = m \prod n (1 + \frac{r _{V} ( e )}{s _{V} ( e )}) .$

Denote $p (n, 0)$ as $p_{n}$ . The function $p$ has a useful property.

$p (n, m) = \frac{p _{n}}{p _{m}} (1)$

One may calculate the accumulated changes upto epoch $n$ as

$s_{D} (n) = s_{D} (0) * p_{n} .$

If we know the delegation upto epoch $m$ , the delegation at epoch $n$ is obtained by the following formula, $s_{D} (n) = s_{D} (m) * p (n, m) .$

Using property $(1)$ ,

$s_{D} (n) = s_{D} (m) * \frac{p _{n}}{p _{m}} .$

Clearly, the quantity $p_{n} / p_{m}$ does not depend on the delegation $D$ . Thus, for a given validator, we need only store this product $p_{e}$ at each epoch $e$ , with which updated amounts for all delegations can be calculated.

The product $p_{e}$ at the end of each epoch $e$ is updated as follows.


updateProducts 
:: HashMap<Address, HashMap<Epoch, Float>> 
-> HashSet<Address> 
-> Epoch 
-> HashMap<BondId, Token::amount>>

updateProducts validatorProducts activeSet currentEpoch = 
	let stake = PoS.readValidatorTotalDeltas validator currentEpoch
        reward = PoS.reward stake currentEpoch
		entries = lookup validatorProducts validator
	    lastProduct = lookup entries (Epoch (currentEpoch - 1))
	in insert currentEpoch (product*(1+rsratio)) entries

Commission

Commission is charged by a validator on the rewards coming from delegations. These are set as percentages by the validator, who may charge any commission they wish between 0-100%.

Let c_V(e) $b e t h eco mmi ss i o n r a t e f or a d e l e g a t i o n$ D $t o a v a l i d a t or$ V $a t e p oc h$ e $. T h ee x p ress i o n f or t h e p ro d u c t$ p_nc_V(e) $i s t h es am e f or a ll d e l e g a t i o n s t o a v a l i d a t or$ V $ina g i v e n e p oc h$ e, including for self-bonds. The validator can change the commission rate at any point, subject to a maximum rate of change per epoch, which is a constant specified when the validator is created and immutable once validator creation has been accepted.

While rewards are given out at the end of every epoch, voting power is only updated after the pipeline offset. According to the proof-of-stake system, at the current epoch e, the validator sets an only be updated for epoch e + pipeline_offset, and it should remain unchanged from epoch e to e + pipeline_offset - 1. Updating voting power in the current epoch would violate this rule.

Slashes

Slashes should lead to punishment for delegators who were contributing voting power to the validator at the height of the infraction, as if the delegations were iterated over and slashed individually.

This can be implemented as a negative inflation rate for a particular block.

Instant redelegation is not supported. Redelegations must wait the unbonding period.

Anoma Specifications

Reward distribution

Basic algorithm

Commission

Slashes