remove block index struct (#1977)

* remove block index struct

* ci ci

diff --git a/database/store.go b/database/store.go
index 3eda894..9b70b29 100644 (file)
--- a/database/store.go
+++ b/database/store.go
@@ -195,50 +195,6 @@ func (s *Store) GetStoreStatus() *protocol.BlockStoreState {
        return loadBlockStoreStateJSON(s.db)
 }
 
-// LoadBlockIndex loadblockIndex by bestHeight
-func (s *Store) LoadBlockIndex(stateBestHeight uint64) (*state.BlockIndex, error) {
-       startTime := time.Now()
-       blockIndex := state.NewBlockIndex()
-       bhIter := s.db.IteratorPrefix(BlockHeaderIndexPrefix)
-       defer bhIter.Release()
-
-       var lastNode *state.BlockNode
-       for bhIter.Next() {
-               bh := &types.BlockHeader{}
-               if err := bh.UnmarshalText(bhIter.Value()); err != nil {
-                       return nil, err
-               }
-
-               // If a block with a height greater than the best height of state is added to the index,
-               // It may cause a bug that the new block cant not be process properly.
-               if bh.Height > stateBestHeight {
-                       break
-               }
-
-               var parent *state.BlockNode
-               if lastNode == nil || lastNode.Hash == bh.PreviousBlockHash {
-                       parent = lastNode
-               } else {
-                       parent = blockIndex.GetNode(&bh.PreviousBlockHash)
-               }
-
-               node, err := state.NewBlockNode(bh, parent)
-               if err != nil {
-                       return nil, err
-               }
-
-               blockIndex.AddNode(node)
-               lastNode = node
-       }
-
-       log.WithFields(log.Fields{
-               "module":   logModule,
-               "height":   stateBestHeight,
-               "duration": time.Since(startTime),
-       }).Debug("initialize load history block index from database")
-       return blockIndex, nil
-}
-
 // SaveChainStatus save the core's newest status && delete old status
 func (s *Store) SaveChainStatus(blockHeader, finalizedBlockHeader *types.BlockHeader, mainBlockHeaders []*types.BlockHeader, view *state.UtxoViewpoint, contractView *state.ContractViewpoint) error {
        batch := s.db.NewBatch()

diff --git a/database/store_test.go b/database/store_test.go
index 9258ab5..085bade 100644 (file)
--- a/database/store_test.go
+++ b/database/store_test.go
@@ -14,128 +14,6 @@ import (
        "github.com/bytom/bytom/testutil"
 )
 
-func TestLoadBlockIndex(t *testing.T) {
-       defer os.RemoveAll("temp")
-       testDB := dbm.NewDB("testdb", "leveldb", "temp")
-       store := NewStore(testDB)
-
-       block := config.GenesisBlock()
-       if err := store.SaveBlock(block); err != nil {
-               t.Fatal(err)
-       }
-
-       for block.Height <= 128 {
-               preHash := block.Hash()
-               block.PreviousBlockHash = preHash
-               block.Height++
-               if err := store.SaveBlock(block); err != nil {
-                       t.Fatal(err)
-               }
-
-               if block.Height%32 != 0 {
-                       continue
-               }
-
-               for i := uint64(0); i < block.Height/32; i++ {
-                       if err := store.SaveBlock(block); err != nil {
-                               t.Fatal(err)
-                       }
-               }
-       }
-
-       if _, err := store.LoadBlockIndex(128); err != nil {
-               t.Fatal(err)
-       }
-}
-
-func TestLoadBlockIndexBestHeight(t *testing.T) {
-       cases := []struct {
-               blockBestHeight uint64
-               stateBestHeight uint64
-       }{
-               {
-                       blockBestHeight: 100,
-                       stateBestHeight: 90,
-               },
-               {
-                       blockBestHeight: 100,
-                       stateBestHeight: 0,
-               },
-               {
-                       blockBestHeight: 100,
-                       stateBestHeight: 100,
-               },
-       }
-
-       defer os.RemoveAll("temp")
-       testDB := dbm.NewDB("testdb", "leveldb", "temp")
-       store := NewStore(testDB)
-       var savedBlocks []types.Block
-
-       for _, c := range cases {
-               block := config.GenesisBlock()
-               for i := uint64(0); i < c.blockBestHeight; i++ {
-                       if err := store.SaveBlock(block); err != nil {
-                               t.Fatal(err)
-                       }
-
-                       savedBlocks = append(savedBlocks, *block)
-                       block.PreviousBlockHash = block.Hash()
-                       block.Height++
-               }
-
-               index, err := store.LoadBlockIndex(c.stateBestHeight)
-               if err != nil {
-                       t.Fatal(err)
-               }
-
-               for _, block := range savedBlocks {
-                       blockHash := block.Hash()
-                       if existIndex := index.BlockExist(&blockHash); (block.Height <= c.stateBestHeight) != existIndex {
-                               t.Errorf("Error in load block index")
-                       }
-               }
-       }
-}
-
-func TestLoadBlockIndexEquals(t *testing.T) {
-       defer os.RemoveAll("temp")
-       testDB := dbm.NewDB("testdb", "leveldb", "temp")
-       store := NewStore(testDB)
-
-       block := config.GenesisBlock()
-       expectBlockIndex := state.NewBlockIndex()
-       var parent *state.BlockNode
-
-       for block.Height <= 100 {
-               if err := store.SaveBlock(block); err != nil {
-                       t.Fatal(err)
-               }
-
-               if block.Height != 0 {
-                       parent = expectBlockIndex.GetNode(&block.PreviousBlockHash)
-               }
-
-               node, err := state.NewBlockNode(&block.BlockHeader, parent)
-               if err != nil {
-                       t.Fatal(err)
-               }
-
-               expectBlockIndex.AddNode(node)
-               block.PreviousBlockHash = block.Hash()
-               block.Height++
-       }
-
-       index, err := store.LoadBlockIndex(100)
-       if err != nil {
-               t.Fatal(err)
-       }
-
-       if !testutil.DeepEqual(expectBlockIndex, index) {
-               t.Errorf("got block index:%v, expect block index:%v", index, expectBlockIndex)
-       }
-}
-
 func TestSaveChainStatus(t *testing.T) {
        defer os.RemoveAll("temp")
        testDB := dbm.NewDB("testdb", "leveldb", "temp")

diff --git a/protocol/auth_verification_test.go b/protocol/auth_verification_test.go
index 5c5899e..98d7759 100644 (file)
--- a/protocol/auth_verification_test.go
+++ b/protocol/auth_verification_test.go
@@ -105,8 +105,7 @@ func (s *mockStore2) GetStoreStatus() *BlockStoreState                         {
 func (s *mockStore2) GetTransactionsUtxo(*state.UtxoViewpoint, []*bc.Tx) error { return nil }
 func (s *mockStore2) GetUtxo(*bc.Hash) (*storage.UtxoEntry, error)             { return nil, nil }
 func (s *mockStore2) GetMainChainHash(uint64) (*bc.Hash, error)                { return nil, nil }
-func (s *mockStore2) GetContract(hash [32]byte) ([]byte, error)                { return nil, nil }
-func (s *mockStore2) LoadBlockIndex(uint64) (*state.BlockIndex, error)         { return nil, nil }
+func (s *mockStore2) GetContract([32]byte) ([]byte, error)                     { return nil, nil }
 func (s *mockStore2) SaveBlock(*types.Block) error                             { return nil }
 func (s *mockStore2) SaveBlockHeader(*types.BlockHeader) error                 { return nil }
 func (s *mockStore2) SaveChainStatus(*types.BlockHeader, *types.BlockHeader, []*types.BlockHeader, *state.UtxoViewpoint, *state.ContractViewpoint) error {

diff --git a/protocol/state/blockindex.go b/protocol/state/blockindex.go
deleted file mode 100644 (file)
index a2e9d19..0000000
--- a/protocol/state/blockindex.go
+++ /dev/null
@@ -1,179 +0,0 @@
-package state
-
-import (
-       "errors"
-       "sort"
-       "sync"
-
-       "github.com/bytom/bytom/common"
-       "github.com/bytom/bytom/consensus"
-       "github.com/bytom/bytom/protocol/bc"
-       "github.com/bytom/bytom/protocol/bc/types"
-       "github.com/bytom/bytom/testutil"
-)
-
-// approxNodesPerDay is an approximation of the number of new blocks there are
-// in a day on average.
-const approxNodesPerDay = 24 * 24
-
-// BlockNode represents a block within the block chain and is primarily used to
-// aid in selecting the best chain to be the main chain.
-type BlockNode struct {
-       Parent                 *BlockNode // parent is the parent block for this node.
-       Hash                   bc.Hash    // hash of the block.
-       Version                uint64
-       Height                 uint64
-       Timestamp              uint64
-       TransactionsMerkleRoot bc.Hash
-}
-
-func NewBlockNode(bh *types.BlockHeader, parent *BlockNode) (*BlockNode, error) {
-       if bh.Height != 0 && parent == nil {
-               return nil, errors.New("parent node can not be nil")
-       }
-
-       node := &BlockNode{
-               Parent:                 parent,
-               Hash:                   bh.Hash(),
-               Version:                bh.Version,
-               Height:                 bh.Height,
-               Timestamp:              bh.Timestamp,
-               TransactionsMerkleRoot: bh.TransactionsMerkleRoot,
-       }
-
-       return node, nil
-}
-
-// blockHeader convert a node to the header struct
-func (node *BlockNode) BlockHeader() *types.BlockHeader {
-       previousBlockHash := bc.Hash{}
-       if node.Parent != nil {
-               previousBlockHash = node.Parent.Hash
-       }
-       return &types.BlockHeader{
-               Version:           node.Version,
-               Height:            node.Height,
-               PreviousBlockHash: previousBlockHash,
-               Timestamp:         node.Timestamp,
-               BlockCommitment: types.BlockCommitment{
-                       TransactionsMerkleRoot: node.TransactionsMerkleRoot,
-               },
-       }
-}
-
-func (node *BlockNode) CalcPastMedianTime() uint64 {
-       timestamps := []uint64{}
-       iterNode := node
-       for i := 0; i < consensus.MedianTimeBlocks && iterNode != nil; i++ {
-               timestamps = append(timestamps, iterNode.Timestamp)
-               iterNode = iterNode.Parent
-       }
-
-       sort.Sort(common.TimeSorter(timestamps))
-       return timestamps[len(timestamps)/2]
-}
-
-// BlockIndex is the struct for help chain trace block chain as tree
-type BlockIndex struct {
-       sync.RWMutex
-
-       index     map[bc.Hash]*BlockNode
-       mainChain []*BlockNode
-}
-
-// NewBlockIndex will create a empty BlockIndex
-func NewBlockIndex() *BlockIndex {
-       return &BlockIndex{
-               index:     make(map[bc.Hash]*BlockNode),
-               mainChain: make([]*BlockNode, 0, approxNodesPerDay),
-       }
-}
-
-func NewBlockIndexWithData(index map[bc.Hash]*BlockNode, mainChain []*BlockNode) *BlockIndex {
-       return &BlockIndex{index: index, mainChain: mainChain}
-}
-
-// AddNode will add node to the index map
-func (bi *BlockIndex) AddNode(node *BlockNode) {
-       bi.Lock()
-       bi.index[node.Hash] = node
-       bi.Unlock()
-}
-
-func (bi *BlockIndex) BestNode() *BlockNode {
-       bi.RLock()
-       defer bi.RUnlock()
-       return bi.mainChain[len(bi.mainChain)-1]
-}
-
-// BlockExist check does the block existed in blockIndex
-func (bi *BlockIndex) BlockExist(hash *bc.Hash) bool {
-       bi.RLock()
-       _, ok := bi.index[*hash]
-       bi.RUnlock()
-       return ok
-}
-
-func (bi *BlockIndex) Equals(bi1 *BlockIndex) bool {
-       if bi1 == nil {
-               return false
-       }
-       return testutil.DeepEqual(bi.index, bi1.index) && testutil.DeepEqual(bi.mainChain, bi1.mainChain)
-}
-
-// GetNode will search node from the index map
-func (bi *BlockIndex) GetNode(hash *bc.Hash) *BlockNode {
-       bi.RLock()
-       defer bi.RUnlock()
-       return bi.index[*hash]
-}
-
-// TODO: THIS FUNCTION MIGHT BE DELETED
-func (bi *BlockIndex) InMainchain(hash bc.Hash) bool {
-       bi.RLock()
-       defer bi.RUnlock()
-
-       node, ok := bi.index[hash]
-       if !ok {
-               return false
-       }
-       return bi.nodeByHeight(node.Height) == node
-}
-
-// NodeByHeight returns the block node at the specified height.
-func (bi *BlockIndex) NodeByHeight(height uint64) *BlockNode {
-       bi.RLock()
-       defer bi.RUnlock()
-       return bi.nodeByHeight(height)
-}
-
-// SetMainChain will set the the mainChain array
-func (bi *BlockIndex) SetMainChain(node *BlockNode) {
-       bi.Lock()
-       defer bi.Unlock()
-
-       needed := node.Height + 1
-       if uint64(cap(bi.mainChain)) < needed {
-               nodes := make([]*BlockNode, needed, needed+approxNodesPerDay)
-               copy(nodes, bi.mainChain)
-               bi.mainChain = nodes
-       } else {
-               i := uint64(len(bi.mainChain))
-               bi.mainChain = bi.mainChain[0:needed]
-               for ; i < needed; i++ {
-                       bi.mainChain[i] = nil
-               }
-       }
-
-       for node != nil && bi.mainChain[node.Height] != node {
-               bi.mainChain[node.Height] = node
-               node = node.Parent
-       }
-}
-
-func (bi *BlockIndex) nodeByHeight(height uint64) *BlockNode {
-       if height >= uint64(len(bi.mainChain)) {
-               return nil
-       }
-       return bi.mainChain[height]
-}

diff --git a/protocol/state/blockindex_test.go b/protocol/state/blockindex_test.go
deleted file mode 100644 (file)
index 9667059..0000000
--- a/protocol/state/blockindex_test.go
+++ /dev/null
@@ -1,243 +0,0 @@
-package state
-
-import (
-       "math/big"
-       "reflect"
-       "testing"
-
-       "github.com/davecgh/go-spew/spew"
-
-       "github.com/bytom/bytom/protocol/bc"
-       "github.com/bytom/bytom/protocol/bc/types"
-       "github.com/bytom/bytom/testutil"
-)
-
-func stringToBigInt(s string, base int) *big.Int {
-       result, _ := new(big.Int).SetString(s, base)
-       return result
-}
-
-func TestNewBlockNode(t *testing.T) {
-       cases := []struct {
-               blockHeader   *types.BlockHeader
-               parentNode    *BlockNode
-               wantBlockNode *BlockNode
-       }{
-               {
-                       blockHeader: &types.BlockHeader{
-                               Height:    uint64(0),
-                               Timestamp: 0,
-                       },
-                       parentNode: &BlockNode{},
-                       wantBlockNode: &BlockNode{
-                               Hash:    testutil.MustDecodeHash("4e88a20cc3809a5f344d500cf0fd83bec9af89f6858c71cf2e5e46bb6ba904c3"),
-                               Parent: &BlockNode{},
-                       },
-               },
-               {
-                       blockHeader: &types.BlockHeader{
-                               Height:    uint64(100),
-                               Timestamp: 0,
-                       },
-                       parentNode: &BlockNode{},
-                       wantBlockNode: &BlockNode{
-                               Hash:    testutil.MustDecodeHash("387f6a7a6f0560410d83cde6f723aae6d86ef85c1cd835af89531ea4b648ddc6"),
-                               Height:  uint64(100),
-                               Parent: &BlockNode{},
-                       },
-               },
-               {
-                       blockHeader: &types.BlockHeader{
-                               Height:    uint64(100),
-                               Timestamp: 0,
-                       },
-                       parentNode: &BlockNode{},
-                       wantBlockNode: &BlockNode{
-                               Hash:    testutil.MustDecodeHash("387f6a7a6f0560410d83cde6f723aae6d86ef85c1cd835af89531ea4b648ddc6"),
-                               Height:  uint64(100),
-                               Parent: &BlockNode{},
-                       },
-               },
-       }
-
-       for i, c := range cases {
-               blockNode, err := NewBlockNode(c.blockHeader, c.parentNode)
-               if err != nil {
-                       t.Fatal(err)
-               }
-
-               if !reflect.DeepEqual(blockNode, c.wantBlockNode) {
-                       t.Fatal("NewBlockNode test error, index:", i, "want:", spew.Sdump(c.wantBlockNode), "got:", spew.Sdump(blockNode))
-               }
-       }
-}
-
-func TestCalcPastMedianTime(t *testing.T) {
-       cases := []struct {
-               Timestamps []uint64
-               MedianTime uint64
-       }{
-               {
-                       Timestamps: []uint64{1},
-                       MedianTime: 1,
-               },
-               {
-                       Timestamps: []uint64{1, 2},
-                       MedianTime: 2,
-               },
-               {
-                       Timestamps: []uint64{1, 3, 2},
-                       MedianTime: 2,
-               },
-               {
-                       Timestamps: []uint64{1, 3, 2, 3},
-                       MedianTime: 3,
-               },
-               {
-                       Timestamps: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 11, 10, 9},
-                       MedianTime: 6,
-               },
-               {
-                       Timestamps: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 11, 10, 9, 11, 11, 11, 14},
-                       MedianTime: 10,
-               },
-       }
-
-       for idx, c := range cases {
-               var parentNode *BlockNode
-               for i := range c.Timestamps {
-                       blockHeader := &types.BlockHeader{
-                               Height:    uint64(i),
-                               Timestamp: c.Timestamps[i],
-                       }
-
-                       blockNode, err := NewBlockNode(blockHeader, parentNode)
-                       if err != nil {
-                               t.Fatal(err)
-                       }
-                       parentNode = blockNode
-               }
-
-               medianTime := parentNode.CalcPastMedianTime()
-               if medianTime != c.MedianTime {
-                       t.Fatalf("calc median timestamp failed, index: %d, expected: %d, have: %d", idx, c.MedianTime, medianTime)
-               }
-       }
-}
-
-func TestSetMainChain(t *testing.T) {
-       blockIndex := NewBlockIndex()
-       var lastNode *BlockNode
-       for i := uint64(0); i < 4; i++ {
-               node := &BlockNode{
-                       Height: i,
-                       Hash:   bc.Hash{V0: i},
-                       Parent: lastNode,
-               }
-               blockIndex.AddNode(node)
-               lastNode = node
-       }
-
-       tailNode := lastNode
-       blockIndex.SetMainChain(lastNode)
-       for lastNode.Parent != nil {
-               if !blockIndex.InMainchain(lastNode.Hash) {
-                       t.Fatalf("block %d, hash %v is not in main chain", lastNode.Height, lastNode.Hash)
-               }
-               lastNode = lastNode.Parent
-       }
-
-       // fork and set main chain
-       forkHeight := uint64(1)
-       lastNode = blockIndex.nodeByHeight(forkHeight)
-       for i := uint64(1); i <= 3; i++ {
-               node := &BlockNode{
-                       Height: lastNode.Height + 1,
-                       Hash:   bc.Hash{V1: uint64(i)},
-                       Parent: lastNode,
-               }
-               blockIndex.AddNode(node)
-               lastNode = node
-       }
-
-       bestNode := lastNode
-       blockIndex.SetMainChain(lastNode)
-       for lastNode.Parent != nil {
-               if !blockIndex.InMainchain(lastNode.Hash) {
-                       t.Fatalf("after fork, block %d, hash %v is not in main chain", lastNode.Height, lastNode.Hash)
-               }
-               lastNode = lastNode.Parent
-       }
-
-       if bestNode != blockIndex.BestNode() {
-               t.Fatalf("check best node failed")
-       }
-
-       for tailNode.Parent != nil && tailNode.Height > forkHeight {
-               if blockIndex.InMainchain(tailNode.Hash) {
-                       t.Fatalf("old chain block %d, hash %v still in main chain", tailNode.Height, tailNode.Hash)
-               }
-               tailNode = tailNode.Parent
-       }
-}
-
-// MockBlockIndex will mock a empty BlockIndex
-func MockBlockIndex() *BlockIndex {
-       return &BlockIndex{
-               index:     make(map[bc.Hash]*BlockNode),
-               mainChain: make([]*BlockNode, 0, 2),
-       }
-}
-
-func TestSetMainChainExtendCap(t *testing.T) {
-       blockIndex := MockBlockIndex()
-       var lastNode *BlockNode
-
-       cases := []struct {
-               start   uint64
-               stop    uint64
-               wantLen int
-               wantCap int
-       }{
-               {
-                       start:   0,
-                       stop:    500,
-                       wantLen: 500,
-                       wantCap: 500 + approxNodesPerDay,
-               },
-               {
-                       start:   500,
-                       stop:    1000,
-                       wantLen: 1000,
-                       wantCap: 500 + approxNodesPerDay,
-               },
-               {
-                       start:   1000,
-                       stop:    2000,
-                       wantLen: 2000,
-                       wantCap: 2000 + approxNodesPerDay,
-               },
-       }
-
-       for num, c := range cases {
-               for i := c.start; i < c.stop; i++ {
-                       node := &BlockNode{
-                               Height: i,
-                               Hash:   bc.Hash{V0: i},
-                               Parent: lastNode,
-                       }
-                       blockIndex.AddNode(node)
-                       lastNode = node
-               }
-               blockIndex.SetMainChain(lastNode)
-               if c.wantLen != len(blockIndex.mainChain) || c.wantCap != cap(blockIndex.mainChain) {
-                       t.Fatalf("SetMainChain extended capacity error, index: %d, got len: %d, got cap: %d, want len: %d, want cap: %d", num, len(blockIndex.mainChain), cap(blockIndex.mainChain), c.wantLen, c.wantCap)
-               }
-       }
-
-       for i := 0; i < len(blockIndex.mainChain); i++ {
-               if blockIndex.mainChain[i] != blockIndex.index[blockIndex.mainChain[i].Hash] {
-                       t.Fatal("SetMainChain extended capacity error, index:", i, "want:", spew.Sdump(blockIndex.mainChain[i]), "got:", spew.Sdump(blockIndex.index[blockIndex.mainChain[i].Hash]))
-               }
-       }
-}

diff --git a/protocol/store.go b/protocol/store.go
index fd01101..52ad8d7 100644 (file)
--- a/protocol/store.go
+++ b/protocol/store.go
@@ -24,7 +24,6 @@ type Store interface {
        GetCheckpointsByHeight(uint64) ([]*state.Checkpoint, error)
        SaveCheckpoints([]*state.Checkpoint) error
 
-       LoadBlockIndex(uint64) (*state.BlockIndex, error)
        SaveBlock(*types.Block) error
        SaveBlockHeader(*types.BlockHeader) error
        SaveChainStatus(*types.BlockHeader, *types.BlockHeader, []*types.BlockHeader, *state.UtxoViewpoint, *state.ContractViewpoint) error

diff --git a/protocol/txpool_test.go b/protocol/txpool_test.go
index fa9a6c5..e19ff25 100644 (file)
--- a/protocol/txpool_test.go
+++ b/protocol/txpool_test.go
@@ -111,7 +111,6 @@ func (s *mockStore) GetTransactionsUtxo(*state.UtxoViewpoint, []*bc.Tx) error {
 func (s *mockStore) GetUtxo(*bc.Hash) (*storage.UtxoEntry, error)             { return nil, nil }
 func (s *mockStore) GetMainChainHash(uint64) (*bc.Hash, error)                { return nil, nil }
 func (s *mockStore) GetContract(hash [32]byte) ([]byte, error)                { return nil, nil }
-func (s *mockStore) LoadBlockIndex(uint64) (*state.BlockIndex, error)         { return nil, nil }
 func (s *mockStore) SaveBlock(*types.Block) error                             { return nil }
 func (s *mockStore) SaveBlockHeader(*types.BlockHeader) error                 { return nil }
 func (s *mockStore) SaveChainStatus(*types.BlockHeader, *types.BlockHeader, []*types.BlockHeader, *state.UtxoViewpoint, *state.ContractViewpoint) error {
@@ -613,12 +612,11 @@ func (s *mockStore1) GetTransactionsUtxo(utxoView *state.UtxoViewpoint, tx []*bc
        }
        return nil
 }
-func (s *mockStore1) GetUtxo(*bc.Hash) (*storage.UtxoEntry, error)     { return nil, nil }
-func (s *mockStore1) GetMainChainHash(uint64) (*bc.Hash, error)        { return nil, nil }
-func (s *mockStore1) GetContract(hash [32]byte) ([]byte, error)        { return nil, nil }
-func (s *mockStore1) LoadBlockIndex(uint64) (*state.BlockIndex, error) { return nil, nil }
-func (s *mockStore1) SaveBlock(*types.Block) error                     { return nil }
-func (s *mockStore1) SaveBlockHeader(*types.BlockHeader) error         { return nil }
+func (s *mockStore1) GetUtxo(*bc.Hash) (*storage.UtxoEntry, error) { return nil, nil }
+func (s *mockStore1) GetMainChainHash(uint64) (*bc.Hash, error)    { return nil, nil }
+func (s *mockStore1) GetContract(hash [32]byte) ([]byte, error)    { return nil, nil }
+func (s *mockStore1) SaveBlock(*types.Block) error                 { return nil }
+func (s *mockStore1) SaveBlockHeader(*types.BlockHeader) error     { return nil }
 func (s *mockStore1) SaveChainStatus(*types.BlockHeader, *types.BlockHeader, []*types.BlockHeader, *state.UtxoViewpoint, *state.ContractViewpoint) error {
        return nil
 }

diff --git a/test/integration/block_integration_test.go b/test/integration/block_integration_test.go
index 5b67e9c..d111033 100644 (file)
--- a/test/integration/block_integration_test.go
+++ b/test/integration/block_integration_test.go
@@ -1,10 +1,6 @@
 package integration
 
 import (
-       "fmt"
-       "testing"
-       "time"
-
        "github.com/bytom/bytom/config"
        "github.com/bytom/bytom/consensus"
        "github.com/bytom/bytom/database"
@@ -12,7 +8,6 @@ import (
        "github.com/bytom/bytom/protocol"
        "github.com/bytom/bytom/protocol/bc"
        "github.com/bytom/bytom/protocol/bc/types"
-       "github.com/bytom/bytom/protocol/state"
        "github.com/bytom/bytom/testutil"
 )
 
@@ -459,612 +454,6 @@ func init() {
        mustPostProcessBlock()
 }
 
-func TestProcessBlock(t *testing.T) {
-       t.Skip("Skipping testing in CI environment")
-       cases := []*processBlockTestCase{
-               {
-                       desc: "process a invalid block",
-                       newBlock: &types.Block{
-                               BlockHeader: types.BlockHeader{
-                                       Height:            1,
-                                       Version:           1,
-                                       PreviousBlockHash: blockMap[0][0].block.Hash(),
-                               },
-                       },
-                       wantStore: createStoreEntries([]int{0}, []*attachBlock{blockMap[0][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantError:        true,
-               },
-               {
-                       desc:      "process a orphan block normally",
-                       newBlock:  blockMap[2][0].block,
-                       wantStore: createStoreEntries([]int{0}, []*attachBlock{blockMap[0][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil),
-                               },
-                               []*state.BlockNode{
-                                       mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManageWithData(
-                               map[bc.Hash]*protocol.OrphanBlock{blockMap[2][0].block.Hash(): {Block: blockMap[2][0].block}},
-                               map[bc.Hash][]*bc.Hash{blockMap[2][0].block.PreviousBlockHash: {hashPtr(blockMap[2][0].block.Hash())}},
-                       ),
-                       wantIsOrphan: true,
-                       wantError:    false,
-               },
-               {
-                       desc:      "attach a block normally",
-                       newBlock:  blockMap[1][0].block,
-                       wantStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil),
-                                       mustNewBlockNode(&blockMap[1][0].block.BlockHeader, mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil)),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:      "init genesis block from db",
-                       newBlock:  blockMap[1][0].block,
-                       initStore: createStoreEntries([]int{0}, []*attachBlock{blockMap[0][0]}),
-                       wantStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil),
-                                       mustNewBlockNode(&blockMap[1][0].block.BlockHeader, mustNewBlockNode(&blockMap[0][0].block.BlockHeader, nil)),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:      "attach a block to fork chain normally, not rollback",
-                       newBlock:  blockMap[2][0].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[1][1]}),
-                       wantStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[1][1], blockMap[2][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][1].block.Hash(): mustCreateBlockNode(&blockMap[1][1].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "attach a block with btm transaction normally",
-                       newBlock: blockMap[2][1].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][1]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][1].block.Hash(): mustCreateBlockNode(&blockMap[2][1].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][1].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "attach a block with retire transaction normally",
-                       newBlock: blockMap[2][2].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][2]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][2].block.Hash(): mustCreateBlockNode(&blockMap[2][2].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][2].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "attach a block with issuance transaction normally",
-                       newBlock: blockMap[2][3].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][3]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][3].block.Hash(): mustCreateBlockNode(&blockMap[2][3].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][3].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "attach a block with issuance transaction but status fail is true",
-                       newBlock: blockMap[2][4].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        true,
-               },
-               {
-                       desc:     "attach a block with non btm transaction",
-                       newBlock: blockMap[2][5].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][5]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][5].block.Hash(): mustCreateBlockNode(&blockMap[2][5].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][5].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "attach a block with non btm transaction but status fail is true",
-                       newBlock: blockMap[2][6].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        true,
-               },
-               {
-                       desc:      "rollback a block only has coinbase transaction",
-                       newBlock:  blockMap[2][0].block,
-                       initStore: createStoreEntries([]int{0, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[1][1]}),
-                       wantStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[1][1], blockMap[2][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][1].block.Hash(): mustCreateBlockNode(&blockMap[1][1].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has spend btm transaction",
-                       newBlock: blockMap[3][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][1]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][1], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][1].block.Hash(): mustCreateBlockNode(&blockMap[2][1].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has issuance transaction",
-                       newBlock: blockMap[3][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][3]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][3], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][3].block.Hash(): mustCreateBlockNode(&blockMap[2][3].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has issuance transaction but status fail is true",
-                       newBlock: blockMap[3][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][4]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore:        nil,
-                       wantBlockIndex:   nil,
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        true,
-               },
-               {
-                       desc:     "rollback a block has spend non btm",
-                       newBlock: blockMap[3][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][5]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][5], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][5].block.Hash(): mustCreateBlockNode(&blockMap[2][5].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has spend non btm but status fail is true",
-                       newBlock: blockMap[3][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][6]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       wantStore:        nil,
-                       wantBlockIndex:   nil,
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        true,
-               },
-               {
-                       desc:      "rollback a block only has coinbase tx, and from orphan manage",
-                       newBlock:  blockMap[1][0].block,
-                       initStore: createStoreEntries([]int{0, 1}, []*attachBlock{blockMap[0][0], blockMap[1][1]}),
-                       initOrphanManage: protocol.NewOrphanManageWithData(
-                               map[bc.Hash]*protocol.OrphanBlock{
-                                       blockMap[2][0].block.Hash(): protocol.NewOrphanBlock(blockMap[2][0].block, time.Now().Add(time.Minute*60)),
-                               },
-                               map[bc.Hash][]*bc.Hash{blockMap[2][0].block.PreviousBlockHash: {hashPtr(blockMap[2][0].block.Hash())}},
-                       ),
-                       wantStore: createStoreEntries([]int{0, 1, 3}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[1][1], blockMap[2][0]}),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][1].block.Hash(): mustCreateBlockNode(&blockMap[1][1].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has spend btm tx, and from orphan manage",
-                       newBlock: blockMap[2][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][1]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       initOrphanManage: protocol.NewOrphanManageWithData(
-                               map[bc.Hash]*protocol.OrphanBlock{
-                                       blockMap[3][0].block.Hash(): protocol.NewOrphanBlock(blockMap[3][0].block, time.Now().Add(time.Minute*60)),
-                               },
-                               map[bc.Hash][]*bc.Hash{blockMap[3][0].block.PreviousBlockHash: {hashPtr(blockMap[3][0].block.Hash())}},
-                       ),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][1], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][1].block.Hash(): mustCreateBlockNode(&blockMap[2][1].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has retire tx, and from orphan manage",
-                       newBlock: blockMap[2][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][2]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       initOrphanManage: protocol.NewOrphanManageWithData(
-                               map[bc.Hash]*protocol.OrphanBlock{
-                                       blockMap[3][0].block.Hash(): protocol.NewOrphanBlock(blockMap[3][0].block, time.Now().Add(time.Minute*60)),
-                               },
-                               map[bc.Hash][]*bc.Hash{blockMap[3][0].block.PreviousBlockHash: {hashPtr(blockMap[3][0].block.Hash())}},
-                       ),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][2], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][2].block.Hash(): mustCreateBlockNode(&blockMap[2][2].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has issuance tx, and from orphan manage",
-                       newBlock: blockMap[2][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][3]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       initOrphanManage: protocol.NewOrphanManageWithData(
-                               map[bc.Hash]*protocol.OrphanBlock{
-                                       blockMap[3][0].block.Hash(): protocol.NewOrphanBlock(blockMap[3][0].block, time.Now().Add(time.Minute*60)),
-                               },
-                               map[bc.Hash][]*bc.Hash{blockMap[3][0].block.PreviousBlockHash: {hashPtr(blockMap[3][0].block.Hash())}},
-                       ),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][3], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][3].block.Hash(): mustCreateBlockNode(&blockMap[2][3].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-               {
-                       desc:     "rollback a block has non btm tx, and from orphan manage",
-                       newBlock: blockMap[2][0].block,
-                       initStore: createStoreEntries([]int{0, 1, 2}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][5]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 1, Spent: false},
-                       }),
-                       initOrphanManage: protocol.NewOrphanManageWithData(
-                               map[bc.Hash]*protocol.OrphanBlock{
-                                       blockMap[3][0].block.Hash(): protocol.NewOrphanBlock(blockMap[3][0].block, time.Now().Add(time.Minute*60)),
-                               },
-                               map[bc.Hash][]*bc.Hash{blockMap[3][0].block.PreviousBlockHash: {hashPtr(blockMap[3][0].block.Hash())}},
-                       ),
-                       wantStore: createStoreEntries([]int{0, 1, 2, 4}, []*attachBlock{blockMap[0][0], blockMap[1][0], blockMap[2][0], blockMap[2][5], blockMap[3][0]}, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("c93b687f98d039046cd2afd514c62f5d1c2c3b0804e4845b00a33e736ef48a33"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }, &storeItem{
-                               key: database.CalcUtxoKey(hashPtr(testutil.MustDecodeHash("be164edbce8bcd1d890c1164541b8418fdcb257499757d3b88561bca06e97e29"))),
-                               val: &storage.UtxoEntry{IsCoinBase: false, BlockHeight: 0, Spent: false},
-                       }),
-                       wantBlockIndex: state.NewBlockIndexWithData(
-                               map[bc.Hash]*state.BlockNode{
-                                       blockMap[0][0].block.Hash(): mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       blockMap[1][0].block.Hash(): mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][0].block.Hash(): mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[2][5].block.Hash(): mustCreateBlockNode(&blockMap[2][5].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       blockMap[3][0].block.Hash(): mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                               []*state.BlockNode{
-                                       mustCreateBlockNode(&blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                                       mustCreateBlockNode(&blockMap[3][0].block.BlockHeader, &blockMap[2][0].block.BlockHeader, &blockMap[1][0].block.BlockHeader, &blockMap[0][0].block.BlockHeader),
-                               },
-                       ),
-                       wantOrphanManage: protocol.NewOrphanManage(),
-                       wantIsOrphan:     false,
-                       wantError:        false,
-               },
-       }
-
-       for i, c := range cases {
-               if err := c.Run(); err != nil {
-                       panic(fmt.Sprintf("tesecase:%d, error:%s", i, err.Error()))
-               }
-       }
-}
-
 func createStoreItems(mainChainIndexes []int, attachBlocks []*attachBlock, extralItem ...*storeItem) storeItems {
        var items storeItems
        for _, item := range extralItem {
@@ -1127,14 +516,6 @@ func hashPtr(hash bc.Hash) *bc.Hash {
        return &hash
 }
 
-func mustCreateBlockNode(header *types.BlockHeader, parents ...*types.BlockHeader) *state.BlockNode {
-       var parentNode *state.BlockNode
-       for i := len(parents) - 1; i >= 0; i-- {
-               parentNode = mustNewBlockNode(parents[i], parentNode)
-       }
-       return mustNewBlockNode(header, parentNode)
-}
-
 func mustPostProcessBlock() {
        for _, blocks := range blockMap {
                for _, attachBlock := range blocks {
@@ -1166,14 +547,6 @@ func mustFillTransactionSize(block *types.Block) {
        }
 }
 
-func mustNewBlockNode(h *types.BlockHeader, parent *state.BlockNode) *state.BlockNode {
-       node, err := state.NewBlockNode(h, parent)
-       if err != nil {
-               panic(err)
-       }
-       return node
-}
-
 func spendUTXO(spendOutputID bc.Hash, items storeItems, blockHeight uint64) int {
        for i, item := range items {
                utxo, ok := item.val.(*storage.UtxoEntry)

diff --git a/test/integration/block_integration_util.go b/test/integration/block_integration_util.go
index 712c3c4..e8dd7ff 100644 (file)
--- a/test/integration/block_integration_util.go
+++ b/test/integration/block_integration_util.go
@@ -18,7 +18,6 @@ import (
        "github.com/bytom/bytom/protocol"
        "github.com/bytom/bytom/protocol/bc"
        "github.com/bytom/bytom/protocol/bc/types"
-       "github.com/bytom/bytom/protocol/state"
        "github.com/bytom/bytom/testutil"
 )
 
@@ -37,7 +36,6 @@ type processBlockTestCase struct {
        desc             string
        initStore        []storeEntry
        wantStore        []storeEntry
-       wantBlockIndex   *state.BlockIndex
        initOrphanManage *protocol.OrphanManage
        wantOrphanManage *protocol.OrphanManage
        wantIsOrphan     bool

diff --git a/test/utxo_view/utxo_view_test_util.go b/test/utxo_view/utxo_view_test_util.go
index f408993..49b3462 100644 (file)
--- a/test/utxo_view/utxo_view_test_util.go
+++ b/test/utxo_view/utxo_view_test_util.go
@@ -6,7 +6,6 @@ import (
        "github.com/bytom/bytom/consensus"
        "github.com/bytom/bytom/protocol/bc"
        "github.com/bytom/bytom/protocol/bc/types"
-       "github.com/bytom/bytom/protocol/state"
        "github.com/bytom/bytom/testutil"
 )
 
@@ -49,22 +48,6 @@ func (t *tx) OutputHash(outIndex int) *bc.Hash {
        return t.Tx.ResultIds[outIndex]
 }
 
-func blockNode(header *bc.BlockHeader) *state.BlockNode {
-       h := types.BlockHeader{
-               Version:           header.Version,
-               Height:            header.Height,
-               PreviousBlockHash: *header.PreviousBlockId,
-               Timestamp:         header.Timestamp,
-       }
-       return &state.BlockNode{
-               Parent:    nil,
-               Hash:      h.Hash(),
-               Version:   h.Version,
-               Height:    h.Height,
-               Timestamp: h.Timestamp,
-       }
-}
-
 func mustDecodeHex(str string) []byte {
        data, err := hex.DecodeString(str)
        if err != nil {