├── .gitignore
├── .vscode
    └── launch.json
├── LICENSE
├── README.md
├── auth
    └── auth.go
├── go.mod
├── go.sum
├── realtime
    ├── websocket.go
    └── websocket_test.go
├── rest
    ├── client.go
    ├── errors.go
    ├── interface.go
    ├── private
    │   ├── account
    │   │   ├── information.go
    │   │   ├── leverage.go
    │   │   └── positions.go
    │   ├── convert
    │   │   ├── accept-quote.go
    │   │   ├── get-quote-status.go
    │   │   ├── request-quote.go
    │   │   └── request-quote_test.go
    │   ├── fills
    │   │   └── fills.go
    │   ├── funding
    │   │   └── funding.go
    │   ├── leveraged
    │   │   ├── balances.go
    │   │   ├── created.go
    │   │   ├── list-created-tokens.go
    │   │   ├── list-redemption-tokens.go
    │   │   ├── list.go
    │   │   ├── redemption.go
    │   │   └── token.go
    │   ├── options
    │   │   ├── accept-quote.go
    │   │   ├── cancel-quote.go
    │   │   ├── cancel-request.go
    │   │   ├── common.go
    │   │   ├── create-request.go
    │   │   ├── fills.go
    │   │   ├── modify-quote-request.go
    │   │   ├── my-quote-request.go
    │   │   ├── my-quote-requests.go
    │   │   ├── my-quotes.go
    │   │   ├── positons.go
    │   │   ├── requests.go
    │   │   └── trades.go
    │   ├── orders
    │   │   ├── cancel-all.go
    │   │   ├── cancel.go
    │   │   ├── get-open-order-histories.go
    │   │   ├── get-open-order.go
    │   │   ├── get-open-trigger-order.go
    │   │   ├── get-open-trigger-orders.go
    │   │   ├── get-order-trigger-histories.go
    │   │   ├── modify-order.go
    │   │   ├── modify-trigger-order.go
    │   │   ├── order-status.go
    │   │   ├── place-order.go
    │   │   └── place-trigger-order.go
    │   ├── spotmargin
    │   │   ├── get-borrow-history.go
    │   │   ├── get-borrow-rates.go
    │   │   ├── get-lending-history.go
    │   │   ├── get-lending-info.go
    │   │   ├── get-lending-rates.go
    │   │   └── submit-lending-offer.go
    │   ├── subaccount
    │   │   ├── all.go
    │   │   ├── balance.go
    │   │   ├── change.go
    │   │   ├── create.go
    │   │   ├── delete.go
    │   │   └── transfer.go
    │   └── wallet
    │   │   ├── balances-all.go
    │   │   ├── balances.go
    │   │   ├── coins.go
    │   │   ├── deposit-address.go
    │   │   ├── deposit-histories.go
    │   │   ├── withdraw-histories.go
    │   │   └── withdraw.go
    ├── public
    │   ├── futures
    │   │   ├── future.go
    │   │   ├── list.go
    │   │   ├── rates.go
    │   │   └── stats.go
    │   └── markets
    │   │   ├── candles.go
    │   │   ├── market.go
    │   │   ├── orderbook.go
    │   │   └── trades.go
    ├── request-lev-options.go
    ├── request-lev-options_test.go
    ├── request-private.go
    ├── request-private_test.go
    ├── request-public.go
    ├── request-public_test.go
    └── request.go
└── types
    └── models.go


/.gitignore:
--------------------------------------------------------------------------------
1 | *.DS_Store
2 | *.vscode
3 | .env
4 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // IntelliSense を使用して利用可能な属性を学べます。
 3 |     // 既存の属性の説明をホバーして表示します。
 4 |     // 詳細情報は次を確認してください: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         {
 8 |             "name": "Launch",
 9 |             "type": "go",
