diff --git a/README.md b/README.md index 6c803841..febaa871 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,7 @@ Join our slack to discuss all things related to GoCryptoTrader! [GoCryptoTrader | Bittrex | Yes | No | NA | | BTCC | Yes | Yes | No | | BTCMarkets | Yes | No | NA | +| BTSE | Yes | Yes | NA | | COINUT | Yes | Yes | NA | | Exmo | Yes | NA | NA | | CoinbasePro | Yes | Yes | No| diff --git a/config/config_test.go b/config/config_test.go index c322ac97..b0e076b1 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -11,7 +11,7 @@ import ( const ( // Default number of enabled exchanges. Modify this whenever an exchange is // added or removed - defaultEnabledExchanges = 27 + defaultEnabledExchanges = 28 ) func TestGetCurrencyConfig(t *testing.T) { diff --git a/config_example.json b/config_example.json index 0b32e469..870914bc 100644 --- a/config_example.json +++ b/config_example.json @@ -509,6 +509,47 @@ } ] }, + { + "name": "BTSE", + "enabled": true, + "verbose": false, + "websocket": true, + "useSandbox": false, + "restPollingDelay": 10, + "httpTimeout": 15000000000, + "httpUserAgent": "", + "authenticatedApiSupport": false, + "apiKey": "Key", + "apiSecret": "Secret", + "apiUrl": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", + "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", + "proxyAddress": "", + "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", + "availablePairs": "BTC-USD", + "enabledPairs": "BTC-USD", + "baseCurrencies": "USD", + "assetTypes": "SPOT", + "supportsAutoPairUpdates": true, + "configCurrencyPairFormat": { + "uppercase": true, + "delimiter": "-" + }, + "requestCurrencyPairFormat": { + "uppercase": true, + "delimiter": "-" + }, + "bankAccounts": [ + { + "bankName": "", + "bankAddress": "", + "accountName": "", + "accountNumber": "", + "swiftCode": "", + "iban": "", + "supportedCurrencies": "" + } + ] + }, { "name": "BTC Markets", "enabled": true, diff --git a/exchange.go b/exchange.go index c9c45f6f..61f54165 100644 --- a/exchange.go +++ b/exchange.go @@ -16,6 +16,7 @@ import ( "github.com/thrasher-/gocryptotrader/exchanges/bittrex" "github.com/thrasher-/gocryptotrader/exchanges/btcc" "github.com/thrasher-/gocryptotrader/exchanges/btcmarkets" + "github.com/thrasher-/gocryptotrader/exchanges/btse" "github.com/thrasher-/gocryptotrader/exchanges/coinbasepro" "github.com/thrasher-/gocryptotrader/exchanges/coinut" "github.com/thrasher-/gocryptotrader/exchanges/exmo" @@ -154,6 +155,8 @@ func LoadExchange(name string, useWG bool, wg *sync.WaitGroup) error { exch = new(btcc.BTCC) case "btc markets": exch = new(btcmarkets.BTCMarkets) + case "btse": + exch = new(btse.BTSE) case "coinut": exch = new(coinut.COINUT) case "exmo": diff --git a/exchanges/alphapoint/alphapoint_wrapper.go b/exchanges/alphapoint/alphapoint_wrapper.go index 9eb6f00b..a2a53c40 100644 --- a/exchanges/alphapoint/alphapoint_wrapper.go +++ b/exchanges/alphapoint/alphapoint_wrapper.go @@ -155,7 +155,7 @@ func (a *Alphapoint) CancelAllOrders(orderCancellation exchange.OrderCancellatio } // GetOrderInfo returns information on a current open order -func (a *Alphapoint) GetOrderInfo(orderID int64) (float64, error) { +func (a *Alphapoint) GetOrderInfo(orderID string) (float64, error) { orders, err := a.GetOrders() if err != nil { return 0, err @@ -163,7 +163,7 @@ func (a *Alphapoint) GetOrderInfo(orderID int64) (float64, error) { for x := range orders { for y := range orders[x].OpenOrders { - if int64(orders[x].OpenOrders[y].ServerOrderID) == orderID { + if strconv.Itoa(orders[x].OpenOrders[y].ServerOrderID) == orderID { return orders[x].OpenOrders[y].QtyRemaining, nil } } diff --git a/exchanges/anx/anx_wrapper.go b/exchanges/anx/anx_wrapper.go index c74b2c48..4d0c04f7 100644 --- a/exchanges/anx/anx_wrapper.go +++ b/exchanges/anx/anx_wrapper.go @@ -303,7 +303,7 @@ func (a *ANX) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelAllO } // GetOrderInfo returns information on a current open order -func (a *ANX) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (a *ANX) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/binance/binance_wrapper.go b/exchanges/binance/binance_wrapper.go index d905cbf7..cd01eea6 100644 --- a/exchanges/binance/binance_wrapper.go +++ b/exchanges/binance/binance_wrapper.go @@ -265,7 +265,7 @@ func (b *Binance) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cancel } // GetOrderInfo returns information on a current open order -func (b *Binance) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Binance) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/bitfinex/bitfinex_wrapper.go b/exchanges/bitfinex/bitfinex_wrapper.go index 6e8ecd80..c09b1570 100644 --- a/exchanges/bitfinex/bitfinex_wrapper.go +++ b/exchanges/bitfinex/bitfinex_wrapper.go @@ -211,7 +211,7 @@ func (b *Bitfinex) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cance } // GetOrderInfo returns information on a current open order -func (b *Bitfinex) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Bitfinex) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/bitflyer/bitflyer_wrapper.go b/exchanges/bitflyer/bitflyer_wrapper.go index ad555a6c..17c7bc09 100644 --- a/exchanges/bitflyer/bitflyer_wrapper.go +++ b/exchanges/bitflyer/bitflyer_wrapper.go @@ -178,7 +178,7 @@ func (b *Bitflyer) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cance } // GetOrderInfo returns information on a current open order -func (b *Bitflyer) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Bitflyer) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/bithumb/bithumb_wrapper.go b/exchanges/bithumb/bithumb_wrapper.go index 435a562b..5074e561 100644 --- a/exchanges/bithumb/bithumb_wrapper.go +++ b/exchanges/bithumb/bithumb_wrapper.go @@ -244,7 +244,7 @@ func (b *Bithumb) CancelAllOrders(orderCancellation exchange.OrderCancellation) } // GetOrderInfo returns information on a current open order -func (b *Bithumb) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Bithumb) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/bitmex/bitmex_wrapper.go b/exchanges/bitmex/bitmex_wrapper.go index 4bc0c23d..2d977c40 100644 --- a/exchanges/bitmex/bitmex_wrapper.go +++ b/exchanges/bitmex/bitmex_wrapper.go @@ -246,7 +246,7 @@ func (b *Bitmex) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelA } // GetOrderInfo returns information on a current open order -func (b *Bitmex) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Bitmex) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/bitstamp/bitstamp_wrapper.go b/exchanges/bitstamp/bitstamp_wrapper.go index a21c22a8..f43ebfa4 100644 --- a/exchanges/bitstamp/bitstamp_wrapper.go +++ b/exchanges/bitstamp/bitstamp_wrapper.go @@ -218,7 +218,7 @@ func (b *Bitstamp) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cance } // GetOrderInfo returns information on a current open order -func (b *Bitstamp) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Bitstamp) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/bittrex/bittrex_wrapper.go b/exchanges/bittrex/bittrex_wrapper.go index 786bddc5..e6b64033 100644 --- a/exchanges/bittrex/bittrex_wrapper.go +++ b/exchanges/bittrex/bittrex_wrapper.go @@ -240,7 +240,7 @@ func (b *Bittrex) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cancel } // GetOrderInfo returns information on a current open order -func (b *Bittrex) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *Bittrex) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/btcc/btcc_wrapper.go b/exchanges/btcc/btcc_wrapper.go index 29246ba3..73367f38 100644 --- a/exchanges/btcc/btcc_wrapper.go +++ b/exchanges/btcc/btcc_wrapper.go @@ -121,7 +121,7 @@ func (b *BTCC) CancelAllOrders(orderCancellation exchange.OrderCancellation) (ex } // GetOrderInfo returns information on a current open order -func (b *BTCC) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *BTCC) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { return exchange.OrderDetail{}, common.ErrNotYetImplemented } diff --git a/exchanges/btcmarkets/btcmarkets_test.go b/exchanges/btcmarkets/btcmarkets_test.go index 7096b371..f1a5a29c 100644 --- a/exchanges/btcmarkets/btcmarkets_test.go +++ b/exchanges/btcmarkets/btcmarkets_test.go @@ -160,7 +160,7 @@ func TestCancelOrder(t *testing.T) { } func TestGetOrderInfo(t *testing.T) { - _, err := b.GetOrderInfo(1337) + _, err := b.GetOrderInfo("1337") if err == nil { t.Error("Test failed - GetOrderInfo() error", err) } diff --git a/exchanges/btcmarkets/btcmarkets_wrapper.go b/exchanges/btcmarkets/btcmarkets_wrapper.go index 2adcd4bf..ce0ef133 100644 --- a/exchanges/btcmarkets/btcmarkets_wrapper.go +++ b/exchanges/btcmarkets/btcmarkets_wrapper.go @@ -230,10 +230,15 @@ func (b *BTCMarkets) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Can } // GetOrderInfo returns information on a current open order -func (b *BTCMarkets) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (b *BTCMarkets) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var OrderDetail exchange.OrderDetail - orders, err := b.GetOrderDetail([]int64{orderID}) + o, err := strconv.ParseInt(orderID, 10, 64) + if err != nil { + return OrderDetail, err + } + + orders, err := b.GetOrderDetail([]int64{o}) if err != nil { return OrderDetail, err } diff --git a/exchanges/btse/README.md b/exchanges/btse/README.md new file mode 100644 index 00000000..6face95f --- /dev/null +++ b/exchanges/btse/README.md @@ -0,0 +1,30 @@ + +# GoCryptoTrader Btse Exchange Wrapper + + + +An exchange interface wrapper for the GoCryptoTrader application. + +## This is still in active development + + You can track ideas, planned features and what's in progresss on this Trello board: [https://trello.com/b/ZAhMhpOy/gocryptotrader](https://trello.com/b/ZAhMhpOy/gocryptotrader). + +## Current Btse Exchange Features + ++ REST Support ++ Websocket Support + ++ Can be used as a package + +## Notes + ++ Please add notes here with any production issues ++ Please provide link to exchange website and API documentation + +## Contributors + ++ Please add your information + +|User|Github|Contribution| +|--|--|--| +|AliasGoesHere|https://github.com/AliasGoesHere |WHAT-YOU-DID| diff --git a/exchanges/btse/btse.go b/exchanges/btse/btse.go new file mode 100644 index 00000000..d9db0cde --- /dev/null +++ b/exchanges/btse/btse.go @@ -0,0 +1,367 @@ +package btse + +import ( + "errors" + "fmt" + "net/http" + "strconv" + "strings" + "time" + + "github.com/gorilla/websocket" + "github.com/thrasher-/gocryptotrader/common" + "github.com/thrasher-/gocryptotrader/config" + "github.com/thrasher-/gocryptotrader/currency/symbol" + exchange "github.com/thrasher-/gocryptotrader/exchanges" + "github.com/thrasher-/gocryptotrader/exchanges/request" + "github.com/thrasher-/gocryptotrader/exchanges/ticker" + log "github.com/thrasher-/gocryptotrader/logger" +) + +// BTSE is the overarching type across this package +type BTSE struct { + exchange.Base + WebsocketConn *websocket.Conn +} + +const ( + btseAPIURL = "https://api.btse.com/v1/restapi" + btseAPIVersion = "1" + + // Public endpoints + btseMarkets = "markets" + btseTrades = "trades" + btseTicker = "ticker" + btseStats = "stats" + btseTime = "time" + + // Authenticated endpoints + btseAccount = "account" + btseOrder = "order" + btsePendingOrders = "pending" + btseDeleteOrder = "deleteOrder" + btseDeleteOrders = "deleteOrders" + btseFills = "fills" +) + +// SetDefaults sets the basic defaults for BTSE +func (b *BTSE) SetDefaults() { + b.Name = "BTSE" + b.Enabled = false + b.Verbose = false + b.RESTPollingDelay = 10 + b.APIWithdrawPermissions = exchange.NoAPIWithdrawalMethods + b.RequestCurrencyPairFormat.Delimiter = "-" + b.RequestCurrencyPairFormat.Uppercase = true + b.ConfigCurrencyPairFormat.Delimiter = "-" + b.ConfigCurrencyPairFormat.Uppercase = true + b.AssetTypes = []string{ticker.Spot} + b.Requester = request.New(b.Name, + request.NewRateLimit(time.Second, 0), + request.NewRateLimit(time.Second, 0), + common.NewHTTPClientWithTimeout(exchange.DefaultHTTPTimeout)) + b.APIUrlDefault = btseAPIURL + b.APIUrl = b.APIUrlDefault + b.SupportsAutoPairUpdating = true + b.SupportsRESTTickerBatching = false + b.WebsocketInit() + b.Websocket.Functionality = exchange.WebsocketOrderbookSupported | + exchange.WebsocketTickerSupported +} + +// Setup takes in the supplied exchange configuration details and sets params +func (b *BTSE) Setup(exch config.ExchangeConfig) { + if !exch.Enabled { + b.SetEnabled(false) + } else { + b.Enabled = true + b.AuthenticatedAPISupport = exch.AuthenticatedAPISupport + b.SetAPIKeys(exch.APIKey, exch.APISecret, "", false) + b.SetHTTPClientTimeout(exch.HTTPTimeout) + b.SetHTTPClientUserAgent(exch.HTTPUserAgent) + b.RESTPollingDelay = exch.RESTPollingDelay + b.Verbose = exch.Verbose + b.Websocket.SetEnabled(exch.Websocket) + b.BaseCurrencies = common.SplitStrings(exch.BaseCurrencies, ",") + b.AvailablePairs = common.SplitStrings(exch.AvailablePairs, ",") + b.EnabledPairs = common.SplitStrings(exch.EnabledPairs, ",") + err := b.SetCurrencyPairFormat() + if err != nil { + log.Fatal(err) + } + err = b.SetAssetTypes() + if err != nil { + log.Fatal(err) + } + err = b.SetAutoPairDefaults() + if err != nil { + log.Fatal(err) + } + err = b.SetAPIURL(exch) + if err != nil { + log.Fatal(err) + } + err = b.SetClientProxyAddress(exch.ProxyAddress) + if err != nil { + log.Fatal(err) + } + err = b.WebsocketSetup(b.WsConnect, + exch.Name, + exch.Websocket, + btseWebsocket, + exch.WebsocketURL) + if err != nil { + log.Fatal(err) + } + } +} + +// GetMarkets returns a list of markets available on BTSE +func (b *BTSE) GetMarkets() (*Markets, error) { + var m Markets + return &m, b.SendHTTPRequest(http.MethodGet, btseMarkets, &m) +} + +// GetTrades returns a list of trades for the specified symbol +func (b *BTSE) GetTrades(symbol string) (*Trades, error) { + var t Trades + endpoint := fmt.Sprintf("%s/%s", btseTrades, symbol) + return &t, b.SendHTTPRequest(http.MethodGet, endpoint, &t) + +} + +// GetTicker returns the ticker for a specified symbol +func (b *BTSE) GetTicker(symbol string) (*Ticker, error) { + type tickerResponse struct { + Price interface{} `json:"price"` + Size float64 `json:"size,string"` + Bid float64 `json:"bid,string"` + Ask float64 `json:"ask,string"` + Volume float64 `json:"volume,string"` + Time string `json:"time"` + } + + var r tickerResponse + endpoint := fmt.Sprintf("%s/%s", btseTicker, symbol) + err := b.SendHTTPRequest(http.MethodGet, endpoint, &r) + if err != nil { + return nil, err + } + + p := strings.Replace(r.Price.(string), ",", "", -1) + price, err := strconv.ParseFloat(p, 64) + if err != nil { + return nil, err + } + + return &Ticker{ + Price: price, + Size: r.Size, + Bid: r.Bid, + Ask: r.Ask, + Volume: r.Volume, + Time: r.Time, + }, nil +} + +// GetMarketStatistics gets market statistics for a specificed market +func (b *BTSE) GetMarketStatistics(symbol string) (*MarketStatistics, error) { + var m MarketStatistics + endpoint := fmt.Sprintf("%s/%s", btseStats, symbol) + return &m, b.SendHTTPRequest(http.MethodGet, endpoint, &m) +} + +// GetServerTime returns the exchanges server time +func (b *BTSE) GetServerTime() (*ServerTime, error) { + var s ServerTime + return &s, b.SendHTTPRequest(http.MethodGet, btseTime, &s) +} + +// GetAccountBalance returns the users account balance +func (b *BTSE) GetAccountBalance() (*AccountBalance, error) { + var a AccountBalance + return &a, b.SendAuthenticatedHTTPRequest(http.MethodGet, btseAccount, nil, &a) +} + +// CreateOrder creates an order +func (b *BTSE) CreateOrder(amount, price float64, side, orderType, symbol, timeInForce, tag string) (*string, error) { + req := make(map[string]interface{}) + req["amount"] = strconv.FormatFloat(amount, 'f', -1, 64) + req["price"] = strconv.FormatFloat(price, 'f', -1, 64) + req["side"] = side + req["type"] = orderType + req["product_id"] = symbol + + if timeInForce != "" { + req["time_in_force"] = timeInForce + } + + if tag != "" { + req["tag"] = tag + } + + type orderResp struct { + ID string `json:"id"` + } + + var r orderResp + return &r.ID, b.SendAuthenticatedHTTPRequest(http.MethodPost, btseOrder, req, &r) +} + +// GetOrders returns all pending orders +func (b *BTSE) GetOrders(productID string) (*OpenOrders, error) { + req := make(map[string]interface{}) + if productID != "" { + req["product_id"] = productID + } + var o OpenOrders + return &o, b.SendAuthenticatedHTTPRequest(http.MethodGet, btsePendingOrders, req, &o) +} + +// CancelExistingOrder cancels an order +func (b *BTSE) CancelExistingOrder(orderID, productID string) (*CancelOrder, error) { + var c CancelOrder + req := make(map[string]interface{}) + req["order_id"] = orderID + req["product_id"] = productID + return &c, b.SendAuthenticatedHTTPRequest(http.MethodPost, btseDeleteOrder, req, &c) +} + +// CancelOrders cancels all orders +// productID optional. If product ID is sent, all orders of that specified market +// will be cancelled. If not specified, all orders of all markets will be cancelled +func (b *BTSE) CancelOrders(productID string) (*CancelOrder, error) { + var c CancelOrder + req := make(map[string]interface{}) + if productID != "" { + req["product_id"] = productID + } + return &c, b.SendAuthenticatedHTTPRequest(http.MethodPost, btseDeleteOrders, req, &c) +} + +// GetFills gets all filled orders +func (b *BTSE) GetFills(orderID, productID, before, after, limit string) (*FilledOrders, error) { + if orderID != "" && productID != "" { + return nil, errors.New("orderID and productID cannot co-exist in the same query") + } else if orderID == "" && productID == "" { + return nil, errors.New("orderID OR productID must be set") + } + + req := make(map[string]interface{}) + if orderID != "" { + req["order_id"] = orderID + } + + if productID != "" { + req["product_id"] = productID + } + + if before != "" { + req["before"] = before + } + + if after != "" { + req["after"] = after + } + + if limit != "" { + req["limit"] = limit + } + + var o FilledOrders + return &o, b.SendAuthenticatedHTTPRequest(http.MethodPost, btseFills, req, &o) +} + +// SendHTTPRequest sends an HTTP request to the desired endpoint +func (b *BTSE) SendHTTPRequest(method, endpoint string, result interface{}) error { + p := fmt.Sprintf("%s/%s", btseAPIURL, endpoint) + return b.SendPayload(method, p, nil, nil, &result, false, b.Verbose) +} + +// SendAuthenticatedHTTPRequest sends an authenticated HTTP request to the desired endpoint +func (b *BTSE) SendAuthenticatedHTTPRequest(method, endpoint string, req map[string]interface{}, result interface{}) error { + if !b.AuthenticatedAPISupport { + return fmt.Errorf(exchange.WarningAuthenticatedRequestWithoutCredentialsSet, b.Name) + } + + payload, err := common.JSONEncode(req) + if err != nil { + return errors.New("sendAuthenticatedAPIRequest: unable to JSON request") + } + + headers := make(map[string]string) + headers["API-KEY"] = b.APIKey + headers["API-PASSPHRASE"] = b.APISecret + if len(payload) > 0 { + headers["Content-Type"] = "application/json" + } + + p := fmt.Sprintf("%s/%s", btseAPIURL, endpoint) + if b.Verbose { + log.Debugf("Sending %s request to URL %s with params %s\n", method, p, string(payload)) + } + return b.SendPayload(method, p, headers, strings.NewReader(string(payload)), + &result, true, b.Verbose) +} + +// GetFee returns an estimate of fee based on type of transaction +func (b *BTSE) GetFee(feeBuilder exchange.FeeBuilder) (float64, error) { + var fee float64 + + switch feeBuilder.FeeType { + case exchange.CryptocurrencyTradeFee: + fee = calculateTradingFee(feeBuilder.IsMaker) + case exchange.CryptocurrencyWithdrawalFee: + if feeBuilder.FirstCurrency == symbol.BTC { + fee = 0.0005 + } else if feeBuilder.FirstCurrency == symbol.USDT { + fee = 5 + } + case exchange.InternationalBankDepositFee: + fee = getInternationalBankDepositFee(feeBuilder.Amount) + case exchange.InternationalBankWithdrawalFee: + fee = getInternationalBankWithdrawalFee(feeBuilder.Amount) + } + return fee, nil +} + +// getInternationalBankDepositFee returns international deposit fee +// Only when the initial deposit amount is less than $1000 or equivalent, +// BTSE will charge a small fee (0.25% or $3 USD equivalent, whichever is greater). +// The small deposit fee is charged in whatever currency it comes in. +func getInternationalBankDepositFee(amount float64) float64 { + var fee float64 + if amount <= 1000 { + fee = amount * 0.0025 + if fee < 3 { + return 3 + } + } + return fee +} + +// getInternationalBankWithdrawalFee returns international withdrawal fee +// 0.1% (min25 USD) +func getInternationalBankWithdrawalFee(amount float64) float64 { + fee := amount * 0.001 + + if fee < 25 { + return 25 + } + return fee +} + +// calculateTradingFee BTSE has fee tiers, but does not disclose them via API, +// so the largest fee has to be assumed +func calculateTradingFee(isMaker bool) float64 { + fee := 0.00050 + if !isMaker { + fee = 0.0015 + } + return fee +} + +func parseOrderTime(timeStr string) time.Time { + t, _ := time.Parse("2006-01-02 15:04:04", timeStr) + return t +} diff --git a/exchanges/btse/btse_test.go b/exchanges/btse/btse_test.go new file mode 100644 index 00000000..e1cae180 --- /dev/null +++ b/exchanges/btse/btse_test.go @@ -0,0 +1,298 @@ +package btse + +import ( + "testing" + + "github.com/thrasher-/gocryptotrader/common" + "github.com/thrasher-/gocryptotrader/config" + "github.com/thrasher-/gocryptotrader/currency/pair" + "github.com/thrasher-/gocryptotrader/currency/symbol" + exchange "github.com/thrasher-/gocryptotrader/exchanges" +) + +// Please supply your own keys here to do better tests +const ( + apiKey = "" + apiSecret = "" + canManipulateRealOrders = false +) + +var b BTSE + +func TestSetDefaults(t *testing.T) { + b.SetDefaults() +} + +func TestSetup(t *testing.T) { + cfg := config.GetConfig() + cfg.LoadConfig("../../testdata/configtest.json") + btseConfig, err := cfg.GetExchangeConfig("BTSE") + if err != nil { + t.Error("Test Failed - BTSE Setup() init error") + } + + btseConfig.AuthenticatedAPISupport = true + btseConfig.APIKey = apiKey + btseConfig.APISecret = apiSecret + + b.Setup(btseConfig) +} + +func TestGetMarkets(t *testing.T) { + b.SetDefaults() + _, err := b.GetMarkets() + if err != nil { + t.Fatalf("Test failed. Err: %s", err) + } +} + +func TestGetTrades(t *testing.T) { + b.SetDefaults() + _, err := b.GetTrades("BTC-USD") + if err != nil { + t.Fatalf("Test failed. Err: %s", err) + } +} + +func TestGetTicker(t *testing.T) { + b.SetDefaults() + _, err := b.GetTicker("BTC-USD") + if err != nil { + t.Fatalf("Test failed. Err: %s", err) + } +} + +func TestGetMarketStatistics(t *testing.T) { + b.SetDefaults() + _, err := b.GetMarketStatistics("BTC-USD") + if err != nil { + t.Fatalf("Test failed. Err: %s", err) + } +} + +func TestGetServerTime(t *testing.T) { + b.SetDefaults() + _, err := b.GetServerTime() + if err != nil { + t.Fatalf("Test failed. Err: %s", err) + } +} + +func TestGetAccount(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + _, err := b.GetAccountBalance() + if areTestAPIKeysSet() && err != nil { + t.Errorf("Could not get account balance: %s", err) + } else if !areTestAPIKeysSet() && err == nil { + t.Error("Expecting an error when no keys are set") + } +} + +func TestGetFills(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + _, err := b.GetFills("", "BTC-USD", "", "", "") + if areTestAPIKeysSet() && err != nil { + t.Errorf("Could not get fills: %s", err) + } else if !areTestAPIKeysSet() && err == nil { + t.Error("Expecting an error when no keys are set") + } + +} + +func TestGetActiveOrders(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + var getOrdersRequest = exchange.GetOrdersRequest{ + OrderType: exchange.AnyOrderType, + } + + _, err := b.GetActiveOrders(getOrdersRequest) + if areTestAPIKeysSet() && err != nil { + t.Errorf("Could not get open orders: %s", err) + } else if !areTestAPIKeysSet() && err == nil { + t.Error("Expecting an error when no keys are set") + } +} + +func TestGetOrderHistory(t *testing.T) { + b.SetDefaults() + TestSetup(t) + var getOrdersRequest = exchange.GetOrdersRequest{ + OrderType: exchange.AnyOrderType, + } + + _, err := b.GetOrderHistory(getOrdersRequest) + if err != common.ErrFunctionNotSupported { + t.Fatal("Test failed. Expected different result") + } +} + +func TestFormatWithdrawPermissions(t *testing.T) { + b.SetDefaults() + expected := exchange.NoAPIWithdrawalMethodsText + actual := b.FormatWithdrawPermissions() + if actual != expected { + t.Errorf("Expected: %s, Received: %s", expected, actual) + } +} + +func TestGetFee(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + feeBuilder := exchange.FeeBuilder{ + FeeType: exchange.CryptocurrencyTradeFee, + FirstCurrency: "BTC", + SecondCurrency: "USD", + IsMaker: true, + Amount: 1000, + } + + if resp, err := b.GetFee(feeBuilder); resp != 0.00050 || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", 0.00050, resp) + t.Error(err) + } + + feeBuilder.IsMaker = false + if resp, err := b.GetFee(feeBuilder); resp != 0.0015 || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", 0.0015, resp) + t.Error(err) + } + + feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee + if resp, err := b.GetFee(feeBuilder); resp != 0.0005 || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", 0.0005, resp) + t.Error(err) + } + + feeBuilder.FirstCurrency = "USDT" + if resp, err := b.GetFee(feeBuilder); resp != float64(5) || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(5), resp) + t.Error(err) + } + + feeBuilder.FeeType = exchange.InternationalBankDepositFee + if resp, err := b.GetFee(feeBuilder); resp != float64(3) || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(3), resp) + t.Error(err) + } + + feeBuilder.Amount = 1000000 + if resp, err := b.GetFee(feeBuilder); resp != float64(0) || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp) + t.Error(err) + } + + feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee + if resp, err := b.GetFee(feeBuilder); resp != float64(1000) || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(1000), resp) + t.Error(err) + } + + feeBuilder.Amount = 1000 + if resp, err := b.GetFee(feeBuilder); resp != float64(25) || err != nil { + t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(25), resp) + t.Error(err) + } +} + +func TestParseOrderTime(t *testing.T) { + expected := int64(1534794360) + actual := parseOrderTime("2018-08-20 19:20:46").Unix() + if expected != actual { + t.Errorf("Test Failed. TestParseOrderTime expected: %d, got %d", expected, actual) + } +} + +func areTestAPIKeysSet() bool { + if b.APIKey != "" && b.APIKey != "Key" && + b.APISecret != "" && b.APISecret != "Secret" { + return true + } + return false +} + +// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them +// ---------------------------------------------------------------------------------------------------------------------------- +func TestSubmitOrder(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + if areTestAPIKeysSet() && !canManipulateRealOrders { + t.Skip("API keys set, canManipulateRealOrders false, skipping test") + } + + var p = pair.CurrencyPair{ + Delimiter: "", + FirstCurrency: symbol.BTC, + SecondCurrency: symbol.USD, + } + response, err := b.SubmitOrder(p, exchange.SellOrderSide, exchange.LimitOrderType, 0.01, 1000000, "clientId") + if areTestAPIKeysSet() && (err != nil || !response.IsOrderPlaced) { + t.Errorf("Order failed to be placed: %v", err) + } else if !areTestAPIKeysSet() && err == nil { + t.Error("Expecting an error when no keys are set") + } +} + +func TestCancelExchangeOrder(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + if areTestAPIKeysSet() && !canManipulateRealOrders { + t.Skip("API keys set, canManipulateRealOrders false, skipping test") + } + + currencyPair := pair.NewCurrencyPairWithDelimiter(symbol.BTC, symbol.USD, "-") + + var orderCancellation = exchange.OrderCancellation{ + OrderID: "0b66ccaf-dfd4-4b9f-a30b-2380b9c7b66d", + WalletAddress: "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB", + AccountID: "1", + CurrencyPair: currencyPair, + } + + err := b.CancelOrder(orderCancellation) + if !areTestAPIKeysSet() && err == nil { + t.Error("Expecting an error when no keys are set") + } + if areTestAPIKeysSet() && err != nil { + t.Errorf("Could not cancel orders: %v", err) + } +} + +func TestCancelAllExchangeOrders(t *testing.T) { + b.SetDefaults() + TestSetup(t) + + if areTestAPIKeysSet() && !canManipulateRealOrders { + t.Skip("API keys set, canManipulateRealOrders false, skipping test") + } + + currencyPair := pair.NewCurrencyPairWithDelimiter(symbol.BTC, symbol.USD, "-") + + var orderCancellation = exchange.OrderCancellation{ + OrderID: "1", + WalletAddress: "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB", + AccountID: "1", + CurrencyPair: currencyPair, + } + + resp, err := b.CancelAllOrders(orderCancellation) + + if !areTestAPIKeysSet() && err == nil { + t.Error("Expecting an error when no keys are set") + } + if areTestAPIKeysSet() && err != nil { + t.Errorf("Could not cancel orders: %v", err) + } + + if len(resp.OrderStatus) > 0 { + t.Errorf("%v orders failed to cancel", len(resp.OrderStatus)) + } +} diff --git a/exchanges/btse/btse_types.go b/exchanges/btse/btse_types.go new file mode 100644 index 00000000..51a1eea8 --- /dev/null +++ b/exchanges/btse/btse_types.go @@ -0,0 +1,135 @@ +package btse + +// Market stores market data +type Market struct { + ID string `json:"id"` + BaseCurrency string `json:"base_currency"` + QuoteCurrency string `json:"quote_currency"` + BaseMinSize float64 `json:"base_min_size"` + BaseMaxSize float64 `json:"base_max_size"` + BaseIncremementSize float64 `json:"base_increment_size"` + QuoteMinPrice float64 `json:"quote_min_price"` + QuoteIncrement float64 `json:"quote_increment"` + Status string `json:"status"` +} + +// Markets stores an array of market data +type Markets []Market + +// Trade stores trade data +type Trade struct { + SerialID string `json:"serial_id"` + Symbol string `json:"symbol"` + Price float64 `json:"price"` + Amount float64 `json:"amount"` + Time string `json:"time"` + Type string `json:"type"` +} + +// Trades stores an array of trade data +type Trades []Trade + +// Ticker stores the ticker data +type Ticker struct { + Price float64 + Size float64 + Bid float64 + Ask float64 + Volume float64 + Time string +} + +// MarketStatistics stores market statistics for a particular product +type MarketStatistics struct { + Open float64 `json:"open,string"` + Low float64 `json:"low,string"` + High float64 `json:"high,string"` + Close float64 `json:"close,string"` + Volume float64 `json:"volume,string"` + Time string `json:"time"` +} + +// ServerTime stores the server time data +type ServerTime struct { + ISO string `json:"iso"` + Epoch float64 `json:"epoch"` +} + +// CurrencyBalance stores the account info data +type CurrencyBalance struct { + Currency string `json:"currency"` + Total float64 `json:"total,string"` + Available float64 `json:"available,string"` +} + +// AccountBalance stores an array of currency balances +type AccountBalance []CurrencyBalance + +// Order stores the order info +type Order struct { + ID string `json:"id"` + Type string `json:"type"` + Side string `json:"side"` + Price float64 `json:"price"` + Amount float64 `json:"amount"` + Tag string `json:"tag"` + ProductID string `json:"product_id"` + CreatedAt string `json:"created_at"` +} + +// OpenOrder stores an open order info +type OpenOrder struct { + Order + Status string `json:"status"` +} + +// OpenOrders stores an array of orders +type OpenOrders []OpenOrder + +// CancelOrder stores the cancel order response data +type CancelOrder struct { + Code int `json:"code"` + Time int64 `json:"time"` +} + +// FilledOrder stores filled order data +type FilledOrder struct { + Price float64 `json:"price"` + Amount float64 `json:"amount"` + Fee float64 `json:"fee"` + Side string `json:"side"` + Tag string `json:"tag"` + ID int64 `json:"id"` + TradeID string `json:"trade_id"` + ProductID string `json:"product_id"` + OrderID string `json:"order_id"` + CreatedAt string `json:"created_at"` +} + +// FilledOrders stores an array of filled orders +type FilledOrders []FilledOrder + +type websocketSubscribe struct { + Type string `json:"type"` + Channels []websocketChannel `json:"channels"` +} + +type websocketChannel struct { + Name string `json:"name"` + ProductIDs []string `json:"product_ids"` +} + +type wsTicker struct { + BestAsk float64 `json:"best_ask,string"` + BestBids float64 `json:"best_bid,string"` + LastSize float64 `json:"last_size,string"` + Price interface{} `json:"price"` + ProductID string `json:"product_id"` +} + +type websocketOrderbookSnapshot struct { + ProductID string `json:"product_id"` + Type string `json:"type"` + Bids [][]interface{} `json:"bids"` + Asks [][]interface{} `json:"asks"` +} diff --git a/exchanges/btse/btse_websocket.go b/exchanges/btse/btse_websocket.go new file mode 100644 index 00000000..0792769b --- /dev/null +++ b/exchanges/btse/btse_websocket.go @@ -0,0 +1,223 @@ +package btse + +import ( + "errors" + "fmt" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "github.com/gorilla/websocket" + "github.com/thrasher-/gocryptotrader/common" + "github.com/thrasher-/gocryptotrader/currency/pair" + exchange "github.com/thrasher-/gocryptotrader/exchanges" + "github.com/thrasher-/gocryptotrader/exchanges/orderbook" +) + +const ( + btseWebsocket = "wss://ws.btse.com/api/ws-feed" +) + +// WebsocketSubscriber subscribes to websocket channels with respect to enabled +// currencies +func (b *BTSE) WebsocketSubscriber() error { + subscribe := websocketSubscribe{ + Type: "subscribe", + Channels: []websocketChannel{ + { + Name: "snapshot", + ProductIDs: b.EnabledPairs, + }, + { + Name: "ticker", + ProductIDs: b.EnabledPairs, + }, + }, + } + + data, err := common.JSONEncode(subscribe) + if err != nil { + return err + } + + return b.WebsocketConn.WriteMessage(websocket.TextMessage, data) +} + +// WsConnect connects the websocket client +func (b *BTSE) WsConnect() error { + if !b.Websocket.IsEnabled() || !b.IsEnabled() { + return errors.New(exchange.WebsocketNotEnabled) + } + + var dialer websocket.Dialer + + if b.Websocket.GetProxyAddress() != "" { + proxy, err := url.Parse(b.Websocket.GetProxyAddress()) + if err != nil { + return fmt.Errorf("%s websocket error - proxy address %s", + b.Name, err) + } + + dialer.Proxy = http.ProxyURL(proxy) + } + + var err error + b.WebsocketConn, _, err = dialer.Dial(b.Websocket.GetWebsocketURL(), + http.Header{}) + if err != nil { + return fmt.Errorf("%s websocket error - unable to connect %s", + b.Name, err) + } + + err = b.WebsocketSubscriber() + if err != nil { + return err + } + + go b.WsHandleData() + + return nil +} + +// WsReadData reads data from the websocket connection +func (b *BTSE) WsReadData() (exchange.WebsocketResponse, error) { + _, resp, err := b.WebsocketConn.ReadMessage() + if err != nil { + return exchange.WebsocketResponse{}, err + } + + b.Websocket.TrafficAlert <- struct{}{} + return exchange.WebsocketResponse{Raw: resp}, nil +} + +// WsHandleData handles read data from websocket connection +func (b *BTSE) WsHandleData() { + b.Websocket.Wg.Add(1) + + defer func() { + err := b.WebsocketConn.Close() + if err != nil { + b.Websocket.DataHandler <- fmt.Errorf("%s - Unable to to close Websocket connection. Error: %s", + b.Name, err) + } + b.Websocket.Wg.Done() + }() + + for { + select { + case <-b.Websocket.ShutdownC: + return + + default: + resp, err := b.WsReadData() + if err != nil { + b.Websocket.DataHandler <- err + return + } + + type MsgType struct { + Type string `json:"type"` + ProductID string `json:"product_id"` + } + + msgType := MsgType{} + err = common.JSONDecode(resp.Raw, &msgType) + if err != nil { + b.Websocket.DataHandler <- err + continue + } + + switch msgType.Type { + case "ticker": + var t wsTicker + err = common.JSONDecode(resp.Raw, &t) + if err != nil { + b.Websocket.DataHandler <- err + continue + } + p := strings.Replace(t.Price.(string), ",", "", -1) + price, err := strconv.ParseFloat(p, 64) + if err != nil { + b.Websocket.DataHandler <- err + continue + } + + b.Websocket.DataHandler <- exchange.TickerData{ + Timestamp: time.Now(), + Pair: pair.NewCurrencyPairDelimiter(t.ProductID, "-"), + AssetType: "SPOT", + Exchange: b.GetName(), + OpenPrice: price, + } + case "snapshot": + snapshot := websocketOrderbookSnapshot{} + err := common.JSONDecode(resp.Raw, &snapshot) + if err != nil { + b.Websocket.DataHandler <- err + continue + } + + err = b.wsProcessSnapshot(snapshot) + if err != nil { + b.Websocket.DataHandler <- err + continue + } + } + } + } +} + +// ProcessSnapshot processes the initial orderbook snap shot +func (b *BTSE) wsProcessSnapshot(snapshot websocketOrderbookSnapshot) error { + var base orderbook.Base + for _, bid := range snapshot.Bids { + p := strings.Replace(bid[0].(string), ",", "", -1) + price, err := strconv.ParseFloat(p, 64) + if err != nil { + return err + } + + a := strings.Replace(bid[1].(string), ",", "", -1) + amount, err := strconv.ParseFloat(a, 64) + if err != nil { + return err + } + + base.Bids = append(base.Bids, + orderbook.Item{Price: price, Amount: amount}) + } + + for _, ask := range snapshot.Asks { + p := strings.Replace(ask[0].(string), ",", "", -1) + price, err := strconv.ParseFloat(p, 64) + if err != nil { + return err + } + + a := strings.Replace(ask[1].(string), ",", "", -1) + amount, err := strconv.ParseFloat(a, 64) + if err != nil { + return err + } + + base.Asks = append(base.Asks, + orderbook.Item{Price: price, Amount: amount}) + } + + p := pair.NewCurrencyPairDelimiter(snapshot.ProductID, "-") + base.AssetType = "SPOT" + base.Pair = p + base.CurrencyPair = snapshot.ProductID + base.LastUpdated = time.Now() + orderbook.ProcessOrderbook(b.Name, p, base, "SPOT") + + b.Websocket.DataHandler <- exchange.WebsocketOrderbookUpdate{ + Pair: p, + Asset: "SPOT", + Exchange: b.GetName(), + } + + return nil +} diff --git a/exchanges/btse/btse_wrapper.go b/exchanges/btse/btse_wrapper.go new file mode 100644 index 00000000..857333d0 --- /dev/null +++ b/exchanges/btse/btse_wrapper.go @@ -0,0 +1,346 @@ +package btse + +import ( + "errors" + "fmt" + "strings" + "sync" + "time" + + "github.com/thrasher-/gocryptotrader/common" + "github.com/thrasher-/gocryptotrader/currency/pair" + exchange "github.com/thrasher-/gocryptotrader/exchanges" + "github.com/thrasher-/gocryptotrader/exchanges/orderbook" + "github.com/thrasher-/gocryptotrader/exchanges/ticker" + log "github.com/thrasher-/gocryptotrader/logger" +) + +// Start starts the BTSE go routine +func (b *BTSE) Start(wg *sync.WaitGroup) { + wg.Add(1) + go func() { + b.Run() + wg.Done() + }() +} + +// Run implements the BTSE wrapper +func (b *BTSE) Run() { + if b.Verbose { + log.Debugf("%s Websocket: %s. (url: %s).\n", b.GetName(), common.IsEnabled(b.Websocket.IsEnabled()), b.Websocket.GetWebsocketURL()) + log.Debugf("%s polling delay: %ds.\n", b.GetName(), b.RESTPollingDelay) + log.Debugf("%s %d currencies enabled: %s.\n", b.GetName(), len(b.EnabledPairs), b.EnabledPairs) + } + + markets, err := b.GetMarkets() + if err != nil { + log.Errorf("%s failed to get trading pairs. Err: %s", b.Name, err) + } else { + var currencies []string + for _, m := range *markets { + currencies = append(currencies, m.ID) + } + err = b.UpdateCurrencies(currencies, false, false) + if err != nil { + log.Errorf("%s Failed to update available currencies.\n", b.Name) + } + } + +} + +// UpdateTicker updates and returns the ticker for a currency pair +func (b *BTSE) UpdateTicker(p pair.CurrencyPair, assetType string) (ticker.Price, error) { + var tickerPrice ticker.Price + + t, err := b.GetTicker(exchange.FormatExchangeCurrency(b.Name, p).String()) + if err != nil { + return tickerPrice, err + } + + s, err := b.GetMarketStatistics(exchange.FormatExchangeCurrency(b.Name, p).String()) + if err != nil { + return tickerPrice, err + + } + + tickerPrice.Pair = p + tickerPrice.Ask = t.Ask + tickerPrice.Bid = t.Bid + tickerPrice.Low = s.Low + tickerPrice.Last = t.Price + tickerPrice.Volume = s.Volume + tickerPrice.High = s.High + ticker.ProcessTicker(b.GetName(), p, tickerPrice, assetType) + return ticker.GetTicker(b.Name, p, assetType) +} + +// GetTickerPrice returns the ticker for a currency pair +func (b *BTSE) GetTickerPrice(p pair.CurrencyPair, assetType string) (ticker.Price, error) { + tickerNew, err := ticker.GetTicker(b.GetName(), p, assetType) + if err != nil { + return b.UpdateTicker(p, assetType) + } + return tickerNew, nil +} + +// GetOrderbookEx returns orderbook base on the currency pair +func (b *BTSE) GetOrderbookEx(p pair.CurrencyPair, assetType string) (orderbook.Base, error) { + ob, err := orderbook.GetOrderbook(b.GetName(), p, assetType) + if err != nil { + return b.UpdateOrderbook(p, assetType) + } + return ob, nil +} + +// UpdateOrderbook updates and returns the orderbook for a currency pair +func (b *BTSE) UpdateOrderbook(p pair.CurrencyPair, assetType string) (orderbook.Base, error) { + return orderbook.Base{}, common.ErrFunctionNotSupported +} + +// GetAccountInfo retrieves balances for all enabled currencies for the +// BTSE exchange +func (b *BTSE) GetAccountInfo() (exchange.AccountInfo, error) { + var a exchange.AccountInfo + balance, err := b.GetAccountBalance() + if err != nil { + return a, err + } + + var currencies []exchange.AccountCurrencyInfo + for _, b := range *balance { + currencies = append(currencies, + exchange.AccountCurrencyInfo{ + CurrencyName: b.Currency, + TotalValue: b.Total, + Hold: b.Available, + }, + ) + } + a.Exchange = b.Name + a.Accounts = []exchange.Account{ + { + Currencies: currencies, + }, + } + return a, nil +} + +// GetFundingHistory returns funding history, deposits and +// withdrawals +func (b *BTSE) GetFundingHistory() ([]exchange.FundHistory, error) { + return nil, common.ErrFunctionNotSupported +} + +// GetExchangeHistory returns historic trade data since exchange opening. +func (b *BTSE) GetExchangeHistory(p pair.CurrencyPair, assetType string) ([]exchange.TradeHistory, error) { + return nil, common.ErrNotYetImplemented +} + +// SubmitOrder submits a new order +func (b *BTSE) SubmitOrder(p pair.CurrencyPair, side exchange.OrderSide, orderType exchange.OrderType, amount, price float64, clientID string) (exchange.SubmitOrderResponse, error) { + var resp exchange.SubmitOrderResponse + r, err := b.CreateOrder(amount, price, side.ToString(), + orderType.ToString(), exchange.FormatExchangeCurrency(b.Name, p).String(), "GTC", clientID) + if err != nil { + return resp, err + } + + if *r != "" { + resp.IsOrderPlaced = true + resp.OrderID = *r + } + + return resp, nil +} + +// ModifyOrder will allow of changing orderbook placement and limit to +// market conversion +func (b *BTSE) ModifyOrder(action exchange.ModifyOrder) (string, error) { + return "", common.ErrFunctionNotSupported +} + +// CancelOrder cancels an order by its corresponding ID number +func (b *BTSE) CancelOrder(order exchange.OrderCancellation) error { + r, err := b.CancelExistingOrder(order.OrderID, + exchange.FormatExchangeCurrency(b.Name, order.CurrencyPair).String()) + if err != nil { + return err + } + + switch r.Code { + case -1: + return errors.New("order cancellation unsuccessful") + case 4: + return errors.New("order cancellation timeout") + } + + return nil +} + +// CancelAllOrders cancels all orders associated with a currency pair +// If product ID is sent, all orders of that specified market will be cancelled +// If not specified, all orders of all markets will be cancelled +func (b *BTSE) CancelAllOrders(orderCancellation exchange.OrderCancellation) (exchange.CancelAllOrdersResponse, error) { + r, err := b.CancelOrders(exchange.FormatExchangeCurrency(b.Name, + orderCancellation.CurrencyPair).String()) + if err != nil { + return exchange.CancelAllOrdersResponse{}, err + } + + var resp exchange.CancelAllOrdersResponse + switch r.Code { + case -1: + return resp, errors.New("order cancellation unsuccessful") + case 4: + return resp, errors.New("order cancellation timeout") + } + + return resp, nil +} + +// GetOrderInfo returns information on a current open order +func (b *BTSE) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { + o, err := b.GetOrders("") + if err != nil { + return exchange.OrderDetail{}, err + } + + var od exchange.OrderDetail + if len(*o) == 0 { + return od, errors.New("no orders found") + } + + for _, o := range *o { + if o.ID != orderID { + continue + } + + var side = exchange.BuyOrderSide + if strings.EqualFold(o.Side, exchange.AskOrderSide.ToString()) { + side = exchange.SellOrderSide + } + + od.CurrencyPair = pair.NewCurrencyPairDelimiter(o.ProductID, + b.ConfigCurrencyPairFormat.Delimiter) + od.Exchange = b.Name + od.Amount = o.Amount + od.ID = o.ID + od.OrderDate = parseOrderTime(o.CreatedAt) + od.OrderSide = side + od.OrderType = exchange.OrderType(strings.ToUpper(o.Type)) + od.Price = o.Price + od.Status = o.Status + + fills, err := b.GetFills(orderID, "", "", "", "") + if err != nil { + return od, fmt.Errorf("unable to get order fills for orderID %s", orderID) + } + + for _, f := range *fills { + createdAt, _ := time.Parse(time.RFC3339, f.CreatedAt) + od.Trades = append(od.Trades, exchange.TradeHistory{ + Timestamp: createdAt, + TID: f.ID, + Price: f.Price, + Amount: f.Amount, + Exchange: b.Name, + Type: exchange.OrderSide(f.Side).ToString(), + Fee: f.Fee, + }) + } + } + return od, nil +} + +// GetDepositAddress returns a deposit address for a specified currency +func (b *BTSE) GetDepositAddress(cryptocurrency pair.CurrencyItem, accountID string) (string, error) { + return "", common.ErrFunctionNotSupported +} + +// WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is +// submitted +func (b *BTSE) WithdrawCryptocurrencyFunds(withdrawRequest exchange.WithdrawRequest) (string, error) { + return "", common.ErrFunctionNotSupported +} + +// WithdrawFiatFunds returns a withdrawal ID when a withdrawal is +// submitted +func (b *BTSE) WithdrawFiatFunds(withdrawRequest exchange.WithdrawRequest) (string, error) { + return "", common.ErrFunctionNotSupported +} + +// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a withdrawal is +// submitted +func (b *BTSE) WithdrawFiatFundsToInternationalBank(withdrawRequest exchange.WithdrawRequest) (string, error) { + return "", common.ErrFunctionNotSupported +} + +// GetWebsocket returns a pointer to the exchange websocket +func (b *BTSE) GetWebsocket() (*exchange.Websocket, error) { + return b.Websocket, nil +} + +// GetActiveOrders retrieves any orders that are active/open +func (b *BTSE) GetActiveOrders(getOrdersRequest exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) { + resp, err := b.GetOrders("") + if err != nil { + return nil, err + } + + var orders []exchange.OrderDetail + for _, order := range *resp { + var side = exchange.BuyOrderSide + if strings.EqualFold(order.Side, exchange.AskOrderSide.ToString()) { + side = exchange.SellOrderSide + } + + openOrder := exchange.OrderDetail{ + CurrencyPair: pair.NewCurrencyPairDelimiter(order.ProductID, + b.ConfigCurrencyPairFormat.Delimiter), + Exchange: b.Name, + Amount: order.Amount, + ID: order.ID, + OrderDate: parseOrderTime(order.CreatedAt), + OrderSide: side, + OrderType: exchange.OrderType(strings.ToUpper(order.Type)), + Price: order.Price, + Status: order.Status, + } + + fills, err := b.GetFills(order.ID, "", "", "", "") + if err != nil { + log.Errorf("unable to get order fills for orderID %s", order.ID) + continue + } + + for _, f := range *fills { + createdAt, _ := time.Parse(time.RFC3339, f.CreatedAt) + openOrder.Trades = append(openOrder.Trades, exchange.TradeHistory{ + Timestamp: createdAt, + TID: f.ID, + Price: f.Price, + Amount: f.Amount, + Exchange: b.Name, + Type: exchange.OrderSide(f.Side).ToString(), + Fee: f.Fee, + }) + } + orders = append(orders, openOrder) + } + + exchange.FilterOrdersByType(&orders, getOrdersRequest.OrderType) + exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks) + exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide) + return orders, nil +} + +// GetOrderHistory retrieves account order information +// Can Limit response to specific order status +func (b *BTSE) GetOrderHistory(getOrdersRequest exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) { + return nil, common.ErrFunctionNotSupported +} + +// GetFeeByType returns an estimate of fee based on type of transaction +func (b *BTSE) GetFeeByType(feeBuilder exchange.FeeBuilder) (float64, error) { + return b.GetFee(feeBuilder) +} diff --git a/exchanges/coinbasepro/coinbasepro_wrapper.go b/exchanges/coinbasepro/coinbasepro_wrapper.go index b6663f58..d8915486 100644 --- a/exchanges/coinbasepro/coinbasepro_wrapper.go +++ b/exchanges/coinbasepro/coinbasepro_wrapper.go @@ -198,7 +198,7 @@ func (c *CoinbasePro) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Ca } // GetOrderInfo returns information on a current open order -func (c *CoinbasePro) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (c *CoinbasePro) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/coinut/coinut_wrapper.go b/exchanges/coinut/coinut_wrapper.go index 25affd80..9e49b6fe 100644 --- a/exchanges/coinut/coinut_wrapper.go +++ b/exchanges/coinut/coinut_wrapper.go @@ -330,7 +330,7 @@ func (c *COINUT) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelA } // GetOrderInfo returns information on a current open order -func (c *COINUT) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (c *COINUT) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/exchange.go b/exchanges/exchange.go index 6477fb69..fd04d2c5 100644 --- a/exchanges/exchange.go +++ b/exchanges/exchange.go @@ -319,7 +319,7 @@ type IBotExchange interface { ModifyOrder(action ModifyOrder) (string, error) CancelOrder(order OrderCancellation) error CancelAllOrders(orders OrderCancellation) (CancelAllOrdersResponse, error) - GetOrderInfo(orderID int64) (OrderDetail, error) + GetOrderInfo(orderID string) (OrderDetail, error) GetDepositAddress(cryptocurrency pair.CurrencyItem, accountID string) (string, error) GetOrderHistory(getOrdersRequest GetOrdersRequest) ([]OrderDetail, error) diff --git a/exchanges/exmo/exmo_wrapper.go b/exchanges/exmo/exmo_wrapper.go index 34adb54e..ce922ea7 100644 --- a/exchanges/exmo/exmo_wrapper.go +++ b/exchanges/exmo/exmo_wrapper.go @@ -252,7 +252,7 @@ func (e *EXMO) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelAll } // GetOrderInfo returns information on a current open order -func (e *EXMO) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (e *EXMO) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/gateio/gateio_wrapper.go b/exchanges/gateio/gateio_wrapper.go index bbc7461a..e292ee1a 100644 --- a/exchanges/gateio/gateio_wrapper.go +++ b/exchanges/gateio/gateio_wrapper.go @@ -263,7 +263,7 @@ func (g *Gateio) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelA } // GetOrderInfo returns information on a current open order -func (g *Gateio) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (g *Gateio) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/gemini/gemini_wrapper.go b/exchanges/gemini/gemini_wrapper.go index c615d036..6e052072 100644 --- a/exchanges/gemini/gemini_wrapper.go +++ b/exchanges/gemini/gemini_wrapper.go @@ -189,7 +189,7 @@ func (g *Gemini) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelA } // GetOrderInfo returns information on a current open order -func (g *Gemini) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (g *Gemini) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/hitbtc/hitbtc_wrapper.go b/exchanges/hitbtc/hitbtc_wrapper.go index 2231c022..8a3988e4 100644 --- a/exchanges/hitbtc/hitbtc_wrapper.go +++ b/exchanges/hitbtc/hitbtc_wrapper.go @@ -218,7 +218,7 @@ func (h *HitBTC) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelA } // GetOrderInfo returns information on a current open order -func (h *HitBTC) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (h *HitBTC) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/huobi/huobi_wrapper.go b/exchanges/huobi/huobi_wrapper.go index 61fce83a..aa0cd3ce 100644 --- a/exchanges/huobi/huobi_wrapper.go +++ b/exchanges/huobi/huobi_wrapper.go @@ -332,7 +332,7 @@ func (h *HUOBI) CancelAllOrders(orderCancellation exchange.OrderCancellation) (e } // GetOrderInfo returns information on a current open order -func (h *HUOBI) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (h *HUOBI) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/huobihadax/huobihadax_wrapper.go b/exchanges/huobihadax/huobihadax_wrapper.go index 82428739..a9cf773b 100644 --- a/exchanges/huobihadax/huobihadax_wrapper.go +++ b/exchanges/huobihadax/huobihadax_wrapper.go @@ -299,7 +299,7 @@ func (h *HUOBIHADAX) CancelAllOrders(orderCancellation exchange.OrderCancellatio } // GetOrderInfo returns information on a current open order -func (h *HUOBIHADAX) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (h *HUOBIHADAX) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/itbit/itbit_wrapper.go b/exchanges/itbit/itbit_wrapper.go index 356e0439..2d956da9 100644 --- a/exchanges/itbit/itbit_wrapper.go +++ b/exchanges/itbit/itbit_wrapper.go @@ -237,7 +237,7 @@ func (i *ItBit) CancelAllOrders(orderCancellation exchange.OrderCancellation) (e } // GetOrderInfo returns information on a current open order -func (i *ItBit) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (i *ItBit) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/kraken/kraken_wrapper.go b/exchanges/kraken/kraken_wrapper.go index 1861f981..4e149578 100644 --- a/exchanges/kraken/kraken_wrapper.go +++ b/exchanges/kraken/kraken_wrapper.go @@ -237,7 +237,7 @@ func (k *Kraken) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelA } // GetOrderInfo returns information on a current open order -func (k *Kraken) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (k *Kraken) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/lakebtc/lakebtc_wrapper.go b/exchanges/lakebtc/lakebtc_wrapper.go index 97bbfa67..4e4b28a3 100644 --- a/exchanges/lakebtc/lakebtc_wrapper.go +++ b/exchanges/lakebtc/lakebtc_wrapper.go @@ -204,7 +204,7 @@ func (l *LakeBTC) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cancel } // GetOrderInfo returns information on a current open order -func (l *LakeBTC) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (l *LakeBTC) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/localbitcoins/localbitcoins_wrapper.go b/exchanges/localbitcoins/localbitcoins_wrapper.go index a09a2304..231c4936 100644 --- a/exchanges/localbitcoins/localbitcoins_wrapper.go +++ b/exchanges/localbitcoins/localbitcoins_wrapper.go @@ -246,7 +246,7 @@ func (l *LocalBitcoins) CancelAllOrders(_ exchange.OrderCancellation) (exchange. } // GetOrderInfo returns information on a current open order -func (l *LocalBitcoins) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (l *LocalBitcoins) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/okcoin/okcoin_wrapper.go b/exchanges/okcoin/okcoin_wrapper.go index f14b0c2d..b2776610 100644 --- a/exchanges/okcoin/okcoin_wrapper.go +++ b/exchanges/okcoin/okcoin_wrapper.go @@ -283,7 +283,7 @@ func (o *OKCoin) CancelAllOrders(orderCancellation exchange.OrderCancellation) ( } // GetOrderInfo returns information on a current open order -func (o *OKCoin) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (o *OKCoin) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/okex/okex_wrapper.go b/exchanges/okex/okex_wrapper.go index 0ecfddc5..adb52fad 100644 --- a/exchanges/okex/okex_wrapper.go +++ b/exchanges/okex/okex_wrapper.go @@ -279,7 +279,7 @@ func (o *OKEX) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelAll } // GetOrderInfo returns information on a current open order -func (o *OKEX) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (o *OKEX) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/poloniex/poloniex_wrapper.go b/exchanges/poloniex/poloniex_wrapper.go index c6d76d8a..405082b9 100644 --- a/exchanges/poloniex/poloniex_wrapper.go +++ b/exchanges/poloniex/poloniex_wrapper.go @@ -237,7 +237,7 @@ func (p *Poloniex) CancelAllOrders(_ exchange.OrderCancellation) (exchange.Cance } // GetOrderInfo returns information on a current open order -func (p *Poloniex) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (p *Poloniex) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/yobit/yobit_test.go b/exchanges/yobit/yobit_test.go index ad0b3fc7..5631ba64 100644 --- a/exchanges/yobit/yobit_test.go +++ b/exchanges/yobit/yobit_test.go @@ -89,7 +89,7 @@ func TestGetOpenOrders(t *testing.T) { func TestGetOrderInfo(t *testing.T) { t.Parallel() - _, err := y.GetOrderInfo(6196974) + _, err := y.GetOrderInfo("6196974") if err == nil { t.Error("Test Failed - GetOrderInfo() error", err) } diff --git a/exchanges/yobit/yobit_wrapper.go b/exchanges/yobit/yobit_wrapper.go index 340ef671..f4efb818 100644 --- a/exchanges/yobit/yobit_wrapper.go +++ b/exchanges/yobit/yobit_wrapper.go @@ -221,7 +221,7 @@ func (y *Yobit) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelAl } // GetOrderInfo returns information on a current open order -func (y *Yobit) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (y *Yobit) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/exchanges/zb/zb_wrapper.go b/exchanges/zb/zb_wrapper.go index 38ef1297..81418eea 100644 --- a/exchanges/zb/zb_wrapper.go +++ b/exchanges/zb/zb_wrapper.go @@ -249,7 +249,7 @@ func (z *ZB) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelAllOr } // GetOrderInfo returns information on a current open order -func (z *ZB) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func (z *ZB) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { var orderDetail exchange.OrderDetail return orderDetail, common.ErrNotYetImplemented } diff --git a/testdata/configtest.json b/testdata/configtest.json index 9beb9770..da9cae83 100644 --- a/testdata/configtest.json +++ b/testdata/configtest.json @@ -115,13 +115,13 @@ { "Address": "1JCe8z4jJVNXSjohjM4i9Hh813dLCNx2Sy", "CoinType": "BTC", - "Balance": 53000.01330003, + "Balance": 53000.01393623, "Description": "" }, { "Address": "3Nxwenay9Z8Lc9JBiywExpnEFiLp6Afp8v", "CoinType": "BTC", - "Balance": 97848.28491436, + "Balance": 108848.2855427, "Description": "" }, { @@ -133,7 +133,7 @@ { "Address": "0xb794f5ea0ba39494ce839613fffba74279579268", "CoinType": "ETH", - "Balance": 0.25927504051326, + "Balance": 0.25555604051326, "Description": "" } ] @@ -204,7 +204,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "ETH-BTC,LTC-BTC,BNB-BTC,NEO-BTC,QTUM-ETH,EOS-ETH,SNT-ETH,BNT-ETH,GAS-BTC,BNB-ETH,BTC-USDT,ETH-USDT,OAX-ETH,DNT-ETH,MCO-ETH,MCO-BTC,WTC-BTC,WTC-ETH,LRC-BTC,LRC-ETH,QTUM-BTC,YOYO-BTC,OMG-BTC,OMG-ETH,ZRX-BTC,ZRX-ETH,STRAT-BTC,STRAT-ETH,SNGLS-BTC,SNGLS-ETH,BQX-BTC,BQX-ETH,KNC-BTC,KNC-ETH,FUN-BTC,FUN-ETH,SNM-BTC,SNM-ETH,NEO-ETH,IOTA-BTC,IOTA-ETH,LINK-BTC,LINK-ETH,XVG-BTC,XVG-ETH,SALT-BTC,SALT-ETH,MDA-BTC,MDA-ETH,MTL-BTC,MTL-ETH,SUB-BTC,SUB-ETH,EOS-BTC,SNT-BTC,ETC-ETH,ETC-BTC,MTH-BTC,MTH-ETH,ENG-BTC,ENG-ETH,DNT-BTC,ZEC-BTC,ZEC-ETH,BNT-BTC,AST-BTC,AST-ETH,DASH-BTC,DASH-ETH,OAX-BTC,BTG-BTC,BTG-ETH,EVX-BTC,EVX-ETH,REQ-BTC,REQ-ETH,VIB-BTC,VIB-ETH,TRX-BTC,TRX-ETH,POWR-BTC,POWR-ETH,ARK-BTC,ARK-ETH,YOYO-ETH,XRP-BTC,XRP-ETH,MOD-BTC,MOD-ETH,ENJ-BTC,ENJ-ETH,STORJ-BTC,STORJ-ETH,BNB-USDT,YOYO-BNB,POWR-BNB,KMD-BTC,KMD-ETH,NULS-BNB,RCN-BTC,RCN-ETH,RCN-BNB,NULS-BTC,NULS-ETH,RDN-BTC,RDN-ETH,RDN-BNB,XMR-BTC,XMR-ETH,DLT-BNB,WTC-BNB,DLT-BTC,DLT-ETH,AMB-BTC,AMB-ETH,AMB-BNB,BAT-BTC,BAT-ETH,BAT-BNB,BCPT-BTC,BCPT-ETH,BCPT-BNB,ARN-BTC,ARN-ETH,GVT-BTC,GVT-ETH,CDT-BTC,CDT-ETH,GXS-BTC,GXS-ETH,NEO-USDT,NEO-BNB,POE-BTC,POE-ETH,QSP-BTC,QSP-ETH,QSP-BNB,BTS-BTC,BTS-ETH,BTS-BNB,XZC-BTC,XZC-ETH,XZC-BNB,LSK-BTC,LSK-ETH,LSK-BNB,TNT-BTC,TNT-ETH,FUEL-BTC,FUEL-ETH,MANA-BTC,MANA-ETH,BCD-BTC,BCD-ETH,DGD-BTC,DGD-ETH,IOTA-BNB,ADX-BTC,ADX-ETH,ADX-BNB,ADA-BTC,ADA-ETH,PPT-BTC,PPT-ETH,CMT-BTC,CMT-ETH,CMT-BNB,XLM-BTC,XLM-ETH,XLM-BNB,CND-BTC,CND-ETH,CND-BNB,LEND-BTC,LEND-ETH,WABI-BTC,WABI-ETH,WABI-BNB,LTC-ETH,LTC-USDT,LTC-BNB,TNB-BTC,TNB-ETH,WAVES-BTC,WAVES-ETH,WAVES-BNB,GTO-BTC,GTO-ETH,GTO-BNB,ICX-BTC,ICX-ETH,ICX-BNB,OST-BTC,OST-ETH,OST-BNB,ELF-BTC,ELF-ETH,AION-BTC,AION-ETH,AION-BNB,NEBL-BTC,NEBL-ETH,NEBL-BNB,BRD-BTC,BRD-ETH,BRD-BNB,MCO-BNB,EDO-BTC,EDO-ETH,WINGS-BTC,WINGS-ETH,NAV-BTC,NAV-ETH,NAV-BNB,LUN-BTC,LUN-ETH,APPC-BTC,APPC-ETH,APPC-BNB,VIBE-BTC,VIBE-ETH,RLC-BTC,RLC-ETH,RLC-BNB,INS-BTC,INS-ETH,PIVX-BTC,PIVX-ETH,PIVX-BNB,IOST-BTC,IOST-ETH,STEEM-BTC,STEEM-ETH,STEEM-BNB,NANO-BTC,NANO-ETH,NANO-BNB,VIA-BTC,VIA-ETH,VIA-BNB,BLZ-BTC,BLZ-ETH,BLZ-BNB,AE-BTC,AE-ETH,AE-BNB,NCASH-BTC,NCASH-ETH,NCASH-BNB,POA-BTC,POA-ETH,POA-BNB,ZIL-BTC,ZIL-ETH,ZIL-BNB,ONT-BTC,ONT-ETH,ONT-BNB,STORM-BTC,STORM-ETH,STORM-BNB,QTUM-BNB,QTUM-USDT,XEM-BTC,XEM-ETH,XEM-BNB,WAN-BTC,WAN-ETH,WAN-BNB,WPR-BTC,WPR-ETH,QLC-BTC,QLC-ETH,SYS-BTC,SYS-ETH,SYS-BNB,QLC-BNB,GRS-BTC,GRS-ETH,ADA-USDT,ADA-BNB,CLOAK-BTC,CLOAK-ETH,GNT-BTC,GNT-ETH,GNT-BNB,LOOM-BTC,LOOM-ETH,LOOM-BNB,XRP-USDT,REP-BTC,REP-ETH,REP-BNB,TUSD-BTC,TUSD-ETH,TUSD-BNB,ZEN-BTC,ZEN-ETH,ZEN-BNB,SKY-BTC,SKY-ETH,SKY-BNB,EOS-USDT,EOS-BNB,CVC-BTC,CVC-ETH,CVC-BNB,THETA-BTC,THETA-ETH,THETA-BNB,XRP-BNB,TUSD-USDT,IOTA-USDT,XLM-USDT,IOTX-BTC,IOTX-ETH,QKC-BTC,QKC-ETH,AGI-BTC,AGI-ETH,AGI-BNB,NXS-BTC,NXS-ETH,NXS-BNB,ENJ-BNB,DATA-BTC,DATA-ETH,ONT-USDT,TRX-BNB,TRX-USDT,ETC-USDT,ETC-BNB,ICX-USDT,SC-BTC,SC-ETH,SC-BNB,NPXS-BTC,NPXS-ETH,KEY-BTC,KEY-ETH,NAS-BTC,NAS-ETH,NAS-BNB,MFT-BTC,MFT-ETH,MFT-BNB,DENT-BTC,DENT-ETH,ARDR-BTC,ARDR-ETH,ARDR-BNB,NULS-USDT,HOT-BTC,HOT-ETH,VET-BTC,VET-ETH,VET-USDT,VET-BNB,DOCK-BTC,DOCK-ETH,POLY-BTC,POLY-BNB,PHX-BTC,PHX-ETH,PHX-BNB,HC-BTC,HC-ETH,GO-BTC,GO-BNB,PAX-USDT,RVN-BTC,RVN-BNB,DCR-BTC,DCR-BNB,MITH-BTC,MITH-BNB,BCHABC-BTC,BCHSV-BTC,BCHABC-USDT,BCHSV-USDT,BNB-PAX,BTC-PAX,ETH-PAX,XRP-PAX,EOS-PAX,XLM-PAX,REN-BTC,REN-BNB,XRP-TUSD,EOS-TUSD,XLM-TUSD,BNB-USDC,BTC-USDC,ETH-USDC,XRP-USDC,EOS-USDC,XLM-USDC,USDC-USDT,ADA-TUSD,TRX-TUSD,NEO-TUSD,TRX-XRP,XZC-XRP,PAX-TUSD,USDC-TUSD,USDC-PAX,LINK-USDT,LINK-TUSD,LINK-PAX,LINK-USDC,WAVES-USDT,WAVES-TUSD,WAVES-PAX,WAVES-USDC,BCHABC-TUSD,BCHABC-PAX,BCHABC-USDC,BCHSV-TUSD,BCHSV-PAX,BCHSV-USDC,LTC-TUSD,LTC-PAX,LTC-USDC,TRX-PAX,TRX-USDC,BTT-BTC,BTT-BNB,BTT-USDT,BNB-USDS,BTC-USDS", + "availablePairs": "ETH-BTC,LTC-BTC,BNB-BTC,NEO-BTC,QTUM-ETH,EOS-ETH,SNT-ETH,BNT-ETH,GAS-BTC,BNB-ETH,BTC-USDT,ETH-USDT,OAX-ETH,DNT-ETH,MCO-ETH,MCO-BTC,WTC-BTC,WTC-ETH,LRC-BTC,LRC-ETH,QTUM-BTC,YOYO-BTC,OMG-BTC,OMG-ETH,ZRX-BTC,ZRX-ETH,STRAT-BTC,STRAT-ETH,SNGLS-BTC,SNGLS-ETH,BQX-BTC,BQX-ETH,KNC-BTC,KNC-ETH,FUN-BTC,FUN-ETH,SNM-BTC,SNM-ETH,NEO-ETH,IOTA-BTC,IOTA-ETH,LINK-BTC,LINK-ETH,XVG-BTC,XVG-ETH,MDA-BTC,MDA-ETH,MTL-BTC,MTL-ETH,EOS-BTC,SNT-BTC,ETC-ETH,ETC-BTC,MTH-BTC,MTH-ETH,ENG-BTC,ENG-ETH,DNT-BTC,ZEC-BTC,ZEC-ETH,BNT-BTC,AST-BTC,AST-ETH,DASH-BTC,DASH-ETH,OAX-BTC,BTG-BTC,BTG-ETH,EVX-BTC,EVX-ETH,REQ-BTC,REQ-ETH,VIB-BTC,VIB-ETH,TRX-BTC,TRX-ETH,POWR-BTC,POWR-ETH,ARK-BTC,ARK-ETH,YOYO-ETH,XRP-BTC,XRP-ETH,ENJ-BTC,ENJ-ETH,STORJ-BTC,STORJ-ETH,BNB-USDT,YOYO-BNB,POWR-BNB,KMD-BTC,KMD-ETH,NULS-BNB,RCN-BTC,RCN-ETH,RCN-BNB,NULS-BTC,NULS-ETH,RDN-BTC,RDN-ETH,RDN-BNB,XMR-BTC,XMR-ETH,DLT-BNB,WTC-BNB,DLT-BTC,DLT-ETH,AMB-BTC,AMB-ETH,AMB-BNB,BAT-BTC,BAT-ETH,BAT-BNB,BCPT-BTC,BCPT-ETH,BCPT-BNB,ARN-BTC,ARN-ETH,GVT-BTC,GVT-ETH,CDT-BTC,CDT-ETH,GXS-BTC,GXS-ETH,NEO-USDT,NEO-BNB,POE-BTC,POE-ETH,QSP-BTC,QSP-ETH,QSP-BNB,BTS-BTC,BTS-ETH,BTS-BNB,XZC-BTC,XZC-ETH,XZC-BNB,LSK-BTC,LSK-ETH,LSK-BNB,TNT-BTC,TNT-ETH,FUEL-BTC,FUEL-ETH,MANA-BTC,MANA-ETH,BCD-BTC,BCD-ETH,DGD-BTC,DGD-ETH,IOTA-BNB,ADX-BTC,ADX-ETH,ADX-BNB,ADA-BTC,ADA-ETH,PPT-BTC,PPT-ETH,CMT-BTC,CMT-ETH,CMT-BNB,XLM-BTC,XLM-ETH,XLM-BNB,CND-BTC,CND-ETH,CND-BNB,LEND-BTC,LEND-ETH,WABI-BTC,WABI-ETH,WABI-BNB,LTC-ETH,LTC-USDT,LTC-BNB,TNB-BTC,TNB-ETH,WAVES-BTC,WAVES-ETH,WAVES-BNB,GTO-BTC,GTO-ETH,GTO-BNB,ICX-BTC,ICX-ETH,ICX-BNB,OST-BTC,OST-ETH,OST-BNB,ELF-BTC,ELF-ETH,AION-BTC,AION-ETH,AION-BNB,NEBL-BTC,NEBL-ETH,NEBL-BNB,BRD-BTC,BRD-ETH,BRD-BNB,MCO-BNB,EDO-BTC,EDO-ETH,NAV-BTC,NAV-ETH,NAV-BNB,LUN-BTC,LUN-ETH,APPC-BTC,APPC-ETH,APPC-BNB,VIBE-BTC,VIBE-ETH,RLC-BTC,RLC-ETH,RLC-BNB,INS-BTC,INS-ETH,PIVX-BTC,PIVX-ETH,PIVX-BNB,IOST-BTC,IOST-ETH,STEEM-BTC,STEEM-ETH,STEEM-BNB,NANO-BTC,NANO-ETH,NANO-BNB,VIA-BTC,VIA-ETH,VIA-BNB,BLZ-BTC,BLZ-ETH,BLZ-BNB,AE-BTC,AE-ETH,AE-BNB,NCASH-BTC,NCASH-ETH,NCASH-BNB,POA-BTC,POA-ETH,POA-BNB,ZIL-BTC,ZIL-ETH,ZIL-BNB,ONT-BTC,ONT-ETH,ONT-BNB,STORM-BTC,STORM-ETH,STORM-BNB,QTUM-BNB,QTUM-USDT,XEM-BTC,XEM-ETH,XEM-BNB,WAN-BTC,WAN-ETH,WAN-BNB,WPR-BTC,WPR-ETH,QLC-BTC,QLC-ETH,SYS-BTC,SYS-ETH,SYS-BNB,QLC-BNB,GRS-BTC,GRS-ETH,ADA-USDT,ADA-BNB,GNT-BTC,GNT-ETH,GNT-BNB,LOOM-BTC,LOOM-ETH,LOOM-BNB,XRP-USDT,REP-BTC,REP-ETH,REP-BNB,TUSD-BTC,TUSD-ETH,TUSD-BNB,ZEN-BTC,ZEN-ETH,ZEN-BNB,SKY-BTC,SKY-ETH,SKY-BNB,EOS-USDT,EOS-BNB,CVC-BTC,CVC-ETH,CVC-BNB,THETA-BTC,THETA-ETH,THETA-BNB,XRP-BNB,TUSD-USDT,IOTA-USDT,XLM-USDT,IOTX-BTC,IOTX-ETH,QKC-BTC,QKC-ETH,AGI-BTC,AGI-ETH,AGI-BNB,NXS-BTC,NXS-ETH,NXS-BNB,ENJ-BNB,DATA-BTC,DATA-ETH,ONT-USDT,TRX-BNB,TRX-USDT,ETC-USDT,ETC-BNB,ICX-USDT,SC-BTC,SC-ETH,SC-BNB,NPXS-BTC,NPXS-ETH,KEY-BTC,KEY-ETH,NAS-BTC,NAS-ETH,NAS-BNB,MFT-BTC,MFT-ETH,MFT-BNB,DENT-BTC,DENT-ETH,ARDR-BTC,ARDR-ETH,ARDR-BNB,NULS-USDT,HOT-BTC,HOT-ETH,VET-BTC,VET-ETH,VET-USDT,VET-BNB,DOCK-BTC,DOCK-ETH,POLY-BTC,POLY-BNB,PHX-BTC,PHX-ETH,PHX-BNB,HC-BTC,HC-ETH,GO-BTC,GO-BNB,PAX-USDT,RVN-BTC,RVN-BNB,DCR-BTC,DCR-BNB,MITH-BTC,MITH-BNB,BCHABC-BTC,BCHSV-BTC,BCHABC-USDT,BCHSV-USDT,BNB-PAX,BTC-PAX,ETH-PAX,XRP-PAX,EOS-PAX,XLM-PAX,REN-BTC,REN-BNB,XRP-TUSD,EOS-TUSD,XLM-TUSD,BNB-USDC,BTC-USDC,ETH-USDC,XRP-USDC,EOS-USDC,XLM-USDC,USDC-USDT,ADA-TUSD,TRX-TUSD,NEO-TUSD,TRX-XRP,XZC-XRP,PAX-TUSD,USDC-TUSD,USDC-PAX,LINK-USDT,LINK-TUSD,LINK-PAX,LINK-USDC,WAVES-USDT,WAVES-TUSD,WAVES-PAX,WAVES-USDC,BCHABC-TUSD,BCHABC-PAX,BCHABC-USDC,BCHSV-TUSD,BCHSV-PAX,BCHSV-USDC,LTC-TUSD,LTC-PAX,LTC-USDC,TRX-PAX,TRX-USDC,BTT-BTC,BTT-BNB,BTT-USDT,BNB-USDS,BTC-USDS,USDS-USDT,USDS-PAX,USDS-TUSD,USDS-USDC,BTT-PAX,BTT-TUSD,BTT-USDC,ONG-BNB,ONG-BTC,ONG-USDT,HOT-BNB,HOT-USDT,ZIL-USDT,ZRX-BNB,ZRX-USDT,FET-BNB,FET-BTC,FET-USDT,BAT-USDT", "enabledPairs": "BTC-USDT", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -244,7 +244,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTCUSD,LTCUSD,LTCBTC,ETHUSD,ETHBTC,ETCBTC,ETCUSD,RRTUSD,RRTBTC,ZECUSD,ZECBTC,XMRUSD,XMRBTC,DSHUSD,DSHBTC,BTCEUR,BTCJPY,XRPUSD,XRPBTC,IOTUSD,IOTBTC,IOTETH,EOSUSD,EOSBTC,EOSETH,SANUSD,SANBTC,SANETH,OMGUSD,OMGBTC,OMGETH,NEOUSD,NEOBTC,NEOETH,ETPUSD,ETPBTC,ETPETH,QTMUSD,QTMBTC,QTMETH,AVTUSD,AVTBTC,AVTETH,EDOUSD,EDOBTC,EDOETH,BTGUSD,BTGBTC,DATUSD,DATBTC,DATETH,QSHUSD,QSHBTC,QSHETH,YYWUSD,YYWBTC,YYWETH,GNTUSD,GNTBTC,GNTETH,SNTUSD,SNTBTC,SNTETH,IOTEUR,BATUSD,BATBTC,BATETH,MNAUSD,MNABTC,MNAETH,FUNUSD,FUNBTC,FUNETH,ZRXUSD,ZRXBTC,ZRXETH,TNBUSD,TNBBTC,TNBETH,SPKUSD,SPKBTC,SPKETH,TRXUSD,TRXBTC,TRXETH,RCNUSD,RCNBTC,RCNETH,RLCUSD,RLCBTC,RLCETH,AIDUSD,AIDBTC,AIDETH,SNGUSD,SNGBTC,SNGETH,REPUSD,REPBTC,REPETH,ELFUSD,ELFBTC,ELFETH,BTCGBP,ETHEUR,ETHJPY,ETHGBP,NEOEUR,NEOJPY,NEOGBP,EOSEUR,EOSJPY,EOSGBP,IOTJPY,IOTGBP,IOSUSD,IOSBTC,IOSETH,AIOUSD,AIOBTC,AIOETH,REQUSD,REQBTC,REQETH,RDNUSD,RDNBTC,RDNETH,LRCUSD,LRCBTC,LRCETH,WAXUSD,WAXBTC,WAXETH,DAIUSD,DAIBTC,DAIETH,AGIUSD,AGIBTC,AGIETH,BFTUSD,BFTBTC,BFTETH,MTNUSD,MTNBTC,MTNETH,ODEUSD,ODEBTC,ODEETH,ANTUSD,ANTBTC,ANTETH,DTHUSD,DTHBTC,DTHETH,MITUSD,MITBTC,MITETH,STJUSD,STJBTC,STJETH,XLMUSD,XLMEUR,XLMJPY,XLMGBP,XLMBTC,XLMETH,XVGUSD,XVGEUR,XVGJPY,XVGGBP,XVGBTC,XVGETH,BCIUSD,BCIBTC,MKRUSD,MKRBTC,MKRETH,KNCUSD,KNCBTC,KNCETH,POAUSD,POABTC,POAETH,LYMUSD,LYMBTC,LYMETH,UTKUSD,UTKBTC,UTKETH,VEEUSD,VEEBTC,VEEETH,DADUSD,DADBTC,DADETH,ORSUSD,ORSBTC,ORSETH,AUCUSD,AUCBTC,AUCETH,POYUSD,POYBTC,POYETH,FSNUSD,FSNBTC,FSNETH,CBTUSD,CBTBTC,CBTETH,ZCNUSD,ZCNBTC,ZCNETH,SENUSD,SENBTC,SENETH,NCAUSD,NCABTC,NCAETH,CNDUSD,CNDBTC,CNDETH,CTXUSD,CTXBTC,CTXETH,PAIUSD,PAIBTC,SEEUSD,SEEBTC,SEEETH,ESSUSD,ESSBTC,ESSETH,ATMUSD,ATMBTC,ATMETH,HOTUSD,HOTBTC,HOTETH,DTAUSD,DTABTC,DTAETH,IQXUSD,IQXBTC,IQXEOS,WPRUSD,WPRBTC,WPRETH,ZILUSD,ZILBTC,ZILETH,BNTUSD,BNTBTC,BNTETH,ABSUSD,ABSETH,XRAUSD,XRAETH,MANUSD,MANETH,BBNUSD,BBNETH,NIOUSD,NIOETH,DGXUSD,DGXETH,VETUSD,VETBTC,VETETH,UTNUSD,UTNETH,TKNUSD,TKNETH,GOTUSD,GOTEUR,GOTETH,XTZUSD,XTZBTC,CNNUSD,CNNETH,BOXUSD,BOXETH,TRXEUR,TRXGBP,TRXJPY,MGOUSD,MGOETH,RTEUSD,RTEETH,YGGUSD,YGGETH,MLNUSD,MLNETH,WTCUSD,WTCETH,CSXUSD,CSXETH,OMNUSD,OMNBTC,INTUSD,INTETH,DRNUSD,DRNETH,PNKUSD,PNKETH,DGBUSD,DGBBTC,BSVUSD,BSVBTC,BABUSD,BABBTC,WLOUSD,WLOXLM,VLDUSD,VLDETH,ENJUSD,ENJETH,ONLUSD,ONLETH,RBTUSD,RBTBTC,USTUSD,EUTEUR,EUTUSD,GSDUSD,UDCUSD,TSDUSD,PAXUSD,RIFUSD,RIFBTC,PASUSD,PASETH,VSYUSD,VSYBTC,ZRXDAI,MKRDAI,OMGDAI", + "availablePairs": "BTCUSD,LTCUSD,LTCBTC,ETHUSD,ETHBTC,ETCBTC,ETCUSD,RRTUSD,RRTBTC,ZECUSD,ZECBTC,XMRUSD,XMRBTC,DSHUSD,DSHBTC,BTCEUR,BTCJPY,XRPUSD,XRPBTC,IOTUSD,IOTBTC,IOTETH,EOSUSD,EOSBTC,EOSETH,SANUSD,SANBTC,SANETH,OMGUSD,OMGBTC,OMGETH,NEOUSD,NEOBTC,NEOETH,ETPUSD,ETPBTC,ETPETH,QTMUSD,QTMBTC,QTMETH,AVTUSD,AVTBTC,AVTETH,EDOUSD,EDOBTC,EDOETH,BTGUSD,BTGBTC,DATUSD,DATBTC,DATETH,QSHUSD,QSHBTC,QSHETH,YYWUSD,YYWBTC,YYWETH,GNTUSD,GNTBTC,GNTETH,SNTUSD,SNTBTC,SNTETH,IOTEUR,BATUSD,BATBTC,BATETH,MNAUSD,MNABTC,MNAETH,FUNUSD,FUNBTC,FUNETH,ZRXUSD,ZRXBTC,ZRXETH,TNBUSD,TNBBTC,TNBETH,SPKUSD,SPKBTC,SPKETH,TRXUSD,TRXBTC,TRXETH,RCNUSD,RCNBTC,RCNETH,RLCUSD,RLCBTC,RLCETH,AIDUSD,AIDBTC,AIDETH,SNGUSD,SNGBTC,SNGETH,REPUSD,REPBTC,REPETH,ELFUSD,ELFBTC,ELFETH,BTCGBP,ETHEUR,ETHJPY,ETHGBP,NEOEUR,NEOJPY,NEOGBP,EOSEUR,EOSJPY,EOSGBP,IOTJPY,IOTGBP,IOSUSD,IOSBTC,IOSETH,AIOUSD,AIOBTC,AIOETH,REQUSD,REQBTC,REQETH,RDNUSD,RDNBTC,RDNETH,LRCUSD,LRCBTC,LRCETH,WAXUSD,WAXBTC,WAXETH,DAIUSD,DAIBTC,DAIETH,AGIUSD,AGIBTC,AGIETH,BFTUSD,BFTBTC,BFTETH,MTNUSD,MTNBTC,MTNETH,ODEUSD,ODEBTC,ODEETH,ANTUSD,ANTBTC,ANTETH,DTHUSD,DTHBTC,DTHETH,MITUSD,MITBTC,MITETH,STJUSD,STJBTC,STJETH,XLMUSD,XLMEUR,XLMJPY,XLMGBP,XLMBTC,XLMETH,XVGUSD,XVGEUR,XVGJPY,XVGGBP,XVGBTC,XVGETH,BCIUSD,BCIBTC,MKRUSD,MKRBTC,MKRETH,KNCUSD,KNCBTC,KNCETH,POAUSD,POABTC,POAETH,LYMUSD,LYMBTC,LYMETH,UTKUSD,UTKBTC,UTKETH,VEEUSD,VEEBTC,VEEETH,DADUSD,DADBTC,DADETH,ORSUSD,ORSBTC,ORSETH,AUCUSD,AUCBTC,AUCETH,POYUSD,POYBTC,POYETH,FSNUSD,FSNBTC,FSNETH,CBTUSD,CBTBTC,CBTETH,ZCNUSD,ZCNBTC,ZCNETH,SENUSD,SENBTC,SENETH,NCAUSD,NCABTC,NCAETH,CNDUSD,CNDBTC,CNDETH,CTXUSD,CTXBTC,CTXETH,PAIUSD,PAIBTC,SEEUSD,SEEBTC,SEEETH,ESSUSD,ESSBTC,ESSETH,ATMUSD,ATMBTC,ATMETH,HOTUSD,HOTBTC,HOTETH,DTAUSD,DTABTC,DTAETH,IQXUSD,IQXBTC,IQXEOS,WPRUSD,WPRBTC,WPRETH,ZILUSD,ZILBTC,ZILETH,BNTUSD,BNTBTC,BNTETH,ABSUSD,ABSETH,XRAUSD,XRAETH,MANUSD,MANETH,BBNUSD,BBNETH,NIOUSD,NIOETH,DGXUSD,DGXETH,VETUSD,VETBTC,VETETH,UTNUSD,UTNETH,TKNUSD,TKNETH,GOTUSD,GOTEUR,GOTETH,XTZUSD,XTZBTC,CNNUSD,CNNETH,BOXUSD,BOXETH,TRXEUR,TRXGBP,TRXJPY,MGOUSD,MGOETH,RTEUSD,RTEETH,YGGUSD,YGGETH,MLNUSD,MLNETH,WTCUSD,WTCETH,CSXUSD,CSXETH,OMNUSD,OMNBTC,INTUSD,INTETH,DRNUSD,DRNETH,PNKUSD,PNKETH,DGBUSD,DGBBTC,BSVUSD,BSVBTC,BABUSD,BABBTC,WLOUSD,WLOXLM,VLDUSD,VLDETH,ENJUSD,ENJETH,ONLUSD,ONLETH,RBTUSD,RBTBTC,USTUSD,EUTEUR,EUTUSD,GSDUSD,UDCUSD,TSDUSD,PAXUSD,RIFUSD,RIFBTC,PASUSD,PASETH,VSYUSD,VSYBTC,ZRXDAI,MKRDAI,OMGDAI,BTTUSD,BTTBTC", "enabledPairs": "BTCUSD,LTCUSD,LTCBTC,ETHUSD,ETHBTC", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -335,7 +335,7 @@ "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", "clientId": "ClientID", - "availablePairs": "ETHKRW,LOOMKRW,ZILKRW,KNCKRW,XRPKRW,THETAKRW,ARNKRW,PPTKRW,ROMKRW,CMTKRW,WAXKRW,XMRKRW,BTGKRW,BATKRW,ETZKRW,INSKRW,WTCKRW,ITCKRW,HCKRW,PIVXKRW,AEKRW,EOSKRW,VETKRW,LTCKRW,XLMKRW,CTXCKRW,XEMKRW,BHPCKRW,RNTKRW,TMTGKRW,BCHKRW,TRUEKRW,IOSTKRW,DACCKRW,WAVESKRW,DACKRW,POWRKRW,PSTKRW,LRCKRW,STRATKRW,PAYKRW,SALTKRW,BZNTKRW,OCNKRW,ZRXKRW,RDNKRW,GNTKRW,ICXKRW,TRXKRW,XVGKRW,MTLKRW,AMOKRW,SNTKRW,BTCKRW,BSVKRW,ELFKRW,PLYKRW,ETCKRW,ETHOSKRW,MCOKRW,REPKRW,ADAKRW,POLYKRW,APISKRW,OMGKRW,BCDKRW,WETKRW,DASHKRW,ABTKRW,ENJKRW,MITHKRW,STEEMKRW,GTOKRW,LINKKRW,QTUMKRW,ZECKRW", + "availablePairs": "ARNKRW,DACCKRW,POWRKRW,AMOKRW,NPXSKRW,BTTKRW,REPKRW,LINKKRW,XMRKRW,ITCKRW,ADAKRW,OCNKRW,OMGKRW,KNCKRW,MITHKRW,WAVESKRW,DACKRW,XEMKRW,TMTGKRW,LOOMKRW,BHPKRW,BCHKRW,IOSTKRW,BCDKRW,XVGKRW,ZECKRW,HCKRW,LTCKRW,PAYKRW,WETKRW,ZRXKRW,XRPKRW,SNTKRW,ROMKRW,PSTKRW,APISKRW,GTOKRW,XLMKRW,BATKRW,VETKRW,STEEMKRW,TRXKRW,THETAKRW,ETHKRW,RNTKRW,RDNKRW,PIVXKRW,ELFKRW,QTUMKRW,ICXKRW,STRATKRW,CMTKRW,PLYKRW,ETCKRW,BZNTKRW,BTGKRW,PPTKRW,SALTKRW,POLYKRW,AEKRW,WTCKRW,ENJKRW,ABTKRW,WAXKRW,MCOKRW,DASHKRW,LRCKRW,BTCKRW,ETHOSKRW,GNTKRW,ZILKRW,MTLKRW,HDACKRW,BSVKRW,CTXCKRW,EOSKRW,INSKRW,TRUEKRW,ETZKRW", "enabledPairs": "BTCKRW,ETHKRW,DASHKRW,LTCKRW,ETCKRW,XRPKRW,BCHKRW,XMRKRW,ZECKRW,QTUMKRW,BTGKRW,EOSKRW", "baseCurrencies": "KRW", "assetTypes": "SPOT", @@ -415,7 +415,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTC-LTC,BTC-DOGE,BTC-VTC,BTC-PPC,BTC-FTC,BTC-RDD,BTC-NXT,BTC-DASH,BTC-POT,BTC-BLK,BTC-EMC2,BTC-XMY,BTC-GLD,BTC-SLR,BTC-GRS,BTC-NLG,BTC-XWC,BTC-MONA,BTC-THC,BTC-VRC,BTC-CURE,BTC-XMR,BTC-CLOAK,BTC-KORE,BTC-XDN,BTC-NAV,BTC-XST,BTC-VIA,BTC-PINK,BTC-IOC,BTC-CANN,BTC-SYS,BTC-NEOS,BTC-DGB,BTC-BURST,BTC-EXCL,BTC-BITS,BTC-DOPE,BTC-BLOCK,BTC-ABY,BTC-BAY,BTC-BTS,BTC-XRP,BTC-GAME,BTC-COVAL,BTC-NXS,BTC-XCP,BTC-BITB,BTC-GEO,BTC-FLDC,BTC-GRC,BTC-FLO,BTC-NBT,BTC-MUE,BTC-XEM,BTC-DMD,BTC-GAM,BTC-SPHR,BTC-OK,BTC-AEON,BTC-ETH,BTC-TX,BTC-EXP,BTC-AMP,BTC-XLM,USDT-BTC,BTC-RVR,BTC-EMC,BTC-FCT,BTC-EGC,BTC-SLS,BTC-RADS,BTC-DCR,BTC-BSD,BTC-XVG,BTC-PIVX,BTC-MEME,BTC-STEEM,BTC-2GIVE,BTC-LSK,BTC-BRK,BTC-WAVES,BTC-LBC,BTC-SBD,BTC-BRX,BTC-ETC,ETH-ETC,BTC-STRAT,BTC-SYNX,BTC-EBST,BTC-VRM,BTC-SEQ,BTC-REP,BTC-SHIFT,BTC-ARDR,BTC-XZC,BTC-NEO,BTC-ZEC,BTC-ZCL,BTC-IOP,BTC-GOLOS,BTC-UBQ,BTC-KMD,BTC-GBG,BTC-SIB,BTC-ION,BTC-QWARK,BTC-CRW,BTC-SWT,BTC-MLN,BTC-ARK,BTC-DYN,BTC-TKS,BTC-MUSIC,BTC-DTB,BTC-INCNT,BTC-GBYTE,BTC-GNT,BTC-NXC,BTC-EDG,BTC-MORE,ETH-GNT,ETH-REP,USDT-ETH,BTC-WINGS,BTC-RLC,BTC-GNO,BTC-GUP,BTC-LUN,ETH-RLC,ETH-GNO,BTC-HMQ,BTC-ANT,ETH-ANT,BTC-SC,ETH-BAT,BTC-BAT,BTC-ZEN,BTC-QRL,ETH-MORE,BTC-PTOY,BTC-BNT,ETH-BNT,BTC-NMR,ETH-LTC,ETH-XRP,BTC-SNT,ETH-SNT,BTC-DCT,BTC-XEL,BTC-MCO,ETH-MCO,BTC-ADT,BTC-PAY,ETH-PAY,BTC-MTL,BTC-STORJ,BTC-ADX,ETH-ADX,ETH-DASH,ETH-SC,ETH-ZEC,USDT-ZEC,USDT-LTC,USDT-ETC,USDT-XRP,BTC-OMG,ETH-OMG,BTC-CVC,ETH-CVC,BTC-PART,BTC-QTUM,ETH-QTUM,ETH-XMR,ETH-XEM,ETH-XLM,ETH-NEO,USDT-XMR,USDT-DASH,ETH-BCH,USDT-BCH,BTC-BCH,BTC-DNT,USDT-NEO,ETH-WAVES,ETH-STRAT,ETH-DGB,USDT-OMG,BTC-ADA,BTC-MANA,ETH-MANA,BTC-SALT,ETH-SALT,BTC-TIX,BTC-RCN,BTC-VIB,ETH-VIB,BTC-MER,BTC-POWR,ETH-POWR,ETH-ADA,BTC-ENG,ETH-ENG,USDT-ADA,USDT-XVG,USDT-NXT,BTC-UKG,ETH-UKG,BTC-IGNIS,BTC-SRN,ETH-SRN,BTC-WAX,ETH-WAX,BTC-ZRX,ETH-ZRX,BTC-VEE,BTC-BCPT,BTC-TRX,ETH-TRX,BTC-TUSD,BTC-LRC,ETH-TUSD,BTC-UP,BTC-DMT,ETH-DMT,USDT-TUSD,BTC-POLY,ETH-POLY,BTC-PRO,USDT-SC,USDT-TRX,BTC-BLT,BTC-STORM,ETH-STORM,BTC-AID,BTC-NGC,BTC-GTO,USDT-DCR,BTC-OCN,ETH-OCN,USD-BTC,USD-USDT,USD-TUSD,BTC-TUBE,BTC-CBC,BTC-CMCT,USD-ETH,BTC-NLC2,BTC-BKX,BTC-MFT,BTC-LOOM,BTC-RFR,USDT-DGB,BTC-RVN,USD-XRP,USD-ETC,BTC-BFT,BTC-GO,BTC-HYDRO,BTC-UPP,USD-ADA,USD-ZEC,USDT-DOGE,BTC-ENJ,BTC-MET,USD-LTC,USD-TRX,BTC-DTA,BTC-EDR,BTC-BOXX,BTC-IHT,USD-BCH,BTC-XHV,USDT-ZRX,BTC-NPXS,BTC-PMA,USDT-BAT,USDT-RVN,BTC-PAL,USD-SC,BTC-PAX,USDT-PAX,BTC-ZIL,BTC-MOC,BTC-OST,BTC-SPC,BTC-MEDX,BTC-BSV,BTC-IOST,BTC-XNK,USDT-BSV,ETH-BSV,BTC-NCASH,BTC-SOLVE,BTC-USDS,USDT-PMA,ETH-NPXS,USDT-NPXS,USD-ZRX,BTC-JNT,BTC-LBA,BTC-MOBI,USD-BAT,USD-BSV,BTC-DENT,USD-USDS,BTC-DRGN,USD-PAX,BTC-VITE,BTC-IOTX,USD-DGB,BTC-BTM,BTC-ELF,USD-EDR,BTC-QNT,BTC-BTU,USD-ZEN,BTC-SPND,BTC-BTT,BTC-NKN,USD-KMD", + "availablePairs": "BTC-LTC,BTC-DOGE,BTC-VTC,BTC-PPC,BTC-FTC,BTC-RDD,BTC-NXT,BTC-DASH,BTC-POT,BTC-BLK,BTC-EMC2,BTC-XMY,BTC-GLD,BTC-SLR,BTC-GRS,BTC-NLG,BTC-XWC,BTC-MONA,BTC-THC,BTC-VRC,BTC-CURE,BTC-XMR,BTC-CLOAK,BTC-KORE,BTC-XDN,BTC-NAV,BTC-XST,BTC-VIA,BTC-PINK,BTC-IOC,BTC-CANN,BTC-SYS,BTC-NEOS,BTC-DGB,BTC-BURST,BTC-EXCL,BTC-BITS,BTC-DOPE,BTC-BLOCK,BTC-ABY,BTC-BAY,BTC-BTS,BTC-XRP,BTC-GAME,BTC-COVAL,BTC-NXS,BTC-XCP,BTC-BITB,BTC-GEO,BTC-FLDC,BTC-GRC,BTC-FLO,BTC-NBT,BTC-MUE,BTC-XEM,BTC-DMD,BTC-GAM,BTC-SPHR,BTC-OK,BTC-AEON,BTC-ETH,BTC-EXP,BTC-AMP,BTC-XLM,USDT-BTC,BTC-RVR,BTC-EMC,BTC-FCT,BTC-EGC,BTC-SLS,BTC-RADS,BTC-DCR,BTC-BSD,BTC-XVG,BTC-PIVX,BTC-MEME,BTC-STEEM,BTC-2GIVE,BTC-LSK,BTC-BRK,BTC-WAVES,BTC-LBC,BTC-SBD,BTC-BRX,BTC-ETC,ETH-ETC,BTC-STRAT,BTC-SYNX,BTC-EBST,BTC-VRM,BTC-SEQ,BTC-REP,BTC-SHIFT,BTC-ARDR,BTC-XZC,BTC-NEO,BTC-ZEC,BTC-ZCL,BTC-IOP,BTC-GOLOS,BTC-UBQ,BTC-KMD,BTC-GBG,BTC-SIB,BTC-ION,BTC-QWARK,BTC-CRW,BTC-SWT,BTC-MLN,BTC-ARK,BTC-DYN,BTC-TKS,BTC-MUSIC,BTC-DTB,BTC-INCNT,BTC-GBYTE,BTC-GNT,BTC-NXC,BTC-EDG,BTC-MORE,ETH-GNT,ETH-REP,USDT-ETH,BTC-WINGS,BTC-RLC,BTC-GNO,BTC-GUP,BTC-LUN,ETH-GNO,BTC-HMQ,BTC-ANT,ETH-ANT,BTC-SC,ETH-BAT,BTC-BAT,BTC-ZEN,BTC-QRL,BTC-PTOY,BTC-BNT,ETH-BNT,BTC-NMR,ETH-LTC,ETH-XRP,BTC-SNT,ETH-SNT,BTC-DCT,BTC-XEL,BTC-MCO,ETH-MCO,BTC-ADT,BTC-PAY,ETH-PAY,BTC-MTL,BTC-STORJ,BTC-ADX,ETH-ADX,ETH-DASH,ETH-SC,ETH-ZEC,USDT-ZEC,USDT-LTC,USDT-ETC,USDT-XRP,BTC-OMG,ETH-OMG,BTC-CVC,ETH-CVC,BTC-PART,BTC-QTUM,ETH-QTUM,ETH-XMR,ETH-XEM,ETH-XLM,ETH-NEO,USDT-XMR,USDT-DASH,ETH-BCH,USDT-BCH,BTC-BCH,BTC-DNT,USDT-NEO,ETH-WAVES,ETH-STRAT,ETH-DGB,USDT-OMG,BTC-ADA,BTC-MANA,ETH-MANA,BTC-SALT,BTC-TIX,BTC-RCN,BTC-VIB,ETH-VIB,BTC-MER,BTC-POWR,ETH-POWR,ETH-ADA,BTC-ENG,ETH-ENG,USDT-ADA,USDT-XVG,USDT-NXT,BTC-UKG,ETH-UKG,BTC-IGNIS,BTC-SRN,ETH-SRN,BTC-WAX,ETH-WAX,BTC-ZRX,ETH-ZRX,BTC-VEE,BTC-BCPT,BTC-TRX,ETH-TRX,BTC-TUSD,BTC-LRC,ETH-TUSD,BTC-UP,BTC-DMT,ETH-DMT,USDT-TUSD,BTC-POLY,ETH-POLY,BTC-PRO,USDT-SC,USDT-TRX,BTC-BLT,BTC-STORM,ETH-STORM,BTC-AID,BTC-NGC,BTC-GTO,USDT-DCR,BTC-OCN,ETH-OCN,USD-BTC,USD-USDT,USD-TUSD,BTC-TUBE,BTC-CBC,BTC-CMCT,USD-ETH,BTC-NLC2,BTC-BKX,BTC-MFT,BTC-LOOM,BTC-RFR,USDT-DGB,BTC-RVN,USD-XRP,USD-ETC,BTC-BFT,BTC-GO,BTC-HYDRO,BTC-UPP,USD-ADA,USD-ZEC,USDT-DOGE,BTC-ENJ,BTC-MET,USD-LTC,USD-TRX,BTC-DTA,BTC-EDR,BTC-BOXX,BTC-IHT,USD-BCH,BTC-XHV,USDT-ZRX,BTC-NPXS,BTC-PMA,USDT-BAT,USDT-RVN,BTC-PAL,USD-SC,BTC-PAX,USDT-PAX,BTC-ZIL,BTC-MOC,BTC-OST,BTC-SPC,BTC-MEDX,BTC-BSV,BTC-IOST,BTC-XNK,USDT-BSV,ETH-BSV,BTC-NCASH,BTC-SOLVE,BTC-USDS,USDT-PMA,ETH-NPXS,USDT-NPXS,USD-ZRX,BTC-JNT,BTC-LBA,BTC-MOBI,USD-BAT,USD-BSV,BTC-DENT,USD-USDS,BTC-DRGN,USD-PAX,BTC-VITE,BTC-IOTX,USD-DGB,BTC-BTM,BTC-ELF,USD-EDR,BTC-QNT,BTC-BTU,USD-ZEN,BTC-SPND,BTC-BTT,BTC-NKN,USD-KMD,USDT-BTT,BTC-GRIN,BTC-CTXC,BTC-HXRO,BTC-SERV,BTC-META,USDT-GRIN,BTC-FSN,BTC-HST,BTC-ANKR,USDT-XLM", "enabledPairs": "USDT-BTC", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -479,6 +479,47 @@ } ] }, + { + "name": "BTSE", + "enabled": true, + "verbose": false, + "websocket": true, + "useSandbox": false, + "restPollingDelay": 10, + "httpTimeout": 15000000000, + "httpUserAgent": "", + "authenticatedApiSupport": false, + "apiKey": "Key", + "apiSecret": "Secret", + "apiUrl": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", + "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", + "proxyAddress": "", + "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", + "availablePairs": "BTC-USD", + "enabledPairs": "BTC-USD", + "baseCurrencies": "USD", + "assetTypes": "SPOT", + "supportsAutoPairUpdates": true, + "configCurrencyPairFormat": { + "uppercase": true, + "delimiter": "-" + }, + "requestCurrencyPairFormat": { + "uppercase": true, + "delimiter": "-" + }, + "bankAccounts": [ + { + "bankName": "", + "bankAddress": "", + "accountName": "", + "accountNumber": "", + "swiftCode": "", + "iban": "", + "supportedCurrencies": "" + } + ] + }, { "name": "BTC Markets", "enabled": true, @@ -495,7 +536,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTC-AUD,LTC-AUD,LTC-BTC,ETH-BTC,ETH-AUD,ETC-AUD,ETC-BTC,XRP-AUD,XRP-BTC,POWR-AUD,POWR-BTC,OMG-AUD,OMG-BTC,BCHABC-AUD,BCHABC-BTC,BCHSV-AUD,BCHSV-BTC", + "availablePairs": "BTC-AUD,LTC-AUD,LTC-BTC,ETH-BTC,ETH-AUD,ETC-AUD,ETC-BTC,XRP-AUD,XRP-BTC,POWR-AUD,POWR-BTC,OMG-AUD,OMG-BTC,BCHABC-AUD,BCHABC-BTC,BCHSV-AUD,BCHSV-BTC,GNT-AUD,GNT-BTC,BAT-AUD,BAT-BTC", "enabledPairs": "BTC-AUD", "baseCurrencies": "AUD", "assetTypes": "SPOT", @@ -575,7 +616,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "DAI_ETH,INK_BTC,OMG_ETH,WAVES_RUB,TRX_USD,DXT_BTC,BTCZ_BTC,ETH_USDT,XRP_USDT,NEO_BTC,EOS_USD,DOGE_BTC,QTUM_USD,GUSD_RUB,TRX_BTC,TRX_RUB,INK_ETH,OMG_USD,USDT_UAH,DASH_UAH,MNX_ETH,BCH_ETH,ZEC_USD,XMR_EUR,MNX_BTC,USDT_USD,XEM_UAH,BCH_UAH,ADA_USD,STQ_EUR,BTC_RUB,SMART_RUB,NEO_USD,ZEC_BTC,XRP_BTC,XMR_BTC,XRP_UAH,BTC_UAH,BTC_TRY,ZRX_ETH,HBZ_USD,DXT_USD,XRP_RUB,XRP_TRY,BTC_PLN,LTC_EUR,XMR_ETH,LSK_BTC,BTC_USD,BTC_EUR,XEM_BTC,INK_USD,DASH_USD,DAI_BTC,DASH_USDT,QTUM_BTC,SMART_USD,XEM_USD,NEO_RUB,ADA_BTC,STQ_RUB,GAS_BTC,ETH_USD,WAVES_BTC,XEM_EUR,ADA_ETH,MNX_USD,STQ_USD,ETH_LTC,USDT_EUR,ZEC_EUR,XRP_USD,BCH_USDT,DOGE_USD,GUSD_USD,ETH_RUB,LTC_BTC,XMR_USD,BTC_USDT,EOS_EUR,HB_BTC,LSK_USD,HBZ_BTC,ETC_BTC,BTG_ETH,XLM_TRY,DAI_RUB,MKR_BTC,GUSD_BTC,STQ_BTC,KICK_ETH,EOS_BTC,HBZ_ETH,ETH_EUR,ETH_TRY,XLM_RUB,BTG_BTC,MKR_DAI,ETC_USD,USDT_RUB,QTUM_ETH,BTG_USD,BCH_BTC,BCH_USD,ZRX_USD,ZRX_BTC,GAS_USD,XLM_USD,DASH_BTC,USD_RUB,DASH_RUB,ETH_BTC,GNT_BTC,LTC_USD,LSK_RUB,BCH_RUB,ETH_UAH,BCH_EUR,XRP_EUR,GNT_ETH,OMG_BTC,ETH_PLN,ETC_RUB,ZEC_RUB,DAI_USD,SMART_BTC,KICK_BTC,WAVES_USD,XRP_ETH,WAVES_ETH,SMART_EUR,XLM_BTC,LTC_RUB", + "availablePairs": "QTUM_ETH,NEO_USD,OMG_BTC,ETC_USD,USD_RUB,BTC_UAH,BTC_PLN,SMART_USD,DXT_USD,BCH_BTC,ETH_RUB,BTC_RUB,SMART_BTC,XLM_RUB,NEO_RUB,MNX_BTC,STQ_EUR,ETH_EUR,USDT_RUB,WAVES_RUB,QTUM_USD,LSK_BTC,KICK_ETH,XEM_UAH,LTC_BTC,MNC_BTC,HBZ_USD,HB_BTC,MNX_ETH,DASH_USD,ETC_BTC,ETH_TRY,MKR_BTC,BTCZ_BTC,WAVES_ETH,MNX_USD,OMG_USD,ETH_UAH,USDT_USD,DAI_RUB,INK_USD,DASH_BTC,BCH_USDT,ZRX_USD,WAVES_USD,XEM_EUR,GUSD_RUB,XRP_RUB,ETH_USDT,XRP_EUR,BCH_UAH,DASH_UAH,GUSD_BTC,BCH_RUB,ETH_BTC,ETH_USD,XMR_EUR,XLM_TRY,ZRX_BTC,SMART_EUR,EOS_USD,BCH_ETH,XRP_TRY,DAI_BTC,ETC_RUB,USDT_EUR,STQ_RUB,GUSD_USD,GAS_BTC,LTC_RUB,DASH_RUB,ZEC_BTC,ZEC_EUR,DOGE_USD,XRP_ETH,XMR_ETH,SMART_RUB,DXT_BTC,TRX_RUB,STQ_USD,LTC_EUR,ZEC_USD,XRP_USD,WAVES_BTC,MNC_ETH,LSK_RUB,ETH_LTC,BTC_TRY,TRX_UAH,EOS_BTC,ZEC_RUB,BTC_USDT,DOGE_BTC,DASH_USDT,NEO_BTC,ZRX_ETH,OMG_ETH,ADA_USD,ADA_ETH,BTG_BTC,ETH_PLN,KICK_BTC,BTC_EUR,QTUM_BTC,XRP_USDT,DAI_ETH,GAS_USD,USDT_UAH,XEM_BTC,STQ_BTC,MKR_DAI,TRX_USD,BCH_USD,XMR_BTC,EOS_EUR,GNT_BTC,TRX_BTC,XLM_USD,XRP_BTC,BTG_ETH,GNT_ETH,XLM_BTC,XRP_UAH,XEM_USD,XMR_USD,ADA_BTC,LTC_USD,INK_BTC,BTG_USD,BTC_USD,DAI_USD,HBZ_BTC,HBZ_ETH,BCH_EUR,LSK_USD,INK_ETH", "enabledPairs": "BTC_USD,LTC_USD", "baseCurrencies": "USD,EUR,RUB,PLN,UAH", "assetTypes": "SPOT", @@ -618,7 +659,7 @@ "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", "clientId": "ClientID", - "availablePairs": "BCHUSD,BCHBTC,BTCGBP,BTCEUR,BCHGBP,MKRUSDC,BCHEUR,BTCUSD,ZECUSDC,DNTUSDC,LOO-USDC,DAIUSDC,GNTUSDC,ZILUSDC,MAN-USDC,CVCUSDC,ETHUSDC,ZRXEUR,BATUSDC,ETCEUR,BTCUSDC,ZRXUSD,ETHBTC,ETHEUR,ETHUSD,LTCBTC,LTCEUR,LTCUSD,ETCUSD,ETCBTC,ZRXBTC,ETCGBP,ETHGBP,LTCGBP", + "availablePairs": "BCHUSD,BCHBTC,BTCGBP,BTCEUR,BCHGBP,BCHEUR,BTCUSD,ZECUSDC,DNTUSDC,LOO-USDC,DAIUSDC,GNTUSDC,MAN-USDC,CVCUSDC,ETHUSDC,ZRXEUR,BATUSDC,ETCEUR,XRPUSD,XRPEUR,XRPBTC,BTCUSDC,ZRXUSD,ETHBTC,ETHEUR,ETHUSD,LTCBTC,LTCEUR,LTCUSD,ETCUSD,ETCBTC,ZRXBTC,ETCGBP,ETHGBP,LTCGBP", "enabledPairs": "BTCUSD,BTCGBP,BTCEUR", "baseCurrencies": "USD,GBP,EUR", "assetTypes": "SPOT", @@ -658,7 +699,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "USDT_CNYX,BTC_CNYX,ETH_CNYX,EOS_CNYX,BCH_CNYX,XRP_CNYX,DOGE_CNYX,TIPS_CNYX,BTC_USDT,BCH_USDT,ETH_USDT,ETC_USDT,QTUM_USDT,LTC_USDT,DASH_USDT,ZEC_USDT,BTM_USDT,EOS_USDT,REQ_USDT,SNT_USDT,OMG_USDT,PAY_USDT,CVC_USDT,ZRX_USDT,TNT_USDT,XMR_USDT,XRP_USDT,DOGE_USDT,BAT_USDT,PST_USDT,BTG_USDT,DPY_USDT,LRC_USDT,STORJ_USDT,RDN_USDT,STX_USDT,KNC_USDT,LINK_USDT,CDT_USDT,AE_USDT,AE_ETH,AE_BTC,CDT_ETH,RDN_ETH,STX_ETH,KNC_ETH,LINK_ETH,REQ_ETH,RCN_ETH,TRX_ETH,ARN_ETH,KICK_ETH,BNT_ETH,VET_ETH,MCO_ETH,FUN_ETH,DATA_ETH,RLC_ETH,RLC_USDT,ZSC_ETH,WINGS_ETH,MDA_ETH,RCN_USDT,TRX_USDT,KICK_USDT,VET_USDT,MCO_USDT,FUN_USDT,DATA_USDT,ZSC_USDT,MDA_USDT,XTZ_USDT,XTZ_BTC,XTZ_ETH,GNT_USDT,GNT_ETH,GEM_USDT,GEM_ETH,RFR_USDT,RFR_ETH,DADI_USDT,DADI_ETH,ABT_USDT,ABT_ETH,LEDU_BTC,LEDU_ETH,OST_USDT,OST_ETH,XLM_USDT,XLM_ETH,XLM_BTC,MOBI_USDT,MOBI_ETH,MOBI_BTC,OCN_USDT,OCN_ETH,OCN_BTC,ZPT_USDT,ZPT_ETH,ZPT_BTC,COFI_USDT,COFI_ETH,JNT_USDT,JNT_ETH,JNT_BTC,BLZ_USDT,BLZ_ETH,GXS_USDT,GXS_BTC,MTN_USDT,MTN_ETH,RUFF_USDT,RUFF_ETH,RUFF_BTC,TNC_USDT,TNC_ETH,TNC_BTC,ZIL_USDT,ZIL_ETH,BTO_USDT,BTO_ETH,THETA_USDT,THETA_ETH,DDD_USDT,DDD_ETH,DDD_BTC,MKR_USDT,MKR_ETH,DAI_USDT,SMT_USDT,SMT_ETH,MDT_USDT,MDT_ETH,MDT_BTC,MANA_USDT,MANA_ETH,LUN_USDT,LUN_ETH,SALT_USDT,SALT_ETH,FUEL_USDT,FUEL_ETH,ELF_USDT,ELF_ETH,DRGN_USDT,DRGN_ETH,GTC_USDT,GTC_ETH,GTC_BTC,QLC_USDT,QLC_BTC,QLC_ETH,DBC_USDT,DBC_BTC,DBC_ETH,BNTY_USDT,BNTY_ETH,LEND_USDT,LEND_ETH,ICX_USDT,ICX_ETH,BTF_USDT,BTF_BTC,ADA_USDT,ADA_BTC,LSK_USDT,LSK_BTC,WAVES_USDT,WAVES_BTC,BIFI_USDT,BIFI_BTC,MDS_ETH,MDS_USDT,DGD_USDT,DGD_ETH,QASH_USDT,QASH_ETH,QASH_BTC,POWR_USDT,POWR_ETH,POWR_BTC,FIL_USDT,BCD_USDT,BCD_BTC,SBTC_USDT,SBTC_BTC,GOD_USDT,GOD_BTC,BCX_USDT,BCX_BTC,QSP_USDT,QSP_ETH,INK_BTC,INK_USDT,INK_ETH,INK_QTUM,MED_QTUM,MED_ETH,MED_USDT,BOT_QTUM,BOT_USDT,BOT_ETH,QBT_QTUM,QBT_ETH,QBT_USDT,TSL_QTUM,TSL_USDT,GNX_USDT,GNX_ETH,NEO_USDT,GAS_USDT,NEO_BTC,GAS_BTC,IOTA_USDT,IOTA_BTC,NAS_USDT,NAS_ETH,NAS_BTC,ETH_BTC,ETC_BTC,ETC_ETH,ZEC_BTC,DASH_BTC,LTC_BTC,BCH_BTC,BTG_BTC,QTUM_BTC,QTUM_ETH,XRP_BTC,DOGE_BTC,XMR_BTC,ZRX_BTC,ZRX_ETH,DNT_ETH,DPY_ETH,OAX_ETH,REP_ETH,LRC_ETH,LRC_BTC,PST_ETH,BCDN_ETH,BCDN_USDT,TNT_ETH,SNT_ETH,SNT_BTC,BTM_ETH,BTM_BTC,SNET_ETH,SNET_USDT,LLT_SNET,OMG_ETH,OMG_BTC,PAY_ETH,PAY_BTC,BAT_ETH,BAT_BTC,CVC_ETH,STORJ_ETH,STORJ_BTC,EOS_ETH,EOS_BTC,BTS_USDT,BTS_BTC,TIPS_ETH,XEM_ETH,XEM_USDT,XEM_BTC,BU_USDT,BU_ETH,BU_BTC,BCHSV_USDT,BCHSV_CNYX,BCHSV_BTC,DCR_USDT,DCR_BTC,BCN_USDT,BCN_BTC,XMC_USDT,XMC_BTC,ATP_USDT,ATP_ETH,BOE_ETH,BOE_USDT,MEDX_USDT,MEDX_ETH,GRIN_USDT,GRIN_ETH,GRIN_BTC,BEAM_USDT,BEAM_ETH,BEAM_BTC,BTT_USDT,BTT_ETH,CS_ETH,CS_USDT,MAN_ETH,MAN_USDT,REM_ETH,REM_USDT,LYM_ETH,LYM_BTC,LYM_USDT,ONT_ETH,ONT_USDT,BFT_ETH,BFT_USDT,IHT_ETH,IHT_USDT,SENC_ETH,SENC_USDT,TOMO_ETH,TOMO_USDT,ELEC_ETH,ELEC_USDT,HAV_ETH,HAV_USDT,SWTH_ETH,SWTH_USDT,NKN_ETH,NKN_USDT,SOUL_ETH,SOUL_USDT,LRN_ETH,LRN_USDT,EOSDAC_ETH,EOSDAC_USDT,MEETONE_ETH,DOCK_USDT,DOCK_ETH,GSE_USDT,GSE_ETH,RATING_USDT,RATING_ETH,HSC_USDT,HSC_ETH,HIT_USDT,HIT_ETH,DX_USDT,DX_ETH,BXC_USDT,BXC_ETH,PAX_USDT,PAX_CNYX,USDC_CNYX,USDC_USDT,TUSD_CNYX,TUSD_USDT,HC_USDT,HC_BTC,HC_ETH,GARD_USDT,GARD_ETH,FTI_USDT,FTI_ETH,SOP_ETH,SOP_USDT,LEMO_USDT,LEMO_ETH,QKC_USDT,QKC_ETH,IOTX_USDT,IOTX_ETH,RED_USDT,RED_ETH,LBA_USDT,LBA_ETH,OPEN_USDT,OPEN_ETH,MITH_USDT,MITH_ETH,SKM_USDT,SKM_ETH,XVG_USDT,XVG_BTC,NANO_USDT,NANO_BTC,HT_USDT,BNB_USDT,MET_ETH,MET_USDT,TCT_ETH,TCT_USDT,MXC_USDT,MXC_BTC,MXC_ETH", + "availablePairs": "USDT_CNYX,BTC_CNYX,ETH_CNYX,EOS_CNYX,BCH_CNYX,XRP_CNYX,DOGE_CNYX,TIPS_CNYX,BTC_USDT,BCH_USDT,ETH_USDT,ETC_USDT,QTUM_USDT,LTC_USDT,DASH_USDT,ZEC_USDT,BTM_USDT,EOS_USDT,REQ_USDT,SNT_USDT,OMG_USDT,PAY_USDT,CVC_USDT,ZRX_USDT,TNT_USDT,XMR_USDT,XRP_USDT,DOGE_USDT,BAT_USDT,PST_USDT,BTG_USDT,DPY_USDT,LRC_USDT,STORJ_USDT,RDN_USDT,STX_USDT,KNC_USDT,LINK_USDT,CDT_USDT,AE_USDT,AE_ETH,AE_BTC,CDT_ETH,RDN_ETH,STX_ETH,KNC_ETH,LINK_ETH,REQ_ETH,RCN_ETH,TRX_ETH,ARN_ETH,KICK_ETH,BNT_ETH,VET_ETH,MCO_ETH,FUN_ETH,DATA_ETH,RLC_ETH,RLC_USDT,ZSC_ETH,WINGS_ETH,MDA_ETH,RCN_USDT,TRX_USDT,KICK_USDT,VET_USDT,MCO_USDT,FUN_USDT,DATA_USDT,ZSC_USDT,MDA_USDT,XTZ_USDT,XTZ_BTC,XTZ_ETH,GNT_USDT,GNT_ETH,GEM_USDT,GEM_ETH,RFR_USDT,RFR_ETH,DADI_USDT,DADI_ETH,ABT_USDT,ABT_ETH,LEDU_BTC,LEDU_ETH,OST_USDT,OST_ETH,XLM_USDT,XLM_ETH,XLM_BTC,MOBI_USDT,MOBI_ETH,MOBI_BTC,OCN_USDT,OCN_ETH,OCN_BTC,ZPT_USDT,ZPT_ETH,ZPT_BTC,COFI_USDT,COFI_ETH,JNT_USDT,JNT_ETH,JNT_BTC,BLZ_USDT,BLZ_ETH,GXS_USDT,GXS_BTC,MTN_USDT,MTN_ETH,RUFF_USDT,RUFF_ETH,RUFF_BTC,TNC_USDT,TNC_ETH,TNC_BTC,ZIL_USDT,ZIL_ETH,BTO_USDT,BTO_ETH,THETA_USDT,THETA_ETH,DDD_USDT,DDD_ETH,DDD_BTC,MKR_USDT,MKR_ETH,DAI_USDT,SMT_USDT,SMT_ETH,MDT_USDT,MDT_ETH,MDT_BTC,MANA_USDT,MANA_ETH,LUN_USDT,LUN_ETH,SALT_USDT,SALT_ETH,FUEL_USDT,FUEL_ETH,ELF_USDT,ELF_ETH,DRGN_USDT,DRGN_ETH,GTC_USDT,GTC_ETH,GTC_BTC,QLC_USDT,QLC_BTC,QLC_ETH,DBC_USDT,DBC_BTC,DBC_ETH,BNTY_USDT,BNTY_ETH,LEND_USDT,LEND_ETH,ICX_USDT,ICX_ETH,BTF_USDT,BTF_BTC,ADA_USDT,ADA_BTC,LSK_USDT,LSK_BTC,WAVES_USDT,WAVES_BTC,BIFI_USDT,BIFI_BTC,MDS_ETH,MDS_USDT,DGD_USDT,DGD_ETH,QASH_USDT,QASH_ETH,QASH_BTC,POWR_USDT,POWR_ETH,POWR_BTC,FIL_USDT,BCD_USDT,BCD_BTC,SBTC_USDT,SBTC_BTC,GOD_USDT,GOD_BTC,BCX_USDT,BCX_BTC,QSP_USDT,QSP_ETH,INK_BTC,INK_USDT,INK_ETH,INK_QTUM,MED_QTUM,MED_ETH,MED_USDT,BOT_QTUM,BOT_USDT,BOT_ETH,QBT_QTUM,QBT_ETH,QBT_USDT,TSL_QTUM,TSL_USDT,GNX_USDT,GNX_ETH,NEO_USDT,GAS_USDT,NEO_BTC,GAS_BTC,IOTA_USDT,IOTA_BTC,NAS_USDT,NAS_ETH,NAS_BTC,ETH_BTC,ETC_BTC,ETC_ETH,ZEC_BTC,DASH_BTC,LTC_BTC,BCH_BTC,BTG_BTC,QTUM_BTC,QTUM_ETH,XRP_BTC,DOGE_BTC,XMR_BTC,ZRX_BTC,ZRX_ETH,DNT_ETH,DPY_ETH,OAX_ETH,REP_ETH,LRC_ETH,LRC_BTC,PST_ETH,BCDN_ETH,BCDN_USDT,TNT_ETH,SNT_ETH,SNT_BTC,BTM_ETH,BTM_BTC,SNET_ETH,SNET_USDT,LLT_SNET,OMG_ETH,OMG_BTC,PAY_ETH,PAY_BTC,BAT_ETH,BAT_BTC,CVC_ETH,STORJ_ETH,STORJ_BTC,EOS_ETH,EOS_BTC,BTS_USDT,BTS_BTC,TIPS_ETH,XEM_ETH,XEM_USDT,XEM_BTC,BU_USDT,BU_ETH,BU_BTC,BCHSV_USDT,BCHSV_CNYX,BCHSV_BTC,DCR_USDT,DCR_BTC,BCN_USDT,BCN_BTC,XMC_USDT,XMC_BTC,ATP_USDT,ATP_ETH,BOE_ETH,BOE_USDT,MEDX_USDT,MEDX_ETH,GRIN_USDT,GRIN_ETH,GRIN_BTC,BEAM_USDT,BEAM_ETH,BEAM_BTC,VTHO_ETH,BTT_USDT,BTT_ETH,CS_ETH,CS_USDT,MAN_ETH,MAN_USDT,REM_ETH,REM_USDT,LYM_ETH,LYM_BTC,LYM_USDT,ONG_ETH,ONG_USDT,ONT_ETH,ONT_USDT,BFT_ETH,BFT_USDT,IHT_ETH,IHT_USDT,SENC_ETH,SENC_USDT,TOMO_ETH,TOMO_USDT,ELEC_ETH,ELEC_USDT,HAV_ETH,HAV_USDT,SWTH_ETH,SWTH_USDT,NKN_ETH,NKN_USDT,SOUL_ETH,SOUL_USDT,LRN_ETH,LRN_USDT,EOSDAC_ETH,EOSDAC_USDT,DOCK_USDT,DOCK_ETH,GSE_USDT,GSE_ETH,RATING_USDT,RATING_ETH,HSC_USDT,HSC_ETH,HIT_USDT,HIT_ETH,DX_USDT,DX_ETH,BXC_USDT,BXC_ETH,PAX_USDT,PAX_CNYX,USDC_CNYX,USDC_USDT,TUSD_CNYX,TUSD_USDT,HC_USDT,HC_BTC,HC_ETH,GARD_USDT,GARD_ETH,FTI_USDT,FTI_ETH,SOP_ETH,SOP_USDT,LEMO_USDT,LEMO_ETH,QKC_USDT,QKC_ETH,IOTX_USDT,IOTX_ETH,RED_USDT,RED_ETH,LBA_USDT,LBA_ETH,OPEN_USDT,OPEN_ETH,MITH_USDT,MITH_ETH,SKM_USDT,SKM_ETH,XVG_USDT,XVG_BTC,NANO_USDT,NANO_BTC,HT_USDT,BNB_USDT,MET_ETH,MET_USDT,TCT_ETH,TCT_USDT,MXC_USDT,MXC_BTC,MXC_ETH", "enabledPairs": "BTC_USDT", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -738,7 +779,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BCN-BTC,BTC-USD,DASH-BTC,DOGE-BTC,DOGE-USD,EMC-BTC,ETH-BTC,FCN-BTC,LSK-BTC,LTC-BTC,LTC-USD,NXT-BTC,SBD-BTC,SC-BTC,STEEM-BTC,XDN-BTC,XEM-BTC,XMR-BTC,ARDR-BTC,ZEC-BTC,WAVES-BTC,MAID-BTC,AMP-BTC,BUS-BTC,DGD-BTC,SNGLS-BTC,1ST-BTC,TRST-BTC,TIME-BTC,GNO-BTC,REP-BTC,XMR-USD,DASH-USD,ETH-USD,NXT-USD,ZRC-BTC,BOS-BTC,DCT-BTC,ANT-BTC,AEON-BTC,GUP-BTC,PLU-BTC,LUN-BTC,TAAS-BTC,NXC-BTC,EDG-BTC,MLN-BTC,RLC-BTC,SWT-BTC,TKN-BTC,WINGS-BTC,XAUR-BTC,AE-BTC,PTOY-BTC,ZEC-USD,XEM-USD,BCN-USD,XDN-USD,MAID-USD,ETC-BTC,ETC-USD,PLBT-BTC,BNT-BTC,FYN-ETH,SNT-ETH,CVC-USD,PAY-ETH,OAX-ETH,OMG-ETH,BQX-ETH,XTZ-BTC,DICE-BTC,PTOY-ETH,1ST-ETH,XAUR-ETH,TAAS-ETH,TIME-ETH,DICE-ETH,SWT-ETH,XMR-ETH,ETC-ETH,DASH-ETH,ZEC-ETH,PLU-ETH,GNO-ETH,XRP-BTC,STRAT-USD,STRAT-BTC,SNC-ETH,ADX-ETH,BET-ETH,EOS-ETH,DENT-ETH,SAN-ETH,EOS-BTC,EOS-USD,XTZ-ETH,XTZ-USD,UET-ETH,MYB-ETH,SUR-ETH,IXT-ETH,PLR-ETH,TIX-ETH,NDC-ETH,PRO-ETH,AVT-ETH,EVX-USD,DLT-BTC,BNT-ETH,BNT-USD,MANA-USD,DNT-BTC,FYP-BTC,OPT-BTC,TNT-ETH,IFT-BTC,STX-BTC,STX-ETH,STX-USD,TNT-USD,TNT-BTC,CAT-BTC,CAT-ETH,CAT-USD,BCH-BTC,BCH-ETH,BCH-USD,ENG-ETH,XUC-USD,SNC-BTC,SNC-USD,OAX-USD,OAX-BTC,ZRX-BTC,ZRX-ETH,ZRX-USD,RVT-BTC,PPC-BTC,PPC-USD,QTUM-ETH,IGNIS-ETH,BMC-BTC,BMC-ETH,BMC-USD,CND-BTC,CND-ETH,CND-USD,CDT-ETH,CDT-USD,FUN-BTC,FUN-ETH,FUN-USD,HVN-BTC,HVN-ETH,FUEL-BTC,FUEL-ETH,FUEL-USD,POE-BTC,POE-ETH,AMB-USD,AMB-ETH,AMB-BTC,HPC-BTC,PPT-ETH,MTH-BTC,MTH-ETH,LRC-BTC,LRC-ETH,ICX-BTC,ICX-ETH,NEO-BTC,NEO-ETH,NEO-USD,CSNO-BTC,ORME-BTC,ICX-USD,PIX-BTC,PIX-ETH,IND-ETH,KICK-BTC,YOYOW-BTC,CDT-BTC,XVG-BTC,XVG-ETH,XVG-USD,DGB-BTC,DGB-ETH,DGB-USD,DCN-BTC,DCN-ETH,DCN-USD,KIN-BTC,VIBE-BTC,ENJ-BTC,ENJ-ETH,ENJ-USD,ZSC-BTC,ZSC-ETH,ZSC-USD,TRX-BTC,TRX-ETH,TRX-USD,ART-BTC,EVX-BTC,EVX-ETH,SUB-BTC,SUB-ETH,SUB-USD,WTC-BTC,ODN-BTC,BTM-BTC,BTM-ETH,BTM-USD,B2X-BTC,B2X-ETH,B2X-USD,LIFE-BTC,VIB-BTC,VIB-ETH,VIB-USD,DRT-ETH,STU-USD,OMG-BTC,PAY-BTC,PPT-BTC,SNT-BTC,BTG-BTC,BTG-ETH,BTG-USD,SMART-BTC,SMART-ETH,SMART-USD,XUC-ETH,XUC-BTC,LA-ETH,EDO-BTC,EDO-ETH,EDO-USD,HGT-ETH,IXT-BTC,SCL-BTC,ATL-BTC,ETP-BTC,ETP-ETH,ETP-USD,DRPU-BTC,NEBL-BTC,NEBL-ETH,ARN-BTC,ARN-ETH,STU-BTC,STU-ETH,GVT-ETH,BTX-BTC,LTC-ETH,BCN-ETH,MAID-ETH,NXT-ETH,STRAT-ETH,XDN-ETH,XEM-ETH,PLR-BTC,SUR-BTC,BQX-BTC,DOGE-ETH,AMM-BTC,AMM-ETH,AMM-USD,DBIX-BTC,PRE-BTC,ERO-BTC,ZAP-BTC,DOV-BTC,DOV-ETH,DRPU-ETH,OTN-BTC,XRP-ETH,XRP-USD,HSR-BTC,LEND-BTC,LEND-ETH,SPF-BTC,SPF-ETH,SBTC-BTC,SBTC-ETH,LOC-BTC,LOC-ETH,LOC-USD,SWFTC-BTC,SWFTC-ETH,SWFTC-USD,STAR-ETH,SBTC-USD,STORM-BTC,DIM-ETH,DIM-USD,DIM-BTC,NGC-BTC,NGC-ETH,NGC-USD,EMC-ETH,EMC-USD,MCO-BTC,MCO-ETH,MCO-USD,MANA-ETH,MANA-BTC,CPAY-ETH,DATA-BTC,DATA-ETH,DATA-USD,UTT-BTC,UTT-ETH,UTT-USD,KMD-BTC,KMD-ETH,KMD-USD,QTUM-USD,QTUM-BTC,SNT-USD,OMG-USD,EKO-BTC,EKO-ETH,ADX-BTC,ADX-USD,LSK-ETH,LSK-USD,PLR-USD,SUR-USD,BQX-USD,DRT-USD,REP-ETH,REP-USD,WAX-BTC,WAX-ETH,WAX-USD,EET-BTC,EET-ETH,EET-USD,C20-BTC,C20-ETH,IDH-BTC,IDH-ETH,IPL-BTC,COV-BTC,COV-ETH,SENT-BTC,SENT-ETH,SENT-USD,SMT-BTC,SMT-ETH,SMT-USD,CVH-ETH,CVH-USD,CAS-BTC,CAS-ETH,CAS-USD,CHAT-BTC,CHAT-ETH,CHAT-USD,GRMD-BTC,TRAC-ETH,JNT-ETH,PCL-BTC,PCL-ETH,UTK-BTC,UTK-ETH,UTK-USD,GNX-ETH,CHSB-BTC,CHSB-ETH,DAY-BTC,DAY-ETH,DAY-USD,NEU-BTC,NEU-ETH,NEU-USD,TAU-BTC,FLP-BTC,FLP-ETH,FLP-USD,R-BTC,R-ETH,EKO-USD,BCPT-ETH,BCPT-USD,PKT-BTC,PKT-ETH,WLK-BTC,WLK-ETH,WLK-USD,BETR-BTC,BETR-ETH,ARCT-BTC,ARCT-USD,DBET-BTC,DBET-ETH,DBET-USD,RNTB-ETH,HAND-ETH,HAND-USD,ACO-ETH,CPY-BTC,CPY-ETH,CHP-ETH,BCPT-BTC,ACT-BTC,ACT-ETH,ACT-USD,ADA-BTC,ADA-ETH,ADA-USD,SIG-BTC,MTX-BTC,MTX-ETH,MTX-USD,WIZ-BTC,WIZ-ETH,WIZ-USD,DADI-BTC,DADI-ETH,BDG-ETH,DATX-BTC,DATX-ETH,TRUE-BTC,DRG-BTC,DRG-ETH,BANCA-BTC,BANCA-ETH,ZAP-ETH,ZAP-USD,AUTO-BTC,NOAH-BTC,SOC-BTC,INSUR-BTC,INSUR-ETH,OCN-BTC,OCN-ETH,STQ-BTC,STQ-ETH,XLM-BTC,XLM-ETH,XLM-USD,IOTA-BTC,IOTA-ETH,IOTA-USD,DRT-BTC,BETR-USD,ERT-BTC,CRPT-BTC,CRPT-USD,MESH-BTC,MESH-ETH,MESH-USD,IHT-BTC,IHT-ETH,IHT-USD,SCC-BTC,YCC-BTC,DAN-BTC,TEL-BTC,TEL-ETH,BUBO-BTC,BUBO-ETH,BUBO-USD,NCT-BTC,NCT-ETH,NCT-USD,BMH-BTC,BANCA-USD,NOAH-ETH,NOAH-USD,BERRY-BTC,BERRY-ETH,BERRY-USD,GBX-BTC,GBX-ETH,GBX-USD,SHIP-BTC,SHIP-ETH,NANO-BTC,NANO-ETH,NANO-USD,LNC-BTC,KIN-ETH,ARDR-USD,DAXT-BTC,DAXT-ETH,FOTA-ETH,FOTA-BTC,CVT-BTC,CVT-ETH,CVT-USD,STQ-USD,GNT-BTC,GNT-ETH,GNT-USD,ADH-BTC,ADH-ETH,GET-BTC,MITH-BTC,MITH-ETH,MITH-USD,SUNC-ETH,DADI-USD,TKY-BTC,ACAT-BTC,ACAT-ETH,ACAT-USD,BTX-USD,WIKI-BTC,WIKI-ETH,WIKI-USD,ONT-BTC,ONT-ETH,ONT-USD,CVCOIN-BTC,CVCOIN-ETH,CVCOIN-USD,FTX-BTC,FTX-ETH,FREC-BTC,NAVI-BTC,FREC-ETH,FREC-USD,VME-ETH,NAVI-ETH,BTCP-BTC,LND-ETH,CSM-BTC,NANJ-BTC,NTK-BTC,NTK-ETH,NTK-USD,AUC-BTC,AUC-ETH,CMCT-BTC,CMCT-ETH,CMCT-USD,MAN-BTC,MAN-ETH,MAN-USD,TKA-BTC,TKA-ETH,TKA-USD,PNT-BTC,PNT-ETH,FXT-BTC,NEXO-BTC,CHX-BTC,CHX-ETH,CHX-USD,PAT-BTC,PAT-ETH,XMC-BTC,FXT-ETH,XMC-ETH,XMC-USD,FDZ-BTC,FDZ-ETH,FDZ-USD,SPD-BTC,SPD-ETH,LUC-BTC,MITX-BTC,TIV-BTC,B2G-BTC,B2G-USD,ZPT-BTC,ZPT-ETH,HBZ-BTC,FACE-BTC,FACE-ETH,HBZ-ETH,HBZ-USD,ZPT-USD,MORPH-BTC,MORPH-ETH,MORPH-USD,CPT-BTC,PAT-USD,HTML-BTC,HTML-ETH,MITX-ETH,JOT-BTC,JBC-BTC,JBC-ETH,BTS-BTC,BNK-BTC,KBC-BTC,KBC-ETH,BNK-ETH,BNK-USD,TIV-ETH,TIV-USD,LUC-ETH,LUC-USD,CSM-ETH,CSM-USD,INK-BTC,SPC-BTC,IOST-BTC,INK-ETH,INK-USD,SPC-ETH,SPC-USD,IOST-USD,ZIL-BTC,PMNT-BTC,ABYSS-BTC,ABYSS-ETH,ZIL-USD,BCI-BTC,PITCH-BTC,PITCH-ETH,HTML-USD,TDS-BTC,TDS-ETH,TDS-USD,SBD-ETH,SBD-USD,DPN-BTC,UUU-BTC,UUU-ETH,XBP-BTC,KRM-USD,CLN-BTC,IVY-BTC,IVY-ETH,TTU-BTC,TTU-ETH,TTU-USD,CLN-ETH,DOR-BTC,DOR-ETH,DOR-USD,ELEC-BTC,ELEC-ETH,ELEC-USD,QNTU-BTC,QNTU-ETH,QNTU-USD,NLC2-BTC,IPL-ETH,IPL-USD,CENNZ-BTC,BTCP-ETH,BTCP-USD,CENNZ-ETH,SWM-BTC,CLO-BTC,MXM-BTC,MXM-ETH,SPF-USD,LCC-BTC,HGT-BTC,BTC-DAI,ETH-DAI,MKR-DAI,EOS-DAI,USD-DAI,ETH-TUSD,BTC-TUSD,LTC-TUSD,XMR-TUSD,ZRX-TUSD,NEO-TUSD,BCH-TUSD,USD-TUSD,MKR-BTC,MKR-ETH,MKR-USD,TUSD-DAI,NEO-DAI,LTC-DAI,XMR-DAI,BCH-DAI,XRP-DAI,NEXO-ETH,NEXO-USD,PROC-BTC,DWS-BTC,DWS-ETH,DWS-USD,APPC-BTC,APPC-ETH,APPC-USD,BIT-ETH,DASH-EURS,ZEC-EURS,BTC-EURS,EOS-EURS,ETH-EURS,LTC-EURS,BCH-EURS,NEO-EURS,XMR-EURS,XRP-EURS,REX-BTC,REX-ETH,REX-USD,BCD-BTC,ELF-BTC,ELF-USD,BCD-USD,EDG-ETH,EDG-USD,COSM-BTC,COSM-ETH,EURS-USD,EURS-TUSD,EURS-DAI,MNX-USD,ROX-ETH,ZPR-ETH,MNX-BTC,MNX-ETH,KIND-BTC,KIND-ETH,ENGT-BTC,ENGT-ETH,PMA-BTC,PMA-ETH,TV-BTC,TV-ETH,TV-USD,XCLR-BTC,BAT-BTC,BAT-ETH,BAT-USD,SRN-BTC,SRN-ETH,SRN-USD,SVD-BTC,SVD-ETH,SVD-USD,GST-BTC,GST-ETH,GST-USD,BNB-BTC,BNB-ETH,BNB-USD,DIT-BTC,DIT-ETH,UMT-BTC,UMT-ETH,BCST-BTC,BCST-ETH,BCST-USD,POA20-BTC,CCL-USD,POA20-ETH,POA20-USD,POA20-DAI,NIM-BTC,USE-BTC,USE-ETH,ABTC-BTC,DAV-BTC,DAV-ETH,ETN-BTC,ETN-ETH,ETN-USD,ABA-BTC,ABA-ETH,ABA-USD,NIM-ETH,BCN-EOS,LTC-EOS,XMR-EOS,DASH-EOS,TRX-EOS,NEO-EOS,ZEC-EOS,LSK-EOS,XEM-EOS,XRP-EOS,MESSE-BTC,MESSE-ETH,MESSE-USD,CCL-ETH,RCN-BTC,RCN-ETH,RCN-USD,HMQ-BTC,HMQ-ETH,MYST-BTC,MYST-ETH,TOLL-BTC,TOLL-ETH,TOLL-USD,BTC-GUSD,ETH-GUSD,USD-GUSD,EOS-GUSD,AXPR-BTC,AXPR-ETH,DAG-BTC,DAG-ETH,BITS-BTC,BITS-ETH,BITS-USD,USC-BTC,USC-ETH,CDCC-BTC,CDCC-ETH,CDCC-USD,VET-BTC,VET-ETH,VET-USD,SLX-BTC,SLX-USD,SILK-ETH,BOX-BTC,BOX-ETH,BOX-EURS,BOX-EOS,VOCO-BTC,VOCO-ETH,VOCO-USD,PASS-BTC,PASS-ETH,PBTT-BTC,PMA-USD,TRAD-BTC,DGTX-BTC,DGTX-ETH,DGTX-USD,MRK-BTC,MRK-ETH,DGB-TUSD,MESSE-EOS,MESSE-EURS,SNBL-BTC,BCHABC-BTC,BCHABC-USD,BCHSV-BTC,BCHSV-USD,OAK-ETH,BKX-BTC,NPLC-BTC,NPLC-ETH,MRS-BTC,MRS-ETH,MRS-USD,POA-BTC,DTR-BTC,DTR-ETH,TDP-BTC,HBT-ETH,PXG-BTC,PXG-USD,BTC-PAX,ETH-PAX,USD-PAX,BTC-USDC,ETH-USDC,USD-USDC,TUSD-USDC,DAI-USDC,CLO-ETH,CLO-USD,EOS-PAX,PETH-BTC,PETH-ETH,PETH-USD,BRD-BTC,BRD-ETH,NMR-BTC,SALT-BTC,SALT-ETH,POLY-BTC,POLY-ETH,POWR-BTC,POWR-ETH,STORJ-BTC,STORJ-ETH,STORJ-USD,MLN-ETH,BDG-BTC,POA-ETH,POA-USD,POA-DAI,VEO-BTC,PLA-BTC,PLA-ETH,PLA-USD", + "availablePairs": "BCN-BTC,BTC-USD,DASH-BTC,DOGE-BTC,DOGE-USD,EMC-BTC,ETH-BTC,FCN-BTC,LSK-BTC,LTC-BTC,LTC-USD,NXT-BTC,SBD-BTC,SC-BTC,STEEM-BTC,XDN-BTC,XEM-BTC,XMR-BTC,ARDR-BTC,ZEC-BTC,WAVES-BTC,MAID-BTC,AMP-BTC,BUS-BTC,DGD-BTC,SNGLS-BTC,1ST-BTC,TRST-BTC,TIME-BTC,GNO-BTC,REP-BTC,XMR-USD,DASH-USD,ETH-USD,NXT-USD,ZRC-BTC,BOS-BTC,DCT-BTC,ANT-BTC,AEON-BTC,GUP-BTC,PLU-BTC,LUN-BTC,TAAS-BTC,NXC-BTC,EDG-BTC,MLN-BTC,RLC-BTC,SWT-BTC,TKN-BTC,WINGS-BTC,XAUR-BTC,AE-BTC,PTOY-BTC,ZEC-USD,XEM-USD,BCN-USD,XDN-USD,MAID-USD,ETC-BTC,ETC-USD,PLBT-BTC,BNT-BTC,SNT-ETH,CVC-USD,PAY-ETH,OAX-ETH,OMG-ETH,BQX-ETH,XTZ-BTC,DICE-BTC,PTOY-ETH,1ST-ETH,XAUR-ETH,TAAS-ETH,TIME-ETH,DICE-ETH,SWT-ETH,XMR-ETH,ETC-ETH,DASH-ETH,ZEC-ETH,PLU-ETH,GNO-ETH,XRP-BTC,STRAT-USD,STRAT-BTC,SNC-ETH,ADX-ETH,BET-ETH,EOS-ETH,DENT-ETH,SAN-ETH,EOS-BTC,EOS-USD,XTZ-ETH,XTZ-USD,UET-ETH,MYB-ETH,SUR-ETH,IXT-ETH,PLR-ETH,TIX-ETH,NDC-ETH,PRO-ETH,AVT-ETH,EVX-USD,DLT-BTC,BNT-ETH,BNT-USD,MANA-USD,DNT-BTC,FYP-BTC,OPT-BTC,TNT-ETH,IFT-BTC,STX-BTC,STX-ETH,STX-USD,TNT-USD,TNT-BTC,CAT-BTC,CAT-ETH,CAT-USD,BCH-BTC,BCH-ETH,BCH-USD,ENG-ETH,XUC-USD,SNC-BTC,SNC-USD,OAX-USD,OAX-BTC,ZRX-BTC,ZRX-ETH,ZRX-USD,RVT-BTC,PPC-BTC,PPC-USD,QTUM-ETH,IGNIS-ETH,BMC-BTC,BMC-ETH,BMC-USD,CND-BTC,CND-ETH,CND-USD,CDT-ETH,CDT-USD,FUN-BTC,FUN-ETH,FUN-USD,HVN-BTC,HVN-ETH,FUEL-BTC,FUEL-ETH,FUEL-USD,POE-BTC,POE-ETH,AMB-USD,AMB-ETH,AMB-BTC,HPC-BTC,PPT-ETH,MTH-BTC,MTH-ETH,LRC-BTC,LRC-ETH,ICX-BTC,ICX-ETH,NEO-BTC,NEO-ETH,NEO-USD,CSNO-BTC,ICX-USD,PIX-BTC,PIX-ETH,IND-ETH,KICK-BTC,YOYOW-BTC,CDT-BTC,XVG-BTC,XVG-ETH,XVG-USD,DGB-BTC,DGB-ETH,DGB-USD,DCN-BTC,DCN-ETH,DCN-USD,KIN-BTC,VIBE-BTC,ENJ-BTC,ENJ-ETH,ENJ-USD,ZSC-BTC,ZSC-ETH,ZSC-USD,TRX-BTC,TRX-ETH,TRX-USD,ART-BTC,EVX-BTC,EVX-ETH,SUB-BTC,SUB-ETH,SUB-USD,WTC-BTC,ODN-BTC,BTM-BTC,BTM-ETH,BTM-USD,B2X-BTC,B2X-ETH,B2X-USD,LIFE-BTC,VIB-BTC,VIB-ETH,VIB-USD,DRT-ETH,STU-USD,OMG-BTC,PAY-BTC,PPT-BTC,SNT-BTC,BTG-BTC,BTG-ETH,BTG-USD,SMART-BTC,SMART-ETH,SMART-USD,XUC-ETH,XUC-BTC,LA-ETH,EDO-BTC,EDO-ETH,EDO-USD,HGT-ETH,IXT-BTC,SCL-BTC,ATL-BTC,ETP-BTC,ETP-ETH,ETP-USD,DRPU-BTC,NEBL-BTC,NEBL-ETH,ARN-BTC,ARN-ETH,STU-BTC,STU-ETH,GVT-ETH,BTX-BTC,LTC-ETH,BCN-ETH,MAID-ETH,NXT-ETH,STRAT-ETH,XDN-ETH,XEM-ETH,PLR-BTC,SUR-BTC,BQX-BTC,DOGE-ETH,AMM-BTC,AMM-ETH,AMM-USD,DBIX-BTC,PRE-BTC,ERO-BTC,ZAP-BTC,DOV-BTC,DOV-ETH,DRPU-ETH,OTN-BTC,XRP-ETH,XRP-USD,HSR-BTC,LEND-BTC,LEND-ETH,SPF-BTC,SPF-ETH,SBTC-BTC,SBTC-ETH,LOC-BTC,LOC-ETH,LOC-USD,SWFTC-BTC,SWFTC-ETH,SWFTC-USD,STAR-ETH,SBTC-USD,STORM-BTC,DIM-ETH,DIM-USD,DIM-BTC,NGC-BTC,NGC-ETH,NGC-USD,EMC-ETH,EMC-USD,MCO-BTC,MCO-ETH,MCO-USD,MANA-ETH,MANA-BTC,CPAY-ETH,DATA-BTC,DATA-ETH,DATA-USD,UTT-BTC,UTT-ETH,UTT-USD,KMD-BTC,KMD-ETH,KMD-USD,QTUM-USD,QTUM-BTC,SNT-USD,OMG-USD,EKO-BTC,EKO-ETH,ADX-BTC,ADX-USD,LSK-ETH,LSK-USD,PLR-USD,SUR-USD,BQX-USD,DRT-USD,REP-ETH,REP-USD,WAX-BTC,WAX-ETH,WAX-USD,C20-BTC,C20-ETH,IDH-BTC,IDH-ETH,IPL-BTC,COV-BTC,COV-ETH,SENT-BTC,SENT-ETH,SENT-USD,SMT-BTC,SMT-ETH,SMT-USD,CVH-ETH,CVH-USD,CAS-BTC,CAS-ETH,CAS-USD,CHAT-BTC,CHAT-ETH,CHAT-USD,GRMD-BTC,TRAC-ETH,JNT-ETH,UTK-BTC,UTK-ETH,UTK-USD,GNX-ETH,CHSB-BTC,CHSB-ETH,DAY-BTC,DAY-ETH,DAY-USD,NEU-BTC,NEU-ETH,NEU-USD,TAU-BTC,FLP-BTC,FLP-ETH,FLP-USD,R-BTC,R-ETH,EKO-USD,BCPT-ETH,BCPT-USD,PKT-BTC,PKT-ETH,WLK-BTC,WLK-ETH,WLK-USD,BETR-BTC,BETR-ETH,ARCT-BTC,ARCT-USD,DBET-BTC,DBET-ETH,DBET-USD,RNTB-ETH,HAND-ETH,HAND-USD,ACO-ETH,CPY-BTC,CPY-ETH,CHP-ETH,BCPT-BTC,ACT-BTC,ACT-ETH,ACT-USD,ADA-BTC,ADA-ETH,ADA-USD,SIG-BTC,MTX-BTC,MTX-ETH,MTX-USD,WIZ-BTC,WIZ-ETH,WIZ-USD,DADI-BTC,DADI-ETH,BDG-ETH,DATX-BTC,DATX-ETH,TRUE-BTC,DRG-BTC,DRG-ETH,BANCA-BTC,BANCA-ETH,ZAP-ETH,ZAP-USD,AUTO-BTC,NOAH-BTC,SOC-BTC,INSUR-BTC,INSUR-ETH,OCN-BTC,OCN-ETH,STQ-BTC,STQ-ETH,XLM-BTC,XLM-ETH,XLM-USD,IOTA-BTC,IOTA-ETH,IOTA-USD,DRT-BTC,BETR-USD,ERT-BTC,CRPT-BTC,CRPT-USD,MESH-BTC,MESH-ETH,MESH-USD,IHT-BTC,IHT-ETH,IHT-USD,SCC-BTC,YCC-BTC,DAN-BTC,TEL-BTC,TEL-ETH,BUBO-BTC,BUBO-ETH,BUBO-USD,NCT-BTC,NCT-ETH,NCT-USD,BMH-BTC,BANCA-USD,NOAH-ETH,NOAH-USD,BERRY-BTC,BERRY-ETH,BERRY-USD,GBX-BTC,GBX-ETH,GBX-USD,SHIP-BTC,SHIP-ETH,NANO-BTC,NANO-ETH,NANO-USD,LNC-BTC,KIN-ETH,ARDR-USD,DAXT-BTC,DAXT-ETH,FOTA-ETH,FOTA-BTC,CVT-BTC,CVT-ETH,CVT-USD,STQ-USD,GNT-BTC,GNT-ETH,GNT-USD,ADH-BTC,ADH-ETH,GET-BTC,MITH-BTC,MITH-ETH,MITH-USD,SUNC-ETH,DADI-USD,TKY-BTC,ACAT-BTC,ACAT-ETH,ACAT-USD,BTX-USD,WIKI-BTC,WIKI-ETH,WIKI-USD,ONT-BTC,ONT-ETH,ONT-USD,CVCOIN-BTC,CVCOIN-ETH,CVCOIN-USD,FTX-BTC,FTX-ETH,FREC-BTC,NAVI-BTC,FREC-ETH,FREC-USD,VME-ETH,NAVI-ETH,LND-ETH,CSM-BTC,NANJ-BTC,NTK-BTC,NTK-ETH,NTK-USD,AUC-BTC,AUC-ETH,CMCT-BTC,CMCT-ETH,CMCT-USD,MAN-BTC,MAN-ETH,MAN-USD,TKA-BTC,TKA-ETH,TKA-USD,PNT-BTC,PNT-ETH,FXT-BTC,NEXO-BTC,CHX-BTC,CHX-ETH,CHX-USD,PAT-BTC,PAT-ETH,XMC-BTC,FXT-ETH,XMC-ETH,XMC-USD,FDZ-BTC,FDZ-ETH,FDZ-USD,SPD-BTC,SPD-ETH,LUC-BTC,MITX-BTC,TIV-BTC,B2G-BTC,B2G-USD,ZPT-BTC,ZPT-ETH,HBZ-BTC,FACE-BTC,FACE-ETH,HBZ-ETH,HBZ-USD,ZPT-USD,MORPH-BTC,MORPH-ETH,MORPH-USD,CPT-BTC,PAT-USD,HTML-BTC,HTML-ETH,MITX-ETH,JOT-BTC,JBC-BTC,JBC-ETH,BTS-BTC,BNK-BTC,KBC-BTC,KBC-ETH,BNK-ETH,BNK-USD,TIV-ETH,TIV-USD,LUC-ETH,LUC-USD,CSM-ETH,CSM-USD,INK-BTC,SPC-BTC,IOST-BTC,INK-ETH,INK-USD,SPC-ETH,SPC-USD,IOST-USD,ZIL-BTC,PMNT-BTC,ABYSS-BTC,ABYSS-ETH,ZIL-USD,BCI-BTC,PITCH-BTC,PITCH-ETH,HTML-USD,TDS-BTC,TDS-ETH,TDS-USD,SBD-ETH,SBD-USD,DPN-BTC,UUU-BTC,UUU-ETH,XBP-BTC,KRM-USD,CLN-BTC,IVY-BTC,IVY-ETH,CLN-ETH,DOR-BTC,DOR-ETH,DOR-USD,ELEC-BTC,ELEC-ETH,ELEC-USD,QNTU-BTC,QNTU-ETH,QNTU-USD,NLC2-BTC,IPL-ETH,IPL-USD,CENNZ-BTC,CENNZ-ETH,SWM-BTC,CLO-BTC,MXM-BTC,MXM-ETH,SPF-USD,LCC-BTC,HGT-BTC,BTC-DAI,ETH-DAI,MKR-DAI,EOS-DAI,USD-DAI,ETH-TUSD,BTC-TUSD,LTC-TUSD,XMR-TUSD,ZRX-TUSD,NEO-TUSD,BCH-TUSD,USD-TUSD,MKR-BTC,MKR-ETH,MKR-USD,TUSD-DAI,NEO-DAI,LTC-DAI,XMR-DAI,BCH-DAI,XRP-DAI,NEXO-ETH,NEXO-USD,PROC-BTC,DWS-BTC,DWS-ETH,DWS-USD,APPC-BTC,APPC-ETH,APPC-USD,BIT-ETH,DASH-EURS,ZEC-EURS,BTC-EURS,EOS-EURS,ETH-EURS,LTC-EURS,BCH-EURS,NEO-EURS,XMR-EURS,XRP-EURS,REX-BTC,REX-ETH,REX-USD,BCD-BTC,ELF-BTC,ELF-USD,BCD-USD,EDG-ETH,EDG-USD,COSM-BTC,COSM-ETH,EURS-USD,EURS-TUSD,EURS-DAI,MNX-USD,ROX-ETH,ZPR-ETH,MNX-BTC,MNX-ETH,KIND-BTC,KIND-ETH,ENGT-BTC,ENGT-ETH,PMA-BTC,PMA-ETH,TV-BTC,TV-ETH,TV-USD,XCLR-BTC,BAT-BTC,BAT-ETH,BAT-USD,SRN-BTC,SRN-ETH,SRN-USD,SVD-BTC,SVD-ETH,SVD-USD,GST-BTC,GST-ETH,GST-USD,BNB-BTC,BNB-ETH,BNB-USD,DIT-BTC,DIT-ETH,UMT-BTC,UMT-ETH,BCST-BTC,BCST-ETH,BCST-USD,POA20-BTC,CCL-USD,POA20-ETH,POA20-USD,POA20-DAI,NIM-BTC,USE-BTC,USE-ETH,ABTC-BTC,DAV-BTC,DAV-ETH,ETN-BTC,ETN-ETH,ETN-USD,ABA-BTC,ABA-ETH,ABA-USD,NIM-ETH,BCN-EOS,LTC-EOS,XMR-EOS,DASH-EOS,TRX-EOS,NEO-EOS,ZEC-EOS,LSK-EOS,XEM-EOS,XRP-EOS,MESSE-BTC,MESSE-ETH,MESSE-USD,CCL-ETH,RCN-BTC,RCN-ETH,RCN-USD,HMQ-BTC,HMQ-ETH,MYST-BTC,MYST-ETH,TOLL-BTC,TOLL-ETH,TOLL-USD,BTC-GUSD,ETH-GUSD,USD-GUSD,EOS-GUSD,AXPR-BTC,AXPR-ETH,DAG-BTC,DAG-ETH,BITS-BTC,BITS-ETH,BITS-USD,CDCC-BTC,CDCC-ETH,CDCC-USD,VET-BTC,VET-ETH,VET-USD,SLX-BTC,SLX-USD,SILK-ETH,BOX-BTC,BOX-ETH,BOX-EURS,BOX-EOS,VOCO-BTC,VOCO-ETH,VOCO-USD,PASS-BTC,PASS-ETH,PBTT-BTC,PMA-USD,TRAD-BTC,DGTX-BTC,DGTX-ETH,DGTX-USD,MRK-BTC,MRK-ETH,DGB-TUSD,MESSE-EOS,MESSE-EURS,SNBL-BTC,BCHABC-BTC,BCHABC-USD,BCHSV-BTC,BCHSV-USD,OAK-ETH,BKX-BTC,NPLC-BTC,NPLC-ETH,MRS-BTC,MRS-ETH,MRS-USD,POA-BTC,DTR-BTC,DTR-ETH,TDP-BTC,HBT-ETH,PXG-BTC,PXG-USD,BTC-PAX,ETH-PAX,USD-PAX,BTC-USDC,ETH-USDC,USD-USDC,TUSD-USDC,DAI-USDC,CLO-ETH,CLO-USD,EOS-PAX,PETH-BTC,PETH-ETH,PETH-USD,BRD-BTC,BRD-ETH,NMR-BTC,SALT-BTC,SALT-ETH,POLY-BTC,POLY-ETH,POWR-BTC,POWR-ETH,STORJ-BTC,STORJ-ETH,STORJ-USD,MLN-ETH,BDG-BTC,POA-ETH,POA-USD,POA-DAI,VEO-BTC,PLA-BTC,PLA-ETH,PLA-USD,BTT-BTC,BTT-USD,BTT-ETH,ZEN-BTC,ZEN-ETH,ZEN-USD,GRIN-BTC,GRIN-ETH,GRIN-USD,FET-BTC,HT-BTC,HT-USD,HERO-BTC,HERO-ETH", "enabledPairs": "BTC-USD", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -779,7 +820,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTC-USDT,BCH-USDT,ETH-USDT,ETC-USDT,LTC-USDT,EOS-USDT,XRP-USDT,OMG-USDT,DASH-USDT,ZEC-USDT,ADA-USDT,STEEM-USDT,IOTA-USDT,OCN-USDT,SOC-USDT,CTXC-USDT,ACT-USDT,BTM-USDT,BTS-USDT,ONT-USDT,IOST-USDT,HT-USDT,TRX-USDT,DTA-USDT,NEO-USDT,QTUM-USDT,SMT-USDT,ELA-USDT,VEN-USDT,THETA-USDT,SNT-USDT,ZIL-USDT,XEM-USDT,NAS-USDT,RUFF-USDT,HC-USDT,LET-USDT,MDS-USDT,STORJ-USDT,ELF-USDT,ITC-USDT,CVC-USDT,GNT-USDT,XMR-BTC,BCH-BTC,ETH-BTC,LTC-BTC,ETC-BTC,EOS-BTC,OMG-BTC,XRP-BTC,DASH-BTC,ZEC-BTC,ADA-BTC,STEEM-BTC,IOTA-BTC,POLY-BTC,KAN-BTC,LBA-BTC,WAN-BTC,BFT-BTC,BTM-BTC,ONT-BTC,IOST-BTC,HT-BTC,TRX-BTC,SMT-BTC,ELA-BTC,WICC-BTC,OCN-BTC,ZLA-BTC,ABT-BTC,MTX-BTC,NAS-BTC,VEN-BTC,DTA-BTC,NEO-BTC,WAX-BTC,BTS-BTC,ZIL-BTC,THETA-BTC,CTXC-BTC,SRN-BTC,XEM-BTC,ICX-BTC,DGD-BTC,CHAT-BTC,WPR-BTC,LUN-BTC,SWFTC-BTC,SNT-BTC,MEET-BTC,YEE-BTC,ELF-BTC,LET-BTC,QTUM-BTC,LSK-BTC,ITC-BTC,SOC-BTC,QASH-BTC,MDS-BTC,EKO-BTC,TOPC-BTC,MTN-BTC,ACT-BTC,HC-BTC,STK-BTC,STORJ-BTC,GNX-BTC,DBC-BTC,SNC-BTC,CMT-BTC,TNB-BTC,RUFF-BTC,QUN-BTC,ZRX-BTC,KNC-BTC,BLZ-BTC,PROPY-BTC,PHX-BTC,APPC-BTC,AIDOC-BTC,POWR-BTC,CVC-BTC,PAY-BTC,QSP-BTC,DAT-BTC,RDN-BTC,MCO-BTC,RCN-BTC,MANA-BTC,UTK-BTC,TNT-BTC,GAS-BTC,BAT-BTC,OST-BTC,LINK-BTC,GNT-BTC,MTL-BTC,EVX-BTC,REQ-BTC,ADX-BTC,AST-BTC,ENG-BTC,SALT-BTC,EDU-BTC,XVG-BTC,WTC-BTC,BIFI-BTC,BCX-BTC,BCD-BTC,SBTC-BTC,BTG-BTC,XMR-ETH,EOS-ETH,OMG-ETH,IOTA-ETH,ADA-ETH,STEEM-ETH,POLY-ETH,KAN-ETH,LBA-ETH,WAN-ETH,BFT-ETH,ZRX-ETH,AST-ETH,KNC-ETH,ONT-ETH,HT-ETH,BTM-ETH,IOST-ETH,SMT-ETH,ELA-ETH,TRX-ETH,ABT-ETH,NAS-ETH,OCN-ETH,WICC-ETH,ZIL-ETH,CTXC-ETH,ZLA-ETH,WPR-ETH,DTA-ETH,MTX-ETH,THETA-ETH,SRN-ETH,VEN-ETH,BTS-ETH,WAX-ETH,HC-ETH,ICX-ETH,MTN-ETH,ACT-ETH,BLZ-ETH,QASH-ETH,RUFF-ETH,CMT-ETH,ELF-ETH,MEET-ETH,SOC-ETH,QTUM-ETH,ITC-ETH,SWFTC-ETH,YEE-ETH,LSK-ETH,LUN-ETH,LET-ETH,GNX-ETH,CHAT-ETH,EKO-ETH,TOPC-ETH,DGD-ETH,STK-ETH,MDS-ETH,DBC-ETH,SNC-ETH,PAY-ETH,QUN-ETH,AIDOC-ETH,TNB-ETH,APPC-ETH,RDN-ETH,UTK-ETH,POWR-ETH,BAT-ETH,PROPY-ETH,MANA-ETH,REQ-ETH,CVC-ETH,QSP-ETH,EVX-ETH,DAT-ETH,MCO-ETH,GNT-ETH,GAS-ETH,OST-ETH,LINK-ETH,RCN-ETH,TNT-ETH,ENG-ETH,SALT-ETH,ADX-ETH,EDU-ETH,XVG-ETH,WTC-ETH,XRP-HT,IOST-HT,DASH-HT,WICC-USDT,EOS-HT,BCH-HT,LTC-HT,ETC-HT,WAVES-BTC,WAVES-ETH,HB10-USDT,CMT-USDT,DCR-BTC,DCR-ETH,PAI-BTC,PAI-ETH,BOX-BTC,BOX-ETH,DGB-BTC,DGB-ETH,GXC-BTC,GXC-ETH,XLM-BTC,XLM-ETH,BIX-BTC,BIX-ETH,BIX-USDT,HIT-BTC,HIT-ETH,PAI-USDT,BT1-BTC,BT2-BTC,XZC-BTC,XZC-ETH,VET-USDT,VET-ETH,VET-BTC,NCASH-ETH,NCASH-BTC,GRS-BTC,GRS-ETH,RCCC-ETH,EGCC-ETH,IIC-ETH,SHE-ETH,RCCC-BTC,MEX-ETH,EKT-ETH,BKBT-ETH,GTC-ETH,HOT-ETH,FTI-ETH,GSC-ETH,PC-ETH,XMX-ETH,LYM-ETH,CNN-ETH,MAN-ETH,UC-ETH,AAC-ETH,FAIR-ETH,SEELE-ETH,UIP-ETH,LXT-ETH,DATX-ETH,GET-ETH,AE-ETH,UUU-ETH,YCC-ETH,CDC-ETH,BUT-ETH,PORTAL-ETH,SSP-ETH,REN-ETH,MT-ETH,RTE-BTC,FTI-BTC,EKT-BTC,REN-BTC,ZJLT-ETH,TOS-BTC,GET-BTC,SSP-BTC,MUSK-BTC,CNN-BTC,TOS-ETH,GVE-ETH,AE-BTC,NCC-BTC,KCASH-ETH,YCC-BTC,18C-ETH,PNT-ETH,CVCOIN-ETH,NCC-ETH,BCV-BTC,UIP-BTC,PNT-BTC,DAC-ETH,TRIO-ETH,SEELE-BTC,HOT-BTC,BCV-ETH,MUSK-ETH,GTC-BTC,BKBT-BTC,MAN-BTC,AAC-BTC,UC-BTC,SHE-BTC,BUT-BTC,IDT-ETH,MEX-BTC,IDT-BTC,DATX-BTC,ZJLT-BTC,FAIR-BTC,IIC-BTC,RTE-ETH,CDC-BTC,PC-BTC,DAC-BTC,EGCC-BTC,XMX-BTC,GSC-BTC,LXT-BTC,PORTAL-BTC,LYM-BTC,UUU-BTC,TRIO-BTC,KCASH-BTC,MT-HT,MT-BTC,KCASH-HT,18C-BTC,GVE-BTC,CVCOIN-BTC,ARDR-BTC,ARDR-ETH,HPT-USDT,HPT-BTC,HPT-HT,XLM-USDT,NANO-ETH,NANO-BTC,USDT-HUSD,BTC-HUSD,ZEN-ETH,ZEN-BTC,EOS-HUSD,ETH-HUSD,XMR-USDT,HIT-USDT,RBTC-BTC,GXC-USDT,BSV-BTC,DOCK-BTC,DOCK-ETH,XRP-HUSD,BSV-USDT,NANO-USDT,HT-HUSD,MXC-BTC,XTZ-BTC,XTZ-ETH,NULS-BTC,NULS-ETH,LINK-USDT,WAVES-USDT,COVA-ETH,COVA-BTC,ZRX-USDT,LAMB-BTC,LAMB-ETH,DCR-USDT,AE-USDT,CVNT-BTC,CVNT-ETH", + "availablePairs": "BTC-USDT,BCH-USDT,ETH-USDT,ETC-USDT,LTC-USDT,EOS-USDT,XRP-USDT,OMG-USDT,DASH-USDT,ZEC-USDT,ADA-USDT,STEEM-USDT,IOTA-USDT,OCN-USDT,SOC-USDT,CTXC-USDT,ACT-USDT,BTM-USDT,BTS-USDT,ONT-USDT,IOST-USDT,HT-USDT,TRX-USDT,DTA-USDT,NEO-USDT,QTUM-USDT,SMT-USDT,ELA-USDT,VEN-USDT,THETA-USDT,SNT-USDT,ZIL-USDT,XEM-USDT,NAS-USDT,RUFF-USDT,HC-USDT,LET-USDT,MDS-USDT,STORJ-USDT,ELF-USDT,ITC-USDT,CVC-USDT,GNT-USDT,XMR-BTC,BCH-BTC,ETH-BTC,LTC-BTC,ETC-BTC,EOS-BTC,OMG-BTC,XRP-BTC,DASH-BTC,ZEC-BTC,ADA-BTC,STEEM-BTC,IOTA-BTC,POLY-BTC,KAN-BTC,LBA-BTC,WAN-BTC,BFT-BTC,BTM-BTC,ONT-BTC,IOST-BTC,HT-BTC,TRX-BTC,SMT-BTC,ELA-BTC,WICC-BTC,OCN-BTC,ZLA-BTC,ABT-BTC,MTX-BTC,NAS-BTC,VEN-BTC,DTA-BTC,NEO-BTC,WAX-BTC,BTS-BTC,ZIL-BTC,THETA-BTC,CTXC-BTC,SRN-BTC,XEM-BTC,ICX-BTC,DGD-BTC,CHAT-BTC,WPR-BTC,LUN-BTC,SWFTC-BTC,SNT-BTC,MEET-BTC,YEE-BTC,ELF-BTC,LET-BTC,QTUM-BTC,LSK-BTC,ITC-BTC,SOC-BTC,QASH-BTC,MDS-BTC,EKO-BTC,TOPC-BTC,MTN-BTC,ACT-BTC,HC-BTC,STK-BTC,STORJ-BTC,GNX-BTC,DBC-BTC,SNC-BTC,CMT-BTC,TNB-BTC,RUFF-BTC,QUN-BTC,ZRX-BTC,KNC-BTC,BLZ-BTC,PROPY-BTC,PHX-BTC,APPC-BTC,AIDOC-BTC,POWR-BTC,CVC-BTC,PAY-BTC,QSP-BTC,DAT-BTC,RDN-BTC,MCO-BTC,RCN-BTC,MANA-BTC,UTK-BTC,TNT-BTC,GAS-BTC,BAT-BTC,OST-BTC,LINK-BTC,GNT-BTC,MTL-BTC,EVX-BTC,REQ-BTC,ADX-BTC,AST-BTC,ENG-BTC,SALT-BTC,EDU-BTC,XVG-BTC,WTC-BTC,BIFI-BTC,BCX-BTC,BCD-BTC,SBTC-BTC,BTG-BTC,XMR-ETH,EOS-ETH,OMG-ETH,IOTA-ETH,ADA-ETH,STEEM-ETH,POLY-ETH,KAN-ETH,LBA-ETH,WAN-ETH,BFT-ETH,ZRX-ETH,AST-ETH,KNC-ETH,ONT-ETH,HT-ETH,BTM-ETH,IOST-ETH,SMT-ETH,ELA-ETH,TRX-ETH,ABT-ETH,NAS-ETH,OCN-ETH,WICC-ETH,ZIL-ETH,CTXC-ETH,ZLA-ETH,WPR-ETH,DTA-ETH,MTX-ETH,THETA-ETH,SRN-ETH,VEN-ETH,BTS-ETH,WAX-ETH,HC-ETH,ICX-ETH,MTN-ETH,ACT-ETH,BLZ-ETH,QASH-ETH,RUFF-ETH,CMT-ETH,ELF-ETH,MEET-ETH,SOC-ETH,QTUM-ETH,ITC-ETH,SWFTC-ETH,YEE-ETH,LSK-ETH,LUN-ETH,LET-ETH,GNX-ETH,CHAT-ETH,EKO-ETH,TOPC-ETH,DGD-ETH,STK-ETH,MDS-ETH,DBC-ETH,SNC-ETH,PAY-ETH,QUN-ETH,AIDOC-ETH,TNB-ETH,APPC-ETH,RDN-ETH,UTK-ETH,POWR-ETH,BAT-ETH,PROPY-ETH,MANA-ETH,REQ-ETH,CVC-ETH,QSP-ETH,EVX-ETH,DAT-ETH,MCO-ETH,GNT-ETH,GAS-ETH,OST-ETH,LINK-ETH,RCN-ETH,TNT-ETH,ENG-ETH,SALT-ETH,ADX-ETH,EDU-ETH,XVG-ETH,WTC-ETH,XRP-HT,IOST-HT,DASH-HT,WICC-USDT,EOS-HT,BCH-HT,LTC-HT,ETC-HT,WAVES-BTC,WAVES-ETH,HB10-USDT,CMT-USDT,DCR-BTC,DCR-ETH,PAI-BTC,PAI-ETH,BOX-BTC,BOX-ETH,DGB-BTC,DGB-ETH,GXC-BTC,GXC-ETH,XLM-BTC,XLM-ETH,BIX-BTC,BIX-ETH,BIX-USDT,HIT-BTC,HIT-ETH,PAI-USDT,BT1-BTC,BT2-BTC,XZC-BTC,XZC-ETH,VET-USDT,VET-ETH,VET-BTC,NCASH-ETH,NCASH-BTC,GRS-BTC,GRS-ETH,RCCC-ETH,EGCC-ETH,IIC-ETH,SHE-ETH,RCCC-BTC,MEX-ETH,EKT-ETH,BKBT-ETH,GTC-ETH,HOT-ETH,FTI-ETH,GSC-ETH,PC-ETH,XMX-ETH,LYM-ETH,CNN-ETH,MAN-ETH,UC-ETH,AAC-ETH,FAIR-ETH,SEELE-ETH,UIP-ETH,LXT-ETH,DATX-ETH,GET-ETH,AE-ETH,UUU-ETH,YCC-ETH,CDC-ETH,BUT-ETH,PORTAL-ETH,SSP-ETH,REN-ETH,MT-ETH,RTE-BTC,FTI-BTC,EKT-BTC,REN-BTC,ZJLT-ETH,TOS-BTC,GET-BTC,SSP-BTC,MUSK-BTC,CNN-BTC,TOS-ETH,GVE-ETH,AE-BTC,NCC-BTC,KCASH-ETH,YCC-BTC,18C-ETH,PNT-ETH,CVCOIN-ETH,NCC-ETH,BCV-BTC,UIP-BTC,PNT-BTC,DAC-ETH,TRIO-ETH,SEELE-BTC,HOT-BTC,BCV-ETH,MUSK-ETH,GTC-BTC,BKBT-BTC,MAN-BTC,AAC-BTC,UC-BTC,SHE-BTC,BUT-BTC,IDT-ETH,MEX-BTC,IDT-BTC,DATX-BTC,ZJLT-BTC,FAIR-BTC,IIC-BTC,RTE-ETH,CDC-BTC,PC-BTC,DAC-BTC,EGCC-BTC,XMX-BTC,GSC-BTC,LXT-BTC,PORTAL-BTC,LYM-BTC,UUU-BTC,TRIO-BTC,KCASH-BTC,MT-HT,MT-BTC,KCASH-HT,18C-BTC,GVE-BTC,CVCOIN-BTC,ARDR-BTC,ARDR-ETH,HPT-USDT,HPT-BTC,HPT-HT,XLM-USDT,NANO-ETH,NANO-BTC,USDT-HUSD,BTC-HUSD,ZEN-ETH,ZEN-BTC,EOS-HUSD,ETH-HUSD,XMR-USDT,HIT-USDT,RBTC-BTC,GXC-USDT,BSV-BTC,DOCK-BTC,DOCK-ETH,XRP-HUSD,BSV-USDT,NANO-USDT,HT-HUSD,MXC-BTC,XTZ-BTC,XTZ-ETH,NULS-BTC,NULS-ETH,LINK-USDT,WAVES-USDT,COVA-ETH,COVA-BTC,ZRX-USDT,LAMB-BTC,LAMB-ETH,DCR-USDT,AE-USDT,CVNT-BTC,CVNT-ETH,BTT-ETH,BTT-USDT,BTT-BTC,SC-ETH,SC-BTC,KMD-BTC,KMD-ETH,LOOM-BTC,LOOM-ETH,NEXO-BTC,NEXO-ETH", "enabledPairs": "BTC-USDT", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -942,7 +983,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTCGBP,AUDUSD,USDJPY,BTCAUD,GBPUSD,USDHKD,BTCEUR,BTCCHF,USDCAD,XRPBTC,NZDUSD,BCHBTC,BTCNZD,EURUSD,USDNGN,BTCSGD,BTCJPY,USDSGD,BTCCAD,USDCHF,BTCUSD,BTCNGN,ETHBTC,LTCBTC,BTCHKD,BACETH", + "availablePairs": "USDHKD,NZDUSD,BTCSGD,USDNGN,USDCHF,BTCNZD,USDJPY,EURUSD,USDSGD,BTCCAD,BTCNGN,BACETH,BTCUSD,AUDUSD,BTCJPY,XRPBTC,BTCAUD,BTCGBP,BTCCHF,USDCAD,BTCEUR,LTCBTC,ETHBTC,BCHBTC,BTCHKD,GBPUSD", "enabledPairs": "BTCUSD,BTCAUD", "baseCurrencies": "USD,EUR,HKD,AUD,GBP,NZD,JPY,SGD,NGN,CHF,CAD", "assetTypes": "SPOT", @@ -981,7 +1022,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTCCOP,BTCMYR,BTCXMR,BTCSGD,BTCGHS,BTCNGN,BTCMWK,BTCCHF,BTCNZD,BTCKZT,BTCUSD,BTCXOF,BTCTTD,BTCHRK,BTCPHP,BTCPAB,BTCPKR,BTCTHB,BTCBOB,BTCGTQ,BTCCAD,BTCKRW,BTCRUB,BTCINR,BTCMAD,BTCCZK,BTCAED,BTCETH,BTCJPY,BTCHKD,BTCBYN,BTCNOK,BTCZAR,BTCHUF,BTCGEL,BTCMXN,BTCLKR,BTCOMR,BTCBDT,BTCUYU,BTCXRP,BTCEGP,BTCCNY,BTCRWF,BTCTWD,BTCRSD,BTCZMW,BTCDKK,BTCCLP,BTCTRY,BTCPLN,BTCBWP,BTCIDR,BTCAUD,BTCGBP,BTCDOP,BTCTZS,BTCLTC,BTCUGX,BTCCRC,BTCIRR,BTCARS,BTCBRL,BTCDASH,BTCSAR,BTCXAF,BTCEUR,BTCHTG,BTCKES,BTCHNL,BTCRON,BTCUAH,BTCVES,BTCBAM,BTCQAR,BTCSEK,BTCPEN,BTCILS", + "availablePairs": "BTCEGP,BTCDKK,BTCUGX,BTCXOF,BTCILS,BTCRON,BTCCLP,BTCXAF,BTCPAB,BTCBOB,BTCHNL,BTCFJD,BTCCRC,BTCUAH,BTCEUR,BTCKES,BTCGHS,BTCBYN,BTCNZD,BTCTWD,BTCAED,BTCVND,BTCZMW,BTCLTC,BTCIRR,BTCHRK,BTCCOP,BTCNGN,BTCVES,BTCSEK,BTCZAR,BTCPHP,BTCCNY,BTCUYU,BTCHUF,BTCMWK,BTCLKR,BTCRSD,BTCGTQ,BTCSAR,BTCETH,BTCXRP,BTCBRL,BTCMAD,BTCPEN,BTCKWD,BTCMYR,BTCBDT,BTCKRW,BTCETB,BTCTZS,BTCSZL,BTCCAD,BTCSGD,BTCGEL,BTCCHF,BTCNOK,BTCGBP,BTCAUD,BTCRWF,BTCKZT,BTCMXN,BTCPLN,BTCPKR,BTCXMR,BTCHKD,BTCBWP,BTCTRY,BTCRUB,BTCINR,BTCUSD,BTCDOP,BTCJPY,BTCOMR,BTCTHB,BTCARS,BTCPGK,BTCMUR,BTCQAR,BTCCZK", "enabledPairs": "BTCARS,BTCAUD,BTCBRL,BTCCAD,BTCCHF,BTCCZK,BTCDKK,BTCEUR,BTCGBP,BTCHKD,BTCILS,BTCINR,BTCMXN,BTCNOK,BTCNZD,BTCPLN,BTCRUB,BTCSEK,BTCSGD,BTCTHB,BTCUSD,BTCZAR", "baseCurrencies": "ARS,AUD,BRL,CAD,CHF,CZK,DKK,EUR,GBP,HKD,ILS,INR,MXN,NOK,NZD,PLN,RUB,SEK,SGD,THB,USD,ZAR", "assetTypes": "SPOT", @@ -1020,7 +1061,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "BTC_USD,LTC_USD,ETH_USD,ETC_USD,TUSD_USD,ETH_BTC,ETC_BTC,TUSD_BTC,LTC_BTC,USDT_BTC,ZEC_BTC,ADA_BTC,XLM_BTC,ZRX_BTC,XRP_BTC,BAT_BTC,PAX_BTC,GUSD_BTC,USDC_BTC,BCH_BTC,BSV_BTC,TRX_BTC,TUSD_ETH,ETC_ETH,LTC_ETH,USDT_ETH,ZEC_ETH,ADA_ETH,XLM_ETH,ZRX_ETH,XRP_ETH,BAT_ETH,TRX_ETH,USDT_USD,ZEC_USD,ADA_USD,XLM_USD,ZRX_USD,XRP_USD,BAT_USD,PAX_USD,GUSD_USD,USDC_USD,BCH_USD,BSV_USD,TRX_USD", + "availablePairs": "BTC_USD,LTC_USD,ETH_USD,ETC_USD,TUSD_USD,ETH_BTC,ETC_BTC,TUSD_BTC,LTC_BTC,USDT_BTC,ZEC_BTC,ADA_BTC,XLM_BTC,ZRX_BTC,XRP_BTC,BAT_BTC,PAX_BTC,GUSD_BTC,USDC_BTC,BCH_BTC,BSV_BTC,TRX_BTC,GRIN_BTC,TUSD_ETH,ETC_ETH,LTC_ETH,USDT_ETH,ZEC_ETH,ADA_ETH,XLM_ETH,ZRX_ETH,XRP_ETH,BAT_ETH,TRX_ETH,GRIN_ETH,USDT_USD,ZEC_USD,ADA_USD,XLM_USD,ZRX_USD,XRP_USD,BAT_USD,PAX_USD,GUSD_USD,USDC_USD,BCH_USD,BSV_USD,TRX_USD,GRIN_USD", "enabledPairs": "BTC_USD", "baseCurrencies": "USD", "assetTypes": "SPOT", @@ -1102,7 +1143,7 @@ "apiUrlSecondary": "NON_DEFAULT_HTTP_LINK_TO_EXCHANGE_API", "proxyAddress": "", "websocketUrl": "NON_DEFAULT_HTTP_LINK_TO_WEBSOCKET_EXCHANGE_API", - "availablePairs": "USDT_MANA,USDC_USDT,USDT_NXT,BTC_BCHSV,BTC_XCP,BTC_SNT,BTC_FOAM,USDC_FOAM,BTC_GNT,BTC_LTC,BTC_NMC,BTC_LBC,BTC_ETC,ETH_EOS,ETH_KNC,ETH_BNT,BTC_GAME,USDT_BNT,BTC_PPC,USDT_BTC,USDT_QTUM,USDC_LTC,BTC_NMR,BTC_SC,BTC_REP,BTC_BAT,USDT_ZRX,USDC_XRP,USDT_ETH,BTC_STR,BTC_XMR,BTC_LSK,ETH_BCH,BTC_BNT,BTC_NXT,USDT_EOS,USDT_STR,ETH_REP,BTC_PASC,BTC_STORJ,BTC_KNC,USDT_LSK,BTC_ETH,BTC_OMNI,USDT_DASH,XMR_NXT,BTC_STEEM,BTC_STRAT,USDT_BAT,BTC_DOGE,ETH_SNT,USDT_KNC,USDT_SC,USDC_XMR,BTC_GAS,BTC_SYS,BTC_QTUM,BTC_BTS,XMR_MAID,USDC_BCHSV,USDT_XRP,USDC_ETH,BTC_OMG,ETH_STEEM,BTC_ARDR,ETH_BAT,ETH_LSK,ETH_CVC,USDC_BCHABC,BTC_LPT,BTC_XPM,ETH_LOOM,BTC_BCHABC,BTC_HUC,ETH_QTUM,XMR_BCN,ETH_OMG,USDC_STR,BTC_DCR,ETH_GAS,USDC_DOGE,ETH_GNT,USDT_XMR,USDT_ZEC,BTC_ZRX,USDT_DOGE,USDT_GNT,BTC_XEM,BTC_DGB,XMR_LTC,BTC_FCT,USDT_LOOM,ETH_MANA,BTC_BURST,XMR_DASH,BTC_MANA,BTC_POLY,BTC_VIA,BTC_CLAM,BTC_MAID,XMR_ZEC,USDT_BCH,BTC_BCN,BTC_XRP,USDT_LTC,USDT_ETC,ETH_ZEC,BTC_LOOM,BTC_DASH,BTC_CVC,BTC_EOS,BTC_VTC,BTC_ZEC,USDC_BTC,BTC_SBD,ETH_ETC,USDT_REP,BTC_BCH,ETH_ZRX,USDT_SNT,USDC_BCH,USDC_ZEC,BTC_NAV", + "availablePairs": "BTC_STR,USDT_DASH,ETH_ETC,USDT_SC,BTC_BCHABC,BTC_LPT,BTC_GRIN,BTC_BURST,ETH_ZEC,ETH_CVC,BTC_XEM,USDT_BTC,BTC_REP,ETH_GAS,USDC_ZEC,BTC_MAID,USDC_BCHSV,BTC_POLY,ETH_GNT,BTC_OMG,XMR_LTC,USDT_ETH,ETH_LSK,ETH_SNT,USDT_ETC,XMR_ZEC,ETH_ZRX,BTC_BTS,BTC_FCT,BTC_SBD,ETH_BCH,ETH_OMG,USDT_EOS,BTC_XRP,USDT_BAT,BTC_FOAM,USDT_XMR,BTC_GNT,BTC_EOS,USDT_KNC,BTC_XCP,USDT_GNT,USDC_STR,BTC_NMR,BTC_STEEM,BTC_BCH,BTC_DASH,BTC_GAME,XMR_DASH,BTC_SNT,BTC_ZEC,USDT_BCH,USDC_ETH,BTC_OMNI,BTC_LOOM,USDT_QTUM,BTC_MANA,BTC_BCN,XMR_NXT,BTC_ZRX,USDT_LOOM,ETH_QTUM,BTC_PPC,BTC_VIA,ETH_EOS,USDT_SNT,ETH_LOOM,USDC_BTC,USDC_XMR,USDC_FOAM,BTC_LTC,USDT_NXT,BTC_PASC,BTC_STORJ,USDC_BCH,USDC_XRP,BTC_XMR,BTC_CVC,USDT_DOGE,ETH_BNT,BTC_CLAM,BTC_DGB,BTC_DCR,BTC_LSK,BTC_LBC,BTC_ETC,ETH_MANA,USDT_XRP,BTC_BAT,BTC_KNC,BTC_XPM,XMR_MAID,ETH_REP,BTC_STRAT,USDT_LSK,USDC_BCHABC,USDC_DOGE,BTC_NAV,BTC_SC,ETH_STEEM,USDT_BNT,USDC_LTC,BTC_SYS,BTC_VTC,BTC_GAS,USDC_GRIN,BTC_DOGE,BTC_HUC,USDT_STR,USDT_MANA,BTC_ETH,BTC_BCHSV,BTC_NMC,XMR_BCN,USDT_ZEC,ETH_KNC,USDT_ZRX,BTC_QTUM,USDC_USDT,BTC_ARDR,ETH_BAT,BTC_BNT,BTC_NXT,USDT_LTC,USDT_REP", "enabledPairs": "BTC_LTC,BTC_ETH,BTC_DOGE,BTC_DASH,BTC_XRP", "baseCurrencies": "USD", "assetTypes": "SPOT", diff --git a/tools/documentation/root_templates/root_readme.tmpl b/tools/documentation/root_templates/root_readme.tmpl index 861e9b4c..0abfdd1c 100644 --- a/tools/documentation/root_templates/root_readme.tmpl +++ b/tools/documentation/root_templates/root_readme.tmpl @@ -30,6 +30,7 @@ Join our slack to discuss all things related to GoCryptoTrader! [GoCryptoTrader | Bittrex | Yes | No | NA | | BTCC | Yes | Yes | No | | BTCMarkets | Yes | No | NA | +| BTSE | Yes | Yes | NA | | COINUT | Yes | Yes | NA | | Exmo | Yes | NA | NA | | CoinbasePro | Yes | Yes | No| diff --git a/tools/exchange_template/wrapper_file.tmpl b/tools/exchange_template/wrapper_file.tmpl index 98a8052e..6fc6d2a9 100644 --- a/tools/exchange_template/wrapper_file.tmpl +++ b/tools/exchange_template/wrapper_file.tmpl @@ -137,7 +137,7 @@ func ({{.Variable}} *{{.CapitalName}}) CancelAllOrders(orderCancellation exchang } // GetOrderInfo returns information on a current open order -func ({{.Variable}} *{{.CapitalName}}) GetOrderInfo(orderID int64) (exchange.OrderDetail, error) { +func ({{.Variable}} *{{.CapitalName}}) GetOrderInfo(orderID string) (exchange.OrderDetail, error) { return exchange.OrderDetail{}, common.ErrNotYetImplemented }