Don't create machine accounts for non-consensus or collection nodes (#244)

* generate quorum certificate even if a node hasn't submitted

* dont create machine account for non collection or consensus

Author: joshuahannan

contracts/FlowStakingCollection.cdc

@@ -407,9 +407,15 @@ pub contract FlowStakingCollection {
             let nodeReference = self.borrowNode(id)
                 ?? panic("Could not borrow node reference")
 
+            let nodeInfo = FlowIDTableStaking.NodeInfo(nodeID: nodeReference.id)
+
             // Register the machine account for the node
             // creates an auth account object and returns it to the caller
-            return self.registerMachineAccount(nodeReference: nodeReference, payer: payer)
+            if nodeInfo.role == FlowEpoch.NodeRole.Collector.rawValue || nodeInfo.role == FlowEpoch.NodeRole.Consensus.rawValue {
+                return self.registerMachineAccount(nodeReference: nodeReference, payer: payer)
+            } else {
+                return nil
+            }
         }
 
         /// Registers the secondary machine account for a node

contracts/epochs/FlowClusterQC.cdc

@@ -149,9 +149,13 @@ pub contract FlowClusterQC {
                 // Add the signatures, messages, and node IDs only for votes
                 // that match the votes that reached quorum
                 for vote in self.generatedVotes.values {
-                    if vote.message! == quorumMessage {
-                        certificate.voteSignatures.append(vote.signature!)
-                        certificate.voterIDs.append(vote.nodeID)
+                    
+                    // Only count votes that were submitted
+                    if let submittedMessage = vote.message {
+                        if submittedMessage == quorumMessage {
+                            certificate.voteSignatures.append(vote.signature!)
+                            certificate.voterIDs.append(vote.nodeID)
+                        }
                     }
                 }
 

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

@@ -27,12 +27,13 @@ const (
 	getVotingCompletedFilename = "quorumCertificate/scripts/get_voting_completed.cdc"
 	getClusterVotesFilename    = "quorumCertificate/scripts/get_cluster_votes.cdc"
 
-	getClusterVoteThresholdFilename = "quorumCertificate/scripts/get_cluster_vote_threshold.cdc"
-	getClusterWeightFilename        = "quorumCertificate/scripts/get_cluster_weight.cdc"
-	getClusterNodeWeightsFilename   = "quorumCertificate/scripts/get_cluster_node_weights.cdc"
-	getNodeWeightFilename           = "quorumCertificate/scripts/get_node_weight.cdc"
-	getVoterIsRegisteredFilename    = "quorumCertificate/scripts/get_voter_is_registered.cdc"
-	getNodeHasVotedFilename         = "quorumCertificate/scripts/get_node_has_voted.cdc"
+	getClusterVoteThresholdFilename   = "quorumCertificate/scripts/get_cluster_vote_threshold.cdc"
+	getClusterWeightFilename          = "quorumCertificate/scripts/get_cluster_weight.cdc"
+	getClusterNodeWeightsFilename     = "quorumCertificate/scripts/get_cluster_node_weights.cdc"
+	getNodeWeightFilename             = "quorumCertificate/scripts/get_node_weight.cdc"
+	getVoterIsRegisteredFilename      = "quorumCertificate/scripts/get_voter_is_registered.cdc"
+	getNodeHasVotedFilename           = "quorumCertificate/scripts/get_node_has_voted.cdc"
+	generateQuorumCertificateFilename = "quorumCertificate/scripts/generate_quorum_certificate.cdc"
 )
 
 // Admin Templates -----------------------------------------------------------
@@ -146,3 +147,9 @@ func GenerateGetNodeHasVotedScript(env Environment) []byte {
 
 	return []byte(replaceAddresses(code, env))
 }
+
+func GenerateGenerateQuorumCertificateScript(env Environment) []byte {
+	code := assets.MustAssetString(generateQuorumCertificateFilename)
+
+	return []byte(replaceAddresses(code, env))
+}

lib/go/templates/flow_qc_templates.go

@@ -723,3 +723,124 @@ func TestQuorumCertificateMoreNodes(t *testing.T) {
 		assert.Equal(t, cadence.NewBool(true), result)
 	})
 }
