Del BlockSignatureMsg unused Height field (#293)

[bytom/vapor.git] / protocol / consensus_node_manager.go

diff --git a/protocol/consensus_node_manager.go b/protocol/consensus_node_manager.go
index 12146f1..d55e7cc 100644 (file)
--- a/protocol/consensus_node_manager.go
+++ b/protocol/consensus_node_manager.go
@@ -13,65 +13,32 @@ var (
        errNotFoundBlockNode     = errors.New("can not find block node")
 )
 
-func (c *Chain) getConsensusNode(prevBlockHash *bc.Hash, pubkey string) (*state.ConsensusNode, error) {
-       consensusNodeMap, err := c.getConsensusNodes(prevBlockHash)
-       if err != nil {
-               return nil, err
-       }
-
-       node, exist := consensusNodeMap[pubkey]
-       if !exist {
-               return nil, errNotFoundConsensusNode
-       }
-       return node, nil
-}
-
-// GetBlocker return blocker by specified timestamp
-func (c *Chain) GetBlocker(prevBlockHash *bc.Hash, timeStamp uint64) (string, error) {
-       consensusNodeMap, err := c.getConsensusNodes(prevBlockHash)
-       if err != nil {
-               return "", err
-       }
-
-       prevVoteRoundLastBlock, err := c.getPrevRoundLastBlock(prevBlockHash)
-       if err != nil {
-               return "", err
-       }
-
-       startTimestamp := prevVoteRoundLastBlock.Timestamp + consensus.BlockTimeInterval
-       order := getBlockerOrder(startTimestamp, timeStamp, uint64(len(consensusNodeMap)))
-       for xPub, consensusNode := range consensusNodeMap {
-               if consensusNode.Order == order {
-                       return xPub, nil
-               }
-       }
-
-       // impossible occur
-       return "", errors.New("can not find blocker by given timestamp")
+func (c *Chain) getBestConsensusResult() (*state.ConsensusResult, error) {
+       bestBlockHeader := c.bestBlockHeader
+       seq := state.CalcVoteSeq(bestBlockHeader.Height)
+       return c.getConsensusResult(seq, bestBlockHeader)
 }
 
 func getBlockerOrder(startTimestamp, blockTimestamp, numOfConsensusNode uint64) uint64 {
        // One round of product block time for all consensus nodes
-       roundBlockTime := consensus.BlockNumEachNode * numOfConsensusNode * consensus.BlockTimeInterval
+       roundBlockTime := consensus.ActiveNetParams.BlockNumEachNode * numOfConsensusNode * consensus.ActiveNetParams.BlockTimeInterval
        // The start time of the last round of product block
        lastRoundStartTime := startTimestamp + (blockTimestamp-startTimestamp)/roundBlockTime*roundBlockTime
        // Order of blocker
-       return (blockTimestamp - lastRoundStartTime) / (consensus.BlockNumEachNode * consensus.BlockTimeInterval)
+       return (blockTimestamp - lastRoundStartTime) / (consensus.ActiveNetParams.BlockNumEachNode * consensus.ActiveNetParams.BlockTimeInterval)
 }
 
-func (c *Chain) getPrevRoundLastBlock(prevBlockHash *bc.Hash) (*types.BlockHeader, error) {
-       blockHeader, err := c.store.GetBlockHeader(prevBlockHash)
+func (c *Chain) getConsensusNode(prevBlockHash *bc.Hash, pubkey string) (*state.ConsensusNode, error) {
+       consensusNodeMap, err := c.getConsensusNodes(prevBlockHash)
        if err != nil {
-               return nil, errNotFoundBlockNode
+               return nil, err
        }
 
-       for blockHeader.Height%consensus.RoundVoteBlockNums != 0 {
-               blockHeader, err = c.store.GetBlockHeader(&blockHeader.PreviousBlockHash)
-               if err != nil {
-                       return nil, err
-               }
+       node, exist := consensusNodeMap[pubkey]
+       if !exist {
+               return nil, errNotFoundConsensusNode
        }
-       return blockHeader, nil
+       return node, nil
 }
 
 func (c *Chain) getConsensusNodes(prevBlockHash *bc.Hash) (map[string]*state.ConsensusNode, error) {
@@ -91,39 +58,48 @@ func (c *Chain) getConsensusNodes(prevBlockHash *bc.Hash) (map[string]*state.Con
                return nil, err
        }
 
-       voteResult, err := c.getVoteResult(preSeq, lastBlockHeader)
+       consensusResult, err := c.getConsensusResult(preSeq, lastBlockHeader)
        if err != nil {
                return nil, err
        }
 
-       return voteResult.ConsensusNodes()
-}
-
-func (c *Chain) getBestVoteResult() (*state.VoteResult, error) {
-       bestBlockHeader := c.bestBlockHeader
-       seq := state.CalcVoteSeq(bestBlockHeader.Height)
-       return c.getVoteResult(seq, bestBlockHeader)
+       return consensusResult.ConsensusNodes()
 }
 
-// getVoteResult return the vote result
+// getConsensusResult return the vote result
 // seq represent the sequence of vote
 // blockHeader represent the chain in which the result of the vote is located
 // Voting results need to be adjusted according to the chain
-func (c *Chain) getVoteResult(seq uint64, blockHeader *types.BlockHeader) (*state.VoteResult, error) {
-       voteResult, err := c.store.GetVoteResult(seq)
+func (c *Chain) getConsensusResult(seq uint64, blockHeader *types.BlockHeader) (*state.ConsensusResult, error) {
+       consensusResult, err := c.store.GetConsensusResult(seq)
        if err != nil {
                return nil, err
        }
 
-       if err := c.reorganizeVoteResult(voteResult, blockHeader); err != nil {
+       if err := c.reorganizeConsensusResult(consensusResult, blockHeader); err != nil {
                return nil, err
        }
 
-       return voteResult, nil
+       return consensusResult, nil
+}
+
+func (c *Chain) getPrevRoundLastBlock(prevBlockHash *bc.Hash) (*types.BlockHeader, error) {
+       blockHeader, err := c.store.GetBlockHeader(prevBlockHash)
+       if err != nil {
+               return nil, errNotFoundBlockNode
+       }
+
+       for blockHeader.Height%consensus.ActiveNetParams.RoundVoteBlockNums != 0 {
+               blockHeader, err = c.store.GetBlockHeader(&blockHeader.PreviousBlockHash)
+               if err != nil {
+                       return nil, err
+               }
+       }
+       return blockHeader, nil
 }
 
-func (c *Chain) reorganizeVoteResult(voteResult *state.VoteResult, blockHeader *types.BlockHeader) error {
-       mainChainBlockHeader, err := c.store.GetBlockHeader(&voteResult.BlockHash)
+func (c *Chain) reorganizeConsensusResult(consensusResult *state.ConsensusResult, blockHeader *types.BlockHeader) error {
+       mainChainBlockHeader, err := c.store.GetBlockHeader(&consensusResult.BlockHash)
        if err != nil {
                return err
        }
@@ -140,7 +116,7 @@ func (c *Chain) reorganizeVoteResult(voteResult *state.VoteResult, blockHeader *
                        return err
                }
 
-               if err := voteResult.DetachBlock(block); err != nil {
+               if err := consensusResult.DetachBlock(block); err != nil {
                        return err
                }
        }
@@ -152,9 +128,42 @@ func (c *Chain) reorganizeVoteResult(voteResult *state.VoteResult, blockHeader *
                        return err
                }
 
-               if err := voteResult.ApplyBlock(block); err != nil {
+               if err := consensusResult.ApplyBlock(block); err != nil {
                        return err
                }
        }
        return nil
 }
+
+// GetBlocker return blocker by specified timestamp
+func (c *Chain) GetBlocker(prevBlockHash *bc.Hash, timeStamp uint64) (string, error) {
+       consensusNodeMap, err := c.getConsensusNodes(prevBlockHash)
+       if err != nil {
+               return "", err
+       }
+
+       prevVoteRoundLastBlock, err := c.getPrevRoundLastBlock(prevBlockHash)
+       if err != nil {
+               return "", err
+       }
+
+       startTimestamp := prevVoteRoundLastBlock.Timestamp + consensus.ActiveNetParams.BlockTimeInterval
+       order := getBlockerOrder(startTimestamp, timeStamp, uint64(len(consensusNodeMap)))
+       for xPub, consensusNode := range consensusNodeMap {
+               if consensusNode.Order == order {
+                       return xPub, nil
+               }
+       }
+
+       // impossible occur
+       return "", errors.New("can not find blocker by given timestamp")
+}
+
+// GetConsensusResultByHash return vote result by block hash
+func (c *Chain) GetConsensusResultByHash(blockHash *bc.Hash) (*state.ConsensusResult, error) {
+       blockHeader, err := c.store.GetBlockHeader(blockHash)
+       if err != nil {
+               return nil, err
+       }
+       return c.getConsensusResult(state.CalcVoteSeq(blockHeader.Height), blockHeader)
+}