Adds approved list and node id hex restriction (#224)

* removing added field

* remove address check

* remove access node requirement

* adds approved list and node id hex restriction

* remove unnecessary lines from advance view

Author: joshuahannan

contracts/FlowIDTableStaking.cdc

@@ -160,6 +160,7 @@ pub contract FlowIDTableStaking {
         ) {
             pre {
                 id.length == 64: "Node ID length must be 32 bytes (64 hex characters)"
+                FlowIDTableStaking.isValidNodeID(id): "The node ID must have only numbers and lowercase hex characters"
                 FlowIDTableStaking.nodes[id] == nil: "The ID cannot already exist in the record"
                 role >= UInt8(1) && role <= UInt8(5): "The role must be 1, 2, 3, 4, or 5"
                 networkingAddress.length > 0 && networkingAddress.length <= 510: "The networkingAddress must be less than 255 bytes (510 hex characters)"
@@ -728,6 +729,15 @@ pub contract FlowIDTableStaking {
             return <-node
         }
 
+        /// Sets a list of approved node IDs for the next epoch
+        /// Nodes not on this list will be unstaked at the end of the staking auction
+        /// and not considered to be a proposed/staked node
+        pub fun setApprovedList(_ nodeIDs: [String]) {
+            let list = FlowIDTableStaking.account.load<[String]>(from: /storage/idTableApproveList)
+
+            FlowIDTableStaking.account.save<[String]>(nodeIDs, to: /storage/idTableApproveList)
+        }
+
         /// Starts the staking auction, the period when nodes and delegators
         /// are allowed to perform staking related operations
         pub fun startStakingAuction() {
@@ -737,7 +747,13 @@ pub contract FlowIDTableStaking {
 
         /// Ends the staking Auction by removing any unapproved nodes
         /// and setting stakingEnabled to false
-        pub fun endStakingAuction(approvedNodeIDs: {String: Bool}) {
+        pub fun endStakingAuction() {
+            let approvedList = FlowIDTableStaking.getApprovedList()
+            let approvedNodeIDs: {String: Bool} = {}
+            for id in approvedList {
+                approvedNodeIDs[id] = true
+            }
+
             self.removeUnapprovedNodes(approvedNodeIDs: approvedNodeIDs)
 
             FlowIDTableStaking.account.load<Bool>(from: /storage/stakingEnabled)
@@ -945,6 +961,9 @@ pub contract FlowIDTableStaking {
             // Start the new epoch's staking auction
             self.startStakingAuction()
 
+            // Set the current Epoch node list
+            FlowIDTableStaking.setCurrentNodeList(FlowIDTableStaking.getApprovedList())
+
             // Indicates that the tokens have moved and the epoch has ended
             // Tells what the new reward payout will be. The new payout is calculated and changed
             // before this method is executed and will not be changed for the rest of the epoch
@@ -1067,21 +1086,50 @@ pub contract FlowIDTableStaking {
         self.account.save(claimedDictionary, to: path)
     }
 
+    /// Sets a list of approved node IDs for the current epoch
+    access(contract) fun setCurrentNodeList(_ nodeIDs: [String]) {
+        let list = self.account.load<[String]>(from: /storage/idTableCurrentList)
+
+        self.account.save<[String]>(nodeIDs, to: /storage/idTableCurrentList)
+    }
+
+    /// Checks if the given string has all numbers or lowercase hex characters
+    /// Used to ensure that there are no duplicate node IDs
+    pub fun isValidNodeID(_ input: String): Bool {
+        let byteVersion = input.utf8
+
+        for character in byteVersion {
+            if ((character < 48) || (character > 57 && character < 97) || (character > 102)) {
+                return false
+            }
+        }
+
+        return true
+    }
+
     /// Indicates if the staking auction is currently enabled
     pub fun stakingEnabled(): Bool {
         return self.account.copy<Bool>(from: /storage/stakingEnabled) ?? false
     }
 
-    /// Gets an array of the node IDs that are proposed for the next epoch
+    /// Gets an array of the node IDs that are proposed and approved for the next epoch
     pub fun getProposedNodeIDs(): [String] {
         var proposedNodes: [String] = []
 
+        let approvedList = FlowIDTableStaking.getApprovedList()
+        let approvedNodeIDs: {String: Bool} = {}
+        for id in approvedList {
+            approvedNodeIDs[id] = true
+        }
+
         for nodeID in FlowIDTableStaking.getNodeIDs() {
             let nodeRecord = FlowIDTableStaking.borrowNodeRecord(nodeID)
+            let approved = approvedNodeIDs[nodeID] ?? false
 
             // To be considered proposed, a node has to have tokens staked + committed equal or above the minimum
             // Access nodes have a minimum of 0, so they need to be strictly greater than zero to be considered proposed
             if self.isGreaterThanMinimumForRole(numTokens: self.NodeInfo(nodeID: nodeRecord.id).totalCommittedWithoutDelegators(), role: nodeRecord.role)
+               && approved
             {
                 proposedNodes.append(nodeID)
             }
@@ -1096,12 +1144,21 @@ pub contract FlowIDTableStaking {
     pub fun getStakedNodeIDs(): [String] {
         var stakedNodes: [String] = []
 
+        let currentList = self.account.copy<[String]>(from: /storage/idTableCurrentList)
+            ?? panic("Could not get current list")
+        let currentNodeIDs: {String: Bool} = {}
+        for id in currentList {
+            currentNodeIDs[id] = true
+        }
+
         for nodeID in FlowIDTableStaking.getNodeIDs() {
             let nodeRecord = FlowIDTableStaking.borrowNodeRecord(nodeID)
+            let current = currentNodeIDs[nodeID] ?? false
 
             // To be considered staked, a node has to have tokens staked equal or above the minimum
             // Access nodes have a minimum of 0, so they need to be strictly greater than zero to be considered staked
             if self.isGreaterThanMinimumForRole(numTokens: nodeRecord.tokensStaked.balance, role: nodeRecord.role)
+               && current
             {
                 stakedNodes.append(nodeID)
             }
@@ -1142,6 +1199,12 @@ pub contract FlowIDTableStaking {
         return claimedDictionary[key] ?? false
     }
 
+    /// Returns the list of approved node IDs that the admin has set
+    pub fun getApprovedList(): [String] {
+        return self.account.copy<[String]>(from: /storage/idTableApproveList)
+            ?? panic("could not get approved list")
+    }
+
     /// Gets the minimum stake requirements for all the node types
     pub fun getMinimumStakeRequirements(): {UInt8: UFix64} {
         return self.minimumStakeRequired
@@ -1203,6 +1266,10 @@ pub contract FlowIDTableStaking {
         self.nodeDelegatingRewardCut = rewardCut
         self.rewardRatios = {UInt8(1): 0.168, UInt8(2): 0.518, UInt8(3): 0.078, UInt8(4): 0.236, UInt8(5): 0.0}
 
+        let list: [String] = []
+        self.setCurrentNodeList(list)
+        self.account.save<[String]>(list, to: /storage/idTableApproveList)
+
         self.account.save(<-create Admin(), to: self.StakingAdminStoragePath)
     }
 }

contracts/epochs/FlowEpoch.cdc

@@ -349,17 +349,7 @@ pub contract FlowEpoch {
             switch FlowEpoch.currentEpochPhase {
                 case EpochPhase.STAKINGAUCTION:
                     if currentBlock.view >= currentEpochMetadata.stakingEndView {
-                        let ids = FlowIDTableStaking.getProposedNodeIDs()
-
-                        let approvedIDs: {String: Bool} = {}
-                        for id in ids {
-                            // Here is where we would make sure that each node's 
-                            // keys and addresses are correct, they haven't committed any violations,
-                            // and are operating properly
-                            // for now we just set approved to true for all
-                            approvedIDs[id] = true
-                        }
-                        self.endStakingAuction(approvedIDs: approvedIDs)
+                        self.endStakingAuction()
                     }
                 case EpochPhase.EPOCHSETUP:
                     if FlowClusterQC.votingCompleted() && (FlowDKG.dkgCompleted() != nil) {
@@ -377,12 +367,12 @@ pub contract FlowEpoch {
 
         /// Calls `FlowEpoch` functions to end the staking auction phase
         /// and start the Epoch Setup phase
-        pub fun endStakingAuction(approvedIDs: {String: Bool}) {
+        pub fun endStakingAuction() {
             pre {
                 FlowEpoch.currentEpochPhase == EpochPhase.STAKINGAUCTION: "Can only end staking auction during the staking auction"
             }
 
-            FlowEpoch.endStakingAuction(approvedIDs: approvedIDs)
+            FlowEpoch.endStakingAuction()
 
             FlowEpoch.startEpochSetup(randomSource: unsafeRandom().toString())
         }
@@ -516,8 +506,8 @@ pub contract FlowEpoch {
     }
 
     /// Ends the staking Auction with all the proposed nodes approved
-    access(account) fun endStakingAuction(approvedIDs: {String: Bool}) {
-        self.borrowStakingAdmin().endStakingAuction(approvedNodeIDs: approvedIDs)
+    access(account) fun endStakingAuction() {
+        self.borrowStakingAdmin().endStakingAuction()
     }
 
     /// Starts the EpochSetup phase and emits the epoch setup event

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

@@ -10,6 +10,7 @@ const (
 	removeNodeFilename              = "idTableStaking/admin/remove_node.cdc"
 	endStakingFilename              = "idTableStaking/admin/end_staking.cdc"
 	removeUnapprovedNodesFilename   = "idTableStaking/admin/remove_unapproved_nodes.cdc"
+	setApprovedNodesFilename        = "idTableStaking/admin/set_approved_nodes.cdc"
 	payRewardsFilename              = "idTableStaking/admin/pay_rewards.cdc"
 	moveTokensFilename              = "idTableStaking/admin/move_tokens.cdc"
 	endEpochFilename                = "idTableStaking/admin/end_epoch.cdc"
@@ -103,6 +104,12 @@ func GenerateRemoveUnapprovedNodesScript(env Environment) []byte {
 	return []byte(replaceAddresses(code, env))
 }
 
+func GenerateSetApprovedNodesScript(env Environment) []byte {
+	code := assets.MustAssetString(setApprovedNodesFilename)
+
+	return []byte(replaceAddresses(code, env))
+}
+
 // GeneratePayRewardsScript creates a script that pays rewards
 func GeneratePayRewardsScript(env Environment) []byte {
 	code := assets.MustAssetString(payRewardsFilename)