10 |             "request": "launch",
11 |             "mode": "auto",
12 |             "program": "${fileDirname}",
13 |             "env": {
14 |             },
15 |             "args": []
16 |         }
17 |     ]
18 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 _numbP
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # go-ftx
  2 | 
  3 | FTX exchange API version2, renew at 2020/04.
  4 | 
  5 | ## Description
  6 | 
  7 | go-ftx is a go client library for [FTX API Document](https://docs.ftx.com).
  8 | 
  9 | **Supported**
 10 | - [x] Public & Private
 11 | - [x] Orders
 12 | - [x] Leveraged tokens
 13 | - [x] Options
 14 | - [x] Websocket
 15 | - [x] SubAccounts 
 16 | 
 17 | **Not Supported**
 18 | - [ ] FIX API
 19 | 
 20 | ## Installation
 21 | 
 22 | ```
 23 | $ go get -u github.com/go-numb/go-ftx
 24 | ```
 25 | 
 26 | ## Usage
 27 | ``` golang
 28 | package main
 29 | 
 30 | import (
 31 | 	"fmt"
 32 | 	"github.com/dustin/go-humanize"
 33 | 	"github.com/go-numb/go-ftx/auth"
 34 | 	"github.com/go-numb/go-ftx/rest"
 35 | 	"github.com/go-numb/go-ftx/rest/private/orders"
 36 | 	//"log"
 37 | 	"github.com/go-numb/go-ftx/rest/private/account"
 38 | 	"github.com/go-numb/go-ftx/rest/public/futures"
 39 | 	"github.com/go-numb/go-ftx/rest/public/markets"
 40 | 	"github.com/go-numb/go-ftx/types"
 41 | 	"github.com/labstack/gommon/log"
 42 | 	"sort"
 43 | 	"strings"
 44 | )
 45 | 
 46 | func main() {
 47 | 	// Only main account
 48 | 	client := rest.New(auth.New("<key>", "<secret>"))
 49 | 
 50 | 	// or
 51 | 	// UseSubAccounts
 52 | 	clientWithSubAccounts := rest.New(
 53 | 		auth.New(
 54 | 			"<key>",
 55 | 			"<secret>",
 56 | 			auth.SubAccount{
 57 | 				UUID:     1,
 58 | 				Nickname: "subaccount_1",
 59 | 			},
 60 | 			auth.SubAccount{
 61 | 				UUID:     2,
 62 | 				Nickname: "subaccount_2",
 63 | 			},
 64 | 			// many....
 65 | 		))
 66 | 	// switch subaccount
 67 | 	clientWithSubAccounts.Auth.UseSubAccountID(1) // or 2... this number is key in map[int]SubAccount
 68 | 
 69 | 	// account informations
 70 | 	// client or clientWithSubAccounts in this time.
 71 | 	c := client // or clientWithSubAccounts
 72 | 	info, err := c.Information(&account.RequestForInformation{})
 73 | 	if err != nil {
 74 | 		log.Fatal(err)
 75 | 	}
 76 | 
 77 | 	fmt.Printf("%v\n", info)
 78 | 
 79 | 	// lev, err := c.Leverage(5)
 80 | 	lev, err := c.Leverage(&account.RequestForLeverage{
 81 | 		Leverage: 3,
 82 | 	})
 83 | 
 84 | 	if err != nil {
 85 | 		log.Fatal(err)
 86 | 	}
 87 | 
 88 | 	fmt.Printf("%v\n", lev)
 89 | 
 90 | 	market, err := c.Markets(&markets.RequestForMarkets{
 91 | 		ProductCode: "XRPBULL/USDT",
 92 | 	})
 93 | 
 94 | 	if err != nil {
 95 | 		log.Fatal(err)
 96 | 	}
 97 | 
 98 | 	// products List
 99 | 	fmt.Printf("%+v\n", strings.Join(market.List(), "\n"))
100 | 	// product ranking by USD
101 | 	fmt.Printf("%+v\n", strings.Join(market.Ranking(markets.ALL), "\n"))
102 | 
103 | 	// FundingRate
104 | 	rates, err := c.Rates(&futures.RequestForRates{})
105 | 	if err != nil {
106 | 		log.Fatal(err)
107 | 	}
108 | 	// Sort by FundingRate & Print
109 | 	// Custom sort
110 | 	sort.Sort(sort.Reverse(rates))
111 | 	for _, v := range *rates {
112 | 		fmt.Printf("%s			%s		%s\n", humanize.Commaf(v.Rate), v.Future, v.Time.String())
113 | 	}
114 | 
115 | 	order, err := c.PlaceOrder(&orders.RequestForPlaceOrder{
116 | 		Type:   types.LIMIT,
117 | 		Market: "BTC-PERP",
118 | 		Side:   types.BUY,
119 | 		Price:  6200,
120 | 		Size:   0.01,
121 | 		// Optionals
122 | 		ClientID:   "use_original_client_id",
123 | 		Ioc:        false,
124 | 		ReduceOnly: false,
125 | 		PostOnly:   false,
126 | 	})
127 | 	if err != nil {
128 | 		// client.Logger.Error(err) // Logger does not seem to exist @tuanito
129 | 	}
130 | 
131 | 	fmt.Printf("%+v\n", order)
132 | 
133 | 	ok, err := c.CancelByID(&orders.RequestForCancelByID{
134 | 		OrderID: 1,
135 | 		// either... , prioritize clientID
136 | 		ClientID:       "",
137 | 		TriggerOrderID: "",
138 | 	})
139 | 	if err != nil {
140 | 		log.Fatal(err)
141 | 	}
142 | 
143 | 	fmt.Println(ok)
144 | 	// ok is status comment
145 | 
146 | }
147 | 
148 | ```
149 | 
150 | 
151 | ## Websocket
152 | ``` golang 
153 | package main
154 | 
155 | import (
156 | 	"context"
157 | 	"fmt"
158 | 	"github.com/go-numb/go-ftx/realtime"
159 | 	"github.com/go-numb/go-ftx/auth"
160 | 
161 | 	"github.com/labstack/gommon/log"
162 | )
163 | 
164 | 
165 | func main() {
166 | 	ctx, cancel := context.WithCancel(context.Background())
167 | 	defer cancel()
168 | 
169 | 	ch := make(chan realtime.Response)
170 | 	go realtime.Connect(ctx, ch, []string{"ticker"}, []string{"BTC-PERP", "ETH-PERP"}, nil)
171 | 	go realtime.ConnectForPrivate(ctx, ch, "<key>", "<secret>", []string{"orders", "fills"}, nil)
172 | 
173 | 	for {
174 | 		select {
175 | 		case v := <-ch:
176 | 			switch v.Type {
177 | 			case realtime.TICKER:
178 | 				fmt.Printf("%s	%+v\n", v.Symbol, v.Ticker)
179 | 
180 | 			case realtime.TRADES:
181 | 				fmt.Printf("%s	%+v\n", v.Symbol, v.Trades)
182 | 				for i := range v.Trades {
183 | 					if v.Trades[i].Liquidation {
184 | 						fmt.Printf("-----------------------------%+v\n", v.Trades[i])
185 | 					}
186 | 				}
187 | 
188 | 			case realtime.ORDERBOOK:
189 | 				fmt.Printf("%s	%+v\n", v.Symbol, v.Orderbook)
190 | 
191 | 			case realtime.ORDERS:
192 | 				fmt.Printf("%d	%+v\n", v.Type, v.Orders)
193 | 
194 | 			case realtime.FILLS:
195 | 				fmt.Printf("%d	%+v\n", v.Type, v.Fills)
196 | 
197 | 			case realtime.UNDEFINED:
198 | 				fmt.Printf("UNDEFINED %s	%s\n", v.Symbol, v.Results.Error())
199 | 			}
200 | 		}
201 | 	}
202 | }
203 | ```
204 | 
205 | 
206 | ## Author
207 | 
208 | [@_numbP](https://twitter.com/_numbP)
209 | 
210 | ## License
211 | 
212 | [MIT](https://github.com/go-numb/go-ftx/blob/master/LICENSE)
213 | 


--------------------------------------------------------------------------------
/auth/auth.go:
--------------------------------------------------------------------------------
 1 | package auth
 2 | 
 3 | import (
 4 | 	"crypto/hmac"
 5 | 	"crypto/sha256"
 6 | 	"encoding/hex"
 7 | 	"sync"
 8 | )
 9 | 
10 | type Config struct {
11 | 	mux sync.RWMutex
12 | 
13 | 	Key    string
14 | 	Secret string
15 | 
16 | 	// SubAccountID use Account as needed when rewrite ID
17 | 	SubAccountID int
18 | 	subAccounts  map[int]SubAccount
19 | }
20 | 
21 | type SubAccount struct {
22 | 	UUID     int
23 | 	Nickname string
24 | }
25 | 
26 | func (p *Config) UseSubAccountID(uuid int) {
27 | 	p.mux.Lock()
28 | 	defer p.mux.Unlock()
29 | 
30 | 	p.SubAccountID = uuid
31 | }
32 | 
33 | func (p *Config) SubAccount() SubAccount {
34 | 	p.mux.Lock()
35 | 	defer p.mux.Unlock()
36 | 
37 | 	return p.subAccounts[p.SubAccountID]
38 | }
39 | 
40 | func New(key, secret string, subaccounts ...SubAccount) *Config {
41 | 	config := &Config{
42 | 		Key:          key,
43 | 		Secret:       secret,
44 | 		SubAccountID: 0,
45 | 	}
46 | 
47 | 	if 0 < len(subaccounts) {
48 | 		accounts := make(map[int]SubAccount)
49 | 		for i := range subaccounts {
50 | 			accounts[subaccounts[i].UUID] = subaccounts[i]
51 | 		}
52 | 		config.subAccounts = accounts
53 | 	}
54 | 
55 | 	return config
56 | }
57 | 
58 | func (p *Config) Signature(body string) string {
59 | 	mac := hmac.New(sha256.New, []byte(p.Secret))
60 | 	mac.Write([]byte(body))
61 | 	return hex.EncodeToString(mac.Sum(nil))
62 | }
63 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/go-numb/go-ftx
 2 | 
 3 | go 1.14
 4 | 
 5 | require (
 6 | 	github.com/buger/jsonparser v1.1.1
 7 | 	github.com/dustin/go-humanize v1.0.0
 8 | 	github.com/google/go-querystring v1.0.0
 9 | 	github.com/gorilla/websocket v1.4.2
10 | 	github.com/json-iterator/go v1.1.10
11 | 	github.com/stretchr/testify v1.3.0
12 | 	github.com/valyala/fasthttp v1.34.0
13 | )
14 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
 2 | github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
 3 | github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
 4 | github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 5 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 6 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 7 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 8 | github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 9 | github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
10 | github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
11 | github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
12 | github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
13 | github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
14 | github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
15 | github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
16 | github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
17 | github.com/klauspost/compress v1.15.0 h1:xqfchp4whNFxn5A4XFyyYtitiWI8Hy5EW59jEwcyL6U=
18 | github.com/klauspost/compress v1.15.0/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
19 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
20 | github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
21 | github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
22 | github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
23 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
24 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
25 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
26 | github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
27 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
28 | github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
29 | github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
30 | github.com/valyala/fasthttp v1.34.0 h1:d3AAQJ2DRcxJYHm7OXNXtXt2as1vMDfxeIcFvhmGGm4=
31 | github.com/valyala/fasthttp v1.34.0/go.mod h1:epZA5N+7pY6ZaEKRmstzOuYJx9HI8DI1oaCGZpdH4h0=
32 | github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
33 | golang.org/x/crypto v0.0.0-20220214200702-86341886e292/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
34 | golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
35 | golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
36 | golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
37 | golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
38 | golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
39 | golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
40 | golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
41 | golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
42 | golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
43 | golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
44 | golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
45 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
46 | 


--------------------------------------------------------------------------------
/realtime/websocket.go:
--------------------------------------------------------------------------------
  1 | package realtime
  2 | 
  3 | import (
  4 | 	"context"
  5 | 	"crypto/hmac"
  6 | 	"crypto/sha256"
  7 | 	"encoding/hex"
  8 | 	"encoding/json"
  9 | 	"fmt"
 10 | 	"log"
 11 | 	"os"
 12 | 	"time"
 13 | 
 14 | 	"github.com/buger/jsonparser"
 15 | 	"github.com/go-numb/go-ftx/rest/private/fills"
 16 | 	"github.com/go-numb/go-ftx/rest/private/orders"
 17 | 	"github.com/go-numb/go-ftx/rest/public/markets"
 18 | 	"github.com/go-numb/go-ftx/types"
 19 | 	"github.com/gorilla/websocket"
 20 | )
 21 | 
 22 | const (
 23 | 	UNDEFINED = iota
 24 | 	ERROR
 25 | 	TICKER
 26 | 	TRADES
 27 | 	ORDERBOOK
 28 | 	ORDERS
 29 | 	FILLS
 30 | )
 31 | 
 32 | type request struct {
 33 | 	Op      string `json:"op"`
 34 | 	Channel string `json:"channel"`
 35 | 	Market  string `json:"market"`
 36 | }
 37 | 
 38 | // {"op": "login", "args": {"key": "<api_key>", "sign": "<signature>", "time": 1111}}
 39 | type requestForPrivate struct {
 40 | 	Op   string                 `json:"op"`
 41 | 	Args map[string]interface{} `json:"args"`
 42 | }
 43 | 
 44 | type Response struct {
 45 | 	Type   int
 46 | 	Symbol string
 47 | 
 48 | 	Ticker    markets.Ticker
 49 | 	Trades    []markets.Trade
 50 | 	Orderbook Orderbook
 51 | 
 52 | 	Orders orders.Order
 53 | 	Fills  fills.Fill
 54 | 
 55 | 	Results error
 56 | }
 57 | 
 58 | type Orderbook struct {
 59 | 	Bids [][]float64 `json:"bids"`
 60 | 	Asks [][]float64 `json:"asks"`
 61 | 	// Action return update/partial
 62 | 	Action   string        `json:"action"`
 63 | 	Time     types.FtxTime `json:"time"`
 64 | 	Checksum int64         `json:"checksum"`
 65 | }
 66 | 
 67 | func subscribe(conn *websocket.Conn, channels, symbols []string) error {
 68 | 	if symbols != nil {
 69 | 		for i := range channels {
 70 | 			for j := range symbols {
 71 | 				if err := conn.WriteJSON(&request{
 72 | 					Op:      "subscribe",
 73 | 					Channel: channels[i],
 74 | 					Market:  symbols[j],
 75 | 				}); err != nil {
 76 | 					return err
 77 | 				}
 78 | 			}
 79 | 		}
 80 | 	} else {
 81 | 		for i := range channels {
 82 | 			if err := conn.WriteJSON(&request{
 83 | 				Op:      "subscribe",
 84 | 				Channel: channels[i],
 85 | 			}); err != nil {
 86 | 				return err
 87 | 			}
 88 | 		}
 89 | 	}
 90 | 	return nil
 91 | }
 92 | 
 93 | func unsubscribe(conn *websocket.Conn, channels, symbols []string, l *log.Logger) error {
 94 | 	if symbols != nil {
 95 | 		for i := range channels {
 96 | 			for j := range symbols {
 97 | 				if err := conn.WriteJSON(&request{
 98 | 					Op:      "unsubscribe",
 99 | 					Channel: channels[i],
100 | 					Market:  symbols[j],
101 | 				}); err != nil {
102 | 					return err
103 | 				}
104 | 			}
105 | 		}
106 | 	} else {
107 | 		for i := range channels {
108 | 			if err := conn.WriteJSON(&request{
109 | 				Op:      "unsubscribe",
110 | 				Channel: channels[i],
111 | 			}); err != nil {
112 | 				return err
113 | 			}
114 | 		}
115 | 	}
116 | 
117 | 	_, msg, err := conn.ReadMessage()
118 | 	if err != nil {
119 | 		l.Printf("[ERROR]: ws unsubscribed %s", err)
120 | 		return err
121 | 	}
122 | 
123 | 	l.Printf("[INFO]: ws unsubscribed msg %s\n", msg)
124 | 
125 | 	return nil
126 | }
127 | 
128 | func ping(conn *websocket.Conn) (err error) {
129 | 	ticker := time.NewTicker(15 * time.Second)
130 | 	defer ticker.Stop()
131 | 
132 | 	for {
133 | 		select {
134 | 		case <-ticker.C:
135 | 			if err := conn.WriteMessage(websocket.PingMessage, []byte(`{"op": "pong"}`)); err != nil {
136 | 				goto EXIT
137 | 			}
138 | 		}
139 | 	}
140 | EXIT:
141 | 	return err
142 | }
143 | 
144 | func Connect(ctx context.Context, ch chan Response, channels, symbols []string, l *log.Logger) error {
145 | 	if l == nil {
146 | 		l = log.New(os.Stdout, "ftx websocket", log.Llongfile)
147 | 	}
148 | 
149 | 	conn, _, err := websocket.DefaultDialer.Dial("wss://ftx.com/ws/", nil)
150 | 	if err != nil {
151 | 		return err
152 | 	}
153 | 
154 | 	if err := subscribe(conn, channels, symbols); err != nil {
155 | 		return err
156 | 	}
157 | 
158 | 	// ping each 15sec for exchange
159 | 	go ping(conn)
160 | 
161 | 	go func() {
162 | 		defer conn.Close()
163 | 		defer unsubscribe(conn, channels, symbols, l)
164 | 
165 | 	RESTART:
166 | 		for {
167 | 			var res Response
168 | 
169 | 			// Receive cancellation notification from the parent and execute CLOSE(unsubscribe->conn.Close). In this case RECONNECT is performed by the parent.
170 | 			select {
171 | 			case <-ctx.Done():
172 | 				l.Printf("[INFO]: ws context done: %s", err)
173 | 				return
174 | 
175 | 			default:
176 | 			}
177 | 
178 | 			_, msg, err := conn.ReadMessage()
179 | 			if err != nil {
180 | 				l.Printf("[ERROR]: msg error: %+v", err)
181 | 				res.Type = ERROR
182 | 				res.Results = fmt.Errorf("%v", err)
183 | 				ch <- res
184 | 				break RESTART
185 | 			}
186 | 
187 | 			typeMsg, err := jsonparser.GetString(msg, "type")
188 | 			if typeMsg == "error" {
189 | 				l.Printf("[ERROR]: error: %+v", string(msg))
190 | 				res.Type = ERROR
191 | 				res.Results = fmt.Errorf("%v", string(msg))
192 | 				ch <- res
193 | 				break RESTART
194 | 			}
195 | 
196 | 			channel, err := jsonparser.GetString(msg, "channel")
197 | 			if err != nil {
198 | 				l.Printf("[ERROR]: channel error: %+v", string(msg))
199 | 				res.Type = ERROR
200 | 				res.Results = fmt.Errorf("%v", string(msg))
201 | 				ch <- res
202 | 				break RESTART
203 | 			}
204 | 
205 | 			market, err := jsonparser.GetString(msg, "market")
206 | 			if err != nil {
207 | 				l.Printf("[ERROR]: market err: %+v", string(msg))
208 | 				res.Type = ERROR
209 | 				res.Results = fmt.Errorf("%v", string(msg))
210 | 				ch <- res
211 | 				break RESTART
212 | 			}
213 | 
214 | 			res.Symbol = market
215 | 
216 | 			data, _, _, err := jsonparser.Get(msg, "data")
217 | 			if err != nil {
218 | 				if isSubscribe, _ := jsonparser.GetString(msg, "type"); isSubscribe == "subscribed" {
219 | 					l.Printf("[SUCCESS]: %s %+v", isSubscribe, string(msg))
220 | 					continue
221 | 				} else {
222 | 					err = fmt.Errorf("[ERROR]: data err: %v %s", err, string(msg))
223 | 					l.Println(err)
224 | 					res.Type = ERROR
225 | 					res.Results = err
226 | 					ch <- res
227 | 					break RESTART
228 | 				}
229 | 			}
230 | 
231 | 			switch channel {
232 | 			case "ticker":
233 | 				res.Type = TICKER
234 | 				if err := json.Unmarshal(data, &res.Ticker); err != nil {
235 | 					l.Printf("[WARN]: cant unmarshal ticker %+v", err)
236 | 					continue
237 | 				}
238 | 
239 | 			case "trades":
240 | 				res.Type = TRADES
241 | 				if err := json.Unmarshal(data, &res.Trades); err != nil {
242 | 					l.Printf("[WARN]: cant unmarshal trades %+v", err)
243 | 					continue
244 | 				}
245 | 
246 | 			case "orderbook":
247 | 				res.Type = ORDERBOOK
248 | 				if err := json.Unmarshal(data, &res.Orderbook); err != nil {
249 | 					l.Printf("[WARN]: cant unmarshal orderbook %+v", err)
250 | 					continue
251 | 				}
252 | 
253 | 			default:
254 | 				res.Type = UNDEFINED
255 | 				res.Results = fmt.Errorf("%v", string(msg))
256 | 			}
257 | 
258 | 			ch <- res
259 | 
260 | 		}
261 | 	}()
262 | 
263 | 	return nil
264 | }
265 | 
266 | func ConnectForPrivate(ctx context.Context, ch chan Response, key, secret string, channels []string, l *log.Logger, subaccount ...string) error {
267 | 	if l == nil {
268 | 		l = log.New(os.Stdout, "ftx websocket", log.Llongfile)
269 | 	}
270 | 
271 | 	conn, _, err := websocket.DefaultDialer.Dial("wss://ftx.com/ws/", nil)
272 | 	if err != nil {
273 | 		return err
274 | 	}
275 | 
276 | 	// sign up
277 | 	if err := signature(conn, key, secret, subaccount); err != nil {
278 | 		return err
279 | 	}
280 | 
281 | 	if err := subscribe(conn, channels, nil); err != nil {
282 | 		return err
283 | 	}
284 | 
285 | 	go ping(conn)
286 | 
287 | 	go func() {
288 | 		defer conn.Close()
289 | 		defer unsubscribe(conn, channels, nil, l)
290 | 
291 | 	RESTART:
292 | 		for {
293 | 			var res Response
294 | 
295 | 			// Receive cancellation notification from the parent and execute CLOSE(unsubscribe->conn.Close). In this case RECONNECT is performed by the parent.
296 | 			select {
297 | 			case <-ctx.Done():
298 | 				l.Printf("[INFO]: ws context done: %s", err)
299 | 				return
300 | 
301 | 			default:
302 | 			}
303 | 
304 | 			_, msg, err := conn.ReadMessage()
305 | 			if err != nil {
306 | 				l.Printf("[ERROR]: msg error: %+v", err)
307 | 				res.Type = ERROR
308 | 				res.Results = fmt.Errorf("%v", err)
309 | 				ch <- res
310 | 				break RESTART
311 | 			}
312 | 
313 | 			typeMsg, err := jsonparser.GetString(msg, "type")
314 | 			if typeMsg == "error" {
315 | 				l.Printf("[ERROR]: error: %+v", string(msg))
316 | 				res.Type = ERROR
317 | 				res.Results = fmt.Errorf("%v", string(msg))
318 | 				ch <- res
319 | 				break RESTART
320 | 			}
321 | 
322 | 			channel, err := jsonparser.GetString(msg, "channel")
323 | 			if err != nil {
324 | 				l.Printf("[ERROR]: channel error: %+v", string(msg))
325 | 				res.Type = ERROR
326 | 				res.Results = fmt.Errorf("%v", string(msg))
327 | 				ch <- res
328 | 				break RESTART
329 | 			}
330 | 
331 | 			data, _, _, err := jsonparser.Get(msg, "data")
332 | 			if err != nil {
333 | 				if isSubscribe, _ := jsonparser.GetString(msg, "type"); isSubscribe == "subscribed" {
334 | 					l.Printf("[SUCCESS]: %s %+v", isSubscribe, string(msg))
335 | 					continue
336 | 				} else {
337 | 					err = fmt.Errorf("[ERROR]: data err: %v %s", err, string(msg))
338 | 					l.Println(err)
339 | 					res.Type = ERROR
340 | 					res.Results = err
341 | 					ch <- res
342 | 					break RESTART
343 | 				}
344 | 			}
345 | 
346 | 			// Private channel has not market name.
347 | 			switch channel {
348 | 			case "orders":
349 | 				res.Type = ORDERS
350 | 				if err := json.Unmarshal(data, &res.Orders); err != nil {
351 | 					l.Printf("[WARN]: cant unmarshal orders %+v", err)
352 | 					continue
353 | 				}
354 | 
355 | 			case "fills":
356 | 				res.Type = FILLS
357 | 				if err := json.Unmarshal(data, &res.Fills); err != nil {
358 | 					l.Printf("[WARN]: cant unmarshal fills %+v", err)
359 | 					continue
360 | 				}
361 | 
362 | 			default:
363 | 				res.Type = UNDEFINED
364 | 				res.Results = fmt.Errorf("%v", string(msg))
365 | 			}
366 | 
367 | 			ch <- res
368 | 		}
369 | 	}()
370 | 
371 | 	return nil
372 | }
373 | 
374 | func signature(conn *websocket.Conn, key, secret string, subaccount []string) error {
375 | 	// key: your API key
376 | 	// time: integer current timestamp (in milliseconds)
377 | 	// sign: SHA256 HMAC of the following string, using your API secret: <time>websocket_login
378 | 	// subaccount: (optional) subaccount name
379 | 	// As an example, if:
380 | 
381 | 	// time: 1557246346499
382 | 	// secret: 'Y2QTHI23f23f23jfjas23f23To0RfUwX3H42fvN-'
383 | 	// sign would be d10b5a67a1a941ae9463a60b285ae845cdeac1b11edc7da9977bef0228b96de9
384 | 
385 | 	// One websocket connection may be logged in to at most one user. If the connection is already authenticated, further attempts to log in will result in 400s.
386 | 
387 | 	msec := time.Now().UTC().UnixNano() / int64(time.Millisecond)
388 | 
389 | 	mac := hmac.New(sha256.New, []byte(secret))
390 | 	mac.Write([]byte(fmt.Sprintf("%dwebsocket_login", msec)))
391 | 	args := map[string]interface{}{
392 | 		"key":  key,
393 | 		"sign": hex.EncodeToString(mac.Sum(nil)),
394 | 		"time": msec,
395 | 	}
396 | 	if len(subaccount) > 0 {
397 | 		args["subaccount"] = subaccount[0]
398 | 	}
399 | 
400 | 	if err := conn.WriteJSON(&requestForPrivate{
401 | 		Op:   "login",
402 | 		Args: args,
403 | 	}); err != nil {
404 | 		return err
405 | 	}
406 | 
407 | 	return nil
408 | }
409 | 


--------------------------------------------------------------------------------
/realtime/websocket_test.go:
--------------------------------------------------------------------------------
 1 | package realtime_test
 2 | 
 3 | import (
 4 | 	"context"
 5 | 	"fmt"
 6 | 	"testing"
 7 | 	"time"
 8 | 
 9 | 	"github.com/go-numb/go-ftx/realtime"
10 | )
11 | 
12 | func TestConnect(t *testing.T) {
13 | 	start := time.Now()
14 | 	defer func() {
15 | 		fmt.Printf("exec time: %f s\n", time.Since(start).Seconds())
16 | 	}()
17 | 
18 | 	isReconnect := false
19 | 
20 | RECONNECT:
21 | 	if isReconnect {
22 | 		fmt.Println("[ws RE:CONNECT]")
23 | 		isReconnect = false
24 | 		time.Sleep(15 * time.Second)
25 | 	}
26 | 
27 | 	ctx, cancel := context.WithCancel(context.Background())
28 | 	defer cancel()
29 | 
30 | 	ch := make(chan realtime.Response, 10)
31 | 	go realtime.Connect(ctx, ch, []string{"trades"}, []string{"BTC-PERP", "ETH-PERP", "SOL-PERP"}, nil)
32 | 
33 | 	for {
34 | 		select {
35 | 		case v := <-ch:
36 | 			switch v.Type {
37 | 			case realtime.TICKER:
38 | 				fmt.Printf("%s	%+v\n", v.Symbol, v.Ticker)
39 | 
40 | 			case realtime.TRADES:
41 | 				// fmt.Printf("%s	%+v\n", v.Symbol, v.Trades)
42 | 				for i := range v.Trades {
43 | 					if v.Trades[i].Liquidation {
44 | 						fmt.Printf("-----------------------------[%s]%+v\n", v.Symbol, v.Trades[i])
45 | 					}
46 | 				}
47 | 
48 | 			case realtime.ORDERBOOK:
49 | 				fmt.Printf("%s	%+v\n", v.Symbol, v.Orderbook)
50 | 
51 | 			case realtime.UNDEFINED:
52 | 				fmt.Printf("%s	%s\n", v.Symbol, v.Results.Error())
53 | 
54 | 			case realtime.ERROR:
55 | 				fmt.Printf("[ERROR] %s\n", v.Results.Error())
56 | 				goto EXIT
57 | 			}
58 | 		}
59 | 	}
60 | 
61 | EXIT:
62 | 	time.AfterFunc(time.Minute, cancel)
63 | 	close(ch)
64 | 	isReconnect = true
65 | 
66 | 	fmt.Printf("reconnect exec time: %f s\n", time.Since(start).Seconds())
67 | 
68 | 	goto RECONNECT
69 | }
70 | 
71 | func TestConnectForPrivate(t *testing.T) {
72 | 	ctx, cancel := context.WithCancel(context.Background())
73 | 	defer cancel()
74 | 
75 | 	ch := make(chan realtime.Response)
76 | 	go realtime.ConnectForPrivate(ctx, ch, "", "", []string{"orders", "fills"}, nil)
77 | 
78 | 	for {
79 | 		select {
80 | 		case v := <-ch:
81 | 			switch v.Type {
82 | 			case realtime.ORDERS:
83 | 				fmt.Printf("%d	%+v\n", v.Type, v.Orders)
84 | 			case realtime.FILLS:
85 | 				fmt.Printf("%d	%+v\n", v.Type, v.Fills)
86 | 
87 | 			case realtime.UNDEFINED:
88 | 				fmt.Printf("UNDEFINED %s	%s\n", v.Symbol, v.Results.Error())
89 | 			}
90 | 		}
91 | 	}
92 | }
93 | 


--------------------------------------------------------------------------------
/rest/client.go:
--------------------------------------------------------------------------------
 1 | package rest
 2 | 
 3 | import (
 4 | 	"time"
 5 | 
 6 | 	"github.com/go-numb/go-ftx/auth"
 7 | 	jsoniter "github.com/json-iterator/go"
 8 | 	"github.com/valyala/fasthttp"
 9 | )
10 | 
11 | const ENDPOINT = "https://ftx.com/api"
12 | 
13 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
14 | 
15 | type Client struct {
16 | 	Auth *auth.Config
17 | 
18 | 	HTTPC       *fasthttp.Client
19 | 	HTTPTimeout time.Duration
20 | }
21 | 
22 | func New(auth *auth.Config) *Client {
23 | 	hc := new(fasthttp.Client)
24 | 
25 | 	return &Client{
26 | 		Auth:        auth,
27 | 		HTTPC:       hc,
28 | 		HTTPTimeout: 5 * time.Second,
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/rest/errors.go:
--------------------------------------------------------------------------------
 1 | package rest
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | // APIError return the api error
 8 | type APIError struct {
 9 | 	Status  int
10 | 	Message string
11 | }
12 | 
13 | // Error return the error message
14 | func (e APIError) Error() string {
15 | 	return fmt.Sprintf("APIError: status=%d, message=%s", e.Status, e.Message)
16 | }
17 | 


--------------------------------------------------------------------------------
/rest/interface.go:
--------------------------------------------------------------------------------
1 | package rest
2 | 
3 | type Requester interface {
4 | 	Path() string
5 | 	Method() string
6 | 	Query() string
7 | 	Payload() []byte
8 | }
9 | 


--------------------------------------------------------------------------------
/rest/private/account/information.go:
--------------------------------------------------------------------------------
 1 | package account
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForInformation struct {
 8 | }
 9 | 
10 | type ResponseForInformation struct {
11 | 	Username string `json:"username"`
12 | 
13 | 	Collateral               float64 `json:"collateral"`
14 | 	FreeCollateral           float64 `json:"freeCollateral"`
15 | 	TotalAccountValue        float64 `json:"totalAccountValue"`
16 | 	TotalPositionSize        float64 `json:"totalPositionSize"`
17 | 	InitialMarginRequirement float64 `json:"initialMarginRequirement"`
18 | 	Leverage                 float64 `json:"leverage"`
19 | 
20 | 	MakerFee                     float64 `json:"makerFee"`
21 | 	TakerFee                     float64 `json:"takerFee"`
22 | 	MaintenanceMarginRequirement float64 `json:"maintenanceMarginRequirement"`
23 | 
24 | 	MarginFraction     float64 `json:"marginFraction"`
25 | 	OpenMarginFraction float64 `json:"openMarginFraction"`
26 | 
27 | 	Positions []Position `json:"positions"`
28 | 
29 | 	BackstopProvider bool `json:"backstopProvider"`
30 | 	Liquidating      bool `json:"liquidating"`
31 | }
32 | 
33 | func (req *RequestForInformation) Path() string {
34 | 	return "/account"
35 | }
36 | 
37 | func (req *RequestForInformation) Method() string {
38 | 	return http.MethodGet
39 | }
40 | 
41 | func (req *RequestForInformation) Query() string {
42 | 	return ""
43 | }
44 | 
45 | func (req *RequestForInformation) Payload() []byte {
46 | 	return nil
47 | }
48 | 


--------------------------------------------------------------------------------
/rest/private/account/leverage.go:
--------------------------------------------------------------------------------
 1 | package account
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 
 6 | 	jsoniter "github.com/json-iterator/go"
 7 | )
 8 | 
 9 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
10 | 
11 | type RequestForLeverage struct {
12 | 	Leverage int `json:"leverage"`
13 | }
14 | 
15 | type ResponseForLeverage interface{}
16 | 
17 | func (req *RequestForLeverage) Path() string {
18 | 	return "/account/leverage"
19 | }
20 | 
21 | func (req *RequestForLeverage) Method() string {
22 | 	return http.MethodPost
23 | }
24 | 
25 | func (req *RequestForLeverage) Query() string {
26 | 	return ""
27 | }
28 | 
29 | func (req *RequestForLeverage) Payload() []byte {
30 | 	b, err := json.Marshal(req)
31 | 	if err != nil {
32 | 		return nil
33 | 	}
34 | 	return b
35 | }
36 | 


--------------------------------------------------------------------------------
/rest/private/account/positions.go:
--------------------------------------------------------------------------------
 1 | package account
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForPositions struct {
 8 | 	ShowAvgPrice bool `json:"showAvgPrice"`
 9 | }
10 | 
11 | type ResponseForPositions []Position
12 | 
13 | type Position struct {
14 | 	Future string `json:"future"`
15 | 	Side   string `json:"side"`
16 | 
17 | 	InitialMarginRequirement     float64 `json:"initialMarginRequirement"`
18 | 	MaintenanceMarginRequirement float64 `json:"maintenanceMarginRequirement"`
19 | 
20 | 	EntryPrice                float64 `json:"entryPrice"`
21 | 	EstimatedLiquidationPrice float64 `json:"estimatedLiquidationPrice,omitempty"`
22 | 
23 | 	Size           float64 `json:"size"`
24 | 	NetSize        float64 `json:"netSize"`
25 | 	OpenSize       float64 `json:"openSize"`
26 | 	LongOrderSize  float64 `json:"longOrderSize"`
27 | 	ShortOrderSize float64 `json:"shortOrderSize"`
28 | 
29 | 	Cost          float64 `json:"cost"`
30 | 	UnrealizedPnl float64 `json:"unrealizedPnl"`
31 | 	RealizedPnl   float64 `json:"realizedPnl"`
32 | 
33 | 	CollateralUsed         float64 `json:"collateralUsed,omitempty"`
34 | 	RecentAverageOpenPrice float64 `json:"recentAverageOpenPrice,omitempty"`
35 | 	RecentPnl              float64 `json:"recentPnl,omitempty"`
36 | 	RecentBreakEvenPrice   float64 `json:"recentBreakEvenPrice,omitempty"`
37 | 	CumulativeBuySize      float64 `json:"cumulativeBuySize,omitempty"`
38 | 	CumulativeSellSize     float64 `json:"cumulativeSellSize,omitempty"`
39 | }
40 | 
41 | func (req *RequestForPositions) Path() string {
42 | 	return "/positions"
43 | }
44 | 
45 | func (req *RequestForPositions) Method() string {
46 | 	return http.MethodGet
47 | }
48 | 
49 | func (req *RequestForPositions) Query() string {
50 | 	if req.ShowAvgPrice {
51 | 		return "showAvgPrice=true"
52 | 	}
53 | 	return ""
54 | }
55 | 
56 | func (req *RequestForPositions) Payload() []byte {
57 | 	// b, err := json.Marshal(req)
58 | 	// if err != nil {
59 | 	// 	return nil
60 | 	// }
61 | 	return nil
62 | }
63 | 


--------------------------------------------------------------------------------
/rest/private/convert/accept-quote.go:
--------------------------------------------------------------------------------
 1 | package convert
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForAcceptQuote struct {
 9 | 	QuoteId int `json:"quoteId"`
10 | }
11 | 
12 | type ResponseForAcceptQuote struct {
13 | 	// Filled bool `json:"filled"`
14 | }
15 | 
16 | func (req *RequestForAcceptQuote) Path() string {
17 | 	return fmt.Sprintf("/otc/quotes/%d/accept", req.QuoteId)
18 | }
19 | 
20 | func (req *RequestForAcceptQuote) Method() string {
21 | 	return http.MethodPost
22 | }
23 | 
24 | func (req *RequestForAcceptQuote) Query() string {
25 | 	return ""
26 | }
27 | 
28 | func (req *RequestForAcceptQuote) Payload() []byte {
29 | 	return nil
30 | }
31 | 


--------------------------------------------------------------------------------
/rest/private/convert/get-quote-status.go:
--------------------------------------------------------------------------------
 1 | package convert
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForQuoteStatus struct {
 9 | 	QuoteId int `json:"quoteId"`
10 | }
11 | 
12 | type ResponseForQuoteStatus struct {
13 | 	BaseCoin  string  `json:"baseCoin"`
14 | 	Cost      float64 `json:"cost"`
15 | 	Expired   bool    `json:"expired"`
16 | 	Expiry    float64 `json:"expiry"`
17 | 	Filled    bool    `json:"filled"`
18 | 	FromCoin  string  `json:"fromCoin"`
19 | 	QuoteId   int     `json:"id"`
20 | 	Price     float64 `json:"price"`
21 | 	Proceeds  float64 `json:"proceeds"`
22 | 	QuoteCoin string  `json:"quoteCoin"`
23 | 	Side      string  `json:"side"`
24 | 	ToCoin    string  `json:"toCoin"`
25 | }
26 | 
27 | func (req *RequestForQuoteStatus) Path() string {
28 | 	return fmt.Sprintf("/otc/quotes/%d", req.QuoteId)
29 | }
30 | 
31 | func (req *RequestForQuoteStatus) Method() string {
32 | 	return http.MethodGet
33 | }
34 | 
35 | func (req *RequestForQuoteStatus) Query() string {
36 | 	return ""
37 | }
38 | 
39 | func (req *RequestForQuoteStatus) Payload() []byte {
40 | 	return nil
41 | }
42 | 


--------------------------------------------------------------------------------
/rest/private/convert/request-quote.go:
--------------------------------------------------------------------------------
 1 | package convert
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForRequestQuote struct {
 9 | 	FromCoin string  `json:"fromCoin"`
10 | 	ToCoin   string  `json:"toCoin"`
11 | 	Size     float64 `json:"size"`
12 | 	// WaitForPrice bool    `json:"waitForPrice,omitempty"`
13 | }
14 | 
15 | type ResponseForRequestQuote struct {
16 | 	QuoteId int `json:"quoteId"`
17 | }
18 | 
19 | func (req *RequestForRequestQuote) Path() string {
20 | 	return "/otc/quotes"
21 | }
22 | 
23 | func (req *RequestForRequestQuote) Method() string {
24 | 	return http.MethodPost
25 | }
26 | 
27 | func (req *RequestForRequestQuote) Query() string {
28 | 	return ""
29 | }
30 | 
31 | func (req *RequestForRequestQuote) Payload() []byte {
32 | 	b, err := json.Marshal(req)
33 | 	if err != nil {
34 | 		return nil
35 | 	}
36 | 	return b
37 | }
38 | 


--------------------------------------------------------------------------------
/rest/private/convert/request-quote_test.go:
--------------------------------------------------------------------------------
  1 | package convert_test
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"os"
  6 | 	"testing"
  7 | 
  8 | 	"github.com/go-numb/go-ftx/auth"
  9 | 	"github.com/go-numb/go-ftx/rest"
 10 | 	"github.com/go-numb/go-ftx/rest/private/account"
 11 | 	"github.com/go-numb/go-ftx/rest/private/convert"
 12 | 	"github.com/stretchr/testify/assert"
 13 | )
 14 | 
 15 | func getAuth() *rest.Client {
 16 | 	subaccountNickname := os.Getenv("FTXSUBACCOUNT")
 17 | 
 18 | 	if subaccountNickname == "" {
 19 | 		return rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 20 | 	}
 21 | 
 22 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET"),
 23 | 		auth.SubAccount{
 24 | 			UUID:     1,
 25 | 			Nickname: subaccountNickname,
 26 | 		}))
 27 | 	c.Auth.UseSubAccountID(1)
 28 | 	return c
 29 | }
 30 | 
 31 | func TestInformation(t *testing.T) {
 32 | 	c := getAuth()
 33 | 
 34 | 	res, err := c.Information(&account.RequestForInformation{})
 35 | 	assert.NoError(t, err)
 36 | 
 37 | 	fmt.Printf("%+v\n", res)
 38 | }
 39 | 
 40 | func GetQuote() (resp *convert.ResponseForRequestQuote, err error) {
 41 | 	c := getAuth()
 42 | 
 43 | 	res, err := c.RequestConvertQuote(&convert.RequestForRequestQuote{
 44 | 		FromCoin: "USDT",
 45 | 		ToCoin:   "USD",
 46 | 		Size:     2,
 47 | 	})
 48 | 	return res, err
 49 | }
 50 | 
 51 | func TestRequestQuote(t *testing.T) {
 52 | 	quote, err := GetQuote()
 53 | 	assert.NoError(t, err)
 54 | 	assert.NotZero(t, quote.QuoteId)
 55 | 	quoteId := quote.QuoteId
 56 | 
 57 | 	fmt.Printf("QuoteID: %+v\n", quoteId)
 58 | }
 59 | 
 60 | func GetQuoteStatus(quoteId int) (resp *convert.ResponseForQuoteStatus, err error) {
 61 | 	c := getAuth()
 62 | 
 63 | 	res, err := c.GetConvertQuoteStatus(&convert.RequestForQuoteStatus{
 64 | 		QuoteId: quoteId,
 65 | 	})
 66 | 
 67 | 	return res, err
 68 | }
 69 | 
 70 | func TestQuoteStatus(t *testing.T) {
 71 | 	quote, err := GetQuote()
 72 | 	assert.NoError(t, err)
 73 | 	assert.NotZero(t, quote.QuoteId)
 74 | 	quoteId := quote.QuoteId
 75 | 	fmt.Printf("Got quote with ID: %+v\n", quoteId)
 76 | 
 77 | 	res, err := GetQuoteStatus(quoteId)
 78 | 
 79 | 	assert.NoError(t, err)
 80 | 	assert.Equal(t, res.QuoteId, quoteId)
 81 | 	assert.NotZero(t, res.Price)
 82 | 
 83 | 	fmt.Printf("Result: %+v\n", res)
 84 | }
 85 | 
 86 | func AcceptQuote(quoteId int) (resp *convert.ResponseForAcceptQuote, err error) {
 87 | 	c := getAuth()
 88 | 
 89 | 	res, err := c.AcceptConvertQuote(&convert.RequestForAcceptQuote{
 90 | 		QuoteId: quoteId,
 91 | 	})
 92 | 
 93 | 	return res, err
 94 | }
 95 | 
 96 | func TestAcceptQuote(t *testing.T) {
 97 | 	quote, err := GetQuote()
 98 | 	assert.NoError(t, err)
 99 | 	assert.NotZero(t, quote.QuoteId)
100 | 	quoteId := quote.QuoteId
101 | 	fmt.Printf("Got quote with ID: %+v\n", quoteId)
102 | 
103 | 	res_status, err := GetQuoteStatus(quoteId)
104 | 	assert.NoError(t, err)
105 | 	assert.Equal(t, res_status.QuoteId, quoteId)
106 | 	assert.NotZero(t, res_status.Cost)
107 | 	fmt.Printf("Got quote status: %+v\n", res_status)
108 | 
109 | 	res_accept, err := AcceptQuote(quoteId)
110 | 	assert.NoError(t, err)
111 | 	fmt.Printf("Accepted quote: %+v\n", res_accept)
112 | }
113 | 


--------------------------------------------------------------------------------
/rest/private/fills/fills.go:
--------------------------------------------------------------------------------
 1 | package fills
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type Request struct {
11 | 	ProductCode string `url:"market,omitempty"`
12 | 	OrderID     int    `url:"orderId,omitempty"`
13 | 	Order       string `url:"order,omitempty"`
14 | 	Limit       int    `url:"limit,omitempty"`
15 | 	Start       int64  `url:"start_time,omitempty"`
16 | 	End         int64  `url:"end_time,omitempty"`
17 | }
18 | 
19 | type Response []Fill
20 | 
21 | type Fill struct {
22 | 	Future    string `json:"future"`
23 | 	Market    string `json:"market"`
24 | 	Type      string `json:"type"`
25 | 	Liquidity string `json:"liquidity"`
26 | 
27 | 	// only rest follow 2factor
28 | 	BaseCurrency  string `json:"baseCurrency"`
29 | 	QuoteCurrency string `json:"quoteCurrency"`
30 | 	FeeCurrency   string `json:"feeCurrency"`
31 | 
32 | 	Side string `json:"side"`
33 | 
34 | 	Price   float64 `json:"price"`
35 | 	Size    float64 `json:"size"`
36 | 	Fee     float64 `json:"fee"`
37 | 	FeeRate float64 `json:"feeRate"`
38 | 
39 | 	Time time.Time `json:"time"`
40 | 
41 | 	ID      int `json:"id"`
42 | 	OrderID int `json:"orderId"`
43 | 	TradeID int `json:"tradeId"`
44 | }
45 | 
46 | func (req *Request) Path() string {
47 | 	return "/fills"
48 | }
49 | 
50 | func (req *Request) Method() string {
51 | 	return http.MethodGet
52 | }
53 | 
54 | func (req *Request) Query() string {
55 | 	value, _ := query.Values(req)
56 | 	return value.Encode()
57 | }
58 | 
59 | func (req *Request) Payload() []byte {
60 | 	return nil
61 | }
62 | 


--------------------------------------------------------------------------------
/rest/private/funding/funding.go:
--------------------------------------------------------------------------------
 1 | package funding
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type Request struct {
11 | 	ProductCode string `url:"future,omitempty"`
12 | 	Start       int64  `url:"start_time,omitempty"`
13 | 	End         int64  `url:"end_time,omitempty"`
14 | }
15 | 
16 | type Response []Funding
17 | 
18 | type Funding struct {
19 | 	Future string `json:"future"`
20 | 
21 | 	Payment float64 `json:"payment"`
22 | 	Rate    float64 `json:"rate"`
23 | 
24 | 	Time time.Time `json:"time"`
25 | 	ID   int       `json:"id"`
26 | }
27 | 
28 | func (req *Request) Path() string {
29 | 	return "/funding_payments"
30 | }
31 | 
32 | func (req *Request) Method() string {
33 | 	return http.MethodGet
34 | }
35 | 
36 | func (req *Request) Query() string {
37 | 	value, _ := query.Values(req)
38 | 	return value.Encode()
39 | }
40 | 
41 | func (req *Request) Payload() []byte {
42 | 	return nil
43 | }
44 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/balances.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForLvBalances struct {
 8 | }
 9 | 
10 | type ResponseForLvBalances []TokenBalance
11 | 
12 | type TokenBalance struct {
13 | 	Token   string  `json:"token"`
14 | 	Balance float64 `json:"balance"`
15 | }
16 | 
17 | func (req *RequestForLvBalances) Path() string {
18 | 	return "/lt/balances"
19 | }
20 | 
21 | func (req *RequestForLvBalances) Method() string {
22 | 	return http.MethodGet
23 | }
24 | 
25 | func (req *RequestForLvBalances) Query() string {
26 | 	return ""
27 | }
28 | 
29 | func (req *RequestForLvBalances) Payload() []byte {
30 | 	return nil
31 | }
32 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/created.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | 
 8 | 	jsoniter "github.com/json-iterator/go"
 9 | )
