protocol/block.go

   1 package protocol
   2
   3 import (
   4         log "github.com/sirupsen/logrus"
   5
   6         "github.com/vapor/errors"
   7         "github.com/vapor/event"
   8         "github.com/vapor/protocol/bc"
   9         "github.com/vapor/protocol/bc/types"
  10         "github.com/vapor/protocol/state"
  11         "github.com/vapor/protocol/validation"
  12 )
  13
  14 var (
  15         // ErrBadBlock is returned when a block is invalid.
  16         ErrBadBlock = errors.New("invalid block")
  17         // ErrBadStateRoot is returned when the computed assets merkle root
  18         // disagrees with the one declared in a block header.
  19         ErrBadStateRoot = errors.New("invalid state merkle root")
  20 )
  21
  22 // BlockExist check is a block in chain or orphan
  23 func (c *Chain) BlockExist(hash *bc.Hash) bool {
  24         return c.index.BlockExist(hash) || c.orphanManage.BlockExist(hash)
  25 }
  26
  27 // GetBlockByHash return a block by given hash
  28 func (c *Chain) GetBlockByHash(hash *bc.Hash) (*types.Block, error) {
  29         return c.store.GetBlock(hash)
  30 }
  31
  32 // GetBlockByHeight return a block header by given height
  33 func (c *Chain) GetBlockByHeight(height uint64) (*types.Block, error) {
  34         node := c.index.NodeByHeight(height)
  35         if node == nil {
  36                 return nil, errors.New("can't find block in given height")
  37         }
  38         return c.store.GetBlock(&node.Hash)
  39 }
  40
  41 // GetHeaderByHash return a block header by given hash
  42 func (c *Chain) GetHeaderByHash(hash *bc.Hash) (*types.BlockHeader, error) {
  43         node := c.index.GetNode(hash)
  44         if node == nil {
  45                 return nil, errors.New("can't find block header in given hash")
  46         }
  47         return node.BlockHeader(), nil
  48 }
  49
  50 // GetHeaderByHeight return a block header by given height
  51 func (c *Chain) GetHeaderByHeight(height uint64) (*types.BlockHeader, error) {
  52         node := c.index.NodeByHeight(height)
  53         if node == nil {
  54                 return nil, errors.New("can't find block header in given height")
  55         }
  56         return node.BlockHeader(), nil
  57 }
  58
  59 func (c *Chain) calcReorganizeNodes(node *state.BlockNode) ([]*state.BlockNode, []*state.BlockNode) {
  60         var attachNodes []*state.BlockNode
  61         var detachNodes []*state.BlockNode
  62
  63         attachNode := node
  64         for c.index.NodeByHeight(attachNode.Height) != attachNode {
  65                 attachNodes = append([]*state.BlockNode{attachNode}, attachNodes...)
  66                 attachNode = attachNode.Parent
  67         }
  68
  69         detachNode := c.bestNode
  70         for detachNode != attachNode {
  71                 detachNodes = append(detachNodes, detachNode)
  72                 detachNode = detachNode.Parent
  73         }
  74         return attachNodes, detachNodes
  75 }
  76
  77 func (c *Chain) connectBlock(block *types.Block) (err error) {
  78         irreversibleNode := c.bestIrreversibleNode
  79         bcBlock := types.MapBlock(block)
  80         if bcBlock.TransactionStatus, err = c.store.GetTransactionStatus(&bcBlock.ID); err != nil {
  81                 return err
  82         }
  83
  84         utxoView := state.NewUtxoViewpoint()
  85         if err := c.store.GetTransactionsUtxo(utxoView, bcBlock.Transactions); err != nil {
  86                 return err
  87         }
  88         if err := utxoView.ApplyBlock(bcBlock, bcBlock.TransactionStatus); err != nil {
  89                 return err
  90         }
  91
  92         voteResultMap := make(map[uint64]*state.VoteResult)
  93         if err := c.bbft.ApplyBlock(voteResultMap, block); err != nil {
  94                 return err
  95         }
  96
  97         node := c.index.GetNode(&bcBlock.ID)
  98         if c.bbft.isIrreversible(block) && block.Height > irreversibleNode.Height {
  99                 irreversibleNode = node
 100         }
 101
 102         if err := c.setState(node, irreversibleNode, utxoView, voteResultMap); err != nil {
 103                 return err
 104         }
 105
 106         for _, tx := range block.Transactions {
 107                 c.txPool.RemoveTransaction(&tx.Tx.ID)
 108         }
 109         return nil
 110 }
 111
 112 func (c *Chain) reorganizeChain(node *state.BlockNode) error {
 113         attachNodes, detachNodes := c.calcReorganizeNodes(node)
 114         utxoView := state.NewUtxoViewpoint()
 115         voteResultMap := make(map[uint64]*state.VoteResult)
 116         irreversibleNode := c.bestIrreversibleNode
 117
 118         for _, detachNode := range detachNodes {
 119                 b, err := c.store.GetBlock(&detachNode.Hash)
 120                 if err != nil {
 121                         return err
 122                 }
 123
 124                 if b.Height <= irreversibleNode.Height {
 125                         return errors.New("the height of rollback block below the height of irreversible block")
 126                 }
 127
 128                 detachBlock := types.MapBlock(b)
 129                 if err := c.store.GetTransactionsUtxo(utxoView, detachBlock.Transactions); err != nil {
 130                         return err
 131                 }
 132                 txStatus, err := c.GetTransactionStatus(&detachBlock.ID)
 133                 if err != nil {
 134                         return err
 135                 }
 136                 if err := utxoView.DetachBlock(detachBlock, txStatus); err != nil {
 137                         return err
 138                 }
 139
 140                 if err := c.bbft.DetachBlock(voteResultMap, b); err != nil {
 141                         return err
 142                 }
 143
 144                 log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("detach from mainchain")
 145         }
 146
 147         for _, attachNode := range attachNodes {
 148                 b, err := c.store.GetBlock(&attachNode.Hash)
 149                 if err != nil {
 150                         return err
 151                 }
 152
 153                 attachBlock := types.MapBlock(b)
 154                 if err := c.store.GetTransactionsUtxo(utxoView, attachBlock.Transactions); err != nil {
 155                         return err
 156                 }
 157                 txStatus, err := c.GetTransactionStatus(&attachBlock.ID)
 158                 if err != nil {
 159                         return err
 160                 }
 161                 if err := utxoView.ApplyBlock(attachBlock, txStatus); err != nil {
 162                         return err
 163                 }
 164
 165                 if err := c.bbft.ApplyBlock(voteResultMap, b); err != nil {
 166                         return err
 167                 }
 168
 169                 if c.bbft.isIrreversible(b) && b.Height > irreversibleNode.Height {
 170                         irreversibleNode = attachNode
 171                 }
 172
 173                 log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("attach from mainchain")
 174         }
 175
 176         return c.setState(node, irreversibleNode, utxoView, voteResultMap)
 177 }
 178
 179 // SaveBlock will validate and save block into storage
 180 func (c *Chain) saveBlock(block *types.Block) error {
 181         if err := c.bbft.ValidateBlock(block); err != nil {
 182                 return errors.Sub(ErrBadBlock, err)
 183         }
 184
 185         parent := c.index.GetNode(&block.PreviousBlockHash)
 186         if err := validation.ValidateBlock(types.MapBlock(block), parent); err != nil {
 187                 return errors.Sub(ErrBadBlock, err)
 188         }
 189
 190         signature, err := c.bbft.SignBlock(block)
 191         if err != nil {
 192                 return errors.Sub(ErrBadBlock, err)
 193         }
 194
 195         if len(signature) != 0 {
 196                 if err := c.bbft.eventDispatcher.Post(event.BlockSignatureEvent{BlockHash: block.Hash(), Signature: signature}); err != nil {
 197                         return err
 198                 }
 199         }
 200
 201         bcBlock := types.MapBlock(block)
 202         if err := c.store.SaveBlock(block, bcBlock.TransactionStatus); err != nil {
 203                 return err
 204         }
 205
 206         c.orphanManage.Delete(&bcBlock.ID)
 207         node, err := state.NewBlockNode(&block.BlockHeader, parent)
 208         if err != nil {
 209                 return err
 210         }
 211
 212         c.index.AddNode(node)
 213         return nil
 214 }
 215
 216 func (c *Chain) saveSubBlock(block *types.Block) *types.Block {
 217         blockHash := block.Hash()
 218         prevOrphans, ok := c.orphanManage.GetPrevOrphans(&blockHash)
 219         if !ok {
 220                 return block
 221         }
 222
 223         bestBlock := block
 224         for _, prevOrphan := range prevOrphans {
 225                 orphanBlock, ok := c.orphanManage.Get(prevOrphan)
 226                 if !ok {
 227                         log.WithFields(log.Fields{"module": logModule, "hash": prevOrphan.String()}).Warning("saveSubBlock fail to get block from orphanManage")
 228                         continue
 229                 }
 230                 if err := c.saveBlock(orphanBlock); err != nil {
 231                         log.WithFields(log.Fields{"module": logModule, "hash": prevOrphan.String(), "height": orphanBlock.Height}).Warning("saveSubBlock fail to save block")
 232                         continue
 233                 }
 234
 235                 if subBestBlock := c.saveSubBlock(orphanBlock); subBestBlock.Height > bestBlock.Height {
 236                         bestBlock = subBestBlock
 237                 }
 238         }
 239         return bestBlock
 240 }
 241
 242 type processBlockResponse struct {
 243         isOrphan bool
 244         err      error
 245 }
 246
 247 type processBlockMsg struct {
 248         block *types.Block
 249         reply chan processBlockResponse
 250 }
 251
 252 // ProcessBlock is the entry for chain update
 253 func (c *Chain) ProcessBlock(block *types.Block) (bool, error) {
 254         reply := make(chan processBlockResponse, 1)
 255         c.processBlockCh <- &processBlockMsg{block: block, reply: reply}
 256         response := <-reply
 257         return response.isOrphan, response.err
 258 }
 259
 260 func (c *Chain) blockProcesser() {
 261         for msg := range c.processBlockCh {
 262                 isOrphan, err := c.processBlock(msg.block)
 263                 msg.reply <- processBlockResponse{isOrphan: isOrphan, err: err}
 264         }
 265 }
 266
 267 // ProcessBlock is the entry for handle block insert
 268 func (c *Chain) processBlock(block *types.Block) (bool, error) {
 269         if block.Height <= c.bestIrreversibleNode.Height {
 270                 return false, errors.New("the height of block below the height of irreversible block")
 271         }
 272
 273         blockHash := block.Hash()
 274         if c.BlockExist(&blockHash) {
 275                 log.WithFields(log.Fields{"module": logModule, "hash": blockHash.String(), "height": block.Height}).Info("block has been processed")
 276                 return c.orphanManage.BlockExist(&blockHash), nil
 277         }
 278
 279         parent := c.index.GetNode(&block.PreviousBlockHash)
 280         if parent == nil {
 281                 c.orphanManage.Add(block)
 282                 return true, nil
 283         }
 284
 285         if err := c.saveBlock(block); err != nil {
 286                 return false, err
 287         }
 288
 289         bestBlock := c.saveSubBlock(block)
 290         bestBlockHash := bestBlock.Hash()
 291         bestNode := c.index.GetNode(&bestBlockHash)
 292
 293         if bestNode.Parent == c.bestNode {
 294                 log.WithFields(log.Fields{"module": logModule}).Debug("append block to the end of mainchain")
 295                 return false, c.connectBlock(bestBlock)
 296         }
 297
 298         if bestNode.Height > c.bestNode.Height {
 299                 log.WithFields(log.Fields{"module": logModule}).Debug("start to reorganize chain")
 300                 return false, c.reorganizeChain(bestNode)
 301         }
 302         return false, nil
 303 }
 304
 305 func (c *Chain) ProcessBlockSignature(signature, pubkey []byte, blockHeight uint64, blockHash *bc.Hash) error {
 306         isBestIrreversible, err := c.bbft.ProcessBlockSignature(signature, pubkey, blockHeight, blockHash)
 307         if err != nil {
 308                 return err
 309         }
 310
 311         if isBestIrreversible {
 312                 bestIrreversibleNode := c.index.GetNode(blockHash)
 313                 if err := c.store.SaveChainNodeStatus(c.bestNode, bestIrreversibleNode); err != nil {
 314                         return err
 315                 }
 316
 317                 c.bestIrreversibleNode = bestIrreversibleNode
 318         }
 319         return nil
 320 }