protocol/block.go

   1 package protocol
   2
   3 import (
   4         log "github.com/sirupsen/logrus"
   5
   6         "github.com/bytom/vapor/errors"
   7         "github.com/bytom/vapor/protocol/bc"
   8         "github.com/bytom/vapor/protocol/bc/types"
   9         "github.com/bytom/vapor/protocol/state"
  10         "github.com/bytom/vapor/protocol/validation"
  11 )
  12
  13 var (
  14         // ErrBadBlock is returned when a block is invalid.
  15         ErrBadBlock = errors.New("invalid block")
  16         // ErrBadStateRoot is returned when the computed assets merkle root
  17         // disagrees with the one declared in a block header.
  18         ErrBadStateRoot = errors.New("invalid state merkle root")
  19 )
  20
  21 // BlockExist check is a block in chain or orphan
  22 func (c *Chain) BlockExist(hash *bc.Hash) bool {
  23         if bh, err := c.store.GetBlockHeader(hash); err == nil && bh.Height <= c.BestBlockHeight() {
  24                 return true
  25         }
  26         return 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 by given height
  35 func (c *Chain) GetBlockByHeight(height uint64) (*types.Block, error) {
  36         hash, err := c.store.GetMainChainHash(height)
  37         if err != nil {
  38                 return nil, errors.Wrap(err, "can't find block in given height")
  39         }
  40         return c.store.GetBlock(hash)
  41 }
  42
  43 // GetHeaderByHash return a block header by given hash
  44 func (c *Chain) GetHeaderByHash(hash *bc.Hash) (*types.BlockHeader, error) {
  45         return c.store.GetBlockHeader(hash)
  46 }
  47
  48 // GetHeaderByHeight return a block header by given height
  49 func (c *Chain) GetHeaderByHeight(height uint64) (*types.BlockHeader, error) {
  50         hash, err := c.store.GetMainChainHash(height)
  51         if err != nil {
  52                 return nil, errors.Wrap(err, "can't find block header in given height")
  53         }
  54         return c.store.GetBlockHeader(hash)
  55 }
  56
  57 func (c *Chain) calcReorganizeChain(beginAttach *types.BlockHeader, beginDetach *types.BlockHeader) ([]*types.BlockHeader, []*types.BlockHeader, error) {
  58         var err error
  59         var attachBlockHeaders []*types.BlockHeader
  60         var detachBlockHeaders []*types.BlockHeader
  61
  62         for attachBlockHeader, detachBlockHeader := beginAttach, beginDetach; detachBlockHeader.Hash() != attachBlockHeader.Hash(); {
  63                 var attachRollback, detachRollBack bool
  64                 if attachRollback = attachBlockHeader.Height >= detachBlockHeader.Height; attachRollback {
  65                         attachBlockHeaders = append([]*types.BlockHeader{attachBlockHeader}, attachBlockHeaders...)
  66                 }
  67
  68                 if detachRollBack = attachBlockHeader.Height <= detachBlockHeader.Height; detachRollBack {
  69                         detachBlockHeaders = append(detachBlockHeaders, detachBlockHeader)
  70                 }
  71
  72                 if attachRollback {
  73                         attachBlockHeader, err = c.store.GetBlockHeader(&attachBlockHeader.PreviousBlockHash)
  74                         if err != nil {
  75                                 return nil, nil, err
  76                         }
  77                 }
  78
  79                 if detachRollBack {
  80                         detachBlockHeader, err = c.store.GetBlockHeader(&detachBlockHeader.PreviousBlockHash)
  81                         if err != nil {
  82                                 return nil, nil, err
  83                         }
  84                 }
  85         }
  86         return attachBlockHeaders, detachBlockHeaders, nil
  87 }
  88
  89 func (c *Chain) connectBlock(block *types.Block) (err error) {
  90         bcBlock := types.MapBlock(block)
  91         if bcBlock.TransactionStatus, err = c.store.GetTransactionStatus(&bcBlock.ID); err != nil {
  92                 return err
  93         }
  94
  95         utxoView := state.NewUtxoViewpoint()
  96         if err := c.store.GetTransactionsUtxo(utxoView, bcBlock.Transactions); err != nil {
  97                 return err
  98         }
  99         if err := utxoView.ApplyBlock(bcBlock, bcBlock.TransactionStatus); err != nil {
 100                 return err
 101         }
 102
 103         consensusResult, err := c.getBestConsensusResult()
 104         if err != nil {
 105                 return err
 106         }
 107         if err := consensusResult.ApplyBlock(block); err != nil {
 108                 return err
 109         }
 110
 111         for _, p := range c.subProtocols {
 112                 if err := c.syncProtocolStatus(p); err != nil {
 113                         return errors.Wrap(err, p.Name(), "sync sub protocol status")
 114                 }
 115
 116                 if err := p.ApplyBlock(block); err != nil {
 117                         return errors.Wrap(err, p.Name(), "sub protocol connect block")
 118                 }
 119         }
 120
 121         if err := c.applyBlockSign(&block.BlockHeader); err != nil {
 122                 return err
 123         }
 124
 125         irrBlockHeader := c.lastIrrBlockHeader
 126         if c.isIrreversible(&block.BlockHeader) && block.Height > irrBlockHeader.Height {
 127                 irrBlockHeader = &block.BlockHeader
 128         }
 129
 130         if err := c.setState(&block.BlockHeader, irrBlockHeader, []*types.BlockHeader{&block.BlockHeader}, utxoView, []*state.ConsensusResult{consensusResult}); err != nil {
 131                 return err
 132         }
 133
 134         for _, tx := range block.Transactions {
 135                 c.txPool.RemoveTransaction(&tx.Tx.ID)
 136         }
 137         return nil
 138 }
 139
 140 func (c *Chain) reorganizeChain(blockHeader *types.BlockHeader) error {
 141         attachBlockHeaders, detachBlockHeaders, err := c.calcReorganizeChain(blockHeader, c.bestBlockHeader)
 142         if err != nil {
 143                 return err
 144         }
 145
 146         utxoView := state.NewUtxoViewpoint()
 147         consensusResults := []*state.ConsensusResult{}
 148         consensusResult, err := c.getBestConsensusResult()
 149         if err != nil {
 150                 return err
 151         }
 152
 153         for _, p := range c.subProtocols {
 154                 if err := c.syncProtocolStatus(p); err != nil {
 155                         return errors.Wrap(err, p.Name(), "sync sub protocol status")
 156                 }
 157         }
 158
 159         txsToRestore := map[bc.Hash]*types.Tx{}
 160         for _, detachBlockHeader := range detachBlockHeaders {
 161                 detachHash := detachBlockHeader.Hash()
 162                 b, err := c.store.GetBlock(&detachHash)
 163                 if err != nil {
 164                         return err
 165                 }
 166
 167                 detachBlock := types.MapBlock(b)
 168                 if err := c.store.GetTransactionsUtxo(utxoView, detachBlock.Transactions); err != nil {
 169                         return err
 170                 }
 171
 172                 txStatus, err := c.GetTransactionStatus(&detachBlock.ID)
 173                 if err != nil {
 174                         return err
 175                 }
 176
 177                 if err := utxoView.DetachBlock(detachBlock, txStatus); err != nil {
 178                         return err
 179                 }
 180
 181                 if err := consensusResult.DetachBlock(b); err != nil {
 182                         return err
 183                 }
 184
 185                 for _, p := range c.subProtocols {
 186                         if err := p.DetachBlock(b); err != nil {
 187                                 return errors.Wrap(err, p.Name(), "sub protocol detach block")
 188                         }
 189                 }
 190
 191                 for _, tx := range b.Transactions {
 192                         txsToRestore[tx.ID] = tx
 193                 }
 194
 195                 blockHash := blockHeader.Hash()
 196                 log.WithFields(log.Fields{"module": logModule, "height": blockHeader.Height, "hash": blockHash.String()}).Debug("detach from mainchain")
 197         }
 198
 199         txsToRemove := map[bc.Hash]*types.Tx{}
 200         irrBlockHeader := c.lastIrrBlockHeader
 201         for _, attachBlockHeader := range attachBlockHeaders {
 202                 attachHash := attachBlockHeader.Hash()
 203                 b, err := c.store.GetBlock(&attachHash)
 204                 if err != nil {
 205                         return err
 206                 }
 207
 208                 attachBlock := types.MapBlock(b)
 209                 if err := c.store.GetTransactionsUtxo(utxoView, attachBlock.Transactions); err != nil {
 210                         return err
 211                 }
 212
 213                 txStatus, err := c.GetTransactionStatus(&attachBlock.ID)
 214                 if err != nil {
 215                         return err
 216                 }
 217
 218                 if err := utxoView.ApplyBlock(attachBlock, txStatus); err != nil {
 219                         return err
 220                 }
 221
 222                 if err := consensusResult.ApplyBlock(b); err != nil {
 223                         return err
 224                 }
 225
 226                 for _, p := range c.subProtocols {
 227                         if err := p.ApplyBlock(b); err != nil {
 228                                 return errors.Wrap(err, p.Name(), "sub protocol attach block")
 229                         }
 230                 }
 231
 232                 if consensusResult.IsFinalize() {
 233                         consensusResults = append(consensusResults, consensusResult.Fork())
 234                 }
 235
 236                 if err := c.applyBlockSign(attachBlockHeader); err != nil {
 237                         return err
 238                 }
 239
 240                 if c.isIrreversible(attachBlockHeader) && attachBlockHeader.Height > irrBlockHeader.Height {
 241                         irrBlockHeader = attachBlockHeader
 242                 }
 243
 244                 for _, tx := range b.Transactions {
 245                         if _, ok := txsToRestore[tx.ID]; !ok {
 246                                 txsToRemove[tx.ID] = tx
 247                         } else {
 248                                 delete(txsToRestore, tx.ID)
 249                         }
 250                 }
 251
 252                 blockHash := blockHeader.Hash()
 253                 log.WithFields(log.Fields{"module": logModule, "height": blockHeader.Height, "hash": blockHash.String()}).Debug("attach from mainchain")
 254         }
 255
 256         if len(detachBlockHeaders) > 0 &&
 257                 detachBlockHeaders[len(detachBlockHeaders)-1].Height <= c.lastIrrBlockHeader.Height &&
 258                 irrBlockHeader.Height <= c.lastIrrBlockHeader.Height {
 259                 return errors.New("rollback block below the height of irreversible block")
 260         }
 261
 262         consensusResults = append(consensusResults, consensusResult.Fork())
 263         if err := c.setState(blockHeader, irrBlockHeader, attachBlockHeaders, utxoView, consensusResults); err != nil {
 264                 return err
 265         }
 266
 267         for txHash := range txsToRemove {
 268                 c.txPool.RemoveTransaction(&txHash)
 269         }
 270
 271         for _, tx := range txsToRestore {
 272                 // the number of restored Tx should be very small or most of time ZERO
 273                 // Error returned from validation is ignored, tx could still be lost if validation fails.
 274                 // TODO: adjust tx timestamp so that it won't starve in pool.
 275                 if _, err := c.validateTx(tx, blockHeader); err != nil {
 276                         log.WithFields(log.Fields{"module": logModule, "tx_id": tx.Tx.ID.String(), "error": err}).Info("restore tx fail")
 277                 }
 278         }
 279
 280         if len(txsToRestore) > 0 {
 281                 log.WithFields(log.Fields{"module": logModule, "num": len(txsToRestore)}).Debug("restore txs back to pool")
 282         }
 283         return nil
 284 }
 285
 286 // SaveBlock will validate and save block into storage
 287 func (c *Chain) saveBlock(block *types.Block) error {
 288         if err := c.validateSign(block); err != nil {
 289                 return errors.Sub(ErrBadBlock, err)
 290         }
 291
 292         parent, err := c.store.GetBlockHeader(&block.PreviousBlockHash)
 293         if err != nil {
 294                 return err
 295         }
 296
 297         consensusResult, err := c.GetConsensusResultByHash(&block.PreviousBlockHash)
 298         if err != nil {
 299                 return err
 300         }
 301
 302         rewards, err := consensusResult.GetCoinbaseRewards(parent.Height)
 303         if err != nil {
 304                 return err
 305         }
 306
 307         bcBlock := types.MapBlock(block)
 308         if err := validation.ValidateBlock(bcBlock, parent, rewards); err != nil {
 309                 return errors.Sub(ErrBadBlock, err)
 310         }
 311
 312         for _, p := range c.subProtocols {
 313                 if err := p.ValidateBlock(block, bcBlock.TransactionStatus.GetVerifyStatus()); err != nil {
 314                         return errors.Wrap(err, "sub protocol save block")
 315                 }
 316         }
 317
 318         if err := c.store.SaveBlock(block, bcBlock.TransactionStatus); err != nil {
 319                 return err
 320         }
 321
 322         c.orphanManage.Delete(&bcBlock.ID)
 323         return nil
 324 }
 325
 326 func (c *Chain) saveSubBlock(block *types.Block) *types.Block {
 327         blockHash := block.Hash()
 328         prevOrphans, ok := c.orphanManage.GetPrevOrphans(&blockHash)
 329         if !ok {
 330                 return block
 331         }
 332
 333         bestBlock := block
 334         for _, prevOrphan := range prevOrphans {
 335                 orphanBlock, ok := c.orphanManage.Get(prevOrphan)
 336                 if !ok {
 337                         log.WithFields(log.Fields{"module": logModule, "hash": prevOrphan.String()}).Warning("saveSubBlock fail to get block from orphanManage")
 338                         continue
 339                 }
 340                 if err := c.saveBlock(orphanBlock); err != nil {
 341                         log.WithFields(log.Fields{"module": logModule, "hash": prevOrphan.String(), "height": orphanBlock.Height}).Warning("saveSubBlock fail to save block")
 342                         continue
 343                 }
 344
 345                 if subBestBlock := c.saveSubBlock(orphanBlock); subBestBlock.Height > bestBlock.Height {
 346                         bestBlock = subBestBlock
 347                 }
 348         }
 349         return bestBlock
 350 }
 351
 352 type processBlockResponse struct {
 353         isOrphan bool
 354         err      error
 355 }
 356
 357 type processBlockMsg struct {
 358         block *types.Block
 359         reply chan processBlockResponse
 360 }
 361
 362 // ProcessBlock is the entry for chain update
 363 func (c *Chain) ProcessBlock(block *types.Block) (bool, error) {
 364         reply := make(chan processBlockResponse, 1)
 365         c.processBlockCh <- &processBlockMsg{block: block, reply: reply}
 366         response := <-reply
 367         return response.isOrphan, response.err
 368 }
 369
 370 func (c *Chain) blockProcesser() {
 371         for msg := range c.processBlockCh {
 372                 isOrphan, err := c.processBlock(msg.block)
 373                 msg.reply <- processBlockResponse{isOrphan: isOrphan, err: err}
 374         }
 375 }
 376
 377 // ProcessBlock is the entry for handle block insert
 378 func (c *Chain) processBlock(block *types.Block) (bool, error) {
 379         blockHash := block.Hash()
 380         if c.BlockExist(&blockHash) {
 381                 log.WithFields(log.Fields{"module": logModule, "hash": blockHash.String(), "height": block.Height}).Debug("block has been processed")
 382                 return c.orphanManage.BlockExist(&blockHash), nil
 383         }
 384
 385         c.markTransactions(block.Transactions...)
 386
 387         if _, err := c.store.GetBlockHeader(&block.PreviousBlockHash); err != nil {
 388                 c.orphanManage.Add(block)
 389                 return true, nil
 390         }
 391
 392         if err := c.saveBlock(block); err != nil {
 393                 return false, err
 394         }
 395
 396         bestBlock := c.saveSubBlock(block)
 397         bestBlockHeader := &bestBlock.BlockHeader
 398
 399         c.cond.L.Lock()
 400         defer c.cond.L.Unlock()
 401         if bestBlockHeader.PreviousBlockHash == c.bestBlockHeader.Hash() {
 402                 log.WithFields(log.Fields{"module": logModule}).Debug("append block to the end of mainchain")
 403                 return false, c.connectBlock(bestBlock)
 404         }
 405
 406         if bestBlockHeader.Height > c.bestBlockHeader.Height {
 407                 log.WithFields(log.Fields{"module": logModule}).Debug("start to reorganize chain")
 408                 return false, c.reorganizeChain(bestBlockHeader)
 409         }
 410         return false, nil
 411 }