10 | 
11 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
12 | 
13 | type RequestForCreatedLvToken struct {
14 | 	ProductCode string `json:"-"`
15 | 	// to body
16 | 	Size string `json:"size"`
17 | }
18 | 
19 | type ResponseForCreatedLvToken struct {
20 | 	Token         string    `json:"token"`
21 | 	RequestedSize float64   `json:"requestedSize"`
22 | 	Cost          float64   `json:"cost"`
23 | 	RequestedAt   time.Time `json:"requestedAt"`
24 | 
25 | 	Pending bool `json:"pending"`
26 | 	ID      int  `json:"id"`
27 | }
28 | 
29 | func (req *RequestForCreatedLvToken) Path() string {
30 | 	return fmt.Sprintf("/lt/%s/create", req.ProductCode)
31 | }
32 | 
33 | func (req *RequestForCreatedLvToken) Method() string {
34 | 	return http.MethodPost
35 | }
36 | 
37 | func (req *RequestForCreatedLvToken) Query() string {
38 | 	return ""
39 | }
40 | 
41 | func (req *RequestForCreatedLvToken) Payload() []byte {
42 | 	b, err := json.Marshal(req)
43 | 	if err != nil {
44 | 		return nil
45 | 	}
46 | 	return b
47 | }
48 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/list-created-tokens.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForCreatedLvTokens struct {
 9 | }
10 | 
11 | type ResponseForCreatedLvTokens []Creation
12 | 
13 | type Creation struct {
14 | 	ID    int    `json:"id"`
15 | 	Token string `json:"token"`
16 | 
17 | 	Price         float64   `json:"price"`
18 | 	RequestedSize float64   `json:"requestedSize"`
19 | 	CreatedSize   float64   `json:"createdSize"`
20 | 	Cost          float64   `json:"cost"`
21 | 	Fee           float64   `json:"fee"`
22 | 	RequestedAt   time.Time `json:"requestedAt"`
23 | 	FulfilledAt   time.Time `json:"fulfilledAt"`
24 | 
25 | 	Pending bool `json:"pending"`
26 | }
27 | 
28 | func (req *RequestForCreatedLvTokens) Path() string {
29 | 	return "/lt/creations"
30 | }
31 | 
32 | func (req *RequestForCreatedLvTokens) Method() string {
33 | 	return http.MethodGet
34 | }
35 | 
36 | func (req *RequestForCreatedLvTokens) Query() string {
37 | 	return ""
38 | }
39 | 
40 | func (req *RequestForCreatedLvTokens) Payload() []byte {
41 | 	return nil
42 | }
43 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/list-redemption-tokens.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForRedemptionLvTokens struct {
 9 | }
10 | 
11 | type ResponseForRedemptionLvTokens []Redemption
12 | 
13 | type Redemption struct {
14 | 	ID          int       `json:"id"`
15 | 	Token       string    `json:"token"`
16 | 	Size        float64   `json:"size"`
17 | 	Price       float64   `json:"price"`
18 | 	Proceeds    float64   `json:"proceeds"`
19 | 	Fee         float64   `json:"fee"`
20 | 	RequestedAt time.Time `json:"requestedAt"`
21 | 	FulfilledAt time.Time `json:"fulfilledAt"`
22 | 
23 | 	Pending bool `json:"pending"`
24 | }
25 | 
26 | func (req *RequestForRedemptionLvTokens) Path() string {
27 | 	return "/lt/redemptions"
28 | }
29 | 
30 | func (req *RequestForRedemptionLvTokens) Method() string {
31 | 	return http.MethodGet
32 | }
33 | 
34 | func (req *RequestForRedemptionLvTokens) Query() string {
35 | 	return ""
36 | }
37 | 
38 | func (req *RequestForRedemptionLvTokens) Payload() []byte {
39 | 	return nil
40 | }
41 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/list.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForLvTokens struct {
 8 | }
 9 | 
10 | type ResponseForLvTokens []LvToken
11 | 
12 | type LvToken struct {
13 | 	Name            string `json:"name"`
14 | 	Description     string `json:"description"`
15 | 	Underlying      string `json:"underlying"`
16 | 	ContractAddress string `json:"contractAddress"`
17 | 
18 | 	Leverage         float64 `json:"leverage"`
19 | 	Outstanding      float64 `json:"outstanding"`
20 | 	PricePerShare    float64 `json:"pricePerShare"`
21 | 	PositionPerShare float64 `json:"positionPerShare"`
22 | 	UnderlyingMark   float64 `json:"underlyingMark"`
23 | 	Change1H         float64 `json:"change1h"`
24 | 	Change24H        float64 `json:"change24h"`
25 | }
26 | 
27 | func (req *RequestForLvTokens) Path() string {
28 | 	return "/lt/tokens"
29 | }
30 | 
31 | func (req *RequestForLvTokens) Method() string {
32 | 	return http.MethodGet
33 | }
34 | 
35 | func (req *RequestForLvTokens) Query() string {
36 | 	return ""
37 | }
38 | 
39 | func (req *RequestForLvTokens) Payload() []byte {
40 | 	return nil
41 | }
42 | 
43 | func (tokens ResponseForLvTokens) Products() []string {
44 | 	list := make([]string, len(tokens))
45 | 	for i := range tokens {
46 | 		list[i] = tokens[i].Name
47 | 	}
48 | 	return list
49 | }
50 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/redemption.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForRedemptionLvToken struct {
10 | 	ProductCode string `json:"-"`
11 | 	// to body
12 | 	Size string `json:"size"`
13 | }
14 | 
15 | type ResponseForRedemptionLvToken struct {
16 | 	Token             string    `json:"token"`
17 | 	Size              float64   `json:"size"`
18 | 	ProjectedProceeds float64   `json:"projectedProceeds"`
19 | 	Pending           bool      `json:"pending"`
20 | 	RequestedAt       time.Time `json:"requestedAt"`
21 | 
22 | 	ID int `json:"id"`
23 | }
24 | 
25 | func (req *RequestForRedemptionLvToken) Path() string {
26 | 	return fmt.Sprintf("/lt/%s/redeem", req.ProductCode)
27 | }
28 | 
29 | func (req *RequestForRedemptionLvToken) Method() string {
30 | 	return http.MethodPost
31 | }
32 | 
33 | func (req *RequestForRedemptionLvToken) Query() string {
34 | 	return ""
35 | }
36 | 
37 | func (req *RequestForRedemptionLvToken) Payload() []byte {
38 | 	b, err := json.Marshal(req)
39 | 	if err != nil {
40 | 		return nil
41 | 	}
42 | 	return b
43 | }
44 | 


--------------------------------------------------------------------------------
/rest/private/leveraged/token.go:
--------------------------------------------------------------------------------
 1 | package leveraged
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForLvToken struct {
 9 | 	ProductCode string
10 | }
11 | 
12 | type ResponseForLvToken LvToken
13 | 
14 | func (req *RequestForLvToken) Path() string {
15 | 	return fmt.Sprintf("/lt/%s", req.ProductCode)
16 | }
17 | 
18 | func (req *RequestForLvToken) Method() string {
19 | 	return http.MethodGet
20 | }
21 | 
22 | func (req *RequestForLvToken) Query() string {
23 | 	return ""
24 | }
25 | 
26 | func (req *RequestForLvToken) Payload() []byte {
27 | 	return nil
28 | }
29 | 


--------------------------------------------------------------------------------
/rest/private/options/accept-quote.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForAcceptOpQuote struct {
 9 | 	QuoteID int
10 | }
11 | 
12 | type ResponseForAcceptOpQuote Quote
13 | 
14 | func (req *RequestForAcceptOpQuote) Path() string {
15 | 	return fmt.Sprintf("/options/quotes/%d/accept", req.QuoteID)
16 | }
17 | 
18 | func (req *RequestForAcceptOpQuote) Method() string {
19 | 	return http.MethodPost
20 | }
21 | 
22 | func (req *RequestForAcceptOpQuote) Query() string {
23 | 	return ""
24 | }
25 | 
26 | func (req *RequestForAcceptOpQuote) Payload() []byte {
27 | 	return nil
28 | }
29 | 


--------------------------------------------------------------------------------
/rest/private/options/cancel-quote.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForCancelOpQuote struct {
 9 | 	QuoteID int
10 | }
11 | 
12 | type ResponseForCancelOpQuote Quote
13 | 
14 | func (req *RequestForCancelOpQuote) Path() string {
15 | 	return fmt.Sprintf("/options/quotes/%d", req.QuoteID)
16 | }
17 | 
18 | func (req *RequestForCancelOpQuote) Method() string {
19 | 	return http.MethodDelete
20 | }
21 | 
22 | func (req *RequestForCancelOpQuote) Query() string {
23 | 	return ""
24 | }
25 | 
26 | func (req *RequestForCancelOpQuote) Payload() []byte {
27 | 	return nil
28 | }
29 | 


--------------------------------------------------------------------------------
/rest/private/options/cancel-request.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForCancelOpQuoteRequest struct {
10 | 	RequestID int
11 | }
12 | 
13 | type ResponseForCancelOpQuoteRequest struct {
14 | 	ID     int `json:"id"`
15 | 	Option struct {
16 | 		Expiry     time.Time `json:"expiry"`
17 | 		Strike     float64   `json:"strike"`
18 | 		Type       string    `json:"type"`
19 | 		Underlying string    `json:"underlying"`
20 | 	} `json:"option"`
21 | 	Status        string    `json:"status"`
22 | 	Side          string    `json:"side"`
23 | 	Size          float64   `json:"size"`
24 | 	RequestExpiry time.Time `json:"requestExpiry"`
25 | 	Time          time.Time `json:"time"`
26 | }
27 | 
28 | func (req *RequestForCancelOpQuoteRequest) Path() string {
29 | 	return fmt.Sprintf("/options/requests/%d", req.RequestID)
30 | }
31 | 
32 | func (req *RequestForCancelOpQuoteRequest) Method() string {
33 | 	return http.MethodDelete
34 | }
35 | 
36 | func (req *RequestForCancelOpQuoteRequest) Query() string {
37 | 	return ""
38 | }
39 | 
40 | func (req *RequestForCancelOpQuoteRequest) Payload() []byte {
41 | 	return nil
42 | }
43 | 


--------------------------------------------------------------------------------
/rest/private/options/common.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import "time"
 4 | 
 5 | type Quote struct {
 6 | 	ID          int     `json:"id"`
 7 | 	RequestID   int     `json:"requestId"`
 8 | 	Status      string  `json:"status"`
 9 | 	QuoterSide  string  `json:"quoterSide"`
10 | 	RequestSide string  `json:"requestSide"`
11 | 	Price       float64 `json:"price"`
12 | 	Size        float64 `json:"size"`
13 | 	Collateral  float64 `json:"collateral"`
14 | 
15 | 	Option Option `json:"option"`
16 | 
17 | 	QuoteExpiry time.Time `json:"quoteExpiry"`
18 | 	Time        time.Time `json:"time"`
19 | }
20 | 
21 | type Option struct {
22 | 	Underlying string    `json:"underlying"`
23 | 	Type       string    `json:"type"`
24 | 	Strike     float64   `json:"strike"`
25 | 	Expiry     time.Time `json:"expiry"`
26 | }
27 | 


--------------------------------------------------------------------------------
/rest/private/options/create-request.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	jsoniter "github.com/json-iterator/go"
 8 | )
 9 | 
10 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
11 | 
12 | type RequestForCreateOpQuoteRequest struct {
13 | 	Underlying string  `json:"underlying"`
14 | 	Type       string  `json:"type"`
15 | 	Side       string  `json:"side"`
16 | 	Strike     float64 `json:"strike"`
17 | 	Size       float64 `json:"size"`
18 | 	Expiry     int64   `json:"expiry"`
19 | 	// Options
20 | 	LimitPrice     float64 `json:"limitPrice,omitempty"`
21 | 	HideLimitPrice bool    `json:"hideLimitPrice,omitempty"`
22 | 	RequestExpiry  int64   `json:"requestExpiry,omitempty"`
23 | 	CounterpartyID int     `json:"counterpartyId,omitempty"`
24 | }
25 | 
26 | type ResponseForCreateOpQuoteRequest struct {
27 | 	ID     int `json:"id"`
28 | 	Option struct {
29 | 		Strike     float64   `json:"strike"`
30 | 		Type       string    `json:"type"`
31 | 		Underlying string    `json:"underlying"`
32 | 		Expiry     time.Time `json:"expiry"`
33 | 	} `json:"option"`
34 | 	Strike        int       `json:"strike"`
35 | 	Type          string    `json:"type"`
36 | 	Underlying    string    `json:"underlying"`
37 | 	Side          string    `json:"side"`
38 | 	Status        string    `json:"status"`
39 | 	Size          float64   `json:"size"`
40 | 	Expiry        time.Time `json:"expiry"`
41 | 	RequestExpiry time.Time `json:"requestExpiry"`
42 | 	Time          time.Time `json:"time"`
43 | }
44 | 
45 | func (req *RequestForCreateOpQuoteRequest) Path() string {
46 | 	return "/options/requests"
47 | }
48 | 
49 | func (req *RequestForCreateOpQuoteRequest) Method() string {
50 | 	return http.MethodPost
51 | }
52 | 
53 | func (req *RequestForCreateOpQuoteRequest) Query() string {
54 | 	return ""
55 | }
56 | 
57 | func (req *RequestForCreateOpQuoteRequest) Payload() []byte {
58 | 	b, err := json.Marshal(req)
59 | 	if err != nil {
60 | 		return nil
61 | 	}
62 | 	return b
63 | }
64 | 


--------------------------------------------------------------------------------
/rest/private/options/fills.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForOpFills struct {
11 | 	Limit int   `url:"limit,omitempty"`
12 | 	Start int64 `url:"start_time,omitempty"`
13 | 	End   int64 `url:"end_time,omitempty"`
14 | }
15 | 
16 | type ResponseForOpFills []OpTrade
17 | 
18 | type OpFill struct {
19 | 	ID        int       `json:"id"`
20 | 	Liquidity string    `json:"liquidity"`
21 | 	Side      string    `json:"side"`
22 | 	Price     float64   `json:"price"`
23 | 	QuoteID   float64   `json:"quoteId"`
24 | 	Size      float64   `json:"size"`
25 | 	Fee       float64   `json:"fee"`
26 | 	FeeRate   float64   `json:"feeRate"`
27 | 	Option    Option    `json:"option"`
28 | 	Time      time.Time `json:"time"`
29 | }
30 | 
31 | func (req *RequestForOpFills) Path() string {
32 | 	return "/options/fills"
33 | }
34 | 
35 | func (req *RequestForOpFills) Method() string {
36 | 	return http.MethodGet
37 | }
38 | 
39 | func (req *RequestForOpFills) Query() string {
40 | 	value, _ := query.Values(req)
41 | 	return value.Encode()
42 | }
43 | 
44 | func (req *RequestForOpFills) Payload() []byte {
45 | 	return nil
46 | }
47 | 


--------------------------------------------------------------------------------
/rest/private/options/modify-quote-request.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | // Document記載はCreate quoteだが、modify request
 9 | type RequestForModifyOpQuoteRequest struct {
10 | 	RequestID int     `json:"-"`
11 | 	Price     float64 `json:"price"`
12 | }
13 | 
14 | type ResponseForModifyOpQuoteRequest Quote
15 | 
16 | func (req *RequestForModifyOpQuoteRequest) Path() string {
17 | 	return fmt.Sprintf("/options/requests/%s/quotes", req.RequestID)
18 | }
19 | 
20 | func (req *RequestForModifyOpQuoteRequest) Method() string {
21 | 	return http.MethodPost
22 | }
23 | 
24 | func (req *RequestForModifyOpQuoteRequest) Query() string {
25 | 	return ""
26 | }
27 | 
28 | func (req *RequestForModifyOpQuoteRequest) Payload() []byte {
29 | 	b, err := json.Marshal(req)
30 | 	if err != nil {
31 | 		return nil
32 | 	}
33 | 	return b
34 | }
35 | 


--------------------------------------------------------------------------------
/rest/private/options/my-quote-request.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForMyOpQuoteRequest struct {
 9 | 	RequestID int
10 | }
11 | 
12 | type ResponseForMyOpQuoteRequest []Quote
13 | 
14 | func (req *RequestForMyOpQuoteRequest) Path() string {
15 | 	return fmt.Sprintf("/options/requests/%d/quotes", req.RequestID)
16 | }
17 | 
18 | func (req *RequestForMyOpQuoteRequest) Method() string {
19 | 	return http.MethodGet
20 | }
21 | 
22 | func (req *RequestForMyOpQuoteRequest) Query() string {
23 | 	return ""
24 | }
25 | 
26 | func (req *RequestForMyOpQuoteRequest) Payload() []byte {
27 | 	return nil
28 | }
29 | 


--------------------------------------------------------------------------------
/rest/private/options/my-quote-requests.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForMyOpQuoteRequests struct {
 9 | }
10 | 
11 | type ResponseForMyOpQuoteRequests []MyOpQuote
12 | 
13 | type MyOpQuote struct {
14 | 	ID     int `json:"id"`
15 | 	Option struct {
16 | 		Underlying string    `json:"underlying"`
17 | 		Type       string    `json:"type"`
18 | 		Strike     float64   `json:"strike"`
19 | 		Expiry     time.Time `json:"expiry"`
20 | 	} `json:"option"`
21 | 	Status         string  `json:"status"`
22 | 	Side           string  `json:"side"`
23 | 	Size           float64 `json:"size"`
24 | 	LimitPrice     float64 `json:"limitPrice"`
25 | 	HideLimitPrice bool    `json:"hideLimitPrice"`
26 | 	Quotes         []struct {
27 | 		ID          int       `json:"id"`
28 | 		Collateral  float64   `json:"collateral"`
29 | 		Price       float64   `json:"price"`
30 | 		Status      string    `json:"status"`
31 | 		QuoteExpiry time.Time `json:"quoteExpiry"`
32 | 		Time        time.Time `json:"time"`
33 | 	} `json:"quotes"`
34 | 
35 | 	Time          time.Time `json:"time"`
36 | 	RequestExpiry time.Time `json:"requestExpiry"`
37 | }
38 | 
39 | func (req *RequestForMyOpQuoteRequests) Path() string {
40 | 	return "/options/my_requests"
41 | }
42 | 
43 | func (req *RequestForMyOpQuoteRequests) Method() string {
44 | 	return http.MethodGet
45 | }
46 | 
47 | func (req *RequestForMyOpQuoteRequests) Query() string {
48 | 	return ""
49 | }
50 | 
51 | func (req *RequestForMyOpQuoteRequests) Payload() []byte {
52 | 	return nil
53 | }
54 | 


--------------------------------------------------------------------------------
/rest/private/options/my-quotes.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForMyOpQuotes struct {
 8 | }
 9 | 
10 | type ResponseForMyOpQuotes []Quote
11 | 
12 | func (req *RequestForMyOpQuotes) Path() string {
13 | 	return "/options/my_quotes"
14 | }
15 | 
16 | func (req *RequestForMyOpQuotes) Method() string {
17 | 	return http.MethodGet
18 | }
19 | 
20 | func (req *RequestForMyOpQuotes) Query() string {
21 | 	return ""
22 | }
23 | 
24 | func (req *RequestForMyOpQuotes) Payload() []byte {
25 | 	return nil
26 | }
27 | 


--------------------------------------------------------------------------------
/rest/private/options/positons.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForOpPositions struct {
 8 | }
 9 | 
10 | type ResponseForOpPositions []OpPosition
11 | 
12 | type OpPosition struct {
13 | 	Side       string  `json:"side"`
14 | 	EntryPrice float64 `json:"entryPrice"`
15 | 	Size       float64 `json:"size"`
16 | 	NetSize    float64 `json:"netSize"`
17 | 	Option     Option  `json:"option"`
18 | }
19 | 
20 | func (req *RequestForOpPositions) Path() string {
21 | 	return "/options/positions"
22 | }
23 | 
24 | func (req *RequestForOpPositions) Method() string {
25 | 	return http.MethodGet
26 | }
27 | 
28 | func (req *RequestForOpPositions) Query() string {
29 | 	return ""
30 | }
31 | 
32 | func (req *RequestForOpPositions) Payload() []byte {
33 | 	return nil
34 | }
35 | 


--------------------------------------------------------------------------------
/rest/private/options/requests.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForOpQuoteRequests struct {
 9 | }
10 | 
11 | type ResponseForOpQuoteRequests []OpQuote
12 | 
13 | type OpQuote struct {
14 | 	ID     int `json:"id"`
15 | 	Option struct {
16 | 		Underlying string    `json:"underlying"`
17 | 		Type       string    `json:"type"`
18 | 		Strike     float64   `json:"strike"`
19 | 		Expiry     time.Time `json:"expiry"`
20 | 	} `json:"option"`
21 | 	Side   string  `json:"side"`
22 | 	Size   float64 `json:"size"`
23 | 	Status string  `json:"status"`
24 | 
25 | 	Time          time.Time `json:"time"`
26 | 	RequestExpiry time.Time `json:"requestExpiry"`
27 | }
28 | 
29 | func (req *RequestForOpQuoteRequests) Path() string {
30 | 	return "/options/requests"
31 | }
32 | 
33 | func (req *RequestForOpQuoteRequests) Method() string {
34 | 	return http.MethodGet
35 | }
36 | 
37 | func (req *RequestForOpQuoteRequests) Query() string {
38 | 	return ""
39 | }
40 | 
41 | func (req *RequestForOpQuoteRequests) Payload() []byte {
42 | 	return nil
43 | }
44 | 


--------------------------------------------------------------------------------
/rest/private/options/trades.go:
--------------------------------------------------------------------------------
 1 | package options
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForOpTrades struct {
11 | 	Limit int   `url:"limit,omitempty"`
12 | 	Start int64 `url:"start_time,omitempty"`
13 | 	End   int64 `url:"end_time,omitempty"`
14 | }
15 | 
16 | type ResponseForOpTrades []OpTrade
17 | 
18 | type OpTrade struct {
19 | 	ID     int       `json:"id"`
20 | 	Price  float64   `json:"price"`
21 | 	Size   float64   `json:"size"`
22 | 	Option Option    `json:"option"`
23 | 	Time   time.Time `json:"time"`
24 | }
25 | 
26 | func (req *RequestForOpTrades) Path() string {
27 | 	return "/options/trades"
28 | }
29 | 
30 | func (req *RequestForOpTrades) Method() string {
31 | 	return http.MethodGet
32 | }
33 | 
34 | func (req *RequestForOpTrades) Query() string {
35 | 	value, _ := query.Values(req)
36 | 	return value.Encode()
37 | }
38 | 
39 | func (req *RequestForOpTrades) Payload() []byte {
40 | 	return nil
41 | }
42 | 


--------------------------------------------------------------------------------
/rest/private/orders/cancel-all.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForCancelAll struct {
 8 | 	ProductCode           string `json:"market,omitempty"`
 9 | 	Side                  string `json:"side,omitempty"`
10 | 	ConditionalOrdersOnly bool   `json:"conditionalOrdersOnly,omitempty"`
11 | 	LimitOrdersOnly       bool   `json:"limitOrdersOnly,omitempty"`
12 | }
13 | 
14 | type ResponseForCancelAll string
15 | 
16 | func (req *RequestForCancelAll) Path() string {
17 | 	return "/orders"
18 | }
19 | 
20 | func (req *RequestForCancelAll) Method() string {
21 | 	return http.MethodDelete
22 | }
23 | 
24 | func (req *RequestForCancelAll) Query() string {
25 | 	return ""
26 | }
27 | 
28 | func (req *RequestForCancelAll) Payload() []byte {
29 | 	b, err := json.Marshal(req)
30 | 	if err != nil {
31 | 		return nil
32 | 	}
33 | 	return b
34 | }
35 | 


