OSDN Git Service

(root) / bytom / vapor.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: a691e8d)
Check mov store (#437)
authorPaladz <yzhu101@uottawa.ca>
Tue, 5 Nov 2019 11:12:36 +0000 (19:12 +0800)
committerGitHub <noreply@github.com>
Tue, 5 Nov 2019 11:12:36 +0000 (19:12 +0800)
* over view code of database/mov_store

* delete the duplicate code

* change the batch read number

application/mov/common/type_test.go [new file with mode: 0644] patch | blob
application/mov/database/mov_store.go patch | blob | history
application/mov/database/mov_store_test.go patch | blob | history

diff --git a/application/mov/common/type_test.go b/application/mov/common/type_test.go
new file mode 100644 (file)
index 0000000..fc98871
--- /dev/null
+++ b/application/mov/common/type_test.go
@@ -0,0 +1,27 @@
+package common
+
+import (
+       "testing"
+
+       "github.com/vapor/consensus"
+       "github.com/vapor/testutil"
+)
+
+func TestCalcUTXOHash(t *testing.T) {
+       wantHash := "d94acbac0304e054569b0a2c2ab546be293552eb83d2d84af7234a013986a906"
+       controlProgram := testutil.MustDecodeHexString("0014d6f0330717170c838e6ac4c643de61e4c035e9b7")
+       sourceID := testutil.MustDecodeHash("3cada915465af2f08c93911bce7a100498fddb5738e5400269c4d5c2b2f5b261")
+       order := Order{
+               FromAssetID: consensus.BTMAssetID,
+               Utxo: &MovUtxo{
+                       SourceID:       &sourceID,
+                       SourcePos:      1,
+                       Amount:         399551000,
+                       ControlProgram: controlProgram,
+               },
+       }
+
+       if hash := order.UTXOHash(); hash.String() != wantHash {
+               t.Fatal("The function is incorrect")
+       }
+}
diff --git a/application/mov/database/mov_store.go b/application/mov/database/mov_store.go
index ac40417..9bbd756 100644 (file)
--- a/application/mov/database/mov_store.go
+++ b/application/mov/database/mov_store.go
@@ -12,6 +12,7 @@ import (
        "github.com/vapor/protocol/bc/types"
 )
 
+// MovStore is the interface for mov's persistent storage
 type MovStore interface {
        GetMovDatabaseState() (*common.MovDatabaseState, error)
        InitDBState(height uint64, hash *bc.Hash) error
@@ -21,14 +22,17 @@ type MovStore interface {
 }
 
 const (
-       order byte = iota
+       order byte = iota + 1
        tradePair
        matchStatus
 
-       tradePairsNum = 1024
-       ordersNum     = 10240
-       assetIDLen    = 32
-       rateByteLen   = 8
+       fromAssetIDPos = 0
+       toAssetIDPos   = 1
+       assetIDLen     = 32
+       rateByteLen    = 8
+
+       tradePairsNum = 32
+       ordersNum     = 128
 )
 
 var (
@@ -52,16 +56,16 @@ func calcTradePairKey(fromAssetID, toAssetID *bc.AssetID) []byte {
        return append(key, toAssetID.Bytes()...)
 }
 
-func getAssetIDFromTradePairKey(key []byte, prefix []byte, posIndex int) *bc.AssetID {
+func getAssetIDFromTradePairKey(key []byte, posIndex int) *bc.AssetID {
        b := [32]byte{}
-       pos := len(prefix) + assetIDLen*posIndex
+       pos := len(tradePairsPrefix) + assetIDLen*posIndex
        copy(b[:], key[pos:pos+assetIDLen])
        assetID := bc.NewAssetID(b)
        return &assetID
 }
 
-func getRateFromOrderKey(key []byte, prefix []byte) float64 {
-       ratePos := len(prefix) + assetIDLen*2
+func getRateFromOrderKey(key []byte) float64 {
+       ratePos := len(ordersPrefix) + assetIDLen*2
        return math.Float64frombits(binary.BigEndian.Uint64(key[ratePos : ratePos+rateByteLen]))
 }
 
@@ -69,14 +73,27 @@ type tradePairData struct {
        Count int
 }
 
+// LevelDBMovStore is the LevelDB implementation for MovStore
 type LevelDBMovStore struct {
        db dbm.DB
 }
 
+// NewLevelDBMovStore create a new LevelDBMovStore object
 func NewLevelDBMovStore(db dbm.DB) *LevelDBMovStore {
        return &LevelDBMovStore{db: db}
 }
 
+// GetMovDatabaseState return the current DB's image status
+func (m *LevelDBMovStore) GetMovDatabaseState() (*common.MovDatabaseState, error) {
+       if value := m.db.Get(bestMatchStore); value != nil {
+               state := &common.MovDatabaseState{}
+               return state, json.Unmarshal(value, state)
+       }
+
+       return nil, errors.New("don't find state of mov-database")
+}
+
+// InitDBState set the DB's image status
 func (m *LevelDBMovStore) InitDBState(height uint64, hash *bc.Hash) error {
        state := &common.MovDatabaseState{Height: height, Hash: hash}
        value, err := json.Marshal(state)
@@ -88,6 +105,7 @@ func (m *LevelDBMovStore) InitDBState(height uint64, hash *bc.Hash) error {
        return nil
 }
 
+// ListOrders return n orders after the input order
 func (m *LevelDBMovStore) ListOrders(orderAfter *common.Order) ([]*common.Order, error) {
        if orderAfter.FromAssetID == nil || orderAfter.ToAssetID == nil {
                return nil, errors.New("assetID is nil")
@@ -97,6 +115,7 @@ func (m *LevelDBMovStore) ListOrders(orderAfter *common.Order) ([]*common.Order,
        orderPrefix = append(orderPrefix, orderAfter.ToAssetID.Bytes()...)
 
        var startKey []byte
+
        if orderAfter.Rate > 0 {
                startKey = calcOrderKey(orderAfter.FromAssetID, orderAfter.ToAssetID, orderAfter.UTXOHash(), orderAfter.Rate)
        }
@@ -111,17 +130,43 @@ func (m *LevelDBMovStore) ListOrders(orderAfter *common.Order) ([]*common.Order,
                        return nil, err
                }
 
-               order := &common.Order{
+               orders = append(orders, &common.Order{
                        FromAssetID: orderAfter.FromAssetID,
                        ToAssetID:   orderAfter.ToAssetID,
-                       Rate:        getRateFromOrderKey(itr.Key(), ordersPrefix),
+                       Rate:        getRateFromOrderKey(itr.Key()),
                        Utxo:        movUtxo,
-               }
-               orders = append(orders, order)
+               })
        }
        return orders, nil
 }
 
+// ListTradePairsWithStart return n trade pairs after the input trade pair
+func (m *LevelDBMovStore) ListTradePairsWithStart(fromAssetIDAfter, toAssetIDAfter *bc.AssetID) ([]*common.TradePair, error) {
+       var startKey []byte
+       if fromAssetIDAfter != nil && toAssetIDAfter != nil {
+               startKey = calcTradePairKey(fromAssetIDAfter, toAssetIDAfter)
+       }
+
+       itr := m.db.IteratorPrefixWithStart(tradePairsPrefix, startKey, false)
+       defer itr.Release()
+
+       var tradePairs []*common.TradePair
+       for txNum := 0; txNum < tradePairsNum && itr.Next(); txNum++ {
+               key := itr.Key()
+               fromAssetID := getAssetIDFromTradePairKey(key, fromAssetIDPos)
+               toAssetID := getAssetIDFromTradePairKey(key, toAssetIDPos)
+
+               tradePairData := &tradePairData{}
+               if err := json.Unmarshal(itr.Value(), tradePairData); err != nil {
+                       return nil, err
+               }
+
+               tradePairs = append(tradePairs, &common.TradePair{FromAssetID: fromAssetID, ToAssetID: toAssetID, Count: tradePairData.Count})
+       }
+       return tradePairs, nil
+}
+
+// ProcessOrders update the DB's image by add new orders, delete the used order
 func (m *LevelDBMovStore) ProcessOrders(addOrders []*common.Order, delOrders []*common.Order, blockHeader *types.BlockHeader) error {
        if err := m.checkMovDatabaseState(blockHeader); err != nil {
                return err
@@ -134,7 +179,6 @@ func (m *LevelDBMovStore) ProcessOrders(addOrders []*common.Order, delOrders []*
        }
 
        m.deleteOrders(batch, delOrders, tradePairsCnt)
-
        if err := m.updateTradePairs(batch, tradePairsCnt); err != nil {
                return err
        }
@@ -174,6 +218,36 @@ func (m *LevelDBMovStore) addOrders(batch dbm.Batch, orders []*common.Order, tra
        return nil
 }
 
+func (m *LevelDBMovStore) calcNextDatabaseState(blockHeader *types.BlockHeader) (*common.MovDatabaseState, error) {
+       hash := blockHeader.Hash()
+       height := blockHeader.Height
+
+       state, err := m.GetMovDatabaseState()
+       if err != nil {
+               return nil, err
+       }
+
+       if *state.Hash == hash {
+               hash = blockHeader.PreviousBlockHash
+               height = blockHeader.Height - 1
+       }
+
+       return &common.MovDatabaseState{Height: height, Hash: &hash}, nil
+}
+
+func (m *LevelDBMovStore) checkMovDatabaseState(header *types.BlockHeader) error {
+       state, err := m.GetMovDatabaseState()
+       if err != nil {
+               return err
+       }
+
+       if (*state.Hash == header.PreviousBlockHash && (state.Height+1) == header.Height) || *state.Hash == header.Hash() {
+               return nil
+       }
+
+       return errors.New("the status of the block is inconsistent with that of mov-database")
+}
+
 func (m *LevelDBMovStore) deleteOrders(batch dbm.Batch, orders []*common.Order, tradePairsCnt map[string]*common.TradePair) {
        for _, order := range orders {
                key := calcOrderKey(order.FromAssetID, order.ToAssetID, order.UTXOHash(), order.Rate)
@@ -190,38 +264,14 @@ func (m *LevelDBMovStore) deleteOrders(batch dbm.Batch, orders []*common.Order,
        }
 }
 
-func (m *LevelDBMovStore) GetMovDatabaseState() (*common.MovDatabaseState, error) {
-       if value := m.db.Get(bestMatchStore); value != nil {
-               state := &common.MovDatabaseState{}
-               return state, json.Unmarshal(value, state)
-       }
-
-       return nil, errors.New("don't find state of mov-database")
-}
-
-func (m *LevelDBMovStore) ListTradePairsWithStart(fromAssetIDAfter, toAssetIDAfter *bc.AssetID) ([]*common.TradePair, error) {
-       var startKey []byte
-       if fromAssetIDAfter != nil && toAssetIDAfter != nil {
-               startKey = calcTradePairKey(fromAssetIDAfter, toAssetIDAfter)
+func (m *LevelDBMovStore) saveMovDatabaseState(batch dbm.Batch, state *common.MovDatabaseState) error {
+       value, err := json.Marshal(state)
+       if err != nil {
+               return err
        }
 
-       itr := m.db.IteratorPrefixWithStart(tradePairsPrefix, startKey, false)
-       defer itr.Release()
-
-       var tradePairs []*common.TradePair
-       for txNum := 0; txNum < tradePairsNum && itr.Next(); txNum++ {
-               key := itr.Key()
-               fromAssetID := getAssetIDFromTradePairKey(key, tradePairsPrefix, 0)
-               toAssetID := getAssetIDFromTradePairKey(key, tradePairsPrefix, 1)
-
-               tradePairData := &tradePairData{}
-               if err := json.Unmarshal(itr.Value(), tradePairData); err != nil {
-                       return nil, err
-               }
-
-               tradePairs = append(tradePairs, &common.TradePair{FromAssetID: fromAssetID, ToAssetID: toAssetID, Count: tradePairData.Count})
-       }
-       return tradePairs, nil
+       batch.Set(bestMatchStore, value)
+       return nil
 }
 
 func (m *LevelDBMovStore) updateTradePairs(batch dbm.Batch, tradePairs map[string]*common.TradePair) error {
@@ -232,11 +282,12 @@ func (m *LevelDBMovStore) updateTradePairs(batch dbm.Batch, tradePairs map[strin
                        if err := json.Unmarshal(value, tradePairData); err != nil {
                                return err
                        }
-               } else if v.Count < 0 {
-                       return errors.New("don't find trade pair")
                }
 
-               tradePairData.Count += v.Count
+               if tradePairData.Count += v.Count; tradePairData.Count < 0 {
+                       return errors.New("negative trade count")
+               }
+
                if tradePairData.Count > 0 {
                        value, err := json.Marshal(tradePairData)
                        if err != nil {
@@ -250,43 +301,3 @@ func (m *LevelDBMovStore) updateTradePairs(batch dbm.Batch, tradePairs map[strin
        }
        return nil
 }
-
-func (m *LevelDBMovStore) checkMovDatabaseState(header *types.BlockHeader) error {
-       state, err := m.GetMovDatabaseState()
-       if err != nil {
-               return err
-       }
-
-       if (*state.Hash == header.PreviousBlockHash && (state.Height+1) == header.Height) || *state.Hash == header.Hash() {
-               return nil
-       }
-
-       return errors.New("the status of the block is inconsistent with that of mov-database")
-}
-
-func (m *LevelDBMovStore) saveMovDatabaseState(batch dbm.Batch, state *common.MovDatabaseState) error {
-       value, err := json.Marshal(state)
-       if err != nil {
-               return err
-       }
-
-       batch.Set(bestMatchStore, value)
-       return nil
-}
-
-func (m *LevelDBMovStore) calcNextDatabaseState(blockHeader *types.BlockHeader) (*common.MovDatabaseState, error) {
-       hash := blockHeader.Hash()
-       height := blockHeader.Height
-
-       state, err := m.GetMovDatabaseState()
-       if err != nil {
-               return nil, err
-       }
-
-       if *state.Hash == hash {
-               hash = blockHeader.PreviousBlockHash
-               height = blockHeader.Height - 1
-       }
-
-       return &common.MovDatabaseState{Height: height, Hash: &hash}, nil
-}
diff --git a/application/mov/database/mov_store_test.go b/application/mov/database/mov_store_test.go
index 2ebb319..d098044 100644 (file)
--- a/application/mov/database/mov_store_test.go
+++ b/application/mov/database/mov_store_test.go
@@ -10,10 +10,8 @@ import (
        "github.com/stretchr/testify/require"
 
        "github.com/vapor/application/mov/common"
-       "github.com/vapor/consensus"
        "github.com/vapor/database/leveldb"
        dbm "github.com/vapor/database/leveldb"
-       chainjson "github.com/vapor/encoding/json"
        "github.com/vapor/protocol/bc"
        "github.com/vapor/protocol/bc/types"
        "github.com/vapor/testutil"
@@ -28,31 +26,188 @@ var (
        assetID6 = &bc.AssetID{V0: 6}
        assetID7 = &bc.AssetID{V0: 7}
        assetID8 = &bc.AssetID{V0: 8}
-)
 
-func TestCalcUTXOHash(t *testing.T) {
-       wantHash := "7cbaf92f950f2a6bededd6cc5ec08c924505f5365b0a8af963e1d52912c99667"
-       controlProgramStr := "0014ab5acbea076f269bfdc8ededbed7d0a13e6e0b19"
-
-       var controlProgram chainjson.HexBytes
-       controlProgram.UnmarshalText([]byte(controlProgramStr))
-
-       sourceID := testutil.MustDecodeHash("ca2faf5fcbf8ee2b43560a32594f608528b12a1fe79cee85252564f886f91060")
-       order := &common.Order{
-               FromAssetID: consensus.BTMAssetID,
-               Utxo: &common.MovUtxo{
-                       SourceID:       &sourceID,
-                       SourcePos:      0,
-                       Amount:         31249300000,
-                       ControlProgram: controlProgram[:],
+       mockOrders = []*common.Order{
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        1.00090,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 21},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00090,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 22},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00097,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 23},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00098,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 13},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00098,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 24},
+                               Amount:         10,
+                               SourcePos:      1,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00099,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 24},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00096,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 25},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00095,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 26},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        1.00090,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 1},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID1,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00090,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 2},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID3,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00096,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 33},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID4,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00095,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 34},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID4,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00096,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 36},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID5,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00096,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 37},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
+               },
+               &common.Order{
+                       FromAssetID: assetID6,
+                       ToAssetID:   assetID2,
+                       Rate:        0.00098,
+                       Utxo: &common.MovUtxo{
+                               SourceID:       &bc.Hash{V0: 38},
+                               Amount:         1,
+                               SourcePos:      0,
+                               ControlProgram: []byte("aa"),
+                       },
                },
        }
+)
+
+func TestGetAssetIDFromTradePairKey(t *testing.T) {
+       b := calcTradePairKey(assetID1, assetID2)
+       gotA := getAssetIDFromTradePairKey(b, fromAssetIDPos)
+       gotB := getAssetIDFromTradePairKey(b, toAssetIDPos)
 
-       hash := order.UTXOHash()
-       if hash.String() != wantHash {
-               t.Fatal("The function is incorrect")
+       if *gotA != *assetID1 {
+               t.Fatalf("got wrong from asset id got %s, want %s", gotA.String(), assetID1.String())
        }
 
+       if *gotB != *assetID2 {
+               t.Fatalf("got wrong to asset id got %s, want %s", gotB.String(), assetID2.String())
+       }
 }
 
 func TestSortOrderKey(t *testing.T) {
@@ -75,12 +230,12 @@ func TestSortOrderKey(t *testing.T) {
        }
 
        cases := []struct {
-               orders []common.Order
+               orders []*common.Order
                want   []expectedData
        }{
                {
-                       orders: []common.Order{
-                               common.Order{
+                       orders: []*common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        1.00090,
@@ -91,7 +246,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00090,
@@ -102,7 +257,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00097,
@@ -113,7 +268,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00098,
@@ -124,7 +279,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00098,
@@ -135,7 +290,40 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
+                                       FromAssetID: &bc.AssetID{V0: 1},
+                                       ToAssetID:   &bc.AssetID{V0: 0},
+                                       Rate:        0.00098,
+                                       Utxo: &common.MovUtxo{
+                                               SourceID:       &bc.Hash{V0: 25},
+                                               Amount:         10,
+                                               SourcePos:      1,
+                                               ControlProgram: []byte("aa"),
+                                       },
+                               },
+                               &common.Order{
+                                       FromAssetID: &bc.AssetID{V0: 1},
+                                       ToAssetID:   &bc.AssetID{V0: 0},
+                                       Rate:        0.00098,
+                                       Utxo: &common.MovUtxo{
+                                               SourceID:       &bc.Hash{V0: 26},
+                                               Amount:         10,
+                                               SourcePos:      1,
+                                               ControlProgram: []byte("aa"),
+                                       },
+                               },
+                               &common.Order{
+                                       FromAssetID: &bc.AssetID{V0: 1},
+                                       ToAssetID:   &bc.AssetID{V0: 0},
+                                       Rate:        0.00098,
+                                       Utxo: &common.MovUtxo{
+                                               SourceID:       &bc.Hash{V0: 27},
+                                               Amount:         10,
+                                               SourcePos:      1,
+                                               ControlProgram: []byte("aa"),
+                                       },
+                               },
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00099,
@@ -146,7 +334,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00096,
@@ -157,7 +345,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00095,
@@ -168,7 +356,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00091,
@@ -179,7 +367,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00092,
@@ -190,7 +378,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00093,
@@ -201,7 +389,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00094,
@@ -212,7 +400,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00077,
@@ -223,7 +411,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        0.00088,
@@ -234,7 +422,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        999999.9521,
@@ -245,7 +433,7 @@ func TestSortOrderKey(t *testing.T) {
                                                ControlProgram: []byte("aa"),
                                        },
                                },
-                               common.Order{
+                               &common.Order{
                                        FromAssetID: &bc.AssetID{V0: 1},
                                        ToAssetID:   &bc.AssetID{V0: 0},
                                        Rate:        888888.7954,
@@ -300,10 +488,22 @@ func TestSortOrderKey(t *testing.T) {
                                },
                                expectedData{
                                        rate:     0.00098,
+                                       utxoHash: "14b51a6103f75d9cacdf0f9551467588c687ed3b029e25c646d276720569e227",
+                               },
+                               expectedData{
+                                       rate:     0.00098,
                                        utxoHash: "1fa9fae83d0a5401a4e92f80636966486e763eecca588aa11dff02b415320602",
                                },
                                expectedData{
                                        rate:     0.00098,
+                                       utxoHash: "6687d18ddbe4e7381a844e393ca3032a412285c9da6988eff182106e28ba09ca",
+                               },
+                               expectedData{
+                                       rate:     0.00098,
+                                       utxoHash: "841b1de7c871dfe6e2d1886809d9ae12ec45e570233b03879305232b096fda43",
+                               },
+                               expectedData{
+                                       rate:     0.00098,
                                        utxoHash: "a4bc534c267d35a9eafc25cd66e0cb270a2537a51186605b7f7591bc567ab4c6",
                                },
                                expectedData{
@@ -338,7 +538,6 @@ func TestSortOrderKey(t *testing.T) {
                }
 
                got := []expectedData{}
-
                itr := db.IteratorPrefixWithStart(nil, nil, false)
                for itr.Next() {
                        key := itr.Key()
@@ -347,9 +546,8 @@ func TestSortOrderKey(t *testing.T) {
                        copy(b[:], key[pos+8:])
                        utxoHash := bc.NewHash(b)
 
-                       rate := getRateFromOrderKey(key, ordersPrefix)
                        got = append(got, expectedData{
-                               rate:     rate,
+                               rate:     getRateFromOrderKey(key),
                                utxoHash: utxoHash.String(),
                        })
                }
@@ -358,7 +556,6 @@ func TestSortOrderKey(t *testing.T) {
                if !testutil.DeepEqual(c.want, got) {
                        t.Errorf("case %v: got recovery status, got: %v, want: %v.", i, got, c.want)
                }
-
        }
 }
 
@@ -378,1583 +575,209 @@ func TestMovStore(t *testing.T) {
                {
                        desc: "add order",
                        addOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       blockHeader: &types.BlockHeader{Height: 1, PreviousBlockHash: bc.Hash{V0: 524821139490765641, V1: 2484214155808702787, V2: 9108473449351508820, V3: 7972721253564512122}},
+                       wantOrders: []*common.Order{
+                               mockOrders[1],
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[0],
+                       },
+                       wantTradePairs: []*common.TradePair{
+                               &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2, Count: 8},
+                       },
+                       wantDBState: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+               },
+               {
+                       desc: "del some order",
+                       beforeOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       beforeTradePairs: []*common.TradePair{
+                               &common.TradePair{
                                        FromAssetID: assetID1,
                                        ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
+                                       Count:       8,
                                },
-                               &common.Order{
+                       },
+                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       delOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                       },
+                       blockHeader: &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       wantOrders: []*common.Order{
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                       },
+                       wantTradePairs: []*common.TradePair{
+                               &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2, Count: 5},
+                       },
+                       wantDBState: &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
+               },
+               {
+                       desc: "del all order",
+                       beforeOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       beforeTradePairs: []*common.TradePair{
+                               &common.TradePair{
                                        FromAssetID: assetID1,
                                        ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
+                                       Count:       8,
                                },
-                               &common.Order{
+                       },
+                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       delOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       blockHeader:    &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       wantOrders:     []*common.Order{},
+                       wantTradePairs: []*common.TradePair{},
+                       wantDBState:    &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
+               },
+               {
+                       desc: "Add and delete the same trade pair", //Add and delete different transaction pairs
+                       beforeOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       beforeTradePairs: []*common.TradePair{
+                               &common.TradePair{
                                        FromAssetID: assetID1,
                                        ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
+                                       Count:       8,
                                },
-                               &common.Order{
+                       },
+                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       addOrders: []*common.Order{
+                               mockOrders[8],
+                               mockOrders[9],
+                       },
+                       delOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       blockHeader: &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       wantOrders: []*common.Order{
+                               mockOrders[9],
+                               mockOrders[8],
+                       },
+                       wantTradePairs: []*common.TradePair{
+                               &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2, Count: 2},
+                       },
+                       wantDBState: &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
+               },
+               {
+                       desc: "Add and delete different transaction pairs",
+                       beforeOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                               mockOrders[10],
+                               mockOrders[11],
+                       },
+                       beforeTradePairs: []*common.TradePair{
+                               &common.TradePair{
                                        FromAssetID: assetID1,
                                        ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
+                                       Count:       8,
                                },
-                               &common.Order{
-                                       FromAssetID: assetID1,
+                               &common.TradePair{
+                                       FromAssetID: assetID3,
                                        ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
+                                       Count:       1,
                                },
-                               &common.Order{
-                                       FromAssetID: assetID1,
+                               &common.TradePair{
+                                       FromAssetID: assetID4,
                                        ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
+                                       Count:       1,
                                },
                        },
-                       blockHeader: &types.BlockHeader{Height: 1, PreviousBlockHash: bc.Hash{V0: 524821139490765641, V1: 2484214155808702787, V2: 9108473449351508820, V3: 7972721253564512122}},
+                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
+                       addOrders: []*common.Order{
+                               mockOrders[12],
+                               mockOrders[13],
+                               mockOrders[14],
+                       },
+                       delOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                               mockOrders[10],
+                       },
+                       blockHeader: &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
                        wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       wantTradePairs: []*common.TradePair{
-                               &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2, Count: 8},
-                       },
-                       wantDBState: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-               },
-               {
-                       desc: "del some order",
-                       beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       beforeTradePairs: []*common.TradePair{
-                               &common.TradePair{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Count:       8,
-                               },
-                       },
-                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       blockHeader: &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       wantTradePairs: []*common.TradePair{
-                               &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2, Count: 5},
-                       },
-                       wantDBState: &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
-               },
-               {
-                       desc: "del all order",
-                       beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       beforeTradePairs: []*common.TradePair{
-                               &common.TradePair{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Count:       8,
-                               },
-                       },
-                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       blockHeader:    &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       wantOrders:     []*common.Order{},
-                       wantTradePairs: []*common.TradePair{},
-                       wantDBState:    &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
-               },
-               {
-                       desc: "Add and delete the same trade pair", //Add and delete different transaction pairs
-                       beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       beforeTradePairs: []*common.TradePair{
-                               &common.TradePair{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Count:       8,
-                               },
-                       },
-                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       addOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 1},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 2},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       blockHeader: &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 2},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 1},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       wantTradePairs: []*common.TradePair{
-                               &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2, Count: 2},
-                       },
-                       wantDBState: &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
-               },
-               {
-                       desc: "Add and delete different transaction pairs",
-                       beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID3,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 33},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID4,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 34},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       beforeTradePairs: []*common.TradePair{
-                               &common.TradePair{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Count:       8,
-                               },
-                               &common.TradePair{
-                                       FromAssetID: assetID3,
-                                       ToAssetID:   assetID2,
-                                       Count:       1,
-                               },
-                               &common.TradePair{
-                                       FromAssetID: assetID4,
-                                       ToAssetID:   assetID2,
-                                       Count:       1,
-                               },
-                       },
-                       beforeDBStatus: &common.MovDatabaseState{Height: 1, Hash: &bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       addOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID4,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 36},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID5,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 37},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID6,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 38},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID3,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 33},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       blockHeader: &types.BlockHeader{Height: 2, PreviousBlockHash: bc.Hash{V0: 14213576368347360351, V1: 16287398171800437029, V2: 9513543230620030445, V3: 8534035697182508177}},
-                       wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID4,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 34},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID4,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 36},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID5,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 37},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID6,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 38},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       wantTradePairs: []*common.TradePair{
-                               &common.TradePair{FromAssetID: assetID4, ToAssetID: assetID2, Count: 2},
-                               &common.TradePair{FromAssetID: assetID5, ToAssetID: assetID2, Count: 1},
-                               &common.TradePair{FromAssetID: assetID6, ToAssetID: assetID2, Count: 1},
-                       },
-                       wantDBState: &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
-               },
-       }
-
-       initBlockHeader := &types.BlockHeader{
-               Height:  0,
-               Version: 1,
-       }
-
-       height := initBlockHeader.Height
-       hash := initBlockHeader.Hash()
-
-       defer os.RemoveAll("temp")
-       for i, c := range cases {
-               testDB := dbm.NewDB("testdb", "leveldb", "temp")
-               movStore := NewLevelDBMovStore(testDB)
-               if err := movStore.InitDBState(height, &hash); err != nil {
-                       t.Fatalf("case %d: InitDBState error %v.", i, err)
-               }
-
-               batch := movStore.db.NewBatch()
-               tradePairsCnt := make(map[string]*common.TradePair)
-               movStore.addOrders(batch, c.beforeOrders, tradePairsCnt)
-               if len(c.beforeOrders) > 0 {
-                       tradePairsCnt = make(map[string]*common.TradePair)
-                       for _, tradePair := range c.beforeTradePairs {
-                               tradePairsCnt[tradePair.Key()] = tradePair
-                       }
-                       movStore.updateTradePairs(batch, tradePairsCnt)
-                       movStore.saveMovDatabaseState(batch, c.beforeDBStatus)
-               }
-               batch.Write()
-
-               if err := movStore.ProcessOrders(c.addOrders, c.delOrders, c.blockHeader); err != nil {
-                       t.Fatalf("case %d: ProcessOrders error %v.", i, err)
-               }
-
-               var gotOrders []*common.Order
-
-               tmp, err := movStore.ListOrders(&common.Order{FromAssetID: assetID1, ToAssetID: assetID2, Rate: 0})
-               if err != nil {
-                       t.Fatalf("case %d: ListOrders(assetID1 and assetID2) error %v.", i, err)
-               }
-
-               gotOrders = append(gotOrders, tmp...)
-
-               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID3, ToAssetID: assetID2, Rate: 0})
-               if err != nil {
-                       t.Fatalf("case %d: ListOrders(assetID3 and assetID2)  error %v.", i, err)
-               }
-
-               gotOrders = append(gotOrders, tmp...)
-
-               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID4, ToAssetID: assetID2, Rate: 0})
-               if err != nil {
-                       t.Fatalf("case %d: ListOrders(assetID4 and assetID2)  error %v.", i, err)
-               }
-
-               gotOrders = append(gotOrders, tmp...)
-
-               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID5, ToAssetID: assetID2, Rate: 0})
-               if err != nil {
-                       t.Fatalf("case %d: ListOrders(assetID5 and assetID2)  error %v.", i, err)
-               }
-
-               gotOrders = append(gotOrders, tmp...)
-
-               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID6, ToAssetID: assetID2, Rate: 0})
-               if err != nil {
-                       t.Fatalf("case %d: ListOrders(assetID6 and assetID2)  error %v.", i, err)
-               }
-
-               gotOrders = append(gotOrders, tmp...)
-
-               if !testutil.DeepEqual(gotOrders, c.wantOrders) {
-                       t.Fatalf("case %d: got orders , gotOrders: %v, wantOrders: %v.", i, gotOrders, c.wantOrders)
-               }
-
-               gotTradePairs, err := movStore.ListTradePairsWithStart(nil, nil)
-               if err != nil {
-                       t.Fatalf("case %d: ListTradePairsWithStart error %v.", i, err)
-               }
-
-               if !testutil.DeepEqual(gotTradePairs, c.wantTradePairs) {
-                       t.Fatalf("case %d: got tradePairs, gotTradePairs: %v, wantTradePairs: %v.", i, gotTradePairs, c.wantTradePairs)
-               }
-
-               gotDBState, err := movStore.GetMovDatabaseState()
-               if err != nil {
-                       t.Fatalf("case %d: GetMovDatabaseState error %v.", i, err)
-               }
-
-               if !testutil.DeepEqual(gotDBState, c.wantDBState) {
-                       t.Fatalf("case %d: got tradePairs, gotDBState: %v, wantDBStatus: %v.", i, gotDBState, c.wantDBState)
-               }
-
-               testDB.Close()
-               os.RemoveAll("temp")
-       }
-}
-
-func TestListOrders(t *testing.T) {
-       cases := []struct {
-               desc        string
-               storeOrders []*common.Order
-               query       *common.Order
-               wantOrders  []*common.Order
-       }{
-               {
-                       desc:       "empty",
-                       query:      &common.Order{FromAssetID: assetID1, ToAssetID: assetID2},
-                       wantOrders: []*common.Order{},
-               },
-               {
-                       desc: "query from first",
-                       storeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       query: &common.Order{FromAssetID: assetID1, ToAssetID: assetID2},
-                       wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-               },
-               {
-                       desc: "query from middle",
-                       storeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                       },
-                       query: &common.Order{
-                               FromAssetID: assetID1,
-                               ToAssetID:   assetID2,
-                               Rate:        0.00098,
-                               Utxo: &common.MovUtxo{
-                                       SourceID:       &bc.Hash{V0: 13},
-                                       Amount:         1,
-                                       SourcePos:      0,
-                                       ControlProgram: []byte("aa"),
-                               },
+                               mockOrders[11],
+                               mockOrders[12],
+                               mockOrders[13],
+                               mockOrders[14],
                        },
-                       wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                       wantTradePairs: []*common.TradePair{
+                               &common.TradePair{FromAssetID: assetID4, ToAssetID: assetID2, Count: 2},
+                               &common.TradePair{FromAssetID: assetID5, ToAssetID: assetID2, Count: 1},
+                               &common.TradePair{FromAssetID: assetID6, ToAssetID: assetID2, Count: 1},
                        },
+                       wantDBState: &common.MovDatabaseState{Height: 2, Hash: &bc.Hash{V0: 3724755213446347384, V1: 158878632373345042, V2: 18283800951484248781, V3: 7520797730449067221}},
                },
        }
 
