application/mov/mock/mock_mov_store.go

   1 package mock
   2
   3 import (
   4         "sort"
   5
   6         "github.com/vapor/application/mov/common"
   7         "github.com/vapor/errors"
   8         "github.com/vapor/protocol/bc"
   9         "github.com/vapor/protocol/bc/types"
  10 )
  11
  12 type MovStore struct {
  13         tradePairs []*common.TradePair
  14         orderMap   map[string][]*common.Order
  15         dbState    *common.MovDatabaseState
  16 }
  17
  18 func NewMovStore(tradePairs []*common.TradePair, orders []*common.Order) *MovStore {
  19         orderMap := make(map[string][]*common.Order)
  20         for _, order := range orders {
  21                 orderMap[order.TradePair().Key()] = append(orderMap[order.TradePair().Key()], order)
  22         }
  23
  24         for _, orders := range orderMap {
  25                 sort.Sort(common.OrderSlice(orders))
  26         }
  27         return &MovStore{
  28                 tradePairs: tradePairs,
  29                 orderMap:   orderMap,
  30         }
  31 }
  32
  33 func (m *MovStore) GetMovDatabaseState() (*common.MovDatabaseState, error) {
  34         return m.dbState, nil
  35 }
  36
  37 func (m *MovStore) InitDBState(height uint64, hash *bc.Hash) error {
  38         return nil
  39 }
  40
  41 func (m *MovStore) ListOrders(orderAfter *common.Order) ([]*common.Order, error) {
  42         tradePair := &common.TradePair{FromAssetID: orderAfter.FromAssetID, ToAssetID: orderAfter.ToAssetID}
  43         orders := m.orderMap[tradePair.Key()]
  44         begin := len(orders)
  45         if orderAfter.Rate == 0 {
  46                 begin = 0
  47         } else {
  48                 for i, order := range orders {
  49                         if order.Rate == orderAfter.Rate {
  50                                 begin = i + 1
  51                                 break
  52                         }
  53                 }
  54         }
  55         var result []*common.Order
  56         for i := begin; i < len(orders) && len(result) < 3; i++ {
  57                 result = append(result, orders[i])
  58         }
  59         return result, nil
  60 }
  61
  62 func (m *MovStore) ListTradePairsWithStart(fromAssetIDAfter, toAssetIDAfter *bc.AssetID) ([]*common.TradePair, error) {
  63         begin := len(m.tradePairs)
  64         if fromAssetIDAfter == nil || toAssetIDAfter == nil {
  65                 begin = 0
  66         } else {
  67                 for i, tradePair := range m.tradePairs {
  68                         if *tradePair.FromAssetID == *fromAssetIDAfter && *tradePair.ToAssetID == *toAssetIDAfter {
  69                                 begin = i + 1
  70                                 break
  71                         }
  72                 }
  73         }
  74         var result []*common.TradePair
  75         for i := begin; i < len(m.tradePairs) && len(result) < 3; i++ {
  76                 result = append(result, m.tradePairs[i])
  77         }
  78         return result, nil
  79 }
  80
  81 func (m *MovStore) ProcessOrders(addOrders []*common.Order, delOrders []*common.Order, blockHeader *types.BlockHeader) error {
  82         for _, order := range addOrders {
  83                 tradePair := &common.TradePair{FromAssetID: order.FromAssetID, ToAssetID: order.ToAssetID}
  84                 m.orderMap[tradePair.Key()] = append(m.orderMap[tradePair.Key()], order)
  85         }
  86         for _, delOrder := range delOrders {
  87                 tradePair := &common.TradePair{FromAssetID: delOrder.FromAssetID, ToAssetID: delOrder.ToAssetID}
  88                 orders := m.orderMap[tradePair.Key()]
  89                 for i, order := range orders {
  90                         if delOrder.Key() == order.Key() {
  91                                 m.orderMap[tradePair.Key()] = append(orders[0:i], orders[i+1:]...)
  92                         }
  93                 }
  94         }
  95         for _, orders := range m.orderMap {
  96                 sort.Sort(common.OrderSlice(orders))
  97         }
  98
  99         if blockHeader.Height == m.dbState.Height {
 100                 m.dbState = &common.MovDatabaseState{Height: blockHeader.Height - 1, Hash: &blockHeader.PreviousBlockHash}
 101         } else if blockHeader.Height == m.dbState.Height+1 {
 102                 blockHash := blockHeader.Hash()
 103                 m.dbState = &common.MovDatabaseState{Height: blockHeader.Height, Hash: &blockHash}
 104         } else {
 105                 return errors.New("error block header")
 106         }
 107         return nil
 108 }