package protocol
import (
- "encoding/hex"
- "sort"
-
"github.com/vapor/config"
+ "github.com/vapor/consensus"
"github.com/vapor/errors"
- "github.com/vapor/math/checked"
"github.com/vapor/protocol/bc"
"github.com/vapor/protocol/bc/types"
"github.com/vapor/protocol/state"
)
-const (
- NumOfConsensusNode = 21
- RoundVoteBlockNums = 1000
- MinVoteNum = 5000000
-
- // BlockTimeInterval indicate product one block per 500 milliseconds
- BlockTimeInterval = 500
- // BlockNumEachNode indicate product three blocks per node in succession
- BlockNumEachNode = 3
-)
-
var (
errNotFoundConsensusNode = errors.New("can not found consensus node")
errNotFoundBlockNode = errors.New("can not find block node")
)
-type consensusNode struct {
- pubkey string
- voteNum uint64
- order uint64
-}
-
-type consensusNodeSlice []*consensusNode
-
-func (c consensusNodeSlice) Len() int { return len(c) }
-func (c consensusNodeSlice) Less(i, j int) bool { return c[i].voteNum > c[j].voteNum }
-func (c consensusNodeSlice) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
-
type consensusNodeManager struct {
store Store
blockIndex *state.BlockIndex
}
}
-func (c *consensusNodeManager) getConsensusNode(prevBlockHash *bc.Hash, pubkey string) (*consensusNode, error) {
+func (c *consensusNodeManager) getConsensusNode(prevBlockHash *bc.Hash, pubkey string) (*state.ConsensusNode, error) {
consensusNodeMap, err := c.getConsensusNodesByVoteResult(prevBlockHash)
if err != nil {
return nil, err
}
func (c *consensusNodeManager) isBlocker(prevBlockHash *bc.Hash, pubKey string, timeStamp uint64) (bool, error) {
- consensusNode, err := c.getConsensusNode(prevBlockHash, pubKey)
- if err != nil && err != errNotFoundConsensusNode {
+ consensusNodeMap, err := c.getConsensusNodesByVoteResult(prevBlockHash)
+ if err != nil {
return false, err
}
+ consensusNode := consensusNodeMap[pubKey]
if consensusNode == nil {
return false, nil
}
return false, err
}
- startTimestamp := prevVoteRoundLastBlock.Timestamp + BlockTimeInterval
- begin := getLastBlockTimeInTimeRange(startTimestamp, timeStamp, consensusNode.order)
- end := begin + BlockNumEachNode*BlockTimeInterval
+ startTimestamp := prevVoteRoundLastBlock.Timestamp + consensus.BlockTimeInterval
+ begin := getLastBlockTimeInTimeRange(startTimestamp, timeStamp, consensusNode.Order, len(consensusNodeMap))
+ end := begin + consensus.BlockNumEachNode*consensus.BlockTimeInterval
return timeStamp >= begin && timeStamp < end, nil
}
-func getLastBlockTimeInTimeRange(startTimestamp, endTimestamp, order uint64) uint64 {
+func getLastBlockTimeInTimeRange(startTimestamp, endTimestamp, order uint64, numOfConsensusNode int) uint64 {
// One round of product block time for all consensus nodes
- roundBlockTime := uint64(BlockNumEachNode * NumOfConsensusNode * BlockTimeInterval)
+ roundBlockTime := uint64(consensus.BlockNumEachNode * numOfConsensusNode * consensus.BlockTimeInterval)
// The start time of the last round of product block
lastRoundStartTime := startTimestamp + (endTimestamp-startTimestamp)/roundBlockTime*roundBlockTime
// The time of product block of the consensus in last round
- return lastRoundStartTime + order*(BlockNumEachNode*BlockTimeInterval)
+ return lastRoundStartTime + order*(consensus.BlockNumEachNode*consensus.BlockTimeInterval)
}
func (c *consensusNodeManager) getPrevRoundVoteLastBlock(prevBlockHash *bc.Hash) (*state.BlockNode, error) {
blockHeight := prevBlockNode.Height + 1
- prevVoteRoundLastBlockHeight := blockHeight/RoundVoteBlockNums*RoundVoteBlockNums - 1
+ prevVoteRoundLastBlockHeight := blockHeight/consensus.RoundVoteBlockNums*consensus.RoundVoteBlockNums - 1
// first round
- if blockHeight/RoundVoteBlockNums == 0 {
+ if blockHeight/consensus.RoundVoteBlockNums == 0 {
prevVoteRoundLastBlockHeight = 0
}
return lastBlockNode, nil
}
-func (c *consensusNodeManager) getConsensusNodesByVoteResult(prevBlockHash *bc.Hash) (map[string]*consensusNode, error) {
+func (c *consensusNodeManager) getConsensusNodesByVoteResult(prevBlockHash *bc.Hash) (map[string]*state.ConsensusNode, error) {
prevBlockNode := c.blockIndex.GetNode(prevBlockHash)
if prevBlockNode == nil {
return nil, errNotFoundBlockNode
}
- seq := (prevBlockNode.Height + 1) / RoundVoteBlockNums
+ seq := (prevBlockNode.Height + 1) / consensus.RoundVoteBlockNums
voteResult, err := c.store.GetVoteResult(seq)
if err != nil {
// TODO find previous round vote
voteResult = &state.VoteResult{
Seq: seq,
NumOfVote: make(map[string]uint64),
- Finalized: false,
}
}
return initConsensusNodes(), nil
}
- var nodes []*consensusNode
- for pubkey, voteNum := range voteResult.NumOfVote {
- if voteNum >= MinVoteNum {
- nodes = append(nodes, &consensusNode{
- pubkey: pubkey,
- voteNum: voteNum,
- })
- }
- }
- // In principle, there is no need to sort all voting nodes.
- // if there is a performance problem, consider the optimization later.
- // TODO not consider the same number of votes
- sort.Sort(consensusNodeSlice(nodes))
-
- result := make(map[string]*consensusNode)
- for i := 0; i < len(nodes) && i < NumOfConsensusNode; i++ {
- node := nodes[i]
- node.order = uint64(i)
- result[node.pubkey] = node
- }
- return result, nil
+ return voteResult.ConsensusNodes()
}
func (c *consensusNodeManager) reorganizeVoteResult(voteResult *state.VoteResult, forkChainNode *state.BlockNode) error {
return err
}
- emptyHash := bc.Hash{}
- if voteResult.LastBlockHash != emptyHash && voteResult.LastBlockHash != block.PreviousBlockHash {
- return errors.New("bbft append block error, the block parent hash is not equals last block hash of vote result")
- }
-
- for _, tx := range block.Transactions {
- for _, input := range tx.Inputs {
- unVoteInput, ok := input.TypedInput.(*types.UnvoteInput)
- if !ok {
- continue
- }
-
- pubkey := hex.EncodeToString(unVoteInput.Vote)
- voteResult.NumOfVote[pubkey], ok = checked.SubUint64(voteResult.NumOfVote[pubkey], unVoteInput.Amount)
- if !ok {
- return errVotingOperationOverFlow
- }
- }
- for _, output := range tx.Outputs {
- voteOutput, ok := output.TypedOutput.(*types.VoteTxOutput)
- if !ok {
- continue
- }
-
- pubkey := hex.EncodeToString(voteOutput.Vote)
- voteResult.NumOfVote[pubkey], ok = checked.AddUint64(voteResult.NumOfVote[pubkey], voteOutput.Amount)
- if !ok {
- return errVotingOperationOverFlow
- }
- }
- }
-
- voteResult.Finalized = (block.Height+1)%RoundVoteBlockNums == 0
- return nil
+ return voteResult.ApplyBlock(block)
}
func (c *consensusNodeManager) getVoteResult(voteResultMap map[uint64]*state.VoteResult, blockHeight uint64) (*state.VoteResult, error) {
var err error
// This round of voting prepares for the next round
- seq := blockHeight/RoundVoteBlockNums + 1
+ seq := blockHeight/consensus.RoundVoteBlockNums + 1
voteResult := voteResultMap[seq]
if blockHeight == 0 {
voteResult = &state.VoteResult{
Seq: seq,
NumOfVote: make(map[string]uint64),
- Finalized: false,
}
}
voteResult = &state.VoteResult{
Seq: seq,
NumOfVote: prevVoteResult.NumOfVote,
- Finalized: false,
}
}
}
}
if voteResult != nil {
- // previous round voting must have finalized
- if !voteResult.Finalized {
- return nil, errors.New("previous round voting has not finalized")
- }
-
voteResult.Seq = seq
- voteResult.Finalized = false
voteResult.LastBlockHash = bc.Hash{}
}
}
}
func (c *consensusNodeManager) detachBlock(voteResultMap map[uint64]*state.VoteResult, block *types.Block) error {
- voteSeq := block.Height / RoundVoteBlockNums
+ voteSeq := block.Height / consensus.RoundVoteBlockNums
voteResult := voteResultMap[voteSeq]
if voteResult == nil {
voteResultMap[voteSeq] = voteResult
}
- if voteResult.LastBlockHash != block.Hash() {
- return errors.New("bbft detach block error, the block hash is not equals last block hash of vote result")
- }
-
- for _, tx := range block.Transactions {
- for _, input := range tx.Inputs {
- unVoteInput, ok := input.TypedInput.(*types.UnvoteInput)
- if !ok {
- continue
- }
-
- pubkey := hex.EncodeToString(unVoteInput.Vote)
- voteResult.NumOfVote[pubkey], ok = checked.AddUint64(voteResult.NumOfVote[pubkey], unVoteInput.Amount)
- if !ok {
- return errVotingOperationOverFlow
- }
- }
- for _, output := range tx.Outputs {
- voteOutput, ok := output.TypedOutput.(*types.VoteTxOutput)
- if !ok {
- continue
- }
-
- pubkey := hex.EncodeToString(voteOutput.Vote)
- voteResult.NumOfVote[pubkey], ok = checked.SubUint64(voteResult.NumOfVote[pubkey], voteOutput.Amount)
- if !ok {
- return errVotingOperationOverFlow
- }
- }
- }
-
- voteResult.Finalized = false
+ voteResult.DetachBlock(block)
return nil
}
-func initConsensusNodes() map[string]*consensusNode {
- voteResult := map[string]*consensusNode{}
- for i, pubkey := range config.CommonConfig.Federation.Xpubs {
- pubkeyStr := pubkey.String()
- voteResult[pubkeyStr] = &consensusNode{pubkey: pubkeyStr, voteNum: 0, order: uint64(i)}
+func initConsensusNodes() map[string]*state.ConsensusNode {
+ voteResult := map[string]*state.ConsensusNode{}
+ for i, xpub := range config.CommonConfig.Federation.Xpubs {
+ voteResult[xpub.String()] = &state.ConsensusNode{XPub: xpub, VoteNum: 0, Order: uint64(i)}
}
return voteResult
}