@@ -1963,410 +786,245 @@ func TestListOrders(t *testing.T) {
                Version: 1,
        }
 
-       height := initBlockHeader.Height
-       hash := initBlockHeader.Hash()
+       height := initBlockHeader.Height
+       hash := initBlockHeader.Hash()
+
+       defer os.RemoveAll("temp")
+       for i, c := range cases {
+               testDB := dbm.NewDB("testdb", "leveldb", "temp")
+               movStore := NewLevelDBMovStore(testDB)
+               if err := movStore.InitDBState(height, &hash); err != nil {
+                       t.Fatalf("case %d: InitDBState error %v.", i, err)
+               }
+
+               batch := movStore.db.NewBatch()
+               tradePairsCnt := make(map[string]*common.TradePair)
+               movStore.addOrders(batch, c.beforeOrders, tradePairsCnt)
+               if len(c.beforeOrders) > 0 {
+                       tradePairsCnt = make(map[string]*common.TradePair)
+                       for _, tradePair := range c.beforeTradePairs {
+                               tradePairsCnt[tradePair.Key()] = tradePair
+                       }
+                       movStore.updateTradePairs(batch, tradePairsCnt)
+                       movStore.saveMovDatabaseState(batch, c.beforeDBStatus)
+               }
+               batch.Write()
+
+               if err := movStore.ProcessOrders(c.addOrders, c.delOrders, c.blockHeader); err != nil {
+                       t.Fatalf("case %d: ProcessOrders error %v.", i, err)
+               }
+
+               var gotOrders []*common.Order
+
+               tmp, err := movStore.ListOrders(&common.Order{FromAssetID: assetID1, ToAssetID: assetID2, Rate: 0})
+               if err != nil {
+                       t.Fatalf("case %d: ListOrders(assetID1 and assetID2) error %v.", i, err)
+               }
+
+               gotOrders = append(gotOrders, tmp...)
+
+               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID3, ToAssetID: assetID2, Rate: 0})
+               if err != nil {
+                       t.Fatalf("case %d: ListOrders(assetID3 and assetID2)  error %v.", i, err)
+               }
+
+               gotOrders = append(gotOrders, tmp...)
+
+               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID4, ToAssetID: assetID2, Rate: 0})
+               if err != nil {
+                       t.Fatalf("case %d: ListOrders(assetID4 and assetID2)  error %v.", i, err)
+               }
+
+               gotOrders = append(gotOrders, tmp...)
 
