X-Git-Url: http://git.osdn.net/view?p=bytom%2Fvapor.git;a=blobdiff_plain;f=protocol%2Fblock.go;h=630095131261074810f4061d9fff33e9c0294f3e;hp=dca8b4d9d2311cd826adf5558f0777c065ed1258;hb=a4d2fccbb6638bee6a8afa2af4df6e3989b91609;hpb=c071c7f9648e8e8f39c1826ccb4e5d2ba5e8efd7

diff --git a/protocol/block.go b/protocol/block.go
index dca8b4d9..63009513 100644
--- a/protocol/block.go
+++ b/protocol/block.go
@@ -3,6 +3,7 @@ package protocol
 import (
 	log "github.com/sirupsen/logrus"
 
+	"github.com/vapor/config"
 	"github.com/vapor/errors"
 	"github.com/vapor/event"
 	"github.com/vapor/protocol/bc"
@@ -21,7 +22,10 @@ var (
 
 // BlockExist check is a block in chain or orphan
 func (c *Chain) BlockExist(hash *bc.Hash) bool {
-	return c.index.BlockExist(hash) || c.orphanManage.BlockExist(hash)
+	if _, err := c.store.GetBlockHeader(hash); err == nil {
+		return true
+	}
+	return c.orphanManage.BlockExist(hash)
 }
 
 // GetBlockByHash return a block by given hash
@@ -29,53 +33,62 @@ func (c *Chain) GetBlockByHash(hash *bc.Hash) (*types.Block, error) {
 	return c.store.GetBlock(hash)
 }
 
-// GetBlockByHeight return a block header by given height
+// GetBlockByHeight return a block by given height
 func (c *Chain) GetBlockByHeight(height uint64) (*types.Block, error) {
-	node := c.index.NodeByHeight(height)
-	if node == nil {
-		return nil, errors.New("can't find block in given height")
+	hash, err := c.store.GetMainChainHash(height)
+	if err != nil {
+		return nil, errors.Wrap(err, "can't find block in given height")
 	}
-	return c.store.GetBlock(&node.Hash)
+	return c.store.GetBlock(hash)
 }
 
 // GetHeaderByHash return a block header by given hash
 func (c *Chain) GetHeaderByHash(hash *bc.Hash) (*types.BlockHeader, error) {
-	node := c.index.GetNode(hash)
-	if node == nil {
-		return nil, errors.New("can't find block header in given hash")
-	}
-	return node.BlockHeader(), nil
+	return c.store.GetBlockHeader(hash)
 }
 
 // GetHeaderByHeight return a block header by given height
 func (c *Chain) GetHeaderByHeight(height uint64) (*types.BlockHeader, error) {
-	node := c.index.NodeByHeight(height)
-	if node == nil {
-		return nil, errors.New("can't find block header in given height")
+	hash, err := c.store.GetMainChainHash(height)
+	if err != nil {
+		return nil, errors.Wrap(err, "can't find block header in given height")
 	}
-	return node.BlockHeader(), nil
+	return c.store.GetBlockHeader(hash)
 }
 
-func (c *Chain) calcReorganizeNodes(node *state.BlockNode) ([]*state.BlockNode, []*state.BlockNode) {
-	var attachNodes []*state.BlockNode
-	var detachNodes []*state.BlockNode
+func (c *Chain) calcReorganizeChain(beginAttach *types.BlockHeader, beginDetach *types.BlockHeader) ([]*types.BlockHeader, []*types.BlockHeader, error) {
+	var err error
+	var attachBlockHeaders []*types.BlockHeader
+	var detachBlockHeaders []*types.BlockHeader
 
-	attachNode := node
-	for c.index.NodeByHeight(attachNode.Height) != attachNode {
-		attachNodes = append([]*state.BlockNode{attachNode}, attachNodes...)
-		attachNode = attachNode.Parent
-	}
+	for attachBlockHeader, detachBlockHeader := beginAttach, beginDetach; detachBlockHeader.Hash() != attachBlockHeader.Hash(); {
+		var attachRollback, detachRollBack bool
+		if attachRollback = attachBlockHeader.Height >= detachBlockHeader.Height; attachRollback {
+			attachBlockHeaders = append([]*types.BlockHeader{attachBlockHeader}, attachBlockHeaders...)
+		}
+
+		if detachRollBack = attachBlockHeader.Height <= detachBlockHeader.Height; detachRollBack {
+			detachBlockHeaders = append(detachBlockHeaders, detachBlockHeader)
+		}
+
+		if attachRollback {
+			attachBlockHeader, err = c.store.GetBlockHeader(&attachBlockHeader.PreviousBlockHash)
+			if err != nil {
+				return nil, nil, err
+			}
+		}
 
-	detachNode := c.bestNode
-	for detachNode != attachNode {
-		detachNodes = append(detachNodes, detachNode)
-		detachNode = detachNode.Parent
+		if detachRollBack {
+			detachBlockHeader, err = c.store.GetBlockHeader(&detachBlockHeader.PreviousBlockHash)
+			if err != nil {
+				return nil, nil, err
+			}
+		}
 	}
-	return attachNodes, detachNodes
+	return attachBlockHeaders, detachBlockHeaders, nil
 }
 
 func (c *Chain) connectBlock(block *types.Block) (err error) {
-	irreversibleNode := c.bestIrreversibleNode
 	bcBlock := types.MapBlock(block)
 	if bcBlock.TransactionStatus, err = c.store.GetTransactionStatus(&bcBlock.ID); err != nil {
 		return err
@@ -89,17 +102,20 @@ func (c *Chain) connectBlock(block *types.Block) (err error) {
 		return err
 	}
 
-	voteResultMap := make(map[uint64]*state.VoteResult)
-	if err := c.bbft.ApplyBlock(voteResultMap, block); err != nil {
+	consensusResult, err := c.getBestConsensusResult()
+	if err != nil {
+		return err
+	}
+	if err := consensusResult.ApplyBlock(block); err != nil {
 		return err
 	}
 
-	node := c.index.GetNode(&bcBlock.ID)
-	if c.bbft.isIrreversible(block) && block.Height > irreversibleNode.Height {
-		irreversibleNode = node
+	irrBlockHeader := c.lastIrrBlockHeader
+	if c.isIrreversible(&block.BlockHeader) && block.Height > irrBlockHeader.Height {
+		irrBlockHeader = &block.BlockHeader
 	}
 
-	if err := c.setState(node, irreversibleNode, utxoView, voteResultMap); err != nil {
+	if err := c.setState(&block.BlockHeader, irrBlockHeader, []*types.BlockHeader{&block.BlockHeader}, utxoView, []*state.ConsensusResult{consensusResult}); err != nil {
 		return err
 	}
 
@@ -109,43 +125,58 @@ func (c *Chain) connectBlock(block *types.Block) (err error) {
 	return nil
 }
 
-func (c *Chain) reorganizeChain(node *state.BlockNode) error {
-	attachNodes, detachNodes := c.calcReorganizeNodes(node)
+func (c *Chain) reorganizeChain(blockHeader *types.BlockHeader) error {
+	attachBlockHeaders, detachBlockHeaders, err := c.calcReorganizeChain(blockHeader, c.bestBlockHeader)
+	if err != nil {
+		return err
+	}
+
 	utxoView := state.NewUtxoViewpoint()
-	voteResultMap := make(map[uint64]*state.VoteResult)
-	irreversibleNode := c.bestIrreversibleNode
-	
-	for _, detachNode := range detachNodes {
-		b, err := c.store.GetBlock(&detachNode.Hash)
+	consensusResults := []*state.ConsensusResult{}
+	consensusResult, err := c.getBestConsensusResult()
+	if err != nil {
+		return err
+	}
+
+	txsToRestore := map[bc.Hash]*types.Tx{}
+	for _, detachBlockHeader := range detachBlockHeaders {
+		detachHash := detachBlockHeader.Hash()
+		b, err := c.store.GetBlock(&detachHash)
 		if err != nil {
 			return err
 		}
 
-		if b.Height <= irreversibleNode.Height {
-			return errors.New("the height of rollback block below the height of irreversible block")
-		}
-
 		detachBlock := types.MapBlock(b)
 		if err := c.store.GetTransactionsUtxo(utxoView, detachBlock.Transactions); err != nil {
 			return err
 		}
+
 		txStatus, err := c.GetTransactionStatus(&detachBlock.ID)
 		if err != nil {
 			return err
 		}
+
 		if err := utxoView.DetachBlock(detachBlock, txStatus); err != nil {
 			return err
 		}
-		
-		if err := c.bbft.DetachBlock(voteResultMap, b); err != nil {
+
+		if err := consensusResult.DetachBlock(b); err != nil {
 			return err
 		}
 
-		log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("detach from mainchain")
+		for _, tx := range b.Transactions {
+			txsToRestore[tx.ID] = tx
+		}
+
+		blockHash := blockHeader.Hash()
+		log.WithFields(log.Fields{"module": logModule, "height": blockHeader.Height, "hash": blockHash.String()}).Debug("detach from mainchain")
 	}
 
-	for _, attachNode := range attachNodes {
-		b, err := c.store.GetBlock(&attachNode.Hash)
+	txsToRemove := map[bc.Hash]*types.Tx{}
+	irrBlockHeader := c.lastIrrBlockHeader
+	for _, attachBlockHeader := range attachBlockHeaders {
+		attachHash := attachBlockHeader.Hash()
+		b, err := c.store.GetBlock(&attachHash)
 		if err != nil {
 			return err
 		}
@@ -154,62 +185,116 @@ func (c *Chain) reorganizeChain(node *state.BlockNode) error {
 		if err := c.store.GetTransactionsUtxo(utxoView, attachBlock.Transactions); err != nil {
 			return err
 		}
+
 		txStatus, err := c.GetTransactionStatus(&attachBlock.ID)
 		if err != nil {
 			return err
 		}
+
 		if err := utxoView.ApplyBlock(attachBlock, txStatus); err != nil {
 			return err
 		}
 
-		if err := c.bbft.ApplyBlock(voteResultMap, b); err != nil {
+		if err := consensusResult.ApplyBlock(b); err != nil {
 			return err
 		}
 
-		if c.bbft.isIrreversible(b) && b.Height > irreversibleNode.Height {
-			irreversibleNode = attachNode
+		if consensusResult.IsFinalize() {
+			consensusResults = append(consensusResults, consensusResult.Fork())
+		}
+
+		if c.isIrreversible(attachBlockHeader) && attachBlockHeader.Height > irrBlockHeader.Height {
+			irrBlockHeader = attachBlockHeader
+		}
+
+		for _, tx := range b.Transactions {
+			if _, ok := txsToRestore[tx.ID]; !ok {
+				txsToRemove[tx.ID] = tx
+			} else {
+				delete(txsToRestore, tx.ID)
+			}
 		}
 
-		log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("attach from mainchain")
+		blockHash := blockHeader.Hash()
+		log.WithFields(log.Fields{"module": logModule, "height": blockHeader.Height, "hash": blockHash.String()}).Debug("attach from mainchain")
 	}
 
-	return c.setState(node, irreversibleNode, utxoView, voteResultMap)
+	if len(detachBlockHeaders) > 0 &&
+		detachBlockHeaders[len(detachBlockHeaders)-1].Height <= c.lastIrrBlockHeader.Height &&
+		irrBlockHeader.Height <= c.lastIrrBlockHeader.Height {
+		return errors.New("rollback block below the height of irreversible block")
+	}
+
+	consensusResults = append(consensusResults, consensusResult.Fork())
+	if err := c.setState(blockHeader, irrBlockHeader, attachBlockHeaders, utxoView, consensusResults); err != nil {
+		return err
+	}
+
+	for txHash := range txsToRemove {
+		c.txPool.RemoveTransaction(&txHash)
+	}
+
+	for _, tx := range txsToRestore {
+		// the number of restored Tx should be very small or most of time ZERO
+		// Error returned from validation is ignored, tx could still be lost if validation fails.
+		// TODO: adjust tx timestamp so that it won't starve in pool.
+		if _, err := c.validateTx(tx, blockHeader); err != nil {
+			log.WithFields(log.Fields{"module": logModule, "tx_id": tx.Tx.ID.String(), "error": err}).Info("restore tx fail")
+		}
+	}
+
+	if len(txsToRestore) > 0 {
+		log.WithFields(log.Fields{"module": logModule, "num": len(txsToRestore)}).Debug("restore txs back to pool")
+	}
+	return nil
 }
 
 // SaveBlock will validate and save block into storage
 func (c *Chain) saveBlock(block *types.Block) error {
-	if err := c.bbft.ValidateBlock(block); err != nil {
+	if err := c.validateSign(block); err != nil {
 		return errors.Sub(ErrBadBlock, err)
 	}
 
-	parent := c.index.GetNode(&block.PreviousBlockHash)
-	if err := validation.ValidateBlock(types.MapBlock(block), parent); err != nil {
-		return errors.Sub(ErrBadBlock, err)
+	parent, err := c.store.GetBlockHeader(&block.PreviousBlockHash)
+	if err != nil {
+		return err
 	}
 
-	signature, err := c.bbft.SignBlock(block)
+	consensusResult, err := c.GetConsensusResultByHash(&block.PreviousBlockHash)
 	if err != nil {
-		return errors.Sub(ErrBadBlock, err)
+		return err
 	}
 
-	if len(signature) != 0 {
-		if err := c.bbft.eventDispatcher.Post(event.BlockSignatureEvent{BlockHash: block.Hash(), Signature: signature}); err != nil {
-			return err
-		}
+	if err := consensusResult.AttachCoinbaseReward(block); err != nil {
+		return err
 	}
 
-	bcBlock := types.MapBlock(block)
-	if err := c.store.SaveBlock(block, bcBlock.TransactionStatus); err != nil {
+	rewards, err := consensusResult.GetCoinbaseRewards(block.Height)
+	if err != nil {
 		return err
 	}
 
-	c.orphanManage.Delete(&bcBlock.ID)
-	node, err := state.NewBlockNode(&block.BlockHeader, parent)
+	bcBlock := types.MapBlock(block)
+	if err := validation.ValidateBlock(bcBlock, parent, rewards); err != nil {
+		return errors.Sub(ErrBadBlock, err)
+	}
+
+	signature, err := c.SignBlock(block)
 	if err != nil {
+		return errors.Sub(ErrBadBlock, err)
+	}
+
+	if err := c.store.SaveBlock(block, bcBlock.TransactionStatus); err != nil {
 		return err
 	}
+	c.orphanManage.Delete(&bcBlock.ID)
 
-	c.index.AddNode(node)
+	if len(signature) != 0 {
+		xPub := config.CommonConfig.PrivateKey().XPub()
+		if err := c.eventDispatcher.Post(event.BlockSignatureEvent{BlockHash: block.Hash(), Signature: signature, XPub: xPub[:]}); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -266,18 +351,15 @@ func (c *Chain) blockProcesser() {
 
 // ProcessBlock is the entry for handle block insert
 func (c *Chain) processBlock(block *types.Block) (bool, error) {
-	if block.Height <= c.bestIrreversibleNode.Height {
-		return false, errors.New("the height of block below the height of irreversible block")
-	}
-	
 	blockHash := block.Hash()
 	if c.BlockExist(&blockHash) {
 		log.WithFields(log.Fields{"module": logModule, "hash": blockHash.String(), "height": block.Height}).Info("block has been processed")
 		return c.orphanManage.BlockExist(&blockHash), nil
 	}
 
-	parent := c.index.GetNode(&block.PreviousBlockHash)
-	if parent == nil {
+	c.markTransactions(block.Transactions...)
+
+	if _, err := c.store.GetBlockHeader(&block.PreviousBlockHash); err != nil {
 		c.orphanManage.Add(block)
 		return true, nil
 	}
@@ -287,34 +369,18 @@ func (c *Chain) processBlock(block *types.Block) (bool, error) {
 	}
 
 	bestBlock := c.saveSubBlock(block)
-	bestBlockHash := bestBlock.Hash()
-	bestNode := c.index.GetNode(&bestBlockHash)
+	bestBlockHeader := &bestBlock.BlockHeader
 
-	if bestNode.Parent == c.bestNode {
+	c.cond.L.Lock()
+	defer c.cond.L.Unlock()
+	if bestBlockHeader.PreviousBlockHash == c.bestBlockHeader.Hash() {
 		log.WithFields(log.Fields{"module": logModule}).Debug("append block to the end of mainchain")
 		return false, c.connectBlock(bestBlock)
 	}
 
-	if bestNode.Height > c.bestNode.Height {
+	if bestBlockHeader.Height > c.bestBlockHeader.Height {
 		log.WithFields(log.Fields{"module": logModule}).Debug("start to reorganize chain")
-		return false, c.reorganizeChain(bestNode)
+		return false, c.reorganizeChain(bestBlockHeader)
 	}
 	return false, nil
 }
-
-func (c *Chain) ProcessBlockSignature(signature, pubkey []byte, blockHeight uint64, blockHash *bc.Hash) error {
-	isBestIrreversible, err := c.bbft.ProcessBlockSignature(signature, pubkey, blockHeight, blockHash)
-	if err != nil {
-		return err
-	}
-
-	if isBestIrreversible {
-		bestIrreversibleNode := c.index.GetNode(blockHash)
-		if err := c.store.SaveChainNodeStatus(c.bestNode, bestIrreversibleNode); err != nil {
-			return err
-		}
-
-		c.bestIrreversibleNode = bestIrreversibleNode
-	}
-	return nil
-}