Automated rewards and calculation (#267)

* automatic rewards calculations changes

* supply calculation

* more tests

* update FlowEpoch to depend on FlowFees

This temporarily breaks the tests which pull in flow-go, because flow-go
also depends on the contracts module

* update flow-go version

* fix array ordering tests

* update flow-go dependency

* go mod tidy

Co-authored-by: Jordan Schalm <[email protected]>

Author: joshuahannan

contracts/epochs/FlowEpoch.cdc

@@ -3,6 +3,7 @@ import FlowToken from 0xFLOWTOKENADDRESS
 import FlowIDTableStaking from 0xFLOWIDTABLESTAKINGADDRESS
 import FlowClusterQC from 0xQCADDRESS
 import FlowDKG from 0xDKGADDRESS
+import FlowFees from 0xFLOWFEESADDRESS
 
 // The top-level smart contract managing the lifecycle of epochs. In Flow,
 // epochs are the smallest unit of time where the identity table (the set of 
@@ -212,8 +213,8 @@ pub contract FlowEpoch {
         /// The number of collector clusters in each epoch
         pub(set) var numCollectorClusters: UInt16
 
-        /// Tracks the annualized percentage of FLOW total supply that is minted as rewards at the end of an epoch
-        /// Calculation for a single epoch would be (totalSupply * FLOWsupplyIncreasePercentage) / 52
+        /// Tracks the rate at which the rewards payout increases every epoch
+        /// This value is multiplied by the FLOW total supply to get the next payout
         pub(set) var FLOWsupplyIncreasePercentage: UFix64
 
         init(numViewsInEpoch: UInt64, numViewsInStakingAuction: UInt64, numViewsInDKGPhase: UInt64, numCollectorClusters: UInt16, FLOWsupplyIncreasePercentage: UFix64) {
@@ -331,6 +332,12 @@ pub contract FlowEpoch {
 
             FlowEpoch.configurableMetadata.FLOWsupplyIncreasePercentage = newPercentage
         }
+
+        // Enable or disable automatic rewards calculations and payments
+        pub fun updateAutomaticRewardsEnabled(_ enabled: Bool) {
+            FlowEpoch.account.load<Bool>(from: /storage/flowAutomaticRewardsEnabled)
+            FlowEpoch.account.save(enabled, to: /storage/flowAutomaticRewardsEnabled)
+        }
     }
 
     /// Resource that is controlled by the protocol and is used
@@ -357,8 +364,11 @@ pub contract FlowEpoch {
                     let currentBlock = getCurrentBlock()
                     let currentEpochMetadata = FlowEpoch.getEpochMetadata(FlowEpoch.currentEpochCounter)!
                     if currentBlock.view >= currentEpochMetadata.endView {
-                        self.calculateAndSetRewards(nil)
+                        self.calculateAndSetRewards()
                         self.endEpoch()
+                        if FlowEpoch.automaticRewardsEnabled() {
+                            self.payRewards()
+                        }
                     }
                 default:
                     return
@@ -399,8 +409,8 @@ pub contract FlowEpoch {
 
         /// Needs to be called before the epoch is over
         /// Calculates rewards for the current epoch and stores them in epoch metadata
-        pub fun calculateAndSetRewards(_ newPayout: UFix64?) {
-            FlowEpoch.calculateAndSetRewards(newPayout)
+        pub fun calculateAndSetRewards() {
+            FlowEpoch.calculateAndSetRewards()
         }
 
         pub fun payRewards() {
@@ -438,8 +448,6 @@ pub contract FlowEpoch {
                 FlowEpoch.borrowDKGAdmin().forceEndDKG()
             }
 
-            FlowEpoch.calculateAndSetRewards(newPayout)
-
             // Start a new Epoch, which increments the current epoch counter
             FlowEpoch.startNewEpoch()
 
@@ -462,21 +470,37 @@ pub contract FlowEpoch {
 
     /// Calculates a new token payout for the current epoch
     /// and sets the new payout for the next epoch
-    access(account) fun calculateAndSetRewards(_ newPayout: UFix64?) {
+    access(account) fun calculateAndSetRewards() {
 
-        let rewardsBreakdown = self.borrowStakingAdmin().calculateRewards()
+        let stakingAdmin = self.borrowStakingAdmin()
+
+        // Calculate rewards for the current epoch that is about to end
+        // and save that reward breakdown in the epoch metadata for the current epoch
+        let rewardsBreakdown = stakingAdmin.calculateRewards()
         let currentMetadata = self.getEpochMetadata(self.currentEpochCounter)!
         currentMetadata.setRewardAmounts(rewardsBreakdown)
         self.saveEpochMetadata(currentMetadata)
 
-        // Calculate the new epoch's payout
-        // disabled until we enable automated rewards calculations
-        // let newPayout = FlowToken.totalSupply * (FlowEpoch.configurableMetadata.FLOWsupplyIncreasePercentage / 52.0)
+        if FlowEpoch.automaticRewardsEnabled() {
+            // Calculate the total supply of FLOW after the current epoch's payout
+            // the calculation includes the tokens that haven't been minted for the current epoch yet
+            let currentPayout = FlowIDTableStaking.getEpochTokenPayout()
+            let feeAmount = FlowFees.getFeeBalance()
+            var flowTotalSupplyAfterPayout = 0.0
+            if feeAmount >= currentPayout {
+                flowTotalSupplyAfterPayout = FlowToken.totalSupply
+            } else {
+                flowTotalSupplyAfterPayout = FlowToken.totalSupply + (currentPayout - feeAmount)
+            }
+
+            // Calculate the payout for the next epoch
+            let proposedPayout = flowTotalSupplyAfterPayout * FlowEpoch.configurableMetadata.FLOWsupplyIncreasePercentage
 
-        if let payout = newPayout {
-            self.borrowStakingAdmin().setEpochTokenPayout(payout)
-            let proposedMetadata = self.getEpochMetadata(self.proposedEpochCounter())!
-            proposedMetadata.setTotalRewards(payout)
+            // Set the new payout in the staking contract and proposed Epoch Metadata
+            self.borrowStakingAdmin().setEpochTokenPayout(proposedPayout)
+            let proposedMetadata = self.getEpochMetadata(self.proposedEpochCounter())
+                ?? panic("Cannot set rewards for the next epoch becuase it hasn't been proposed yet")
+            proposedMetadata.setTotalRewards(proposedPayout)
             self.saveEpochMetadata(proposedMetadata)
         }
     }
@@ -767,6 +791,10 @@ pub contract FlowEpoch {
         return self.currentEpochCounter + 1 as UInt64
     }
 
+    pub fun automaticRewardsEnabled(): Bool {
+        return self.account.copy<Bool>(from: /storage/flowAutomaticRewardsEnabled) ?? false
+    }
+
     init (currentEpochCounter: UInt64,
           numViewsInEpoch: UInt64, 
           numViewsInStakingAuction: UInt64, 

lib/go/contracts/contracts.go

@@ -264,6 +264,7 @@ func FlowEpoch(fungibleTokenAddress,
 	idTableAddress,
 	qcAddress,
 	dkgAddress string,
+	flowFeesAddress string,
 ) []byte {
 	code := assets.MustAssetString(flowEpochFilename)
 
@@ -272,6 +273,7 @@ func FlowEpoch(fungibleTokenAddress,
 	code = strings.ReplaceAll(code, placeholderIDTableAddress, withHexPrefix(idTableAddress))
 	code = strings.ReplaceAll(code, placeholderQCAddr, withHexPrefix(qcAddress))
 	code = strings.ReplaceAll(code, placeholderDKGAddr, withHexPrefix(dkgAddress))
+	code = strings.ReplaceAll(code, placeholderFlowFeesAddress, withHexPrefix(flowFeesAddress))
 
 	return []byte(code)
 }

lib/go/contracts/internal/assets/assets.go

@@ -17,6 +17,7 @@ const (
 	resetEpochFilename               = "epoch/admin/reset_epoch.cdc"
 	epochCalculateSetRewardsFilename = "epoch/admin/calculate_rewards.cdc"
 	epochPayRewardsFilename          = "epoch/admin/pay_rewards.cdc"
+	epochSetAutoRewardsFilename      = "epoch/admin/set_automatic_rewards.cdc"
 
 	// Node Transactions
 	epochRegisterNodeFilename           = "epoch/node/register_node.cdc"
@@ -30,6 +31,7 @@ const (
 	getConfigMetadataFilename       = "epoch/scripts/get_config_metadata.cdc"
 	getEpochPhaseFilename           = "epoch/scripts/get_epoch_phase.cdc"
 	getCurrentViewFilename          = "epoch/scripts/get_current_view.cdc"
+	getFlowTotalSupplyFilename      = "flowToken/scripts/get_supply.cdc"
 
 	// test scripts
 	getRandomizeFilename      = "epoch/scripts/get_randomize.cdc"
@@ -106,6 +108,12 @@ func GenerateEpochPayRewardsScript(env Environment) []byte {
 	return []byte(replaceAddresses(code, env))
 }
 
+func GenerateEpochSetAutomaticRewardsScript(env Environment) []byte {
+	code := assets.MustAssetString(epochSetAutoRewardsFilename)
+
+	return []byte(replaceAddresses(code, env))
+}
+
 // Node Templates -----------------------------------------------
 
 func GenerateEpochRegisterNodeScript(env Environment) []byte {
@@ -175,3 +183,9 @@ func GenerateGetCurrentViewScript(env Environment) []byte {
 
 	return []byte(replaceAddresses(code, env))
 }
+
+func GenerateGetFlowTotalSupplyScript(env Environment) []byte {
+	code := assets.MustAssetString(getFlowTotalSupplyFilename)
+
+	return []byte(replaceAddresses(code, env))
+}