-       defer os.RemoveAll("temp")
-       for i, c := range cases {
-               testDB := dbm.NewDB("testdb", "leveldb", "temp")
-               movStore := NewLevelDBMovStore(testDB)
-               if err := movStore.InitDBState(height, &hash); err != nil {
-                       t.Fatalf("case %d: InitDBState error %v.", i, err)
+               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID5, ToAssetID: assetID2, Rate: 0})
+               if err != nil {
+                       t.Fatalf("case %d: ListOrders(assetID5 and assetID2)  error %v.", i, err)
                }
 
-               batch := movStore.db.NewBatch()
-               tradePairsCnt := make(map[string]*common.TradePair)
-               movStore.addOrders(batch, c.storeOrders, tradePairsCnt)
-               movStore.updateTradePairs(batch, tradePairsCnt)
-               batch.Write()
+               gotOrders = append(gotOrders, tmp...)
 
-               gotOrders, err := movStore.ListOrders(c.query)
+               tmp, err = movStore.ListOrders(&common.Order{FromAssetID: assetID6, ToAssetID: assetID2, Rate: 0})
                if err != nil {
-                       t.Fatalf("case %d: ListOrders error %v.", i, err)
+                       t.Fatalf("case %d: ListOrders(assetID6 and assetID2)  error %v.", i, err)
                }
 