--------------------------------------------------------------------------------
/rest/private/orders/cancel.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForCancelByID struct {
 9 | 	ClientID       string
10 | 	OrderID        int
11 | 	TriggerOrderID string
12 | }
13 | 
14 | type ResponseForCancelByID string
15 | 
16 | func (req *RequestForCancelByID) Path() string {
17 | 	if req.TriggerOrderID != "" {
18 | 		return fmt.Sprintf("/conditional_orders/%s", req.TriggerOrderID)
19 | 	} else if req.ClientID != "" {
20 | 		return fmt.Sprintf("/orders/by_client_id/%s", req.ClientID)
21 | 	}
22 | 	return fmt.Sprintf("/orders/%d", req.OrderID)
23 | }
24 | 
25 | func (req *RequestForCancelByID) Method() string {
26 | 	return http.MethodDelete
27 | }
28 | 
29 | func (req *RequestForCancelByID) Query() string {
30 | 	return ""
31 | }
32 | 
33 | func (req *RequestForCancelByID) Payload() []byte {
34 | 	return nil
35 | }
36 | 


--------------------------------------------------------------------------------
/rest/private/orders/get-open-order-histories.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForHistories struct {
11 | 	ProductCode string `url:"market,omitempty"`
12 | 	Limit       int    `url:"limit,omitempty"`
13 | 	Start       int64  `url:"start_time,omitempty"`
14 | 	End         int64  `url:"end_time,omitempty"`
15 | }
16 | 
17 | type ResponseForHistories []Histories
18 | 
19 | type Histories struct {
20 | 	Type     string `json:"type"`
21 | 	ClientID string `json:"clientId"`
22 | 	Future   string `json:"future"`
23 | 	Market   string `json:"market"`
24 | 	Status   string `json:"status"`
25 | 	Side     string `json:"side"`
26 | 
27 | 	Price         float64 `json:"price"`
28 | 	AvgFillPrice  float64 `json:"avgFillPrice"`
29 | 	FilledSize    float64 `json:"filledSize"`
30 | 	Size          float64 `json:"size"`
31 | 	RemainingSize float64 `json:"remainingSize"`
32 | 
33 | 	ID         int  `json:"id"`
34 | 	Ioc        bool `json:"ioc"`
35 | 	PostOnly   bool `json:"postOnly"`
36 | 	ReduceOnly bool `json:"reduceOnly"`
37 | 
38 | 	CreatedAt time.Time `json:"createdAt"`
39 | }
40 | 
41 | func (req *RequestForHistories) Path() string {
42 | 	return "/orders/history"
43 | }
44 | 
45 | func (req *RequestForHistories) Method() string {
46 | 	return http.MethodGet
47 | }
48 | 
49 | func (req *RequestForHistories) Query() string {
50 | 	value, _ := query.Values(req)
51 | 	return value.Encode()
52 | }
53 | 
54 | func (req *RequestForHistories) Payload() []byte {
55 | 	return nil
56 | }
57 | 


--------------------------------------------------------------------------------
/rest/private/orders/get-open-order.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForOpenOrder struct {
11 | 	ProductCode string `url:"market,omitempty"`
12 | }
13 | 
14 | type ResponseForOpenOrder []OpenOrder
15 | 
16 | type OpenOrder struct {
17 | 	Type     string `json:"type"`
18 | 	Market   string `json:"market"`
19 | 	Future   string `json:"future"`
20 | 	ClientID string `json:"clientId"`
21 | 	Status   string `json:"status"`
22 | 	Side     string `json:"side"`
23 | 
24 | 	Price         float64 `json:"price"`
25 | 	AvgFillPrice  float64 `json:"avgFillPrice"`
26 | 	Size          float64 `json:"size"`
27 | 	FilledSize    float64 `json:"filledSize"`
28 | 	RemainingSize float64 `json:"remainingSize"`
29 | 
30 | 	ID         int64 `json:"id"`
31 | 	ReduceOnly bool  `json:"reduceOnly"`
32 | 	Ioc        bool  `json:"ioc"`
33 | 	PostOnly   bool  `json:"postOnly"`
34 | 
35 | 	CreatedAt time.Time `json:"createdAt"`
36 | }
37 | 
38 | type Order struct {
39 | 	ID            int64     `json:"id"`
40 | 	ClientID      string    `json:"clientId"`
41 | 	Market        string    `json:"market"`
42 | 	Type          string    `json:"type"`
43 | 	Side          string    `json:"side"`
44 | 	Size          float64   `json:"size"`
45 | 	Price         float64   `json:"price"`
46 | 	ReduceOnly    bool      `json:"reduceOnly"`
47 | 	Ioc           bool      `json:"ioc"`
48 | 	PostOnly      bool      `json:"postOnly"`
49 | 	Status        string    `json:"status"`
50 | 	FilledSize    float64   `json:"filledSize"`
51 | 	RemainingSize float64   `json:"remainingSize"`
52 | 	AvgFillPrice  float64   `json:"avgFillPrice"`
53 | 	CreatedAt     time.Time `json:"createdAt"`
54 | }
55 | 
56 | func (req *RequestForOpenOrder) Path() string {
57 | 	return "/orders"
58 | }
59 | 
60 | func (req *RequestForOpenOrder) Method() string {
61 | 	return http.MethodGet
62 | }
63 | 
64 | func (req *RequestForOpenOrder) Query() string {
65 | 	value, _ := query.Values(req)
66 | 	return value.Encode()
67 | }
68 | 
69 | func (req *RequestForOpenOrder) Payload() []byte {
70 | 	return nil
71 | }
72 | 


--------------------------------------------------------------------------------
/rest/private/orders/get-open-trigger-order.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForOrderTriggers struct {
10 | 	CID string `url:"-"`
11 | }
12 | 
13 | type ResponseForOrderTriggers []Trigger
14 | 
15 | type Trigger struct {
16 | 	FilledSize float64 `json:"filledSize"`
17 | 	OrderSize  float64 `json:"orderSize"`
18 | 	Error      string  `json:"error"`
19 | 
20 | 	OrderID int       `json:"orderId"`
21 | 	Time    time.Time `json:"time"`
22 | }
23 | 
24 | func (req *RequestForOrderTriggers) Path() string {
25 | 	return fmt.Sprintf("/conditional_orders/%s/triggers", req.CID)
26 | }
27 | 
28 | func (req *RequestForOrderTriggers) Method() string {
29 | 	return http.MethodGet
30 | }
31 | 
32 | func (req *RequestForOrderTriggers) Query() string {
33 | 	return ""
34 | }
35 | 
36 | func (req *RequestForOrderTriggers) Payload() []byte {
37 | 	return nil
38 | }
39 | 


--------------------------------------------------------------------------------
/rest/private/orders/get-open-trigger-orders.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForOpenTriggerOrders struct {
11 | 	ProductCode string `url:"market,omitempty"`
12 | 	Type        string `url:"type,omitempty"`
13 | }
14 | 
15 | type ResponseForOpenTriggerOrders []OpenTriggerOrder
16 | 
17 | type OpenTriggerOrder struct {
18 | 	Type      string `json:"type"`
19 | 	OrderType string `json:"orderType"`
20 | 	OrderID   string `json:"orderId"`
21 | 	Status    string `json:"status"`
22 | 	Error     string `json:"error"`
23 | 	Market    string `json:"market"`
24 | 	Future    string `json:"future"`
25 | 	Side      string `json:"side"`
26 | 
27 | 	OrderPrice float64 `json:"orderPrice"`
28 | 	Size       float64 `json:"size"`
29 | 
30 | 	TrailStart   float64 `json:"trailStart"`
31 | 	TrailValue   float64 `json:"trailValue"`
32 | 	TriggerPrice float64 `json:"triggerPrice"`
33 | 	AvgFillPrice float64 `json:"avgFillPrice"`
34 | 
35 | 	TriggeredAt time.Time `json:"triggeredAt"`
36 | 	CreatedAt   time.Time `json:"createdAt"`
37 | 
38 | 	ReduceOnly       bool    `json:"reduceOnly"`
39 | 	RetryUntilFilled bool    `json:"retryUntilFilled"`
40 | 	FilledSize       float64 `json:"filledSize"`
41 | 	ID               int     `json:"id"`
42 | }
43 | 
44 | func (req *RequestForOpenTriggerOrders) Path() string {
45 | 	return "/conditional_orders"
46 | }
47 | 
48 | func (req *RequestForOpenTriggerOrders) Method() string {
49 | 	return http.MethodGet
50 | }
51 | 
52 | func (req *RequestForOpenTriggerOrders) Query() string {
53 | 	value, _ := query.Values(req)
54 | 	return value.Encode()
55 | }
56 | 
57 | func (req *RequestForOpenTriggerOrders) Payload() []byte {
58 | 	return nil
59 | }
60 | 


--------------------------------------------------------------------------------
/rest/private/orders/get-order-trigger-histories.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForOrderTriggerHistories struct {
11 | 	ProductCode string `url:"market,omitempty"`
12 | 	Type        string `url:"type,omitempty"`
13 | 	Side        string `url:"side,omitempty"`
14 | 	OrderType   string `url:"orderType,omitempty"`
15 | 
16 | 	Start int64 `url:"start_time,omitempty"`
17 | 	End   int64 `url:"end_time,omitempty"`
18 | }
19 | 
20 | type ResponseForOrderTriggerHistories []TriggerHistory
21 | 
22 | type TriggerHistory struct {
23 | 	Status       string  `json:"status"`
24 | 	Error        string  `json:"error"`
25 | 	Future       string  `json:"future"`
26 | 	Market       string  `json:"market"`
27 | 	Type         string  `json:"type"`
28 | 	OrderType    string  `json:"orderType"`
29 | 	OrderStatus  string  `json:"orderStatus"`
30 | 	Side         string  `json:"side"`
31 | 	OrderPrice   float64 `json:"orderPrice"`
32 | 	TriggerPrice float64 `json:"triggerPrice"`
33 | 	AvgFillPrice float64 `json:"avgFillPrice"`
34 | 	TrailStart   float64 `json:"trailStart"`
35 | 	TrailValue   float64 `json:"trailValue"`
36 | 
37 | 	ID               int       `json:"id"`
38 | 	OrderID          int       `json:"orderId"`
39 | 	Size             float64   `json:"size"`
40 | 	FilledSize       float64   `json:"filledSize"`
41 | 	RetryUntilFilled bool      `json:"retryUntilFilled"`
42 | 	ReduceOnly       bool      `json:"reduceOnly"`
43 | 	TriggeredAt      time.Time `json:"triggeredAt"`
44 | 	CreatedAt        time.Time `json:"createdAt"`
45 | }
46 | 
47 | func (req *RequestForOrderTriggerHistories) Path() string {
48 | 	return "/conditional_orders/history"
49 | }
50 | 
51 | func (req *RequestForOrderTriggerHistories) Method() string {
52 | 	return http.MethodGet
53 | }
54 | 
55 | func (req *RequestForOrderTriggerHistories) Query() string {
56 | 	value, _ := query.Values(req)
57 | 	return value.Encode()
58 | }
59 | 
60 | func (req *RequestForOrderTriggerHistories) Payload() []byte {
61 | 	return nil
62 | }
63 | 


--------------------------------------------------------------------------------
/rest/private/orders/modify-order.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForModifyOrder struct {
10 | 	OrderID  string  `json:"-"`
11 | 	ClientID string  `json:"-"`
12 | 	Price    float64 `json:"price,omitempty"`
13 | 	Size     float64 `json:"size,omitempty"`
14 | }
15 | 
16 | type ResponseForModifyOrder struct {
17 | 	ClientID string `json:"clientId"`
18 | 	Future   string `json:"future"`
19 | 	Market   string `json:"market"`
20 | 	Status   string `json:"status"`
21 | 	Type     string `json:"type"`
22 | 	Side     string `json:"side"`
23 | 
24 | 	Price         float64 `json:"price"`
25 | 	Size          float64 `json:"size"`
26 | 	FilledSize    float64 `json:"filledSize"`
27 | 	RemainingSize float64 `json:"remainingSize"`
28 | 
29 | 	ID         int       `json:"id"`
30 | 	ReduceOnly bool      `json:"reduceOnly"`
31 | 	Ioc        bool      `json:"ioc"`
32 | 	PostOnly   bool      `json:"postOnly"`
33 | 	CreatedAt  time.Time `json:"createdAt"`
34 | }
35 | 
36 | func (req *RequestForModifyOrder) Path() string {
37 | 	// prioritize ClientID
38 | 	if req.ClientID != "" {
39 | 		return fmt.Sprintf("/orders/by_client_id/%s/modify", req.ClientID)
40 | 	}
41 | 	return fmt.Sprintf("/orders/%s/modify", req.OrderID)
42 | }
43 | 
44 | func (req *RequestForModifyOrder) Method() string {
45 | 	return http.MethodPost
46 | }
47 | 
48 | func (req *RequestForModifyOrder) Query() string {
49 | 	return ""
50 | }
51 | 
52 | func (req *RequestForModifyOrder) Payload() []byte {
53 | 	b, err := json.Marshal(req)
54 | 	if err != nil {
55 | 		return nil
56 | 	}
57 | 	return b
58 | }
59 | 


--------------------------------------------------------------------------------
/rest/private/orders/modify-trigger-order.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForModifyTriggerOrder struct {
10 | 	OrderID      string  `json:"-"`
11 | 	TrailValue   float64 `json:"trailValue,omitempty"`
12 | 	TriggerPrice float64 `json:"triggerPrice,omitempty"`
13 | 	//	OrderPrice only for stop limit orders
14 | 	OrderPrice float64 `json:"orderPrice,omitempty"`
15 | 	// necessary
16 | 	Size float64 `json:"size"`
17 | }
18 | 
19 | type ResponseForModifyTriggerOrder struct {
20 | 	OrderID   int    `json:"orderId"`
21 | 	Type      string `json:"type"`
22 | 	OrderType string `json:"orderType"`
23 | 	Future    string `json:"future"`
24 | 	Market    string `json:"market"`
25 | 	Status    string `json:"status"`
26 | 	Error     string `json:"error"`
27 | 	Side      string `json:"side"`
28 | 
29 | 	OrderPrice   float64 `json:"orderPrice"`
30 | 	AvgFillPrice float64 `json:"avgFillPrice"`
31 | 	TriggerPrice float64 `json:"triggerPrice"`
32 | 	Size         float64 `json:"size"`
33 | 	FilledSize   float64 `json:"filledSize"`
34 | 
35 | 	ID               int  `json:"id"`
36 | 	RetryUntilFilled bool `json:"retryUntilFilled"`
37 | 	ReduceOnly       bool `json:"reduceOnly"`
38 | 
39 | 	TriggeredAt time.Time `json:"triggeredAt"`
40 | 	CreatedAt   time.Time `json:"createdAt"`
41 | }
42 | 
43 | func (req *RequestForModifyTriggerOrder) Path() string {
44 | 	return fmt.Sprintf("/conditional_orders/%s/modify", req.OrderID)
45 | }
46 | 
47 | func (req *RequestForModifyTriggerOrder) Method() string {
48 | 	return http.MethodPost
49 | }
50 | 
51 | func (req *RequestForModifyTriggerOrder) Query() string {
52 | 	return ""
53 | }
54 | 
55 | func (req *RequestForModifyTriggerOrder) Payload() []byte {
56 | 	b, err := json.Marshal(req)
57 | 	if err != nil {
58 | 		return nil
59 | 	}
60 | 	return b
61 | }
62 | 


--------------------------------------------------------------------------------
/rest/private/orders/order-status.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForOrderStatus struct {
10 | 	ClientID string
11 | 	OrderID  int
12 | }
13 | 
14 | type ResponseForOrderStatus struct {
15 | 	ClientID string `json:"clientId"`
16 | 	Future   string `json:"future"`
17 | 	Market   string `json:"market"`
18 | 	Status   string `json:"status"`
19 | 	Type     string `json:"type"`
20 | 	Side     string `json:"side"`
21 | 
22 | 	Price         float64 `json:"price"`
23 | 	AvgFillPrice  float64 `json:"avgFillPrice"`
24 | 	FilledSize    float64 `json:"filledSize"`
25 | 	Size          float64 `json:"size"`
26 | 	RemainingSize float64 `json:"remainingSize"`
27 | 
28 | 	ID         int  `json:"id"`
29 | 	Ioc        bool `json:"ioc"`
30 | 	ReduceOnly bool `json:"reduceOnly"`
31 | 	PostOnly   bool `json:"postOnly"`
32 | 
33 | 	CreatedAt time.Time `json:"createdAt"`
34 | }
35 | 
36 | func (req *RequestForOrderStatus) Path() string {
37 | 	if req.ClientID != "" {
38 | 		return fmt.Sprintf("/orders/by_client_id/%s", req.ClientID)
39 | 	}
40 | 	return fmt.Sprintf("/orders/%d", req.OrderID)
41 | }
42 | 
43 | func (req *RequestForOrderStatus) Method() string {
44 | 	return http.MethodGet
45 | }
46 | 
47 | func (req *RequestForOrderStatus) Query() string {
48 | 	return ""
49 | }
50 | 
51 | func (req *RequestForOrderStatus) Payload() []byte {
52 | 	return nil
53 | }
54 | 


--------------------------------------------------------------------------------
/rest/private/orders/place-order.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	jsoniter "github.com/json-iterator/go"
 8 | )
 9 | 
10 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
11 | 
12 | type RequestForPlaceOrder struct {
13 | 	ClientID          string  `json:"clientId,omitempty"`
14 | 	Type              string  `json:"type"`
15 | 	Market            string  `json:"market"`
16 | 	Side              string  `json:"side"`
17 | 	Price             float64 `json:"price"`
18 | 	Size              float64 `json:"size"`
19 | 	ReduceOnly        bool    `json:"reduceOnly,omitempty"`
20 | 	Ioc               bool    `json:"ioc,omitempty"`
21 | 	PostOnly          bool    `json:"postOnly,omitempty"`
22 | 	RejectOnPriceBand bool    `json:"rejectOnPriceBand,omitempty"`
23 | }
24 | 
25 | type ResponseForPlaceOrder struct {
26 | 	ClientID string `json:"clientId"`
27 | 	Status   string `json:"status"`
28 | 	Type     string `json:"type"`
29 | 	Future   string `json:"future"`
30 | 	Market   string `json:"market"`
31 | 	Side     string `json:"side"`
32 | 
33 | 	Price         float64 `json:"price"`
34 | 	Size          float64 `json:"size"`
35 | 	RemainingSize float64 `json:"remainingSize"`
36 | 	FilledSize    float64 `json:"filledSize"`
37 | 
38 | 	ID         int  `json:"id"`
39 | 	Ioc        bool `json:"ioc"`
40 | 	PostOnly   bool `json:"postOnly"`
41 | 	ReduceOnly bool `json:"reduceOnly"`
42 | 
43 | 	CreatedAt time.Time `json:"createdAt"`
44 | }
45 | 
46 | func (req *RequestForPlaceOrder) Path() string {
47 | 	return "/orders"
48 | }
49 | 
50 | func (req *RequestForPlaceOrder) Method() string {
51 | 	return http.MethodPost
52 | }
53 | 
54 | func (req *RequestForPlaceOrder) Query() string {
55 | 	return ""
56 | }
57 | 
58 | func (req *RequestForPlaceOrder) Payload() []byte {
59 | 	b, err := json.Marshal(req)
60 | 	if err != nil {
61 | 		return nil
62 | 	}
63 | 	return b
64 | }
65 | 


--------------------------------------------------------------------------------
/rest/private/orders/place-trigger-order.go:
--------------------------------------------------------------------------------
 1 | package orders
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForPlaceTriggerOrder struct {
 9 | 	Market string `json:"market"`
10 | 	// Type stop, trailingStop, takeProfit. default is stop
11 | 	Type string  `json:"type"`
12 | 	Side string  `json:"side"`
13 | 	Size float64 `json:"size"`
14 | 
15 | 	// Special Orders
16 | 	TriggerPrice float64 `json:"triggerPrice,omitempty"`
17 | 	// negative for "sell"; positive for "buy"
18 | 	TrailValue float64 `json:"trailValue,omitempty"`
19 | 	OrderPrice float64 `json:"orderPrice,omitempty"`
20 | 
21 | 	ReduceOnly       bool `json:"reduceOnly,omitempty"`
22 | 	RetryUntilFilled bool `json:"retryUntilFilled,omitempty"`
23 | }
24 | 
25 | type ResponseForPlaceTriggerOrder struct {
26 | 	Type      string `json:"type"`
27 | 	Future    string `json:"future"`
28 | 	Market    string `json:"market"`
29 | 	OrderID   string `json:"orderId"`
30 | 	Status    string `json:"status"`
31 | 	Error     string `json:"error"`
32 | 	OrderType string `json:"orderType"`
33 | 	Side      string `json:"side"`
34 | 
35 | 	TriggerPrice float64 `json:"triggerPrice"`
36 | 	Size         float64 `json:"size"`
37 | 
38 | 	OrderPrice float64 `json:"orderPrice"`
39 | 
40 | 	ID               int  `json:"id"`
41 | 	ReduceOnly       bool `json:"reduceOnly"`
42 | 	RetryUntilFilled bool `json:"retryUntilFilled"`
43 | 
44 | 	TriggeredAt time.Time `json:"triggeredAt"`
45 | 	CreatedAt   time.Time `json:"createdAt"`
46 | }
47 | 
48 | func (req *RequestForPlaceTriggerOrder) Path() string {
49 | 	return "/conditional_orders"
50 | }
51 | 
52 | func (req *RequestForPlaceTriggerOrder) Method() string {
53 | 	return http.MethodPost
54 | }
55 | 
56 | func (req *RequestForPlaceTriggerOrder) Query() string {
57 | 	return ""
58 | }
59 | 
60 | func (req *RequestForPlaceTriggerOrder) Payload() []byte {
61 | 	b, err := json.Marshal(req)
62 | 	if err != nil {
63 | 		return nil
64 | 	}
65 | 	return b
66 | }
67 | 


--------------------------------------------------------------------------------
/rest/private/spotmargin/get-borrow-history.go:
--------------------------------------------------------------------------------
 1 | package spotmargin
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForBorrowHistory struct {
10 | 	StartTime int64 `json:"start_time,omitempty"`
11 | 	EndTime   int64 `json:"end_time,omitempty"`
12 | }
13 | 
14 | type ResponseForBorrowHistory []BorrowHistory
15 | 
16 | type BorrowHistory struct {
17 | 	Coin string    `json:"coin"`
18 | 	Cost float64   `json:"cost"`
19 | 	Rate float64   `json:"rate"`
20 | 	Size float64   `json:"size"`
21 | 	Time time.Time `json:"time"`
22 | }
23 | 
24 | func (req *RequestForBorrowHistory) Path() string {
25 | 	return "/spot_margin/borrow_history"
26 | }
27 | 
28 | func (req *RequestForBorrowHistory) Method() string {
29 | 	return http.MethodGet
30 | }
31 | 
32 | func (req *RequestForBorrowHistory) Query() string {
33 | 	return ""
34 | }
35 | 
36 | func (req *RequestForBorrowHistory) Payload() []byte {
37 | 	b, err := json.Marshal(req)
38 | 	if err != nil {
39 | 		return nil
40 | 	}
41 | 	return b
42 | }
43 | 


--------------------------------------------------------------------------------
/rest/private/spotmargin/get-borrow-rates.go:
--------------------------------------------------------------------------------
 1 | package spotmargin
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type ResponseForBorrowRates []BorrowRates
 8 | 
 9 | type BorrowRates struct {
10 | 	Coin     string  `json:"coin"`
11 | 	Estimate float64 `json:"estimate"`
12 | 	Previous float64 `json:"previous"`
13 | }
14 | 
15 | type RequestForBorrowRates struct {
16 | }
17 | 
18 | func (req *RequestForBorrowRates) Path() string {
19 | 	return "/spot_margin/borrow_rates"
20 | }
21 | 
22 | func (req *RequestForBorrowRates) Method() string {
23 | 	return http.MethodGet
24 | }
25 | 
26 | func (req *RequestForBorrowRates) Query() string {
27 | 	return ""
28 | }
29 | 
30 | func (req *RequestForBorrowRates) Payload() []byte {
31 | 	return nil
32 | }
33 | 


--------------------------------------------------------------------------------
/rest/private/spotmargin/get-lending-history.go:
--------------------------------------------------------------------------------
 1 | package spotmargin
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForLendingHistory struct {
10 | 	StartTime int64 `json:"start_time,omitempty"`
11 | 	EndTime   int64 `json:"end_time,omitempty"`
12 | }
13 | 
14 | type ResponseForLendingHistory []LendingHistory
15 | 
16 | type LendingHistory struct {
17 | 	Coin string    `json:"coin"`
18 | 	Cost float64   `json:"cost"`
19 | 	Rate float64   `json:"rate"`
20 | 	Size float64   `json:"size"`
21 | 	Time time.Time `json:"time"`
22 | }
23 | 
24 | func (req *RequestForLendingHistory) Path() string {
25 | 	return "/spot_margin/lending_history"
26 | }
27 | 
28 | func (req *RequestForLendingHistory) Method() string {
29 | 	return http.MethodGet
30 | }
31 | 
32 | func (req *RequestForLendingHistory) Query() string {
33 | 	return ""
34 | }
35 | 
36 | func (req *RequestForLendingHistory) Payload() []byte {
37 | 	b, err := json.Marshal(req)
38 | 	if err != nil {
39 | 		return nil
40 | 	}
41 | 	return b
42 | }
43 | 