+
+func TestQuorumCertificateNotSubmittedVote(t *testing.T) {
+	b := newBlockchain()
+
+	env := templates.Environment{
+		FungibleTokenAddress: emulatorFTAddress,
+		FlowTokenAddress:     emulatorFlowTokenAddress,
+	}
+
+	accountKeys := test.AccountKeyGenerator()
+
+	// Create new keys for the QC account and deploy
+	QCAccountKey, QCSigner := accountKeys.NewWithSigner()
+	QCCode := contracts.FlowQC()
+
+	QCAddress, err := b.CreateAccount([]*flow.AccountKey{QCAccountKey}, []sdktemplates.Contract{
+		{
+			Name:   "FlowClusterQC",
+			Source: string(QCCode),
+		},
+	})
+	if !assert.NoError(t, err) {
+		t.Log(err.Error())
+	}
+
+	env.QuorumCertificateAddress = QCAddress.Hex()
+
+	collectorVoteHasher := flow_crypto.NewBLSKMAC(encoding.CollectorVoteTag)
+
+	tx := createTxWithTemplateAndAuthorizer(b, templates.GeneratePublishVoterScript(env), QCAddress)
+
+	signAndSubmit(
+		t, b, tx,
+		[]flow.Address{b.ServiceKey().Address, QCAddress},
+		[]crypto.Signer{b.ServiceKey().Signer(), QCSigner},
+		false,
+	)
+
+	numberOfClusters := 1
+	numberOfNodesPerCluster := 4
+
+	// Create new user accounts
+	addresses, _, signers := registerAndMintManyAccounts(t, b, accountKeys, numberOfClusters*numberOfNodesPerCluster)
+
+	clusterNodeIDStrings := make([][]string, numberOfClusters*numberOfNodesPerCluster)
+
+	stakingPrivateKeys, stakingPublicKeys, _, _ := generateManyNodeKeys(t, numberOfClusters*numberOfNodesPerCluster)
+
+	// initializes clusters by filling them all in in order
+	// Other tests continue this cluster organization assumption
+	startVotingArguments := initClusters(clusterNodeIDStrings, numberOfClusters, numberOfNodesPerCluster)
+
+	tx = createTxWithTemplateAndAuthorizer(b, templates.GenerateStartVotingScript(env), QCAddress)
+
+	err = tx.AddArgument(cadence.NewArray(startVotingArguments[0]))
+	require.NoError(t, err)
+
+	err = tx.AddArgument(cadence.NewArray(startVotingArguments[1]))
+	require.NoError(t, err)
+
+	err = tx.AddArgument(cadence.NewArray(startVotingArguments[2]))
+	require.NoError(t, err)
+
+	signAndSubmit(
+		t, b, tx,
+		[]flow.Address{b.ServiceKey().Address, QCAddress},
+		[]crypto.Signer{b.ServiceKey().Signer(), QCSigner},
+		false,
+	)
+
+	// Claim voter resources
+	for i := 0; i < numberOfClusters*numberOfNodesPerCluster; i++ {
+
+		tx := createTxWithTemplateAndAuthorizer(b, templates.GenerateCreateVoterScript(env), addresses[i])
+
+		_ = tx.AddArgument(cadence.NewAddress(QCAddress))
+		_ = tx.AddArgument(cadence.NewString(clusterNodeIDStrings[i/numberOfNodesPerCluster][i%numberOfNodesPerCluster]))
+		_ = tx.AddArgument(cadence.NewString(stakingPublicKeys[i]))
+
+		signAndSubmit(
+			t, b, tx,
+			[]flow.Address{b.ServiceKey().Address, addresses[i]},
+			[]crypto.Signer{b.ServiceKey().Signer(), signers[i]},
+			false,
+		)
+	}
+
+	t.Run("Should generate a valid quorum certificate even if a node hasn't voted", func(t *testing.T) {
+
+		for i := 0; i < numberOfNodesPerCluster-1; i++ {
+
+			// Construct a valid message and signature
+			msg, _ := hex.DecodeString("deadbeef")
+			validSignature, err := stakingPrivateKeys[i].Sign(msg, collectorVoteHasher)
+			validSignatureString := validSignature.String()[2:]
+			assert.NoError(t, err)
+
+			tx := createTxWithTemplateAndAuthorizer(b, templates.GenerateSubmitVoteScript(env), addresses[i])
+
+			_ = tx.AddArgument(cadence.NewString(validSignatureString))
+			_ = tx.AddArgument(cadence.NewString("deadbeef"))
+
+			signAndSubmit(
+				t, b, tx,
+				[]flow.Address{b.ServiceKey().Address, addresses[i]},
+				[]crypto.Signer{b.ServiceKey().Signer(), signers[i]},
+				false,
+			)
+		}
+
+		result := executeScriptAndCheck(t, b, templates.GenerateGetVotingCompletedScript(env), nil)
+		assert.Equal(t, cadence.NewBool(true), result)
+
+		result = executeScriptAndCheck(t, b, templates.GenerateGetClusterCompleteScript(env), [][]byte{jsoncdc.MustEncode(cadence.UInt16(uint16(0)))})
+		assert.Equal(t, cadence.NewBool(true), result)
+
+		executeScriptAndCheck(t, b, templates.GenerateGenerateQuorumCertificateScript(env), [][]byte{jsoncdc.MustEncode(cadence.UInt16(uint16(0)))})
+
+	})
+
+}

lib/go/templates/internal/assets/assets.go

@@ -0,0 +1,12 @@
+import FlowClusterQC from 0xQCADDRESS
+
+// Gets the status of a cluster's QC generation
+
+pub fun main(clusterIndex: UInt16): FlowClusterQC.ClusterQC {
+
+    let clusters = FlowClusterQC.getClusters()
+
+    return clusters[clusterIndex].generateQuorumCertificate()
+        ?? panic("Could not generate quorum certificate")
+
+}