+               gotOrders = append(gotOrders, tmp...)
+
                if !testutil.DeepEqual(gotOrders, c.wantOrders) {
                        t.Fatalf("case %d: got orders , gotOrders: %v, wantOrders: %v.", i, gotOrders, c.wantOrders)
                }
 
+               gotTradePairs, err := movStore.ListTradePairsWithStart(nil, nil)
+               if err != nil {
+                       t.Fatalf("case %d: ListTradePairsWithStart error %v.", i, err)
+               }
+
+               if !testutil.DeepEqual(gotTradePairs, c.wantTradePairs) {
+                       t.Fatalf("case %d: got tradePairs, gotTradePairs: %v, wantTradePairs: %v.", i, gotTradePairs, c.wantTradePairs)
+               }
+
+               gotDBState, err := movStore.GetMovDatabaseState()
+               if err != nil {
+                       t.Fatalf("case %d: GetMovDatabaseState error %v.", i, err)
+               }
+
+               if !testutil.DeepEqual(gotDBState, c.wantDBState) {
+                       t.Fatalf("case %d: got tradePairs, gotDBState: %v, wantDBStatus: %v.", i, gotDBState, c.wantDBState)
+               }
+
                testDB.Close()
                os.RemoveAll("temp")
        }
 }
 
-func TestAddOrders(t *testing.T) {
+func TestListOrders(t *testing.T) {
        cases := []struct {
-               desc         string
-               beforeOrders []*common.Order
-               addOrders    []*common.Order
-               wantOrders   []*common.Order
+               desc        string
+               storeOrders []*common.Order
+               query       *common.Order
+               wantOrders  []*common.Order
        }{
                {
-                       desc: "empty",
-                       addOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                       desc:       "empty",
+                       query:      &common.Order{FromAssetID: assetID1, ToAssetID: assetID2},
+                       wantOrders: []*common.Order{},
+               },
+               {
+                       desc: "query from first",
+                       storeOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                               mockOrders[10],
                        },
+                       query: &common.Order{FromAssetID: assetID1, ToAssetID: assetID2},
                        wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[1],
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[0],
+                       },
+               },
+               {
+                       desc: "query from middle",
+                       storeOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       query: mockOrders[3],
+                       wantOrders: []*common.Order{
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[0],
+                       },
+               },
+       }
+
+       initBlockHeader := &types.BlockHeader{
+               Height:  0,
+               Version: 1,
+       }
+
+       height := initBlockHeader.Height
+       hash := initBlockHeader.Hash()
+
+       defer os.RemoveAll("temp")
+       for i, c := range cases {
+               testDB := dbm.NewDB("testdb", "leveldb", "temp")
+               movStore := NewLevelDBMovStore(testDB)
+               if err := movStore.InitDBState(height, &hash); err != nil {
+                       t.Fatalf("case %d: InitDBState error %v.", i, err)
+               }
+
+               batch := movStore.db.NewBatch()
+               tradePairsCnt := make(map[string]*common.TradePair)
+               movStore.addOrders(batch, c.storeOrders, tradePairsCnt)
+               movStore.updateTradePairs(batch, tradePairsCnt)
+               batch.Write()
+
+               gotOrders, err := movStore.ListOrders(c.query)
+               if err != nil {
+                       t.Fatalf("case %d: ListOrders error %v.", i, err)
+               }
+
+               if !testutil.DeepEqual(gotOrders, c.wantOrders) {
+                       t.Fatalf("case %d: got orders , gotOrders: %v, wantOrders: %v.", i, gotOrders, c.wantOrders)
+               }
+
+               testDB.Close()
+               os.RemoveAll("temp")
+       }
+}
+
+func TestAddOrders(t *testing.T) {
+       cases := []struct {
+               desc         string
+               beforeOrders []*common.Order
+               addOrders    []*common.Order
+               wantOrders   []*common.Order
+       }{
+               {
+                       desc: "empty",
+                       addOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
+                       },
+                       wantOrders: []*common.Order{
+                               mockOrders[1],
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[0],
                        },
                },
                {
                        desc: "Stored data already exists",
                        beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[0],
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
                        },
                        addOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
                        },
                        wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[1],
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[0],
                        },
                },
        }