--------------------------------------------------------------------------------
/rest/private/spotmargin/get-lending-info.go:
--------------------------------------------------------------------------------
 1 | package spotmargin
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForLendingInfo struct{}
 8 | 
 9 | type ResponseForLendingInfo []LendingInfo
10 | 
11 | type LendingInfo struct {
12 | 	Coin     string  `json:"coin"`
13 | 	Lendable float64 `json:"lendable"`
14 | 	Locked   float64 `json:"locked"`
15 | 	MinRate  float64 `json:"minRate"`
16 | 	Offered  float64 `json:"offered"`
17 | }
18 | 
19 | func (req *RequestForLendingInfo) Path() string {
20 | 	return "/spot_margin/lending_info"
21 | }
22 | 
23 | func (req *RequestForLendingInfo) Method() string {
24 | 	return http.MethodGet
25 | }
26 | 
27 | func (req *RequestForLendingInfo) Query() string {
28 | 	return ""
29 | }
30 | 
31 | func (req *RequestForLendingInfo) Payload() []byte {
32 | 	return nil
33 | }
34 | 


--------------------------------------------------------------------------------
/rest/private/spotmargin/get-lending-rates.go:
--------------------------------------------------------------------------------
 1 | package spotmargin
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForLendingRates struct{}
 8 | 
 9 | type ResponseForLendingRates []LendingRates
10 | 
11 | type LendingRates struct {
12 | 	Coin     string  `json:"coin"`
13 | 	Estimate float64 `json:"estimate"`
14 | 	Previous float64 `json:"previous"`
15 | }
16 | 
17 | func (req *RequestForLendingRates) Path() string {
18 | 	return "/spot_margin/lending_rates"
19 | }
20 | 
21 | func (req *RequestForLendingRates) Method() string {
22 | 	return http.MethodGet
23 | }
24 | 
25 | func (req *RequestForLendingRates) Query() string {
26 | 	return ""
27 | }
28 | 
29 | func (req *RequestForLendingRates) Payload() []byte {
30 | 	return nil
31 | }
32 | 


--------------------------------------------------------------------------------
/rest/private/spotmargin/submit-lending-offer.go:
--------------------------------------------------------------------------------
 1 | package spotmargin
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type ResponseForLendingOffer struct{}
 9 | 
10 | type RequestForLendingOffer struct {
11 | 	Coin string  `json:"coin"`
12 | 	Size float64 `json:"size"`
13 | 	Rate float64 `json:"rate"`
14 | }
15 | 
16 | func (req *RequestForLendingOffer) Path() string {
17 | 	return "/spot_margin/offers"
18 | }
19 | 
20 | func (req *RequestForLendingOffer) Method() string {
21 | 	return http.MethodPost
22 | }
23 | 
24 | func (req *RequestForLendingOffer) Query() string {
25 | 	return ""
26 | }
27 | 
28 | func (req *RequestForLendingOffer) Payload() []byte {
29 | 	b, err := json.Marshal(req)
30 | 	if err != nil {
31 | 		return nil
32 | 	}
33 | 	return b
34 | }
35 | 


--------------------------------------------------------------------------------
/rest/private/subaccount/all.go:
--------------------------------------------------------------------------------
 1 | package subaccount
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForSubAccounts struct {
 8 | }
 9 | 
10 | type ResponseForSubAccounts []SubAccount
11 | 
12 | type SubAccount struct {
13 | 	Nickname  string `json:"nickname"`
14 | 	Deletable bool   `json:"deletable"`
15 | 	Editable  bool   `json:"editable"`
16 | }
17 | 
18 | func (req *RequestForSubAccounts) Path() string {
19 | 	return "/subaccounts"
20 | }
21 | 
22 | func (req *RequestForSubAccounts) Method() string {
23 | 	return http.MethodGet
24 | }
25 | 
26 | func (req *RequestForSubAccounts) Query() string {
27 | 	return ""
28 | }
29 | 
30 | func (req *RequestForSubAccounts) Payload() []byte {
31 | 	return nil
32 | }
33 | 


--------------------------------------------------------------------------------
/rest/private/subaccount/balance.go:
--------------------------------------------------------------------------------
 1 | package subaccount
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForBalanceSubAccount struct {
 9 | 	NickName string
10 | }
11 | 
12 | type ResponseForBalanceSubAccount []Balance
13 | 
14 | type Balance struct {
15 | 	Coin  string  `json:"coin"`
16 | 	Free  float64 `json:"free"`
17 | 	Total float64 `json:"total"`
18 | }
19 | 
20 | func (req *RequestForBalanceSubAccount) Path() string {
21 | 	return fmt.Sprintf("/subaccounts/%s/balances", req.NickName)
22 | }
23 | 
24 | func (req *RequestForBalanceSubAccount) Method() string {
25 | 	return http.MethodGet
26 | }
27 | 
28 | func (req *RequestForBalanceSubAccount) Query() string {
29 | 	return ""
30 | }
31 | 
32 | func (req *RequestForBalanceSubAccount) Payload() []byte {
33 | 	return nil
34 | }
35 | 


--------------------------------------------------------------------------------
/rest/private/subaccount/change.go:
--------------------------------------------------------------------------------
 1 | package subaccount
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForChangeSubAccount struct {
 8 | 	NickName    string `json:"nickname"`
 9 | 	NewNickname string `json:"newNickname"`
10 | }
11 | 
12 | type ResponseForChangeSubAccount string
13 | 
14 | func (req *RequestForChangeSubAccount) Path() string {
15 | 	return "/subaccounts/update_name"
16 | }
17 | 
18 | func (req *RequestForChangeSubAccount) Method() string {
19 | 	return http.MethodPost
20 | }
21 | 
22 | func (req *RequestForChangeSubAccount) Query() string {
23 | 	return ""
24 | }
25 | 
26 | func (req *RequestForChangeSubAccount) Payload() []byte {
27 | 	b, err := json.Marshal(req)
28 | 	if err != nil {
29 | 		return nil
30 | 	}
31 | 	return b
32 | }
33 | 


--------------------------------------------------------------------------------
/rest/private/subaccount/create.go:
--------------------------------------------------------------------------------
 1 | package subaccount
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 
 6 | 	jsoniter "github.com/json-iterator/go"
 7 | )
 8 | 
 9 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
10 | 
11 | type RequestForCreateSubAccount struct {
12 | 	NickName string `json:"nickname"`
13 | }
14 | 
15 | type ResponseForCreateSubAccount SubAccount
16 | 
17 | func (req *RequestForCreateSubAccount) Path() string {
18 | 	return "/subaccounts"
19 | }
20 | 
21 | func (req *RequestForCreateSubAccount) Method() string {
22 | 	return http.MethodPost
23 | }
24 | 
25 | func (req *RequestForCreateSubAccount) Query() string {
26 | 	return ""
27 | }
28 | 
29 | func (req *RequestForCreateSubAccount) Payload() []byte {
30 | 	b, err := json.Marshal(req)
31 | 	if err != nil {
32 | 		return nil
33 | 	}
34 | 	return b
35 | }
36 | 


--------------------------------------------------------------------------------
/rest/private/subaccount/delete.go:
--------------------------------------------------------------------------------
 1 | package subaccount
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForDeleteSubAccount struct {
 8 | 	NickName string `json:"nickname"`
 9 | }
10 | 
11 | type ResponseForDeleteSubAccount string
12 | 
13 | func (req *RequestForDeleteSubAccount) Path() string {
14 | 	return "/subaccounts"
15 | }
16 | 
17 | func (req *RequestForDeleteSubAccount) Method() string {
18 | 	return http.MethodDelete
19 | }
20 | 
21 | func (req *RequestForDeleteSubAccount) Query() string {
22 | 	return ""
23 | }
24 | 
25 | func (req *RequestForDeleteSubAccount) Payload() []byte {
26 | 	b, err := json.Marshal(req)
27 | 	if err != nil {
28 | 		return nil
29 | 	}
30 | 	return b
31 | }
32 | 


--------------------------------------------------------------------------------
/rest/private/subaccount/transfer.go:
--------------------------------------------------------------------------------
 1 | package subaccount
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForTransferSubAccount struct {
 9 | 	Coin string  `json:"coin"`
10 | 	Size float64 `json:"size"`
11 | 	// out account name
12 | 	Source string `json:"source"`
13 | 	// in account name
14 | 	Destination string `json:"destination"`
15 | }
16 | 
17 | type ResponseForTransferSubAccount struct {
18 | 	ID     int    `json:"id"`
19 | 	Coin   string `json:"coin"`
20 | 	Status string `json:"status"`
21 | 	Notes  string `json:"notes"`
22 | 
23 | 	Size float64 `json:"size"`
24 | 
25 | 	Time time.Time `json:"time"`
26 | }
27 | 
28 | func (req *RequestForTransferSubAccount) Path() string {
29 | 	return "/subaccounts/transfer"
30 | }
31 | 
32 | func (req *RequestForTransferSubAccount) Method() string {
33 | 	return http.MethodPost
34 | }
35 | 
36 | func (req *RequestForTransferSubAccount) Query() string {
37 | 	return ""
38 | }
39 | 
40 | func (req *RequestForTransferSubAccount) Payload() []byte {
41 | 	b, err := json.Marshal(req)
42 | 	if err != nil {
43 | 		return nil
44 | 	}
45 | 	return b
46 | }
47 | 


--------------------------------------------------------------------------------
/rest/private/wallet/balances-all.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForBalancesAll struct {
 8 | }
 9 | 
10 | type ResponseForBalancesAll map[string][]Balance
11 | 
12 | func (req *RequestForBalancesAll) Path() string {
13 | 	return "/wallet/all_balances"
14 | }
15 | 
16 | func (req *RequestForBalancesAll) Method() string {
17 | 	return http.MethodGet
18 | }
19 | 
20 | func (req *RequestForBalancesAll) Query() string {
21 | 	return ""
22 | }
23 | 
24 | func (req *RequestForBalancesAll) Payload() []byte {
25 | 	return nil
26 | }
27 | 


--------------------------------------------------------------------------------
/rest/private/wallet/balances.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | )
 6 | 
 7 | type RequestForBalances struct {
 8 | }
 9 | 
10 | type ResponseForBalances []Balance
11 | 
12 | type Balance struct {
13 | 	Coin                   string  `json:"coin"`
14 | 	Free                   float64 `json:"free"`
15 | 	Total                  float64 `json:"total"`
16 | 	USDValue               float64 `json:"usdvalue"`
17 | 	StopBorrow             float64 `json:"spotBorrow"`
18 | 	AvailableWithoutBorrow float64 `json:"availableWithoutBorrow"`
19 | }
20 | 
21 | func (req *RequestForBalances) Path() string {
22 | 	return "/wallet/balances"
23 | }
24 | 
25 | func (req *RequestForBalances) Method() string {
26 | 	return http.MethodGet
27 | }
28 | 
29 | func (req *RequestForBalances) Query() string {
30 | 	return ""
31 | }
32 | 
33 | func (req *RequestForBalances) Payload() []byte {
34 | 	return nil
35 | }
36 | 


--------------------------------------------------------------------------------
/rest/private/wallet/coins.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 
 6 | 	jsoniter "github.com/json-iterator/go"
 7 | )
 8 | 
 9 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
10 | 
11 | type RequestForCoins struct {
12 | }
13 | 
14 | type ResponseForCoins []Coin
15 | 
16 | type Coin struct {
17 | 	ID   string `json:"id"`
18 | 	Name string `json:"name"`
19 | 
20 | 	CanDeposit  bool `json:"canDeposit"`
21 | 	CanWithdraw bool `json:"canWithdraw"`
22 | 	HasTag      bool `json:"hasTag"`
23 | 
24 | 	Collateral               bool     `json:"collateral"`
25 | 	UsdFungible              bool     `json:"usdFungible"`
26 | 	IsEtf                    bool     `json:"isEtf"`
27 | 	IsToken                  bool     `json:"isToken"`
28 | 	Hidden                   bool     `json:"hidden"`
29 | 	CanConvert               bool     `json:"canConvert"`
30 | 	CollateralWeight         float64  `json:"collateralWeight"`
31 | 	Fiat                     bool     `json:"fiat"`
32 | 	Methods                  []string `json:"methods"`
33 | 	Erc20Contract            string   `json:"erc20Contract"`
34 | 	Bep2Asset                string   `json:"bep2Asset"`
35 | 	Trc20Contract            string   `json:"trc20Contract"`
36 | 	SplMint                  string   `json:"splMint"`
37 | 	CreditTo                 string   `json:"creditTo"`
38 | 	SpotMargin               bool     `json:"spotMargin"`
39 | 	NftQuoteCurrencyEligible bool     `json:"nftQuoteCurrencyEligible"`
40 | 	IndexPrice               float64  `json:"indexPrice"`
41 | }
42 | 
43 | func (req *RequestForCoins) Path() string {
44 | 	return "/wallet/coins"
45 | }
46 | 
47 | func (req *RequestForCoins) Method() string {
48 | 	return http.MethodGet
49 | }
50 | 
51 | func (req *RequestForCoins) Query() string {
52 | 	return ""
53 | }
54 | 
55 | func (req *RequestForCoins) Payload() []byte {
56 | 	return nil
57 | }
58 | 


--------------------------------------------------------------------------------
/rest/private/wallet/deposit-address.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | type RequestForDepositAddress struct {
 9 | 	Coin    string `json:"-"`
10 | 	Methods string `json:"-"`
11 | }
12 | 
13 | type ResponseForDepositAddress struct {
14 | 	Address string `json:"address"`
15 | 	Tag     string `json:"tag"`
16 | }
17 | 
18 | func (req *RequestForDepositAddress) Path() string {
19 | 	return fmt.Sprintf("/wallet/deposit_address/%s", req.Coin)
20 | }
21 | 
22 | func (req *RequestForDepositAddress) Method() string {
23 | 	return http.MethodGet
24 | }
25 | 
26 | func (req *RequestForDepositAddress) Query() string {
27 | 	if req.Methods != "" {
28 | 		return fmt.Sprintf("method=%s", req.Methods)
29 | 	}
30 | 	return ""
31 | }
32 | 
33 | func (req *RequestForDepositAddress) Payload() []byte {
34 | 	return nil
35 | }
36 | 


--------------------------------------------------------------------------------
/rest/private/wallet/deposit-histories.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForDepositHistories struct {
 9 | 	StartTime time.Time `url:"start_time,omitempty"`
10 | 	EndTime   time.Time `url:"end_time,omitempty"`
11 | }
12 | 
13 | type ResponseForDepositHistories []History
14 | 
15 | type History struct {
16 | 	Coin   string `json:"coin"`
17 | 	Status string `json:"status"`
18 | 	Txid   string `json:"txid"`
19 | 
20 | 	Size float64 `json:"size"`
21 | 	Fee  float64 `json:"fee"`
22 | 
23 | 	Confirmations int `json:"confirmations"`
24 | 	ID            int `json:"id"`
25 | 
26 | 	ConfirmedTime time.Time `json:"confirmedTime"`
27 | 	SentTime      time.Time `json:"sentTime"`
28 | 	Time          time.Time `json:"time"`
29 | }
30 | 
31 | func (req *RequestForDepositHistories) Path() string {
32 | 	return "/wallet/deposits"
33 | }
34 | 
35 | func (req *RequestForDepositHistories) Method() string {
36 | 	return http.MethodGet
37 | }
38 | 
39 | func (req *RequestForDepositHistories) Query() string {
40 | 	return ""
41 | }
42 | 
43 | func (req *RequestForDepositHistories) Payload() []byte {
44 | 	return nil
45 | }
46 | 


--------------------------------------------------------------------------------
/rest/private/wallet/withdraw-histories.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForWithdrawHistories struct {
 9 | }
10 | 
11 | type ResponseForWithdrawHistories []Withdraw
12 | 
13 | type Withdraw struct {
14 | 	Coin    string `json:"coin"`
15 | 	Address string `json:"address"`
16 | 	Tag     string `json:"tag"`
17 | 	Status  string `json:"status"`
18 | 	Txid    string `json:"txid"`
19 | 	Method  string `json:"method"`
20 | 	
21 | 	Fee  float64 `json:"fee"`
22 | 	Size float64 `json:"size"`
23 | 
24 | 	Time time.Time `json:"time"`
25 | 
26 | 	ID int `json:"id"`
27 | }
28 | 
29 | func (req *RequestForWithdrawHistories) Path() string {
30 | 	return "/wallet/withdrawals"
31 | }
32 | 
33 | func (req *RequestForWithdrawHistories) Method() string {
34 | 	return http.MethodGet
35 | }
36 | 
37 | func (req *RequestForWithdrawHistories) Query() string {
38 | 	return ""
39 | }
40 | 
41 | func (req *RequestForWithdrawHistories) Payload() []byte {
42 | 	return nil
43 | }
44 | 


--------------------------------------------------------------------------------
/rest/private/wallet/withdraw.go:
--------------------------------------------------------------------------------
 1 | package wallet
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForWithdraw struct {
 9 | 	Coin    string  `json:"coin"`
10 | 	Size    float64 `json:"size"`
11 | 	Address string  `json:"address"`
12 | 	// Optionals
13 | 	Tag      string `json:"tag,omitempty"`
14 | 	Methods  string `json:"method,omitempty"`
15 | 	Password string `json:"password,omitempty"`
16 | 	Code     string `json:"code,omitempty"`
17 | }
18 | 
19 | type ResponseForWithdraw struct {
20 | 	Coin    string    `json:"coin,omitempty"`
21 | 	Address string    `json:"address,omitempty"`
22 | 	Tag     string    `json:"tag,omitempty"`
23 | 	Fee     float64   `json:"fee,omitempty"`
24 | 	ID      int64     `json:"id,omitempty"`
25 | 	Size    float64   `json:"size,omitempty"`
26 | 	Status  string    `json:"status,omitempty"` // one of "requested", "processing", "complete", or "cancelled"
27 | 	Time    time.Time `json:"time,omitempty"`
28 | 	TxID    string    `json:"txid,omitempty"`
29 | }
30 | 
31 | func (req *RequestForWithdraw) Path() string {
32 | 	return "/wallet/withdrawals"
33 | }
34 | 
35 | func (req *RequestForWithdraw) Method() string {
36 | 	return http.MethodPost
37 | }
38 | 
39 | func (req *RequestForWithdraw) Query() string {
40 | 	return ""
41 | }
42 | 
43 | func (req *RequestForWithdraw) Payload() []byte {
44 | 	b, err := json.Marshal(req)
45 | 	if err != nil {
46 | 		return nil
47 | 	}
48 | 	return b
49 | }
50 | 


--------------------------------------------------------------------------------
/rest/public/futures/future.go:
--------------------------------------------------------------------------------
 1 | package futures
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForFuture struct {
10 | 	ProductCode string `url:"-"`
11 | }
12 | 
13 | type ResponseForFuture Future
14 | 
15 | type Future struct {
16 | 	Type       string `json:"type"`
17 | 	Name       string `json:"name"`
18 | 	Underlying string `json:"underlying"`
19 | 
20 | 	Index     float64 `json:"index"`
21 | 	Last      float64 `json:"last"`
22 | 	Mark      float64 `json:"mark"`
23 | 	Ask       float64 `json:"ask"`
24 | 	Bid       float64 `json:"bid"`
25 | 	Change1H  float64 `json:"change1h"`
26 | 	Change24H float64 `json:"change24h"`
27 | 
28 | 	PriceIncrement float64 `json:"priceIncrement"`
29 | 	SizeIncrement  float64 `json:"sizeIncrement"`
30 | 
31 | 	UpperBound float64 `json:"upperBound"`
32 | 	LowerBound float64 `json:"lowerBound"`
33 | 
34 | 	Description string    `json:"description"`
35 | 	Expiry      time.Time `json:"expiry"`
36 | 	Enabled     bool      `json:"enabled"`
37 | 	Expired     bool      `json:"expired"`
38 | 	Perpetual   bool      `json:"perpetual"`
39 | 	PostOnly    bool      `json:"postOnly"`
40 | }
41 | 
42 | func (req *RequestForFuture) Path() string {
43 | 	return fmt.Sprintf("/futures/%s", req.ProductCode)
44 | }
45 | 
46 | func (req *RequestForFuture) Method() string {
47 | 	return http.MethodGet
48 | }
49 | 
50 | func (req *RequestForFuture) Query() string {
51 | 	return ""
52 | }
53 | 
54 | func (req *RequestForFuture) Payload() []byte {
55 | 	return nil
56 | }
57 | 


--------------------------------------------------------------------------------
/rest/public/futures/list.go:
--------------------------------------------------------------------------------
 1 | package futures
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | )
 7 | 
 8 | type RequestForFutures struct {
 9 | }
10 | 
11 | type ResponseForFutures []FutureForList
12 | 
13 | type FutureForList struct {
14 | 	Type       string `json:"type"`
15 | 	Name       string `json:"name"`
16 | 	Underlying string `json:"underlying"`
17 | 
18 | 	Index        float64 `json:"index"`
19 | 	Mark         float64 `json:"mark"`
20 | 	Last         float64 `json:"last"`
21 | 	Ask          float64 `json:"ask"`
22 | 	Bid          float64 `json:"bid"`
23 | 	Change1H     float64 `json:"change1h"`
24 | 	Change24H    float64 `json:"change24h"`
25 | 	ChangeBod    float64 `json:"changeBod"`
26 | 	Volume       float64 `json:"volume"`
27 | 	VolumeUsd24H float64 `json:"volumeUsd24h"`
28 | 
29 | 	OpenInterestUsd     float64 `json:"openInterestUsd"`
30 | 	PositionLimitWeight float64 `json:"positionLimitWeight"`
31 | 
32 | 	ImfFactor float64 `json:"imfFactor"`
33 |         ImfWeight float64 `json:"imfWeight"`
34 |         MmfWeight float64 `json:"mmfWeight"`
35 | 
36 | 	PriceIncrement float64 `json:"priceIncrement"`
37 | 	SizeIncrement  float64 `json:"sizeIncrement"`
38 | 
39 | 	UpperBound float64 `json:"upperBound"`
40 | 	LowerBound float64 `json:"lowerBound"`
41 | 
42 | 	Description string    `json:"description"`
43 | 	Expiry      time.Time `json:"expiry"`
44 | 	Enabled     bool      `json:"enabled"`
45 | 	Expired     bool      `json:"expired"`
46 | 	Perpetual   bool      `json:"perpetual"`
47 | 	PostOnly    bool      `json:"postOnly"`
48 | }
49 | 
50 | func (req *RequestForFutures) Path() string {
51 | 	return "/futures"
52 | }
53 | 
54 | func (req *RequestForFutures) Method() string {
55 | 	return http.MethodGet
56 | }
57 | 
58 | func (req *RequestForFutures) Query() string {
59 | 	return ""
60 | }
61 | 
62 | func (req *RequestForFutures) Payload() []byte {
63 | 	return nil
64 | }
65 | 
66 | func (futures ResponseForFutures) Products() []string {
67 | 	list := make([]string, len(futures))
68 | 	for i := range futures {
69 | 		list[i] = futures[i].Name
70 | 	}
71 | 	return list
72 | }
73 | 
74 | // Sort by alphabetical order (by Name)
75 | func (a ResponseForFutures) Len() int           { return len(a) }
76 | func (a ResponseForFutures) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
77 | func (a ResponseForFutures) Less(i, j int) bool { return a[i].Name < a[j].Name }
78 | 


--------------------------------------------------------------------------------
/rest/public/futures/rates.go:
--------------------------------------------------------------------------------
 1 | package futures
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"time"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | type RequestForRates struct {
11 | 	ProductCode string `url:"future,omitempty"`
12 | 	Start       int64  `url:"start_time,omitempty"`
13 | 	End         int64  `url:"end_time,omitempty"`
14 | }
15 | 
16 | type ResponseForRates []Rate
17 | 
18 | type ByDate []Rate
19 | 
20 | func (a ByDate) Len() int           { return len(a) }
21 | func (a ByDate) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
22 | func (a ByDate) Less(i, j int) bool { return a[i].Time.Before(a[j].Time) }
23 | 
24 | type Rate struct {
25 | 	Future string    `json:"future"`
26 | 	Rate   float64   `json:"rate"`
27 | 	Time   time.Time `json:"time"`
28 | }
29 | 
30 | // Example : https://ftx.com/api/funding_rates?future=DEFI-PERP&start_time=1597687200&end_time=1597773600
31 | func (req *RequestForRates) Path() string {
32 | 	return "/funding_rates"
33 | }
34 | 
35 | func (req *RequestForRates) Method() string {
36 | 	return http.MethodGet
37 | }
38 | 
39 | func (req *RequestForRates) Query() string {
40 | 	value, _ := query.Values(req)
41 | 	return value.Encode()
42 | }
43 | 
44 | func (req *RequestForRates) Payload() []byte {
45 | 	return nil
46 | }
47 | 
48 | func (a ResponseForRates) Len() int           { return len(a) }
49 | func (a ResponseForRates) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
50 | func (a ResponseForRates) Less(i, j int) bool { return a[i].Rate < a[j].Rate }
51 | 


