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