5906 lines
267 KiB
Go
5906 lines
267 KiB
Go
package ccxt
|
||
|
||
// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
|
||
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
|
||
|
||
type kucoin struct {
|
||
Exchange
|
||
|
||
}
|
||
|
||
func NewKucoinCore() kucoin {
|
||
p := kucoin{}
|
||
setDefaults(&p)
|
||
return p
|
||
}
|
||
|
||
func (this *kucoin) Describe() interface{} {
|
||
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
|
||
"id": "kucoin",
|
||
"name": "KuCoin",
|
||
"countries": []interface{}{"SC"},
|
||
"rateLimit": 10,
|
||
"version": "v2",
|
||
"certified": true,
|
||
"pro": true,
|
||
"comment": "Platform 2.0",
|
||
"quoteJsonNumbers": false,
|
||
"has": map[string]interface{} {
|
||
"CORS": nil,
|
||
"spot": true,
|
||
"margin": true,
|
||
"swap": false,
|
||
"future": false,
|
||
"option": false,
|
||
"borrowCrossMargin": true,
|
||
"borrowIsolatedMargin": true,
|
||
"cancelAllOrders": true,
|
||
"cancelOrder": true,
|
||
"closeAllPositions": false,
|
||
"closePosition": false,
|
||
"createDepositAddress": true,
|
||
"createMarketBuyOrderWithCost": true,
|
||
"createMarketOrderWithCost": true,
|
||
"createMarketSellOrderWithCost": true,
|
||
"createOrder": true,
|
||
"createOrders": true,
|
||
"createPostOnlyOrder": true,
|
||
"createStopLimitOrder": true,
|
||
"createStopMarketOrder": true,
|
||
"createStopOrder": true,
|
||
"createTriggerOrder": true,
|
||
"editOrder": true,
|
||
"fetchAccounts": true,
|
||
"fetchBalance": true,
|
||
"fetchBorrowInterest": true,
|
||
"fetchBorrowRateHistories": true,
|
||
"fetchBorrowRateHistory": true,
|
||
"fetchClosedOrders": true,
|
||
"fetchCrossBorrowRate": false,
|
||
"fetchCrossBorrowRates": false,
|
||
"fetchCurrencies": true,
|
||
"fetchDepositAddress": true,
|
||
"fetchDepositAddresses": false,
|
||
"fetchDepositAddressesByNetwork": true,
|
||
"fetchDeposits": true,
|
||
"fetchDepositWithdrawFee": true,
|
||
"fetchDepositWithdrawFees": true,
|
||
"fetchFundingHistory": false,
|
||
"fetchFundingRate": false,
|
||
"fetchFundingRateHistory": false,
|
||
"fetchFundingRates": false,
|
||
"fetchIndexOHLCV": false,
|
||
"fetchIsolatedBorrowRate": false,
|
||
"fetchIsolatedBorrowRates": false,
|
||
"fetchL3OrderBook": true,
|
||
"fetchLedger": true,
|
||
"fetchLeverageTiers": false,
|
||
"fetchMarginAdjustmentHistory": false,
|
||
"fetchMarginMode": false,
|
||
"fetchMarketLeverageTiers": false,
|
||
"fetchMarkets": true,
|
||
"fetchMarkOHLCV": false,
|
||
"fetchMarkPrice": true,
|
||
"fetchMarkPrices": true,
|
||
"fetchMyTrades": true,
|
||
"fetchOHLCV": true,
|
||
"fetchOpenInterest": false,
|
||
"fetchOpenInterestHistory": false,
|
||
"fetchOpenOrders": true,
|
||
"fetchOrder": true,
|
||
"fetchOrderBook": true,
|
||
"fetchOrderBooks": false,
|
||
"fetchOrdersByStatus": true,
|
||
"fetchOrderTrades": true,
|
||
"fetchPositionHistory": false,
|
||
"fetchPositionMode": false,
|
||
"fetchPositionsHistory": false,
|
||
"fetchPremiumIndexOHLCV": false,
|
||
"fetchStatus": true,
|
||
"fetchTicker": true,
|
||
"fetchTickers": true,
|
||
"fetchTime": true,
|
||
"fetchTrades": true,
|
||
"fetchTradingFee": true,
|
||
"fetchTradingFees": false,
|
||
"fetchTransactionFee": true,
|
||
"fetchTransfers": false,
|
||
"fetchWithdrawals": true,
|
||
"repayCrossMargin": true,
|
||
"repayIsolatedMargin": true,
|
||
"setLeverage": true,
|
||
"setMarginMode": false,
|
||
"setPositionMode": false,
|
||
"signIn": false,
|
||
"transfer": true,
|
||
"withdraw": true,
|
||
},
|
||
"urls": map[string]interface{} {
|
||
"logo": "https://user-images.githubusercontent.com/51840849/87295558-132aaf80-c50e-11ea-9801-a2fb0c57c799.jpg",
|
||
"referral": "https://www.kucoin.com/ucenter/signup?rcode=E5wkqe",
|
||
"api": map[string]interface{} {
|
||
"public": "https://api.kucoin.com",
|
||
"private": "https://api.kucoin.com",
|
||
"futuresPrivate": "https://api-futures.kucoin.com",
|
||
"futuresPublic": "https://api-futures.kucoin.com",
|
||
"webExchange": "https://kucoin.com/_api",
|
||
"broker": "https://api-broker.kucoin.com",
|
||
"earn": "https://api.kucoin.com",
|
||
},
|
||
"www": "https://www.kucoin.com",
|
||
"doc": []interface{}{"https://docs.kucoin.com"},
|
||
},
|
||
"requiredCredentials": map[string]interface{} {
|
||
"apiKey": true,
|
||
"secret": true,
|
||
"password": true,
|
||
},
|
||
"api": map[string]interface{} {
|
||
"public": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"currencies": 4.5,
|
||
"currencies/{currency}": 4.5,
|
||
"symbols": 6,
|
||
"market/orderbook/level1": 3,
|
||
"market/allTickers": 22.5,
|
||
"market/stats": 22.5,
|
||
"markets": 4.5,
|
||
"market/orderbook/level{level}_{limit}": 6,
|
||
"market/orderbook/level2_20": 3,
|
||
"market/orderbook/level2_100": 6,
|
||
"market/histories": 4.5,
|
||
"market/candles": 4.5,
|
||
"prices": 4.5,
|
||
"timestamp": 4.5,
|
||
"status": 4.5,
|
||
"mark-price/{symbol}/current": 3,
|
||
"mark-price/all-symbols": 3,
|
||
"margin/config": 25,
|
||
"announcements": 20,
|
||
},
|
||
"post": map[string]interface{} {
|
||
"bullet-public": 15,
|
||
},
|
||
},
|
||
"private": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"user-info": 30,
|
||
"accounts": 7.5,
|
||
"accounts/{accountId}": 7.5,
|
||
"accounts/ledgers": 3,
|
||
"hf/accounts/ledgers": 2,
|
||
"hf/margin/account/ledgers": 2,
|
||
"transaction-history": 3,
|
||
"sub/user": 30,
|
||
"sub-accounts/{subUserId}": 22.5,
|
||
"sub-accounts": 30,
|
||
"sub/api-key": 30,
|
||
"margin/account": 40,
|
||
"margin/accounts": 15,
|
||
"isolated/accounts": 15,
|
||
"deposit-addresses": 7.5,
|
||
"deposits": 7.5,
|
||
"hist-deposits": 7.5,
|
||
"withdrawals": 30,
|
||
"hist-withdrawals": 30,
|
||
"withdrawals/quotas": 30,
|
||
"accounts/transferable": 30,
|
||
"transfer-list": 30,
|
||
"base-fee": 3,
|
||
"trade-fees": 3,
|
||
"market/orderbook/level{level}": 3,
|
||
"market/orderbook/level2": 3,
|
||
"market/orderbook/level3": 3,
|
||
"hf/accounts/opened": 2,
|
||
"hf/orders/active": 2,
|
||
"hf/orders/active/symbols": 2,
|
||
"hf/margin/order/active/symbols": 2,
|
||
"hf/orders/done": 2,
|
||
"hf/orders/{orderId}": 2,
|
||
"hf/orders/client-order/{clientOid}": 2,
|
||
"hf/orders/dead-cancel-all/query": 2,
|
||
"hf/fills": 2,
|
||
"orders": 2,
|
||
"limit/orders": 3,
|
||
"orders/{orderId}": 2,
|
||
"order/client-order/{clientOid}": 3,
|
||
"fills": 10,
|
||
"limit/fills": 20,
|
||
"stop-order": 8,
|
||
"stop-order/{orderId}": 3,
|
||
"stop-order/queryOrderByClientOid": 3,
|
||
"oco/order/{orderId}": 2,
|
||
"oco/order/details/{orderId}": 2,
|
||
"oco/client-order/{clientOid}": 2,
|
||
"oco/orders": 2,
|
||
"hf/margin/orders/active": 4,
|
||
"hf/margin/orders/done": 10,
|
||
"hf/margin/orders/{orderId}": 4,
|
||
"hf/margin/orders/client-order/{clientOid}": 5,
|
||
"hf/margin/fills": 5,
|
||
"etf/info": 25,
|
||
"margin/currencies": 20,
|
||
"risk/limit/strategy": 20,
|
||
"isolated/symbols": 20,
|
||
"margin/symbols": 5,
|
||
"isolated/account/{symbol}": 50,
|
||
"margin/borrow": 15,
|
||
"margin/repay": 15,
|
||
"margin/interest": 20,
|
||
"project/list": 10,
|
||
"project/marketInterestRate": 7.5,
|
||
"redeem/orders": 10,
|
||
"purchase/orders": 10,
|
||
"broker/api/rebase/download": 3,
|
||
"migrate/user/account/status": 3,
|
||
"affiliate/inviter/statistics": 30,
|
||
},
|
||
"post": map[string]interface{} {
|
||
"sub/user/created": 22.5,
|
||
"sub/api-key": 30,
|
||
"sub/api-key/update": 45,
|
||
"deposit-addresses": 30,
|
||
"withdrawals": 7.5,
|
||
"accounts/universal-transfer": 6,
|
||
"accounts/sub-transfer": 45,
|
||
"accounts/inner-transfer": 15,
|
||
"transfer-out": 30,
|
||
"transfer-in": 30,
|
||
"hf/orders": 1,
|
||
"hf/orders/test": 1,
|
||
"hf/orders/sync": 1,
|
||
"hf/orders/multi": 1,
|
||
"hf/orders/multi/sync": 1,
|
||
"hf/orders/alter": 3,
|
||
"hf/orders/dead-cancel-all": 2,
|
||
"orders": 2,
|
||
"orders/test": 2,
|
||
"orders/multi": 3,
|
||
"stop-order": 2,
|
||
"oco/order": 2,
|
||
"hf/margin/order": 5,
|
||
"hf/margin/order/test": 5,
|
||
"margin/order": 5,
|
||
"margin/order/test": 5,
|
||
"margin/borrow": 15,
|
||
"margin/repay": 10,
|
||
"purchase": 15,
|
||
"redeem": 15,
|
||
"lend/purchase/update": 10,
|
||
"bullet-private": 10,
|
||
"position/update-user-leverage": 5,
|
||
"deposit-address/create": 20,
|
||
},
|
||
"delete": map[string]interface{} {
|
||
"sub/api-key": 45,
|
||
"withdrawals/{withdrawalId}": 30,
|
||
"hf/orders/{orderId}": 1,
|
||
"hf/orders/sync/{orderId}": 1,
|
||
"hf/orders/client-order/{clientOid}": 1,
|
||
"hf/orders/sync/client-order/{clientOid}": 1,
|
||
"hf/orders/cancel/{orderId}": 2,
|
||
"hf/orders": 2,
|
||
"hf/orders/cancelAll": 30,
|
||
"orders/{orderId}": 3,
|
||
"order/client-order/{clientOid}": 5,
|
||
"orders": 20,
|
||
"stop-order/{orderId}": 3,
|
||
"stop-order/cancelOrderByClientOid": 5,
|
||
"stop-order/cancel": 3,
|
||
"oco/order/{orderId}": 3,
|
||
"oco/client-order/{clientOid}": 3,
|
||
"oco/orders": 3,
|
||
"hf/margin/orders/{orderId}": 5,
|
||
"hf/margin/orders/client-order/{clientOid}": 5,
|
||
"hf/margin/orders": 10,
|
||
},
|
||
},
|
||
"futuresPublic": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"contracts/active": 4.5,
|
||
"contracts/{symbol}": 4.5,
|
||
"ticker": 3,
|
||
"level2/snapshot": 4.5,
|
||
"level2/depth20": 7.5,
|
||
"level2/depth100": 15,
|
||
"trade/history": 7.5,
|
||
"kline/query": 4.5,
|
||
"interest/query": 7.5,
|
||
"index/query": 3,
|
||
"mark-price/{symbol}/current": 4.5,
|
||
"premium/query": 4.5,
|
||
"trade-statistics": 4.5,
|
||
"funding-rate/{symbol}/current": 3,
|
||
"contract/funding-rates": 7.5,
|
||
"timestamp": 3,
|
||
"status": 6,
|
||
"level2/message/query": 1.3953,
|
||
},
|
||
"post": map[string]interface{} {
|
||
"bullet-public": 15,
|
||
},
|
||
},
|
||
"futuresPrivate": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"transaction-history": 3,
|
||
"account-overview": 7.5,
|
||
"account-overview-all": 9,
|
||
"transfer-list": 30,
|
||
"orders": 3,
|
||
"stopOrders": 9,
|
||
"recentDoneOrders": 7.5,
|
||
"orders/{orderId}": 7.5,
|
||
"orders/byClientOid": 7.5,
|
||
"fills": 7.5,
|
||
"recentFills": 4.5,
|
||
"openOrderStatistics": 15,
|
||
"position": 3,
|
||
"positions": 3,
|
||
"margin/maxWithdrawMargin": 15,
|
||
"contracts/risk-limit/{symbol}": 7.5,
|
||
"funding-history": 7.5,
|
||
},
|
||
"post": map[string]interface{} {
|
||
"transfer-out": 30,
|
||
"transfer-in": 30,
|
||
"orders": 3,
|
||
"orders/test": 3,
|
||
"orders/multi": 4.5,
|
||
"position/margin/auto-deposit-status": 6,
|
||
"margin/withdrawMargin": 15,
|
||
"position/margin/deposit-margin": 6,
|
||
"position/risk-limit-level/change": 6,
|
||
"bullet-private": 15,
|
||
},
|
||
"delete": map[string]interface{} {
|
||
"orders/{orderId}": 1.5,
|
||
"orders/client-order/{clientOid}": 1.5,
|
||
"orders": 45,
|
||
"stopOrders": 22.5,
|
||
},
|
||
},
|
||
"webExchange": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"currency/currency/chain-info": 1,
|
||
},
|
||
},
|
||
"broker": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"broker/nd/info": 2,
|
||
"broker/nd/account": 2,
|
||
"broker/nd/account/apikey": 2,
|
||
"broker/nd/rebase/download": 3,
|
||
"asset/ndbroker/deposit/list": 1,
|
||
"broker/nd/transfer/detail": 1,
|
||
"broker/nd/deposit/detail": 1,
|
||
"broker/nd/withdraw/detail": 1,
|
||
},
|
||
"post": map[string]interface{} {
|
||
"broker/nd/transfer": 1,
|
||
"broker/nd/account": 3,
|
||
"broker/nd/account/apikey": 3,
|
||
"broker/nd/account/update-apikey": 3,
|
||
},
|
||
"delete": map[string]interface{} {
|
||
"broker/nd/account/apikey": 3,
|
||
},
|
||
},
|
||
"earn": map[string]interface{} {
|
||
"get": map[string]interface{} {
|
||
"otc-loan/loan": 1,
|
||
"otc-loan/accounts": 1,
|
||
"earn/redeem-preview": 7.5,
|
||
"earn/saving/products": 7.5,
|
||
"earn/hold-assets": 7.5,
|
||
"earn/promotion/products": 7.5,
|
||
"earn/kcs-staking/products": 7.5,
|
||
"earn/staking/products": 7.5,
|
||
"earn/eth-staking/products": 7.5,
|
||
},
|
||
"post": map[string]interface{} {
|
||
"earn/orders": 7.5,
|
||
},
|
||
"delete": map[string]interface{} {
|
||
"earn/orders": 7.5,
|
||
},
|
||
},
|
||
},
|
||
"timeframes": map[string]interface{} {
|
||
"1m": "1min",
|
||
"3m": "3min",
|
||
"5m": "5min",
|
||
"15m": "15min",
|
||
"30m": "30min",
|
||
"1h": "1hour",
|
||
"2h": "2hour",
|
||
"4h": "4hour",
|
||
"6h": "6hour",
|
||
"8h": "8hour",
|
||
"12h": "12hour",
|
||
"1d": "1day",
|
||
"1w": "1week",
|
||
"1M": "1month",
|
||
},
|
||
"precisionMode": TICK_SIZE,
|
||
"exceptions": map[string]interface{} {
|
||
"exact": map[string]interface{} {
|
||
"The order does not exist.": OrderNotFound,
|
||
"order not exist": OrderNotFound,
|
||
"order not exist.": OrderNotFound,
|
||
"order_not_exist": OrderNotFound,
|
||
"order_not_exist_or_not_allow_to_cancel": InvalidOrder,
|
||
"Order size below the minimum requirement.": InvalidOrder,
|
||
"The withdrawal amount is below the minimum requirement.": ExchangeError,
|
||
"Unsuccessful! Exceeded the max. funds out-transfer limit": InsufficientFunds,
|
||
"The amount increment is invalid.": BadRequest,
|
||
"The quantity is below the minimum requirement.": InvalidOrder,
|
||
"400": BadRequest,
|
||
"401": AuthenticationError,
|
||
"403": NotSupported,
|
||
"404": NotSupported,
|
||
"405": NotSupported,
|
||
"415": NotSupported,
|
||
"429": RateLimitExceeded,
|
||
"500": ExchangeNotAvailable,
|
||
"503": ExchangeNotAvailable,
|
||
"101030": PermissionDenied,
|
||
"103000": InvalidOrder,
|
||
"130101": BadRequest,
|
||
"130102": ExchangeError,
|
||
"130103": OrderNotFound,
|
||
"130104": ExchangeError,
|
||
"130105": InsufficientFunds,
|
||
"130106": NotSupported,
|
||
"130107": ExchangeError,
|
||
"130108": OrderNotFound,
|
||
"130201": PermissionDenied,
|
||
"130202": ExchangeError,
|
||
"130203": InsufficientFunds,
|
||
"130204": BadRequest,
|
||
"130301": InsufficientFunds,
|
||
"130302": PermissionDenied,
|
||
"130303": NotSupported,
|
||
"130304": NotSupported,
|
||
"130305": NotSupported,
|
||
"130306": NotSupported,
|
||
"130307": NotSupported,
|
||
"130308": InvalidOrder,
|
||
"130309": InvalidOrder,
|
||
"130310": ExchangeError,
|
||
"130311": InvalidOrder,
|
||
"130312": InvalidOrder,
|
||
"130313": InvalidOrder,
|
||
"130314": InvalidOrder,
|
||
"130315": NotSupported,
|
||
"126000": ExchangeError,
|
||
"126001": NotSupported,
|
||
"126002": ExchangeError,
|
||
"126003": InvalidOrder,
|
||
"126004": ExchangeError,
|
||
"126005": PermissionDenied,
|
||
"126006": ExchangeError,
|
||
"126007": ExchangeError,
|
||
"126009": ExchangeError,
|
||
"126010": ExchangeError,
|
||
"126011": ExchangeError,
|
||
"126013": InsufficientFunds,
|
||
"126015": ExchangeError,
|
||
"126021": NotSupported,
|
||
"126022": InvalidOrder,
|
||
"126027": InvalidOrder,
|
||
"126028": InvalidOrder,
|
||
"126029": InvalidOrder,
|
||
"126030": InvalidOrder,
|
||
"126033": InvalidOrder,
|
||
"126034": InvalidOrder,
|
||
"126036": InvalidOrder,
|
||
"126037": ExchangeError,
|
||
"126038": ExchangeError,
|
||
"126039": ExchangeError,
|
||
"126041": ExchangeError,
|
||
"126042": ExchangeError,
|
||
"126043": OrderNotFound,
|
||
"126044": InvalidOrder,
|
||
"126045": NotSupported,
|
||
"126046": NotSupported,
|
||
"126047": PermissionDenied,
|
||
"126048": PermissionDenied,
|
||
"135005": ExchangeError,
|
||
"135018": ExchangeError,
|
||
"200004": InsufficientFunds,
|
||
"210014": InvalidOrder,
|
||
"210021": InsufficientFunds,
|
||
"230003": InsufficientFunds,
|
||
"260000": InvalidAddress,
|
||
"260100": InsufficientFunds,
|
||
"300000": InvalidOrder,
|
||
"400000": BadSymbol,
|
||
"400001": AuthenticationError,
|
||
"400002": InvalidNonce,
|
||
"400003": AuthenticationError,
|
||
"400004": AuthenticationError,
|
||
"400005": AuthenticationError,
|
||
"400006": AuthenticationError,
|
||
"400007": AuthenticationError,
|
||
"400008": NotSupported,
|
||
"400100": InsufficientFunds,
|
||
"400200": InvalidOrder,
|
||
"400330": InvalidOrder,
|
||
"400350": InvalidOrder,
|
||
"400370": InvalidOrder,
|
||
"400400": BadRequest,
|
||
"400401": AuthenticationError,
|
||
"400500": InvalidOrder,
|
||
"400600": BadSymbol,
|
||
"400760": InvalidOrder,
|
||
"401000": BadRequest,
|
||
"408000": BadRequest,
|
||
"411100": AccountSuspended,
|
||
"415000": BadRequest,
|
||
"400303": PermissionDenied,
|
||
"500000": ExchangeNotAvailable,
|
||
"260220": InvalidAddress,
|
||
"600100": InsufficientFunds,
|
||
"600101": InvalidOrder,
|
||
"900014": BadRequest,
|
||
},
|
||
"broad": map[string]interface{} {
|
||
"Exceeded the access frequency": RateLimitExceeded,
|
||
"require more permission": PermissionDenied,
|
||
},
|
||
},
|
||
"fees": map[string]interface{} {
|
||
"trading": map[string]interface{} {
|
||
"tierBased": true,
|
||
"percentage": true,
|
||
"taker": this.ParseNumber("0.001"),
|
||
"maker": this.ParseNumber("0.001"),
|
||
"tiers": map[string]interface{} {
|
||
"taker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("50"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("200"), this.ParseNumber("0.0009")}, []interface{}{this.ParseNumber("500"), this.ParseNumber("0.0008")}, []interface{}{this.ParseNumber("1000"), this.ParseNumber("0.0007")}, []interface{}{this.ParseNumber("2000"), this.ParseNumber("0.0007")}, []interface{}{this.ParseNumber("4000"), this.ParseNumber("0.0006")}, []interface{}{this.ParseNumber("8000"), this.ParseNumber("0.0005")}, []interface{}{this.ParseNumber("15000"), this.ParseNumber("0.00045")}, []interface{}{this.ParseNumber("25000"), this.ParseNumber("0.0004")}, []interface{}{this.ParseNumber("40000"), this.ParseNumber("0.00035")}, []interface{}{this.ParseNumber("60000"), this.ParseNumber("0.0003")}, []interface{}{this.ParseNumber("80000"), this.ParseNumber("0.00025")}},
|
||
"maker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("50"), this.ParseNumber("0.0009")}, []interface{}{this.ParseNumber("200"), this.ParseNumber("0.0007")}, []interface{}{this.ParseNumber("500"), this.ParseNumber("0.0005")}, []interface{}{this.ParseNumber("1000"), this.ParseNumber("0.0003")}, []interface{}{this.ParseNumber("2000"), this.ParseNumber("0")}, []interface{}{this.ParseNumber("4000"), this.ParseNumber("0")}, []interface{}{this.ParseNumber("8000"), this.ParseNumber("0")}, []interface{}{this.ParseNumber("15000"), this.ParseNumber("-0.00005")}, []interface{}{this.ParseNumber("25000"), this.ParseNumber("-0.00005")}, []interface{}{this.ParseNumber("40000"), this.ParseNumber("-0.00005")}, []interface{}{this.ParseNumber("60000"), this.ParseNumber("-0.00005")}, []interface{}{this.ParseNumber("80000"), this.ParseNumber("-0.00005")}},
|
||
},
|
||
},
|
||
"funding": map[string]interface{} {
|
||
"tierBased": false,
|
||
"percentage": false,
|
||
"withdraw": map[string]interface{} {},
|
||
"deposit": map[string]interface{} {},
|
||
},
|
||
},
|
||
"commonCurrencies": map[string]interface{} {
|
||
"BIFI": "BIFIF",
|
||
"VAI": "VAIOT",
|
||
"WAX": "WAXP",
|
||
"ALT": "APTOSLAUNCHTOKEN",
|
||
"KALT": "ALT",
|
||
"FUD": "FTX Users\\' Debt",
|
||
},
|
||
"options": map[string]interface{} {
|
||
"hf": nil,
|
||
"version": "v1",
|
||
"symbolSeparator": "-",
|
||
"fetchMyTradesMethod": "private_get_fills",
|
||
"timeDifference": 0,
|
||
"adjustForTimeDifference": false,
|
||
"fetchCurrencies": map[string]interface{} {
|
||
"webApiEnable": true,
|
||
"webApiRetries": 1,
|
||
"webApiMuteFailure": true,
|
||
},
|
||
"fetchMarkets": map[string]interface{} {
|
||
"fetchTickersFees": true,
|
||
},
|
||
"withdraw": map[string]interface{} {
|
||
"includeFee": false,
|
||
},
|
||
"versions": map[string]interface{} {
|
||
"public": map[string]interface{} {
|
||
"GET": map[string]interface{} {
|
||
"currencies": "v3",
|
||
"currencies/{currency}": "v3",
|
||
"symbols": "v2",
|
||
"mark-price/all-symbols": "v3",
|
||
"announcements": "v3",
|
||
},
|
||
},
|
||
"private": map[string]interface{} {
|
||
"GET": map[string]interface{} {
|
||
"user-info": "v2",
|
||
"hf/margin/account/ledgers": "v3",
|
||
"sub/user": "v2",
|
||
"sub-accounts": "v2",
|
||
"margin/accounts": "v3",
|
||
"isolated/accounts": "v3",
|
||
"deposit-addresses": "v1",
|
||
"market/orderbook/level2": "v3",
|
||
"market/orderbook/level3": "v3",
|
||
"market/orderbook/level{level}": "v3",
|
||
"oco/order/{orderId}": "v3",
|
||
"oco/order/details/{orderId}": "v3",
|
||
"oco/client-order/{clientOid}": "v3",
|
||
"oco/orders": "v3",
|
||
"hf/margin/orders/active": "v3",
|
||
"hf/margin/order/active/symbols": "v3",
|
||
"hf/margin/orders/done": "v3",
|
||
"hf/margin/orders/{orderId}": "v3",
|
||
"hf/margin/orders/client-order/{clientOid}": "v3",
|
||
"hf/margin/fills": "v3",
|
||
"etf/info": "v3",
|
||
"margin/currencies": "v3",
|
||
"margin/borrow": "v3",
|
||
"margin/repay": "v3",
|
||
"margin/interest": "v3",
|
||
"project/list": "v3",
|
||
"project/marketInterestRate": "v3",
|
||
"redeem/orders": "v3",
|
||
"purchase/orders": "v3",
|
||
"migrate/user/account/status": "v3",
|
||
"margin/symbols": "v3",
|
||
"affiliate/inviter/statistics": "v2",
|
||
"asset/ndbroker/deposit/list": "v1",
|
||
},
|
||
"POST": map[string]interface{} {
|
||
"sub/user/created": "v2",
|
||
"accounts/universal-transfer": "v3",
|
||
"accounts/sub-transfer": "v2",
|
||
"accounts/inner-transfer": "v2",
|
||
"transfer-out": "v3",
|
||
"deposit-address/create": "v3",
|
||
"oco/order": "v3",
|
||
"hf/margin/order": "v3",
|
||
"hf/margin/order/test": "v3",
|
||
"margin/borrow": "v3",
|
||
"margin/repay": "v3",
|
||
"purchase": "v3",
|
||
"redeem": "v3",
|
||
"lend/purchase/update": "v3",
|
||
"position/update-user-leverage": "v3",
|
||
"withdrawals": "v3",
|
||
},
|
||
"DELETE": map[string]interface{} {
|
||
"hf/margin/orders/{orderId}": "v3",
|
||
"hf/margin/orders/client-order/{clientOid}": "v3",
|
||
"hf/margin/orders": "v3",
|
||
"oco/order/{orderId}": "v3",
|
||
"oco/client-order/{clientOid}": "v3",
|
||
"oco/orders": "v3",
|
||
},
|
||
},
|
||
"futuresPrivate": map[string]interface{} {
|
||
"POST": map[string]interface{} {
|
||
"transfer-out": "v3",
|
||
},
|
||
},
|
||
},
|
||
"partner": map[string]interface{} {
|
||
"spot": map[string]interface{} {
|
||
"id": "ccxt",
|
||
"key": "9e58cc35-5b5e-4133-92ec-166e3f077cb8",
|
||
},
|
||
"future": map[string]interface{} {
|
||
"id": "ccxtfutures",
|
||
"key": "1b327198-f30c-4f14-a0ac-918871282f15",
|
||
},
|
||
},
|
||
"accountsByType": map[string]interface{} {
|
||
"spot": "trade",
|
||
"margin": "margin",
|
||
"cross": "margin",
|
||
"isolated": "isolated",
|
||
"main": "main",
|
||
"funding": "main",
|
||
"future": "contract",
|
||
"swap": "contract",
|
||
"mining": "pool",
|
||
"hf": "trade_hf",
|
||
},
|
||
"networks": map[string]interface{} {
|
||
"BRC20": "btc",
|
||
"BTCNATIVESEGWIT": "bech32",
|
||
"ERC20": "eth",
|
||
"TRC20": "trx",
|
||
"HRC20": "heco",
|
||
"MATIC": "matic",
|
||
"KCC": "kcc",
|
||
"SOL": "sol",
|
||
"ALGO": "algo",
|
||
"EOS": "eos",
|
||
"BEP20": "bsc",
|
||
"BEP2": "bnb",
|
||
"ARBONE": "arbitrum",
|
||
"AVAXX": "avax",
|
||
"AVAXC": "avaxc",
|
||
"TLOS": "tlos",
|
||
"CFX": "cfx",
|
||
"ACA": "aca",
|
||
"OP": "optimism",
|
||
"ONT": "ont",
|
||
"GLMR": "glmr",
|
||
"CSPR": "cspr",
|
||
"KLAY": "klay",
|
||
"XRD": "xrd",
|
||
"RVN": "rvn",
|
||
"NEAR": "near",
|
||
"APT": "aptos",
|
||
"ETHW": "ethw",
|
||
"TON": "ton",
|
||
"BCH": "bch",
|
||
"BSV": "bchsv",
|
||
"BCHA": "bchabc",
|
||
"OSMO": "osmo",
|
||
"NANO": "nano",
|
||
"XLM": "xlm",
|
||
"VET": "vet",
|
||
"IOST": "iost",
|
||
"ZIL": "zil",
|
||
"XRP": "xrp",
|
||
"TOMO": "tomo",
|
||
"XMR": "xmr",
|
||
"COTI": "coti",
|
||
"XTZ": "xtz",
|
||
"ADA": "ada",
|
||
"WAX": "waxp",
|
||
"THETA": "theta",
|
||
"ONE": "one",
|
||
"IOTEX": "iotx",
|
||
"NULS": "nuls",
|
||
"KSM": "ksm",
|
||
"LTC": "ltc",
|
||
"WAVES": "waves",
|
||
"DOT": "dot",
|
||
"STEEM": "steem",
|
||
"QTUM": "qtum",
|
||
"DOGE": "doge",
|
||
"FIL": "fil",
|
||
"XYM": "xym",
|
||
"FLUX": "flux",
|
||
"ATOM": "atom",
|
||
"XDC": "xdc",
|
||
"KDA": "kda",
|
||
"ICP": "icp",
|
||
"CELO": "celo",
|
||
"LSK": "lsk",
|
||
"VSYS": "vsys",
|
||
"KAR": "kar",
|
||
"XCH": "xch",
|
||
"FLOW": "flow",
|
||
"BAND": "band",
|
||
"EGLD": "egld",
|
||
"HBAR": "hbar",
|
||
"XPR": "xpr",
|
||
"AR": "ar",
|
||
"FTM": "ftm",
|
||
"KAVA": "kava",
|
||
"KMA": "kma",
|
||
"XEC": "xec",
|
||
"IOTA": "iota",
|
||
"HNT": "hnt",
|
||
"ASTR": "astr",
|
||
"PDEX": "pdex",
|
||
"METIS": "metis",
|
||
"ZEC": "zec",
|
||
"POKT": "pokt",
|
||
"OASYS": "oas",
|
||
"OASIS": "oasis",
|
||
"ETC": "etc",
|
||
"AKT": "akt",
|
||
"FSN": "fsn",
|
||
"SCRT": "scrt",
|
||
"CFG": "cfg",
|
||
"ICX": "icx",
|
||
"KMD": "kmd",
|
||
"NEM": "NEM",
|
||
"STX": "stx",
|
||
"DGB": "dgb",
|
||
"DCR": "dcr",
|
||
"CKB": "ckb",
|
||
"ELA": "ela",
|
||
"HYDRA": "hydra",
|
||
"BTM": "btm",
|
||
"KARDIA": "kai",
|
||
"SXP": "sxp",
|
||
"NEBL": "nebl",
|
||
"ZEN": "zen",
|
||
"SDN": "sdn",
|
||
"LTO": "lto",
|
||
"WEMIX": "wemix",
|
||
"EVER": "ever",
|
||
"BNC": "bnc",
|
||
"BNCDOT": "bncdot",
|
||
"AION": "aion",
|
||
"GRIN": "grin",
|
||
"LOKI": "loki",
|
||
"QKC": "qkc",
|
||
"TT": "TT",
|
||
"PIVX": "pivx",
|
||
"SERO": "sero",
|
||
"METER": "meter",
|
||
"STATEMINE": "statemine",
|
||
"DVPN": "dvpn",
|
||
"XPRT": "xprt",
|
||
"MOVR": "movr",
|
||
"ERGO": "ergo",
|
||
"ABBC": "abbc",
|
||
"DIVI": "divi",
|
||
"PURA": "pura",
|
||
"DFI": "dfi",
|
||
"NEON3": "neon3",
|
||
"DOCK": "dock",
|
||
"TRUE": "true",
|
||
"CS": "cs",
|
||
"ORAI": "orai",
|
||
"BASE": "base",
|
||
},
|
||
"marginModes": map[string]interface{} {
|
||
"cross": "MARGIN_TRADE",
|
||
"isolated": "MARGIN_ISOLATED_TRADE",
|
||
"spot": "TRADE",
|
||
},
|
||
},
|
||
"features": map[string]interface{} {
|
||
"spot": map[string]interface{} {
|
||
"sandbox": false,
|
||
"createOrder": map[string]interface{} {
|
||
"marginMode": true,
|
||
"triggerPrice": true,
|
||
"triggerPriceType": nil,
|
||
"triggerDirection": false,
|
||
"stopLossPrice": true,
|
||
"takeProfitPrice": true,
|
||
"attachedStopLossTakeProfit": nil,
|
||
"timeInForce": map[string]interface{} {
|
||
"IOC": true,
|
||
"FOK": true,
|
||
"PO": true,
|
||
"GTD": true,
|
||
},
|
||
"hedged": false,
|
||
"trailing": false,
|
||
"leverage": false,
|
||
"marketBuyByCost": true,
|
||
"marketBuyRequiresPrice": false,
|
||
"selfTradePrevention": true,
|
||
"iceberg": true,
|
||
},
|
||
"createOrders": map[string]interface{} {
|
||
"max": 5,
|
||
},
|
||
"fetchMyTrades": map[string]interface{} {
|
||
"marginMode": true,
|
||
"limit": nil,
|
||
"daysBack": nil,
|
||
"untilDays": 7,
|
||
"symbolRequired": true,
|
||
},
|
||
"fetchOrder": map[string]interface{} {
|
||
"marginMode": false,
|
||
"trigger": true,
|
||
"trailing": false,
|
||
"symbolRequired": true,
|
||
},
|
||
"fetchOpenOrders": map[string]interface{} {
|
||
"marginMode": true,
|
||
"limit": 500,
|
||
"trigger": true,
|
||
"trailing": false,
|
||
"symbolRequired": true,
|
||
},
|
||
"fetchOrders": nil,
|
||
"fetchClosedOrders": map[string]interface{} {
|
||
"marginMode": true,
|
||
"limit": 500,
|
||
"daysBack": nil,
|
||
"daysBackCanceled": nil,
|
||
"untilDays": 7,
|
||
"trigger": true,
|
||
"trailing": false,
|
||
"symbolRequired": true,
|
||
},
|
||
"fetchOHLCV": map[string]interface{} {
|
||
"limit": 1500,
|
||
},
|
||
},
|
||
"swap": map[string]interface{} {
|
||
"linear": nil,
|
||
"inverse": nil,
|
||
},
|
||
"future": map[string]interface{} {
|
||
"linear": nil,
|
||
"inverse": nil,
|
||
},
|
||
},
|
||
})
|
||
}
|
||
func (this *kucoin) Nonce() interface{} {
|
||
return Subtract(this.Milliseconds(), GetValue(this.Options, "timeDifference"))
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchTime
|
||
* @description fetches the current integer timestamp in milliseconds from the exchange server
|
||
* @see https://docs.kucoin.com/#server-time
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {int} the current integer timestamp in milliseconds from the exchange server
|
||
*/
|
||
func (this *kucoin) FetchTime(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
response:= (<-this.PublicGetTimestamp(params))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// {
|
||
// "code":"200000",
|
||
// "msg":"success",
|
||
// "data":1546837113087
|
||
// }
|
||
//
|
||
ch <- this.SafeInteger(response, "data")
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchStatus
|
||
* @description the latest known information on the availability of the exchange API
|
||
* @see https://docs.kucoin.com/#service-status
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [status structure]{@link https://docs.ccxt.com/#/?id=exchange-status-structure}
|
||
*/
|
||
func (this *kucoin) FetchStatus(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
response:= (<-this.PublicGetStatus(params))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code":"200000",
|
||
// "data":{
|
||
// "status":"open", //open, close, cancelonly
|
||
// "msg":"upgrade match engine" //remark for operation
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var status interface{} = this.SafeString(data, "status")
|
||
|
||
ch <- map[string]interface{} {
|
||
"status": Ternary(IsTrue((IsEqual(status, "open"))), "ok", "maintenance"),
|
||
"updated": nil,
|
||
"eta": nil,
|
||
"url": nil,
|
||
"info": response,
|
||
}
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchMarkets
|
||
* @description retrieves data on all markets for kucoin
|
||
* @see https://docs.kucoin.com/#get-symbols-list-deprecated
|
||
* @see https://docs.kucoin.com/#get-all-tickers
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object[]} an array of objects representing market data
|
||
*/
|
||
func (this *kucoin) FetchMarkets(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
var fetchTickersFees interface{} = nil
|
||
fetchTickersFeesparamsVariable := this.HandleOptionAndParams(params, "fetchMarkets", "fetchTickersFees", true);
|
||
fetchTickersFees = GetValue(fetchTickersFeesparamsVariable,0);
|
||
params = GetValue(fetchTickersFeesparamsVariable,1)
|
||
var promises interface{} = []interface{}{}
|
||
AppendToArray(&promises,this.PublicGetSymbols(params))
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": [
|
||
// {
|
||
// "symbol": "XLM-USDT",
|
||
// "name": "XLM-USDT",
|
||
// "baseCurrency": "XLM",
|
||
// "quoteCurrency": "USDT",
|
||
// "feeCurrency": "USDT",
|
||
// "market": "USDS",
|
||
// "baseMinSize": "0.1",
|
||
// "quoteMinSize": "0.01",
|
||
// "baseMaxSize": "10000000000",
|
||
// "quoteMaxSize": "99999999",
|
||
// "baseIncrement": "0.0001",
|
||
// "quoteIncrement": "0.000001",
|
||
// "priceIncrement": "0.000001",
|
||
// "priceLimitRate": "0.1",
|
||
// "isMarginEnabled": true,
|
||
// "enableTrading": true
|
||
// },
|
||
//
|
||
var credentialsSet interface{} = this.CheckRequiredCredentials(false)
|
||
var requestMarginables interface{} = IsTrue(credentialsSet) && IsTrue(this.SafeBool(params, "marginables", true))
|
||
if IsTrue(requestMarginables) {
|
||
AppendToArray(&promises,this.PrivateGetMarginSymbols(params)) // cross margin symbols
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "timestamp": 1719393213421,
|
||
// "items": [
|
||
// {
|
||
// // same object as in market, with one additional field:
|
||
// "minFunds": "0.1"
|
||
// },
|
||
//
|
||
AppendToArray(&promises,this.PrivateGetIsolatedSymbols(params)) // isolated margin symbols
|
||
}
|
||
if IsTrue(fetchTickersFees) {
|
||
AppendToArray(&promises,this.PublicGetMarketAllTickers(params))
|
||
}
|
||
if IsTrue(credentialsSet) {
|
||
// load migration status for account
|
||
AppendToArray(&promises,this.LoadMigrationStatus())
|
||
}
|
||
|
||
responses:= (<-promiseAll(promises))
|
||
PanicOnError(responses)
|
||
var symbolsData interface{} = this.SafeList(GetValue(responses, 0), "data")
|
||
var crossData interface{} = Ternary(IsTrue(requestMarginables), this.SafeDict(GetValue(responses, 1), "data", map[string]interface{} {}), map[string]interface{} {})
|
||
var crossItems interface{} = this.SafeList(crossData, "items", []interface{}{})
|
||
var crossById interface{} = this.IndexBy(crossItems, "symbol")
|
||
var isolatedData interface{} = Ternary(IsTrue(requestMarginables), GetValue(responses, 2), map[string]interface{} {})
|
||
var isolatedItems interface{} = this.SafeList(isolatedData, "data", []interface{}{})
|
||
var isolatedById interface{} = this.IndexBy(isolatedItems, "symbol")
|
||
var tickersIdx interface{} = Ternary(IsTrue(requestMarginables), 3, 1)
|
||
var tickersResponse interface{} = this.SafeDict(responses, tickersIdx, map[string]interface{} {})
|
||
var tickerItems interface{} = this.SafeList(this.SafeDict(tickersResponse, "data", map[string]interface{} {}), "ticker", []interface{}{})
|
||
var tickersById interface{} = this.IndexBy(tickerItems, "symbol")
|
||
var result interface{} = []interface{}{}
|
||
for i := 0; IsLessThan(i, GetArrayLength(symbolsData)); i++ {
|
||
var market interface{} = GetValue(symbolsData, i)
|
||
var id interface{} = this.SafeString(market, "symbol")
|
||
baseIdquoteIdVariable := Split(id, "-");
|
||
baseId := GetValue(baseIdquoteIdVariable,0);
|
||
quoteId := GetValue(baseIdquoteIdVariable,1)
|
||
var base interface{} = this.SafeCurrencyCode(baseId)
|
||
var quote interface{} = this.SafeCurrencyCode(quoteId)
|
||
// const quoteIncrement = this.safeNumber (market, 'quoteIncrement');
|
||
var ticker interface{} = this.SafeDict(tickersById, id, map[string]interface{} {})
|
||
var makerFeeRate interface{} = this.SafeString(ticker, "makerFeeRate")
|
||
var takerFeeRate interface{} = this.SafeString(ticker, "takerFeeRate")
|
||
var makerCoefficient interface{} = this.SafeString(ticker, "makerCoefficient")
|
||
var takerCoefficient interface{} = this.SafeString(ticker, "takerCoefficient")
|
||
var hasCrossMargin interface{} = (InOp(crossById, id))
|
||
var hasIsolatedMargin interface{} = (InOp(isolatedById, id))
|
||
var isMarginable interface{} = IsTrue(IsTrue(this.SafeBool(market, "isMarginEnabled", false)) || IsTrue(hasCrossMargin)) || IsTrue(hasIsolatedMargin)
|
||
AppendToArray(&result,map[string]interface{} {
|
||
"id": id,
|
||
"symbol": Add(Add(base, "/"), quote),
|
||
"base": base,
|
||
"quote": quote,
|
||
"settle": nil,
|
||
"baseId": baseId,
|
||
"quoteId": quoteId,
|
||
"settleId": nil,
|
||
"type": "spot",
|
||
"spot": true,
|
||
"margin": isMarginable,
|
||
"marginModes": map[string]interface{} {
|
||
"cross": hasCrossMargin,
|
||
"isolated": hasIsolatedMargin,
|
||
},
|
||
"swap": false,
|
||
"future": false,
|
||
"option": false,
|
||
"active": this.SafeBool(market, "enableTrading"),
|
||
"contract": false,
|
||
"linear": nil,
|
||
"inverse": nil,
|
||
"taker": this.ParseNumber(Precise.StringMul(takerFeeRate, takerCoefficient)),
|
||
"maker": this.ParseNumber(Precise.StringMul(makerFeeRate, makerCoefficient)),
|
||
"contractSize": nil,
|
||
"expiry": nil,
|
||
"expiryDatetime": nil,
|
||
"strike": nil,
|
||
"optionType": nil,
|
||
"precision": map[string]interface{} {
|
||
"amount": this.SafeNumber(market, "baseIncrement"),
|
||
"price": this.SafeNumber(market, "priceIncrement"),
|
||
},
|
||
"limits": map[string]interface{} {
|
||
"leverage": map[string]interface{} {
|
||
"min": nil,
|
||
"max": nil,
|
||
},
|
||
"amount": map[string]interface{} {
|
||
"min": this.SafeNumber(market, "baseMinSize"),
|
||
"max": this.SafeNumber(market, "baseMaxSize"),
|
||
},
|
||
"price": map[string]interface{} {
|
||
"min": nil,
|
||
"max": nil,
|
||
},
|
||
"cost": map[string]interface{} {
|
||
"min": this.SafeNumber(market, "quoteMinSize"),
|
||
"max": this.SafeNumber(market, "quoteMaxSize"),
|
||
},
|
||
},
|
||
"created": nil,
|
||
"info": market,
|
||
})
|
||
}
|
||
if IsTrue(GetValue(this.Options, "adjustForTimeDifference")) {
|
||
|
||
retRes131212 := (<-this.LoadTimeDifference())
|
||
PanicOnError(retRes131212)
|
||
}
|
||
|
||
ch <- result
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#loadMigrationStatus
|
||
* @param {boolean} force load account state for non hf
|
||
* @description loads the migration status for the account (hf or not)
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/get-user-type
|
||
* @returns {any} ignore
|
||
*/
|
||
func (this *kucoin) LoadMigrationStatus(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
force := GetArg(optionalArgs, 0, false)
|
||
_ = force
|
||
if IsTrue(IsTrue(!IsTrue((InOp(this.Options, "hf"))) || IsTrue((IsEqual(GetValue(this.Options, "hf"), nil)))) || IsTrue(force)) {
|
||
|
||
result:= (<-this.PrivateGetHfAccountsOpened())
|
||
PanicOnError(result)
|
||
AddElementToObject(this.Options, "hf", this.SafeBool(result, "data"))
|
||
}
|
||
|
||
ch <- true
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) HandleHfAndParams(optionalArgs ...interface{}) interface{} {
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
var migrated interface{} = this.SafeBool(this.Options, "hf", false)
|
||
var loadedHf interface{} = nil
|
||
if IsTrue(!IsEqual(migrated, nil)) {
|
||
if IsTrue(migrated) {
|
||
loadedHf = true
|
||
} else {
|
||
loadedHf = false
|
||
}
|
||
}
|
||
var hf interface{} = this.SafeBool(params, "hf", loadedHf)
|
||
params = this.Omit(params, "hf")
|
||
return []interface{}{hf, params}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchCurrencies
|
||
* @description fetches all available currencies on an exchange
|
||
* @see https://docs.kucoin.com/#get-currencies
|
||
* @param {object} params extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an associative dictionary of currencies
|
||
*/
|
||
func (this *kucoin) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
response:= (<-this.PublicGetCurrencies(params))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code":"200000",
|
||
// "data":[
|
||
// {
|
||
// "currency":"CSP",
|
||
// "name":"CSP",
|
||
// "fullName":"Caspian",
|
||
// "precision":8,
|
||
// "confirms":null,
|
||
// "contractAddress":null,
|
||
// "isMarginEnabled":false,
|
||
// "isDebitEnabled":false,
|
||
// "chains":[
|
||
// {
|
||
// "chainName":"ERC20",
|
||
// "chainId": "eth"
|
||
// "withdrawalMinSize":"2999",
|
||
// "depositMinSize":null,
|
||
// "withdrawFeeRate":"0",
|
||
// "withdrawalMinFee":"2999",
|
||
// "isWithdrawEnabled":false,
|
||
// "isDepositEnabled":false,
|
||
// "confirms":12,
|
||
// "preConfirms":12,
|
||
// "withdrawPrecision": 8,
|
||
// "maxWithdraw": null,
|
||
// "maxDeposit": null,
|
||
// "needTag": false,
|
||
// "contractAddress":"0xa6446d655a0c34bc4f05042ee88170d056cbaf45",
|
||
// "depositFeeRate": "0.001", // present for some currencies/networks
|
||
// }
|
||
// ]
|
||
// },
|
||
// ]
|
||
// }
|
||
//
|
||
var currenciesData interface{} = this.SafeList(response, "data", []interface{}{})
|
||
var result interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(currenciesData)); i++ {
|
||
var entry interface{} = GetValue(currenciesData, i)
|
||
var id interface{} = this.SafeString(entry, "currency")
|
||
var name interface{} = this.SafeString(entry, "fullName")
|
||
var code interface{} = this.SafeCurrencyCode(id)
|
||
var networks interface{} = map[string]interface{} {}
|
||
var chains interface{} = this.SafeList(entry, "chains", []interface{}{})
|
||
var rawPrecision interface{} = this.SafeString(entry, "precision")
|
||
var precision interface{} = this.ParseNumber(this.ParsePrecision(rawPrecision))
|
||
var chainsLength interface{} = GetArrayLength(chains)
|
||
if !IsTrue(chainsLength) {
|
||
continue
|
||
}
|
||
for j := 0; IsLessThan(j, chainsLength); j++ {
|
||
var chain interface{} = GetValue(chains, j)
|
||
var chainId interface{} = this.SafeString(chain, "chainId")
|
||
var networkCode interface{} = this.NetworkIdToCode(chainId, code)
|
||
var chainWithdrawEnabled interface{} = this.SafeBool(chain, "isWithdrawEnabled", false)
|
||
var chainDepositEnabled interface{} = this.SafeBool(chain, "isDepositEnabled", false)
|
||
AddElementToObject(networks, networkCode, map[string]interface{} {
|
||
"info": chain,
|
||
"id": chainId,
|
||
"name": this.SafeString(chain, "chainName"),
|
||
"code": networkCode,
|
||
"active": IsTrue(chainWithdrawEnabled) && IsTrue(chainDepositEnabled),
|
||
"fee": this.SafeNumber(chain, "withdrawalMinFee"),
|
||
"deposit": chainDepositEnabled,
|
||
"withdraw": chainWithdrawEnabled,
|
||
"precision": this.ParseNumber(this.ParsePrecision(this.SafeString(chain, "withdrawPrecision"))),
|
||
"limits": map[string]interface{} {
|
||
"withdraw": map[string]interface{} {
|
||
"min": this.SafeNumber(chain, "withdrawalMinSize"),
|
||
"max": this.SafeNumber(chain, "maxWithdraw"),
|
||
},
|
||
"deposit": map[string]interface{} {
|
||
"min": this.SafeNumber(chain, "depositMinSize"),
|
||
"max": this.SafeNumber(chain, "maxDeposit"),
|
||
},
|
||
},
|
||
})
|
||
}
|
||
// kucoin has determined 'fiat' currencies with below logic
|
||
var isFiat interface{} = IsTrue((IsEqual(rawPrecision, "2"))) && IsTrue((IsEqual(chainsLength, 0)))
|
||
AddElementToObject(result, code, this.SafeCurrencyStructure(map[string]interface{} {
|
||
"id": id,
|
||
"name": name,
|
||
"code": code,
|
||
"type": Ternary(IsTrue(isFiat), "fiat", "crypto"),
|
||
"precision": precision,
|
||
"info": entry,
|
||
"networks": networks,
|
||
"deposit": nil,
|
||
"withdraw": nil,
|
||
"active": nil,
|
||
"fee": nil,
|
||
"limits": nil,
|
||
}))
|
||
}
|
||
|
||
ch <- result
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchAccounts
|
||
* @description fetch all the accounts associated with a profile
|
||
* @see https://docs.kucoin.com/#list-accounts
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a dictionary of [account structures]{@link https://docs.ccxt.com/#/?id=account-structure} indexed by the account type
|
||
*/
|
||
func (this *kucoin) FetchAccounts(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
response:= (<-this.PrivateGetAccounts(params))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": [
|
||
// {
|
||
// "balance": "0.00009788",
|
||
// "available": "0.00009788",
|
||
// "holds": "0",
|
||
// "currency": "BTC",
|
||
// "id": "5c6a4fd399a1d81c4f9cc4d0",
|
||
// "type": "trade"
|
||
// },
|
||
// {
|
||
// "balance": "0.00000001",
|
||
// "available": "0.00000001",
|
||
// "holds": "0",
|
||
// "currency": "ETH",
|
||
// "id": "5c6a49ec99a1d819392e8e9f",
|
||
// "type": "trade"
|
||
// }
|
||
// ]
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
||
var result interface{} = []interface{}{}
|
||
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
|
||
var account interface{} = GetValue(data, i)
|
||
var accountId interface{} = this.SafeString(account, "id")
|
||
var currencyId interface{} = this.SafeString(account, "currency")
|
||
var code interface{} = this.SafeCurrencyCode(currencyId)
|
||
var typeVar interface{} = this.SafeString(account, "type") // main or trade
|
||
AppendToArray(&result,map[string]interface{} {
|
||
"id": accountId,
|
||
"type": typeVar,
|
||
"currency": code,
|
||
"code": code,
|
||
"info": account,
|
||
})
|
||
}
|
||
|
||
ch <- result
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchTransactionFee
|
||
* @description *DEPRECATED* please use fetchDepositWithdrawFee instead
|
||
* @see https://docs.kucoin.com/#get-withdrawal-quotas
|
||
* @param {string} code unified currency code
|
||
* @param {object} params extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
|
||
*/
|
||
func (this *kucoin) FetchTransactionFee(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes15218 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes15218)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
}
|
||
var networkCode interface{} = nil
|
||
networkCodeparamsVariable := this.HandleNetworkCodeAndParams(params);
|
||
networkCode = GetValue(networkCodeparamsVariable,0);
|
||
params = GetValue(networkCodeparamsVariable,1)
|
||
if IsTrue(!IsEqual(networkCode, nil)) {
|
||
AddElementToObject(request, "chain", ToLower(this.NetworkCodeToId(networkCode)))
|
||
}
|
||
|
||
response:= (<-this.PrivateGetWithdrawalsQuotas(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var withdrawFees interface{} = map[string]interface{} {}
|
||
AddElementToObject(withdrawFees, code, this.SafeNumber(data, "withdrawMinFee"))
|
||
|
||
ch <- map[string]interface{} {
|
||
"info": response,
|
||
"withdraw": withdrawFees,
|
||
"deposit": map[string]interface{} {},
|
||
}
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchDepositWithdrawFee
|
||
* @description fetch the fee for deposits and withdrawals
|
||
* @see https://docs.kucoin.com/#get-withdrawal-quotas
|
||
* @param {string} code unified currency code
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.network] The chain of currency. This only apply for multi-chain currency, and there is no need for single chain currency; you can query the chain through the response of the GET /api/v2/currencies/{currency} interface
|
||
* @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
|
||
*/
|
||
func (this *kucoin) FetchDepositWithdrawFee(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes15538 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes15538)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
}
|
||
var networkCode interface{} = nil
|
||
networkCodeparamsVariable := this.HandleNetworkCodeAndParams(params);
|
||
networkCode = GetValue(networkCodeparamsVariable,0);
|
||
params = GetValue(networkCodeparamsVariable,1)
|
||
if IsTrue(!IsEqual(networkCode, nil)) {
|
||
AddElementToObject(request, "chain", ToLower(this.NetworkCodeToId(networkCode)))
|
||
}
|
||
|
||
response:= (<-this.PrivateGetWithdrawalsQuotas(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "currency": "USDT",
|
||
// "limitBTCAmount": "1.00000000",
|
||
// "usedBTCAmount": "0.00000000",
|
||
// "remainAmount": "16548.072149",
|
||
// "availableAmount": "0",
|
||
// "withdrawMinFee": "25",
|
||
// "innerWithdrawMinFee": "0",
|
||
// "withdrawMinSize": "50",
|
||
// "isWithdrawEnabled": true,
|
||
// "precision": 6,
|
||
// "chain": "ERC20"
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
|
||
ch <- this.ParseDepositWithdrawFee(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseDepositWithdrawFee(fee interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "currency": "USDT",
|
||
// "limitBTCAmount": "1.00000000",
|
||
// "usedBTCAmount": "0.00000000",
|
||
// "remainAmount": "16548.072149",
|
||
// "availableAmount": "0",
|
||
// "withdrawMinFee": "25",
|
||
// "innerWithdrawMinFee": "0",
|
||
// "withdrawMinSize": "50",
|
||
// "isWithdrawEnabled": true,
|
||
// "precision": 6,
|
||
// "chain": "ERC20"
|
||
// }
|
||
//
|
||
// if data obtained through `currencies` endpoint
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
if IsTrue(InOp(fee, "chains")) {
|
||
var resultNew interface{} = map[string]interface{} {
|
||
"info": fee,
|
||
"withdraw": map[string]interface{} {
|
||
"fee": nil,
|
||
"percentage": false,
|
||
},
|
||
"deposit": map[string]interface{} {
|
||
"fee": nil,
|
||
"percentage": nil,
|
||
},
|
||
"networks": map[string]interface{} {},
|
||
}
|
||
var chains interface{} = this.SafeList(fee, "chains", []interface{}{})
|
||
for i := 0; IsLessThan(i, GetArrayLength(chains)); i++ {
|
||
var chain interface{} = GetValue(chains, i)
|
||
var networkCodeNew interface{} = this.NetworkIdToCode(this.SafeString(chain, "chainId"), this.SafeString(currency, "code"))
|
||
AddElementToObject(GetValue(resultNew, "networks"), networkCodeNew, map[string]interface{} {
|
||
"withdraw": map[string]interface{} {
|
||
"fee": this.SafeNumber(chain, "withdrawMinFee"),
|
||
"percentage": false,
|
||
},
|
||
"deposit": map[string]interface{} {
|
||
"fee": nil,
|
||
"percentage": nil,
|
||
},
|
||
})
|
||
}
|
||
return resultNew
|
||
}
|
||
var minWithdrawFee interface{} = this.SafeNumber(fee, "withdrawMinFee")
|
||
var result interface{} = map[string]interface{} {
|
||
"info": fee,
|
||
"withdraw": map[string]interface{} {
|
||
"fee": minWithdrawFee,
|
||
"percentage": false,
|
||
},
|
||
"deposit": map[string]interface{} {
|
||
"fee": nil,
|
||
"percentage": nil,
|
||
},
|
||
"networks": map[string]interface{} {},
|
||
}
|
||
var networkId interface{} = this.SafeString(fee, "chain")
|
||
var networkCode interface{} = this.NetworkIdToCode(networkId, this.SafeString(currency, "code"))
|
||
AddElementToObject(GetValue(result, "networks"), networkCode, map[string]interface{} {
|
||
"withdraw": minWithdrawFee,
|
||
"deposit": map[string]interface{} {
|
||
"fee": nil,
|
||
"percentage": nil,
|
||
},
|
||
})
|
||
return result
|
||
}
|
||
func (this *kucoin) IsFuturesMethod(methodName interface{}, params interface{}) interface{} {
|
||
//
|
||
// Helper
|
||
// @methodName (string): The name of the method
|
||
// @params (dict): The parameters passed into {methodName}
|
||
// @return: true if the method used is meant for futures trading, false otherwise
|
||
//
|
||
var defaultType interface{} = this.SafeString2(this.Options, methodName, "defaultType", "trade")
|
||
var requestedType interface{} = this.SafeString(params, "type", defaultType)
|
||
var accountsByType interface{} = this.SafeDict(this.Options, "accountsByType")
|
||
var typeVar interface{} = this.SafeString(accountsByType, requestedType)
|
||
if IsTrue(IsEqual(typeVar, nil)) {
|
||
var keys interface{} = ObjectKeys(accountsByType)
|
||
panic(ExchangeError(Add(Add(this.Id, " isFuturesMethod() type must be one of "), Join(keys, ", "))))
|
||
}
|
||
params = this.Omit(params, "type")
|
||
return IsTrue(IsTrue((IsEqual(typeVar, "contract"))) || IsTrue((IsEqual(typeVar, "future")))) || IsTrue((IsEqual(typeVar, "futures"))) // * (type === 'futures') deprecated, use (type === 'future')
|
||
}
|
||
func (this *kucoin) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "symbol": "BTC-USDT", // symbol
|
||
// "symbolName":"BTC-USDT", // Name of trading pairs, it would change after renaming
|
||
// "buy": "11328.9", // bestAsk
|
||
// "sell": "11329", // bestBid
|
||
// "changeRate": "-0.0055", // 24h change rate
|
||
// "changePrice": "-63.6", // 24h change price
|
||
// "high": "11610", // 24h highest price
|
||
// "low": "11200", // 24h lowest price
|
||
// "vol": "2282.70993217", // 24h volume，the aggregated trading volume in BTC
|
||
// "volValue": "25984946.157790431", // 24h total, the trading volume in quote currency of last 24 hours
|
||
// "last": "11328.9", // last price
|
||
// "averagePrice": "11360.66065903", // 24h average transaction price yesterday
|
||
// "takerFeeRate": "0.001", // Basic Taker Fee
|
||
// "makerFeeRate": "0.001", // Basic Maker Fee
|
||
// "takerCoefficient": "1", // Taker Fee Coefficient
|
||
// "makerCoefficient": "1" // Maker Fee Coefficient
|
||
// }
|
||
//
|
||
// {
|
||
// "trading": true,
|
||
// "symbol": "KCS-BTC",
|
||
// "buy": 0.00011,
|
||
// "sell": 0.00012,
|
||
// "sort": 100,
|
||
// "volValue": 3.13851792584, //total
|
||
// "baseCurrency": "KCS",
|
||
// "market": "BTC",
|
||
// "quoteCurrency": "BTC",
|
||
// "symbolCode": "KCS-BTC",
|
||
// "datetime": 1548388122031,
|
||
// "high": 0.00013,
|
||
// "vol": 27514.34842,
|
||
// "low": 0.0001,
|
||
// "changePrice": -1.0e-5,
|
||
// "changeRate": -0.0769,
|
||
// "lastTradedPrice": 0.00012,
|
||
// "board": 0,
|
||
// "mark": 0
|
||
// }
|
||
//
|
||
// market/ticker ws subscription
|
||
//
|
||
// {
|
||
// "bestAsk": "62258.9",
|
||
// "bestAskSize": "0.38579986",
|
||
// "bestBid": "62258.8",
|
||
// "bestBidSize": "0.0078381",
|
||
// "price": "62260.7",
|
||
// "sequence": "1621383297064",
|
||
// "size": "0.00002841",
|
||
// "time": 1634641777363
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var percentage interface{} = this.SafeString(ticker, "changeRate")
|
||
if IsTrue(!IsEqual(percentage, nil)) {
|
||
percentage = Precise.StringMul(percentage, "100")
|
||
}
|
||
var last interface{} = this.SafeString2(ticker, "last", "lastTradedPrice")
|
||
last = this.SafeString(ticker, "price", last)
|
||
var marketId interface{} = this.SafeString(ticker, "symbol")
|
||
market = this.SafeMarket(marketId, market, "-")
|
||
var symbol interface{} = GetValue(market, "symbol")
|
||
var baseVolume interface{} = this.SafeString(ticker, "vol")
|
||
var quoteVolume interface{} = this.SafeString(ticker, "volValue")
|
||
var timestamp interface{} = this.SafeIntegerN(ticker, []interface{}{"time", "datetime", "timePoint"})
|
||
return this.SafeTicker(map[string]interface{} {
|
||
"symbol": symbol,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"high": this.SafeString(ticker, "high"),
|
||
"low": this.SafeString(ticker, "low"),
|
||
"bid": this.SafeString2(ticker, "buy", "bestBid"),
|
||
"bidVolume": this.SafeString(ticker, "bestBidSize"),
|
||
"ask": this.SafeString2(ticker, "sell", "bestAsk"),
|
||
"askVolume": this.SafeString(ticker, "bestAskSize"),
|
||
"vwap": nil,
|
||
"open": this.SafeString(ticker, "open"),
|
||
"close": last,
|
||
"last": last,
|
||
"previousClose": nil,
|
||
"change": this.SafeString(ticker, "changePrice"),
|
||
"percentage": percentage,
|
||
"average": this.SafeString(ticker, "averagePrice"),
|
||
"baseVolume": baseVolume,
|
||
"quoteVolume": quoteVolume,
|
||
"markPrice": this.SafeString(ticker, "value"),
|
||
"info": ticker,
|
||
}, market)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchTickers
|
||
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
|
||
* @see https://docs.kucoin.com/#get-all-tickers
|
||
* @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
||
*/
|
||
func (this *kucoin) FetchTickers(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbols := GetArg(optionalArgs, 0, nil)
|
||
_ = symbols
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes17808 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes17808)
|
||
symbols = this.MarketSymbols(symbols)
|
||
|
||
response:= (<-this.PublicGetMarketAllTickers(params))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "time":1602832092060,
|
||
// "ticker":[
|
||
// {
|
||
// "symbol": "BTC-USDT", // symbol
|
||
// "symbolName":"BTC-USDT", // Name of trading pairs, it would change after renaming
|
||
// "buy": "11328.9", // bestAsk
|
||
// "sell": "11329", // bestBid
|
||
// "changeRate": "-0.0055", // 24h change rate
|
||
// "changePrice": "-63.6", // 24h change price
|
||
// "high": "11610", // 24h highest price
|
||
// "low": "11200", // 24h lowest price
|
||
// "vol": "2282.70993217", // 24h volume，the aggregated trading volume in BTC
|
||
// "volValue": "25984946.157790431", // 24h total, the trading volume in quote currency of last 24 hours
|
||
// "last": "11328.9", // last price
|
||
// "averagePrice": "11360.66065903", // 24h average transaction price yesterday
|
||
// "takerFeeRate": "0.001", // Basic Taker Fee
|
||
// "makerFeeRate": "0.001", // Basic Maker Fee
|
||
// "takerCoefficient": "1", // Taker Fee Coefficient
|
||
// "makerCoefficient": "1" // Maker Fee Coefficient
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var tickers interface{} = this.SafeList(data, "ticker", []interface{}{})
|
||
var time interface{} = this.SafeInteger(data, "time")
|
||
var result interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(tickers)); i++ {
|
||
AddElementToObject(GetValue(tickers, i), "time", time)
|
||
var ticker interface{} = this.ParseTicker(GetValue(tickers, i))
|
||
var symbol interface{} = this.SafeString(ticker, "symbol")
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
AddElementToObject(result, symbol, ticker)
|
||
}
|
||
}
|
||
|
||
ch <- this.FilterByArrayTickers(result, "symbol", symbols)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchMarkPrices
|
||
* @description fetches the mark price for multiple markets
|
||
* @see https://www.kucoin.com/docs/rest/margin-trading/margin-info/get-all-margin-trading-pairs-mark-prices
|
||
* @param {string[]} [symbols] unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
||
*/
|
||
func (this *kucoin) FetchMarkPrices(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbols := GetArg(optionalArgs, 0, nil)
|
||
_ = symbols
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes18368 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes18368)
|
||
symbols = this.MarketSymbols(symbols)
|
||
|
||
response:= (<-this.PublicGetMarkPriceAllSymbols(params))
|
||
PanicOnError(response)
|
||
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
||
|
||
ch <- this.ParseTickers(data)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchTicker
|
||
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
|
||
* @see https://docs.kucoin.com/#get-24hr-stats
|
||
* @param {string} symbol unified symbol of the market to fetch the ticker for
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
||
*/
|
||
func (this *kucoin) FetchTicker(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes18538 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes18538)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": GetValue(market, "id"),
|
||
}
|
||
|
||
response:= (<-this.PublicGetMarketStats(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "time": 1602832092060, // time
|
||
// "symbol": "BTC-USDT", // symbol
|
||
// "buy": "11328.9", // bestAsk
|
||
// "sell": "11329", // bestBid
|
||
// "changeRate": "-0.0055", // 24h change rate
|
||
// "changePrice": "-63.6", // 24h change price
|
||
// "high": "11610", // 24h highest price
|
||
// "low": "11200", // 24h lowest price
|
||
// "vol": "2282.70993217", // 24h volume，the aggregated trading volume in BTC
|
||
// "volValue": "25984946.157790431", // 24h total, the trading volume in quote currency of last 24 hours
|
||
// "last": "11328.9", // last price
|
||
// "averagePrice": "11360.66065903", // 24h average transaction price yesterday
|
||
// "takerFeeRate": "0.001", // Basic Taker Fee
|
||
// "makerFeeRate": "0.001", // Basic Maker Fee
|
||
// "takerCoefficient": "1", // Taker Fee Coefficient
|
||
// "makerCoefficient": "1" // Maker Fee Coefficient
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseTicker(data, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchMarkPrice
|
||
* @description fetches the mark price for a specific market
|
||
* @see https://www.kucoin.com/docs/rest/margin-trading/margin-info/get-mark-price
|
||
* @param {string} symbol unified symbol of the market to fetch the ticker for
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
||
*/
|
||
func (this *kucoin) FetchMarkPrice(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes18968 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes18968)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": GetValue(market, "id"),
|
||
}
|
||
|
||
response:= (<-this.PublicGetMarkPriceSymbolCurrent(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseTicker(data, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// [
|
||
// "1545904980", // Start time of the candle cycle
|
||
// "0.058", // opening price
|
||
// "0.049", // closing price
|
||
// "0.058", // highest price
|
||
// "0.049", // lowest price
|
||
// "0.018", // base volume
|
||
// "0.000945", // quote volume
|
||
// ]
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
return []interface{}{this.SafeTimestamp(ohlcv, 0), this.SafeNumber(ohlcv, 1), this.SafeNumber(ohlcv, 3), this.SafeNumber(ohlcv, 4), this.SafeNumber(ohlcv, 2), this.SafeNumber(ohlcv, 5)}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchOHLCV
|
||
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
||
* @see https://docs.kucoin.com/#get-klines
|
||
* @param {string} symbol unified symbol of the market to fetch OHLCV data for
|
||
* @param {string} timeframe the length of time each candle represents
|
||
* @param {int} [since] timestamp in ms of the earliest candle to fetch
|
||
* @param {int} [limit] the maximum amount of candles to fetch
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
|
||
*/
|
||
func (this *kucoin) FetchOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
timeframe := GetArg(optionalArgs, 0, "1m")
|
||
_ = timeframe
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes19438 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes19438)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchOHLCV", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes194719 := (<-this.FetchPaginatedCallDeterministic("fetchOHLCV", symbol, since, limit, timeframe, params, 1500))
|
||
PanicOnError(retRes194719)
|
||
ch <- retRes194719
|
||
return nil
|
||
}
|
||
var market interface{} = this.Market(symbol)
|
||
var marketId interface{} = GetValue(market, "id")
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": marketId,
|
||
"type": this.SafeString(this.Timeframes, timeframe, timeframe),
|
||
}
|
||
var duration interface{} = Multiply(this.ParseTimeframe(timeframe), 1000)
|
||
var endAt interface{} = this.Milliseconds() // required param
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startAt", this.ParseToInt(MathFloor(Divide(since, 1000))))
|
||
if IsTrue(IsEqual(limit, nil)) {
|
||
// https://docs.kucoin.com/#get-klines
|
||
// https://docs.kucoin.com/#details
|
||
// For each query, the system would return at most 1500 pieces of data.
|
||
// To obtain more data, please page the data by time.
|
||
limit = this.SafeInteger(this.Options, "fetchOHLCVLimit", 1500)
|
||
}
|
||
endAt = this.Sum(since, Multiply(limit, duration))
|
||
} else if IsTrue(!IsEqual(limit, nil)) {
|
||
since = Subtract(endAt, Multiply(limit, duration))
|
||
AddElementToObject(request, "startAt", this.ParseToInt(MathFloor(Divide(since, 1000))))
|
||
}
|
||
AddElementToObject(request, "endAt", this.ParseToInt(MathFloor(Divide(endAt, 1000))))
|
||
|
||
response:= (<-this.PublicGetMarketCandles(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code":"200000",
|
||
// "data":[
|
||
// ["1591517700","0.025078","0.025069","0.025084","0.025064","18.9883256","0.4761861079404"],
|
||
// ["1591516800","0.025089","0.025079","0.025089","0.02506","99.4716622","2.494143499081"],
|
||
// ["1591515900","0.025079","0.02509","0.025091","0.025068","59.83701271","1.50060885172798"],
|
||
// ]
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
||
|
||
ch <- this.ParseOHLCVs(data, market, timeframe, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#createDepositAddress
|
||
* @see https://www.kucoin.com/docs/rest/funding/deposit/create-deposit-address-v3-
|
||
* @description create a currency deposit address
|
||
* @param {string} code unified currency code of the currency for the deposit address
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.network] the blockchain network name
|
||
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
|
||
*/
|
||
func (this *kucoin) CreateDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes19988 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes19988)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
}
|
||
var networkCode interface{} = nil
|
||
networkCodeparamsVariable := this.HandleNetworkCodeAndParams(params);
|
||
networkCode = GetValue(networkCodeparamsVariable,0);
|
||
params = GetValue(networkCodeparamsVariable,1)
|
||
if IsTrue(!IsEqual(networkCode, nil)) {
|
||
AddElementToObject(request, "chain", this.NetworkCodeToId(networkCode)) // docs mention "chain-name", but seems "chain-id" is used, like in "fetchDepositAddress"
|
||
}
|
||
|
||
response:= (<-this.PrivatePostDepositAddressCreate(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
// {"code":"260000","msg":"Deposit address already exists."}
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "address": "0x2336d1834faab10b2dac44e468f2627138417431",
|
||
// "memo": null,
|
||
// "chainId": "bsc",
|
||
// "to": "MAIN",
|
||
// "expirationDate": 0,
|
||
// "currency": "BNB",
|
||
// "chainName": "BEP20"
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseDepositAddress(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchDepositAddress
|
||
* @description fetch the deposit address for a currency associated with this account
|
||
* @see https://docs.kucoin.com/#get-deposit-addresses-v2
|
||
* @param {string} code unified currency code
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.network] the blockchain network name
|
||
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
|
||
*/
|
||
func (this *kucoin) FetchDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes20398 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes20398)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
}
|
||
var networkCode interface{} = nil
|
||
networkCodeparamsVariable := this.HandleNetworkCodeAndParams(params);
|
||
networkCode = GetValue(networkCodeparamsVariable,0);
|
||
params = GetValue(networkCodeparamsVariable,1)
|
||
if IsTrue(!IsEqual(networkCode, nil)) {
|
||
AddElementToObject(request, "chain", ToLower(this.NetworkCodeToId(networkCode)))
|
||
}
|
||
var version interface{} = GetValue(GetValue(GetValue(GetValue(this.Options, "versions"), "private"), "GET"), "deposit-addresses")
|
||
AddElementToObject(GetValue(GetValue(GetValue(this.Options, "versions"), "private"), "GET"), "deposit-addresses", "v1")
|
||
|
||
response:= (<-this.PrivateGetDepositAddresses(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
// BCH {"code":"200000","data":{"address":"bitcoincash:qza3m4nj9rx7l9r0cdadfqxts6f92shvhvr5ls4q7z","memo":""}}
|
||
// BTC {"code":"200000","data":{"address":"36SjucKqQpQSvsak9A7h6qzFjrVXpRNZhE","memo":""}}
|
||
AddElementToObject(GetValue(GetValue(GetValue(this.Options, "versions"), "private"), "GET"), "deposit-addresses", version)
|
||
var data interface{} = this.SafeValue(response, "data")
|
||
if IsTrue(IsEqual(data, nil)) {
|
||
panic(ExchangeError(Add(this.Id, " fetchDepositAddress() returned an empty response, you might try to run createDepositAddress() first and try again")))
|
||
}
|
||
|
||
ch <- this.ParseDepositAddress(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{} {
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
var address interface{} = this.SafeString(depositAddress, "address")
|
||
// BCH/BSV is returned with a "bitcoincash:" prefix, which we cut off here and only keep the address
|
||
if IsTrue(!IsEqual(address, nil)) {
|
||
address = Replace(address, "bitcoincash:", "")
|
||
}
|
||
var code interface{} = nil
|
||
if IsTrue(!IsEqual(currency, nil)) {
|
||
code = this.SafeCurrencyCode(GetValue(currency, "id"))
|
||
if IsTrue(!IsEqual(code, "NIM")) {
|
||
// contains spaces
|
||
this.CheckAddress(address)
|
||
}
|
||
}
|
||
return map[string]interface{} {
|
||
"info": depositAddress,
|
||
"currency": code,
|
||
"network": this.NetworkIdToCode(this.SafeString(depositAddress, "chainId")),
|
||
"address": address,
|
||
"tag": this.SafeString(depositAddress, "memo"),
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchDepositAddressesByNetwork
|
||
* @see https://docs.kucoin.com/#get-deposit-addresses-v2
|
||
* @description fetch the deposit address for a currency associated with this account
|
||
* @param {string} code unified currency code
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an array of [address structures]{@link https://docs.ccxt.com/#/?id=address-structure}
|
||
*/
|
||
func (this *kucoin) FetchDepositAddressesByNetwork(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes20988 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes20988)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
}
|
||
var version interface{} = GetValue(GetValue(GetValue(GetValue(this.Options, "versions"), "private"), "GET"), "deposit-addresses")
|
||
AddElementToObject(GetValue(GetValue(GetValue(this.Options, "versions"), "private"), "GET"), "deposit-addresses", "v2")
|
||
|
||
response:= (<-this.PrivateGetDepositAddresses(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": [
|
||
// {
|
||
// "address": "fr1qvus7d4d5fgxj5e7zvqe6yhxd7txm95h2and69r",
|
||
// "memo": "",
|
||
// "chain": "BTC-Segwit",
|
||
// "contractAddress": ""
|
||
// },
|
||
// {"address":"37icNMEWbiF8ZkwUMxmfzMxi2A1MQ44bMn","memo":"","chain":"BTC","contractAddress":""},
|
||
// {"address":"Deposit temporarily blocked","memo":"","chain":"TRC20","contractAddress":""}
|
||
// ]
|
||
// }
|
||
//
|
||
AddElementToObject(GetValue(GetValue(GetValue(this.Options, "versions"), "private"), "GET"), "deposit-addresses", version)
|
||
var chains interface{} = this.SafeList(response, "data", []interface{}{})
|
||
var parsed interface{} = this.ParseDepositAddresses(chains, []interface{}{GetValue(currency, "code")}, false, map[string]interface{} {
|
||
"currency": GetValue(currency, "code"),
|
||
})
|
||
|
||
ch <- this.IndexBy(parsed, "network")
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchOrderBook
|
||
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/market-data/get-part-order-book-aggregated-
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/market-data/get-full-order-book-aggregated-
|
||
* @param {string} symbol unified symbol of the market to fetch the order book for
|
||
* @param {int} [limit] the maximum amount of order book entries to return
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
|
||
*/
|
||
func (this *kucoin) FetchOrderBook(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
limit := GetArg(optionalArgs, 0, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes21418 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes21418)
|
||
var market interface{} = this.Market(symbol)
|
||
var level interface{} = this.SafeInteger(params, "level", 2)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": GetValue(market, "id"),
|
||
}
|
||
var isAuthenticated interface{} = this.CheckRequiredCredentials(false)
|
||
var response interface{} = nil
|
||
if IsTrue(!IsTrue(isAuthenticated) || IsTrue(!IsEqual(limit, nil))) {
|
||
if IsTrue(IsEqual(level, 2)) {
|
||
AddElementToObject(request, "level", level)
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
if IsTrue(IsTrue((IsEqual(limit, 20))) || IsTrue((IsEqual(limit, 100)))) {
|
||
AddElementToObject(request, "limit", limit)
|
||
} else {
|
||
panic(ExchangeError(Add(this.Id, " fetchOrderBook() limit argument must be 20 or 100")))
|
||
}
|
||
}
|
||
AddElementToObject(request, "limit", Ternary(IsTrue(limit), limit, 100))
|
||
}
|
||
|
||
response = (<-this.PublicGetMarketOrderbookLevelLevelLimit(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetMarketOrderbookLevel2(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// public (v1) market/orderbook/level2_20 and market/orderbook/level2_100
|
||
//
|
||
// {
|
||
// "sequence": "3262786978",
|
||
// "time": 1550653727731,
|
||
// "bids": [
|
||
// ["6500.12", "0.45054140"],
|
||
// ["6500.11", "0.45054140"],
|
||
// ],
|
||
// "asks": [
|
||
// ["6500.16", "0.57753524"],
|
||
// ["6500.15", "0.57753524"],
|
||
// ]
|
||
// }
|
||
//
|
||
// private (v3) market/orderbook/level2
|
||
//
|
||
// {
|
||
// "sequence": "3262786978",
|
||
// "time": 1550653727731,
|
||
// "bids": [
|
||
// ["6500.12", "0.45054140"],
|
||
// ["6500.11", "0.45054140"],
|
||
// ],
|
||
// "asks": [
|
||
// ["6500.16", "0.57753524"],
|
||
// ["6500.15", "0.57753524"],
|
||
// ]
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var timestamp interface{} = this.SafeInteger(data, "time")
|
||
var orderbook interface{} = this.ParseOrderBook(data, GetValue(market, "symbol"), timestamp, "bids", "asks", Subtract(level, 2), Subtract(level, 1))
|
||
AddElementToObject(orderbook, "nonce", this.SafeInteger(data, "sequence"))
|
||
|
||
ch <- orderbook
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) HandleTriggerPrices(params interface{}) interface{} {
|
||
var triggerPrice interface{} = this.SafeValue2(params, "triggerPrice", "stopPrice")
|
||
var stopLossPrice interface{} = this.SafeValue(params, "stopLossPrice")
|
||
var takeProfitPrice interface{} = this.SafeValue(params, "takeProfitPrice")
|
||
var isStopLoss interface{} = !IsEqual(stopLossPrice, nil)
|
||
var isTakeProfit interface{} = !IsEqual(takeProfitPrice, nil)
|
||
if IsTrue(IsTrue(IsTrue((IsTrue(isStopLoss) && IsTrue(isTakeProfit))) || IsTrue((IsTrue(triggerPrice) && IsTrue(stopLossPrice)))) || IsTrue((IsTrue(triggerPrice) && IsTrue(isTakeProfit)))) {
|
||
panic(ExchangeError(Add(this.Id, " createOrder() - you should use either triggerPrice or stopLossPrice or takeProfitPrice")))
|
||
}
|
||
return []interface{}{triggerPrice, stopLossPrice, takeProfitPrice}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#createOrder
|
||
* @description Create an order on the exchange
|
||
* @see https://docs.kucoin.com/spot#place-a-new-order
|
||
* @see https://docs.kucoin.com/spot#place-a-new-order-2
|
||
* @see https://docs.kucoin.com/spot#place-a-margin-order
|
||
* @see https://docs.kucoin.com/spot-hf/#place-hf-order
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order-test
|
||
* @see https://www.kucoin.com/docs/rest/margin-trading/orders/place-margin-order-test
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/sync-place-hf-order
|
||
* @param {string} symbol Unified CCXT market symbol
|
||
* @param {string} type 'limit' or 'market'
|
||
* @param {string} side 'buy' or 'sell'
|
||
* @param {float} amount the amount of currency to trade
|
||
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
|
||
* @param {string} [params.marginMode] 'cross', // cross (cross mode) and isolated (isolated mode), set to cross by default, the isolated mode will be released soon, stay tuned
|
||
* @param {string} [params.timeInForce] GTC, GTT, IOC, or FOK, default is GTC, limit orders only
|
||
* @param {string} [params.postOnly] Post only flag, invalid when timeInForce is IOC or FOK
|
||
*
|
||
* EXCHANGE SPECIFIC PARAMETERS
|
||
* @param {string} [params.clientOid] client order id, defaults to uuid if not passed
|
||
* @param {string} [params.remark] remark for the order, length cannot exceed 100 utf8 characters
|
||
* @param {string} [params.tradeType] 'TRADE', // TRADE, MARGIN_TRADE // not used with margin orders
|
||
* limit orders ---------------------------------------------------
|
||
* @param {float} [params.cancelAfter] long, // cancel after n seconds, requires timeInForce to be GTT
|
||
* @param {bool} [params.hidden] false, // Order will not be displayed in the order book
|
||
* @param {bool} [params.iceberg] false, // Only a portion of the order is displayed in the order book
|
||
* @param {string} [params.visibleSize] this.amountToPrecision (symbol, visibleSize), // The maximum visible size of an iceberg order
|
||
* market orders --------------------------------------------------
|
||
* @param {string} [params.funds] // Amount of quote currency to use
|
||
* stop orders ----------------------------------------------------
|
||
* @param {string} [params.stop] Either loss or entry, the default is loss. Requires triggerPrice to be defined
|
||
* margin orders --------------------------------------------------
|
||
* @param {float} [params.leverage] Leverage size of the order
|
||
* @param {string} [params.stp] '', // self trade prevention, CN, CO, CB or DC
|
||
* @param {bool} [params.autoBorrow] false, // The system will first borrow you funds at the optimal interest rate and then place an order for you
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @param {bool} [params.test] set to true to test an order, no order will be created but the request will be validated
|
||
* @param {bool} [params.sync] set to true to use the hf sync call
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) CreateOrder(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
price := GetArg(optionalArgs, 0, nil)
|
||
_ = price
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes22588 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes22588)
|
||
var market interface{} = this.Market(symbol)
|
||
var testOrder interface{} = this.SafeBool(params, "test", false)
|
||
params = this.Omit(params, "test")
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
var useSync interface{} = false
|
||
useSyncparamsVariable := this.HandleOptionAndParams(params, "createOrder", "sync", false);
|
||
useSync = GetValue(useSyncparamsVariable,0);
|
||
params = GetValue(useSyncparamsVariable,1)
|
||
triggerPricestopLossPricetakeProfitPriceVariable := this.HandleTriggerPrices(params);
|
||
triggerPrice := GetValue(triggerPricestopLossPricetakeProfitPriceVariable,0);
|
||
stopLossPrice := GetValue(triggerPricestopLossPricetakeProfitPriceVariable,1);
|
||
takeProfitPrice := GetValue(triggerPricestopLossPricetakeProfitPriceVariable,2)
|
||
var tradeType interface{} = this.SafeString(params, "tradeType") // keep it for backward compatibility
|
||
var isTriggerOrder interface{} = (IsTrue(IsTrue(triggerPrice) || IsTrue(stopLossPrice)) || IsTrue(takeProfitPrice))
|
||
var marginResult interface{} = this.HandleMarginModeAndParams("createOrder", params)
|
||
var marginMode interface{} = this.SafeString(marginResult, 0)
|
||
var isMarginOrder interface{} = IsTrue(IsEqual(tradeType, "MARGIN_TRADE")) || IsTrue(!IsEqual(marginMode, nil))
|
||
// don't omit anything before calling createOrderRequest
|
||
var orderRequest interface{} = this.CreateOrderRequest(symbol, typeVar, side, amount, price, params)
|
||
var response interface{} = nil
|
||
if IsTrue(testOrder) {
|
||
if IsTrue(isMarginOrder) {
|
||
|
||
response = (<-this.PrivatePostMarginOrderTest(orderRequest))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivatePostHfOrdersTest(orderRequest))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivatePostOrdersTest(orderRequest))
|
||
PanicOnError(response)
|
||
}
|
||
} else if IsTrue(isTriggerOrder) {
|
||
|
||
response = (<-this.PrivatePostStopOrder(orderRequest))
|
||
PanicOnError(response)
|
||
} else if IsTrue(isMarginOrder) {
|
||
|
||
response = (<-this.PrivatePostMarginOrder(orderRequest))
|
||
PanicOnError(response)
|
||
} else if IsTrue(useSync) {
|
||
|
||
response = (<-this.PrivatePostHfOrdersSync(orderRequest))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivatePostHfOrders(orderRequest))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivatePostOrders(orderRequest))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "orderId": "5bd6e9286d99522a52e458de"
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseOrder(data, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#createMarketOrderWithCost
|
||
* @description create a market order by providing the symbol, side and cost
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order
|
||
* @param {string} symbol unified symbol of the market to create an order in
|
||
* @param {string} side 'buy' or 'sell'
|
||
* @param {float} cost how much you want to trade in units of the quote currency
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) CreateMarketOrderWithCost(symbol interface{}, side interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes23188 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes23188)
|
||
AddElementToObject(params, "cost", cost)
|
||
|
||
retRes232015 := (<-this.CreateOrder(symbol, "market", side, cost, nil, params))
|
||
PanicOnError(retRes232015)
|
||
ch <- retRes232015
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#createMarketBuyOrderWithCost
|
||
* @description create a market buy order by providing the symbol and cost
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order
|
||
* @param {string} symbol unified symbol of the market to create an order in
|
||
* @param {float} cost how much you want to trade in units of the quote currency
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) CreateMarketBuyOrderWithCost(symbol interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes23348 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes23348)
|
||
|
||
retRes233515 := (<-this.CreateMarketOrderWithCost(symbol, "buy", cost, params))
|
||
PanicOnError(retRes233515)
|
||
ch <- retRes233515
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#createMarketSellOrderWithCost
|
||
* @description create a market sell order by providing the symbol and cost
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-order
|
||
* @param {string} symbol unified symbol of the market to create an order in
|
||
* @param {float} cost how much you want to trade in units of the quote currency
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) CreateMarketSellOrderWithCost(symbol interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes23498 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes23498)
|
||
|
||
retRes235015 := (<-this.CreateMarketOrderWithCost(symbol, "sell", cost, params))
|
||
PanicOnError(retRes235015)
|
||
ch <- retRes235015
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#createOrders
|
||
* @description create a list of trade orders
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/orders/place-multiple-orders
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/place-multiple-hf-orders
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/sync-place-multiple-hf-orders
|
||
* @param {Array} orders list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {bool} [params.hf] false, // true for hf orders
|
||
* @param {bool} [params.sync] false, // true to use the hf sync call
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) CreateOrders(orders interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes23678 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes23678)
|
||
var ordersRequests interface{} = []interface{}{}
|
||
var symbol interface{} = nil
|
||
for i := 0; IsLessThan(i, GetArrayLength(orders)); i++ {
|
||
var rawOrder interface{} = GetValue(orders, i)
|
||
var marketId interface{} = this.SafeString(rawOrder, "symbol")
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
symbol = marketId
|
||
} else {
|
||
if IsTrue(!IsEqual(symbol, marketId)) {
|
||
panic(BadRequest(Add(this.Id, " createOrders() requires all orders to have the same symbol")))
|
||
}
|
||
}
|
||
var typeVar interface{} = this.SafeString(rawOrder, "type")
|
||
if IsTrue(!IsEqual(typeVar, "limit")) {
|
||
panic(BadRequest(Add(this.Id, " createOrders() only supports limit orders")))
|
||
}
|
||
var side interface{} = this.SafeString(rawOrder, "side")
|
||
var amount interface{} = this.SafeValue(rawOrder, "amount")
|
||
var price interface{} = this.SafeValue(rawOrder, "price")
|
||
var orderParams interface{} = this.SafeValue(rawOrder, "params", map[string]interface{} {})
|
||
var orderRequest interface{} = this.CreateOrderRequest(marketId, typeVar, side, amount, price, orderParams)
|
||
AppendToArray(&ordersRequests,orderRequest)
|
||
}
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": GetValue(market, "id"),
|
||
"orderList": ordersRequests,
|
||
}
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
var useSync interface{} = false
|
||
useSyncparamsVariable := this.HandleOptionAndParams(params, "createOrders", "sync", false);
|
||
useSync = GetValue(useSyncparamsVariable,0);
|
||
params = GetValue(useSyncparamsVariable,1)
|
||
var response interface{} = nil
|
||
if IsTrue(useSync) {
|
||
|
||
response = (<-this.PrivatePostHfOrdersMultiSync(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivatePostHfOrdersMulti(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivatePostOrdersMulti(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "data": [
|
||
// {
|
||
// "symbol": "LTC-USDT",
|
||
// "type": "limit",
|
||
// "side": "sell",
|
||
// "price": "90",
|
||
// "size": "0.1",
|
||
// "funds": null,
|
||
// "stp": "",
|
||
// "stop": "",
|
||
// "stopPrice": null,
|
||
// "timeInForce": "GTC",
|
||
// "cancelAfter": 0,
|
||
// "postOnly": false,
|
||
// "hidden": false,
|
||
// "iceberge": false,
|
||
// "iceberg": false,
|
||
// "visibleSize": null,
|
||
// "channel": "API",
|
||
// "id": "6539148443fcf500079d15e5",
|
||
// "status": "success",
|
||
// "failMsg": null,
|
||
// "clientOid": "5c4c5398-8ab2-4b4e-af8a-e2d90ad2488f"
|
||
// },
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
data = this.SafeList(data, "data", []interface{}{})
|
||
|
||
ch <- this.ParseOrders(data)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) MarketOrderAmountToPrecision(symbol interface{}, amount interface{}) interface{} {
|
||
var market interface{} = this.Market(symbol)
|
||
var result interface{} = this.DecimalToPrecision(amount, TRUNCATE, GetValue(GetValue(market, "info"), "quoteIncrement"), this.PrecisionMode, this.PaddingMode)
|
||
if IsTrue(IsEqual(result, "0")) {
|
||
panic(InvalidOrder(Add(Add(Add(Add(this.Id, " amount of "), GetValue(market, "symbol")), " must be greater than minimum amount precision of "), this.NumberToString(GetValue(GetValue(market, "precision"), "amount")))))
|
||
}
|
||
return result
|
||
}
|
||
func (this *kucoin) CreateOrderRequest(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) interface{} {
|
||
price := GetArg(optionalArgs, 0, nil)
|
||
_ = price
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
var market interface{} = this.Market(symbol)
|
||
// required param, cannot be used twice
|
||
var clientOrderId interface{} = this.SafeString2(params, "clientOid", "clientOrderId", this.Uuid())
|
||
params = this.Omit(params, []interface{}{"clientOid", "clientOrderId"})
|
||
var request interface{} = map[string]interface{} {
|
||
"clientOid": clientOrderId,
|
||
"side": side,
|
||
"symbol": GetValue(market, "id"),
|
||
"type": typeVar,
|
||
}
|
||
var quoteAmount interface{} = this.SafeNumber2(params, "cost", "funds")
|
||
var amountString interface{} = nil
|
||
var costString interface{} = nil
|
||
var marginMode interface{} = nil
|
||
marginModeparamsVariable := this.HandleMarginModeAndParams("createOrder", params);
|
||
marginMode = GetValue(marginModeparamsVariable,0);
|
||
params = GetValue(marginModeparamsVariable,1)
|
||
if IsTrue(IsEqual(typeVar, "market")) {
|
||
if IsTrue(!IsEqual(quoteAmount, nil)) {
|
||
params = this.Omit(params, []interface{}{"cost", "funds"})
|
||
// kucoin uses base precision even for quote values
|
||
costString = this.MarketOrderAmountToPrecision(symbol, quoteAmount)
|
||
AddElementToObject(request, "funds", costString)
|
||
} else {
|
||
amountString = this.AmountToPrecision(symbol, amount)
|
||
AddElementToObject(request, "size", this.AmountToPrecision(symbol, amount))
|
||
}
|
||
} else {
|
||
amountString = this.AmountToPrecision(symbol, amount)
|
||
AddElementToObject(request, "size", amountString)
|
||
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
||
}
|
||
var tradeType interface{} = this.SafeString(params, "tradeType") // keep it for backward compatibility
|
||
triggerPricestopLossPricetakeProfitPriceVariable := this.HandleTriggerPrices(params);
|
||
triggerPrice := GetValue(triggerPricestopLossPricetakeProfitPriceVariable,0);
|
||
stopLossPrice := GetValue(triggerPricestopLossPricetakeProfitPriceVariable,1);
|
||
takeProfitPrice := GetValue(triggerPricestopLossPricetakeProfitPriceVariable,2)
|
||
var isTriggerOrder interface{} = (IsTrue(IsTrue(triggerPrice) || IsTrue(stopLossPrice)) || IsTrue(takeProfitPrice))
|
||
var isMarginOrder interface{} = IsTrue(IsEqual(tradeType, "MARGIN_TRADE")) || IsTrue(!IsEqual(marginMode, nil))
|
||
params = this.Omit(params, []interface{}{"stopLossPrice", "takeProfitPrice", "triggerPrice", "stopPrice"})
|
||
if IsTrue(isTriggerOrder) {
|
||
if IsTrue(triggerPrice) {
|
||
AddElementToObject(request, "stopPrice", this.PriceToPrecision(symbol, triggerPrice))
|
||
} else if IsTrue(IsTrue(stopLossPrice) || IsTrue(takeProfitPrice)) {
|
||
if IsTrue(stopLossPrice) {
|
||
AddElementToObject(request, "stop", Ternary(IsTrue((IsEqual(side, "buy"))), "entry", "loss"))
|
||
AddElementToObject(request, "stopPrice", this.PriceToPrecision(symbol, stopLossPrice))
|
||
} else {
|
||
AddElementToObject(request, "stop", Ternary(IsTrue((IsEqual(side, "buy"))), "loss", "entry"))
|
||
AddElementToObject(request, "stopPrice", this.PriceToPrecision(symbol, takeProfitPrice))
|
||
}
|
||
}
|
||
if IsTrue(IsEqual(marginMode, "isolated")) {
|
||
panic(BadRequest(Add(this.Id, " createOrder does not support isolated margin for stop orders")))
|
||
} else if IsTrue(IsEqual(marginMode, "cross")) {
|
||
AddElementToObject(request, "tradeType", GetValue(GetValue(this.Options, "marginModes"), marginMode))
|
||
}
|
||
} else if IsTrue(isMarginOrder) {
|
||
if IsTrue(IsEqual(marginMode, "isolated")) {
|
||
AddElementToObject(request, "marginModel", "isolated")
|
||
}
|
||
}
|
||
var postOnly interface{} = nil
|
||
postOnlyparamsVariable := this.HandlePostOnly(IsEqual(typeVar, "market"), false, params);
|
||
postOnly = GetValue(postOnlyparamsVariable,0);
|
||
params = GetValue(postOnlyparamsVariable,1)
|
||
if IsTrue(postOnly) {
|
||
AddElementToObject(request, "postOnly", true)
|
||
}
|
||
return this.Extend(request, params)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#editOrder
|
||
* @description edit an order, kucoin currently only supports the modification of HF orders
|
||
* @see https://docs.kucoin.com/spot-hf/#modify-order
|
||
* @param {string} id order id
|
||
* @param {string} symbol unified symbol of the market to create an order in
|
||
* @param {string} type not used
|
||
* @param {string} side not used
|
||
* @param {float} amount how much of the currency you want to trade in units of the base currency
|
||
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.clientOrderId] client order id, defaults to id if not passed
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) EditOrder(id interface{}, symbol interface{}, typeVar interface{}, side interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
amount := GetArg(optionalArgs, 0, nil)
|
||
_ = amount
|
||
price := GetArg(optionalArgs, 1, nil)
|
||
_ = price
|
||
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes25348 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes25348)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": GetValue(market, "id"),
|
||
}
|
||
var clientOrderId interface{} = this.SafeString2(params, "clientOid", "clientOrderId")
|
||
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
||
AddElementToObject(request, "clientOid", clientOrderId)
|
||
} else {
|
||
AddElementToObject(request, "orderId", id)
|
||
}
|
||
if IsTrue(!IsEqual(amount, nil)) {
|
||
AddElementToObject(request, "newSize", this.AmountToPrecision(symbol, amount))
|
||
}
|
||
if IsTrue(!IsEqual(price, nil)) {
|
||
AddElementToObject(request, "newPrice", this.PriceToPrecision(symbol, price))
|
||
}
|
||
|
||
response:= (<-this.PrivatePostHfOrdersAlter(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code":"200000",
|
||
// "data":{
|
||
// "newOrderId":"6478d7a6c883280001e92d8b"
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseOrder(data, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#cancelOrder
|
||
* @description cancels an open order
|
||
* @see https://docs.kucoin.com/spot#cancel-an-order
|
||
* @see https://docs.kucoin.com/spot#cancel-an-order-2
|
||
* @see https://docs.kucoin.com/spot#cancel-single-order-by-clientoid
|
||
* @see https://docs.kucoin.com/spot#cancel-single-order-by-clientoid-2
|
||
* @see https://docs.kucoin.com/spot-hf/#cancel-orders-by-orderid
|
||
* @see https://docs.kucoin.com/spot-hf/#cancel-order-by-clientoid
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/sync-cancel-hf-order-by-orderid
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/spot-hf-trade-pro-account/sync-cancel-hf-order-by-clientoid
|
||
* @param {string} id order id
|
||
* @param {string} symbol unified symbol of the market the order was made in
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {bool} [params.trigger] True if cancelling a stop order
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @param {bool} [params.sync] false, // true to use the hf sync call
|
||
* @returns Response from the exchange
|
||
*/
|
||
func (this *kucoin) CancelOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes25858 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes25858)
|
||
var request interface{} = map[string]interface{} {}
|
||
var clientOrderId interface{} = this.SafeString2(params, "clientOid", "clientOrderId")
|
||
var trigger interface{} = this.SafeBool2(params, "stop", "trigger", false)
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
var useSync interface{} = false
|
||
useSyncparamsVariable := this.HandleOptionAndParams(params, "cancelOrder", "sync", false);
|
||
useSync = GetValue(useSyncparamsVariable,0);
|
||
params = GetValue(useSyncparamsVariable,1)
|
||
if IsTrue(IsTrue(hf) || IsTrue(useSync)) {
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol parameter for hf orders")))
|
||
}
|
||
var market interface{} = this.Market(symbol)
|
||
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
||
}
|
||
var response interface{} = nil
|
||
params = this.Omit(params, []interface{}{"clientOid", "clientOrderId", "stop", "trigger"})
|
||
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
||
AddElementToObject(request, "clientOid", clientOrderId)
|
||
if IsTrue(trigger) {
|
||
|
||
response = (<-this.PrivateDeleteStopOrderCancelOrderByClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(useSync) {
|
||
|
||
response = (<-this.PrivateDeleteHfOrdersSyncClientOrderClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivateDeleteHfOrdersClientOrderClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateDeleteOrderClientOrderClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
response = this.SafeDict(response, "data")
|
||
|
||
ch <- this.ParseOrder(response)
|
||
return nil
|
||
} else {
|
||
AddElementToObject(request, "orderId", id)
|
||
if IsTrue(trigger) {
|
||
|
||
response = (<-this.PrivateDeleteStopOrderOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(useSync) {
|
||
|
||
response = (<-this.PrivateDeleteHfOrdersSyncOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivateDeleteHfOrdersOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "orderId": "630625dbd9180300014c8d52"
|
||
// }
|
||
// }
|
||
//
|
||
response = this.SafeDict(response, "data")
|
||
|
||
ch <- this.ParseOrder(response)
|
||
return nil
|
||
} else {
|
||
|
||
response = (<-this.PrivateDeleteOrdersOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
var orderIds interface{} = this.SafeList(data, "cancelledOrderIds", []interface{}{})
|
||
var orderId interface{} = this.SafeString(orderIds, 0)
|
||
|
||
ch <- this.SafeOrder(map[string]interface{} {
|
||
"info": data,
|
||
"id": orderId,
|
||
})
|
||
return nil
|
||
}
|
||
return nil
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#cancelAllOrders
|
||
* @description cancel all open orders
|
||
* @see https://docs.kucoin.com/spot#cancel-all-orders
|
||
* @see https://docs.kucoin.com/spot#cancel-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#cancel-all-hf-orders-by-symbol
|
||
* @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {bool} [params.trigger] *invalid for isolated margin* true if cancelling all stop orders
|
||
* @param {string} [params.marginMode] 'cross' or 'isolated'
|
||
* @param {string} [params.orderIds] *stop orders only* Comma seperated order IDs
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @returns Response from the exchange
|
||
*/
|
||
func (this *kucoin) CancelAllOrders(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes27018 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes27018)
|
||
var request interface{} = map[string]interface{} {}
|
||
var trigger interface{} = this.SafeBool(params, "stop", false)
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
params = this.Omit(params, "stop")
|
||
marginModequeryVariable := this.HandleMarginModeAndParams("cancelAllOrders", params);
|
||
marginMode := GetValue(marginModequeryVariable,0);
|
||
query := GetValue(marginModequeryVariable,1)
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
AddElementToObject(request, "symbol", this.MarketId(symbol))
|
||
}
|
||
if IsTrue(!IsEqual(marginMode, nil)) {
|
||
AddElementToObject(request, "tradeType", GetValue(GetValue(this.Options, "marginModes"), marginMode))
|
||
if IsTrue(IsTrue(IsEqual(marginMode, "isolated")) && IsTrue(trigger)) {
|
||
panic(BadRequest(Add(this.Id, " cancelAllOrders does not support isolated margin for stop orders")))
|
||
}
|
||
}
|
||
var response interface{} = nil
|
||
if IsTrue(trigger) {
|
||
|
||
response = (<-this.PrivateDeleteStopOrderCancel(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
|
||
response = (<-this.PrivateDeleteHfOrdersCancelAll(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateDeleteHfOrders(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
}
|
||
} else {
|
||
|
||
response = (<-this.PrivateDeleteOrders(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
}
|
||
|
||
ch <- response
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchOrdersByStatus
|
||
* @description fetch a list of orders
|
||
* @see https://docs.kucoin.com/spot#list-orders
|
||
* @see https://docs.kucoin.com/spot#list-stop-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-list-of-active-hf-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-list-of-filled-hf-orders
|
||
* @param {string} status *not used for stop orders* 'open' or 'closed'
|
||
* @param {string} symbol unified market symbol
|
||
* @param {int} [since] timestamp in ms of the earliest order
|
||
* @param {int} [limit] max number of orders to return
|
||
* @param {object} [params] exchange specific params
|
||
* @param {int} [params.until] end time in ms
|
||
* @param {string} [params.side] buy or sell
|
||
* @param {string} [params.type] limit, market, limit_stop or market_stop
|
||
* @param {string} [params.tradeType] TRADE for spot trading, MARGIN_TRADE for Margin Trading
|
||
* @param {int} [params.currentPage] *trigger orders only* current page
|
||
* @param {string} [params.orderIds] *trigger orders only* comma seperated order ID list
|
||
* @param {bool} [params.trigger] True if fetching a trigger order
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @returns An [array of order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) FetchOrdersByStatus(status interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes27568 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes27568)
|
||
var lowercaseStatus interface{} = ToLower(status)
|
||
var until interface{} = this.SafeInteger(params, "until")
|
||
var trigger interface{} = this.SafeBool2(params, "stop", "trigger", false)
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
if IsTrue(IsTrue(hf) && IsTrue((IsEqual(symbol, nil)))) {
|
||
panic(ArgumentsRequired(Add(this.Id, " fetchOrdersByStatus() requires a symbol parameter for hf orders")))
|
||
}
|
||
params = this.Omit(params, []interface{}{"stop", "trigger", "till", "until"})
|
||
marginModequeryVariable := this.HandleMarginModeAndParams("fetchOrdersByStatus", params);
|
||
marginMode := GetValue(marginModequeryVariable,0);
|
||
query := GetValue(marginModequeryVariable,1)
|
||
if IsTrue(IsEqual(lowercaseStatus, "open")) {
|
||
lowercaseStatus = "active"
|
||
} else if IsTrue(IsEqual(lowercaseStatus, "closed")) {
|
||
lowercaseStatus = "done"
|
||
}
|
||
var request interface{} = map[string]interface{} {
|
||
"status": lowercaseStatus,
|
||
}
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startAt", since)
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "pageSize", limit)
|
||
}
|
||
if IsTrue(until) {
|
||
AddElementToObject(request, "endAt", until)
|
||
}
|
||
AddElementToObject(request, "tradeType", this.SafeString(GetValue(this.Options, "marginModes"), marginMode, "TRADE"))
|
||
var response interface{} = nil
|
||
if IsTrue(trigger) {
|
||
|
||
response = (<-this.PrivateGetStopOrder(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
if IsTrue(IsEqual(lowercaseStatus, "active")) {
|
||
|
||
response = (<-this.PrivateGetHfOrdersActive(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(IsEqual(lowercaseStatus, "done")) {
|
||
|
||
response = (<-this.PrivateGetHfOrdersDone(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
}
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetOrders(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "currentPage": 1,
|
||
// "pageSize": 1,
|
||
// "totalNum": 153408,
|
||
// "totalPage": 153408,
|
||
// "items": [
|
||
// {
|
||
// "id": "5c35c02703aa673ceec2a168", //orderid
|
||
// "symbol": "BTC-USDT", //symbol
|
||
// "opType": "DEAL", // operation type,deal is pending order,cancel is cancel order
|
||
// "type": "limit", // order type,e.g. limit,markrt,stop_limit.
|
||
// "side": "buy", // transaction direction,include buy and sell
|
||
// "price": "10", // order price
|
||
// "size": "2", // order quantity
|
||
// "funds": "0", // order funds
|
||
// "dealFunds": "0.166", // deal funds
|
||
// "dealSize": "2", // deal quantity
|
||
// "fee": "0", // fee
|
||
// "feeCurrency": "USDT", // charge fee currency
|
||
// "stp": "", // self trade prevention,include CN,CO,DC,CB
|
||
// "stop": "", // stop type
|
||
// "stopTriggered": false, // stop order is triggered
|
||
// "stopPrice": "0", // stop price
|
||
// "timeInForce": "GTC", // time InForce,include GTC,GTT,IOC,FOK
|
||
// "postOnly": false, // postOnly
|
||
// "hidden": false, // hidden order
|
||
// "iceberg": false, // iceberg order
|
||
// "visibleSize": "0", // display quantity for iceberg order
|
||
// "cancelAfter": 0, // cancel orders time，requires timeInForce to be GTT
|
||
// "channel": "IOS", // order source
|
||
// "clientOid": "", // user-entered order unique mark
|
||
// "remark": "", // remark
|
||
// "tags": "", // tag order source
|
||
// "isActive": false, // status before unfilled or uncancelled
|
||
// "cancelExist": false, // order cancellation transaction record
|
||
// "createdAt": 1547026471000 // time
|
||
// },
|
||
// ]
|
||
// }
|
||
// }
|
||
var listData interface{} = this.SafeList(response, "data")
|
||
if IsTrue(!IsEqual(listData, nil)) {
|
||
|
||
ch <- this.ParseOrders(listData, market, since, limit)
|
||
return nil
|
||
}
|
||
var responseData interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var orders interface{} = this.SafeList(responseData, "items", []interface{}{})
|
||
|
||
ch <- this.ParseOrders(orders, market, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchClosedOrders
|
||
* @description fetches information on multiple closed orders made by the user
|
||
* @see https://docs.kucoin.com/spot#list-orders
|
||
* @see https://docs.kucoin.com/spot#list-stop-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-list-of-active-hf-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-list-of-filled-hf-orders
|
||
* @param {string} symbol unified market symbol of the market orders were made in
|
||
* @param {int} [since] the earliest time in ms to fetch orders for
|
||
* @param {int} [limit] the maximum number of order structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {int} [params.until] end time in ms
|
||
* @param {string} [params.side] buy or sell
|
||
* @param {string} [params.type] limit, market, limit_stop or market_stop
|
||
* @param {string} [params.tradeType] TRADE for spot trading, MARGIN_TRADE for Margin Trading
|
||
* @param {bool} [params.trigger] True if fetching a trigger order
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) FetchClosedOrders(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes28768 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes28768)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchClosedOrders", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes288019 := (<-this.FetchPaginatedCallDynamic("fetchClosedOrders", symbol, since, limit, params))
|
||
PanicOnError(retRes288019)
|
||
ch <- retRes288019
|
||
return nil
|
||
}
|
||
|
||
retRes288215 := (<-this.FetchOrdersByStatus("done", symbol, since, limit, params))
|
||
PanicOnError(retRes288215)
|
||
ch <- retRes288215
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchOpenOrders
|
||
* @description fetch all unfilled currently open orders
|
||
* @see https://docs.kucoin.com/spot#list-orders
|
||
* @see https://docs.kucoin.com/spot#list-stop-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-list-of-active-hf-orders
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-list-of-filled-hf-orders
|
||
* @param {string} symbol unified market symbol
|
||
* @param {int} [since] the earliest time in ms to fetch open orders for
|
||
* @param {int} [limit] the maximum number of open orders structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {int} [params.until] end time in ms
|
||
* @param {bool} [params.trigger] true if fetching trigger orders
|
||
* @param {string} [params.side] buy or sell
|
||
* @param {string} [params.type] limit, market, limit_stop or market_stop
|
||
* @param {string} [params.tradeType] TRADE for spot trading, MARGIN_TRADE for Margin Trading
|
||
* @param {int} [params.currentPage] *trigger orders only* current page
|
||
* @param {string} [params.orderIds] *trigger orders only* comma seperated order ID list
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) FetchOpenOrders(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes29098 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes29098)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchOpenOrders", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes291319 := (<-this.FetchPaginatedCallDynamic("fetchOpenOrders", symbol, since, limit, params))
|
||
PanicOnError(retRes291319)
|
||
ch <- retRes291319
|
||
return nil
|
||
}
|
||
|
||
retRes291515 := (<-this.FetchOrdersByStatus("active", symbol, since, limit, params))
|
||
PanicOnError(retRes291515)
|
||
ch <- retRes291515
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchOrder
|
||
* @description fetch an order
|
||
* @see https://docs.kucoin.com/spot#get-an-order
|
||
* @see https://docs.kucoin.com/spot#get-single-active-order-by-clientoid
|
||
* @see https://docs.kucoin.com/spot#get-single-order-info
|
||
* @see https://docs.kucoin.com/spot#get-single-order-by-clientoid
|
||
* @see https://docs.kucoin.com/spot-hf/#details-of-a-single-hf-order
|
||
* @see https://docs.kucoin.com/spot-hf/#obtain-details-of-a-single-hf-order-using-clientoid
|
||
* @param {string} id Order id
|
||
* @param {string} symbol not sent to exchange except for trigger orders with clientOid, but used internally by CCXT to filter
|
||
* @param {object} [params] exchange specific parameters
|
||
* @param {bool} [params.trigger] true if fetching a trigger order
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @param {bool} [params.clientOid] unique order id created by users to identify their orders
|
||
* @returns An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *kucoin) FetchOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes29378 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes29378)
|
||
var request interface{} = map[string]interface{} {}
|
||
var clientOrderId interface{} = this.SafeString2(params, "clientOid", "clientOrderId")
|
||
var trigger interface{} = this.SafeBool2(params, "stop", "trigger", false)
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
}
|
||
if IsTrue(hf) {
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " fetchOrder() requires a symbol parameter for hf orders")))
|
||
}
|
||
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
||
}
|
||
params = this.Omit(params, []interface{}{"stop", "clientOid", "clientOrderId", "trigger"})
|
||
var response interface{} = nil
|
||
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
||
AddElementToObject(request, "clientOid", clientOrderId)
|
||
if IsTrue(trigger) {
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
||
}
|
||
|
||
response = (<-this.PrivateGetStopOrderQueryOrderByClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivateGetHfOrdersClientOrderClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetOrderClientOrderClientOid(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
} else {
|
||
// a special case for undefined ids
|
||
// otherwise a wrong endpoint for all orders will be triggered
|
||
// https://github.com/ccxt/ccxt/issues/7234
|
||
if IsTrue(IsEqual(id, nil)) {
|
||
panic(InvalidOrder(Add(this.Id, " fetchOrder() requires an order id")))
|
||
}
|
||
AddElementToObject(request, "orderId", id)
|
||
if IsTrue(trigger) {
|
||
|
||
response = (<-this.PrivateGetStopOrderOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(hf) {
|
||
|
||
response = (<-this.PrivateGetHfOrdersOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetOrdersOrderId(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
}
|
||
var responseData interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
if IsTrue(IsArray(responseData)) {
|
||
responseData = this.SafeValue(responseData, 0)
|
||
}
|
||
|
||
ch <- this.ParseOrder(responseData, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// createOrder
|
||
//
|
||
// {
|
||
// "orderId": "63c97e47d686c5000159a656"
|
||
// }
|
||
//
|
||
// cancelOrder
|
||
//
|
||
// {
|
||
// "cancelledOrderIds": [ "63c97e47d686c5000159a656" ]
|
||
// }
|
||
//
|
||
// fetchOpenOrders, fetchClosedOrders
|
||
//
|
||
// {
|
||
// "id": "63c97ce8d686c500015793bb",
|
||
// "symbol": "USDC-USDT",
|
||
// "opType": "DEAL",
|
||
// "type": "limit",
|
||
// "side": "sell",
|
||
// "price": "1.05",
|
||
// "size": "1",
|
||
// "funds": "0",
|
||
// "dealFunds": "0",
|
||
// "dealSize": "0",
|
||
// "fee": "0",
|
||
// "feeCurrency": "USDT",
|
||
// "stp": "",
|
||
// "stop": "",
|
||
// "stopTriggered": false,
|
||
// "stopPrice": "0",
|
||
// "timeInForce": "GTC",
|
||
// "postOnly": false,
|
||
// "hidden": false,
|
||
// "iceberg": false,
|
||
// "visibleSize": "0",
|
||
// "cancelAfter": 0,
|
||
// "channel": "API",
|
||
// "clientOid": "d602d73f-5424-4751-bef0-8debce8f0a82",
|
||
// "remark": null,
|
||
// "tags": "partner:ccxt",
|
||
// "isActive": true,
|
||
// "cancelExist": false,
|
||
// "createdAt": 1674149096927,
|
||
// "tradeType": "TRADE"
|
||
// }
|
||
//
|
||
// stop orders (fetchOpenOrders, fetchClosedOrders)
|
||
//
|
||
// {
|
||
// "id": "vs9f6ou9e864rgq8000t4qnm",
|
||
// "symbol": "USDC-USDT",
|
||
// "userId": "613a896885d8660006151f01",
|
||
// "status": "NEW",
|
||
// "type": "market",
|
||
// "side": "sell",
|
||
// "price": null,
|
||
// "size": "1.00000000000000000000",
|
||
// "funds": null,
|
||
// "stp": null,
|
||
// "timeInForce": "GTC",
|
||
// "cancelAfter": -1,
|
||
// "postOnly": false,
|
||
// "hidden": false,
|
||
// "iceberg": false,
|
||
// "visibleSize": null,
|
||
// "channel": "API",
|
||
// "clientOid": "5d3fd727-6456-438d-9550-40d9d85eee0b",
|
||
// "remark": null,
|
||
// "tags": "partner:ccxt",
|
||
// "relatedNo": null,
|
||
// "orderTime": 1674146316994000028,
|
||
// "domainId": "kucoin",
|
||
// "tradeSource": "USER",
|
||
// "tradeType": "MARGIN_TRADE",
|
||
// "feeCurrency": "USDT",
|
||
// "takerFeeRate": "0.00100000000000000000",
|
||
// "makerFeeRate": "0.00100000000000000000",
|
||
// "createdAt": 1674146316994,
|
||
// "stop": "loss",
|
||
// "stopTriggerTime": null,
|
||
// "stopPrice": "0.97000000000000000000"
|
||
// }
|
||
// hf order
|
||
// {
|
||
// "id":"6478cf1439bdfc0001528a1d",
|
||
// "symbol":"LTC-USDT",
|
||
// "opType":"DEAL",
|
||
// "type":"limit",
|
||
// "side":"buy",
|
||
// "price":"50",
|
||
// "size":"0.1",
|
||
// "funds":"5",
|
||
// "dealSize":"0",
|
||
// "dealFunds":"0",
|
||
// "fee":"0",
|
||
// "feeCurrency":"USDT",
|
||
// "stp":null,
|
||
// "timeInForce":"GTC",
|
||
// "postOnly":false,
|
||
// "hidden":false,
|
||
// "iceberg":false,
|
||
// "visibleSize":"0",
|
||
// "cancelAfter":0,
|
||
// "channel":"API",
|
||
// "clientOid":"d4d2016b-8e3a-445c-aa5d-dc6df5d1678d",
|
||
// "remark":null,
|
||
// "tags":"partner:ccxt",
|
||
// "cancelExist":false,
|
||
// "createdAt":1685638932074,
|
||
// "lastUpdatedAt":1685639013735,
|
||
// "tradeType":"TRADE",
|
||
// "inOrderBook":true,
|
||
// "cancelledSize":"0",
|
||
// "cancelledFunds":"0",
|
||
// "remainSize":"0.1",
|
||
// "remainFunds":"5",
|
||
// "active":true
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(order, "symbol")
|
||
var timestamp interface{} = this.SafeInteger(order, "createdAt")
|
||
var feeCurrencyId interface{} = this.SafeString(order, "feeCurrency")
|
||
var cancelExist interface{} = this.SafeBool(order, "cancelExist", false)
|
||
var responseStop interface{} = this.SafeString(order, "stop")
|
||
var trigger interface{} = !IsEqual(responseStop, nil)
|
||
var stopTriggered interface{} = this.SafeBool(order, "stopTriggered", false)
|
||
var isActive interface{} = this.SafeBool2(order, "isActive", "active")
|
||
var responseStatus interface{} = this.SafeString(order, "status")
|
||
var status interface{} = nil
|
||
if IsTrue(!IsEqual(isActive, nil)) {
|
||
if IsTrue(IsEqual(isActive, true)) {
|
||
status = "open"
|
||
} else {
|
||
status = "closed"
|
||
}
|
||
}
|
||
if IsTrue(trigger) {
|
||
if IsTrue(IsEqual(responseStatus, "NEW")) {
|
||
status = "open"
|
||
} else if IsTrue(!IsTrue(isActive) && !IsTrue(stopTriggered)) {
|
||
status = "cancelled"
|
||
}
|
||
}
|
||
if IsTrue(cancelExist) {
|
||
status = "canceled"
|
||
}
|
||
if IsTrue(IsEqual(responseStatus, "fail")) {
|
||
status = "rejected"
|
||
}
|
||
return this.SafeOrder(map[string]interface{} {
|
||
"info": order,
|
||
"id": this.SafeStringN(order, []interface{}{"id", "orderId", "newOrderId", "cancelledOrderId"}),
|
||
"clientOrderId": this.SafeString(order, "clientOid"),
|
||
"symbol": this.SafeSymbol(marketId, market, "-"),
|
||
"type": this.SafeString(order, "type"),
|
||
"timeInForce": this.SafeString(order, "timeInForce"),
|
||
"postOnly": this.SafeBool(order, "postOnly"),
|
||
"side": this.SafeString(order, "side"),
|
||
"amount": this.SafeString(order, "size"),
|
||
"price": this.SafeString(order, "price"),
|
||
"triggerPrice": this.SafeNumber(order, "stopPrice"),
|
||
"cost": this.SafeString(order, "dealFunds"),
|
||
"filled": this.SafeString(order, "dealSize"),
|
||
"remaining": nil,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"fee": map[string]interface{} {
|
||
"currency": this.SafeCurrencyCode(feeCurrencyId),
|
||
"cost": this.SafeNumber(order, "fee"),
|
||
},
|
||
"status": status,
|
||
"lastTradeTimestamp": nil,
|
||
"average": this.SafeString(order, "avgDealPrice"),
|
||
"trades": nil,
|
||
}, market)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchOrderTrades
|
||
* @description fetch all the trades made from a single order
|
||
* @see https://docs.kucoin.com/#list-fills
|
||
* @see https://docs.kucoin.com/spot-hf/#transaction-details
|
||
* @param {string} id order id
|
||
* @param {string} symbol unified market symbol
|
||
* @param {int} [since] the earliest time in ms to fetch trades for
|
||
* @param {int} [limit] the maximum number of trades to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
|
||
*/
|
||
func (this *kucoin) FetchOrderTrades(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
var request interface{} = map[string]interface{} {
|
||
"orderId": id,
|
||
}
|
||
|
||
retRes318715 := (<-this.FetchMyTrades(symbol, since, limit, this.Extend(request, params)))
|
||
PanicOnError(retRes318715)
|
||
ch <- retRes318715
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchMyTrades
|
||
* @see https://docs.kucoin.com/#list-fills
|
||
* @see https://docs.kucoin.com/spot-hf/#transaction-details
|
||
* @description fetch all trades made by the user
|
||
* @param {string} symbol unified market symbol
|
||
* @param {int} [since] the earliest time in ms to fetch trades for
|
||
* @param {int} [limit] the maximum number of trades structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {int} [params.until] the latest time in ms to fetch entries for
|
||
* @param {bool} [params.hf] false, // true for hf order
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
|
||
*/
|
||
func (this *kucoin) FetchMyTrades(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes32068 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes32068)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchMyTrades", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes321019 := (<-this.FetchPaginatedCallDynamic("fetchMyTrades", symbol, since, limit, params))
|
||
PanicOnError(retRes321019)
|
||
ch <- retRes321019
|
||
return nil
|
||
}
|
||
var request interface{} = map[string]interface{} {}
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
if IsTrue(IsTrue(hf) && IsTrue(IsEqual(symbol, nil))) {
|
||
panic(ArgumentsRequired(Add(this.Id, " fetchMyTrades() requires a symbol parameter for hf orders")))
|
||
}
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
||
}
|
||
var method interface{} = GetValue(this.Options, "fetchMyTradesMethod")
|
||
var parseResponseData interface{} = false
|
||
var response interface{} = nil
|
||
requestparamsVariable := this.HandleUntilOption("endAt", request, params);
|
||
request = GetValue(requestparamsVariable,0);
|
||
params = GetValue(requestparamsVariable,1)
|
||
if IsTrue(hf) {
|
||
// does not return trades earlier than 2019-02-18T00:00:00Z
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", limit)
|
||
}
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
// only returns trades up to one week after the since param
|
||
AddElementToObject(request, "startAt", since)
|
||
}
|
||
|
||
response = (<-this.PrivateGetHfFills(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(IsEqual(method, "private_get_fills")) {
|
||
// does not return trades earlier than 2019-02-18T00:00:00Z
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
// only returns trades up to one week after the since param
|
||
AddElementToObject(request, "startAt", since)
|
||
}
|
||
|
||
response = (<-this.PrivateGetFills(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(IsEqual(method, "private_get_limit_fills")) {
|
||
// does not return trades earlier than 2019-02-18T00:00:00Z
|
||
// takes no params
|
||
// only returns first 1000 trades (not only "in the last 24 hours" as stated in the docs)
|
||
parseResponseData = true
|
||
|
||
response = (<-this.PrivateGetLimitFills(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
panic(ExchangeError(Add(this.Id, " fetchMyTradesMethod() invalid method")))
|
||
}
|
||
//
|
||
// {
|
||
// "currentPage": 1,
|
||
// "pageSize": 50,
|
||
// "totalNum": 1,
|
||
// "totalPage": 1,
|
||
// "items": [
|
||
// {
|
||
// "symbol":"BTC-USDT", // symbol
|
||
// "tradeId":"5c35c02709e4f67d5266954e", // trade id
|
||
// "orderId":"5c35c02703aa673ceec2a168", // order id
|
||
// "counterOrderId":"5c1ab46003aa676e487fa8e3", // counter order id
|
||
// "side":"buy", // transaction direction,include buy and sell
|
||
// "liquidity":"taker", // include taker and maker
|
||
// "forceTaker":true, // forced to become taker
|
||
// "price":"0.083", // order price
|
||
// "size":"0.8424304", // order quantity
|
||
// "funds":"0.0699217232", // order funds
|
||
// "fee":"0", // fee
|
||
// "feeRate":"0", // fee rate
|
||
// "feeCurrency":"USDT", // charge fee currency
|
||
// "stop":"", // stop type
|
||
// "type":"limit", // order type, e.g. limit, market, stop_limit.
|
||
// "createdAt":1547026472000 // time
|
||
// },
|
||
// //------------------------------------------------------
|
||
// // v1 (historical) trade response structure
|
||
// {
|
||
// "symbol": "SNOV-ETH",
|
||
// "dealPrice": "0.0000246",
|
||
// "dealValue": "0.018942",
|
||
// "amount": "770",
|
||
// "fee": "0.00001137",
|
||
// "side": "sell",
|
||
// "createdAt": 1540080199
|
||
// "id":"5c4d389e4c8c60413f78e2e5",
|
||
// }
|
||
// ]
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var trades interface{} = nil
|
||
if IsTrue(parseResponseData) {
|
||
trades = data
|
||
} else {
|
||
trades = this.SafeList(data, "items", []interface{}{})
|
||
}
|
||
|
||
ch <- this.ParseTrades(trades, market, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchTrades
|
||
* @description get the list of most recent trades for a particular symbol
|
||
* @see https://www.kucoin.com/docs/rest/spot-trading/market-data/get-trade-histories
|
||
* @param {string} symbol unified symbol of the market to fetch trades for
|
||
* @param {int} [since] timestamp in ms of the earliest trade to fetch
|
||
* @param {int} [limit] the maximum amount of trades to fetch
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
|
||
*/
|
||
func (this *kucoin) FetchTrades(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
since := GetArg(optionalArgs, 0, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 1, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes33158 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes33158)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbol": GetValue(market, "id"),
|
||
}
|
||
// pagination is not supported on the exchange side anymore
|
||
// if (since !== undefined) {
|
||
// request['startAt'] = Math.floor (since / 1000);
|
||
// }
|
||
// if (limit !== undefined) {
|
||
// request['pageSize'] = limit;
|
||
// }
|
||
|
||
response:= (<-this.PublicGetMarketHistories(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": [
|
||
// {
|
||
// "sequence": "1548764654235",
|
||
// "side": "sell",
|
||
// "size":"0.6841354",
|
||
// "price":"0.03202",
|
||
// "time":1548848575203567174
|
||
// }
|
||
// ]
|
||
// }
|
||
//
|
||
var trades interface{} = this.SafeList(response, "data", []interface{}{})
|
||
|
||
ch <- this.ParseTrades(trades, market, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// fetchTrades (public)
|
||
//
|
||
// {
|
||
// "sequence": "1548764654235",
|
||
// "side": "sell",
|
||
// "size":"0.6841354",
|
||
// "price":"0.03202",
|
||
// "time":1548848575203567174
|
||
// }
|
||
//
|
||
// {
|
||
// "sequence": "1568787654360",
|
||
// "symbol": "BTC-USDT",
|
||
// "side": "buy",
|
||
// "size": "0.00536577",
|
||
// "price": "9345",
|
||
// "takerOrderId": "5e356c4a9f1a790008f8d921",
|
||
// "time": "1580559434436443257",
|
||
// "type": "match",
|
||
// "makerOrderId": "5e356bffedf0010008fa5d7f",
|
||
// "tradeId": "5e356c4aeefabd62c62a1ece"
|
||
// }
|
||
//
|
||
// fetchMyTrades (private) v2
|
||
//
|
||
// {
|
||
// "symbol":"BTC-USDT",
|
||
// "tradeId":"5c35c02709e4f67d5266954e",
|
||
// "orderId":"5c35c02703aa673ceec2a168",
|
||
// "counterOrderId":"5c1ab46003aa676e487fa8e3",
|
||
// "side":"buy",
|
||
// "liquidity":"taker",
|
||
// "forceTaker":true,
|
||
// "price":"0.083",
|
||
// "size":"0.8424304",
|
||
// "funds":"0.0699217232",
|
||
// "fee":"0",
|
||
// "feeRate":"0",
|
||
// "feeCurrency":"USDT",
|
||
// "stop":"",
|
||
// "type":"limit",
|
||
// "createdAt":1547026472000
|
||
// }
|
||
//
|
||
// fetchMyTrades v2 alternative format since 2019-05-21 https://github.com/ccxt/ccxt/pull/5162
|
||
//
|
||
// {
|
||
// "symbol": "OPEN-BTC",
|
||
// "forceTaker": false,
|
||
// "orderId": "5ce36420054b4663b1fff2c9",
|
||
// "fee": "0",
|
||
// "feeCurrency": "",
|
||
// "type": "",
|
||
// "feeRate": "0",
|
||
// "createdAt": 1558417615000,
|
||
// "size": "12.8206",
|
||
// "stop": "",
|
||
// "price": "0",
|
||
// "funds": "0",
|
||
// "tradeId": "5ce390cf6e0db23b861c6e80"
|
||
// }
|
||
//
|
||
// fetchMyTrades (private) v1 (historical)
|
||
//
|
||
// {
|
||
// "symbol": "SNOV-ETH",
|
||
// "dealPrice": "0.0000246",
|
||
// "dealValue": "0.018942",
|
||
// "amount": "770",
|
||
// "fee": "0.00001137",
|
||
// "side": "sell",
|
||
// "createdAt": 1540080199
|
||
// "id":"5c4d389e4c8c60413f78e2e5",
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(trade, "symbol")
|
||
market = this.SafeMarket(marketId, market, "-")
|
||
var id interface{} = this.SafeString2(trade, "tradeId", "id")
|
||
var orderId interface{} = this.SafeString(trade, "orderId")
|
||
var takerOrMaker interface{} = this.SafeString(trade, "liquidity")
|
||
var timestamp interface{} = this.SafeInteger(trade, "time")
|
||
if IsTrue(!IsEqual(timestamp, nil)) {
|
||
timestamp = this.ParseToInt(Divide(timestamp, 1000000))
|
||
} else {
|
||
timestamp = this.SafeInteger(trade, "createdAt")
|
||
// if it's a historical v1 trade, the exchange returns timestamp in seconds
|
||
if IsTrue(IsTrue((InOp(trade, "dealValue"))) && IsTrue((!IsEqual(timestamp, nil)))) {
|
||
timestamp = Multiply(timestamp, 1000)
|
||
}
|
||
}
|
||
var priceString interface{} = this.SafeString2(trade, "price", "dealPrice")
|
||
var amountString interface{} = this.SafeString2(trade, "size", "amount")
|
||
var side interface{} = this.SafeString(trade, "side")
|
||
var fee interface{} = nil
|
||
var feeCostString interface{} = this.SafeString(trade, "fee")
|
||
if IsTrue(!IsEqual(feeCostString, nil)) {
|
||
var feeCurrencyId interface{} = this.SafeString(trade, "feeCurrency")
|
||
var feeCurrency interface{} = this.SafeCurrencyCode(feeCurrencyId)
|
||
if IsTrue(IsEqual(feeCurrency, nil)) {
|
||
feeCurrency = Ternary(IsTrue((IsEqual(side, "sell"))), GetValue(market, "quote"), GetValue(market, "base"))
|
||
}
|
||
fee = map[string]interface{} {
|
||
"cost": feeCostString,
|
||
"currency": feeCurrency,
|
||
"rate": this.SafeString(trade, "feeRate"),
|
||
}
|
||
}
|
||
var typeVar interface{} = this.SafeString(trade, "type")
|
||
if IsTrue(IsEqual(typeVar, "match")) {
|
||
typeVar = nil
|
||
}
|
||
var costString interface{} = this.SafeString2(trade, "funds", "dealValue")
|
||
return this.SafeTrade(map[string]interface{} {
|
||
"info": trade,
|
||
"id": id,
|
||
"order": orderId,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"symbol": GetValue(market, "symbol"),
|
||
"type": typeVar,
|
||
"takerOrMaker": takerOrMaker,
|
||
"side": side,
|
||
"price": priceString,
|
||
"amount": amountString,
|
||
"cost": costString,
|
||
"fee": fee,
|
||
}, market)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchTradingFee
|
||
* @description fetch the trading fees for a market
|
||
* @see https://www.kucoin.com/docs/rest/funding/trade-fee/trading-pair-actual-fee-spot-margin-trade_hf
|
||
* @param {string} symbol unified market symbol
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
|
||
*/
|
||
func (this *kucoin) FetchTradingFee(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes34878 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes34878)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"symbols": GetValue(market, "id"),
|
||
}
|
||
|
||
response:= (<-this.PrivateGetTradeFees(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": [
|
||
// {
|
||
// "symbol": "BTC-USDT",
|
||
// "takerFeeRate": "0.001",
|
||
// "makerFeeRate": "0.001"
|
||
// }
|
||
// ]
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
||
var first interface{} = this.SafeDict(data, 0)
|
||
var marketId interface{} = this.SafeString(first, "symbol")
|
||
|
||
ch <- map[string]interface{} {
|
||
"info": response,
|
||
"symbol": this.SafeSymbol(marketId, market),
|
||
"maker": this.SafeNumber(first, "makerFeeRate"),
|
||
"taker": this.SafeNumber(first, "takerFeeRate"),
|
||
"percentage": true,
|
||
"tierBased": true,
|
||
}
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#withdraw
|
||
* @description make a withdrawal
|
||
* @see https://www.kucoin.com/docs/rest/funding/withdrawals/apply-withdraw-v3-
|
||
* @param {string} code unified currency code
|
||
* @param {float} amount the amount to withdraw
|
||
* @param {string} address the address to withdraw to
|
||
* @param {string} tag
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
||
*/
|
||
func (this *kucoin) Withdraw(code interface{}, amount interface{}, address interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
tag := GetArg(optionalArgs, 0, nil)
|
||
_ = tag
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
tagparamsVariable := this.HandleWithdrawTagAndParams(tag, params);
|
||
tag = GetValue(tagparamsVariable,0);
|
||
params = GetValue(tagparamsVariable,1)
|
||
|
||
retRes35328 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes35328)
|
||
this.CheckAddress(address)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"toAddress": address,
|
||
"withdrawType": "ADDRESS",
|
||
}
|
||
if IsTrue(!IsEqual(tag, nil)) {
|
||
AddElementToObject(request, "memo", tag)
|
||
}
|
||
var networkCode interface{} = nil
|
||
networkCodeparamsVariable := this.HandleNetworkCodeAndParams(params);
|
||
networkCode = GetValue(networkCodeparamsVariable,0);
|
||
params = GetValue(networkCodeparamsVariable,1)
|
||
if IsTrue(!IsEqual(networkCode, nil)) {
|
||
AddElementToObject(request, "chain", ToLower(this.NetworkCodeToId(networkCode)))
|
||
}
|
||
AddElementToObject(request, "amount", ParseFloat(this.CurrencyToPrecision(code, amount, networkCode)))
|
||
var includeFee interface{} = nil
|
||
includeFeeparamsVariable := this.HandleOptionAndParams(params, "withdraw", "includeFee", false);
|
||
includeFee = GetValue(includeFeeparamsVariable,0);
|
||
params = GetValue(includeFeeparamsVariable,1)
|
||
if IsTrue(includeFee) {
|
||
AddElementToObject(request, "feeDeductType", "INTERNAL")
|
||
}
|
||
|
||
response:= (<-this.PrivatePostWithdrawals(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// the id is inside "data"
|
||
//
|
||
// {
|
||
// "code": 200000,
|
||
// "data": {
|
||
// "withdrawalId": "5bffb63303aa675e8bbe18f9"
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseTransaction(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseTransactionStatus(status interface{}) interface{} {
|
||
var statuses interface{} = map[string]interface{} {
|
||
"SUCCESS": "ok",
|
||
"PROCESSING": "pending",
|
||
"WALLET_PROCESSING": "pending",
|
||
"FAILURE": "failed",
|
||
}
|
||
return this.SafeString(statuses, status, status)
|
||
}
|
||
func (this *kucoin) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// fetchDeposits
|
||
//
|
||
// {
|
||
// "address": "0x5f047b29041bcfdbf0e4478cdfa753a336ba6989",
|
||
// "memo": "5c247c8a03aa677cea2a251d",
|
||
// "amount": 1,
|
||
// "fee": 0.0001,
|
||
// "currency": "KCS",
|
||
// "chain": "",
|
||
// "isInner": false,
|
||
// "walletTxId": "5bbb57386d99522d9f954c5a@test004",
|
||
// "status": "SUCCESS",
|
||
// "createdAt": 1544178843000,
|
||
// "updatedAt": 1544178891000
|
||
// "remark":"foobar"
|
||
// }
|
||
//
|
||
// fetchWithdrawals
|
||
//
|
||
// {
|
||
// "id": "5c2dc64e03aa675aa263f1ac",
|
||
// "address": "0x5bedb060b8eb8d823e2414d82acce78d38be7fe9",
|
||
// "memo": "",
|
||
// "currency": "ETH",
|
||
// "chain": "",
|
||
// "amount": 1.0000000,
|
||
// "fee": 0.0100000,
|
||
// "walletTxId": "3e2414d82acce78d38be7fe9",
|
||
// "isInner": false,
|
||
// "status": "FAILURE",
|
||
// "createdAt": 1546503758000,
|
||
// "updatedAt": 1546504603000
|
||
// "remark":"foobar"
|
||
// }
|
||
//
|
||
// withdraw
|
||
//
|
||
// {
|
||
// "withdrawalId": "5bffb63303aa675e8bbe18f9"
|
||
// }
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
var currencyId interface{} = this.SafeString(transaction, "currency")
|
||
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
|
||
var address interface{} = this.SafeString(transaction, "address")
|
||
var amount interface{} = this.SafeString(transaction, "amount")
|
||
var txid interface{} = this.SafeString(transaction, "walletTxId")
|
||
if IsTrue(!IsEqual(txid, nil)) {
|
||
var txidParts interface{} = Split(txid, "@")
|
||
var numTxidParts interface{} = GetArrayLength(txidParts)
|
||
if IsTrue(IsGreaterThan(numTxidParts, 1)) {
|
||
if IsTrue(IsEqual(address, nil)) {
|
||
if IsTrue(IsGreaterThan(GetLength(GetValue(txidParts, 1)), 1)) {
|
||
address = GetValue(txidParts, 1)
|
||
}
|
||
}
|
||
}
|
||
txid = GetValue(txidParts, 0)
|
||
}
|
||
var typeVar interface{} = Ternary(IsTrue((IsEqual(txid, nil))), "withdrawal", "deposit")
|
||
var rawStatus interface{} = this.SafeString(transaction, "status")
|
||
var fee interface{} = nil
|
||
var feeCost interface{} = this.SafeString(transaction, "fee")
|
||
if IsTrue(!IsEqual(feeCost, nil)) {
|
||
var rate interface{} = nil
|
||
if IsTrue(!IsEqual(amount, nil)) {
|
||
rate = Precise.StringDiv(feeCost, amount)
|
||
}
|
||
fee = map[string]interface{} {
|
||
"cost": this.ParseNumber(feeCost),
|
||
"rate": this.ParseNumber(rate),
|
||
"currency": code,
|
||
}
|
||
}
|
||
var timestamp interface{} = this.SafeInteger2(transaction, "createdAt", "createAt")
|
||
var updated interface{} = this.SafeInteger(transaction, "updatedAt")
|
||
var isV1 interface{} = !IsTrue((InOp(transaction, "createdAt")))
|
||
// if it's a v1 structure
|
||
if IsTrue(isV1) {
|
||
typeVar = Ternary(IsTrue((InOp(transaction, "address"))), "withdrawal", "deposit")
|
||
if IsTrue(!IsEqual(timestamp, nil)) {
|
||
timestamp = Multiply(timestamp, 1000)
|
||
}
|
||
if IsTrue(!IsEqual(updated, nil)) {
|
||
updated = Multiply(updated, 1000)
|
||
}
|
||
}
|
||
var internal interface{} = this.SafeBool(transaction, "isInner")
|
||
var tag interface{} = this.SafeString(transaction, "memo")
|
||
return map[string]interface{} {
|
||
"info": transaction,
|
||
"id": this.SafeString2(transaction, "id", "withdrawalId"),
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"network": this.NetworkIdToCode(this.SafeString(transaction, "chain")),
|
||
"address": address,
|
||
"addressTo": address,
|
||
"addressFrom": nil,
|
||
"tag": tag,
|
||
"tagTo": tag,
|
||
"tagFrom": nil,
|
||
"currency": code,
|
||
"amount": this.ParseNumber(amount),
|
||
"txid": txid,
|
||
"type": typeVar,
|
||
"status": this.ParseTransactionStatus(rawStatus),
|
||
"comment": this.SafeString(transaction, "remark"),
|
||
"internal": internal,
|
||
"fee": fee,
|
||
"updated": updated,
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchDeposits
|
||
* @description fetch all deposits made to an account
|
||
* @see https://www.kucoin.com/docs/rest/funding/deposit/get-deposit-list
|
||
* @see https://www.kucoin.com/docs/rest/funding/deposit/get-v1-historical-deposits-list
|
||
* @param {string} code unified currency code
|
||
* @param {int} [since] the earliest time in ms to fetch deposits for
|
||
* @param {int} [limit] the maximum number of deposits structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {int} [params.until] the latest time in ms to fetch entries for
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
||
*/
|
||
func (this *kucoin) FetchDeposits(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
code := GetArg(optionalArgs, 0, nil)
|
||
_ = code
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes37128 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes37128)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchDeposits", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes371619 := (<-this.FetchPaginatedCallDynamic("fetchDeposits", code, since, limit, params))
|
||
PanicOnError(retRes371619)
|
||
ch <- retRes371619
|
||
return nil
|
||
}
|
||
var request interface{} = map[string]interface{} {}
|
||
var currency interface{} = nil
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
AddElementToObject(request, "currency", GetValue(currency, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "pageSize", limit)
|
||
}
|
||
requestparamsVariable := this.HandleUntilOption("endAt", request, params);
|
||
request = GetValue(requestparamsVariable,0);
|
||
params = GetValue(requestparamsVariable,1)
|
||
var response interface{} = nil
|
||
if IsTrue(IsTrue(!IsEqual(since, nil)) && IsTrue(IsLessThan(since, 1550448000000))) {
|
||
// if since is earlier than 2019-02-18T00:00:00Z
|
||
AddElementToObject(request, "startAt", this.ParseToInt(Divide(since, 1000)))
|
||
|
||
response = (<-this.PrivateGetHistDeposits(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startAt", since)
|
||
}
|
||
|
||
response = (<-this.PrivateGetDeposits(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "currentPage": 1,
|
||
// "pageSize": 5,
|
||
// "totalNum": 2,
|
||
// "totalPage": 1,
|
||
// "items": [
|
||
// //--------------------------------------------------
|
||
// // version 2 deposit response structure
|
||
// {
|
||
// "address": "0x5f047b29041bcfdbf0e4478cdfa753a336ba6989",
|
||
// "memo": "5c247c8a03aa677cea2a251d",
|
||
// "amount": 1,
|
||
// "fee": 0.0001,
|
||
// "currency": "KCS",
|
||
// "isInner": false,
|
||
// "walletTxId": "5bbb57386d99522d9f954c5a@test004",
|
||
// "status": "SUCCESS",
|
||
// "createdAt": 1544178843000,
|
||
// "updatedAt": 1544178891000
|
||
// "remark":"foobar"
|
||
// },
|
||
// //--------------------------------------------------
|
||
// // version 1 (historical) deposit response structure
|
||
// {
|
||
// "currency": "BTC",
|
||
// "createAt": 1528536998,
|
||
// "amount": "0.03266638",
|
||
// "walletTxId": "55c643bc2c68d6f17266383ac1be9e454038864b929ae7cee0bc408cc5c869e8@12ffGWmMMD1zA1WbFm7Ho3JZ1w6NYXjpFk@234",
|
||
// "isInner": false,
|
||
// "status": "SUCCESS",
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var items interface{} = this.SafeList(data, "items", []interface{}{})
|
||
|
||
ch <- this.ParseTransactions(items, currency, since, limit, map[string]interface{} {
|
||
"type": "deposit",
|
||
})
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchWithdrawals
|
||
* @description fetch all withdrawals made from an account
|
||
* @see https://www.kucoin.com/docs/rest/funding/withdrawals/get-withdrawals-list
|
||
* @see https://www.kucoin.com/docs/rest/funding/withdrawals/get-v1-historical-withdrawals-list
|
||
* @param {string} code unified currency code
|
||
* @param {int} [since] the earliest time in ms to fetch withdrawals for
|
||
* @param {int} [limit] the maximum number of withdrawals structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {int} [params.until] the latest time in ms to fetch entries for
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
||
*/
|
||
func (this *kucoin) FetchWithdrawals(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
code := GetArg(optionalArgs, 0, nil)
|
||
_ = code
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes37978 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes37978)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchWithdrawals", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes380119 := (<-this.FetchPaginatedCallDynamic("fetchWithdrawals", code, since, limit, params))
|
||
PanicOnError(retRes380119)
|
||
ch <- retRes380119
|
||
return nil
|
||
}
|
||
var request interface{} = map[string]interface{} {}
|
||
var currency interface{} = nil
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
AddElementToObject(request, "currency", GetValue(currency, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "pageSize", limit)
|
||
}
|
||
requestparamsVariable := this.HandleUntilOption("endAt", request, params);
|
||
request = GetValue(requestparamsVariable,0);
|
||
params = GetValue(requestparamsVariable,1)
|
||
var response interface{} = nil
|
||
if IsTrue(IsTrue(!IsEqual(since, nil)) && IsTrue(IsLessThan(since, 1550448000000))) {
|
||
// if since is earlier than 2019-02-18T00:00:00Z
|
||
AddElementToObject(request, "startAt", this.ParseToInt(Divide(since, 1000)))
|
||
|
||
response = (<-this.PrivateGetHistWithdrawals(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startAt", since)
|
||
}
|
||
|
||
response = (<-this.PrivateGetWithdrawals(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "currentPage": 1,
|
||
// "pageSize": 5,
|
||
// "totalNum": 2,
|
||
// "totalPage": 1,
|
||
// "items": [
|
||
// //--------------------------------------------------
|
||
// // version 2 withdrawal response structure
|
||
// {
|
||
// "id": "5c2dc64e03aa675aa263f1ac",
|
||
// "address": "0x5bedb060b8eb8d823e2414d82acce78d38be7fe9",
|
||
// "memo": "",
|
||
// "currency": "ETH",
|
||
// "amount": 1.0000000,
|
||
// "fee": 0.0100000,
|
||
// "walletTxId": "3e2414d82acce78d38be7fe9",
|
||
// "isInner": false,
|
||
// "status": "FAILURE",
|
||
// "createdAt": 1546503758000,
|
||
// "updatedAt": 1546504603000
|
||
// },
|
||
// //--------------------------------------------------
|
||
// // version 1 (historical) withdrawal response structure
|
||
// {
|
||
// "currency": "BTC",
|
||
// "createAt": 1526723468,
|
||
// "amount": "0.534",
|
||
// "address": "33xW37ZSW4tQvg443Pc7NLCAs167Yc2XUV",
|
||
// "walletTxId": "aeacea864c020acf58e51606169240e96774838dcd4f7ce48acf38e3651323f4",
|
||
// "isInner": false,
|
||
// "status": "SUCCESS"
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var items interface{} = this.SafeList(data, "items", []interface{}{})
|
||
|
||
ch <- this.ParseTransactions(items, currency, since, limit, map[string]interface{} {
|
||
"type": "withdrawal",
|
||
})
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseBalanceHelper(entry interface{}) interface{} {
|
||
var account interface{} = this.Account()
|
||
AddElementToObject(account, "used", this.SafeString2(entry, "holdBalance", "hold"))
|
||
AddElementToObject(account, "free", this.SafeString2(entry, "availableBalance", "available"))
|
||
AddElementToObject(account, "total", this.SafeString2(entry, "totalBalance", "total"))
|
||
var debt interface{} = this.SafeString(entry, "liability")
|
||
var interest interface{} = this.SafeString(entry, "interest")
|
||
AddElementToObject(account, "debt", Precise.StringAdd(debt, interest))
|
||
return account
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchBalance
|
||
* @description query for balance and get the amount of funds available for trading or funds locked in orders
|
||
* @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-list-spot-margin-trade_hf
|
||
* @see https://www.kucoin.com/docs/rest/funding/funding-overview/get-account-detail-margin
|
||
* @see https://www.kucoin.com/docs/rest/funding/funding-overview/get-account-detail-isolated-margin
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {object} [params.marginMode] 'cross' or 'isolated', margin type for fetching margin balance
|
||
* @param {object} [params.type] extra parameters specific to the exchange API endpoint
|
||
* @param {object} [params.hf] *default if false* if true, the result includes the balance of the high frequency account
|
||
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
|
||
*/
|
||
func (this *kucoin) FetchBalance(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes38938 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes38938)
|
||
var code interface{} = this.SafeString(params, "code")
|
||
var currency interface{} = nil
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
}
|
||
var defaultType interface{} = this.SafeString2(this.Options, "fetchBalance", "defaultType", "spot")
|
||
var requestedType interface{} = this.SafeString(params, "type", defaultType)
|
||
var accountsByType interface{} = this.SafeDict(this.Options, "accountsByType")
|
||
var typeVar interface{} = this.SafeString(accountsByType, requestedType, requestedType)
|
||
params = this.Omit(params, "type")
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
if IsTrue(IsTrue(hf) && IsTrue((!IsEqual(typeVar, "main")))) {
|
||
typeVar = "trade_hf"
|
||
}
|
||
marginModequeryVariable := this.HandleMarginModeAndParams("fetchBalance", params);
|
||
marginMode := GetValue(marginModequeryVariable,0);
|
||
query := GetValue(marginModequeryVariable,1)
|
||
var response interface{} = nil
|
||
var request interface{} = map[string]interface{} {}
|
||
var isolated interface{} = IsTrue((IsEqual(marginMode, "isolated"))) || IsTrue((IsEqual(typeVar, "isolated")))
|
||
var cross interface{} = IsTrue((IsEqual(marginMode, "cross"))) || IsTrue((IsEqual(typeVar, "margin")))
|
||
if IsTrue(isolated) {
|
||
if IsTrue(!IsEqual(currency, nil)) {
|
||
AddElementToObject(request, "balanceCurrency", GetValue(currency, "id"))
|
||
}
|
||
|
||
response = (<-this.PrivateGetIsolatedAccounts(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
} else if IsTrue(cross) {
|
||
|
||
response = (<-this.PrivateGetMarginAccount(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
} else {
|
||
if IsTrue(!IsEqual(currency, nil)) {
|
||
AddElementToObject(request, "currency", GetValue(currency, "id"))
|
||
}
|
||
AddElementToObject(request, "type", typeVar)
|
||
|
||
response = (<-this.PrivateGetAccounts(this.Extend(request, query)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// Spot
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": [
|
||
// {
|
||
// "balance": "0.00009788",
|
||
// "available": "0.00009788",
|
||
// "holds": "0",
|
||
// "currency": "BTC",
|
||
// "id": "5c6a4fd399a1d81c4f9cc4d0",
|
||
// "type": "trade",
|
||
// },
|
||
// ]
|
||
// }
|
||
//
|
||
// Cross
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "debtRatio": "0",
|
||
// "accounts": [
|
||
// {
|
||
// "currency": "USDT",
|
||
// "totalBalance": "5",
|
||
// "availableBalance": "5",
|
||
// "holdBalance": "0",
|
||
// "liability": "0",
|
||
// "maxBorrowSize": "20"
|
||
// },
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
// Isolated
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "totalAssetOfQuoteCurrency": "0",
|
||
// "totalLiabilityOfQuoteCurrency": "0",
|
||
// "timestamp": 1712085661155,
|
||
// "assets": [
|
||
// {
|
||
// "symbol": "MANA-USDT",
|
||
// "status": "EFFECTIVE",
|
||
// "debtRatio": "0",
|
||
// "baseAsset": {
|
||
// "currency": "MANA",
|
||
// "borrowEnabled": true,
|
||
// "transferInEnabled": true,
|
||
// "total": "0",
|
||
// "hold": "0",
|
||
// "available": "0",
|
||
// "liability": "0",
|
||
// "interest": "0",
|
||
// "maxBorrowSize": "0"
|
||
// },
|
||
// "quoteAsset": {
|
||
// "currency": "USDT",
|
||
// "borrowEnabled": true,
|
||
// "transferInEnabled": true,
|
||
// "total": "0",
|
||
// "hold": "0",
|
||
// "available": "0",
|
||
// "liability": "0",
|
||
// "interest": "0",
|
||
// "maxBorrowSize": "0"
|
||
// }
|
||
// },
|
||
// ...
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = nil
|
||
var result interface{} = map[string]interface{} {
|
||
"info": response,
|
||
"timestamp": nil,
|
||
"datetime": nil,
|
||
}
|
||
if IsTrue(isolated) {
|
||
data = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var assets interface{} = this.SafeValue(data, "assets", data)
|
||
for i := 0; IsLessThan(i, GetArrayLength(assets)); i++ {
|
||
var entry interface{} = GetValue(assets, i)
|
||
var marketId interface{} = this.SafeString(entry, "symbol")
|
||
var symbol interface{} = this.SafeSymbol(marketId, nil, "_")
|
||
var base interface{} = this.SafeDict(entry, "baseAsset", map[string]interface{} {})
|
||
var quote interface{} = this.SafeDict(entry, "quoteAsset", map[string]interface{} {})
|
||
var baseCode interface{} = this.SafeCurrencyCode(this.SafeString(base, "currency"))
|
||
var quoteCode interface{} = this.SafeCurrencyCode(this.SafeString(quote, "currency"))
|
||
var subResult interface{} = map[string]interface{} {}
|
||
AddElementToObject(subResult, baseCode, this.ParseBalanceHelper(base))
|
||
AddElementToObject(subResult, quoteCode, this.ParseBalanceHelper(quote))
|
||
AddElementToObject(result, symbol, this.SafeBalance(subResult))
|
||
}
|
||
} else if IsTrue(cross) {
|
||
data = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var accounts interface{} = this.SafeList(data, "accounts", []interface{}{})
|
||
for i := 0; IsLessThan(i, GetArrayLength(accounts)); i++ {
|
||
var balance interface{} = GetValue(accounts, i)
|
||
var currencyId interface{} = this.SafeString(balance, "currency")
|
||
var codeInner interface{} = this.SafeCurrencyCode(currencyId)
|
||
AddElementToObject(result, codeInner, this.ParseBalanceHelper(balance))
|
||
}
|
||
} else {
|
||
data = this.SafeList(response, "data", []interface{}{})
|
||
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
|
||
var balance interface{} = GetValue(data, i)
|
||
var balanceType interface{} = this.SafeString(balance, "type")
|
||
if IsTrue(IsEqual(balanceType, typeVar)) {
|
||
var currencyId interface{} = this.SafeString(balance, "currency")
|
||
var codeInner2 interface{} = this.SafeCurrencyCode(currencyId)
|
||
var account interface{} = this.Account()
|
||
AddElementToObject(account, "total", this.SafeString(balance, "balance"))
|
||
AddElementToObject(account, "free", this.SafeString(balance, "available"))
|
||
AddElementToObject(account, "used", this.SafeString(balance, "holds"))
|
||
AddElementToObject(result, codeInner2, account)
|
||
}
|
||
}
|
||
}
|
||
var returnType interface{} = result
|
||
if !IsTrue(isolated) {
|
||
returnType = this.SafeBalance(result)
|
||
}
|
||
|
||
ch <- returnType
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#transfer
|
||
* @description transfer currency internally between wallets on the same account
|
||
* @see https://www.kucoin.com/docs/rest/funding/transfer/inner-transfer
|
||
* @see https://docs.kucoin.com/futures/#transfer-funds-to-kucoin-main-account-2
|
||
* @see https://docs.kucoin.com/spot-hf/#internal-funds-transfers-in-high-frequency-trading-accounts
|
||
* @param {string} code unified currency code
|
||
* @param {float} amount amount to transfer
|
||
* @param {string} fromAccount account to transfer from
|
||
* @param {string} toAccount account to transfer to
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
|
||
*/
|
||
func (this *kucoin) Transfer(code interface{}, amount interface{}, fromAccount interface{}, toAccount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes40748 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes40748)
|
||
var currency interface{} = this.Currency(code)
|
||
var requestedAmount interface{} = this.CurrencyToPrecision(code, amount)
|
||
var fromId interface{} = this.ConvertTypeToAccount(fromAccount)
|
||
var toId interface{} = this.ConvertTypeToAccount(toAccount)
|
||
var fromIsolated interface{} = this.InArray(fromId, this.Ids)
|
||
var toIsolated interface{} = this.InArray(toId, this.Ids)
|
||
if IsTrue(IsEqual(fromId, "contract")) {
|
||
if IsTrue(!IsEqual(toId, "main")) {
|
||
panic(ExchangeError(Add(this.Id, " transfer() only supports transferring from futures account to main account")))
|
||
}
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"amount": requestedAmount,
|
||
}
|
||
if !IsTrue((InOp(params, "bizNo"))) {
|
||
// it doesn't like more than 24 characters
|
||
AddElementToObject(request, "bizNo", this.Uuid22())
|
||
}
|
||
|
||
response:= (<-this.FuturesPrivatePostTransferOut(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "applyId": "605a87217dff1500063d485d",
|
||
// "bizNo": "bcd6e5e1291f4905af84dc",
|
||
// "payAccountType": "CONTRACT",
|
||
// "payTag": "DEFAULT",
|
||
// "remark": '',
|
||
// "recAccountType": "MAIN",
|
||
// "recTag": "DEFAULT",
|
||
// "recRemark": '',
|
||
// "recSystem": "KUCOIN",
|
||
// "status": "PROCESSING",
|
||
// "currency": "XBT",
|
||
// "amount": "0.00001",
|
||
// "fee": "0",
|
||
// "sn": "573688685663948",
|
||
// "reason": '',
|
||
// "createdAt": 1616545569000,
|
||
// "updatedAt": 1616545569000
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
|
||
ch <- this.ParseTransfer(data, currency)
|
||
return nil
|
||
} else {
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"amount": requestedAmount,
|
||
}
|
||
if IsTrue(IsTrue(fromIsolated) || IsTrue(toIsolated)) {
|
||
if IsTrue(this.InArray(fromId, this.Ids)) {
|
||
AddElementToObject(request, "fromTag", fromId)
|
||
fromId = "isolated"
|
||
}
|
||
if IsTrue(this.InArray(toId, this.Ids)) {
|
||
AddElementToObject(request, "toTag", toId)
|
||
toId = "isolated"
|
||
}
|
||
}
|
||
AddElementToObject(request, "from", fromId)
|
||
AddElementToObject(request, "to", toId)
|
||
if !IsTrue((InOp(params, "clientOid"))) {
|
||
AddElementToObject(request, "clientOid", this.Uuid())
|
||
}
|
||
|
||
response:= (<-this.PrivatePostAccountsInnerTransfer(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "orderId": "605a6211e657f00006ad0ad6"
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
|
||
ch <- this.ParseTransfer(data, currency)
|
||
return nil
|
||
}
|
||
return nil
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// transfer (spot)
|
||
//
|
||
// {
|
||
// "orderId": "605a6211e657f00006ad0ad6"
|
||
// }
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "msg": "Failed to transfer out. The amount exceeds the upper limit"
|
||
// }
|
||
//
|
||
// transfer (futures)
|
||
//
|
||
// {
|
||
// "applyId": "605a87217dff1500063d485d",
|
||
// "bizNo": "bcd6e5e1291f4905af84dc",
|
||
// "payAccountType": "CONTRACT",
|
||
// "payTag": "DEFAULT",
|
||
// "remark": '',
|
||
// "recAccountType": "MAIN",
|
||
// "recTag": "DEFAULT",
|
||
// "recRemark": '',
|
||
// "recSystem": "KUCOIN",
|
||
// "status": "PROCESSING",
|
||
// "currency": "XBT",
|
||
// "amount": "0.00001",
|
||
// "fee": "0",
|
||
// "sn": "573688685663948",
|
||
// "reason": '',
|
||
// "createdAt": 1616545569000,
|
||
// "updatedAt": 1616545569000
|
||
// }
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
var timestamp interface{} = this.SafeInteger(transfer, "createdAt")
|
||
var currencyId interface{} = this.SafeString(transfer, "currency")
|
||
var rawStatus interface{} = this.SafeString(transfer, "status")
|
||
var accountFromRaw interface{} = this.SafeStringLower(transfer, "payAccountType")
|
||
var accountToRaw interface{} = this.SafeStringLower(transfer, "recAccountType")
|
||
var accountsByType interface{} = this.SafeDict(this.Options, "accountsByType")
|
||
var accountFrom interface{} = this.SafeString(accountsByType, accountFromRaw, accountFromRaw)
|
||
var accountTo interface{} = this.SafeString(accountsByType, accountToRaw, accountToRaw)
|
||
return map[string]interface{} {
|
||
"id": this.SafeString2(transfer, "applyId", "orderId"),
|
||
"currency": this.SafeCurrencyCode(currencyId, currency),
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"amount": this.SafeNumber(transfer, "amount"),
|
||
"fromAccount": accountFrom,
|
||
"toAccount": accountTo,
|
||
"status": this.ParseTransferStatus(rawStatus),
|
||
"info": transfer,
|
||
}
|
||
}
|
||
func (this *kucoin) ParseTransferStatus(status interface{}) interface{} {
|
||
var statuses interface{} = map[string]interface{} {
|
||
"PROCESSING": "pending",
|
||
}
|
||
return this.SafeString(statuses, status, status)
|
||
}
|
||
func (this *kucoin) ParseLedgerEntryType(typeVar interface{}) interface{} {
|
||
var types interface{} = map[string]interface{} {
|
||
"Assets Transferred in After Upgrading": "transfer",
|
||
"Deposit": "transaction",
|
||
"Withdrawal": "transaction",
|
||
"Transfer": "transfer",
|
||
"Trade_Exchange": "trade",
|
||
"KuCoin Bonus": "bonus",
|
||
"Referral Bonus": "referral",
|
||
"Rewards": "bonus",
|
||
"Airdrop/Fork": "airdrop",
|
||
"Other rewards": "bonus",
|
||
"Fee Rebate": "rebate",
|
||
"Buy Crypto": "trade",
|
||
"Sell Crypto": "sell",
|
||
"Public Offering Purchase": "trade",
|
||
"Refunded Fees": "fee",
|
||
"KCS Pay Fees": "fee",
|
||
"Margin Trade": "trade",
|
||
"Loans": "Loans",
|
||
"Instant Exchange": "trade",
|
||
"Sub-account transfer": "transfer",
|
||
"Liquidation Fees": "fee",
|
||
}
|
||
return this.SafeString(types, typeVar, typeVar)
|
||
}
|
||
func (this *kucoin) ParseLedgerEntry(item interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "id": "611a1e7c6a053300067a88d9", //unique key for each ledger entry
|
||
// "currency": "USDT", //Currency
|
||
// "amount": "10.00059547", //The total amount of assets (fees included) involved in assets changes such as transaction, withdrawal and bonus distribution.
|
||
// "fee": "0", //Deposit or withdrawal fee
|
||
// "balance": "0", //Total assets of a currency remaining funds after transaction
|
||
// "accountType": "MAIN", //Account Type
|
||
// "bizType": "Loans Repaid", //business type
|
||
// "direction": "in", //side, in or out
|
||
// "createdAt": 1629101692950, //Creation time
|
||
// "context": "{\"borrowerUserId\":\"601ad03e50dc810006d242ea\",\"loanRepayDetailNo\":\"611a1e7cc913d000066cf7ec\"}" //Business core parameters
|
||
// }
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
var id interface{} = this.SafeString(item, "id")
|
||
var currencyId interface{} = this.SafeString(item, "currency")
|
||
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
|
||
currency = this.SafeCurrency(currencyId, currency)
|
||
var amount interface{} = this.SafeNumber(item, "amount")
|
||
var balanceAfter interface{} = nil
|
||
// const balanceAfter = this.safeNumber (item, 'balance'); only returns zero string
|
||
var bizType interface{} = this.SafeString(item, "bizType")
|
||
var typeVar interface{} = this.ParseLedgerEntryType(bizType)
|
||
var direction interface{} = this.SafeString(item, "direction")
|
||
var timestamp interface{} = this.SafeInteger(item, "createdAt")
|
||
var datetime interface{} = this.Iso8601(timestamp)
|
||
var account interface{} = this.SafeString(item, "accountType") // MAIN, TRADE, MARGIN, or CONTRACT
|
||
var context interface{} = this.SafeString(item, "context") // contains other information about the ledger entry
|
||
//
|
||
// withdrawal transaction
|
||
//
|
||
// "{\"orderId\":\"617bb2d09e7b3b000196dac8\",\"txId\":\"0x79bb9855f86b351a45cab4dc69d78ca09586a94c45dde49475722b98f401b054\"}"
|
||
//
|
||
// deposit to MAIN, trade via MAIN
|
||
//
|
||
// "{\"orderId\":\"617ab9949e7b3b0001948081\",\"txId\":\"0x7a06b16bbd6b03dbc3d96df5683b15229fc35e7184fd7179a5f3a310bd67d1fa@default@0\"}"
|
||
//
|
||
// sell trade
|
||
//
|
||
// "{\"symbol\":\"ETH-USDT\",\"orderId\":\"617adcd1eb3fa20001dd29a1\",\"tradeId\":\"617adcd12e113d2b91222ff9\"}"
|
||
//
|
||
var referenceId interface{} = nil
|
||
if IsTrue(IsTrue(!IsEqual(context, nil)) && IsTrue(!IsEqual(context, ""))) {
|
||
|
||
{ ret__ := func(this *kucoin) (ret_ interface{}) {
|
||
defer func() {
|
||
if e := recover(); e != nil {
|
||
if e == "break" {
|
||
return
|
||
}
|
||
ret_ = func(this *kucoin) interface{} {
|
||
// catch block:
|
||
referenceId = context
|
||
return nil
|
||
}(this)
|
||
}
|
||
}()
|
||
// try block:
|
||
var parsed interface{} = JsonParse(context)
|
||
var orderId interface{} = this.SafeString(parsed, "orderId")
|
||
var tradeId interface{} = this.SafeString(parsed, "tradeId")
|
||
// transactions only have an orderId but for trades we wish to use tradeId
|
||
if IsTrue(!IsEqual(tradeId, nil)) {
|
||
referenceId = tradeId
|
||
} else {
|
||
referenceId = orderId
|
||
}
|
||
return nil
|
||
}(this)
|
||
if ret__ != nil {
|
||
return ret__
|
||
}
|
||
}
|
||
}
|
||
var fee interface{} = nil
|
||
var feeCost interface{} = this.SafeString(item, "fee")
|
||
var feeCurrency interface{} = nil
|
||
if IsTrue(!IsEqual(feeCost, "0")) {
|
||
feeCurrency = code
|
||
fee = map[string]interface{} {
|
||
"cost": this.ParseNumber(feeCost),
|
||
"currency": feeCurrency,
|
||
}
|
||
}
|
||
return this.SafeLedgerEntry(map[string]interface{} {
|
||
"info": item,
|
||
"id": id,
|
||
"direction": direction,
|
||
"account": account,
|
||
"referenceId": referenceId,
|
||
"referenceAccount": account,
|
||
"type": typeVar,
|
||
"currency": code,
|
||
"amount": amount,
|
||
"timestamp": timestamp,
|
||
"datetime": datetime,
|
||
"before": nil,
|
||
"after": balanceAfter,
|
||
"status": nil,
|
||
"fee": fee,
|
||
}, currency)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchLedger
|
||
* @description fetch the history of changes, actions done by the user or operations that altered the balance of the user
|
||
* @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-ledgers-spot-margin
|
||
* @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-ledgers-trade_hf
|
||
* @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-ledgers-margin_hf
|
||
* @param {string} [code] unified currency code, default is undefined
|
||
* @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
|
||
* @param {int} [limit] max number of ledger entries to return, default is undefined
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {boolean} [params.hf] default false, when true will fetch ledger entries for the high frequency trading account
|
||
* @param {int} [params.until] the latest time in ms to fetch entries for
|
||
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
|
||
* @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger}
|
||
*/
|
||
func (this *kucoin) FetchLedger(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
code := GetArg(optionalArgs, 0, nil)
|
||
_ = code
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes43638 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes43638)
|
||
|
||
retRes43648 := (<-this.LoadAccounts())
|
||
PanicOnError(retRes43648)
|
||
var paginate interface{} = false
|
||
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchLedger", "paginate");
|
||
paginate = GetValue(paginateparamsVariable,0);
|
||
params = GetValue(paginateparamsVariable,1)
|
||
var hf interface{} = nil
|
||
hfparamsVariable := this.HandleHfAndParams(params);
|
||
hf = GetValue(hfparamsVariable,0);
|
||
params = GetValue(hfparamsVariable,1)
|
||
if IsTrue(paginate) {
|
||
|
||
retRes437019 := (<-this.FetchPaginatedCallDynamic("fetchLedger", code, since, limit, params))
|
||
PanicOnError(retRes437019)
|
||
ch <- retRes437019
|
||
return nil
|
||
}
|
||
var request interface{} = map[string]interface{} {}
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startAt", since)
|
||
}
|
||
// atm only single currency retrieval is supported
|
||
var currency interface{} = nil
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
AddElementToObject(request, "currency", GetValue(currency, "id"))
|
||
}
|
||
requestparamsVariable := this.HandleUntilOption("endAt", request, params);
|
||
request = GetValue(requestparamsVariable,0);
|
||
params = GetValue(requestparamsVariable,1)
|
||
var marginMode interface{} = nil
|
||
marginModeparamsVariable := this.HandleMarginModeAndParams("fetchLedger", params);
|
||
marginMode = GetValue(marginModeparamsVariable,0);
|
||
params = GetValue(marginModeparamsVariable,1)
|
||
var response interface{} = nil
|
||
if IsTrue(hf) {
|
||
if IsTrue(!IsEqual(marginMode, nil)) {
|
||
|
||
response = (<-this.PrivateGetHfMarginAccountLedgers(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetHfAccountsLedgers(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetAccountsLedgers(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// {
|
||
// "code":"200000",
|
||
// "data":{
|
||
// "currentPage":1,
|
||
// "pageSize":50,
|
||
// "totalNum":1,
|
||
// "totalPage":1,
|
||
// "items":[
|
||
// {
|
||
// "id":"617cc528729f5f0001c03ceb",
|
||
// "currency":"GAS",
|
||
// "amount":"0.00000339",
|
||
// "fee":"0",
|
||
// "balance":"0",
|
||
// "accountType":"MAIN",
|
||
// "bizType":"Distribution",
|
||
// "direction":"in",
|
||
// "createdAt":1635566888183,
|
||
// "context":"{\"orderId\":\"617cc47a1c47ed0001ce3606\",\"description\":\"Holding NEO,distribute GAS(2021/10/30)\"}"
|
||
// }
|
||
// {
|
||
// "id": "611a1e7c6a053300067a88d9",//unique key
|
||
// "currency": "USDT", //Currency
|
||
// "amount": "10.00059547", //Change amount of the funds
|
||
// "fee": "0", //Deposit or withdrawal fee
|
||
// "balance": "0", //Total assets of a currency
|
||
// "accountType": "MAIN", //Account Type
|
||
// "bizType": "Loans Repaid", //business type
|
||
// "direction": "in", //side, in or out
|
||
// "createdAt": 1629101692950, //Creation time
|
||
// "context": "{\"borrowerUserId\":\"601ad03e50dc810006d242ea\",\"loanRepayDetailNo\":\"611a1e7cc913d000066cf7ec\"}"
|
||
// },
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var dataList interface{} = this.SafeList(response, "data")
|
||
if IsTrue(!IsEqual(dataList, nil)) {
|
||
|
||
ch <- this.ParseLedger(dataList, currency, since, limit)
|
||
return nil
|
||
}
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
var items interface{} = this.SafeList(data, "items", []interface{}{})
|
||
|
||
ch <- this.ParseLedger(items, currency, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) CalculateRateLimiterCost(api interface{}, method interface{}, path interface{}, params interface{}, optionalArgs ...interface{}) interface{} {
|
||
config := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = config
|
||
var versions interface{} = this.SafeDict(this.Options, "versions", map[string]interface{} {})
|
||
var apiVersions interface{} = this.SafeDict(versions, api, map[string]interface{} {})
|
||
var methodVersions interface{} = this.SafeDict(apiVersions, method, map[string]interface{} {})
|
||
var defaultVersion interface{} = this.SafeString(methodVersions, path, GetValue(this.Options, "version"))
|
||
var version interface{} = this.SafeString(params, "version", defaultVersion)
|
||
if IsTrue(IsTrue(IsEqual(version, "v3")) && IsTrue((InOp(config, "v3")))) {
|
||
return GetValue(config, "v3")
|
||
} else if IsTrue(IsTrue(IsEqual(version, "v2")) && IsTrue((InOp(config, "v2")))) {
|
||
return GetValue(config, "v2")
|
||
} else if IsTrue(IsTrue(IsEqual(version, "v1")) && IsTrue((InOp(config, "v1")))) {
|
||
return GetValue(config, "v1")
|
||
}
|
||
return this.SafeValue(config, "cost", 1)
|
||
}
|
||
func (this *kucoin) ParseBorrowRate(info interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "tradeId": "62db2dcaff219600012b56cd",
|
||
// "currency": "USDT",
|
||
// "size": "10",
|
||
// "dailyIntRate": "0.00003",
|
||
// "term": 7,
|
||
// "timestamp": 1658531274508488480
|
||
// },
|
||
//
|
||
// {
|
||
// "createdAt": 1697783812257,
|
||
// "currency": "XMR",
|
||
// "interestAmount": "0.1",
|
||
// "dayRatio": "0.001"
|
||
// }
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
var timestampId interface{} = this.SafeString2(info, "createdAt", "timestamp")
|
||
var timestamp interface{} = this.ParseToInt(Slice(timestampId, 0, 13))
|
||
var currencyId interface{} = this.SafeString(info, "currency")
|
||
return map[string]interface{} {
|
||
"currency": this.SafeCurrencyCode(currencyId, currency),
|
||
"rate": this.SafeNumber2(info, "dailyIntRate", "dayRatio"),
|
||
"period": 86400000,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"info": info,
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchBorrowInterest
|
||
* @description fetch the interest owed by the user for borrowing currency for margin trading
|
||
* @see https://docs.kucoin.com/#get-repay-record
|
||
* @see https://docs.kucoin.com/#query-isolated-margin-account-info
|
||
* @param {string} [code] unified currency code
|
||
* @param {string} [symbol] unified market symbol, required for isolated margin
|
||
* @param {int} [since] the earliest time in ms to fetch borrrow interest for
|
||
* @param {int} [limit] the maximum number of structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.marginMode] 'cross' or 'isolated' default is 'cross'
|
||
* @returns {object[]} a list of [borrow interest structures]{@link https://docs.ccxt.com/#/?id=borrow-interest-structure}
|
||
*/
|
||
func (this *kucoin) FetchBorrowInterest(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
code := GetArg(optionalArgs, 0, nil)
|
||
_ = code
|
||
symbol := GetArg(optionalArgs, 1, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 2, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 3, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 4, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes45098 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes45098)
|
||
var marginMode interface{} = nil
|
||
marginModeparamsVariable := this.HandleMarginModeAndParams("fetchBorrowInterest", params, "cross");
|
||
marginMode = GetValue(marginModeparamsVariable,0);
|
||
params = GetValue(marginModeparamsVariable,1)
|
||
var request interface{} = map[string]interface{} {}
|
||
var currency interface{} = nil
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
if IsTrue(IsEqual(marginMode, "isolated")) {
|
||
AddElementToObject(request, "balanceCurrency", GetValue(currency, "id"))
|
||
} else {
|
||
AddElementToObject(request, "quoteCurrency", GetValue(currency, "id"))
|
||
}
|
||
}
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
}
|
||
var response interface{} = nil
|
||
if IsTrue(IsEqual(marginMode, "isolated")) {
|
||
|
||
response = (<-this.PrivateGetIsolatedAccounts(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.PrivateGetMarginAccounts(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// Cross
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "totalAssetOfQuoteCurrency": "0",
|
||
// "totalLiabilityOfQuoteCurrency": "0",
|
||
// "debtRatio": "0",
|
||
// "status": "EFFECTIVE",
|
||
// "accounts": [
|
||
// {
|
||
// "currency": "1INCH",
|
||
// "total": "0",
|
||
// "available": "0",
|
||
// "hold": "0",
|
||
// "liability": "0",
|
||
// "maxBorrowSize": "0",
|
||
// "borrowEnabled": true,
|
||
// "transferInEnabled": true
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
// Isolated
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "totalConversionBalance": "0.02138647",
|
||
// "liabilityConversionBalance": "0.01480001",
|
||
// "assets": [
|
||
// {
|
||
// "symbol": "MANA-USDT",
|
||
// "debtRatio": "0",
|
||
// "status": "BORROW",
|
||
// "baseAsset": {
|
||
// "currency": "MANA",
|
||
// "borrowEnabled": true,
|
||
// "repayEnabled": true,
|
||
// "transferEnabled": true,
|
||
// "borrowed": "0",
|
||
// "totalAsset": "0",
|
||
// "available": "0",
|
||
// "hold": "0",
|
||
// "maxBorrowSize": "1000"
|
||
// },
|
||
// "quoteAsset": {
|
||
// "currency": "USDT",
|
||
// "borrowEnabled": true,
|
||
// "repayEnabled": true,
|
||
// "transferEnabled": true,
|
||
// "borrowed": "0",
|
||
// "totalAsset": "0",
|
||
// "available": "0",
|
||
// "hold": "0",
|
||
// "maxBorrowSize": "50000"
|
||
// }
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
var assets interface{} = Ternary(IsTrue((IsEqual(marginMode, "isolated"))), this.SafeList(data, "assets", []interface{}{}), this.SafeList(data, "accounts", []interface{}{}))
|
||
var interest interface{} = this.ParseBorrowInterests(assets, market)
|
||
var filteredByCurrency interface{} = this.FilterByCurrencySinceLimit(interest, code, since, limit)
|
||
|
||
ch <- this.FilterBySymbolSinceLimit(filteredByCurrency, symbol, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseBorrowInterest(info interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// Cross
|
||
//
|
||
// {
|
||
// "currency": "1INCH",
|
||
// "total": "0",
|
||
// "available": "0",
|
||
// "hold": "0",
|
||
// "liability": "0",
|
||
// "maxBorrowSize": "0",
|
||
// "borrowEnabled": true,
|
||
// "transferInEnabled": true
|
||
// }
|
||
//
|
||
// Isolated
|
||
//
|
||
// {
|
||
// "symbol": "MANA-USDT",
|
||
// "debtRatio": "0",
|
||
// "status": "BORROW",
|
||
// "baseAsset": {
|
||
// "currency": "MANA",
|
||
// "borrowEnabled": true,
|
||
// "repayEnabled": true,
|
||
// "transferEnabled": true,
|
||
// "borrowed": "0",
|
||
// "totalAsset": "0",
|
||
// "available": "0",
|
||
// "hold": "0",
|
||
// "maxBorrowSize": "1000"
|
||
// },
|
||
// "quoteAsset": {
|
||
// "currency": "USDT",
|
||
// "borrowEnabled": true,
|
||
// "repayEnabled": true,
|
||
// "transferEnabled": true,
|
||
// "borrowed": "0",
|
||
// "totalAsset": "0",
|
||
// "available": "0",
|
||
// "hold": "0",
|
||
// "maxBorrowSize": "50000"
|
||
// }
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(info, "symbol")
|
||
var marginMode interface{} = Ternary(IsTrue((IsEqual(marketId, nil))), "cross", "isolated")
|
||
market = this.SafeMarket(marketId, market)
|
||
var symbol interface{} = this.SafeString(market, "symbol")
|
||
var timestamp interface{} = this.SafeInteger(info, "createdAt")
|
||
var isolatedBase interface{} = this.SafeDict(info, "baseAsset", map[string]interface{} {})
|
||
var amountBorrowed interface{} = nil
|
||
var interest interface{} = nil
|
||
var currencyId interface{} = nil
|
||
if IsTrue(IsEqual(marginMode, "isolated")) {
|
||
amountBorrowed = this.SafeNumber(isolatedBase, "liability")
|
||
interest = this.SafeNumber(isolatedBase, "interest")
|
||
currencyId = this.SafeString(isolatedBase, "currency")
|
||
} else {
|
||
amountBorrowed = this.SafeNumber(info, "liability")
|
||
interest = this.SafeNumber(info, "accruedInterest")
|
||
currencyId = this.SafeString(info, "currency")
|
||
}
|
||
return map[string]interface{} {
|
||
"info": info,
|
||
"symbol": symbol,
|
||
"currency": this.SafeCurrencyCode(currencyId),
|
||
"interest": interest,
|
||
"interestRate": this.SafeNumber(info, "dailyIntRate"),
|
||
"amountBorrowed": amountBorrowed,
|
||
"marginMode": marginMode,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchBorrowRateHistories
|
||
* @description retrieves a history of a multiple currencies borrow interest rate at specific time slots, returns all currencies if no symbols passed, default is undefined
|
||
* @see https://www.kucoin.com/docs/rest/margin-trading/margin-trading-v3-/get-cross-isolated-margin-interest-records
|
||
* @param {string[]|undefined} codes list of unified currency codes, default is undefined
|
||
* @param {int} [since] timestamp in ms of the earliest borrowRate, default is undefined
|
||
* @param {int} [limit] max number of borrow rate prices to return, default is undefined
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.marginMode] 'cross' or 'isolated' default is 'cross'
|
||
* @param {int} [params.until] the latest time in ms to fetch entries for
|
||
* @returns {object} a dictionary of [borrow rate structures]{@link https://docs.ccxt.com/#/?id=borrow-rate-structure} indexed by the market symbol
|
||
*/
|
||
func (this *kucoin) FetchBorrowRateHistories(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
codes := GetArg(optionalArgs, 0, nil)
|
||
_ = codes
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes46938 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes46938)
|
||
var marginResult interface{} = this.HandleMarginModeAndParams("fetchBorrowRateHistories", params)
|
||
var marginMode interface{} = this.SafeString(marginResult, 0, "cross")
|
||
var isIsolated interface{} = (IsEqual(marginMode, "isolated")) // true-isolated, false-cross
|
||
var request interface{} = map[string]interface{} {
|
||
"isIsolated": isIsolated,
|
||
}
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startTime", since)
|
||
}
|
||
requestparamsVariable := this.HandleUntilOption("endTime", request, params);
|
||
request = GetValue(requestparamsVariable,0);
|
||
params = GetValue(requestparamsVariable,1)
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "pageSize", limit) // default:50, min:10, max:500
|
||
}
|
||
|
||
response:= (<-this.PrivateGetMarginInterest(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "timestamp": 1710829939673,
|
||
// "currentPage": 1,
|
||
// "pageSize": 50,
|
||
// "totalNum": 0,
|
||
// "totalPage": 0,
|
||
// "items": [
|
||
// {
|
||
// "createdAt": 1697783812257,
|
||
// "currency": "XMR",
|
||
// "interestAmount": "0.1",
|
||
// "dayRatio": "0.001"
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
var rows interface{} = this.SafeList(data, "items", []interface{}{})
|
||
|
||
ch <- this.ParseBorrowRateHistories(rows, codes, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchBorrowRateHistory
|
||
* @description retrieves a history of a currencies borrow interest rate at specific time slots
|
||
* @see https://www.kucoin.com/docs/rest/margin-trading/margin-trading-v3-/get-cross-isolated-margin-interest-records
|
||
* @param {string} code unified currency code
|
||
* @param {int} [since] timestamp for the earliest borrow rate
|
||
* @param {int} [limit] the maximum number of [borrow rate structures]{@link https://docs.ccxt.com/#/?id=borrow-rate-structure} to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.marginMode] 'cross' or 'isolated' default is 'cross'
|
||
* @param {int} [params.until] the latest time in ms to fetch entries for
|
||
* @returns {object[]} an array of [borrow rate structures]{@link https://docs.ccxt.com/#/?id=borrow-rate-structure}
|
||
*/
|
||
func (this *kucoin) FetchBorrowRateHistory(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
since := GetArg(optionalArgs, 0, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 1, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes47478 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes47478)
|
||
var marginResult interface{} = this.HandleMarginModeAndParams("fetchBorrowRateHistories", params)
|
||
var marginMode interface{} = this.SafeString(marginResult, 0, "cross")
|
||
var isIsolated interface{} = (IsEqual(marginMode, "isolated")) // true-isolated, false-cross
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"isIsolated": isIsolated,
|
||
"currency": GetValue(currency, "id"),
|
||
}
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
AddElementToObject(request, "startTime", since)
|
||
}
|
||
requestparamsVariable := this.HandleUntilOption("endTime", request, params);
|
||
request = GetValue(requestparamsVariable,0);
|
||
params = GetValue(requestparamsVariable,1)
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "pageSize", limit) // default:50, min:10, max:500
|
||
}
|
||
|
||
response:= (<-this.PrivateGetMarginInterest(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "code": "200000",
|
||
// "data": {
|
||
// "timestamp": 1710829939673,
|
||
// "currentPage": 1,
|
||
// "pageSize": 50,
|
||
// "totalNum": 0,
|
||
// "totalPage": 0,
|
||
// "items": [
|
||
// {
|
||
// "createdAt": 1697783812257,
|
||
// "currency": "XMR",
|
||
// "interestAmount": "0.1",
|
||
// "dayRatio": "0.001"
|
||
// }
|
||
// ]
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data")
|
||
var rows interface{} = this.SafeList(data, "items", []interface{}{})
|
||
|
||
ch <- this.ParseBorrowRateHistory(rows, code, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseBorrowRateHistories(response interface{}, codes interface{}, since interface{}, limit interface{}) interface{} {
|
||
//
|
||
// [
|
||
// {
|
||
// "createdAt": 1697783812257,
|
||
// "currency": "XMR",
|
||
// "interestAmount": "0.1",
|
||
// "dayRatio": "0.001"
|
||
// }
|
||
// ]
|
||
//
|
||
var borrowRateHistories interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
|
||
var item interface{} = GetValue(response, i)
|
||
var code interface{} = this.SafeCurrencyCode(this.SafeString(item, "currency"))
|
||
if IsTrue(IsTrue(IsEqual(codes, nil)) || IsTrue(this.InArray(code, codes))) {
|
||
if !IsTrue((InOp(borrowRateHistories, code))) {
|
||
AddElementToObject(borrowRateHistories, code, []interface{}{})
|
||
}
|
||
var borrowRateStructure interface{} = this.ParseBorrowRate(item)
|
||
var borrowRateHistoriesCode interface{} = GetValue(borrowRateHistories, code)
|
||
AppendToArray(&borrowRateHistoriesCode,borrowRateStructure)
|
||
}
|
||
}
|
||
var keys interface{} = ObjectKeys(borrowRateHistories)
|
||
for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
|
||
var code interface{} = GetValue(keys, i)
|
||
AddElementToObject(borrowRateHistories, code, this.FilterByCurrencySinceLimit(GetValue(borrowRateHistories, code), code, since, limit))
|
||
}
|
||
return borrowRateHistories
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#borrowCrossMargin
|
||
* @description create a loan to borrow margin
|
||
* @see https://docs.kucoin.com/#1-margin-borrowing
|
||
* @param {string} code unified currency code of the currency to borrow
|
||
* @param {float} amount the amount to borrow
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoints
|
||
* @param {string} [params.timeInForce] either IOC or FOK
|
||
* @returns {object} a [margin loan structure]{@link https://docs.ccxt.com/#/?id=margin-loan-structure}
|
||
*/
|
||
func (this *kucoin) BorrowCrossMargin(code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes48338 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes48338)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"size": this.CurrencyToPrecision(code, amount),
|
||
"timeInForce": "FOK",
|
||
}
|
||
|
||
response:= (<-this.PrivatePostMarginBorrow(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "success": true,
|
||
// "code": "200",
|
||
// "msg": "success",
|
||
// "retry": false,
|
||
// "data": {
|
||
// "orderNo": "5da6dba0f943c0c81f5d5db5",
|
||
// "actualSize": 10
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseMarginLoan(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#borrowIsolatedMargin
|
||
* @description create a loan to borrow margin
|
||
* @see https://docs.kucoin.com/#1-margin-borrowing
|
||
* @param {string} symbol unified market symbol, required for isolated margin
|
||
* @param {string} code unified currency code of the currency to borrow
|
||
* @param {float} amount the amount to borrow
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoints
|
||
* @param {string} [params.timeInForce] either IOC or FOK
|
||
* @returns {object} a [margin loan structure]{@link https://docs.ccxt.com/#/?id=margin-loan-structure}
|
||
*/
|
||
func (this *kucoin) BorrowIsolatedMargin(symbol interface{}, code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes48708 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes48708)
|
||
var market interface{} = this.Market(symbol)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"size": this.CurrencyToPrecision(code, amount),
|
||
"symbol": GetValue(market, "id"),
|
||
"timeInForce": "FOK",
|
||
"isIsolated": true,
|
||
}
|
||
|
||
response:= (<-this.PrivatePostMarginBorrow(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "success": true,
|
||
// "code": "200",
|
||
// "msg": "success",
|
||
// "retry": false,
|
||
// "data": {
|
||
// "orderNo": "5da6dba0f943c0c81f5d5db5",
|
||
// "actualSize": 10
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseMarginLoan(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#repayCrossMargin
|
||
* @description repay borrowed margin and interest
|
||
* @see https://docs.kucoin.com/#2-repayment
|
||
* @param {string} code unified currency code of the currency to repay
|
||
* @param {float} amount the amount to repay
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoints
|
||
* @returns {object} a [margin loan structure]{@link https://docs.ccxt.com/#/?id=margin-loan-structure}
|
||
*/
|
||
func (this *kucoin) RepayCrossMargin(code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes49088 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes49088)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"size": this.CurrencyToPrecision(code, amount),
|
||
}
|
||
|
||
response:= (<-this.PrivatePostMarginRepay(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "success": true,
|
||
// "code": "200",
|
||
// "msg": "success",
|
||
// "retry": false,
|
||
// "data": {
|
||
// "orderNo": "5da6dba0f943c0c81f5d5db5",
|
||
// "actualSize": 10
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseMarginLoan(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#repayIsolatedMargin
|
||
* @description repay borrowed margin and interest
|
||
* @see https://docs.kucoin.com/#2-repayment
|
||
* @param {string} symbol unified market symbol
|
||
* @param {string} code unified currency code of the currency to repay
|
||
* @param {float} amount the amount to repay
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoints
|
||
* @returns {object} a [margin loan structure]{@link https://docs.ccxt.com/#/?id=margin-loan-structure}
|
||
*/
|
||
func (this *kucoin) RepayIsolatedMargin(symbol interface{}, code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes49438 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes49438)
|
||
var market interface{} = this.Market(symbol)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"currency": GetValue(currency, "id"),
|
||
"size": this.CurrencyToPrecision(code, amount),
|
||
"symbol": GetValue(market, "id"),
|
||
"isIsolated": true,
|
||
}
|
||
|
||
response:= (<-this.PrivatePostMarginRepay(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "success": true,
|
||
// "code": "200",
|
||
// "msg": "success",
|
||
// "retry": false,
|
||
// "data": {
|
||
// "orderNo": "5da6dba0f943c0c81f5d5db5",
|
||
// "actualSize": 10
|
||
// }
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
||
|
||
ch <- this.ParseMarginLoan(data, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) ParseMarginLoan(info interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "orderNo": "5da6dba0f943c0c81f5d5db5",
|
||
// "actualSize": 10
|
||
// }
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
var timestamp interface{} = this.Milliseconds()
|
||
var currencyId interface{} = this.SafeString(info, "currency")
|
||
return map[string]interface{} {
|
||
"id": this.SafeString(info, "orderNo"),
|
||
"currency": this.SafeCurrencyCode(currencyId, currency),
|
||
"amount": this.SafeNumber(info, "actualSize"),
|
||
"symbol": nil,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"info": info,
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#fetchDepositWithdrawFees
|
||
* @description fetch deposit and withdraw fees - *IMPORTANT* use fetchDepositWithdrawFee to get more in-depth info
|
||
* @see https://docs.kucoin.com/#get-currencies
|
||
* @param {string[]|undefined} codes list of unified currency codes
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a list of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure}
|
||
*/
|
||
func (this *kucoin) FetchDepositWithdrawFees(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
codes := GetArg(optionalArgs, 0, nil)
|
||
_ = codes
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes49998 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes49998)
|
||
|
||
response:= (<-this.PublicGetCurrencies(params))
|
||
PanicOnError(response)
|
||
//
|
||
// [
|
||
// {
|
||
// "currency": "CSP",
|
||
// "name": "CSP",
|
||
// "fullName": "Caspian",
|
||
// "precision": 8,
|
||
// "confirms": 12,
|
||
// "contractAddress": "0xa6446d655a0c34bc4f05042ee88170d056cbaf45",
|
||
// "withdrawalMinSize": "2000",
|
||
// "withdrawalMinFee": "1000",
|
||
// "isWithdrawEnabled": true,
|
||
// "isDepositEnabled": true,
|
||
// "isMarginEnabled": false,
|
||
// "isDebitEnabled": false
|
||
// },
|
||
// ]
|
||
//
|
||
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
||
|
||
ch <- this.ParseDepositWithdrawFees(data, codes, "currency")
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name kucoin#setLeverage
|
||
* @description set the level of leverage for a market
|
||
* @see https://www.kucoin.com/docs/rest/margin-trading/margin-trading-v3-/modify-leverage-multiplier
|
||
* @param {int } [leverage] New leverage multiplier. Must be greater than 1 and up to two decimal places, and cannot be less than the user's current debt leverage or greater than the system's maximum leverage
|
||
* @param {string} [symbol] unified market symbol
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} response from the exchange
|
||
*/
|
||
func (this *kucoin) SetLeverage(leverage interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes50348 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes50348)
|
||
var market interface{} = nil
|
||
var marketType interface{} = nil
|
||
marketTypeparamsVariable := this.HandleMarketTypeAndParams("setLeverage", nil, params);
|
||
marketType = GetValue(marketTypeparamsVariable,0);
|
||
params = GetValue(marketTypeparamsVariable,1)
|
||
if IsTrue(IsTrue((!IsEqual(symbol, nil))) || IsTrue(!IsEqual(marketType, "spot"))) {
|
||
market = this.Market(symbol)
|
||
if IsTrue(GetValue(market, "contract")) {
|
||
panic(NotSupported(Add(this.Id, " setLeverage currently supports only spot margin")))
|
||
}
|
||
}
|
||
var marginMode interface{} = nil
|
||
marginModeparamsVariable := this.HandleMarginModeAndParams("setLeverage", params);
|
||
marginMode = GetValue(marginModeparamsVariable,0);
|
||
params = GetValue(marginModeparamsVariable,1)
|
||
if IsTrue(IsEqual(marginMode, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " setLeverage requires a marginMode parameter")))
|
||
}
|
||
var request interface{} = map[string]interface{} {}
|
||
if IsTrue(IsTrue(IsEqual(marginMode, "isolated")) && IsTrue(IsEqual(symbol, nil))) {
|
||
panic(ArgumentsRequired(Add(this.Id, " setLeverage requires a symbol parameter for isolated margin")))
|
||
}
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
||
}
|
||
AddElementToObject(request, "leverage", ToString(leverage))
|
||
AddElementToObject(request, "isIsolated", (IsEqual(marginMode, "isolated")))
|
||
|
||
retRes505815 := (<-this.PrivatePostPositionUpdateUserLeverage(this.Extend(request, params)))
|
||
PanicOnError(retRes505815)
|
||
ch <- retRes505815
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *kucoin) Sign(path interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// the v2 URL is https://openapi-v2.kucoin.com/api/v1/endpoint
|
||
// ↑ ↑
|
||
// ↑ ↑
|
||
//
|
||
api := GetArg(optionalArgs, 0, "public")
|
||
_ = api
|
||
method := GetArg(optionalArgs, 1, "GET")
|
||
_ = method
|
||
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
||
_ = params
|
||
headers := GetArg(optionalArgs, 3, nil)
|
||
_ = headers
|
||
body := GetArg(optionalArgs, 4, nil)
|
||
_ = body
|
||
var versions interface{} = this.SafeDict(this.Options, "versions", map[string]interface{} {})
|
||
var apiVersions interface{} = this.SafeDict(versions, api, map[string]interface{} {})
|
||
var methodVersions interface{} = this.SafeDict(apiVersions, method, map[string]interface{} {})
|
||
var defaultVersion interface{} = this.SafeString(methodVersions, path, GetValue(this.Options, "version"))
|
||
var version interface{} = this.SafeString(params, "version", defaultVersion)
|
||
params = this.Omit(params, "version")
|
||
var endpoint interface{} = Add(Add(Add("/api/", version), "/"), this.ImplodeParams(path, params))
|
||
if IsTrue(IsEqual(api, "webExchange")) {
|
||
endpoint = Add("/", this.ImplodeParams(path, params))
|
||
}
|
||
if IsTrue(IsEqual(api, "earn")) {
|
||
endpoint = Add("/api/v1/", this.ImplodeParams(path, params))
|
||
}
|
||
var query interface{} = this.Omit(params, this.ExtractParams(path))
|
||
var endpart interface{} = ""
|
||
headers = Ternary(IsTrue((!IsEqual(headers, nil))), headers, map[string]interface{} {})
|
||
var url interface{} = GetValue(GetValue(this.Urls, "api"), api)
|
||
if !IsTrue(this.IsEmpty(query)) {
|
||
if IsTrue(IsTrue((IsTrue((IsEqual(method, "GET"))) || IsTrue((IsEqual(method, "DELETE"))))) && IsTrue((!IsEqual(path, "orders/multi-cancel")))) {
|
||
endpoint = Add(endpoint, Add("?", this.Rawencode(query)))
|
||
} else {
|
||
body = this.Json(query)
|
||
endpart = body
|
||
AddElementToObject(headers, "Content-Type", "application/json")
|
||
}
|
||
}
|
||
url = Add(url, endpoint)
|
||
var isFuturePrivate interface{} = (IsEqual(api, "futuresPrivate"))
|
||
var isPrivate interface{} = (IsEqual(api, "private"))
|
||
var isBroker interface{} = (IsEqual(api, "broker"))
|
||
var isEarn interface{} = (IsEqual(api, "earn"))
|
||
if IsTrue(IsTrue(IsTrue(IsTrue(isPrivate) || IsTrue(isFuturePrivate)) || IsTrue(isBroker)) || IsTrue(isEarn)) {
|
||
this.CheckRequiredCredentials()
|
||
var timestamp interface{} = ToString(this.Nonce())
|
||
headers = this.Extend(map[string]interface{} {
|
||
"KC-API-KEY-VERSION": "2",
|
||
"KC-API-KEY": this.ApiKey,
|
||
"KC-API-TIMESTAMP": timestamp,
|
||
}, headers)
|
||
var apiKeyVersion interface{} = this.SafeString(headers, "KC-API-KEY-VERSION")
|
||
if IsTrue(IsEqual(apiKeyVersion, "2")) {
|
||
var passphrase interface{} = this.Hmac(this.Encode(this.Password), this.Encode(this.Secret), sha256, "base64")
|
||
AddElementToObject(headers, "KC-API-PASSPHRASE", passphrase)
|
||
} else {
|
||
AddElementToObject(headers, "KC-API-PASSPHRASE", this.Password)
|
||
}
|
||
var payload interface{} = Add(Add(Add(timestamp, method), endpoint), endpart)
|
||
var signature interface{} = this.Hmac(this.Encode(payload), this.Encode(this.Secret), sha256, "base64")
|
||
AddElementToObject(headers, "KC-API-SIGN", signature)
|
||
var partner interface{} = this.SafeDict(this.Options, "partner", map[string]interface{} {})
|
||
partner = Ternary(IsTrue(isFuturePrivate), this.SafeValue(partner, "future", partner), this.SafeValue(partner, "spot", partner))
|
||
var partnerId interface{} = this.SafeString(partner, "id")
|
||
var partnerSecret interface{} = this.SafeString2(partner, "secret", "key")
|
||
if IsTrue(IsTrue((!IsEqual(partnerId, nil))) && IsTrue((!IsEqual(partnerSecret, nil)))) {
|
||
var partnerPayload interface{} = Add(Add(timestamp, partnerId), this.ApiKey)
|
||
var partnerSignature interface{} = this.Hmac(this.Encode(partnerPayload), this.Encode(partnerSecret), sha256, "base64")
|
||
AddElementToObject(headers, "KC-API-PARTNER-SIGN", partnerSignature)
|
||
AddElementToObject(headers, "KC-API-PARTNER", partnerId)
|
||
AddElementToObject(headers, "KC-API-PARTNER-VERIFY", "true")
|
||
}
|
||
if IsTrue(isBroker) {
|
||
var brokerName interface{} = this.SafeString(partner, "name")
|
||
if IsTrue(!IsEqual(brokerName, nil)) {
|
||
AddElementToObject(headers, "KC-BROKER-NAME", brokerName)
|
||
}
|
||
}
|
||
}
|
||
return map[string]interface{} {
|
||
"url": url,
|
||
"method": method,
|
||
"body": body,
|
||
"headers": headers,
|
||
}
|
||
}
|
||
func (this *kucoin) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
|
||
if !IsTrue(response) {
|
||
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), body, body)
|
||
return nil
|
||
}
|
||
//
|
||
// bad
|
||
// { "code": "400100", "msg": "validation.createOrder.clientOidIsRequired" }
|
||
// good
|
||
// { code: '200000', data: { ... }}
|
||
//
|
||
var errorCode interface{} = this.SafeString(response, "code")
|
||
var message interface{} = this.SafeString2(response, "msg", "data", "")
|
||
var feedback interface{} = Add(Add(this.Id, " "), body)
|
||
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), message, feedback)
|
||
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), errorCode, feedback)
|
||
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), body, feedback)
|
||
if IsTrue(IsTrue(!IsEqual(errorCode, "200000")) && IsTrue(!IsEqual(errorCode, "200"))) {
|
||
panic(ExchangeError(feedback))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
|
||
func (this *kucoin) Init(userConfig map[string]interface{}) {
|
||
this.Exchange = Exchange{}
|
||
this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
|
||
this.Exchange.DerivedExchange = this
|
||
}
|