@@ -2408,42 +1066,22 @@ func TestAddOrders(t *testing.T) {
 
                testDB.Close()
                os.RemoveAll("temp")
-       }
-}
-
-func TestDelOrders(t *testing.T) {
-       cases := []struct {
-               desc         string
-               beforeOrders []*common.Order
-               delOrders    []*common.Order
-               wantOrders   []*common.Order
-               err          error
-       }{
-               {
-                       desc: "empty",
-                       delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+       }
+}
+
+func TestDelOrders(t *testing.T) {
+       cases := []struct {
+               desc         string
+               beforeOrders []*common.Order
+               delOrders    []*common.Order
+               wantOrders   []*common.Order
+               err          error
+       }{
+               {
+                       desc: "empty",
+                       delOrders: []*common.Order{
+                               mockOrders[0],
+                               mockOrders[1],
                        },
                        wantOrders: []*common.Order{},
                        err:        errors.New("don't find trade pair"),
@@ -2451,260 +1089,40 @@ func TestDelOrders(t *testing.T) {
                {
                        desc: "Delete existing data",
                        beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[1],
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[0],
                        },
                        delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         10,
-                                               SourcePos:      1,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[4],
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
                        },
                        wantOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 22},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00097,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 23},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00098,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 13},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        1.00090,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 21},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[1],
+                               mockOrders[2],
+                               mockOrders[3],
+                               mockOrders[0],
                        },
                        err: nil,
                },
                {
                        desc: "Delete all data",
                        beforeOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[7],
+                               mockOrders[6],
+                               mockOrders[5],
                        },
                        delOrders: []*common.Order{
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00099,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 24},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00096,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 25},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
-                               &common.Order{
-                                       FromAssetID: assetID1,
-                                       ToAssetID:   assetID2,
-                                       Rate:        0.00095,
-                                       Utxo: &common.MovUtxo{
-                                               SourceID:       &bc.Hash{V0: 26},
-                                               Amount:         1,
-                                               SourcePos:      0,
-                                               ControlProgram: []byte("aa"),
-                                       },
-                               },
+                               mockOrders[5],
+                               mockOrders[6],
+                               mockOrders[7],
                        },
                        wantOrders: []*common.Order{},
                        err:        nil,
Golang implemented sidechain for Bytom
About OSDN
Find Software
Develop Software
Help