"github.com/vapor/consensus"
"github.com/vapor/errors"
"github.com/vapor/protocol/bc"
+ "github.com/vapor/protocol/bc/types"
"github.com/vapor/protocol/state"
)
errNotFoundBlockNode = errors.New("can not find block node")
)
-type consensusNodeManager struct {
- store Store
- blockIndex *state.BlockIndex
+func (c *Chain) getBestConsensusResult() (*state.ConsensusResult, error) {
+ bestBlockHeader := c.bestBlockHeader
+ seq := state.CalcVoteSeq(bestBlockHeader.Height)
+ return c.getConsensusResult(seq, bestBlockHeader)
}
-func newConsensusNodeManager(store Store, blockIndex *state.BlockIndex) *consensusNodeManager {
- return &consensusNodeManager{
- store: store,
- blockIndex: blockIndex,
- }
+func getBlockerOrder(startTimestamp, blockTimestamp, numOfConsensusNode uint64) uint64 {
+ // One round of product block time for all consensus nodes
+ 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.ActiveNetParams.BlockNumEachNode * consensus.ActiveNetParams.BlockTimeInterval)
}
-func (c *consensusNodeManager) getConsensusNode(prevBlockHash *bc.Hash, pubkey string) (*state.ConsensusNode, error) {
+func (c *Chain) getConsensusNode(prevBlockHash *bc.Hash, pubkey string) (*state.ConsensusNode, error) {
consensusNodeMap, err := c.getConsensusNodes(prevBlockHash)
if err != nil {
return nil, err
return node, nil
}
-func (c *consensusNodeManager) getBlocker(prevBlockHash *bc.Hash, timeStamp uint64) (string, error) {
- consensusNodeMap, err := c.getConsensusNodes(prevBlockHash)
+func (c *Chain) getConsensusNodes(prevBlockHash *bc.Hash) (map[string]*state.ConsensusNode, error) {
+ prevBlockHeader, err := c.store.GetBlockHeader(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 getBlockerOrder(startTimestamp, blockTimestamp, numOfConsensusNode uint64) uint64 {
- // One round of product block time for all consensus nodes
- roundBlockTime := consensus.BlockNumEachNode * numOfConsensusNode * consensus.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)
-}
-
-func (c *consensusNodeManager) getPrevRoundLastBlock(prevBlockHash *bc.Hash) (*state.BlockNode, error) {
- node := c.blockIndex.GetNode(prevBlockHash)
- if node == nil {
- return nil, errNotFoundBlockNode
- }
-
- for node.Height%consensus.RoundVoteBlockNums != 0 {
- node = node.Parent
- }
- return node, nil
-}
-
-func (c *consensusNodeManager) getConsensusNodes(prevBlockHash *bc.Hash) (map[string]*state.ConsensusNode, error) {
- prevBlockNode := c.blockIndex.GetNode(prevBlockHash)
- if prevBlockNode == nil {
return nil, errNotFoundBlockNode
}
- preSeq := state.CalcVoteSeq(prevBlockNode.Height+1) - 1
- if bestSeq := state.CalcVoteSeq(c.blockIndex.BestNode().Height); preSeq > bestSeq {
+ bestBlockHeader := c.bestBlockHeader
+ preSeq := state.CalcVoteSeq(prevBlockHeader.Height+1) - 1
+ if bestSeq := state.CalcVoteSeq(bestBlockHeader.Height); preSeq > bestSeq {
preSeq = bestSeq
}
- lastBlockNode, err := c.getPrevRoundLastBlock(prevBlockHash)
+ lastBlockHeader, err := c.getPrevRoundLastBlock(prevBlockHash)
if err != nil {
return nil, err
}
- voteResult, err := c.getVoteResult(preSeq, lastBlockNode)
+ consensusResult, err := c.getConsensusResult(preSeq, lastBlockHeader)
if err != nil {
return nil, err
}
- return voteResult.ConsensusNodes()
-}
-
-func (c *consensusNodeManager) getBestVoteResult() (*state.VoteResult, error) {
- blockNode := c.blockIndex.BestNode()
- seq := state.CalcVoteSeq(blockNode.Height)
- return c.getVoteResult(seq, blockNode)
+ return consensusResult.ConsensusNodes()
}
-// getVoteResult return the vote result
+// getConsensusResult return the vote result
// seq represent the sequence of vote
-// blockNode represent the chain in which the result of the vote is located
-// Voting results need to be adjusted according to the chain
-func (c *consensusNodeManager) getVoteResult(seq uint64, blockNode *state.BlockNode) (*state.VoteResult, error) {
- voteResult, err := c.store.GetVoteResult(seq)
+// 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) 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, blockNode); err != nil {
+ if err := c.reorganizeConsensusResult(consensusResult, blockHeader); err != nil {
return nil, err
}
- return voteResult, nil
+ return consensusResult, nil
}
-func (c *consensusNodeManager) reorganizeVoteResult(voteResult *state.VoteResult, node *state.BlockNode) error {
- mainChainNode := c.blockIndex.GetNode(&voteResult.BlockHash)
- var attachNodes []*state.BlockNode
- var detachNodes []*state.BlockNode
- for forkChainNode := node; mainChainNode != forkChainNode; {
- var forChainRollback, mainChainRollBack bool
- if forChainRollback = forkChainNode.Height >= mainChainNode.Height; forChainRollback {
- attachNodes = append([]*state.BlockNode{forkChainNode}, attachNodes...)
- }
- if mainChainRollBack = forkChainNode.Height <= mainChainNode.Height; mainChainRollBack {
- detachNodes = append(detachNodes, mainChainNode)
- }
- if forChainRollback {
- forkChainNode = forkChainNode.Parent
- }
- if mainChainRollBack {
- mainChainNode = mainChainNode.Parent
+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
+}
- for _, node := range detachNodes {
- block, err := c.store.GetBlock(&node.Hash)
+func (c *Chain) reorganizeConsensusResult(consensusResult *state.ConsensusResult, blockHeader *types.BlockHeader) error {
+ mainChainBlockHeader, err := c.store.GetBlockHeader(&consensusResult.BlockHash)
+ if err != nil {
+ return err
+ }
+
+ attachBlockHeaders, detachBlockHeaders, err := c.calcReorganizeChain(blockHeader, mainChainBlockHeader)
+ if err != nil {
+ return err
+ }
+
+ for _, bh := range detachBlockHeaders {
+ blockHash := bh.Hash()
+ block, err := c.store.GetBlock(&blockHash)
if err != nil {
return err
}
- if err := voteResult.DetachBlock(block); err != nil {
+ if err := consensusResult.DetachBlock(block); err != nil {
return err
}
}
- for _, node := range attachNodes {
- block, err := c.store.GetBlock(&node.Hash)
+ for _, bh := range attachBlockHeaders {
+ blockHash := bh.Hash()
+ block, err := c.store.GetBlock(&blockHash)
if err != nil {
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)
+}