--------------------------------------------------------------------------------
/rest/public/futures/stats.go:
--------------------------------------------------------------------------------
 1 | package futures
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | )
 8 | 
 9 | type RequestForStats struct {
10 | 	ProductCode string `url:"-"`
11 | }
12 | 
13 | type ResponseForStats Stats
14 | 
15 | type StatsList []Stats
16 | type Stats struct {
17 | 	Name                     string  `json:"name,omitempty"`
18 | 	Volume                   float64 `json:"volume"`
19 | 	NextFundingRate          float64 `json:"nextFundingRate"`
20 | 	ExpirationPrice          float64 `json:"expirationPrice"`
21 | 	PredictedExpirationPrice float64 `json:"predictedExpirationPrice"`
22 | 	StrikePrice              float64 `json:"strikePrice"`
23 | 	OpenInterest             float64 `json:"openInterest"`
24 | 
25 | 	NextFundingTime time.Time `json:"nextFundingTime"`
26 | }
27 | 
28 | func (req *RequestForStats) Path() string {
29 | 	return fmt.Sprintf("/futures/%s/stats", req.ProductCode)
30 | }
31 | 
32 | func (req *RequestForStats) Method() string {
33 | 	return http.MethodGet
34 | }
35 | 
36 | func (req *RequestForStats) Query() string {
37 | 	return ""
38 | }
39 | 
40 | func (req *RequestForStats) Payload() []byte {
41 | 	return nil
42 | }
43 | 
44 | func (a StatsList) Len() int      { return len(a) }
45 | func (a StatsList) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
46 | func (a StatsList) Less(i, j int) bool {
47 | 	return a[i].NextFundingRate < a[j].NextFundingRate
48 | }
49 | 


--------------------------------------------------------------------------------
/rest/public/markets/candles.go:
--------------------------------------------------------------------------------
 1 | package markets
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | 
 8 | 	"github.com/google/go-querystring/query"
 9 | )
10 | 
11 | // query
12 | // ?resolution={resolution}&limit={limit}&start_time={start_time}&end_time={end_time}
13 | type RequestForCandles struct {
14 | 	ProductCode string `url:"-"`
15 | 	// Resolution is sec length, window length in seconds. options: 15, 60(1m), 300(5m), 900(15m), 3600(60m), 14400(4h), 86400(1D)
16 | 	Resolution int   `url:"resolution"`
17 | 	Start      int64 `url:"start_time,omitempty"`
18 | 	End        int64 `url:"end_time,omitempty"`
19 | }
20 | 
21 | type ResponseForCandles []Candle
22 | 
23 | type Candle struct {
24 | 	Close     float64   `json:"close"`
25 | 	High      float64   `json:"high"`
26 | 	Low       float64   `json:"low"`
27 | 	Open      float64   `json:"open"`
28 | 	Volume    float64   `json:"volume"`
29 | 	StartTime time.Time `json:"startTime"`
30 | }
31 | 
32 | func (req *RequestForCandles) Path() string {
33 | 	return fmt.Sprintf("/markets/%s/candles", req.ProductCode)
34 | }
35 | 
36 | func (req *RequestForCandles) Method() string {
37 | 	return http.MethodGet
38 | }
39 | 
40 | func (req *RequestForCandles) Query() string {
41 | 	values, _ := query.Values(req)
42 | 	return values.Encode()
43 | }
44 | 
45 | func (req *RequestForCandles) Payload() []byte {
46 | 	return nil
47 | }
48 | 
49 | // Sort by timestamp
50 | func (a ResponseForCandles) Len() int           { return len(a) }
51 | func (a ResponseForCandles) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
52 | func (a ResponseForCandles) Less(i, j int) bool { return a[i].StartTime.Before(a[j].StartTime) }
53 | 


--------------------------------------------------------------------------------
/rest/public/markets/market.go:
--------------------------------------------------------------------------------
  1 | package markets
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"math"
  6 | 	"net/http"
  7 | 	"sort"
  8 | 
  9 | 	"github.com/dustin/go-humanize"
 10 | )
 11 | 
 12 | // RequestForMarkets arg productcode can be blank
 13 | type RequestForMarkets struct {
 14 | 	ProductCode string `url:"-"`
 15 | }
 16 | 
 17 | type ResponseForMarkets []Market
 18 | 
 19 | type Market struct {
 20 | 	Type          string `json:"type"`
 21 | 	Name          string `json:"name"`
 22 | 	BaseCurrency  string `json:"baseCurrency"`
 23 | 	QuoteCurrency string `json:"quoteCurrency"`
 24 | 	Underlying    string `json:"underlying"`
 25 | 
 26 | 	Last           float64 `json:"last"`
 27 | 	Ask            float64 `json:"ask"`
 28 | 	Bid            float64 `json:"bid"`
 29 | 	Price          float64 `json:"price"`
 30 | 	PriceIncrement float64 `json:"priceIncrement"`
 31 | 	MinProvideSize float64 `json:"minProvideSize"`
 32 | 
 33 | 	SizeIncrement       float64 `json:"sizeIncrement"`
 34 | 	ChangeBod           float64 `json:"changeBod"`
 35 | 	Change1H            float64 `json:"change1h"`
 36 | 	Change24H           float64 `json:"change24h"`
 37 | 	QuoteVolume24H      float64 `json:"quoteVolume24h"`
 38 | 	VolumeUsd24H        float64 `json:"volumeUsd24h"`
 39 | 	LargeOrderThreshold float64 `json:"largeOrderThreshold"`
 40 | 
 41 | 	Enabled               bool `json:"enabled"`
 42 | 	PostOnly              bool `json:"postOnly"`
 43 | 	Restricted            bool `json:"restricted"`
 44 | 	HighLeverageFeeExempt bool `json:"highLeverageFeeExempt"`
 45 | }
 46 | 
 47 | func (req *RequestForMarkets) Path() string {
 48 | 	if req.ProductCode != "" {
 49 | 		// fmt.Println("/markets/%s", req.ProductCode)
 50 | 		return fmt.Sprintf("/markets/%s", req.ProductCode)
 51 | 	}
 52 | 	return "/markets"
 53 | }
 54 | 
 55 | func (req *RequestForMarkets) Method() string {
 56 | 	return http.MethodGet
 57 | }
 58 | 
 59 | func (req *RequestForMarkets) Query() string {
 60 | 	return ""
 61 | }
 62 | 
 63 | func (req *RequestForMarkets) Payload() []byte {
 64 | 	return nil
 65 | }
 66 | 
 67 | func (markets ResponseForMarkets) List() []string {
 68 | 	list := make([]string, len(markets)+1)
 69 | 	list[0] = fmt.Sprint("TYPE	NAME	BASE	QUOTE	UNDER")
 70 | 	for i := range markets {
 71 | 		list[i+1] = fmt.Sprintf("%s	%s	%s	%s	%s", markets[i].Type, markets[i].Name, markets[i].BaseCurrency, markets[i].QuoteCurrency, markets[i].Underlying)
 72 | 	}
 73 | 	sort.Strings(list)
 74 | 	return list
 75 | }
 76 | 
 77 | const (
 78 | 	ALL = iota
 79 | 	BASESPOT
 80 | 	BASEFUTURE
 81 | )
 82 | 
 83 | // Ranking return USD volume in 24hours.
 84 | func (markets ResponseForMarkets) Ranking(base int) []string {
 85 | 	var list []string
 86 | 
 87 | 	sort.Sort(sort.Reverse(markets))
 88 | 
 89 | 	switch base {
 90 | 	case BASESPOT:
 91 | 		for i := range markets {
 92 | 			if markets[i].Type != "spot" {
 93 | 				continue
 94 | 			}
 95 | 			list = append(list, fmt.Sprintf("$%s	%s", humanize.Commaf(math.Round(markets[i].VolumeUsd24H)), markets[i].Name))
 96 | 		}
 97 | 
 98 | 	case BASEFUTURE:
 99 | 		for i := range markets {
100 | 			if markets[i].Type != "future" {
101 | 				continue
102 | 			}
103 | 			list = append(list, fmt.Sprintf("$%s	%s", humanize.Commaf(math.Round(markets[i].VolumeUsd24H)), markets[i].Name))
104 | 		}
105 | 
106 | 	default:
107 | 		ll := make([]string, len(markets))
108 | 		for i := range markets {
109 | 			ll[i] = fmt.Sprintf("$%s	%s", humanize.Commaf(math.Round(markets[i].VolumeUsd24H)), markets[i].Name)
110 | 		}
111 | 		list = ll
112 | 	}
113 | 
114 | 	return list
115 | }
116 | 
117 | func (a ResponseForMarkets) Len() int           { return len(a) }
118 | func (a ResponseForMarkets) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
119 | func (a ResponseForMarkets) Less(i, j int) bool { return a[i].VolumeUsd24H < a[j].VolumeUsd24H }
120 | 


--------------------------------------------------------------------------------
/rest/public/markets/orderbook.go:
--------------------------------------------------------------------------------
 1 | package markets
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 
 7 | 	"github.com/google/go-querystring/query"
 8 | )
 9 | 
10 | // query
11 | // ?depth={depth}
12 | // max 100, default 20
13 | type RequestForOrderbook struct {
14 | 	ProductCode string `url:"-"`
15 | 	Depth       int    `url:"depth,omitempty"`
16 | }
17 | 
18 | type ResponseForOrderbook Orderbook
19 | 
20 | type Orderbook struct {
21 | 	Asks [][]float64 `json:"asks"`
22 | 	Bids [][]float64 `json:"bids"`
23 | }
24 | 
25 | func (req *RequestForOrderbook) Path() string {
26 | 	return fmt.Sprintf("/markets/%s/orderbook", req.ProductCode)
27 | }
28 | 
29 | func (req *RequestForOrderbook) Method() string {
30 | 	return http.MethodGet
31 | }
32 | 
33 | func (req *RequestForOrderbook) Query() string {
34 | 	if req.Depth == 0 {
35 | 		req.Depth = 20
36 | 	}
37 | 	values, _ := query.Values(req)
38 | 	return values.Encode()
39 | }
40 | 
41 | func (req *RequestForOrderbook) Payload() []byte {
42 | 	return nil
43 | }
44 | 


--------------------------------------------------------------------------------
/rest/public/markets/trades.go:
--------------------------------------------------------------------------------
 1 | package markets
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"time"
 7 | 
 8 | 	"github.com/go-numb/go-ftx/types"
 9 | 	"github.com/google/go-querystring/query"
10 | )
11 | 
12 | // query
13 | // ?limit={limit}&start_time={start_time}&end_time={end_time}
14 | type RequestForTrades struct {
15 | 	ProductCode string `url:"-"`
16 | 	Limit       int    `url:"limit,omitempty"`
17 | 	Start       int64  `url:"start_time,omitempty"`
18 | 	End         int64  `url:"end_time,omitempty"`
19 | }
20 | 
21 | type ResponseForTrades []Trade
22 | 
23 | type Trade struct {
24 | 	ID          int64     `json:"id"`
25 | 	Liquidation bool      `json:"liquidation"`
26 | 	Price       float64   `json:"price"`
27 | 	Side        string    `json:"side"`
28 | 	Size        float64   `json:"size"`
29 | 	Time        time.Time `json:"time"`
30 | }
31 | 
32 | type Ticker struct {
33 | 	Bid     float64       `json:"bid"`
34 | 	Ask     float64       `json:"ask"`
35 | 	BidSize float64       `json:"bidSize"`
36 | 	AskSize float64       `json:"askSize"`
37 | 	Last    float64       `json:"last"`
38 | 	Time    types.FtxTime `json:"time"`
39 | }
40 | 
41 | // This syntax works to request historical prices
42 | // https://ftx.com/api/markets/DEFI-PERP/trades?&start_time=1597687200&end_time=1597773600
43 | func (req *RequestForTrades) Path() string {
44 | 	return fmt.Sprintf("/markets/%s/trades", req.ProductCode)
45 | }
46 | 
47 | func (req *RequestForTrades) Method() string {
48 | 	return http.MethodGet
49 | }
50 | 
51 | func (req *RequestForTrades) Query() string {
52 | 	values, _ := query.Values(req)
53 | 	return values.Encode()
54 | }
55 | 
56 | func (req *RequestForTrades) Payload() []byte {
57 | 	// b, err := json.Marshal(req)
58 | 	// if err != nil {
59 | 	// 	return nil
60 | 	// }
61 | 	return nil
62 | }
63 | 


--------------------------------------------------------------------------------
/rest/request-lev-options.go:
--------------------------------------------------------------------------------
  1 | package rest
  2 | 
  3 | import (
  4 | 	"github.com/go-numb/go-ftx/rest/private/leveraged"
  5 | 	"github.com/go-numb/go-ftx/rest/private/options"
  6 | )
  7 | 
  8 | /*
  9 | 	# Leveraged Tokens
 10 | */
 11 | 
 12 | func (p *Client) LvTokens(req *leveraged.RequestForLvTokens) (*leveraged.ResponseForLvTokens, error) {
 13 | 	results := new(leveraged.ResponseForLvTokens)
 14 | 	if err := p.request(req, results); err != nil {
 15 | 		return nil, err
 16 | 	}
 17 | 	return results, nil
 18 | }
 19 | 
 20 | func (p *Client) LvToken(req *leveraged.RequestForLvToken) (*leveraged.ResponseForLvToken, error) {
 21 | 	results := new(leveraged.ResponseForLvToken)
 22 | 	if err := p.request(req, results); err != nil {
 23 | 		return nil, err
 24 | 	}
 25 | 	return results, nil
 26 | }
 27 | 
 28 | func (p *Client) CreatedLvTokens(req *leveraged.RequestForCreatedLvTokens) (*leveraged.ResponseForCreatedLvTokens, error) {
 29 | 	results := new(leveraged.ResponseForCreatedLvTokens)
 30 | 	if err := p.request(req, results); err != nil {
 31 | 		return nil, err
 32 | 	}
 33 | 	return results, nil
 34 | }
 35 | 
 36 | func (p *Client) CreatedLvToken(req *leveraged.RequestForCreatedLvToken) (*leveraged.ResponseForCreatedLvToken, error) {
 37 | 	results := new(leveraged.ResponseForCreatedLvToken)
 38 | 	if err := p.request(req, results); err != nil {
 39 | 		return nil, err
 40 | 	}
 41 | 	return results, nil
 42 | }
 43 | 
 44 | func (p *Client) RedemptionLvTokens(req *leveraged.RequestForRedemptionLvTokens) (*leveraged.ResponseForRedemptionLvTokens, error) {
 45 | 	results := new(leveraged.ResponseForRedemptionLvTokens)
 46 | 	if err := p.request(req, results); err != nil {
 47 | 		return nil, err
 48 | 	}
 49 | 	return results, nil
 50 | }
 51 | 
 52 | func (p *Client) RedemptionLvToken(req *leveraged.RequestForRedemptionLvToken) (*leveraged.ResponseForRedemptionLvToken, error) {
 53 | 	results := new(leveraged.ResponseForRedemptionLvToken)
 54 | 	if err := p.request(req, results); err != nil {
 55 | 		return nil, err
 56 | 	}
 57 | 	return results, nil
 58 | }
 59 | 
 60 | func (p *Client) LvBalances(req *leveraged.RequestForLvBalances) (*leveraged.ResponseForLvBalances, error) {
 61 | 	results := new(leveraged.ResponseForLvBalances)
 62 | 	if err := p.request(req, results); err != nil {
 63 | 		return nil, err
 64 | 	}
 65 | 	return results, nil
 66 | }
 67 | 
 68 | /*
 69 | 	# Opstions
 70 | */
 71 | 
 72 | func (p *Client) OpQuoteRequests(req *options.RequestForOpQuoteRequests) (*options.ResponseForOpQuoteRequests, error) {
 73 | 	results := new(options.ResponseForOpQuoteRequests)
 74 | 	if err := p.request(req, results); err != nil {
 75 | 		return nil, err
 76 | 	}
 77 | 	return results, nil
 78 | }
 79 | 
 80 | func (p *Client) MyOpQuoteRequests(req *options.RequestForMyOpQuoteRequests) (*options.ResponseForMyOpQuoteRequests, error) {
 81 | 	results := new(options.ResponseForMyOpQuoteRequests)
 82 | 	if err := p.request(req, results); err != nil {
 83 | 		return nil, err
 84 | 	}
 85 | 	return results, nil
 86 | }
 87 | 
 88 | func (p *Client) MyOpQuoteRequest(req *options.RequestForMyOpQuoteRequest) (*options.ResponseForMyOpQuoteRequest, error) {
 89 | 	results := new(options.ResponseForMyOpQuoteRequest)
 90 | 	if err := p.request(req, results); err != nil {
 91 | 		return nil, err
 92 | 	}
 93 | 	return results, nil
 94 | }
 95 | 
 96 | func (p *Client) CreateOpQuoteRequest(req *options.RequestForCreateOpQuoteRequest) (*options.ResponseForCreateOpQuoteRequest, error) {
 97 | 	results := new(options.ResponseForCreateOpQuoteRequest)
 98 | 	if err := p.request(req, results); err != nil {
 99 | 		return nil, err
100 | 	}
101 | 	return results, nil
102 | }
103 | 
104 | func (p *Client) ModifyOpQuoteRequest(req *options.RequestForModifyOpQuoteRequest) (*options.ResponseForModifyOpQuoteRequest, error) {
105 | 	results := new(options.ResponseForModifyOpQuoteRequest)
106 | 	if err := p.request(req, results); err != nil {
107 | 		return nil, err
108 | 	}
109 | 	return results, nil
110 | }
111 | 
112 | func (p *Client) CancelOpQuoteRequest(req *options.RequestForCancelOpQuoteRequest) (*options.ResponseForCancelOpQuoteRequest, error) {
113 | 	results := new(options.ResponseForCancelOpQuoteRequest)
114 | 	if err := p.request(req, results); err != nil {
115 | 		return nil, err
116 | 	}
117 | 	return results, nil
118 | }
119 | 
120 | func (p *Client) MyOpQuotes(req *options.RequestForMyOpQuotes) (*options.ResponseForMyOpQuotes, error) {
121 | 	results := new(options.ResponseForMyOpQuotes)
122 | 	if err := p.request(req, results); err != nil {
123 | 		return nil, err
124 | 	}
125 | 	return results, nil
126 | }
127 | 
128 | // // Create Quote is Modify Quote. document is incorrect?
129 | // func (p *Client) CreateOpQuote(req *options.RequestForCreateOpQuote) (*options.ResponseForCreateOpQuote, error) {
130 | // 	results := new(options.ResponseForCreateOpQuote)
131 | // 	if err := p.request(req, results); err != nil {
132 | // 		return nil, err
133 | // 	}
134 | // 	return results, nil
135 | // }
136 | 
137 | func (p *Client) CancelOpQuote(req *options.RequestForCancelOpQuote) (*options.ResponseForCancelOpQuote, error) {
138 | 	results := new(options.ResponseForCancelOpQuote)
139 | 	if err := p.request(req, results); err != nil {
140 | 		return nil, err
141 | 	}
142 | 	return results, nil
143 | }
144 | 
145 | func (p *Client) AcceptOpQuote(req *options.RequestForAcceptOpQuote) (*options.ResponseForAcceptOpQuote, error) {
146 | 	results := new(options.ResponseForAcceptOpQuote)
147 | 	if err := p.request(req, results); err != nil {
148 | 		return nil, err
149 | 	}
150 | 	return results, nil
151 | }
152 | 
153 | func (p *Client) OpPositions(req *options.RequestForOpPositions) (*options.ResponseForOpPositions, error) {
154 | 	results := new(options.ResponseForOpPositions)
155 | 	if err := p.request(req, results); err != nil {
156 | 		return nil, err
157 | 	}
158 | 	return results, nil
159 | }
160 | 
161 | func (p *Client) OpTrades(req *options.RequestForOpTrades) (*options.ResponseForOpTrades, error) {
162 | 	results := new(options.ResponseForOpTrades)
163 | 	if err := p.request(req, results); err != nil {
164 | 		return nil, err
165 | 	}
166 | 	return results, nil
167 | }
168 | 
169 | func (p *Client) OpFills(req *options.RequestForOpFills) (*options.ResponseForOpFills, error) {
170 | 	results := new(options.ResponseForOpFills)
171 | 	if err := p.request(req, results); err != nil {
172 | 		return nil, err
173 | 	}
174 | 	return results, nil
175 | }
176 | 


--------------------------------------------------------------------------------
/rest/request-lev-options_test.go:
--------------------------------------------------------------------------------
  1 | package rest_test
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"os"
  6 | 	"strings"
  7 | 	"testing"
  8 | 	"time"
  9 | 
 10 | 	"github.com/go-numb/go-ftx/auth"
 11 | 	"github.com/go-numb/go-ftx/types"
 12 | 
 13 | 	"github.com/stretchr/testify/assert"
 14 | 
 15 | 	"github.com/go-numb/go-ftx/rest"
 16 | 	"github.com/go-numb/go-ftx/rest/private/leveraged"
 17 | 	"github.com/go-numb/go-ftx/rest/private/options"
 18 | )
 19 | 
 20 | /*
 21 | 	# Leveraged tokens
 22 | */
 23 | func TestLevTokens(t *testing.T) {
 24 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 25 | 
 26 | 	res, err := c.LvTokens(&leveraged.RequestForLvTokens{})
 27 | 	assert.NoError(t, err)
 28 | 
 29 | 	list := res.Products()
 30 | 	fmt.Printf("%+v\n", strings.Join(list, "\n"))
 31 | }
 32 | 
 33 | func TestLvToken(t *testing.T) {
 34 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 35 | 
 36 | 	res, err := c.LvToken(&leveraged.RequestForLvToken{
 37 | 		ProductCode: "BULL",
 38 | 	})
 39 | 	assert.NoError(t, err)
 40 | 
 41 | 	fmt.Printf("%+v\n", res)
 42 | }
 43 | 
 44 | func TestCreatedLvTokens(t *testing.T) {
 45 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 46 | 
 47 | 	res, err := c.CreatedLvTokens(&leveraged.RequestForCreatedLvTokens{})
 48 | 	assert.NoError(t, err)
 49 | 
 50 | 	fmt.Printf("%+v\n", res)
 51 | }
 52 | 
 53 | func TestCreatedLvToken(t *testing.T) {
 54 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 55 | 
 56 | 	res, err := c.CreatedLvToken(&leveraged.RequestForCreatedLvToken{
 57 | 		ProductCode: "BULL",
 58 | 	})
 59 | 	assert.NoError(t, err)
 60 | 
 61 | 	fmt.Printf("%+v\n", res)
 62 | }
 63 | 
 64 | func TestRedemptionLvTokens(t *testing.T) {
 65 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 66 | 
 67 | 	res, err := c.RedemptionLvTokens(&leveraged.RequestForRedemptionLvTokens{})
 68 | 	assert.NoError(t, err)
 69 | 
 70 | 	fmt.Printf("%+v\n", res)
 71 | }
 72 | 
 73 | func TestRedemptionLvToken(t *testing.T) {
 74 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 75 | 
 76 | 	res, err := c.RedemptionLvToken(&leveraged.RequestForRedemptionLvToken{
 77 | 		ProductCode: "BULL",
 78 | 	})
 79 | 	assert.NoError(t, err)
 80 | 
 81 | 	fmt.Printf("%+v\n", res)
 82 | }
 83 | 
 84 | func TestLvBalances(t *testing.T) {
 85 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 86 | 
 87 | 	res, err := c.LvBalances(&leveraged.RequestForLvBalances{})
 88 | 	assert.NoError(t, err)
 89 | 
 90 | 	fmt.Printf("%+v\n", res)
 91 | }
 92 | 
 93 | /*
 94 | 	# Options
 95 | */
 96 | 
 97 | func TestOpQuoteRequests(t *testing.T) {
 98 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 99 | 
100 | 	res, err := c.OpQuoteRequests(&options.RequestForOpQuoteRequests{})
101 | 	assert.NoError(t, err)
102 | 
103 | 	fmt.Printf("%+v\n", res)
104 | }
105 | 
106 | func TestMyOpQuoteRequests(t *testing.T) {
107 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
108 | 
109 | 	res, err := c.MyOpQuoteRequests(&options.RequestForMyOpQuoteRequests{})
110 | 	assert.NoError(t, err)
111 | 
112 | 	fmt.Printf("%+v\n", res)
113 | }
114 | 
115 | func TestMyOpQuoteRequest(t *testing.T) {
116 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
117 | 
118 | 	res, err := c.MyOpQuoteRequest(&options.RequestForMyOpQuoteRequest{
119 | 		RequestID: 1,
120 | 	})
121 | 	assert.NoError(t, err)
122 | 
123 | 	fmt.Printf("%+v\n", res)
124 | }
125 | 
126 | func TestCreateOpQuoteRequest(t *testing.T) {
127 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
128 | 
129 | 	res, err := c.CreateOpQuoteRequest(&options.RequestForCreateOpQuoteRequest{
130 | 		Underlying: "BTC",
131 | 		Type:       "call",
132 | 		Strike:     6200,
133 | 		Expiry:     time.Now().Add(10 * time.Hour).Unix(),
134 | 		Side:       types.BUY,
135 | 		Size:       1,
136 | 		// Optionals
137 | 		// LimitPrice:     6800,
138 | 		// HideLimitPrice: true,
139 | 		// RequestExpiry:  time.Now().Add(10 * time.Hour).Unix(),
140 | 		// CounterpartyID: 1,
141 | 	})
142 | 	assert.NoError(t, err)
143 | 
144 | 	fmt.Printf("%+v\n", res)
145 | }
146 | 
147 | func TestModifyOpQuoteRequest(t *testing.T) {
148 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
149 | 
150 | 	res, err := c.ModifyOpQuoteRequest(&options.RequestForModifyOpQuoteRequest{
151 | 		RequestID: 1,
152 | 	})
153 | 	assert.NoError(t, err)
154 | 
155 | 	fmt.Printf("%+v\n", res)
156 | }
157 | 
158 | func TestCancelOpQuoteRequest(t *testing.T) {
159 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
160 | 
161 | 	res, err := c.CancelOpQuoteRequest(&options.RequestForCancelOpQuoteRequest{
162 | 		RequestID: 1,
163 | 	})
164 | 	assert.NoError(t, err)
165 | 
166 | 	fmt.Printf("%+v\n", res)
167 | }
168 | 
169 | func TestMyOpQuotes(t *testing.T) {
170 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
171 | 
172 | 	res, err := c.MyOpQuotes(&options.RequestForMyOpQuotes{})
173 | 	assert.NoError(t, err)
174 | 
175 | 	fmt.Printf("%+v\n", res)
176 | }
177 | 
178 | // func TestCreateOpQuote(t *testing.T) {
179 | // 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
180 | 
181 | // 	res, err := c.CreateOpQuote(&options.RequestForCreateOpQuote{})
182 | // 	assert.NoError(t, err)
183 | 
184 | // 	fmt.Printf("%+v\n", res)
185 | // }
186 | 
187 | func TestCancelOpQuote(t *testing.T) {
188 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
189 | 
190 | 	res, err := c.CancelOpQuote(&options.RequestForCancelOpQuote{})
191 | 	assert.NoError(t, err)
192 | 
193 | 	fmt.Printf("%+v\n", res)
194 | }
195 | 
196 | func TestAcceptOpQuote(t *testing.T) {
197 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
198 | 
199 | 	res, err := c.AcceptOpQuote(&options.RequestForAcceptOpQuote{
200 | 		QuoteID: 1,
201 | 	})
202 | 	assert.NoError(t, err)
203 | 
204 | 	fmt.Printf("%+v\n", res)
205 | }
206 | 
207 | func TestOpPositions(t *testing.T) {
208 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
209 | 
210 | 	res, err := c.OpPositions(&options.RequestForOpPositions{})
211 | 	assert.NoError(t, err)
212 | 
213 | 	fmt.Printf("%+v\n", res)
214 | }
215 | 
216 | func TestOpTrades(t *testing.T) {
217 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
218 | 
219 | 	res, err := c.OpTrades(&options.RequestForOpTrades{})
220 | 	assert.NoError(t, err)
221 | 
222 | 	fmt.Printf("%+v\n", res)
223 | }
224 | 
225 | func TestOpFills(t *testing.T) {
226 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
227 | 
228 | 	res, err := c.OpFills(&options.RequestForOpFills{})
229 | 	assert.NoError(t, err)
230 | 
231 | 	fmt.Printf("%+v\n", res)
232 | }
233 | 


