forked from adshao/go-binance
/
exchange_info_service.go
203 lines (186 loc) · 6.03 KB
/
exchange_info_service.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
package delivery
import (
"context"
"encoding/json"
"net/http"
)
// ExchangeInfoService exchange info service
type ExchangeInfoService struct {
c *Client
}
// Do send request
func (s *ExchangeInfoService) Do(ctx context.Context, opts ...RequestOption) (res *ExchangeInfo, err error) {
r := &request{
method: http.MethodGet,
endpoint: "/dapi/v1/exchangeInfo",
secType: secTypeNone,
}
data, err := s.c.callAPI(ctx, r, opts...)
if err != nil {
return nil, err
}
res = new(ExchangeInfo)
err = json.Unmarshal(data, res)
if err != nil {
return nil, err
}
return res, nil
}
// ExchangeInfo exchange info
type ExchangeInfo struct {
Timezone string `json:"timezone"`
ServerTime int64 `json:"serverTime"`
RateLimits []RateLimit `json:"rateLimits"`
ExchangeFilters []interface{} `json:"exchangeFilters"`
Symbols []Symbol `json:"symbols"`
}
// RateLimit struct
type RateLimit struct {
RateLimitType string `json:"rateLimitType"`
Interval string `json:"interval"`
IntervalNum int64 `json:"intervalNum"`
Limit int64 `json:"limit"`
}
// Symbol market symbol
type Symbol struct {
OrderType []OrderType `json:"OrderType"`
TimeInForce []TimeInForceType `json:"timeInForce"`
Filters []map[string]interface{} `json:"filters"`
Symbol string `json:"symbol"`
Pair string `json:"pair"`
ContractType string `json:"contractType"`
DeliveryDate int64 `json:"deliveryDate"`
OnboardDate int64 `json:"onboardDate"`
ContractStatus string `json:"contractStatus"`
ContractSize int `json:"contractSize"`
PricePrecision int `json:"pricePrecision"`
QuantityPrecision int `json:"quantityPrecision"`
MaintMarginPercent string `json:"maintMarginPercent"`
RequiredMarginPercent string `json:"requiredMarginPercent"`
QuoteAsset string `json:"quoteAsset"`
BaseAsset string `json:"baseAsset"`
MarginAsset string `json:"marginAsset"`
BaseAssetPrecision int `json:"baseAssetPrecision"`
QuotePrecision int `json:"quotePrecision"`
EqualQtyPrecision int `json:"equalQtyPrecision"`
TriggerProtect string `json:"triggerProtect"`
UnderlyingType string `json:"underlyingType"`
UnderlyingSubType []interface{} `json:"underlyingSubType"`
}
// LotSizeFilter define lot size filter of symbol
type LotSizeFilter struct {
MaxQuantity string `json:"maxQty"`
MinQuantity string `json:"minQty"`
StepSize string `json:"stepSize"`
}
// PriceFilter define price filter of symbol
type PriceFilter struct {
MaxPrice string `json:"maxPrice"`
MinPrice string `json:"minPrice"`
TickSize string `json:"tickSize"`
}
// PercentPriceFilter define percent price filter of symbol
type PercentPriceFilter struct {
MultiplierDecimal int `json:"multiplierDecimal"`
MultiplierUp string `json:"multiplierUp"`
MultiplierDown string `json:"multiplierDown"`
}
// MarketLotSizeFilter define market lot size filter of symbol
type MarketLotSizeFilter struct {
MaxQuantity string `json:"maxQty"`
MinQuantity string `json:"minQty"`
StepSize string `json:"stepSize"`
}
// MaxNumOrdersFilter define max num orders filter of symbol
type MaxNumOrdersFilter struct {
Limit int64 `json:"limit"`
}
// LotSizeFilter return lot size filter of symbol
func (s *Symbol) LotSizeFilter() *LotSizeFilter {
for _, filter := range s.Filters {
if filter["filterType"].(string) == string(SymbolFilterTypeLotSize) {
f := &LotSizeFilter{}
if i, ok := filter["maxQty"]; ok {
f.MaxQuantity = i.(string)
}
if i, ok := filter["minQty"]; ok {
f.MinQuantity = i.(string)
}
if i, ok := filter["stepSize"]; ok {
f.StepSize = i.(string)
}
return f
}
}
return nil
}
// PriceFilter return price filter of symbol
func (s *Symbol) PriceFilter() *PriceFilter {
for _, filter := range s.Filters {
if filter["filterType"].(string) == string(SymbolFilterTypePrice) {
f := &PriceFilter{}
if i, ok := filter["maxPrice"]; ok {
f.MaxPrice = i.(string)
}
if i, ok := filter["minPrice"]; ok {
f.MinPrice = i.(string)
}
if i, ok := filter["tickSize"]; ok {
f.TickSize = i.(string)
}
return f
}
}
return nil
}
// PercentPriceFilter return percent price filter of symbol
func (s *Symbol) PercentPriceFilter() *PercentPriceFilter {
for _, filter := range s.Filters {
if filter["filterType"].(string) == string(SymbolFilterTypePercentPrice) {
f := &PercentPriceFilter{}
if i, ok := filter["multiplierDecimal"]; ok {
f.MultiplierDecimal = int(i.(float64))
}
if i, ok := filter["multiplierUp"]; ok {
f.MultiplierUp = i.(string)
}
if i, ok := filter["multiplierDown"]; ok {
f.MultiplierDown = i.(string)
}
return f
}
}
return nil
}
// MarketLotSizeFilter return market lot size filter of symbol
func (s *Symbol) MarketLotSizeFilter() *MarketLotSizeFilter {
for _, filter := range s.Filters {
if filter["filterType"].(string) == string(SymbolFilterTypeMarketLotSize) {
f := &MarketLotSizeFilter{}
if i, ok := filter["maxQty"]; ok {
f.MaxQuantity = i.(string)
}
if i, ok := filter["minQty"]; ok {
f.MinQuantity = i.(string)
}
if i, ok := filter["stepSize"]; ok {
f.StepSize = i.(string)
}
return f
}
}
return nil
}
// MaxNumOrdersFilter return max num orders filter of symbol
func (s *Symbol) MaxNumOrdersFilter() *MaxNumOrdersFilter {
for _, filter := range s.Filters {
if filter["filterType"].(string) == string(SymbolFilterTypeMaxNumOrders) {
f := &MaxNumOrdersFilter{}
if i, ok := filter["limit"]; ok {
f.Limit = int64(i.(float64))
}
return f
}
}
return nil
}