Add EpochRewards smart contract to calculate epoch rewards and payments

packages/celotool/src/e2e-tests/blockchain_parameters_tests.ts

@@ -13,7 +13,7 @@ describe('Blockchain parameters tests', function(this: any) {
   let parameters: BlockchainParametersWrapper
 
   const gethConfig: GethTestConfig = {
-    migrateTo: 17,
+    migrateTo: 18,
     instances: [
       { name: 'validator', validating: true, syncmode: 'full', port: 30303, rpcport: 8545 },
     ],

packages/celotool/src/e2e-tests/governance_tests.ts

@@ -4,7 +4,14 @@ import { fromFixed, toFixed } from '@celo/utils/lib/fixidity'
 import BigNumber from 'bignumber.js'
 import { assert } from 'chai'
 import Web3 from 'web3'
-import { getContext, getEnode, importGenesis, initAndStartGeth, sleep } from './utils'
+import {
+  assertAlmostEqual,
+  getContext,
+  getEnode,
+  importGenesis,
+  initAndStartGeth,
+  sleep,
+} from './utils'
 
 describe('governance tests', () => {
   const gethConfig = {
@@ -21,9 +28,12 @@ describe('governance tests', () => {
   const context: any = getContext(gethConfig)
   let web3: any
   let election: any
-  let validators: any
+  let stableToken: any
+  let sortedOracles: any
+  let epochRewards: any
   let goldToken: any
   let registry: any
+  let validators: any
   let accounts: AccountsWrapper
   let kit: ContractKit
 
@@ -39,9 +49,12 @@ describe('governance tests', () => {
     web3 = new Web3('http://localhost:8545')
     kit = newKitFromWeb3(web3)
     goldToken = await kit._web3Contracts.getGoldToken()
+    stableToken = await kit._web3Contracts.getStableToken()
+    sortedOracles = await kit._web3Contracts.getSortedOracles()
     validators = await kit._web3Contracts.getValidators()
     registry = await kit._web3Contracts.getRegistry()
     election = await kit._web3Contracts.getElection()
+    epochRewards = await kit._web3Contracts.getEpochRewards()
     accounts = await kit.contracts.getAccounts()
   }
 
@@ -278,10 +291,9 @@ describe('governance tests', () => {
     })
 
     it('should distribute epoch payments at the end of each epoch', async () => {
-      const stableToken = await kit._web3Contracts.getStableToken()
       const commission = 0.1
-      const validatorEpochPayment = new BigNumber(
-        await validators.methods.validatorEpochPayment().call()
+      const targetValidatorEpochPayment = new BigNumber(
+        await epochRewards.methods.targetValidatorEpochPayment().call()
       )
       const [group] = await validators.methods.getRegisteredValidatorGroups().call()
 
@@ -298,7 +310,7 @@ describe('governance tests', () => {
         )
         assert.isNotNaN(currentBalance)
         assert.isNotNaN(previousBalance)
-        assert.equal(expected.toFixed(), currentBalance.minus(previousBalance).toFixed())
+        assertAlmostEqual(currentBalance.minus(previousBalance), expected)
       }
 
       const assertBalanceUnchanged = async (validator: string, blockNumber: number) => {
@@ -310,7 +322,14 @@ describe('governance tests', () => {
           (await validators.methods.getValidator(validator).call({}, blockNumber))[2]
         )
         assert.isNotNaN(score)
-        return validatorEpochPayment.times(fromFixed(score))
+        // We need to calculate the rewards multiplier for the previous block, before
+        // the rewards actually are awarded.
+        const rewardsMultiplier = new BigNumber(
+          await epochRewards.methods.getRewardsMultiplier().call({}, blockNumber - 1)
+        )
+        return targetValidatorEpochPayment
+          .times(fromFixed(score))
+          .times(fromFixed(rewardsMultiplier))
       }
 
       for (const blockNumber of blockNumbers) {
@@ -346,8 +365,6 @@ describe('governance tests', () => {
     it('should distribute epoch rewards at the end of each epoch', async () => {
       const lockedGold = await kit._web3Contracts.getLockedGold()
       const governance = await kit._web3Contracts.getGovernance()
-      const epochReward = new BigNumber(10).pow(18)
-      const infraReward = new BigNumber(10).pow(18)
       const [group] = await validators.methods.getRegisteredValidatorGroups().call()
 
       const assertVotesChanged = async (blockNumber: number, expected: BigNumber) => {
@@ -357,7 +374,7 @@ describe('governance tests', () => {
         const previousVotes = new BigNumber(
           await election.methods.getTotalVotesForGroup(group).call({}, blockNumber - 1)
         )
-        assert.equal(expected.toFixed(), currentVotes.minus(previousVotes).toFixed())
+        assertAlmostEqual(currentVotes.minus(previousVotes), expected)
       }
 
       const assertGoldTokenTotalSupplyChanged = async (
@@ -370,7 +387,7 @@ describe('governance tests', () => {
         const previousSupply = new BigNumber(
           await goldToken.methods.totalSupply().call({}, blockNumber - 1)
         )
-        assert.equal(expected.toFixed(), currentSupply.minus(previousSupply).toFixed())
+        assertAlmostEqual(currentSupply.minus(previousSupply), expected)
       }
 
       const assertBalanceChanged = async (
@@ -384,7 +401,7 @@ describe('governance tests', () => {
         const previousBalance = new BigNumber(
           await goldToken.methods.balanceOf(address).call({}, blockNumber - 1)
         )
-        assert.equal(expected.toFixed(), currentBalance.minus(previousBalance).toFixed())
+        assertAlmostEqual(currentBalance.minus(previousBalance), expected)
       }
 
       const assertLockedGoldBalanceChanged = async (blockNumber: number, expected: BigNumber) => {
@@ -411,12 +428,52 @@ describe('governance tests', () => {
         await assertGovernanceBalanceChanged(blockNumber, new BigNumber(0))
       }
 
+      const getStableTokenSupplyChange = async (blockNumber: number) => {
+        const currentSupply = new BigNumber(
+          await stableToken.methods.totalSupply().call({}, blockNumber)
+        )
+        const previousSupply = new BigNumber(
+          await stableToken.methods.totalSupply().call({}, blockNumber - 1)
+        )
+        return currentSupply.minus(previousSupply)
+      }
+
+      const getStableTokenExchangeRate = async (blockNumber: number) => {
+        const rate = await sortedOracles.methods
+          .medianRate(stableToken.options.address)
+          .call({}, blockNumber)
+        return new BigNumber(rate[0]).div(rate[1])
+      }
+
       for (const blockNumber of blockNumbers) {
         if (isLastBlockOfEpoch(blockNumber, epoch)) {
-          await assertVotesChanged(blockNumber, epochReward)
-          await assertGoldTokenTotalSupplyChanged(blockNumber, epochReward.plus(infraReward))
-          await assertLockedGoldBalanceChanged(blockNumber, epochReward)
-          await assertGovernanceBalanceChanged(blockNumber, infraReward)
+          // We use the number of active votes from the previous block to calculate the expected
+          // epoch reward as the number of active votes for the current block will include the
+          // epoch reward.
+          const activeVotes = new BigNumber(
+            await election.methods.getActiveVotes().call({}, blockNumber - 1)
+          )
+          const targetVotingYield = new BigNumber(
+            (await epochRewards.methods.getTargetVotingYieldParameters().call({}, blockNumber))[0]
+          )
+          // We need to calculate the rewards multiplier for the previous block, before
+          // the rewards actually are awarded.
+          const rewardsMultiplier = new BigNumber(
+            await epochRewards.methods.getRewardsMultiplier().call({}, blockNumber - 1)
+          )
+          const expectedEpochReward = activeVotes
+            .times(fromFixed(targetVotingYield))
+            .times(fromFixed(rewardsMultiplier))
+          const expectedInfraReward = new BigNumber(10).pow(18)
+          const stableTokenSupplyChange = await getStableTokenSupplyChange(blockNumber)
+          const exchangeRate = await getStableTokenExchangeRate(blockNumber)
+          const expectedGoldTotalSupplyChange = expectedInfraReward
+            .plus(expectedEpochReward)
+            .plus(stableTokenSupplyChange.div(exchangeRate))
+          await assertVotesChanged(blockNumber, expectedEpochReward)
+          await assertLockedGoldBalanceChanged(blockNumber, expectedEpochReward)
+          await assertGovernanceBalanceChanged(blockNumber, expectedInfraReward)
+          await assertGoldTokenTotalSupplyChanged(blockNumber, expectedGoldTotalSupplyChange)
         } else {
           await assertVotesUnchanged(blockNumber)
           await assertGoldTokenTotalSupplyUnchanged(blockNumber)
@@ -425,6 +482,54 @@ describe('governance tests', () => {
         }
       }
     })
+
+    it('should update the target voting yield', async () => {
+      const assertTargetVotingYieldChanged = async (blockNumber: number, expected: BigNumber) => {
+        const currentTarget = new BigNumber(
+          (await epochRewards.methods.getTargetVotingYieldParameters().call({}, blockNumber))[0]
+        )
+        const previousTarget = new BigNumber(
+          (await epochRewards.methods.getTargetVotingYieldParameters().call({}, blockNumber - 1))[0]
+        )
+        const difference = currentTarget.minus(previousTarget)
+
+        // Assert equal to 10 decimal places due to rounding errors.
+        assert.equal(
+          fromFixed(difference)
+            .dp(10)
+            .toFixed(),
+          fromFixed(expected)
+            .dp(10)
+            .toFixed()
+        )
+      }
+
+      const assertTargetVotingYieldUnchanged = async (blockNumber: number) => {
+        await assertTargetVotingYieldChanged(blockNumber, new BigNumber(0))
+      }
+
+      for (const blockNumber of blockNumbers) {
+        if (isLastBlockOfEpoch(blockNumber, epoch)) {
+          // We use the voting gold fraction from before the rewards are granted.
+          const votingGoldFraction = new BigNumber(
+            await epochRewards.methods.getVotingGoldFraction().call({}, blockNumber - 1)
+          )
+          const targetVotingGoldFraction = new BigNumber(
+            await epochRewards.methods.getTargetVotingGoldFraction().call({}, blockNumber)
+          )
+          const difference = targetVotingGoldFraction.minus(votingGoldFraction)
+          const adjustmentFactor = fromFixed(
+            new BigNumber(
+              (await epochRewards.methods.getTargetVotingYieldParameters().call({}, blockNumber))[2]
+            )
+          )
+          const delta = difference.times(adjustmentFactor)
+          await assertTargetVotingYieldChanged(blockNumber, delta)
+        } else {
+          await assertTargetVotingYieldUnchanged(blockNumber)
+        }
+      }
+    })
   })
 
   describe('after the gold token smart contract is registered', () => {

packages/celotool/src/e2e-tests/transfer_tests.ts

@@ -180,7 +180,7 @@ describe('Transfer tests', function(this: any) {
 
   const syncModes = ['full', 'fast', 'light', 'ultralight']
   const gethConfig: GethTestConfig = {
-    migrateTo: 17,
+    migrateTo: 18,
     instances: [
       { name: 'validator', validating: true, syncmode: 'full', port: 30303, rpcport: 8545 },
     ],

packages/celotool/src/e2e-tests/utils.ts

@@ -1,3 +1,4 @@
+import BigNumber from 'bignumber.js'
 import { assert } from 'chai'
 import { spawn, SpawnOptions } from 'child_process'
 import fs from 'fs'
@@ -40,6 +41,22 @@ const GENESIS_PATH = `${TEST_DIR}/genesis.json`
 const NetworkId = 1101
 const MonorepoRoot = resolvePath(joinPath(__dirname, '../..', '../..'))
 
+export function assertAlmostEqual(
+  actual: BigNumber,
+  expected: BigNumber,
+  delta: BigNumber = new BigNumber(10).pow(12).times(5)
+) {
+  if (expected.isZero()) {
+    assert.equal(actual.toFixed(), expected.toFixed())
+  } else {
+    const isCloseTo = actual.plus(delta).gte(expected) || actual.minus(delta).lte(expected)
+    assert(
+      isCloseTo,
+      `expected ${actual.toString()} to almost equal ${expected.toString()} +/- ${delta.toString()}`
+    )
+  }
+}
+
 export function spawnWithLog(cmd: string, args: string[], logsFilepath: string) {
   try {
     fs.unlinkSync(logsFilepath)

packages/celotool/src/e2e-tests/validator_order_tests.ts

@@ -10,7 +10,7 @@ const BLOCK_COUNT = EPOCH * EPOCHS_TO_WAIT
 
 describe('governance tests', () => {
   const gethConfig: GethTestConfig = {
-    migrateTo: 14,
+    migrateTo: 15,
     instances: _.range(VALIDATORS).map((i) => ({
       name: `validator${i}`,
       validating: true,

packages/contractkit/src/base.ts

@@ -5,6 +5,7 @@ export enum CeloContract {
   Attestations = 'Attestations',
   BlockchainParameters = 'BlockchainParameters',
   Election = 'Election',
+  EpochRewards = 'EpochRewards',
   Escrow = 'Escrow',
   Exchange = 'Exchange',
   GasCurrencyWhitelist = 'GasCurrencyWhitelist',

packages/contractkit/src/contract-cache.ts

@@ -4,6 +4,7 @@ import { AccountsWrapper } from './wrappers/Accounts'
 import { AttestationsWrapper } from './wrappers/Attestations'
 import { BlockchainParametersWrapper } from './wrappers/BlockchainParameters'
 import { ElectionWrapper } from './wrappers/Election'
+// import { EpochRewardsWrapper } from './wrappers/EpochRewards'
 import { EscrowWrapper } from './wrappers/Escrow'
 import { ExchangeWrapper } from './wrappers/Exchange'
 import { GasPriceMinimumWrapper } from './wrappers/GasPriceMinimum'
@@ -20,6 +21,7 @@ const WrapperFactories = {
   [CeloContract.Attestations]: AttestationsWrapper,
   [CeloContract.BlockchainParameters]: BlockchainParametersWrapper,
   [CeloContract.Election]: ElectionWrapper,
+  // [CeloContract.EpochRewards]?: EpochRewardsWrapper,
   [CeloContract.Escrow]: EscrowWrapper,
   [CeloContract.Exchange]: ExchangeWrapper,
   // [CeloContract.GasCurrencyWhitelist]: GasCurrencyWhitelistWrapper,
@@ -44,6 +46,7 @@ interface WrapperCacheMap {
   [CeloContract.Attestations]?: AttestationsWrapper
   [CeloContract.BlockchainParameters]?: BlockchainParametersWrapper
   [CeloContract.Election]?: ElectionWrapper
+  // [CeloContract.EpochRewards]?: EpochRewardsWrapper
   [CeloContract.Escrow]?: EscrowWrapper
   [CeloContract.Exchange]?: ExchangeWrapper
   // [CeloContract.GasCurrencyWhitelist]?: GasCurrencyWhitelistWrapper,
@@ -83,6 +86,9 @@ export class WrapperCache {
   getElection() {
     return this.getContract(CeloContract.Election)
   }
+  // getEpochRewards() {
+  //   return this.getContract(CeloContract.EpochRewards)
+  // }
   getEscrow() {
     return this.getContract(CeloContract.Escrow)
   }

packages/contractkit/src/web3-contract-cache.ts

@@ -4,6 +4,7 @@ import { newAccounts } from './generated/Accounts'
 import { newAttestations } from './generated/Attestations'
 import { newBlockchainParameters } from './generated/BlockchainParameters'
 import { newElection } from './generated/Election'
+import { newEpochRewards } from './generated/EpochRewards'
 import { newEscrow } from './generated/Escrow'
 import { newExchange } from './generated/Exchange'
 import { newGasCurrencyWhitelist } from './generated/GasCurrencyWhitelist'
@@ -26,6 +27,7 @@ const ContractFactories = {
   [CeloContract.Attestations]: newAttestations,
   [CeloContract.BlockchainParameters]: newBlockchainParameters,
   [CeloContract.Election]: newElection,
+  [CeloContract.EpochRewards]: newEpochRewards,
   [CeloContract.Escrow]: newEscrow,
   [CeloContract.Exchange]: newExchange,
   [CeloContract.GasCurrencyWhitelist]: newGasCurrencyWhitelist,
@@ -68,6 +70,9 @@ export class Web3ContractCache {
   getElection() {
     return this.getContract(CeloContract.Election)
   }
+  getEpochRewards() {
+    return this.getContract(CeloContract.EpochRewards)
+  }
   getEscrow() {
     return this.getContract(CeloContract.Escrow)
   }

packages/protocol/contracts/common/UsingRegistry.sol

@@ -13,6 +13,7 @@ import "../governance/interfaces/IValidators.sol";
 
 import "../identity/interfaces/IRandom.sol";
 
+import "../stability/interfaces/ISortedOracles.sol";
 import "../stability/interfaces/IStableToken.sol";
 
 // Ideally, UsingRegistry should inherit from Initializable and implement initialize() which calls
@@ -81,6 +82,10 @@ contract UsingRegistry is Ownable {
     return IRandom(registry.getAddressForOrDie(RANDOM_REGISTRY_ID));
   }
 
+  function getSortedOracles() internal view returns (ISortedOracles) {
+    return ISortedOracles(registry.getAddressForOrDie(SORTED_ORACLES_REGISTRY_ID));
+  }
+
   function getStableToken() internal view returns (IStableToken) {
     return IStableToken(registry.getAddressForOrDie(STABLE_TOKEN_REGISTRY_ID));
   }

packages/protocol/contracts/stability/test/MockGoldToken.sol → packages/protocol/contracts/common/test/MockGoldToken.sol

@@ -6,6 +6,11 @@ pragma solidity ^0.5.3;
  */
 contract MockGoldToken {
   uint8 public constant decimals = 18;
+  uint256 public totalSupply;
+
+  function setTotalSupply(uint256 value) external {
+    totalSupply = value;
+  }
 
   function transfer(address, uint256) external pure returns (bool) {
     return true;

packages/protocol/contracts/governance/Election.sol

@@ -672,6 +672,14 @@ contract Election is
     return votes.active.total.add(votes.pending.total);
   }
 
+  /**
+   * @notice Returns the active votes received across all groups.
+   * @return The active votes received across all groups.
+   */
+  function getActiveVotes() public view returns (uint256) {
+    return votes.active.total;
+  }
+
   /**
    * @notice Returns the list of validator groups eligible to elect validators.
    * @return The list of validator groups eligible to elect validators.