--------------------------------------------------------------------------------
/rest/request-private.go:
--------------------------------------------------------------------------------
  1 | package rest
  2 | 
  3 | import (
  4 | 	"github.com/go-numb/go-ftx/rest/private/account"
  5 | 	"github.com/go-numb/go-ftx/rest/private/convert"
  6 | 	"github.com/go-numb/go-ftx/rest/private/fills"
  7 | 	"github.com/go-numb/go-ftx/rest/private/funding"
  8 | 	"github.com/go-numb/go-ftx/rest/private/orders"
  9 | 	"github.com/go-numb/go-ftx/rest/private/spotmargin"
 10 | 	"github.com/go-numb/go-ftx/rest/private/subaccount"
 11 | 	"github.com/go-numb/go-ftx/rest/private/wallet"
 12 | )
 13 | 
 14 | func (p *Client) Information(req *account.RequestForInformation) (*account.ResponseForInformation, error) {
 15 | 	results := new(account.ResponseForInformation)
 16 | 	if err := p.request(req, results); err != nil {
 17 | 		return nil, err
 18 | 	}
 19 | 	return results, nil
 20 | }
 21 | 
 22 | func (p *Client) Positions(req *account.RequestForPositions) (*account.ResponseForPositions, error) {
 23 | 	results := new(account.ResponseForPositions)
 24 | 	if err := p.request(req, results); err != nil {
 25 | 		return nil, err
 26 | 	}
 27 | 	return results, nil
 28 | }
 29 | 
 30 | func (p *Client) Leverage(req *account.RequestForLeverage) (*account.ResponseForLeverage, error) {
 31 | 	results := new(account.ResponseForLeverage)
 32 | 	if err := p.request(req, results); err != nil {
 33 | 		return nil, err
 34 | 	}
 35 | 	return results, nil
 36 | }
 37 | 
 38 | func (p *Client) Coins(req *wallet.RequestForCoins) (*wallet.ResponseForCoins, error) {
 39 | 	results := new(wallet.ResponseForCoins)
 40 | 	if err := p.request(req, results); err != nil {
 41 | 		return nil, err
 42 | 	}
 43 | 	return results, nil
 44 | }
 45 | 
 46 | func (p *Client) Balances(req *wallet.RequestForBalances) (*wallet.ResponseForBalances, error) {
 47 | 	results := new(wallet.ResponseForBalances)
 48 | 	if err := p.request(req, results); err != nil {
 49 | 		return nil, err
 50 | 	}
 51 | 	return results, nil
 52 | }
 53 | 
 54 | func (p *Client) BalancesAll(req *wallet.RequestForBalancesAll) (*wallet.ResponseForBalancesAll, error) {
 55 | 	results := new(wallet.ResponseForBalancesAll)
 56 | 	if err := p.request(req, results); err != nil {
 57 | 		return nil, err
 58 | 	}
 59 | 	return results, nil
 60 | }
 61 | 
 62 | func (p *Client) DepositAddress(req *wallet.RequestForDepositAddress) (*wallet.ResponseForDepositAddress, error) {
 63 | 	results := new(wallet.ResponseForDepositAddress)
 64 | 	if err := p.request(req, results); err != nil {
 65 | 		return nil, err
 66 | 	}
 67 | 	return results, nil
 68 | }
 69 | 
 70 | func (p *Client) DepositHistories(req *wallet.RequestForDepositHistories) (*wallet.ResponseForDepositHistories, error) {
 71 | 	results := new(wallet.ResponseForDepositHistories)
 72 | 	if err := p.request(req, results); err != nil {
 73 | 		return nil, err
 74 | 	}
 75 | 	return results, nil
 76 | }
 77 | 
 78 | func (p *Client) WithdrawHistories(req *wallet.RequestForWithdrawHistories) (*wallet.ResponseForWithdrawHistories, error) {
 79 | 	results := new(wallet.ResponseForWithdrawHistories)
 80 | 	if err := p.request(req, results); err != nil {
 81 | 		return nil, err
 82 | 	}
 83 | 	return results, nil
 84 | }
 85 | 
 86 | func (p *Client) Withdraw(req *wallet.RequestForWithdraw) (*wallet.ResponseForWithdraw, error) {
 87 | 	results := new(wallet.ResponseForWithdraw)
 88 | 	if err := p.request(req, results); err != nil {
 89 | 		return nil, err
 90 | 	}
 91 | 	return results, nil
 92 | }
 93 | 
 94 | func (p *Client) OpenOrder(req *orders.RequestForOpenOrder) (*orders.ResponseForOpenOrder, error) {
 95 | 	results := new(orders.ResponseForOpenOrder)
 96 | 	if err := p.request(req, results); err != nil {
 97 | 		return nil, err
 98 | 	}
 99 | 	return results, nil
100 | }
101 | 
102 | func (p *Client) OrderHistories(req *orders.RequestForHistories) (*orders.ResponseForHistories, error) {
103 | 	results := new(orders.ResponseForHistories)
104 | 	if err := p.request(req, results); err != nil {
105 | 		return nil, err
106 | 	}
107 | 	return results, nil
108 | }
109 | 
110 | func (p *Client) OpenTriggerOrders(req *orders.RequestForOpenTriggerOrders) (*orders.ResponseForOpenTriggerOrders, error) {
111 | 	results := new(orders.ResponseForOpenTriggerOrders)
112 | 	if err := p.request(req, results); err != nil {
113 | 		return nil, err
114 | 	}
115 | 	return results, nil
116 | }
117 | 
118 | func (p *Client) OrderTriggers(req *orders.RequestForOrderTriggers) (*orders.ResponseForOrderTriggers, error) {
119 | 	results := new(orders.ResponseForOrderTriggers)
120 | 	if err := p.request(req, results); err != nil {
121 | 		return nil, err
122 | 	}
123 | 	return results, nil
124 | }
125 | 
126 | func (p *Client) OrderTriggerHistories(req *orders.RequestForOrderTriggerHistories) (*orders.ResponseForOrderTriggerHistories, error) {
127 | 	results := new(orders.ResponseForOrderTriggerHistories)
128 | 	if err := p.request(req, results); err != nil {
129 | 		return nil, err
130 | 	}
131 | 	return results, nil
132 | }
133 | 
134 | /*
135 | 	# send order
136 | */
137 | func (p *Client) PlaceOrder(req *orders.RequestForPlaceOrder) (*orders.ResponseForPlaceOrder, error) {
138 | 	results := new(orders.ResponseForPlaceOrder)
139 | 	if err := p.request(req, results); err != nil {
140 | 		return nil, err
141 | 	}
142 | 	return results, nil
143 | }
144 | 
145 | func (p *Client) PlaceTriggerOrder(req *orders.RequestForPlaceTriggerOrder) (*orders.ResponseForPlaceTriggerOrder, error) {
146 | 	results := new(orders.ResponseForPlaceTriggerOrder)
147 | 	if err := p.request(req, results); err != nil {
148 | 		return nil, err
149 | 	}
150 | 	return results, nil
151 | }
152 | 
153 | // ModifyOrder use ClientID or OrderID, prioritize ClientID if has ClientID.
154 | // if has clientID, use by_client_id modify. else if has orderID, use modify.
155 | // the order's queue priority will be reset, and the order ID of the modified order will be different from that of the original order.
156 | func (p *Client) ModifyOrder(req *orders.RequestForModifyOrder) (*orders.ResponseForModifyOrder, error) {
157 | 	results := new(orders.ResponseForModifyOrder)
158 | 	if err := p.request(req, results); err != nil {
159 | 		return nil, err
160 | 	}
161 | 	return results, nil
162 | }
163 | 
164 | func (p *Client) ModifyTriggerOrder(req *orders.RequestForModifyTriggerOrder) (*orders.ResponseForModifyTriggerOrder, error) {
165 | 	results := new(orders.ResponseForModifyTriggerOrder)
166 | 	if err := p.request(req, results); err != nil {
167 | 		return nil, err
168 | 	}
169 | 	return results, nil
170 | }
171 | 
172 | func (p *Client) OrderStatus(req *orders.RequestForOrderStatus) (*orders.ResponseForOrderStatus, error) {
173 | 	results := new(orders.ResponseForOrderStatus)
174 | 	if err := p.request(req, results); err != nil {
175 | 		return nil, err
176 | 	}
177 | 	return results, nil
178 | }
179 | 
180 | // CancelByID do cancel with triggerOrderID > clientID > orderID.
181 | func (p *Client) CancelByID(req *orders.RequestForCancelByID) (*orders.ResponseForCancelByID, error) {
182 | 	results := new(orders.ResponseForCancelByID)
183 | 	if err := p.request(req, results); err != nil {
184 | 		return nil, err
185 | 	}
186 | 	return results, nil
187 | }
188 | 
189 | func (p *Client) CancelAll(req *orders.RequestForCancelAll) (*orders.ResponseForCancelAll, error) {
190 | 	results := new(orders.ResponseForCancelAll)
191 | 	if err := p.request(req, results); err != nil {
192 | 		return nil, err
193 | 	}
194 | 	return results, nil
195 | }
196 | 
197 | func (p *Client) Fills(req *fills.Request) (*fills.Response, error) {
198 | 	results := new(fills.Response)
199 | 	if err := p.request(req, results); err != nil {
200 | 		return nil, err
201 | 	}
202 | 	return results, nil
203 | }
204 | 
205 | func (p *Client) Funding(req *funding.Request) (*funding.Response, error) {
206 | 	results := new(funding.Response)
207 | 	if err := p.request(req, results); err != nil {
208 | 		return nil, err
209 | 	}
210 | 	return results, nil
211 | }
212 | 
213 | /*
214 | 	# Spot Margin
215 | */
216 | 
217 | func (p *Client) GetLendingInfo(req *spotmargin.RequestForLendingInfo) (*spotmargin.ResponseForLendingInfo, error) {
218 | 	results := new(spotmargin.ResponseForLendingInfo)
219 | 	if err := p.request(req, results); err != nil {
220 | 		return nil, err
221 | 	}
222 | 	return results, nil
223 | }
224 | 
225 | func (p *Client) GetLendingRates(req *spotmargin.RequestForLendingRates) (*spotmargin.ResponseForLendingRates, error) {
226 | 	results := new(spotmargin.ResponseForLendingRates)
227 | 	if err := p.request(req, results); err != nil {
228 | 		return nil, err
229 | 	}
230 | 	return results, nil
231 | }
232 | 
233 | func (p *Client) GetLendingHistory(req *spotmargin.RequestForLendingHistory) (*spotmargin.ResponseForLendingHistory, error) {
234 | 	results := new(spotmargin.ResponseForLendingHistory)
235 | 	if err := p.request(req, results); err != nil {
236 | 		return nil, err
237 | 	}
238 | 	return results, nil
239 | }
240 | 
241 | func (p *Client) SubmitLendingOffer(req *spotmargin.RequestForLendingOffer) (*spotmargin.ResponseForLendingOffer, error) {
242 | 	results := new(spotmargin.ResponseForLendingOffer)
243 | 	if err := p.request(req, results); err != nil {
244 | 		return nil, err
245 | 	}
246 | 	return results, nil
247 | }
248 | 
249 | func (p *Client) GetBorrowRates(req *spotmargin.RequestForBorrowRates) (*spotmargin.ResponseForBorrowRates, error) {
250 | 	results := new(spotmargin.ResponseForBorrowRates)
251 | 	if err := p.request(req, results); err != nil {
252 | 		return nil, err
253 | 	}
254 | 	return results, nil
255 | }
256 | 
257 | func (p *Client) GetBorrowHistory(req *spotmargin.RequestForBorrowHistory) (*spotmargin.ResponseForBorrowHistory, error) {
258 | 	results := new(spotmargin.ResponseForBorrowHistory)
259 | 	if err := p.request(req, results); err != nil {
260 | 		return nil, err
261 | 	}
262 | 	return results, nil
263 | }
264 | 
265 | /*
266 | 	# SubAccount
267 | */
268 | func (p *Client) SubAccounts(req *subaccount.RequestForSubAccounts) (*subaccount.ResponseForSubAccounts, error) {
269 | 	results := new(subaccount.ResponseForSubAccounts)
270 | 	if err := p.request(req, results); err != nil {
271 | 		return nil, err
272 | 	}
273 | 	return results, nil
274 | }
275 | 
276 | func (p *Client) CreateSubAccount(req *subaccount.RequestForCreateSubAccount) (*subaccount.ResponseForCreateSubAccount, error) {
277 | 	results := new(subaccount.ResponseForCreateSubAccount)
278 | 	if err := p.request(req, results); err != nil {
279 | 		return nil, err
280 | 	}
281 | 	return results, nil
282 | }
283 | 
284 | func (p *Client) ChangeSubAccount(req *subaccount.RequestForChangeSubAccount) (*subaccount.ResponseForChangeSubAccount, error) {
285 | 	results := new(subaccount.ResponseForChangeSubAccount)
286 | 	if err := p.request(req, results); err != nil {
287 | 		return nil, err
288 | 	}
289 | 	return results, nil
290 | }
291 | 
292 | func (p *Client) DeleteSubAccount(req *subaccount.RequestForDeleteSubAccount) (*subaccount.ResponseForDeleteSubAccount, error) {
293 | 	results := new(subaccount.ResponseForDeleteSubAccount)
294 | 	if err := p.request(req, results); err != nil {
295 | 		return nil, err
296 | 	}
297 | 	return results, nil
298 | }
299 | 
300 | func (p *Client) BalanceSubAccount(req *subaccount.RequestForBalanceSubAccount) (*subaccount.ResponseForBalanceSubAccount, error) {
301 | 	results := new(subaccount.ResponseForBalanceSubAccount)
302 | 	if err := p.request(req, results); err != nil {
303 | 		return nil, err
304 | 	}
305 | 	return results, nil
306 | }
307 | 
308 | func (p *Client) TransferSubAccount(req *subaccount.RequestForTransferSubAccount) (*subaccount.ResponseForTransferSubAccount, error) {
309 | 	results := new(subaccount.ResponseForTransferSubAccount)
310 | 	if err := p.request(req, results); err != nil {
311 | 		return nil, err
312 | 	}
313 | 	return results, nil
314 | }
315 | 
316 | /*
317 | 	# Convert
318 | */
319 | func (p *Client) RequestConvertQuote(req *convert.RequestForRequestQuote) (*convert.ResponseForRequestQuote, error) {
320 | 	results := new(convert.ResponseForRequestQuote)
321 | 	if err := p.request(req, results); err != nil {
322 | 		return nil, err
323 | 	}
324 | 	return results, nil
325 | }
326 | 
327 | func (p *Client) GetConvertQuoteStatus(req *convert.RequestForQuoteStatus) (*convert.ResponseForQuoteStatus, error) {
328 | 	results := new(convert.ResponseForQuoteStatus)
329 | 	if err := p.request(req, results); err != nil {
330 | 		return nil, err
331 | 	}
332 | 	return results, nil
333 | }
334 | 
335 | func (p *Client) AcceptConvertQuote(req *convert.RequestForAcceptQuote) (*convert.ResponseForAcceptQuote, error) {
336 | 	results := new(convert.ResponseForAcceptQuote)
337 | 	if err := p.request(req, results); err != nil {
338 | 		return nil, err
339 | 	}
340 | 	return results, nil
341 | }
342 | 


--------------------------------------------------------------------------------
/rest/request-private_test.go:
--------------------------------------------------------------------------------
  1 | package rest_test
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"net/url"
  6 | 	"os"
  7 | 	"testing"
  8 | 	"time"
  9 | 
 10 | 	"github.com/go-numb/go-ftx/auth"
 11 | 
 12 | 	"github.com/stretchr/testify/assert"
 13 | 
 14 | 	"github.com/go-numb/go-ftx/rest"
 15 | 	"github.com/go-numb/go-ftx/rest/private/account"
 16 | 	"github.com/go-numb/go-ftx/rest/private/fills"
 17 | 	"github.com/go-numb/go-ftx/rest/private/orders"
 18 | 	"github.com/go-numb/go-ftx/rest/private/spotmargin"
 19 | 	"github.com/go-numb/go-ftx/rest/private/subaccount"
 20 | 	"github.com/go-numb/go-ftx/rest/private/wallet"
 21 | 	"github.com/go-numb/go-ftx/types"
 22 | )
 23 | 
 24 | func TestURIEncode(t *testing.T) {
 25 | 	nickname := "subaccount name[ハロ]"
 26 | 	fmt.Printf("%+v\n", url.PathEscape(nickname))
 27 | }
 28 | 
 29 | func TestInformation(t *testing.T) {
 30 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 31 | 
 32 | 	res, err := c.Information(&account.RequestForInformation{})
 33 | 	assert.NoError(t, err)
 34 | 
 35 | 	fmt.Printf("%+v\n", res)
 36 | }
 37 | 
 38 | func TestPositions(t *testing.T) {
 39 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 40 | 
 41 | 	res, err := c.Positions(&account.RequestForPositions{})
 42 | 	assert.NoError(t, err)
 43 | 
 44 | 	fmt.Printf("%+v\n", res)
 45 | }
 46 | 
 47 | func TestLeverage(t *testing.T) {
 48 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 49 | 
 50 | 	res, err := c.Leverage(&account.RequestForLeverage{
 51 | 		Leverage: 3,
 52 | 	})
 53 | 	assert.NoError(t, err)
 54 | 
 55 | 	fmt.Printf("%+v\n", res)
 56 | }
 57 | 
 58 | func TestCoins(t *testing.T) {
 59 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 60 | 
 61 | 	res, err := c.Coins(&wallet.RequestForCoins{})
 62 | 	assert.NoError(t, err)
 63 | 
 64 | 	fmt.Printf("%+v\n", res)
 65 | }
 66 | 
 67 | func TestBalances(t *testing.T) {
 68 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 69 | 
 70 | 	res, err := c.Balances(&wallet.RequestForBalances{})
 71 | 	assert.NoError(t, err)
 72 | 
 73 | 	fmt.Printf("%+v\n", res)
 74 | }
 75 | 
 76 | func TestBalancesAll(t *testing.T) {
 77 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 78 | 
 79 | 	res, err := c.BalancesAll(&wallet.RequestForBalancesAll{})
 80 | 	assert.NoError(t, err)
 81 | 
 82 | 	fmt.Printf("%+v\n", res)
 83 | }
 84 | 
 85 | func TestDepositAddress(t *testing.T) {
 86 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 87 | 
 88 | 	res, err := c.DepositAddress(&wallet.RequestForDepositAddress{
 89 | 		Coin:    "BTC",
 90 | 		Methods: "",
 91 | 	})
 92 | 	assert.NoError(t, err)
 93 | 
 94 | 	fmt.Printf("%+v\n", res)
 95 | }
 96 | 
 97 | func TestDepositHistories(t *testing.T) {
 98 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
 99 | 
100 | 	res, err := c.DepositHistories(&wallet.RequestForDepositHistories{})
101 | 	assert.NoError(t, err)
102 | 
103 | 	fmt.Printf("%+v\n", res)
104 | }
105 | 
106 | func TestWithdrawHistories(t *testing.T) {
107 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
108 | 
109 | 	res, err := c.WithdrawHistories(&wallet.RequestForWithdrawHistories{})
110 | 	assert.NoError(t, err)
111 | 
112 | 	fmt.Printf("%+v\n", res)
113 | }
114 | 
115 | func TestWithdraw(t *testing.T) {
116 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
117 | 
118 | 	res, err := c.Withdraw(&wallet.RequestForWithdraw{})
119 | 	assert.NoError(t, err)
120 | 
121 | 	fmt.Printf("%+v\n", res)
122 | }
123 | 
124 | func TestOpenOrder(t *testing.T) {
125 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
126 | 
127 | 	res, err := c.OpenOrder(&orders.RequestForOpenOrder{})
128 | 	assert.NoError(t, err)
129 | 
130 | 	fmt.Printf("%+v\n", res)
131 | }
132 | 
133 | func TestOrderHistories(t *testing.T) {
134 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
135 | 
136 | 	res, err := c.OrderHistories(&orders.RequestForHistories{})
137 | 	assert.NoError(t, err)
138 | 
139 | 	fmt.Printf("%+v\n", res)
140 | }
141 | 
142 | func TestOpenTriggerOrders(t *testing.T) {
143 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
144 | 
145 | 	res, err := c.OpenTriggerOrders(&orders.RequestForOpenTriggerOrders{})
146 | 	assert.NoError(t, err)
147 | 
148 | 	fmt.Printf("%+v\n", res)
149 | }
150 | 
151 | func TestOrderTriggers(t *testing.T) {
152 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
153 | 
154 | 	res, err := c.OrderTriggers(&orders.RequestForOrderTriggers{
155 | 		CID: "38066650",
156 | 	})
157 | 	assert.NoError(t, err)
158 | 
159 | 	fmt.Printf("%+v\n", res)
160 | }
161 | 
162 | func TestOrderTriggerHistories(t *testing.T) {
163 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
164 | 
165 | 	res, err := c.OrderTriggerHistories(&orders.RequestForOrderTriggerHistories{})
166 | 	assert.NoError(t, err)
167 | 
168 | 	fmt.Printf("%+v\n", res)
169 | }
170 | 
171 | // TODO: in production
172 | func TestPlaceOrder(t *testing.T) {
173 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
174 | 
175 | 	res, err := c.PlaceOrder(&orders.RequestForPlaceOrder{
176 | 		Type:   types.LIMIT,
177 | 		Market: "BTC-PERP",
178 | 		Side:   types.BUY,
179 | 		Price:  6200,
180 | 		Size:   0.01,
181 | 		// Optionals
182 | 		ClientID:   "use_original_client_id",
183 | 		Ioc:        false,
184 | 		ReduceOnly: false,
185 | 		PostOnly:   false,
186 | 	})
187 | 	assert.NoError(t, err)
188 | 
189 | 	fmt.Printf("%+v\n", res)
190 | }
191 | 
192 | // TODO: in production
193 | func TestPlaceTriggerOrder(t *testing.T) {
194 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
195 | 
196 | 	res, err := c.PlaceTriggerOrder(&orders.RequestForPlaceTriggerOrder{
197 | 		Type:         "trailingStop",
198 | 		Market:       "BTC-PERP",
199 | 		Side:         types.BUY,
200 | 		TriggerPrice: 6200,
201 | 		Size:         0.01,
202 | 		// Optionals
203 | 		ReduceOnly:       false,
204 | 		RetryUntilFilled: false,
205 | 	})
206 | 	assert.NoError(t, err)
207 | 
208 | 	fmt.Printf("%+v\n", res)
209 | }
210 | 
211 | // TODO: in production
212 | func TestModifyOrder(t *testing.T) {
213 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
214 | 
215 | 	res, err := c.ModifyOrder(&orders.RequestForModifyOrder{
216 | 		OrderID: "erafa",
217 | 		// prioritize ClientID > OrderID
218 | 		ClientID: "use_original_client_id",
219 | 		Price:    6200,
220 | 		Size:     0.01,
221 | 	})
222 | 	assert.NoError(t, err)
223 | 
224 | 	fmt.Printf("%+v\n", res)
225 | }
226 | 
227 | func TestModifyTriggerOrder(t *testing.T) {
228 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
229 | 
230 | 	// https://docs.ftx.com/#modify-trigger-order
231 | 	res, err := c.ModifyTriggerOrder(&orders.RequestForModifyTriggerOrder{
232 | 		OrderID:      "erafa",
233 | 		TriggerPrice: 6200,
234 | 		OrderPrice:   6210,
235 | 		Size:         0.01,
236 | 	})
237 | 	assert.NoError(t, err)
238 | 
239 | 	fmt.Printf("%+v\n", res)
240 | }
241 | 
242 | func TestOrderStatus(t *testing.T) {
243 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
244 | 
245 | 	res, err := c.OrderStatus(&orders.RequestForOrderStatus{
246 | 		OrderID: 000,
247 | 		// prioritize clientID
248 | 		ClientID: "",
249 | 	})
250 | 	assert.NoError(t, err)
251 | 
252 | 	fmt.Printf("%+v\n", res)
253 | }
254 | 
255 | func TestCancelByID(t *testing.T) {
256 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
257 | 
258 | 	res, err := c.CancelByID(&orders.RequestForCancelByID{
259 | 		OrderID: 000,
260 | 		// prioritize clientID
261 | 		ClientID: "",
262 | 	})
263 | 	assert.NoError(t, err)
264 | 
265 | 	fmt.Printf("%+v\n", res)
266 | }
267 | 
268 | func TestCancelAll(t *testing.T) {
269 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
270 | 
271 | 	res, err := c.CancelAll(&orders.RequestForCancelAll{
272 | 		ProductCode: "",
273 | 		// optionals
274 | 		Side:                  "",
275 | 		ConditionalOrdersOnly: false,
276 | 		LimitOrdersOnly:       false,
277 | 	})
278 | 	assert.NoError(t, err)
279 | 
280 | 	fmt.Printf("%+v\n", res)
281 | }
282 | func TestFills(t *testing.T) {
283 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
284 | 
285 | 	res, err := c.Fills(&fills.Request{
286 | 		ProductCode: "",
287 | 	})
288 | 	assert.NoError(t, err)
289 | 
290 | 	fmt.Printf("%+v\n", res)
291 | }
292 | 
293 | /*
294 | 	# Spot Margin
295 | */
296 | func TestGetLendingInfo(t *testing.T) {
297 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
298 | 
299 | 	res, err := c.GetLendingInfo(&spotmargin.RequestForLendingInfo{})
300 | 	assert.NoError(t, err)
301 | 
302 | 	fmt.Printf("%+v\n", res)
303 | }
304 | 
305 | func TestGetLendingRates(t *testing.T) {
306 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
307 | 
308 | 	res, err := c.GetLendingRates(&spotmargin.RequestForLendingRates{})
309 | 	assert.NoError(t, err)
310 | 
311 | 	fmt.Printf("%+v\n", res)
312 | }
313 | 
314 | func TestGetLendingHistory(t *testing.T) {
315 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
316 | 
317 | 	res, err := c.GetLendingHistory(&spotmargin.RequestForLendingHistory{
318 | 		StartTime: time.Now().Add(-30 * time.Hour).Unix(),
319 | 		EndTime:   time.Now().Unix(),
320 | 	})
321 | 	assert.NoError(t, err)
322 | 
323 | 	fmt.Printf("%+v\n", res)
324 | }
325 | 
326 | func TestSubmitLendingOffer(t *testing.T) {
327 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
328 | 
329 | 	res, err := c.SubmitLendingOffer(&spotmargin.RequestForLendingOffer{
330 | 		Coin: "USD",
331 | 		Size: 10000,
332 | 		Rate: 0.2 / 24 / 365, // APY 20%
333 | 	})
334 | 	assert.NoError(t, err)
335 | 
336 | 	fmt.Printf("%+v\n", res)
337 | }
338 | 
339 | func TestGetBorrowRates(t *testing.T) {
340 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
341 | 
342 | 	res, err := c.GetBorrowRates(&spotmargin.RequestForBorrowRates{})
343 | 	assert.NoError(t, err)
344 | 
345 | 	fmt.Printf("%+v\n", res)
346 | }
347 | 
348 | func TestGetBorrowHistory(t *testing.T) {
349 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
350 | 
351 | 	res, err := c.GetBorrowHistory(&spotmargin.RequestForBorrowHistory{})
352 | 	assert.NoError(t, err)
353 | 
354 | 	fmt.Printf("%+v\n", res)
355 | }
356 | 
357 | /*
358 | 	# SubAccount
359 | */
360 | func TestSubAccounts(t *testing.T) {
361 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
362 | 
363 | 	res, err := c.SubAccounts(&subaccount.RequestForSubAccounts{})
364 | 	assert.NoError(t, err)
365 | 
366 | 	fmt.Printf("%+v\n", res)
367 | }
368 | 
369 | func TestCreateSubAccount(t *testing.T) {
370 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
371 | 
372 | 	res, err := c.CreateSubAccount(&subaccount.RequestForCreateSubAccount{
373 | 		NickName: "testuse",
374 | 	})
375 | 	assert.NoError(t, err)
376 | 
377 | 	fmt.Printf("%+v\n", res)
378 | }
379 | 
380 | func TestChangeSubAccount(t *testing.T) {
381 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
382 | 
383 | 	res, err := c.ChangeSubAccount(&subaccount.RequestForChangeSubAccount{
384 | 		NickName:    "testuse",
385 | 		NewNickname: "new_testuse",
386 | 	})
387 | 	assert.NoError(t, err)
388 | 
389 | 	fmt.Printf("%+v\n", res)
390 | }
391 | 
392 | func TestDeleteSubAccount(t *testing.T) {
393 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
394 | 
395 | 	res, err := c.DeleteSubAccount(&subaccount.RequestForDeleteSubAccount{
396 | 		NickName: "testuse",
397 | 	})
398 | 	assert.NoError(t, err)
399 | 
400 | 	fmt.Printf("%+v\n", res)
401 | }
402 | 
403 | func TestBalanceSubAccount(t *testing.T) {
404 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
405 | 
406 | 	res, err := c.BalanceSubAccount(&subaccount.RequestForBalanceSubAccount{
407 | 		NickName: "testuse",
408 | 	})
409 | 	assert.NoError(t, err)
410 | 
411 | 	fmt.Printf("%+v\n", res)
412 | }
413 | 
414 | func TestTransferSubAccount(t *testing.T) {
415 | 	c := rest.New(auth.New(os.Getenv("FTXKEY"), os.Getenv("FTXSECRET")))
416 | 
417 | 	res, err := c.TransferSubAccount(&subaccount.RequestForTransferSubAccount{
418 | 		Coin:        "BTC",
419 | 		Size:        2.0,
420 | 		Source:      "main",
421 | 		Destination: "subaccount_1",
422 | 	})
423 | 	assert.NoError(t, err)
424 | 
425 | 	fmt.Printf("%+v\n", res)
426 | }
427 | 


