protocol/block.go

   1 package protocol
   2
   3 import (
   4         "context"
   5         "time"
   6
   7         "github.com/bytom/errors"
   8         "github.com/bytom/log"
   9         "github.com/bytom/protocol/bc/legacy"
  10         "github.com/bytom/protocol/state"
  11         "github.com/bytom/protocol/validation"
  12 )
  13
  14 // maxBlockTxs limits the number of transactions
  15 // included in each block.
  16 const maxBlockTxs = 10000
  17
  18 // saveSnapshotFrequency stores how often to save a state
  19 // snapshot to the Store.
  20 const saveSnapshotFrequency = time.Hour
  21
  22 var (
  23         // ErrBadBlock is returned when a block is invalid.
  24         ErrBadBlock = errors.New("invalid block")
  25
  26         // ErrStaleState is returned when the Chain does not have a current
  27         // blockchain state.
  28         ErrStaleState = errors.New("stale blockchain state")
  29
  30         // ErrBadStateRoot is returned when the computed assets merkle root
  31         // disagrees with the one declared in a block header.
  32         ErrBadStateRoot = errors.New("invalid state merkle root")
  33 )
  34
  35 // GetBlock returns the block at the given height, if there is one,
  36 // otherwise it returns an error.
  37 func (c *Chain) GetBlock(height uint64) (*legacy.Block, error) {
  38         return c.store.GetBlock(height)
  39 }
  40
  41 // ValidateBlock validates an incoming block in advance of applying it
  42 // to a snapshot (with ApplyValidBlock) and committing it to the
  43 // blockchain (with CommitAppliedBlock).
  44 func (c *Chain) ValidateBlock(block, prev *legacy.Block) error {
  45         blockEnts := legacy.MapBlock(block)
  46         prevEnts := legacy.MapBlock(prev)
  47         err := validation.ValidateBlock(blockEnts, prevEnts)
  48         if err != nil {
  49                 return errors.Sub(ErrBadBlock, err)
  50         }
  51         return errors.Sub(ErrBadBlock, err)
  52 }
  53
  54 // ApplyValidBlock creates an updated snapshot without validating the
  55 // block.
  56 func (c *Chain) ApplyValidBlock(block *legacy.Block) (*state.Snapshot, error) {
  57         _, curSnapshot := c.State()
  58         newSnapshot := state.Copy(curSnapshot)
  59         err := newSnapshot.ApplyBlock(legacy.MapBlock(block))
  60         if err != nil {
  61                 return nil, err
  62         }
  63         //fmt.Printf("want %v, ger %v \n", block.BlockHeader.AssetsMerkleRoot, newSnapshot.Tree.RootHash())
  64         if block.AssetsMerkleRoot != newSnapshot.Tree.RootHash() {
  65                 return nil, ErrBadStateRoot
  66         }
  67         return newSnapshot, nil
  68 }
  69
  70 // CommitBlock commits a block to the blockchain. The block
  71 // must already have been applied with ApplyValidBlock or
  72 // ApplyNewBlock, which will have produced the new snapshot that's
  73 // required here.
  74 //
  75 // This function saves the block to the store and sometimes (not more
  76 // often than saveSnapshotFrequency) saves the state tree to the
  77 // store. New-block callbacks (via asynchronous block-processor pins)
  78 // are triggered.
  79 //
  80 // TODO(bobg): rename to CommitAppliedBlock for clarity (deferred from https://github.com/chain/chain/pull/788)
  81 func (c *Chain) CommitAppliedBlock(ctx context.Context, block *legacy.Block, snapshot *state.Snapshot) error {
  82         // SaveBlock is the linearization point. Once the block is committed
  83         // to persistent storage, the block has been applied and everything
  84         // else can be derived from that block.
  85         err := c.store.SaveBlock(block)
  86         if err != nil {
  87                 return errors.Wrap(err, "storing block")
  88         }
  89         if block.Time().After(c.lastQueuedSnapshot.Add(saveSnapshotFrequency)) {
  90                 c.queueSnapshot(ctx, block.Height, block.Time(), snapshot)
  91         }
  92
  93         err = c.store.FinalizeBlock(ctx, block.Height)
  94         if err != nil {
  95                 return errors.Wrap(err, "finalizing block")
  96         }
  97
  98         // c.setState will update the local blockchain state and height.
  99         // When c.store is a txdb.Store, and c has been initialized with a
 100         // channel from txdb.ListenBlocks, then the above call to
 101         // c.store.FinalizeBlock will have done a postgresql NOTIFY and
 102         // that will wake up the goroutine in NewChain, which also calls
 103         // setHeight.  But duplicate calls with the same blockheight are
 104         // harmless; and the following call is required in the cases where
 105         // it's not redundant.
 106         c.setState(block, snapshot)
 107
 108         return nil
 109 }
 110
 111 func (c *Chain) AddBlock(ctx context.Context, block *legacy.Block) error {
 112         currentBlock, _ := c.State()
 113         if err := c.ValidateBlock(block, currentBlock); err != nil {
 114                 return err
 115         }
 116
 117         newSnap, err := c.ApplyValidBlock(block)
 118         if err != nil {
 119                 return err
 120         }
 121
 122         if err := c.CommitAppliedBlock(ctx, block, newSnap); err != nil {
 123                 return err
 124         }
 125
 126         for _, tx := range block.Transactions {
 127                 c.txPool.RemoveTransaction(&tx.Tx.ID)
 128         }
 129         return nil
 130 }
 131
 132 func (c *Chain) queueSnapshot(ctx context.Context, height uint64, timestamp time.Time, s *state.Snapshot) {
 133         // Non-blockingly queue the snapshot for storage.
 134         ps := pendingSnapshot{height: height, snapshot: s}
 135         select {
 136         case c.pendingSnapshots <- ps:
 137                 c.lastQueuedSnapshot = timestamp
 138         default:
 139                 // Skip it; saving snapshots is taking longer than the snapshotting period.
 140                 log.Printf(ctx, "snapshot storage is taking too long; last queued at %s",
 141                         c.lastQueuedSnapshot)
 142         }
 143 }
 144
 145 func (c *Chain) setHeight(h uint64) {
 146         // We call setHeight from two places independently:
 147         // CommitBlock and the Postgres LISTEN goroutine.
 148         // This means we can get here twice for each block,
 149         // and any of them might be arbitrarily delayed,
 150         // which means h might be from the past.
 151         // Detect and discard these duplicate calls.
 152
 153         c.state.cond.L.Lock()
 154         defer c.state.cond.L.Unlock()
 155
 156         if h <= c.state.height {
 157                 return
 158         }
 159         c.state.height = h
 160         c.state.cond.Broadcast()
 161 }