Mov (#518)

[bytom/vapor.git] / application / mov / mock / mock_mov_store.go

diff --git a/application/mov/mock/mock_mov_store.go b/application/mov/mock/mock_mov_store.go
new file mode 100644 (file)
index 0000000..34a1bd0
--- /dev/null
+++ b/application/mov/mock/mock_mov_store.go
@@ -0,0 +1,108 @@
+package mock
+
+import (
+       "sort"
+
+       "github.com/bytom/vapor/application/mov/common"
+       "github.com/bytom/vapor/errors"
+       "github.com/bytom/vapor/protocol/bc"
+       "github.com/bytom/vapor/protocol/bc/types"
+)
+
+type MovStore struct {
+       tradePairs []*common.TradePair
+       orderMap   map[string][]*common.Order
+       dbState    *common.MovDatabaseState
+}
+
+func NewMovStore(tradePairs []*common.TradePair, orders []*common.Order) *MovStore {
+       orderMap := make(map[string][]*common.Order)
+       for _, order := range orders {
+               orderMap[order.TradePair().Key()] = append(orderMap[order.TradePair().Key()], order)
+       }
+
+       for _, orders := range orderMap {
+               sort.Sort(common.OrderSlice(orders))
+       }
+       return &MovStore{
+               tradePairs: tradePairs,
+               orderMap:   orderMap,
+       }
+}
+
+func (m *MovStore) GetMovDatabaseState() (*common.MovDatabaseState, error) {
+       return m.dbState, nil
+}
+
+func (m *MovStore) InitDBState(height uint64, hash *bc.Hash) error {
+       return nil
+}
+
+func (m *MovStore) ListOrders(orderAfter *common.Order) ([]*common.Order, error) {
+       tradePair := &common.TradePair{FromAssetID: orderAfter.FromAssetID, ToAssetID: orderAfter.ToAssetID}
+       orders := m.orderMap[tradePair.Key()]
+       begin := len(orders)
+       if orderAfter.Rate() == 0 {
+               begin = 0
+       } else {
+               for i, order := range orders {
+                       if order.Rate() == orderAfter.Rate() {
+                               begin = i + 1
+                               break
+                       }
+               }
+       }
+       var result []*common.Order
+       for i := begin; i < len(orders) && len(result) < 3; i++ {
+               result = append(result, orders[i])
+       }
+       return result, nil
+}
+
+func (m *MovStore) ListTradePairsWithStart(fromAssetIDAfter, toAssetIDAfter *bc.AssetID) ([]*common.TradePair, error) {
+       begin := len(m.tradePairs)
+       if fromAssetIDAfter == nil || toAssetIDAfter == nil {
+               begin = 0
+       } else {
+               for i, tradePair := range m.tradePairs {
+                       if *tradePair.FromAssetID == *fromAssetIDAfter && *tradePair.ToAssetID == *toAssetIDAfter {
+                               begin = i + 1
+                               break
+                       }
+               }
+       }
+       var result []*common.TradePair
+       for i := begin; i < len(m.tradePairs) && len(result) < 3; i++ {
+               result = append(result, m.tradePairs[i])
+       }
+       return result, nil
+}
+
+func (m *MovStore) ProcessOrders(addOrders []*common.Order, delOrders []*common.Order, blockHeader *types.BlockHeader) error {
+       for _, order := range addOrders {
+               tradePair := &common.TradePair{FromAssetID: order.FromAssetID, ToAssetID: order.ToAssetID}
+               m.orderMap[tradePair.Key()] = append(m.orderMap[tradePair.Key()], order)
+       }
+       for _, delOrder := range delOrders {
+               tradePair := &common.TradePair{FromAssetID: delOrder.FromAssetID, ToAssetID: delOrder.ToAssetID}
+               orders := m.orderMap[tradePair.Key()]
+               for i, order := range orders {
+                       if delOrder.Key() == order.Key() {
+                               m.orderMap[tradePair.Key()] = append(orders[0:i], orders[i+1:]...)
+                       }
+               }
+       }
+       for _, orders := range m.orderMap {
+               sort.Sort(common.OrderSlice(orders))
+       }
+
+       if blockHeader.Height == m.dbState.Height {
+               m.dbState = &common.MovDatabaseState{Height: blockHeader.Height - 1, Hash: &blockHeader.PreviousBlockHash}
+       } else if blockHeader.Height == m.dbState.Height+1 {
+               blockHash := blockHeader.Hash()
+               m.dbState = &common.MovDatabaseState{Height: blockHeader.Height, Hash: &blockHash}
+       } else {
+               return errors.New("error block header")
+       }
+       return nil
+}