protocol/block.go

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