bbgo_origin/pkg/exchange/ftx/exchange.go

168 lines
4.5 KiB
Go
Raw Normal View History

2021-02-05 09:29:38 +00:00
package ftx
import (
"context"
2021-02-08 10:59:36 +00:00
"fmt"
"net/http"
"net/url"
2021-02-05 09:29:38 +00:00
"time"
"github.com/sirupsen/logrus"
2021-02-08 10:59:36 +00:00
"github.com/c9s/bbgo/pkg/fixedpoint"
2021-02-05 09:29:38 +00:00
"github.com/c9s/bbgo/pkg/types"
)
2021-02-08 10:59:36 +00:00
const (
restEndpoint = "https://ftx.com"
defaultHTTPTimeout = 15 * time.Second
)
2021-02-27 09:01:20 +00:00
var logger = logrus.WithField("exchange", "ftx")
2021-02-05 09:29:38 +00:00
type Exchange struct {
rest *restRequest
key, secret string
2021-02-05 09:29:38 +00:00
}
2021-02-08 10:59:36 +00:00
func NewExchange(key, secret string, subAccount string) *Exchange {
u, err := url.Parse(restEndpoint)
if err != nil {
panic(err)
}
rest := newRestRequest(&http.Client{Timeout: defaultHTTPTimeout}, u).Auth(key, secret)
if subAccount != "" {
rest.SubAccount(subAccount)
}
return &Exchange{
rest: rest,
key: key,
secret: secret,
2021-02-08 10:59:36 +00:00
}
2021-02-05 09:29:38 +00:00
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) Name() types.ExchangeName {
2021-02-08 14:33:12 +00:00
return types.ExchangeFTX
2021-02-05 09:29:38 +00:00
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) PlatformFeeCurrency() string {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) NewStream() types.Stream {
return NewStream(e.key, e.secret)
2021-02-05 09:29:38 +00:00
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryMarkets(ctx context.Context) (types.MarketMap, error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryAccount(ctx context.Context) (*types.Account, error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryAccountBalances(ctx context.Context) (types.BalanceMap, error) {
resp, err := e.rest.Balances(ctx)
if err != nil {
return nil, err
}
if !resp.Success {
return nil, fmt.Errorf("ftx returns querying balances failure")
}
var balances = make(types.BalanceMap)
for _, r := range resp.Result {
balances[toGlobalCurrency(r.Coin)] = types.Balance{
Currency: toGlobalCurrency(r.Coin),
Available: fixedpoint.NewFromFloat(r.Free),
Locked: fixedpoint.NewFromFloat(r.Total).Sub(fixedpoint.NewFromFloat(r.Free)),
}
}
return balances, nil
}
func (e *Exchange) QueryKLines(ctx context.Context, symbol string, interval types.Interval, options types.KLineQueryOptions) ([]types.KLine, error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryTrades(ctx context.Context, symbol string, options *types.TradeQueryOptions) ([]types.Trade, error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryDepositHistory(ctx context.Context, asset string, since, until time.Time) (allDeposits []types.Deposit, err error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryWithdrawHistory(ctx context.Context, asset string, since, until time.Time) (allWithdraws []types.Withdraw, err error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-03-13 01:51:31 +00:00
func (e *Exchange) SubmitOrders(ctx context.Context, orders ...types.SubmitOrder) (types.OrderSlice, error) {
var createdOrders types.OrderSlice
// TODO: currently only support limit and market order
// TODO: support time in force
for _, so := range orders {
if so.TimeInForce != "GTC" {
return createdOrders, fmt.Errorf("unsupported TimeInForce %s. only support GTC", so.TimeInForce)
}
or, err := e.rest.PlaceOrder(ctx, PlaceOrderPayload{
Market: TrimUpperString(so.Symbol),
Side: TrimLowerString(string(so.Side)),
Price: so.Price,
Type: TrimLowerString(string(so.Type)),
Size: so.Quantity,
ReduceOnly: false,
IOC: false,
PostOnly: false,
ClientID: so.ClientOrderID,
})
if err != nil {
return createdOrders, fmt.Errorf("failed to place order %+v: %w", so, err)
}
if !or.Success {
return createdOrders, fmt.Errorf("ftx returns placing order failure")
}
globalOrder, err := toGlobalOrder(or.Result)
if err != nil {
return createdOrders, fmt.Errorf("failed to convert response to global order")
}
createdOrders = append(createdOrders, globalOrder)
}
return createdOrders, nil
2021-02-05 09:29:38 +00:00
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryOpenOrders(ctx context.Context, symbol string) (orders []types.Order, err error) {
2021-03-07 04:53:41 +00:00
// TODO: invoke open trigger orders
2021-03-07 04:47:11 +00:00
resp, err := e.rest.OpenOrders(ctx, symbol)
if err != nil {
return nil, err
}
if !resp.Success {
return nil, fmt.Errorf("ftx returns querying open orders failure")
}
for _, r := range resp.Result {
2021-03-13 01:51:31 +00:00
o, err := toGlobalOrder(r)
2021-03-07 04:47:11 +00:00
if err != nil {
return nil, err
}
orders = append(orders, o)
}
return orders, nil
2021-02-05 09:29:38 +00:00
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) QueryClosedOrders(ctx context.Context, symbol string, since, until time.Time, lastOrderID uint64) (orders []types.Order, err error) {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
2021-02-08 10:59:36 +00:00
func (e *Exchange) CancelOrders(ctx context.Context, orders ...types.Order) error {
2021-02-05 09:29:38 +00:00
panic("implement me")
}
func (e *Exchange) QueryTicker(ctx context.Context, symbol string) (*types.Ticker, error) {
panic("implement me")
}
func (e *Exchange) QueryTickers(ctx context.Context, symbol ...string) (map[string]types.Ticker, error) {
panic("implement me")
}