We are blockchain researchers from the National University of Singapore.
Our current research analyzed the fairness of NXT incentive algorithm. Several issues are found, so we try to report here and wish to hear some feedback from the team.
We found that the current NXT forging algorithm does not ensure that the block winning probability is proportional to the stake deposited by players.
Specifically, the players with more stakes will receive a higher ROI comparing with poor ones.
In a long-term staking competition, this mechanism will encourage players to join the mining pools and making incentives centralized.
Let me show you some intuitions that the issue caused.
Currently, to propose a new block, NXT forgers must calculate a 'hit' number and a 'target' number, where,
Target = BaseTarget * EffectiveBalance * TimeSinceLastBlock
hit = gethit(publicKey, lastBlock) .
gethit function can be regarded as a hash function or verifiable random function. The
hit number is fixed for every block and the
target number increases every second (because of the variable
TimeSinceLastBlock). Once a new block is found, every forger will update his
hit in the current block and continuously check if
hit < Target for the current timestamp. The player who is assigned the shortest waiting time becomes the proposer of the next block.
We can simplify the waiting time formulation in this form
Waiting_Time = constant * Hash(pk,...)/balance .
Suppose there are two forgers A and B, who control
S_B stakes, respectively ( assuming
S_A < S_B). By some probability calculation, we can show that the probability forger A generates a smaller
Waiting_Time with probability
S_A/2S_B, which is less than
S_A/(S_A+S_B). Consequently, the rich forger will have a higher probability to propose the next block, making himself becomes even richer.
To address this problem, we also proposed a practical solution that can be deployed easily on current NXT client. The solution is just modifying the current
target and 'hit' formulas so that the proposer selection algorithm can be fair. Since we can not put any latex formula here, please check our paper for more details. We are very happy to help the team solving this bug.
Here is the paper link.