--------------------------------------------------------------------------------
/rest/request-public.go:
--------------------------------------------------------------------------------
 1 | package rest
 2 | 
 3 | import (
 4 | 	"github.com/go-numb/go-ftx/rest/public/futures"
 5 | 	"github.com/go-numb/go-ftx/rest/public/markets"
 6 | )
 7 | 
 8 | func (p *Client) Markets(req *markets.RequestForMarkets) (*markets.ResponseForMarkets, error) {
 9 | 	results := new(markets.ResponseForMarkets)
10 | 	if req.ProductCode == "" {
11 | 		if err := p.request(req, results); err != nil {
12 | 			return nil, err
13 | 		}
14 | 		return results, nil
15 | 	}
16 | 
17 | 	r := new(markets.Market)
18 | 	if err := p.request(req, r); err != nil {
19 | 		return nil, err
20 | 	}
21 | 
22 | 	*results = append(*results, *r)
23 | 
24 | 	return results, nil
25 | }
26 | 
27 | func (p *Client) Orderbook(req *markets.RequestForOrderbook) (*markets.ResponseForOrderbook, error) {
28 | 	results := new(markets.ResponseForOrderbook)
29 | 	if err := p.request(req, results); err != nil {
30 | 		return nil, err
31 | 	}
32 | 	return results, nil
33 | }
34 | 
35 | func (p *Client) Trades(req *markets.RequestForTrades) (*markets.ResponseForTrades, error) {
36 | 	results := new(markets.ResponseForTrades)
37 | 	if err := p.request(req, results); err != nil {
38 | 		return nil, err
39 | 	}
40 | 	return results, nil
41 | }
42 | 
43 | func (p *Client) Candles(req *markets.RequestForCandles) (*markets.ResponseForCandles, error) {
44 | 	results := new(markets.ResponseForCandles)
45 | 	if err := p.request(req, results); err != nil {
46 | 		return nil, err
47 | 	}
48 | 	return results, nil
49 | }
50 | 
51 | func (p *Client) Futures(req *futures.RequestForFutures) (*futures.ResponseForFutures, error) {
52 | 	results := new(futures.ResponseForFutures)
53 | 	if err := p.request(req, results); err != nil {
54 | 		return nil, err
55 | 	}
56 | 	return results, nil
57 | }
58 | 
59 | func (p *Client) Future(req *futures.RequestForFuture) (*futures.ResponseForFuture, error) {
60 | 	results := new(futures.ResponseForFuture)
61 | 	if err := p.request(req, results); err != nil {
62 | 		return nil, err
63 | 	}
64 | 	return results, nil
65 | }
66 | 
67 | func (p *Client) Stats(req *futures.RequestForStats) (*futures.ResponseForStats, error) {
68 | 	results := new(futures.ResponseForStats)
69 | 	if err := p.request(req, results); err != nil {
70 | 		return nil, err
71 | 	}
72 | 	return results, nil
73 | }
74 | 
75 | func (p *Client) Rates(req *futures.RequestForRates) (*futures.ResponseForRates, error) {
76 | 	results := new(futures.ResponseForRates)
77 | 	if err := p.request(req, results); err != nil {
78 | 		return nil, err
79 | 	}
80 | 	return results, nil
81 | }
82 | 


--------------------------------------------------------------------------------
/rest/request-public_test.go:
--------------------------------------------------------------------------------
  1 | package rest_test
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"sort"
  6 | 	"strings"
  7 | 	"testing"
  8 | 	"time"
  9 | 
 10 | 	"github.com/dustin/go-humanize"
 11 | 	"github.com/go-numb/go-ftx/rest"
 12 | 	"github.com/go-numb/go-ftx/rest/public/futures"
 13 | 	"github.com/go-numb/go-ftx/rest/public/markets"
 14 | 	"github.com/stretchr/testify/assert"
 15 | )
 16 | 
 17 | /*
 18 | 	# Markets
 19 | */
 20 | func TestMarkets(t *testing.T) {
 21 | 	c := rest.New(nil)
 22 | 	res, err := c.Markets(&markets.RequestForMarkets{
 23 | 		ProductCode: "MNGO/USD",
 24 | 	})
 25 | 	assert.NoError(t, err)
 26 | 
 27 | 	fmt.Printf("%+v\n", res)
 28 | 	fmt.Printf("%+v\n", strings.Join(res.List(), "\n"))
 29 | 	fmt.Printf("%+v\n", strings.Join(res.Ranking(markets.ALL), "\n"))
 30 | }
 31 | 
 32 | func TestOrderbook(t *testing.T) {
 33 | 	c := rest.New(nil)
 34 | 	res, err := c.Orderbook(&markets.RequestForOrderbook{
 35 | 		ProductCode: "BTC-PERP",
 36 | 		Depth:       10,
 37 | 	})
 38 | 	assert.NoError(t, err)
 39 | 
 40 | 	fmt.Printf("%+v\n", res)
 41 | }
 42 | 
 43 | func TestTrades(t *testing.T) {
 44 | 	c := rest.New(nil)
 45 | 	res, err := c.Trades(&markets.RequestForTrades{
 46 | 		ProductCode: "BTC-PERP",
 47 | 		Limit:       100,
 48 | 		Start:       time.Now().UTC().Add(-1 * time.Minute).Unix(),
 49 | 		End:         time.Now().UTC().Unix(),
 50 | 	})
 51 | 	assert.NoError(t, err)
 52 | 
 53 | 	trades := *res
 54 | 	for i := 0; i < len(trades); i++ {
 55 | 		fmt.Printf("%#v\n", trades[i].Time.String())
 56 | 	}
 57 | }
 58 | 
 59 | func TestCandles(t *testing.T) {
 60 | 	c := rest.New(nil)
 61 | 	res, err := c.Candles(&markets.RequestForCandles{
 62 | 		ProductCode: "BTC-PERP",
 63 | 		Resolution:  900,                                       // optional
 64 | 		Start:       time.Now().Add(-900 * time.Second).Unix(), // optional
 65 | 		End:         time.Now().Unix(),                         // optional
 66 | 	})
 67 | 	assert.NoError(t, err)
 68 | 
 69 | 	fmt.Printf("%+v\n", res)
 70 | }
 71 | 
 72 | /*
 73 | 	# Futures
 74 | */
 75 | func TestFutures(t *testing.T) {
 76 | 	c := rest.New(nil)
 77 | 	res, err := c.Futures(&futures.RequestForFutures{})
 78 | 	assert.NoError(t, err)
 79 | 
 80 | 	for i, v := range res.Products() {
 81 | 		fmt.Printf("%d: %+v\n", i, v)
 82 | 	}
 83 | 
 84 | 	for _, v := range *res {
 85 | 		fmt.Printf("%+v	%.2f\n", v.Name, v.Ask)
 86 | 	}
 87 | }
 88 | 
 89 | func TestFuture(t *testing.T) {
 90 | 	c := rest.New(nil)
 91 | 	res, err := c.Future(&futures.RequestForFuture{
 92 | 		ProductCode: "BTC-PERP",
 93 | 	})
 94 | 	assert.NoError(t, err)
 95 | 
 96 | 	fmt.Printf("%+v\n", res)
 97 | }
 98 | 
 99 | func TestStats(t *testing.T) {
100 | 	c := rest.New(nil)
101 | 	res, err := c.Stats(&futures.RequestForStats{
102 | 		ProductCode: "BTC-PERP",
103 | 	})
104 | 	assert.NoError(t, err)
105 | 
106 | 	fmt.Printf("%+v\n", res)
107 | }
108 | 
109 | func TestGetFundingRate(t *testing.T) {
110 | 	c := rest.New(nil)
111 | 	res, err := c.Futures(&futures.RequestForFutures{})
112 | 	assert.NoError(t, err)
113 | 
114 | 	list := res.Products()
115 | 	futureList := make([]futures.Stats, len(list))
116 | 
117 | 	for i := range list {
118 | 		future, err := c.Stats(&futures.RequestForStats{
119 | 			ProductCode: list[i],
120 | 		})
121 | 		if err != nil {
122 | 			t.Fatal(err)
123 | 		}
124 | 		future.Name = list[i]
125 | 		futureList[i] = futures.Stats(*future)
126 | 
127 | 		time.Sleep(100 * time.Millisecond)
128 | 	}
129 | 
130 | 	sort.Sort(sort.Reverse(futures.StatsList(futureList)))
131 | 
132 | 	for _, v := range futureList {
133 | 		if v.NextFundingRate == 0 {
134 | 			continue
135 | 		}
136 | 		fmt.Printf("%s			%s\n", humanize.Commaf(v.NextFundingRate*100), v.Name)
137 | 	}
138 | 
139 | 	/*
140 | 		<<
141 | 		0.000368		BTMX-PERP
142 | 		0.000142		MATIC-PERP
143 | 		0.000141		TOMO-PERP
144 | 		0.000074		PAXG-PERP
145 | 		0.000061		BSV-PERP
146 | 		0.000059		PRIV-PERP
147 | 		0.000042		TRYB-PERP
148 | 		0.000039		EOS-PERP
149 | 		0.000034		MID-PERP
150 | 		0.00003			OKB-PERP
151 | 		0.000025		DRGN-PERP
152 | 		0.000024		SHIT-PERP
153 | 		0.000023		HT-PERP
154 | 		0.000021		LTC-PERP
155 | 		0.00002			USDT-PERP
156 | 		0.000019		XTZ-PERP
157 | 		0.000018		XAUT-PERP
158 | 		0.000007		DOGE-PERP
159 | 		0.000005		BTC-PERP
160 | 		0.000002		BNB-PERP
161 | 		0.000001		ADA-PERP
162 | 		-0.000007		ATOM-PERP
163 | 		-0.000018		BCH-PERP
164 | 		-0.000019		ALGO-PERP
165 | 		-0.000025		TRX-PERP
166 | 		-0.00003		XRP-PERP
167 | 		-0.000031		EXCH-PERP
168 | 		-0.000034		ALT-PERP
169 | 		-0.00004		ETC-PERP
170 | 		-0.000044		ETH-PERP
171 | 		-0.000096		LINK-PERP
172 | 		-0.000162		LEO-PERP
173 | 	*/
174 | }
175 | 
176 | func TestMultiUnderlyingsRates(t *testing.T) {
177 | 	c := rest.New(nil)
178 | 	res, err := c.Rates(&futures.RequestForRates{})
179 | 	assert.NoError(t, err)
180 | 
181 | 	sort.Sort(sort.Reverse(res))
182 | 	for _, v := range *res {
183 | 		fmt.Printf("%s			%s		%s\n", humanize.Commaf(v.Rate), v.Future, v.Time.String())
184 | 	}
185 | 
186 | 	/*
187 | 		>>
188 | 		0.000404			BTMX-PERP		2020-04-05 10:00:00 +0000 +0000
189 | 		0.000367			BTMX-PERP		2020-04-05 11:00:00 +0000 +0000
190 | 		0.000357			BTMX-PERP		2020-04-05 07:00:00 +0000 +0000
191 | 		0.000338			BTMX-PERP		2020-04-05 09:00:00 +0000 +0000
192 | 		0.00029				BTMX-PERP		2020-04-05 08:00:00 +0000 +0000
193 | 
194 | 		(omitting...)
195 | 
196 | 		-0.000277			BTMX-PERP		2020-04-04 23:00:00 +0000 +0000
197 | 		-0.000293			DOGE-PERP		2020-04-05 03:00:00 +0000 +0000
198 | 		-0.000304			XAUT-PERP		2020-04-04 23:00:00 +0000 +0000
199 | 		-0.000322			DOGE-PERP		2020-04-05 04:00:00 +0000 +0000
200 | 		-0.000379			BTMX-PERP		2020-04-05 00:00:00 +0000 +0000
201 | 		-0.000398			XAUT-PERP		2020-04-05 00:00:00 +0000 +0000
202 | 	*/
203 | }
204 | 
205 | func TestSingleUnderlyingRates(t *testing.T) {
206 | 	c := rest.New(nil)
207 | 	res, err := c.Rates(&futures.RequestForRates{
208 | 		ProductCode: "BTC-PERP",
209 | 		Start:       time.Now().Add(-900 * time.Second).Unix(), // optional
210 | 		End:         time.Now().Unix(),                         // optional
211 | 
212 | 	})
213 | 	assert.NoError(t, err)
214 | 
215 | 	sort.Sort(sort.Reverse(res))
216 | 	for _, v := range *res {
217 | 		fmt.Printf("%s			%s		%s\n", humanize.Commaf(v.Rate), v.Future, v.Time.String())
218 | 	}
219 | 
220 | 	/*
221 | 		>>
222 | 		0.000404			BTC-PERP		2020-04-05 10:00:00 +0000 +0000
223 | 		0.000367			BTC-PERP		2020-04-05 11:00:00 +0000 +0000
224 | 		0.000357			BTC-PERP		2020-04-05 07:00:00 +0000 +0000
225 | 		0.000338			BTC-PERP		2020-04-05 09:00:00 +0000 +0000
226 | 		0.00029				BTC-PERP		2020-04-05 08:00:00 +0000 +0000
227 | 
228 | 		(omitting...)
229 | 
230 | 		-0.000277			BTC-PERP		2020-04-04 23:00:00 +0000 +0000
231 | 		-0.000293			BTC-PERP		2020-04-05 03:00:00 +0000 +0000
232 | 		-0.000304			BTC-PERP		2020-04-04 23:00:00 +0000 +0000
233 | 		-0.000322			BTC-PERP		2020-04-05 04:00:00 +0000 +0000
234 | 		-0.000379			BTC-PERP		2020-04-05 00:00:00 +0000 +0000
235 | 		-0.000398			BTC-PERP		2020-04-05 00:00:00 +0000 +0000
236 | 	*/
237 | }
238 | 


--------------------------------------------------------------------------------
/rest/request.go:
--------------------------------------------------------------------------------
  1 | package rest
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"net/url"
  6 | 	"time"
  7 | 
  8 | 	"github.com/valyala/fasthttp"
  9 | )
 10 | 
 11 | type Response struct {
 12 | 	Result  interface{} `json:"result,omitempty"`
 13 | 	Error   string      `json:"error,omitempty"`
 14 | 	Success bool        `json:"success"`
 15 | }
 16 | 
 17 | func (p *Client) request(req Requester, results interface{}) error {
 18 | 	res, err := p.do(req)
 19 | 	if err != nil {
 20 | 		return err
 21 | 	}
 22 | 
 23 | 	if err := decode(res, results); err != nil {
 24 | 		return err
 25 | 	}
 26 | 	return nil
 27 | }
 28 | 
 29 | func (p *Client) newRequest(r Requester) *fasthttp.Request {
 30 | 	// avoid Pointer's butting
 31 | 	u, _ := url.ParseRequestURI(ENDPOINT)
 32 | 	u.Path = u.Path + r.Path()
 33 | 	u.RawQuery = r.Query()
 34 | 
 35 | 	req := fasthttp.AcquireRequest()
 36 | 	req.Header.SetMethod(r.Method())
 37 | 	req.SetRequestURI(u.String())
 38 | 	body := r.Payload()
 39 | 	req.SetBody(body)
 40 | 
 41 | 	if p.Auth != nil {
 42 | 		nonce := fmt.Sprintf("%d", int64(time.Now().UTC().UnixNano()/int64(time.Millisecond)))
 43 | 		payload := nonce + r.Method() + u.Path
 44 | 		if u.RawQuery != "" {
 45 | 			payload += "?" + u.RawQuery
 46 | 		}
 47 | 		payload += string(body)
 48 | 
 49 | 		req.Header.Set("Content-Type", "application/json")
 50 | 		req.Header.Set("FTX-KEY", p.Auth.Key)
 51 | 		req.Header.Set("FTX-SIGN", p.Auth.Signature(payload))
 52 | 		req.Header.Set("FTX-TS", nonce)
 53 | 
 54 | 		// set id is there UseSubAccountID
 55 | 		subaccount := p.Auth.SubAccount()
 56 | 		if subaccount.Nickname != "" {
 57 | 			req.Header.Set("FTX-SUBACCOUNT", url.PathEscape(subaccount.Nickname))
 58 | 		}
 59 | 	}
 60 | 
 61 | 	return req
 62 | }
 63 | 
 64 | func (c *Client) do(r Requester) (*fasthttp.Response, error) {
 65 | 	req := c.newRequest(r)
 66 | 
 67 | 	// fasthttp for http2.0
 68 | 	res := fasthttp.AcquireResponse()
 69 | 	err := c.HTTPC.DoTimeout(req, res, c.HTTPTimeout)
 70 | 	if err != nil {
 71 | 		return nil, err
 72 | 	}
 73 | 
 74 | 	// fmt.Printf("%+v\n", string(res.Body()))
 75 | 	// no usefull headers
 76 | 
 77 | 	if res.StatusCode() != 200 {
 78 | 		var r = new(Response)
 79 | 		if err := json.Unmarshal(res.Body(), r); err != nil {
 80 | 			return nil, &APIError{
 81 | 				Status:  res.StatusCode(),
 82 | 				Message: err.Error(),
 83 | 			}
 84 | 		}
 85 | 
 86 | 		if !r.Success {
 87 | 			return nil, &APIError{
 88 | 				Status:  res.StatusCode(),
 89 | 				Message: r.Error,
 90 | 			}
 91 | 		}
 92 | 	}
 93 | 	return res, nil
 94 | }
 95 | 
 96 | func decode(res *fasthttp.Response, out interface{}) error {
 97 | 	var r = new(Response)
 98 | 	r.Result = out
 99 | 
100 | 	if err := json.Unmarshal(res.Body(), r); err != nil {
101 | 		return err
102 | 	}
103 | 	if !r.Success {
104 | 		return fmt.Errorf("decode error")
105 | 	}
106 | 	return nil
107 | }
108 | 


--------------------------------------------------------------------------------
/types/models.go:
--------------------------------------------------------------------------------
 1 | package types
 2 | 
 3 | import (
 4 | 	"math"
 5 | 	"time"
 6 | 
 7 | 	jsoniter "github.com/json-iterator/go"
 8 | )
 9 | 
10 | var json = jsoniter.ConfigCompatibleWithStandardLibrary
11 | 
12 | const (
13 | 	BUY    = "buy"
14 | 	SELL   = "sell"
15 | 	MARKET = "market"
16 | 	LIMIT  = "limit"
17 | 	STOP = "stop"
18 | )
19 | 
20 | type FtxTime struct {
21 | 	Time time.Time
22 | }
23 | 
24 | func (p *FtxTime) UnmarshalJSON(data []byte) error {
25 | 	var f float64
26 | 	if err := json.Unmarshal(data, &f); err != nil {
27 | 		return err
28 | 	}
29 | 
30 | 	sec, nsec := math.Modf(f)
31 | 	p.Time = time.Unix(int64(sec), int64(nsec))
32 | 	return nil
33 | }
34 | 


--------------------------------------------------------------------------------