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                 if b.Height <= irreversibleNode.Height {
 134                         return errors.New("the height of rollback block below the height of irreversible block")
 135                 }
 136
 137                 detachBlock := types.MapBlock(b)
 138                 if err := c.store.GetTransactionsUtxo(utxoView, detachBlock.Transactions); err != nil {
 139                         return err
 140                 }
 141
 142                 txStatus, err := c.GetTransactionStatus(&detachBlock.ID)
 143                 if err != nil {
 144                         return err
 145                 }
 146
 147                 if err := utxoView.DetachBlock(detachBlock, txStatus); err != nil {
 148                         return err
 149                 }
 150
 151                 if err := voteResult.DetachBlock(b); err != nil {
 152                         return err
 153                 }
 154
 155                 log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("detach from mainchain")
 156         }
 157
 158         for _, attachNode := range attachNodes {
 159                 b, err := c.store.GetBlock(&attachNode.Hash)
 160                 if err != nil {
 161                         return err
 162                 }
 163
 164                 attachBlock := types.MapBlock(b)
 165                 if err := c.store.GetTransactionsUtxo(utxoView, attachBlock.Transactions); err != nil {
 166                         return err
 167                 }
 168
 169                 txStatus, err := c.GetTransactionStatus(&attachBlock.ID)
 170                 if err != nil {
 171                         return err
 172                 }
 173
 174                 if err := utxoView.ApplyBlock(attachBlock, txStatus); err != nil {
 175                         return err
 176                 }
 177
 178                 if err := voteResult.ApplyBlock(b); err != nil {
 179                         return err
 180                 }
 181
 182                 if voteResult.IsFinalize() {
 183                         voteResults = append(voteResults, voteResult.Fork())
 184                 }
 185
 186                 if c.isIrreversible(attachNode) && b.Height > irreversibleNode.Height {
 187                         irreversibleNode = attachNode
 188                 }
 189
 190                 log.WithFields(log.Fields{"module": logModule, "height": node.Height, "hash": node.Hash.String()}).Debug("attach from mainchain")
 191         }
 192
 193         voteResults = append(voteResults, voteResult.Fork())
 194         return c.setState(node, irreversibleNode, utxoView, voteResults)
 195 }
 196
 197 // SaveBlock will validate and save block into storage
 198 func (c *Chain) saveBlock(block *types.Block) error {
 199         if _, err := c.validateSign(block); err != nil {
 200                 return errors.Sub(ErrBadBlock, err)
 201         }
 202
 203         parent := c.index.GetNode(&block.PreviousBlockHash)
 204         bcBlock := types.MapBlock(block)
 205         if err := validation.ValidateBlock(bcBlock, parent); err != nil {
 206                 return errors.Sub(ErrBadBlock, err)
 207         }
 208
 209         signature, err := c.SignBlock(block)
 210         if err != nil {
 211                 return errors.Sub(ErrBadBlock, err)
 212         }
 213
 214         if err := c.store.SaveBlock(block, bcBlock.TransactionStatus); err != nil {
 215                 return err
 216         }
 217
 218         c.orphanManage.Delete(&bcBlock.ID)
 219         node, err := state.NewBlockNode(&block.BlockHeader, parent)
 220         if err != nil {
 221                 return err
 222         }
 223
 224         c.index.AddNode(node)
 225
 226         if len(signature) != 0 {
 227                 xPub := config.CommonConfig.PrivateKey().XPub()
 228                 if err := c.eventDispatcher.Post(event.BlockSignatureEvent{BlockHash: block.Hash(), Signature: signature, XPub: xPub}); err != nil {
 229                         return err
 230                 }
 231         }
 232         return nil
 233 }
 234
 235 func (c *Chain) saveSubBlock(block *types.Block) *types.Block {
 236         blockHash := block.Hash()
 237         prevOrphans, ok := c.orphanManage.GetPrevOrphans(&blockHash)
 238         if !ok {
 239                 return block
 240         }
 241
 242         bestBlock := block
 243         for _, prevOrphan := range prevOrphans {
 244                 orphanBlock, ok := c.orphanManage.Get(prevOrphan)
 245                 if !ok {
 246                         log.WithFields(log.Fields{"module": logModule, "hash": prevOrphan.String()}).Warning("saveSubBlock fail to get block from orphanManage")
 247                         continue
 248                 }
 249                 if err := c.saveBlock(orphanBlock); err != nil {
 250                         log.WithFields(log.Fields{"module": logModule, "hash": prevOrphan.String(), "height": orphanBlock.Height}).Warning("saveSubBlock fail to save block")
 251                         continue
 252                 }
 253
 254                 if subBestBlock := c.saveSubBlock(orphanBlock); subBestBlock.Height > bestBlock.Height {
 255                         bestBlock = subBestBlock
 256                 }
 257         }
 258         return bestBlock
 259 }
 260
 261 type processBlockResponse struct {
 262         isOrphan bool
 263         err      error
 264 }
 265
 266 type processBlockMsg struct {
 267         block *types.Block
 268         reply chan processBlockResponse
 269 }
 270
 271 // ProcessBlock is the entry for chain update
 272 func (c *Chain) ProcessBlock(block *types.Block) (bool, error) {
 273         reply := make(chan processBlockResponse, 1)
 274         c.processBlockCh <- &processBlockMsg{block: block, reply: reply}
 275         response := <-reply
 276         return response.isOrphan, response.err
 277 }
 278
 279 func (c *Chain) blockProcesser() {
 280         for msg := range c.processBlockCh {
 281                 isOrphan, err := c.processBlock(msg.block)
 282                 msg.reply <- processBlockResponse{isOrphan: isOrphan, err: err}
 283         }
 284 }
 285
 286 // ProcessBlock is the entry for handle block insert
 287 func (c *Chain) processBlock(block *types.Block) (bool, error) {
 288         blockHash := block.Hash()
 289         if block.Height <= c.bestIrreversibleNode.Height {
 290                 log.WithFields(log.Fields{"module": logModule, "hash": blockHash.String(), "height": block.Height}).Info(errBelowIrreversibleBlock.Error())
 291                 return false, errBelowIrreversibleBlock
 292         }
 293
 294         if c.BlockExist(&blockHash) {
 295                 log.WithFields(log.Fields{"module": logModule, "hash": blockHash.String(), "height": block.Height}).Info("block has been processed")
 296                 return c.orphanManage.BlockExist(&blockHash), nil
 297         }
 298
 299         if parent := c.index.GetNode(&block.PreviousBlockHash); parent == nil {
 300                 c.orphanManage.Add(block)
 301                 return true, nil
 302         }
 303
 304         if err := c.saveBlock(block); err != nil {
 305                 return false, err
 306         }
 307
 308         bestBlock := c.saveSubBlock(block)
 309         bestBlockHash := bestBlock.Hash()
 310         bestNode := c.index.GetNode(&bestBlockHash)
 311
 312         if bestNode.Parent == c.bestNode {
 313                 log.WithFields(log.Fields{"module": logModule}).Debug("append block to the end of mainchain")
 314                 return false, c.connectBlock(bestBlock)
 315         }
 316
 317         if bestNode.Height > c.bestNode.Height {
 318                 log.WithFields(log.Fields{"module": logModule}).Debug("start to reorganize chain")
 319                 return false, c.reorganizeChain(bestNode)
 320         }
 321         return false, nil
 322 }