edit the log

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

diff --git a/protocol/block.go b/protocol/block.go
index cd002d1..d5ef5cf 100644 (file)
--- a/protocol/block.go
+++ b/protocol/block.go
@@ -28,7 +28,11 @@ func (c *Chain) BlockExist(hash *bc.Hash) bool {
 
 // GetBlockByHash return a block by given hash
 func (c *Chain) GetBlockByHash(hash *bc.Hash) (*types.Block, error) {
-       return c.store.GetBlock(hash)
+       node := c.index.GetNode(hash)
+       if node == nil {
+               return nil, errors.New("can't find block in given hash")
+       }
+       return c.store.GetBlock(hash, node.Height)
 }
 
 // GetBlockByHeight return a block header by given height
@@ -37,7 +41,7 @@ func (c *Chain) GetBlockByHeight(height uint64) (*types.Block, error) {
        if node == nil {
                return nil, errors.New("can't find block in given height")
        }
-       return c.store.GetBlock(&node.Hash)
+       return c.store.GetBlock(&node.Hash, height)
 }
 
 // GetHeaderByHash return a block header by given hash
@@ -125,15 +129,11 @@ func (c *Chain) reorganizeChain(node *state.BlockNode) error {
        }
 
        for _, detachNode := range detachNodes {
-               b, err := c.store.GetBlock(&detachNode.Hash)
+               b, err := c.store.GetBlock(&detachNode.Hash, detachNode.Height)
                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
@@ -156,7 +156,7 @@ func (c *Chain) reorganizeChain(node *state.BlockNode) error {
        }
 
        for _, attachNode := range attachNodes {
-               b, err := c.store.GetBlock(&attachNode.Hash)
+               b, err := c.store.GetBlock(&attachNode.Hash, attachNode.Height)
                if err != nil {
                        return err
                }
@@ -183,20 +183,23 @@ func (c *Chain) reorganizeChain(node *state.BlockNode) error {
                        voteResults = append(voteResults, voteResult.Fork())
                }
 
-               if c.isIrreversible(attachNode) && b.Height > irreversibleNode.Height {
+               if c.isIrreversible(attachNode) && attachNode.Height > irreversibleNode.Height {
                        irreversibleNode = attachNode
                }
 
                log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("attach from mainchain")
        }
 
+       if detachNodes[len(detachNodes)-1].Height <= c.bestIrreversibleNode.Height && irreversibleNode.Height <= c.bestIrreversibleNode.Height {
+               return errors.New("rollback block below the height of irreversible block")
+       }
        voteResults = append(voteResults, voteResult.Fork())
        return c.setState(node, irreversibleNode, utxoView, voteResults)
 }
 
 // SaveBlock will validate and save block into storage
 func (c *Chain) saveBlock(block *types.Block) error {
-       if _, err := c.validateSign(block); err != nil {
+       if err := c.validateSign(block); err != nil {
                return errors.Sub(ErrBadBlock, err)
        }
 
@@ -225,7 +228,7 @@ func (c *Chain) saveBlock(block *types.Block) error {
 
        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 {
+               if err := c.eventDispatcher.Post(event.BlockSignatureEvent{BlockHash: block.Hash(), Signature: signature, XPub: xPub[:]}); err != nil {
                        return err
                }
        }
@@ -286,11 +289,6 @@ func (c *Chain) blockProcesser() {
 // ProcessBlock is the entry for handle block insert
 func (c *Chain) processBlock(block *types.Block) (bool, error) {
        blockHash := block.Hash()
-       if block.Height <= c.bestIrreversibleNode.Height {
-               log.WithFields(log.Fields{"module": logModule, "hash": blockHash.String(), "height": block.Height}).Info(errBelowIrreversibleBlock.Error())
-               return false, errBelowIrreversibleBlock
-       }
-
        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
@@ -309,6 +307,8 @@ func (c *Chain) processBlock(block *types.Block) (bool, error) {
        bestBlockHash := bestBlock.Hash()
        bestNode := c.index.GetNode(&bestBlockHash)
 
+       c.cond.L.Lock()
+       defer c.cond.L.Unlock()
        if bestNode.Parent == c.bestNode {
                log.WithFields(log.Fields{"module": logModule}).Debug("append block to the end of mainchain")
                return false, c.connectBlock(bestBlock)