-
Notifications
You must be signed in to change notification settings - Fork 7
/
querier.go
265 lines (230 loc) · 7.79 KB
/
querier.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
package keepers
import (
"fmt"
"math"
"strconv"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/coinexchain/cet-sdk/modules/market/internal/types"
)
const (
QueryMarket = "market-info"
QueryMarkets = "market-list"
QueryOrdersInMarket = "orders-in-market"
QueryOrder = "order-info"
QueryUserOrders = "user-order-list"
QueryWaitCancelMarkets = "wait-cancel-markets"
QueryParameters = "parameters"
)
// creates a querier for asset REST endpoints
func NewQuerier(mk Keeper) sdk.Querier {
return func(ctx sdk.Context, path []string, req abci.RequestQuery) (res []byte, err sdk.Error) {
switch path[0] {
case QueryParameters:
return queryParameters(ctx, mk)
case QueryMarket:
return queryMarket(ctx, req, mk)
case QueryMarkets:
return queryMarketList(ctx, req, mk)
case QueryOrdersInMarket:
return queryOrdersInMarket(ctx, req, mk)
case QueryOrder:
return queryOrder(ctx, req, mk)
case QueryUserOrders:
return queryUserOrderList(ctx, req, mk)
case QueryWaitCancelMarkets:
return queryWaitCancelMarkets(ctx, req, mk)
default:
return nil, sdk.ErrUnknownRequest("query symbol : " + path[0])
}
}
}
func queryParameters(ctx sdk.Context, k Keeper) ([]byte, sdk.Error) {
params := k.GetParams(ctx)
res, err := codec.MarshalJSONIndent(types.ModuleCdc, params)
if err != nil {
return nil, sdk.ErrInternal(sdk.AppendMsgToErr("could not marshal result to JSON", err.Error()))
}
return res, nil
}
type QueryMarketParam struct {
TradingPair string
}
func NewQueryMarketParam(symbol string) QueryMarketParam {
return QueryMarketParam{
TradingPair: symbol,
}
}
type QueryMarketInfo struct {
Creator sdk.AccAddress `json:"creator"`
Stock string `json:"stock"`
Money string `json:"money"`
PricePrecision string `json:"price_precision"`
LastExecutedPrice sdk.Dec `json:"last_executed_price"`
OrderPrecision string `json:"order_precision"`
}
func queryMarket(ctx sdk.Context, req abci.RequestQuery, mk Keeper) ([]byte, sdk.Error) {
var param QueryMarketParam
if err := mk.cdc.UnmarshalJSON(req.Data, ¶m); err != nil {
return nil, sdk.ErrInternal(fmt.Sprintf("failed to parse param: %s", err))
}
info, err := mk.GetMarketInfo(ctx, param.TradingPair)
if err != nil {
return nil, types.ErrInvalidMarket("Maybe the market have been deleted or not exist")
}
queryInfo := QueryMarketInfo{
Creator: mk.MarketOwner(ctx, info),
Stock: info.Stock,
Money: info.Money,
PricePrecision: strconv.Itoa(int(info.PricePrecision)),
LastExecutedPrice: info.LastExecutedPrice,
OrderPrecision: strconv.Itoa(int(info.OrderPrecision)),
}
bz, err := codec.MarshalJSONIndent(mk.cdc, queryInfo)
if err != nil {
return nil, types.ErrFailedMarshal()
}
return bz, nil
}
type MarketInfoList []QueryMarketInfo
func queryMarketList(ctx sdk.Context, req abci.RequestQuery, mk Keeper) ([]byte, sdk.Error) {
infos := mk.GetAllMarketInfos(ctx)
mInfoList := make([]QueryMarketInfo, len(infos))
for i, info := range infos {
mInfoList[i] = QueryMarketInfo{
Creator: mk.MarketOwner(ctx, info),
Stock: info.Stock,
Money: info.Money,
PricePrecision: strconv.Itoa(int(info.PricePrecision)),
LastExecutedPrice: info.LastExecutedPrice,
OrderPrecision: strconv.Itoa(int(info.OrderPrecision)),
}
}
bz, err := codec.MarshalJSONIndent(mk.cdc, mInfoList)
if err != nil {
return nil, types.ErrFailedMarshal()
}
return bz, nil
}
type ResOrder struct {
OrderID string `json:"order_id"`
Sender sdk.AccAddress `json:"sender"`
Sequence uint64 `json:"sequence"`
Identify byte `json:"identify"`
TradingPair string `json:"trading_pair"`
OrderType byte `json:"order_type"`
Price sdk.Dec `json:"price"`
Quantity int64 `json:"quantity"`
Side byte `json:"side"`
TimeInForce int64 `json:"time_in_force"`
Height int64 `json:"height"`
FrozenCommission int64 `json:"frozen_commission"` // DEX2
ExistBlocks int64 `json:"exist_blocks"`
FrozenFeatureFee int64 `json:"frozen_feature_fee"` // DEX2
FrozenFee int64 `json:"frozen_fee,omitempty"` // DEX2: -> frozen_commission
// These fields will change when order was filled/canceled.
LeftStock int64 `json:"left_stock"`
Freeze int64 `json:"freeze"`
DealStock int64 `json:"deal_stock"`
DealMoney int64 `json:"deal_money"`
}
func convertResOrderFromOrder(order *types.Order) *ResOrder {
return &ResOrder{
OrderID: order.OrderID(),
Sender: order.Sender,
Sequence: order.Sequence,
Identify: order.Identify,
TradingPair: order.TradingPair,
OrderType: order.OrderType,
Price: order.Price,
Quantity: order.Quantity,
Side: order.Side,
TimeInForce: order.TimeInForce,
Height: order.Height,
FrozenCommission: order.FrozenCommission,
ExistBlocks: order.ExistBlocks,
FrozenFeatureFee: order.FrozenFeatureFee,
FrozenFee: order.FrozenFee,
LeftStock: order.LeftStock,
Freeze: order.Freeze,
DealStock: order.DealStock,
DealMoney: order.DealMoney,
}
}
func queryOrdersInMarket(ctx sdk.Context, req abci.RequestQuery, mk Keeper) ([]byte, sdk.Error) {
var param QueryMarketParam
if err := mk.cdc.UnmarshalJSON(req.Data, ¶m); err != nil {
return nil, sdk.ErrInternal(fmt.Sprintf("failed to parse param: %s", err))
}
k := NewOrderKeeper(mk.marketKey, param.TradingPair, mk.cdc)
orders := k.GetOlderThan(ctx, math.MaxInt64)
rs := make([]*ResOrder, len(orders))
for i, or := range orders {
rs[i] = convertResOrderFromOrder(or)
}
bz, err := codec.MarshalJSONIndent(mk.cdc, rs)
if err != nil {
return nil, types.ErrFailedMarshal()
}
return bz, nil
}
type QueryOrderParam struct {
OrderID string
}
func NewQueryOrderParam(orderID string) QueryOrderParam {
return QueryOrderParam{
OrderID: orderID,
}
}
func queryOrder(ctx sdk.Context, req abci.RequestQuery, mk Keeper) ([]byte, sdk.Error) {
var param QueryOrderParam
if err := mk.cdc.UnmarshalJSON(req.Data, ¶m); err != nil {
return nil, types.ErrFailedParseParam()
}
okp := NewGlobalOrderKeeper(mk.marketKey, mk.cdc)
order := okp.QueryOrder(ctx, param.OrderID)
if order == nil {
return nil, types.ErrOrderNotFound(param.OrderID)
}
bz, err := codec.MarshalJSONIndent(mk.cdc, *order)
if err != nil {
return nil, types.ErrFailedMarshal()
}
return bz, nil
}
type QueryUserOrderList struct {
User string
}
func queryUserOrderList(ctx sdk.Context, req abci.RequestQuery, mk Keeper) ([]byte, sdk.Error) {
var param QueryUserOrderList
if err := mk.cdc.UnmarshalJSON(req.Data, ¶m); err != nil {
return nil, types.ErrFailedParseParam()
}
okp := NewGlobalOrderKeeper(mk.marketKey, mk.cdc)
orders := okp.GetOrdersFromUser(ctx, param.User)
if len(orders) == 0 {
orders = append(orders, "")
}
bz, err := codec.MarshalJSONIndent(mk.cdc, orders)
if err != nil {
return nil, types.ErrFailedMarshal()
}
return bz, nil
}
type QueryCancelMarkets struct {
Time int64
}
func queryWaitCancelMarkets(ctx sdk.Context, req abci.RequestQuery, mk Keeper) ([]byte, sdk.Error) {
var param QueryCancelMarkets
if err := mk.cdc.UnmarshalJSON(req.Data, ¶m); err != nil {
return nil, types.ErrFailedParseParam()
}
dlk := NewDelistKeeper(mk.marketKey)
markets := dlk.GetDelistSymbolsBeforeTime(ctx, param.Time)
bz, err := codec.MarshalJSONIndent(mk.cdc, markets)
if err != nil {
return nil, types.ErrFailedMarshal()
}
return bz, nil
}