Merge pull request #166 from canopy-network/issue-#151

issue-#151

Author: andrewnguyen22

bft/bft.go

@@ -13,12 +13,12 @@ import (
 
 // BFT is a structure that holds data for a Hotstuff BFT instance
 type BFT struct {
-	*lib.View                            // the current period during which the BFT is occurring (CreatedHeight/Round/Phase)
+	*lib.View                            // the current period during which the BFT is occurring (Height/Round/Phase)
 	Votes         VotesForHeight         // 'votes' received from Replica (non-leader) Validators
 	Proposals     ProposalsForHeight     // 'proposals' received from the Leader Validator(s)
 	ProposerKey   []byte                 // the public key of the proposer
 	ValidatorSet  ValSet                 // the current set of Validators
-	HighQC        *QC                    // the highest PRECOMMIT quorum certificate the node is aware of for this CreatedHeight
+	HighQC        *QC                    // the highest PRECOMMIT quorum certificate the node is aware of for this Height
 	Block         []byte                 // the current Block being voted on (the foundational unit of the blockchain)
 	BlockHash     []byte                 // the current hash of the block being voted on
 	Results       *lib.CertificateResult // the current Result being voted on (reward and slash recipients)
@@ -101,6 +101,8 @@ func (b *BFT) Start() {
 			func() {
 				b.Controller.Lock()
 				defer b.Controller.Unlock()
+				// Update BFT metrics
+				defer b.Metrics.UpdateBFTMetrics(b.Height, b.RootHeight, b.Round, b.Phase, time.Now())
 				// handle the phase
 				b.HandlePhase()
 			}()
@@ -240,7 +242,7 @@ func (b *BFT) StartElectionVotePhase() {
 			Header:      b.View.Copy(),
 			ProposerKey: b.ProposerKey, // using voting power, authorizes Candidate to act as the 'Leader'
 		},
-		HighQc:                 b.HighQC,                         // forward highest known 'Lock' for this CreatedHeight, so the new Proposer may satisfy SAFE-NODE-PREDICATE
+		HighQc:                 b.HighQC,                         // forward highest known 'Lock' for this Height, so the new Proposer may satisfy SAFE-NODE-PREDICATE
 		LastDoubleSignEvidence: b.ByzantineEvidence.DSE.Evidence, // forward any evidence of DoubleSigning
 		Vdf:                    b.HighVDF,                        // forward local VDF to the candidate
 	})
@@ -249,7 +251,7 @@ func (b *BFT) StartElectionVotePhase() {
 // StartProposePhase() begins the ProposePhase after the ELECTION-VOTE phase timeout
 // PROPOSE PHASE:
 // - Leader reviews the collected vote messages from Replicas
-//   - Determines the highest 'lock' (HighQC) if one exists for this CreatedHeight
+//   - Determines the highest 'lock' (HighQC) if one exists for this Height
 //   - Combines any ByzantineEvidence sent from Replicas into their own
 //   - Aggregates the signatures from the Replicas to form a +2/3 threshold multi-signature
 //
@@ -292,7 +294,7 @@ func (b *BFT) StartProposePhase() {
 // StartProposeVotePhase() begins the ProposeVote after the PROPOSE phase timeout
 // PROPOSE-VOTE PHASE:
 // - Replica reviews the message from the Leader by validating the justification (+2/3 multi-sig) proving that they are in-fact the leader
-// - If the Replica is currently Locked on a previous Proposal for this CreatedHeight, the new Proposal must pass the SAFE-NODE-PREDICATE
+// - If the Replica is currently Locked on a previous Proposal for this Height, the new Proposal must pass the SAFE-NODE-PREDICATE
 // - Replica Validates the proposal using the byzantine evidence and the specific plugin
 // - Replicas send a signed (aggregable) PROPOSE vote to the Leader
 func (b *BFT) StartProposeVotePhase() {
@@ -592,8 +594,6 @@ func (b *BFT) NewHeight(keepLocks ...bool) {
 	b.Height = b.Controller.ChainHeight()
 	// update canopy height
 	b.RootHeight = b.Controller.RootChainHeight()
-	// Update BFT metrics
-	b.Metrics.UpdateBFTMetrics(b.Height, b.RootHeight)
 	// update the validator set
 	b.ValidatorSet, err = b.Controller.LoadCommittee(b.LoadRootChainId(b.Height), b.RootHeight)
 	if err != nil {

bft/election.go

@@ -9,7 +9,7 @@ import (
 /*
 	ELECTION SORTITION:
 
-		1) Practical VRF: Hash(BLS.Signature(Last Proposers Addresses + CreatedHeight + Round)): a cryptographic
+		1) Practical VRF: Hash(BLS.Signature(Last Proposers Addresses + Height + Round)): a cryptographic
 		function that produces a random output that can be publicly verified. In BFT, each participant in
 		the network uses their private key to create a digital signature against Sortition seed data which
 		may be publicly verified using their Public Key.

controller/block.go

@@ -314,7 +314,7 @@ func (c *Controller) CommitCertificate(qc *lib.QuorumCertificate, block *lib.Blo
 		go c.RCManager.Publish(id, info)
 	}
 	// update telemetry
-	c.UpdateTelemetry(block, time.Since(start))
+	defer c.UpdateTelemetry(qc, block, time.Since(start))
 	// exit
 	return
 }
@@ -411,6 +411,8 @@ func (c *Controller) HandlePeerBlock(msg *lib.BlockMessage, syncing bool) (*lib.
 			// exit with error
 			return nil, lib.ErrNoMaj23()
 		}
+		// update the non signer percent for the validators
+		c.Metrics.UpdateNonSignerPercent(qc.Signature, v)
 	}
 	// ensure the proposal inside the quorum certificate is valid at a stateless level
 	block, err := qc.CheckProposalBasic(c.FSM.Height(), c.Config.NetworkID, c.Config.ChainId)
@@ -505,13 +507,17 @@ func (c *Controller) SetFSMInConsensusModeForProposals() (reset func()) {
 }
 
 // UpdateTelemetry() updates the prometheus metrics after 'committing' a block
-func (c *Controller) UpdateTelemetry(block *lib.Block, blockProcessingTime time.Duration) {
-	// get the address of this node
-	address := crypto.NewAddressFromBytes(c.Address)
+func (c *Controller) UpdateTelemetry(qc *lib.QuorumCertificate, block *lib.Block, blockProcessingTime time.Duration) {
+	// create convenience variables
+	address, vdfIterations := crypto.NewAddressFromBytes(c.Address), uint64(0)
+	// attempt to get VDF iterations
+	if block.BlockHeader.Vdf != nil {
+		vdfIterations = block.BlockHeader.Vdf.Iterations
+	}
 	// update node metrics
 	c.Metrics.UpdateNodeMetrics(c.isSyncing.Load())
 	// update the block metrics
-	c.Metrics.UpdateBlockMetrics(block.BlockHeader.ProposerAddress, len(block.Transactions), blockProcessingTime)
+	c.Metrics.UpdateBlockMetrics(block.BlockHeader.ProposerAddress, uint64(len(qc.Block)), block.BlockHeader.NumTxs, vdfIterations, blockProcessingTime)
 	// update validator metric
 	if v, _ := c.FSM.GetValidator(address); v != nil && v.StakedAmount != 0 {
 		c.Metrics.UpdateValidator(address.String(), v.StakedAmount, v.UnstakingHeight != 0, v.MaxPausedHeight != 0, v.Delegate, v.Compound)

controller/controller.go

@@ -45,7 +45,7 @@ func New(fsm *fsm.StateMachine, c lib.Config, valKey crypto.PrivateKeyI, metrics
 		return
 	}
 	// initialize the mempool using the FSM copy and the mempool config
-	mempool, err := NewMempool(fsm, c.MempoolConfig, l)
+	mempool, err := NewMempool(fsm, c.MempoolConfig, metrics, l)
 	// if an error occurred when creating a new mempool
 	if err != nil {
 		// exit with error

controller/tx.go

@@ -132,15 +132,17 @@ type Mempool struct {
 	FSM             *fsm.StateMachine  // the ephemeral finite state machine used to validate inbound transactions
 	cachedResults   lib.TxResults      // a memory cache of transaction results for efficient verification
 	cachedFailedTxs *lib.FailedTxCache // a memory cache of failed transactions for tracking
+	metrics         *lib.Metrics       // telemetry
 	log             lib.LoggerI        // the logger
 }
 
 // NewMempool() creates a new instance of a Mempool structure
-func NewMempool(fsm *fsm.StateMachine, config lib.MempoolConfig, log lib.LoggerI) (m *Mempool, err lib.ErrorI) {
+func NewMempool(fsm *fsm.StateMachine, config lib.MempoolConfig, metrics *lib.Metrics, log lib.LoggerI) (m *Mempool, err lib.ErrorI) {
 	// initialize the structure
 	m = &Mempool{
 		Mempool:         lib.NewMempool(config),
 		cachedFailedTxs: lib.NewFailedTxCache(),
+		metrics:         metrics,
 		log:             log,
 	}
 	// make an 'mempool (ephemeral copy) state' so the mempool can maintain only 'valid' transactions despite dependencies and conflicts
@@ -238,6 +240,8 @@ func (m *Mempool) checkMempool() {
 		// delete the transaction
 		m.DeleteTransaction(tx)
 	}
+	// update the mempool metrics
+	m.metrics.UpdateMempoolMetrics(m.Mempool.TxCount(), m.Mempool.TxsBytes())
 }
 
 // applyAndWriteTx() checks the validity of a transaction by playing it against the mempool (ephemeral copy) state machine

fsm/message.pb.go

@@ -3,6 +3,7 @@ package fsm
 import (
 	"runtime/debug"
 	"strings"
+	"time"
 
 	"github.com/canopy-network/canopy/lib"
 	"github.com/canopy-network/canopy/lib/crypto"
@@ -155,6 +156,7 @@ func (s *StateMachine) ApplyTransactions(block *lib.Block) (txResultsList []*lib
 	// define vars to track the bytes of the transaction results and the size of a block
 	var (
 		txResultsBytes [][]byte
+		largestTxSize  uint64
 		blockSize      uint64
 	)
 	// use a map to check for 'same-block' duplicate transactions
@@ -181,8 +183,15 @@ func (s *StateMachine) ApplyTransactions(block *lib.Block) (txResultsList []*lib
 		txResultsList = append(txResultsList, result)
 		// add the bytes to the list of transactions results
 		txResultsBytes = append(txResultsBytes, txResultBz)
+		// get the tx size
+		txSize := uint64(len(tx))
 		// add to the size of the block
-		blockSize += uint64(len(tx))
+		blockSize += txSize
+		// see if the size is the largest
+		if txSize > largestTxSize {
+			// set as largest
+			largestTxSize = txSize
+		}
 		// update the transaction count
 		n++
 	}
@@ -197,6 +206,8 @@ func (s *StateMachine) ApplyTransactions(block *lib.Block) (txResultsList []*lib
 	}
 	// create a transaction root for the block header
 	root, _, err = lib.MerkleTree(txResultsBytes)
+	// update metrics
+	s.Metrics.UpdateLargestTxSize(largestTxSize)
 	// return and exit
 	return txResultsList, root, n, err
 }
@@ -332,6 +343,8 @@ func (s *StateMachine) GetMaxBlockSize() (uint64, lib.ErrorI) {
 
 // GetRootChainInfo() returns the 'need-to-know' information for a nested chain
 func (s *StateMachine) GetRootChainInfo(id uint64) (*lib.RootChainInfo, lib.ErrorI) {
+	// update the metrics once complete
+	defer s.Metrics.UpdateGetRootChainInfo(time.Now())
 	// get the previous state machine height
 	lastSM, err := s.TimeMachine(s.Height() - 1)
 	if err != nil {

fsm/state.go

@@ -193,7 +193,7 @@ message MessageEditOrder {
   // not modifiable, used for order identification only
   uint64 ChainId = 2; // @gotags: json:"chainID"
   // amount_for_sale: the updated amount of uCNPY listed for sale, a reduction will return escrowed tokens to the seller's
-  // receive address
+  // send address
   uint64 AmountForSale = 3; // @gotags: json:"amountForSale"
   // requested_amount: the updated amount of the 'counter asset' the buyer must send in order to complete a swap
   uint64 RequestedAmount = 4; // @gotags: json:"requestedAmount"

lib/.proto/message.proto

@@ -47,7 +47,7 @@ message SellOrder {
   // committee: the id of the committee that is in-charge of escrow for the swap
   uint64 Committee = 2; // @gotags: json:"committee"
   // amount_for_sale: amount of CNPY for sale
-  uint64 AmountForSale = 3; // @gotags: json:"amountForSalee"
+  uint64 AmountForSale = 3; // @gotags: json:"amountForSale"
   // requested_amount: amount of 'counter-asset' to receive
   uint64 RequestedAmount = 4; // @gotags: json:"requestedAmount"
   // seller_receive_address: the external chain address to receive the 'counter-asset'

lib/.proto/swap.proto

@@ -156,6 +156,7 @@ func (x *QuorumCertificate) CheckProposalBasic(height, networkId, chainId uint64
 	if err != nil {
 		return nil, err
 	}
+	// ensure the block hash is equal
 	if !bytes.Equal(x.BlockHash, blockHash) {
 		return nil, ErrMismatchHeaderBlockHash()
 	}