"sync"
"time"
- "github.com/bytom/blockchain/txdb"
+ "github.com/bytom/consensus"
+ "github.com/bytom/database"
+ "github.com/bytom/database/storage"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
- "github.com/bytom/protocol/bc/legacy"
+ "github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/state"
)
ErrTheDistantFuture = errors.New("block height too far in future")
)
-// Store provides storage for blockchain data: blocks and state tree
-// snapshots.
-//
-// Note, this is different from a state snapshot. A state snapshot
-// provides access to the state at a given point in time -- outputs
-// and issuance memory. The Chain type uses Store to load state
-// from storage and persist validated data.
-type Store interface {
- BlockExist(*bc.Hash) bool
-
- GetBlock(*bc.Hash) (*legacy.Block, error)
- GetMainchain(*bc.Hash) (map[uint64]*bc.Hash, error)
- GetSnapshot(*bc.Hash) (*state.Snapshot, error)
- GetStoreStatus() txdb.BlockStoreStateJSON
-
- SaveBlock(*legacy.Block) error
- SaveMainchain(map[uint64]*bc.Hash, *bc.Hash) error
- SaveSnapshot(*state.Snapshot, *bc.Hash) error
- SaveStoreStatus(uint64, *bc.Hash)
-}
-
+// OrphanManage is use to handle all the orphan block
type OrphanManage struct {
- orphan map[bc.Hash]*legacy.Block
+ //TODO: add orphan cached block limit
+ orphan map[bc.Hash]*types.Block
preOrphans map[bc.Hash][]*bc.Hash
mtx sync.RWMutex
}
+// NewOrphanManage return a new orphan block
+func NewOrphanManage() *OrphanManage {
+ return &OrphanManage{
+ orphan: make(map[bc.Hash]*types.Block),
+ preOrphans: make(map[bc.Hash][]*bc.Hash),
+ }
+}
+
+// BlockExist check is the block in OrphanManage
func (o *OrphanManage) BlockExist(hash *bc.Hash) bool {
o.mtx.RLock()
_, ok := o.orphan[*hash]
return ok
}
-func (o *OrphanManage) Add(block *legacy.Block) {
+// Add will add the block to OrphanManage
+func (o *OrphanManage) Add(block *types.Block) {
blockHash := block.Hash()
o.mtx.Lock()
defer o.mtx.Unlock()
o.preOrphans[block.PreviousBlockHash] = append(o.preOrphans[block.PreviousBlockHash], &blockHash)
}
+// Delete will delelte the block from OrphanManage
func (o *OrphanManage) Delete(hash *bc.Hash) {
o.mtx.Lock()
defer o.mtx.Unlock()
if !ok {
return
}
-
delete(o.orphan, *hash)
+
preOrphans, ok := o.preOrphans[block.PreviousBlockHash]
- if len(preOrphans) == 1 {
+ if !ok || len(preOrphans) == 1 {
delete(o.preOrphans, block.PreviousBlockHash)
return
}
}
}
-func (o *OrphanManage) Get(hash *bc.Hash) (*legacy.Block, bool) {
+// Get return the orphan block by hash
+func (o *OrphanManage) Get(hash *bc.Hash) (*types.Block, bool) {
o.mtx.RLock()
block, ok := o.orphan[*hash]
o.mtx.RUnlock()
txPool *TxPool
state struct {
- cond sync.Cond // protects height, block, snapshot
- height uint64
+ cond sync.Cond
+ block *types.Block
hash *bc.Hash
- block *legacy.Block
- snapshot *state.Snapshot
mainChain map[uint64]*bc.Hash
}
- store Store
-
- lastQueuedSnapshot time.Time
-}
-
-type pendingSnapshot struct {
- height uint64
- snapshot *state.Snapshot
+ store database.Store
}
// NewChain returns a new Chain using store as the underlying storage.
-func NewChain(ctx context.Context, initialBlockHash bc.Hash, store Store, txPool *TxPool) (*Chain, error) {
+func NewChain(initialBlockHash bc.Hash, store database.Store, txPool *TxPool) (*Chain, error) {
c := &Chain{
InitialBlockHash: initialBlockHash,
- orphanManage: &OrphanManage{
- orphan: make(map[bc.Hash]*legacy.Block),
- preOrphans: make(map[bc.Hash][]*bc.Hash),
- },
- store: store,
- txPool: txPool,
+ orphanManage: NewOrphanManage(),
+ store: store,
+ txPool: txPool,
}
c.state.cond.L = new(sync.Mutex)
-
storeStatus := store.GetStoreStatus()
- c.state.height = storeStatus.Height
- if c.state.height < 1 {
- c.state.snapshot = state.Empty()
+ if storeStatus.Hash == nil {
c.state.mainChain = make(map[uint64]*bc.Hash)
- } else {
- //TODO: snapshot, mainChain version check
- c.state.hash = storeStatus.Hash
- c.state.block, _ = store.GetBlock(storeStatus.Hash)
- c.state.snapshot, _ = store.GetSnapshot(storeStatus.Hash)
- c.state.mainChain, _ = store.GetMainchain(storeStatus.Hash)
+ return c, nil
}
- return c, nil
-}
-func (c *Chain) GetStore() *Store {
- return &(c.store)
+ c.state.hash = storeStatus.Hash
+ var err error
+ if c.state.block, err = store.GetBlock(storeStatus.Hash); err != nil {
+ return nil, err
+ }
+ if c.state.mainChain, err = store.GetMainchain(storeStatus.Hash); err != nil {
+ return nil, err
+ }
+ return c, nil
}
// Height returns the current height of the blockchain.
func (c *Chain) Height() uint64 {
c.state.cond.L.Lock()
defer c.state.cond.L.Unlock()
- return c.state.height
+ if c.state.block == nil {
+ return 0
+ }
+ return c.state.block.Height
}
-func (c *Chain) InMainchain(block *legacy.Block) bool {
+// BestBlockHash return the hash of the chain tail block
+func (c *Chain) BestBlockHash() *bc.Hash {
c.state.cond.L.Lock()
defer c.state.cond.L.Unlock()
+ return c.state.hash
+}
+
+func (c *Chain) inMainchain(block *types.Block) bool {
hash, ok := c.state.mainChain[block.Height]
if !ok {
return false
return *hash == block.Hash()
}
-// TimestampMS returns the latest known block timestamp.
-func (c *Chain) TimestampMS() uint64 {
+// InMainChain checks wheather a block is in the main chain
+func (c *Chain) InMainChain(height uint64, hash bc.Hash) bool {
+ c.state.cond.L.Lock()
+ h, ok := c.state.mainChain[height]
+ c.state.cond.L.Unlock()
+ if !ok {
+ return false
+ }
+
+ return *h == hash
+}
+
+// Timestamp returns the latest known block timestamp.
+func (c *Chain) Timestamp() uint64 {
c.state.cond.L.Lock()
defer c.state.cond.L.Unlock()
if c.state.block == nil {
return 0
}
- return c.state.block.TimestampMS
+ return c.state.block.Timestamp
}
-// State returns the most recent state available. It will not be current
-// unless the current process is the leader. Callers should examine the
-// returned block header's height if they need to verify the current state.
-func (c *Chain) State() (*legacy.Block, *state.Snapshot) {
+// BestBlock returns the chain tail block
+func (c *Chain) BestBlock() *types.Block {
c.state.cond.L.Lock()
defer c.state.cond.L.Unlock()
- return c.state.block, c.state.snapshot
+ return c.state.block
}
-func (c *Chain) setState(b *legacy.Block, s *state.Snapshot) {
- c.state.cond.L.Lock()
- defer c.state.cond.L.Unlock()
- c.state.block = b
- c.state.snapshot = s
- if b != nil && b.Height > c.state.height {
- c.state.height = b.Height
- c.state.cond.Broadcast()
+// GetUtxo try to find the utxo status in db
+func (c *Chain) GetUtxo(hash *bc.Hash) (*storage.UtxoEntry, error) {
+ return c.store.GetUtxo(hash)
+}
+
+// GetSeed return the seed for the given block
+func (c *Chain) GetSeed(height uint64, preBlock *bc.Hash) (*bc.Hash, error) {
+ if height == 0 {
+ return consensus.InitialSeed, nil
+ } else if height%consensus.SeedPerRetarget == 0 {
+ return preBlock, nil
}
+ return c.store.GetSeed(preBlock)
+}
+
+// GetTransactionStatus return the transaction status of give block
+func (c *Chain) GetTransactionStatus(hash *bc.Hash) (*bc.TransactionStatus, error) {
+ return c.store.GetTransactionStatus(hash)
+}
+
+// GetTransactionsUtxo return all the utxos that related to the txs' inputs
+func (c *Chain) GetTransactionsUtxo(view *state.UtxoViewpoint, txs []*bc.Tx) error {
+ return c.store.GetTransactionsUtxo(view, txs)
+}
+
+// This function must be called with mu lock in above level
+func (c *Chain) setState(block *types.Block, view *state.UtxoViewpoint, m map[uint64]*bc.Hash) error {
+ blockHash := block.Hash()
+ c.state.block = block
+ c.state.hash = &blockHash
+ for k, v := range m {
+ c.state.mainChain[k] = v
+ }
+
+ if err := c.store.SaveChainStatus(block, view, c.state.mainChain); err != nil {
+ return err
+ }
+
+ c.state.cond.Broadcast()
+ return nil
}
// BlockSoonWaiter returns a channel that
go func() {
c.state.cond.L.Lock()
defer c.state.cond.L.Unlock()
- for c.state.height < height {
+ for c.state.block.Height < height {
c.state.cond.Wait()
}
ch <- struct{}{}
OSDN Git Service
