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