6754 lines
292 KiB
Go
6754 lines
292 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 bingx struct {
|
|
Exchange
|
|
|
|
}
|
|
|
|
func NewBingxCore() bingx {
|
|
p := bingx{}
|
|
setDefaults(&p)
|
|
return p
|
|
}
|
|
|
|
func (this *bingx) Describe() interface{} {
|
|
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
|
|
"id": "bingx",
|
|
"name": "BingX",
|
|
"countries": []interface{}{"US"},
|
|
"rateLimit": 100,
|
|
"version": "v1",
|
|
"certified": true,
|
|
"pro": true,
|
|
"has": map[string]interface{} {
|
|
"CORS": nil,
|
|
"spot": true,
|
|
"margin": false,
|
|
"swap": true,
|
|
"future": false,
|
|
"option": false,
|
|
"addMargin": true,
|
|
"cancelAllOrders": true,
|
|
"cancelAllOrdersAfter": true,
|
|
"cancelOrder": true,
|
|
"cancelOrders": true,
|
|
"closeAllPositions": true,
|
|
"closePosition": true,
|
|
"createMarketBuyOrderWithCost": true,
|
|
"createMarketOrderWithCost": true,
|
|
"createMarketSellOrderWithCost": true,
|
|
"createOrder": true,
|
|
"createOrders": true,
|
|
"createOrderWithTakeProfitAndStopLoss": true,
|
|
"createStopLossOrder": true,
|
|
"createStopOrder": true,
|
|
"createTakeProfitOrder": true,
|
|
"createTrailingAmountOrder": true,
|
|
"createTrailingPercentOrder": true,
|
|
"createTriggerOrder": true,
|
|
"editOrder": true,
|
|
"fetchBalance": true,
|
|
"fetchCanceledOrders": true,
|
|
"fetchClosedOrders": true,
|
|
"fetchCurrencies": true,
|
|
"fetchDepositAddress": true,
|
|
"fetchDepositAddresses": false,
|
|
"fetchDepositAddressesByNetwork": true,
|
|
"fetchDeposits": true,
|
|
"fetchDepositWithdrawFee": "emulated",
|
|
"fetchDepositWithdrawFees": true,
|
|
"fetchFundingRate": true,
|
|
"fetchFundingRateHistory": true,
|
|
"fetchFundingRates": true,
|
|
"fetchLeverage": true,
|
|
"fetchLiquidations": false,
|
|
"fetchMarginAdjustmentHistory": false,
|
|
"fetchMarginMode": true,
|
|
"fetchMarkets": true,
|
|
"fetchMarkOHLCV": true,
|
|
"fetchMarkPrice": true,
|
|
"fetchMarkPrices": true,
|
|
"fetchMyLiquidations": true,
|
|
"fetchMyTrades": true,
|
|
"fetchOHLCV": true,
|
|
"fetchOpenInterest": true,
|
|
"fetchOpenOrders": true,
|
|
"fetchOrder": true,
|
|
"fetchOrderBook": true,
|
|
"fetchOrders": true,
|
|
"fetchPosition": true,
|
|
"fetchPositionHistory": false,
|
|
"fetchPositionMode": true,
|
|
"fetchPositions": true,
|
|
"fetchPositionsHistory": true,
|
|
"fetchTicker": true,
|
|
"fetchTickers": true,
|
|
"fetchTime": true,
|
|
"fetchTrades": true,
|
|
"fetchTradingFee": true,
|
|
"fetchTransfers": true,
|
|
"fetchWithdrawals": true,
|
|
"reduceMargin": true,
|
|
"sandbox": true,
|
|
"setLeverage": true,
|
|
"setMargin": true,
|
|
"setMarginMode": true,
|
|
"setPositionMode": true,
|
|
"transfer": true,
|
|
},
|
|
"hostname": "bingx.com",
|
|
"urls": map[string]interface{} {
|
|
"logo": "https://github-production-user-asset-6210df.s3.amazonaws.com/1294454/253675376-6983b72e-4999-4549-b177-33b374c195e3.jpg",
|
|
"api": map[string]interface{} {
|
|
"spot": "https://open-api.{hostname}/openApi",
|
|
"swap": "https://open-api.{hostname}/openApi",
|
|
"contract": "https://open-api.{hostname}/openApi",
|
|
"wallets": "https://open-api.{hostname}/openApi",
|
|
"user": "https://open-api.{hostname}/openApi",
|
|
"subAccount": "https://open-api.{hostname}/openApi",
|
|
"account": "https://open-api.{hostname}/openApi",
|
|
"copyTrading": "https://open-api.{hostname}/openApi",
|
|
"cswap": "https://open-api.{hostname}/openApi",
|
|
},
|
|
"test": map[string]interface{} {
|
|
"swap": "https://open-api-vst.{hostname}/openApi",
|
|
},
|
|
"www": "https://bingx.com/",
|
|
"doc": "https://bingx-api.github.io/docs/",
|
|
"referral": "https://bingx.com/invite/OHETOM",
|
|
},
|
|
"fees": map[string]interface{} {
|
|
"tierBased": true,
|
|
"spot": map[string]interface{} {
|
|
"feeSide": "get",
|
|
"maker": this.ParseNumber("0.001"),
|
|
"taker": this.ParseNumber("0.001"),
|
|
},
|
|
"swap": map[string]interface{} {
|
|
"feeSide": "quote",
|
|
"maker": this.ParseNumber("0.0002"),
|
|
"taker": this.ParseNumber("0.0005"),
|
|
},
|
|
},
|
|
"requiredCredentials": map[string]interface{} {
|
|
"apiKey": true,
|
|
"secret": true,
|
|
},
|
|
"api": map[string]interface{} {
|
|
"spot": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"server/time": 1,
|
|
"common/symbols": 1,
|
|
"market/trades": 1,
|
|
"market/depth": 1,
|
|
"market/kline": 1,
|
|
"ticker/24hr": 1,
|
|
"ticker/price": 1,
|
|
"ticker/bookTicker": 1,
|
|
},
|
|
},
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"trade/query": 1,
|
|
"trade/openOrders": 1,
|
|
"trade/historyOrders": 1,
|
|
"trade/myTrades": 2,
|
|
"user/commissionRate": 5,
|
|
"account/balance": 2,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"trade/order": 2,
|
|
"trade/cancel": 2,
|
|
"trade/batchOrders": 5,
|
|
"trade/order/cancelReplace": 5,
|
|
"trade/cancelOrders": 5,
|
|
"trade/cancelOpenOrders": 5,
|
|
"trade/cancelAllAfter": 5,
|
|
},
|
|
},
|
|
},
|
|
"v2": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"market/depth": 1,
|
|
"market/kline": 1,
|
|
},
|
|
},
|
|
},
|
|
"v3": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"get/asset/transfer": 1,
|
|
"asset/transfer": 1,
|
|
"capital/deposit/hisrec": 1,
|
|
"capital/withdraw/history": 1,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"post/asset/transfer": 5,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"swap": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"ticker/price": 1,
|
|
"market/historicalTrades": 1,
|
|
"market/markPriceKlines": 1,
|
|
"trade/multiAssetsRules": 1,
|
|
},
|
|
},
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"positionSide/dual": 5,
|
|
"trade/batchCancelReplace": 5,
|
|
"trade/fullOrder": 2,
|
|
"maintMarginRatio": 2,
|
|
"trade/positionHistory": 2,
|
|
"positionMargin/history": 2,
|
|
"twap/openOrders": 5,
|
|
"twap/historyOrders": 5,
|
|
"twap/orderDetail": 5,
|
|
"trade/assetMode": 5,
|
|
"user/marginAssets": 5,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"trade/cancelReplace": 2,
|
|
"positionSide/dual": 5,
|
|
"trade/batchCancelReplace": 5,
|
|
"trade/closePosition": 2,
|
|
"trade/getVst": 5,
|
|
"twap/order": 5,
|
|
"twap/cancelOrder": 5,
|
|
"trade/assetMode": 5,
|
|
},
|
|
},
|
|
},
|
|
"v2": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"server/time": 1,
|
|
"quote/contracts": 1,
|
|
"quote/price": 1,
|
|
"quote/depth": 1,
|
|
"quote/trades": 1,
|
|
"quote/premiumIndex": 1,
|
|
"quote/fundingRate": 1,
|
|
"quote/klines": 1,
|
|
"quote/openInterest": 1,
|
|
"quote/ticker": 1,
|
|
"quote/bookTicker": 1,
|
|
},
|
|
},
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"user/balance": 2,
|
|
"user/positions": 2,
|
|
"user/income": 2,
|
|
"trade/openOrders": 2,
|
|
"trade/openOrder": 2,
|
|
"trade/order": 2,
|
|
"trade/marginType": 5,
|
|
"trade/leverage": 2,
|
|
"trade/forceOrders": 1,
|
|
"trade/allOrders": 2,
|
|
"trade/allFillOrders": 2,
|
|
"trade/fillHistory": 2,
|
|
"user/income/export": 2,
|
|
"user/commissionRate": 2,
|
|
"quote/bookTicker": 1,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"trade/order": 2,
|
|
"trade/batchOrders": 2,
|
|
"trade/closeAllPositions": 2,
|
|
"trade/cancelAllAfter": 5,
|
|
"trade/marginType": 5,
|
|
"trade/leverage": 5,
|
|
"trade/positionMargin": 5,
|
|
"trade/order/test": 2,
|
|
},
|
|
"delete": map[string]interface{} {
|
|
"trade/order": 2,
|
|
"trade/batchOrders": 2,
|
|
"trade/allOpenOrders": 2,
|
|
},
|
|
},
|
|
},
|
|
"v3": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"quote/klines": 1,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"cswap": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"market/contracts": 1,
|
|
"market/premiumIndex": 1,
|
|
"market/openInterest": 1,
|
|
"market/klines": 1,
|
|
"market/depth": 1,
|
|
"market/ticker": 1,
|
|
},
|
|
},
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"trade/leverage": 2,
|
|
"trade/forceOrders": 2,
|
|
"trade/allFillOrders": 2,
|
|
"trade/openOrders": 2,
|
|
"trade/orderDetail": 2,
|
|
"trade/orderHistory": 2,
|
|
"trade/marginType": 2,
|
|
"user/commissionRate": 2,
|
|
"user/positions": 2,
|
|
"user/balance": 2,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"trade/order": 2,
|
|
"trade/leverage": 2,
|
|
"trade/allOpenOrders": 2,
|
|
"trade/closeAllPositions": 2,
|
|
"trade/marginType": 2,
|
|
"trade/positionMargin": 2,
|
|
},
|
|
"delete": map[string]interface{} {
|
|
"trade/allOpenOrders": 2,
|
|
"trade/cancelOrder": 2,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"contract": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"allPosition": 2,
|
|
"allOrders": 2,
|
|
"balance": 2,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"wallets": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"capital/config/getall": 5,
|
|
"capital/deposit/address": 5,
|
|
"capital/innerTransfer/records": 1,
|
|
"capital/subAccount/deposit/address": 5,
|
|
"capital/deposit/subHisrec": 2,
|
|
"capital/subAccount/innerTransfer/records": 1,
|
|
"capital/deposit/riskRecords": 5,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"capital/withdraw/apply": 5,
|
|
"capital/innerTransfer/apply": 5,
|
|
"capital/subAccountInnerTransfer/apply": 2,
|
|
"capital/deposit/createSubAddress": 2,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"subAccount": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"list": 10,
|
|
"assets": 2,
|
|
"allAccountBalance": 2,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"create": 10,
|
|
"apiKey/create": 2,
|
|
"apiKey/edit": 2,
|
|
"apiKey/del": 2,
|
|
"updateStatus": 10,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"account": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"uid": 1,
|
|
"apiKey/query": 2,
|
|
"account/apiPermissions": 5,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"innerTransfer/authorizeSubAccount": 1,
|
|
},
|
|
},
|
|
},
|
|
"transfer": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"subAccount/asset/transferHistory": 1,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"subAccount/transferAsset/supportCoins": 1,
|
|
"subAccount/transferAsset": 1,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"user": map[string]interface{} {
|
|
"auth": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"post": map[string]interface{} {
|
|
"userDataStream": 2,
|
|
},
|
|
"put": map[string]interface{} {
|
|
"userDataStream": 2,
|
|
},
|
|
"delete": map[string]interface{} {
|
|
"userDataStream": 2,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"copyTrading": map[string]interface{} {
|
|
"v1": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"swap/trace/currentTrack": 2,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"swap/trace/closeTrackOrder": 2,
|
|
"swap/trace/setTPSL": 2,
|
|
"spot/trader/sellOrder": 10,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"api": map[string]interface{} {
|
|
"v3": map[string]interface{} {
|
|
"private": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"asset/transfer": 1,
|
|
"capital/deposit/hisrec": 1,
|
|
"capital/withdraw/history": 1,
|
|
},
|
|
"post": map[string]interface{} {
|
|
"post/asset/transfer": 1,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"timeframes": map[string]interface{} {
|
|
"1m": "1m",
|
|
"3m": "3m",
|
|
"5m": "5m",
|
|
"15m": "15m",
|
|
"30m": "30m",
|
|
"1h": "1h",
|
|
"2h": "2h",
|
|
"4h": "4h",
|
|
"6h": "6h",
|
|
"12h": "12h",
|
|
"1d": "1d",
|
|
"3d": "3d",
|
|
"1w": "1w",
|
|
"1M": "1M",
|
|
},
|
|
"precisionMode": TICK_SIZE,
|
|
"exceptions": map[string]interface{} {
|
|
"exact": map[string]interface{} {
|
|
"400": BadRequest,
|
|
"401": AuthenticationError,
|
|
"403": PermissionDenied,
|
|
"404": BadRequest,
|
|
"429": DDoSProtection,
|
|
"418": PermissionDenied,
|
|
"500": ExchangeError,
|
|
"504": ExchangeError,
|
|
"100001": AuthenticationError,
|
|
"100412": AuthenticationError,
|
|
"100202": InsufficientFunds,
|
|
"100204": BadRequest,
|
|
"100400": BadRequest,
|
|
"100410": OperationFailed,
|
|
"100421": BadSymbol,
|
|
"100440": ExchangeError,
|
|
"100500": OperationFailed,
|
|
"100503": ExchangeError,
|
|
"80001": BadRequest,
|
|
"80012": InsufficientFunds,
|
|
"80014": BadRequest,
|
|
"80016": OrderNotFound,
|
|
"80017": OrderNotFound,
|
|
"100414": AccountSuspended,
|
|
"100419": PermissionDenied,
|
|
"100437": BadRequest,
|
|
"101204": InsufficientFunds,
|
|
"110425": InvalidOrder,
|
|
},
|
|
"broad": map[string]interface{} {},
|
|
},
|
|
"commonCurrencies": map[string]interface{} {
|
|
"SNOW": "Snowman",
|
|
"OMNI": "OmniCat",
|
|
"NAP": "$NAP",
|
|
"TRUMP": "TRUMPMAGA",
|
|
"TRUMPSOL": "TRUMP",
|
|
},
|
|
"options": map[string]interface{} {
|
|
"defaultType": "spot",
|
|
"accountsByType": map[string]interface{} {
|
|
"spot": "FUND",
|
|
"swap": "PFUTURES",
|
|
"future": "SFUTURES",
|
|
},
|
|
"accountsById": map[string]interface{} {
|
|
"FUND": "spot",
|
|
"PFUTURES": "swap",
|
|
"SFUTURES": "future",
|
|
},
|
|
"recvWindow": Multiply(5, 1000),
|
|
"broker": "CCXT",
|
|
"defaultNetworks": map[string]interface{} {
|
|
"ETH": "ETH",
|
|
"USDT": "ERC20",
|
|
"USDC": "ERC20",
|
|
"BTC": "BTC",
|
|
"LTC": "LTC",
|
|
},
|
|
"networks": map[string]interface{} {
|
|
"ARB": "ARBITRUM",
|
|
"MATIC": "POLYGON",
|
|
},
|
|
},
|
|
"features": map[string]interface{} {
|
|
"defaultForLinear": map[string]interface{} {
|
|
"sandbox": true,
|
|
"createOrder": map[string]interface{} {
|
|
"marginMode": false,
|
|
"triggerPrice": true,
|
|
"triggerPriceType": map[string]interface{} {
|
|
"last": true,
|
|
"mark": true,
|
|
"index": true,
|
|
},
|
|
"triggerDirection": false,
|
|
"stopLossPrice": true,
|
|
"takeProfitPrice": true,
|
|
"attachedStopLossTakeProfit": map[string]interface{} {
|
|
"triggerPriceType": map[string]interface{} {
|
|
"last": true,
|
|
"mark": true,
|
|
"index": true,
|
|
},
|
|
"price": true,
|
|
},
|
|
"timeInForce": map[string]interface{} {
|
|
"IOC": true,
|
|
"FOK": true,
|
|
"PO": true,
|
|
"GTD": false,
|
|
},
|
|
"hedged": true,
|
|
"trailing": true,
|
|
"leverage": false,
|
|
"marketBuyRequiresPrice": false,
|
|
"marketBuyByCost": true,
|
|
"selfTradePrevention": false,
|
|
"iceberg": false,
|
|
},
|
|
"createOrders": map[string]interface{} {
|
|
"max": 5,
|
|
},
|
|
"fetchMyTrades": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 512,
|
|
"daysBack": 30,
|
|
"untilDays": 30,
|
|
"symbolRequired": true,
|
|
},
|
|
"fetchOrder": map[string]interface{} {
|
|
"marginMode": false,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": true,
|
|
},
|
|
"fetchOpenOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": nil,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 1000,
|
|
"daysBack": 20000,
|
|
"untilDays": 7,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": true,
|
|
},
|
|
"fetchClosedOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 1000,
|
|
"daysBack": nil,
|
|
"daysBackCanceled": nil,
|
|
"untilDays": 7,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": true,
|
|
},
|
|
"fetchOHLCV": map[string]interface{} {
|
|
"limit": 1440,
|
|
},
|
|
},
|
|
"defaultForInverse": map[string]interface{} {
|
|
"extends": "defaultForLinear",
|
|
"fetchMyTrades": map[string]interface{} {
|
|
"limit": 1000,
|
|
"daysBack": nil,
|
|
"untilDays": nil,
|
|
},
|
|
"fetchOrders": nil,
|
|
},
|
|
"spot": map[string]interface{} {
|
|
"extends": "defaultForLinear",
|
|
"createOrder": map[string]interface{} {
|
|
"triggerPriceType": nil,
|
|
"attachedStopLossTakeProfit": nil,
|
|
"trailing": false,
|
|
},
|
|
"fetchMyTrades": map[string]interface{} {
|
|
"limit": 1000,
|
|
"daysBack": 1,
|
|
"untilDays": 1,
|
|
},
|
|
"fetchOrders": nil,
|
|
"fetchClosedOrders": map[string]interface{} {
|
|
"limit": 100,
|
|
"untilDays": nil,
|
|
},
|
|
},
|
|
"swap": map[string]interface{} {
|
|
"linear": map[string]interface{} {
|
|
"extends": "defaultForLinear",
|
|
},
|
|
"inverse": map[string]interface{} {
|
|
"extends": "defaultForInverse",
|
|
},
|
|
},
|
|
"defaultForFuture": map[string]interface{} {
|
|
"extends": "defaultForLinear",
|
|
"fetchOrders": nil,
|
|
},
|
|
"future": map[string]interface{} {
|
|
"linear": map[string]interface{} {
|
|
"extends": "defaultForFuture",
|
|
},
|
|
"inverse": map[string]interface{} {
|
|
"extends": "defaultForFuture",
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchTime
|
|
* @description fetches the current integer timestamp in milliseconds from the bingx server
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/base-info.html#Get%20Server%20Time
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {int} the current integer timestamp in milliseconds from the bingx server
|
|
*/
|
|
func (this *bingx) 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.SwapV2PublicGetServerTime(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "serverTime": 1675319535362
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data")
|
|
|
|
ch <- this.SafeInteger(data, "serverTime")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchCurrencies
|
|
* @description fetches all available currencies on an exchange
|
|
* @see https://bingx-api.github.io/docs/#/common/account-api.html#All%20Coins
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} an associative dictionary of currencies
|
|
*/
|
|
func (this *bingx) 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
|
|
if !IsTrue(this.CheckRequiredCredentials(false)) {
|
|
|
|
return nil
|
|
}
|
|
var isSandbox interface{} = this.SafeBool(this.Options, "sandboxMode", false)
|
|
if IsTrue(isSandbox) {
|
|
|
|
return nil
|
|
}
|
|
|
|
response:= (<-this.WalletsV1PrivateGetCapitalConfigGetall(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "timestamp": 1702623271477,
|
|
// "data": [
|
|
// {
|
|
// "coin": "BTC",
|
|
// "name": "BTC",
|
|
// "networkList": [
|
|
// {
|
|
// "name": "BTC",
|
|
// "network": "BTC",
|
|
// "isDefault": true,
|
|
// "minConfirm": 2,
|
|
// "withdrawEnable": true,
|
|
// "depositEnable": true,
|
|
// "withdrawFee": "0.0006",
|
|
// "withdrawMax": "1.17522",
|
|
// "withdrawMin": "0.0005",
|
|
// "depositMin": "0.0002"
|
|
// },
|
|
// {
|
|
// "name": "BTC",
|
|
// "network": "BEP20",
|
|
// "isDefault": false,
|
|
// "minConfirm": 15,
|
|
// "withdrawEnable": true,
|
|
// "depositEnable": true,
|
|
// "withdrawFee": "0.0000066",
|
|
// "withdrawMax": "1.17522",
|
|
// "withdrawMin": "0.0000066",
|
|
// "depositMin": "0.0002"
|
|
// }
|
|
// ]
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
|
var result interface{} = map[string]interface{} {}
|
|
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
|
|
var entry interface{} = GetValue(data, i)
|
|
var currencyId interface{} = this.SafeString(entry, "coin")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId)
|
|
var name interface{} = this.SafeString(entry, "name")
|
|
var networkList interface{} = this.SafeList(entry, "networkList")
|
|
var networks interface{} = map[string]interface{} {}
|
|
var fee interface{} = nil
|
|
var depositEnabled interface{} = false
|
|
var withdrawEnabled interface{} = false
|
|
var defaultLimits interface{} = map[string]interface{} {}
|
|
for j := 0; IsLessThan(j, GetArrayLength(networkList)); j++ {
|
|
var rawNetwork interface{} = GetValue(networkList, j)
|
|
var network interface{} = this.SafeString(rawNetwork, "network")
|
|
var networkCode interface{} = this.NetworkIdToCode(network)
|
|
var isDefault interface{} = this.SafeBool(rawNetwork, "isDefault")
|
|
var networkDepositEnabled interface{} = this.SafeBool(rawNetwork, "depositEnable")
|
|
if IsTrue(networkDepositEnabled) {
|
|
depositEnabled = true
|
|
}
|
|
var networkWithdrawEnabled interface{} = this.SafeBool(rawNetwork, "withdrawEnable")
|
|
if IsTrue(networkWithdrawEnabled) {
|
|
withdrawEnabled = true
|
|
}
|
|
var limits interface{} = map[string]interface{} {
|
|
"withdraw": map[string]interface{} {
|
|
"min": this.SafeNumber(rawNetwork, "withdrawMin"),
|
|
"max": this.SafeNumber(rawNetwork, "withdrawMax"),
|
|
},
|
|
}
|
|
fee = this.SafeNumber(rawNetwork, "withdrawFee")
|
|
if IsTrue(isDefault) {
|
|
defaultLimits = limits
|
|
}
|
|
var precision interface{} = this.SafeNumber(rawNetwork, "withdrawPrecision")
|
|
var networkActive interface{} = IsTrue(networkDepositEnabled) || IsTrue(networkWithdrawEnabled)
|
|
AddElementToObject(networks, networkCode, map[string]interface{} {
|
|
"info": rawNetwork,
|
|
"id": network,
|
|
"network": networkCode,
|
|
"fee": fee,
|
|
"active": networkActive,
|
|
"deposit": networkDepositEnabled,
|
|
"withdraw": networkWithdrawEnabled,
|
|
"precision": precision,
|
|
"limits": limits,
|
|
})
|
|
}
|
|
var active interface{} = IsTrue(depositEnabled) || IsTrue(withdrawEnabled)
|
|
AddElementToObject(result, code, map[string]interface{} {
|
|
"info": entry,
|
|
"code": code,
|
|
"id": currencyId,
|
|
"precision": nil,
|
|
"name": name,
|
|
"active": active,
|
|
"deposit": depositEnabled,
|
|
"withdraw": withdrawEnabled,
|
|
"networks": networks,
|
|
"fee": fee,
|
|
"limits": defaultLimits,
|
|
})
|
|
}
|
|
|
|
ch <- result
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) FetchSpotMarkets(params interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
|
|
response:= (<-this.SpotV1PublicGetCommonSymbols(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "debugMsg": "",
|
|
// "data": {
|
|
// "symbols": [
|
|
// {
|
|
// "symbol": "GEAR-USDT",
|
|
// "minQty": 735, // deprecated
|
|
// "maxQty": 2941177, // deprecated
|
|
// "minNotional": 5,
|
|
// "maxNotional": 20000,
|
|
// "status": 1,
|
|
// "tickSize": 0.000001,
|
|
// "stepSize": 1,
|
|
// "apiStateSell": true,
|
|
// "apiStateBuy": true,
|
|
// "timeOnline": 0,
|
|
// "offTime": 0,
|
|
// "maintainTime": 0
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data")
|
|
var markets interface{} = this.SafeList(data, "symbols", []interface{}{})
|
|
|
|
ch <- this.ParseMarkets(markets)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) FetchSwapMarkets(params interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
|
|
response:= (<-this.SwapV2PublicGetQuoteContracts(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": [
|
|
// {
|
|
// "contractId": "100",
|
|
// "symbol": "BTC-USDT",
|
|
// "size": "0.0001",
|
|
// "quantityPrecision": "4",
|
|
// "pricePrecision": "1",
|
|
// "feeRate": "0.0005",
|
|
// "makerFeeRate": "0.0002",
|
|
// "takerFeeRate": "0.0005",
|
|
// "tradeMinLimit": "0",
|
|
// "tradeMinQuantity": "0.0001",
|
|
// "tradeMinUSDT": "2",
|
|
// "maxLongLeverage": "125",
|
|
// "maxShortLeverage": "125",
|
|
// "currency": "USDT",
|
|
// "asset": "BTC",
|
|
// "status": "1",
|
|
// "apiStateOpen": "true",
|
|
// "apiStateClose": "true",
|
|
// "ensureTrigger": true,
|
|
// "triggerFeeRate": "0.00020000"
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
var markets interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParseMarkets(markets)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) FetchInverseSwapMarkets(params interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
|
|
response:= (<-this.CswapV1PublicGetMarketContracts(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1720074487610,
|
|
// "data": [
|
|
// {
|
|
// "symbol": "BNB-USD",
|
|
// "pricePrecision": 2,
|
|
// "minTickSize": "10",
|
|
// "minTradeValue": "10",
|
|
// "minQty": "1.00000000",
|
|
// "status": 1,
|
|
// "timeOnline": 1713175200000
|
|
// },
|
|
// ]
|
|
// }
|
|
//
|
|
var markets interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParseMarkets(markets)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseMarket(market interface{}) interface{} {
|
|
var id interface{} = this.SafeString(market, "symbol")
|
|
var symbolParts interface{} = Split(id, "-")
|
|
var baseId interface{} = GetValue(symbolParts, 0)
|
|
var quoteId interface{} = GetValue(symbolParts, 1)
|
|
var base interface{} = this.SafeCurrencyCode(baseId)
|
|
var quote interface{} = this.SafeCurrencyCode(quoteId)
|
|
var currency interface{} = this.SafeString(market, "currency")
|
|
var checkIsInverse interface{} = false
|
|
var checkIsLinear interface{} = true
|
|
var minTickSize interface{} = this.SafeNumber(market, "minTickSize")
|
|
if IsTrue(!IsEqual(minTickSize, nil)) {
|
|
// inverse swap market
|
|
currency = baseId
|
|
checkIsInverse = true
|
|
checkIsLinear = false
|
|
}
|
|
var settle interface{} = this.SafeCurrencyCode(currency)
|
|
var pricePrecision interface{} = this.SafeNumber(market, "tickSize")
|
|
if IsTrue(IsEqual(pricePrecision, nil)) {
|
|
pricePrecision = this.ParseNumber(this.ParsePrecision(this.SafeString(market, "pricePrecision")))
|
|
}
|
|
var quantityPrecision interface{} = this.SafeNumber(market, "stepSize")
|
|
if IsTrue(IsEqual(quantityPrecision, nil)) {
|
|
quantityPrecision = this.ParseNumber(this.ParsePrecision(this.SafeString(market, "quantityPrecision")))
|
|
}
|
|
var typeVar interface{} = Ternary(IsTrue((!IsEqual(settle, nil))), "swap", "spot")
|
|
var spot interface{} = IsEqual(typeVar, "spot")
|
|
var swap interface{} = IsEqual(typeVar, "swap")
|
|
var symbol interface{} = Add(Add(base, "/"), quote)
|
|
if IsTrue(!IsEqual(settle, nil)) {
|
|
symbol = Add(symbol, Add(":", settle))
|
|
}
|
|
var fees interface{} = this.SafeDict(this.Fees, typeVar, map[string]interface{} {})
|
|
var contractSize interface{} = Ternary(IsTrue((swap)), this.ParseNumber("1"), nil)
|
|
var isActive interface{} = false
|
|
if IsTrue(IsTrue((IsEqual(this.SafeString(market, "apiStateOpen"), "true"))) && IsTrue((IsEqual(this.SafeString(market, "apiStateClose"), "true")))) {
|
|
isActive = true // swap active
|
|
} else if IsTrue(IsTrue(IsTrue(this.SafeBool(market, "apiStateSell")) && IsTrue(this.SafeBool(market, "apiStateBuy"))) && IsTrue((IsEqual(this.SafeString(market, "status"), "1")))) {
|
|
isActive = true // spot active
|
|
}
|
|
var isInverse interface{} = Ternary(IsTrue((spot)), nil, checkIsInverse)
|
|
var isLinear interface{} = Ternary(IsTrue((spot)), nil, checkIsLinear)
|
|
var minAmount interface{} = nil
|
|
if !IsTrue(spot) {
|
|
minAmount = this.SafeNumber2(market, "minQty", "tradeMinQuantity")
|
|
}
|
|
var timeOnline interface{} = this.SafeInteger(market, "timeOnline")
|
|
if IsTrue(IsEqual(timeOnline, 0)) {
|
|
timeOnline = nil
|
|
}
|
|
return this.SafeMarketStructure(map[string]interface{} {
|
|
"id": id,
|
|
"symbol": symbol,
|
|
"base": base,
|
|
"quote": quote,
|
|
"settle": settle,
|
|
"baseId": baseId,
|
|
"quoteId": quoteId,
|
|
"settleId": currency,
|
|
"type": typeVar,
|
|
"spot": spot,
|
|
"margin": false,
|
|
"swap": swap,
|
|
"future": false,
|
|
"option": false,
|
|
"active": isActive,
|
|
"contract": swap,
|
|
"linear": isLinear,
|
|
"inverse": isInverse,
|
|
"taker": this.SafeNumber(fees, "taker"),
|
|
"maker": this.SafeNumber(fees, "maker"),
|
|
"feeSide": this.SafeString(fees, "feeSide"),
|
|
"contractSize": contractSize,
|
|
"expiry": nil,
|
|
"expiryDatetime": nil,
|
|
"strike": nil,
|
|
"optionType": nil,
|
|
"precision": map[string]interface{} {
|
|
"amount": quantityPrecision,
|
|
"price": pricePrecision,
|
|
},
|
|
"limits": map[string]interface{} {
|
|
"leverage": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
"amount": map[string]interface{} {
|
|
"min": minAmount,
|
|
"max": nil,
|
|
},
|
|
"price": map[string]interface{} {
|
|
"min": minTickSize,
|
|
"max": nil,
|
|
},
|
|
"cost": map[string]interface{} {
|
|
"min": this.SafeNumberN(market, []interface{}{"minNotional", "tradeMinUSDT", "minTradeValue"}),
|
|
"max": this.SafeNumber(market, "maxNotional"),
|
|
},
|
|
},
|
|
"created": timeOnline,
|
|
"info": market,
|
|
})
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchMarkets
|
|
* @description retrieves data on all markets for bingx
|
|
* @see https://bingx-api.github.io/docs/#/spot/market-api.html#Query%20Symbols
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Contract%20Information
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Contract%20Information
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} an array of objects representing market data
|
|
*/
|
|
func (this *bingx) 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 requests interface{} = []interface{}{this.FetchSwapMarkets(params)}
|
|
var isSandbox interface{} = this.SafeBool(this.Options, "sandboxMode", false)
|
|
if !IsTrue(isSandbox) {
|
|
AppendToArray(&requests,this.FetchInverseSwapMarkets(params))
|
|
AppendToArray(&requests,this.FetchSpotMarkets(params)) // sandbox is swap only
|
|
}
|
|
|
|
promises:= (<-promiseAll(requests))
|
|
PanicOnError(promises)
|
|
var linearSwapMarkets interface{} = this.SafeList(promises, 0, []interface{}{})
|
|
var inverseSwapMarkets interface{} = this.SafeList(promises, 1, []interface{}{})
|
|
var spotMarkets interface{} = this.SafeList(promises, 2, []interface{}{})
|
|
var swapMarkets interface{} = this.ArrayConcat(linearSwapMarkets, inverseSwapMarkets)
|
|
|
|
ch <- this.ArrayConcat(spotMarkets, swapMarkets)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchOHLCV
|
|
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#K-Line%20Data
|
|
* @see https://bingx-api.github.io/docs/#/spot/market-api.html#Candlestick%20chart%20data
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#%20K-Line%20Data
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#Mark%20Price%20Kline/Candlestick%20Data
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Get%20K-line%20Data
|
|
* @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 {int} [params.until] timestamp in ms of the latest candle to fetch
|
|
* @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 {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes10608 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes10608)
|
|
var paginate interface{} = false
|
|
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchOHLCV", "paginate", false);
|
|
paginate = GetValue(paginateparamsVariable,0);
|
|
params = GetValue(paginateparamsVariable,1)
|
|
if IsTrue(paginate) {
|
|
|
|
retRes106419 := (<-this.FetchPaginatedCallDeterministic("fetchOHLCV", symbol, since, limit, timeframe, params, 1440))
|
|
PanicOnError(retRes106419)
|
|
ch <- retRes106419
|
|
return nil
|
|
}
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
AddElementToObject(request, "interval", this.SafeString(this.Timeframes, timeframe, timeframe))
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTime", mathMax(Subtract(since, 1), 0))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit)
|
|
}
|
|
var until interface{} = this.SafeInteger2(params, "until", "endTime")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "endTime", until)
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
|
|
response = (<-this.SpotV1PublicGetMarketKline(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketKlines(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
var price interface{} = this.SafeString(params, "price")
|
|
params = this.Omit(params, "price")
|
|
if IsTrue(IsEqual(price, "mark")) {
|
|
|
|
response = (<-this.SwapV1PublicGetMarketMarkPriceKlines(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV3PublicGetQuoteKlines(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": [
|
|
// {
|
|
// "open": "19396.8",
|
|
// "close": "19394.4",
|
|
// "high": "19397.5",
|
|
// "low": "19385.7",
|
|
// "volume": "110.05",
|
|
// "time": 1666583700000
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
// fetchMarkOHLCV
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": [
|
|
// {
|
|
// "open": "42191.7",
|
|
// "close": "42189.5",
|
|
// "high": "42196.5",
|
|
// "low": "42189.5",
|
|
// "volume": "0.00",
|
|
// "openTime": 1706508840000,
|
|
// "closeTime": 1706508840000
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var ohlcvs interface{} = this.SafeValue(response, "data", []interface{}{})
|
|
if !IsTrue(IsArray(ohlcvs)) {
|
|
ohlcvs = []interface{}{ohlcvs}
|
|
}
|
|
|
|
ch <- this.ParseOHLCVs(ohlcvs, market, timeframe, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "open": "19394.4",
|
|
// "close": "19379.0",
|
|
// "high": "19394.4",
|
|
// "low": "19368.3",
|
|
// "volume": "167.44",
|
|
// "time": 1666584000000
|
|
// }
|
|
//
|
|
// fetchMarkOHLCV
|
|
//
|
|
// {
|
|
// "open": "42191.7",
|
|
// "close": "42189.5",
|
|
// "high": "42196.5",
|
|
// "low": "42189.5",
|
|
// "volume": "0.00",
|
|
// "openTime": 1706508840000,
|
|
// "closeTime": 1706508840000
|
|
// }
|
|
// spot
|
|
// [
|
|
// 1691402580000,
|
|
// 29093.61,
|
|
// 29093.93,
|
|
// 29087.73,
|
|
// 29093.24,
|
|
// 0.59,
|
|
// 1691402639999,
|
|
// 17221.07
|
|
// ]
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
if IsTrue(IsArray(ohlcv)) {
|
|
return []interface{}{this.SafeInteger(ohlcv, 0), this.SafeNumber(ohlcv, 1), this.SafeNumber(ohlcv, 2), this.SafeNumber(ohlcv, 3), this.SafeNumber(ohlcv, 4), this.SafeNumber(ohlcv, 5)}
|
|
}
|
|
return []interface{}{this.SafeInteger2(ohlcv, "time", "closeTime"), this.SafeNumber(ohlcv, "open"), this.SafeNumber(ohlcv, "high"), this.SafeNumber(ohlcv, "low"), this.SafeNumber(ohlcv, "close"), this.SafeNumber(ohlcv, "volume")}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchTrades
|
|
* @description get the list of most recent trades for a particular symbol
|
|
* @see https://bingx-api.github.io/docs/#/spot/market-api.html#Query%20transaction%20records
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#The%20latest%20Trade%20of%20a%20Trading%20Pair
|
|
* @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 {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes12078 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes12078)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", mathMin(limit, 100)) // avoid API exception "limit should less than 100"
|
|
}
|
|
var response interface{} = nil
|
|
var marketType interface{} = nil
|
|
marketTypeparamsVariable := this.HandleMarketTypeAndParams("fetchTrades", market, params);
|
|
marketType = GetValue(marketTypeparamsVariable,0);
|
|
params = GetValue(marketTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(marketType, "spot")) {
|
|
|
|
response = (<-this.SpotV1PublicGetMarketTrades(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuoteTrades(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "data": [
|
|
// {
|
|
// "id": 43148253,
|
|
// "price": 25714.71,
|
|
// "qty": 1.674571,
|
|
// "time": 1655085975589,
|
|
// "buyerMaker": false
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
// swap
|
|
//
|
|
// {
|
|
// "code":0,
|
|
// "msg":"",
|
|
// "data":[
|
|
// {
|
|
// "time": 1672025549368,
|
|
// "isBuyerMaker": true,
|
|
// "price": "16885.0",
|
|
// "qty": "3.3002",
|
|
// "quoteQty": "55723.87"
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
var trades interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParseTrades(trades, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// spot fetchTrades
|
|
//
|
|
// {
|
|
// "id": 43148253,
|
|
// "price": 25714.71,
|
|
// "qty": 1.674571,
|
|
// "time": 1655085975589,
|
|
// "buyerMaker": false
|
|
// }
|
|
//
|
|
// spot fetchMyTrades
|
|
//
|
|
// {
|
|
// "symbol": "LTC-USDT",
|
|
// "id": 36237072,
|
|
// "orderId": 1674069326895775744,
|
|
// "price": "85.891",
|
|
// "qty": "0.0582",
|
|
// "quoteQty": "4.9988562000000005",
|
|
// "commission": -0.00005820000000000001,
|
|
// "commissionAsset": "LTC",
|
|
// "time": 1687964205000,
|
|
// "isBuyer": true,
|
|
// "isMaker": false
|
|
// }
|
|
//
|
|
// swap fetchTrades
|
|
//
|
|
// {
|
|
// "time": 1672025549368,
|
|
// "isBuyerMaker": true,
|
|
// "price": "16885.0",
|
|
// "qty": "3.3002",
|
|
// "quoteQty": "55723.87"
|
|
// }
|
|
//
|
|
// swap fetchMyTrades
|
|
//
|
|
// {
|
|
// "volume": "0.1",
|
|
// "price": "106.75",
|
|
// "amount": "10.6750",
|
|
// "commission": "-0.0053",
|
|
// "currency": "USDT",
|
|
// "orderId": "1676213270274379776",
|
|
// "liquidatedPrice": "0.00",
|
|
// "liquidatedMarginRatio": "0.00",
|
|
// "filledTime": "2023-07-04T20:56:01.000+0800"
|
|
// }
|
|
//
|
|
// ws spot
|
|
//
|
|
// {
|
|
// "E": 1690214529432,
|
|
// "T": 1690214529386,
|
|
// "e": "trade",
|
|
// "m": true,
|
|
// "p": "29110.19",
|
|
// "q": "0.1868",
|
|
// "s": "BTC-USDT",
|
|
// "t": "57903921"
|
|
// }
|
|
//
|
|
// ws linear swap
|
|
//
|
|
// {
|
|
// "q": "0.0421",
|
|
// "p": "29023.5",
|
|
// "T": 1690221401344,
|
|
// "m": false,
|
|
// "s": "BTC-USDT"
|
|
// }
|
|
//
|
|
// ws inverse swap
|
|
//
|
|
// {
|
|
// "e": "trade",
|
|
// "E": 1722920589665,
|
|
// "s": "BTC-USD",
|
|
// "t": "39125001",
|
|
// "p": "55360.0",
|
|
// "q": "1",
|
|
// "T": 1722920589582,
|
|
// "m": false
|
|
// }
|
|
//
|
|
// inverse swap fetchMyTrades
|
|
//
|
|
// {
|
|
// "orderId": "1817441228670648320",
|
|
// "symbol": "SOL-USD",
|
|
// "type": "MARKET",
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "tradeId": "97244554",
|
|
// "volume": "2",
|
|
// "tradePrice": "182.652",
|
|
// "amount": "20.00000000",
|
|
// "realizedPnl": "0.00000000",
|
|
// "commission": "-0.00005475",
|
|
// "currency": "SOL",
|
|
// "buyer": true,
|
|
// "maker": false,
|
|
// "tradeTime": 1722146730000
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var time interface{} = this.SafeIntegerN(trade, []interface{}{"time", "filledTm", "T", "tradeTime"})
|
|
var datetimeId interface{} = this.SafeString(trade, "filledTm")
|
|
if IsTrue(!IsEqual(datetimeId, nil)) {
|
|
time = this.Parse8601(datetimeId)
|
|
}
|
|
if IsTrue(IsEqual(time, 0)) {
|
|
time = nil
|
|
}
|
|
var cost interface{} = this.SafeString(trade, "quoteQty")
|
|
// const type = (cost === undefined) ? 'spot' : 'swap'; this is not reliable
|
|
var currencyId interface{} = this.SafeStringN(trade, []interface{}{"currency", "N", "commissionAsset"})
|
|
var currencyCode interface{} = this.SafeCurrencyCode(currencyId)
|
|
var m interface{} = this.SafeBool(trade, "m")
|
|
var marketId interface{} = this.SafeString2(trade, "s", "symbol")
|
|
var isBuyerMaker interface{} = this.SafeBoolN(trade, []interface{}{"buyerMaker", "isBuyerMaker", "maker"})
|
|
var takeOrMaker interface{} = nil
|
|
if IsTrue(IsTrue((!IsEqual(isBuyerMaker, nil))) || IsTrue((!IsEqual(m, nil)))) {
|
|
takeOrMaker = Ternary(IsTrue((IsTrue(isBuyerMaker) || IsTrue(m))), "maker", "taker")
|
|
}
|
|
var side interface{} = this.SafeStringLower2(trade, "side", "S")
|
|
if IsTrue(IsEqual(side, nil)) {
|
|
if IsTrue(IsTrue((!IsEqual(isBuyerMaker, nil))) || IsTrue((!IsEqual(m, nil)))) {
|
|
side = Ternary(IsTrue((IsTrue(isBuyerMaker) || IsTrue(m))), "sell", "buy")
|
|
takeOrMaker = "taker"
|
|
}
|
|
}
|
|
var isBuyer interface{} = this.SafeBool(trade, "isBuyer")
|
|
if IsTrue(!IsEqual(isBuyer, nil)) {
|
|
side = Ternary(IsTrue(isBuyer), "buy", "sell")
|
|
}
|
|
var isMaker interface{} = this.SafeBool(trade, "isMaker")
|
|
if IsTrue(!IsEqual(isMaker, nil)) {
|
|
takeOrMaker = Ternary(IsTrue(isMaker), "maker", "taker")
|
|
}
|
|
var amount interface{} = this.SafeStringN(trade, []interface{}{"qty", "amount", "q"})
|
|
if IsTrue(IsTrue(IsTrue((!IsEqual(market, nil))) && IsTrue(GetValue(market, "swap"))) && IsTrue((InOp(trade, "volume")))) {
|
|
// private trade returns num of contracts instead of base currency (as the order-related methods do)
|
|
var contractSize interface{} = this.SafeString(GetValue(market, "info"), "tradeMinQuantity")
|
|
var volume interface{} = this.SafeString(trade, "volume")
|
|
amount = Precise.StringMul(volume, contractSize)
|
|
}
|
|
return this.SafeTrade(map[string]interface{} {
|
|
"id": this.SafeStringN(trade, []interface{}{"id", "t"}),
|
|
"info": trade,
|
|
"timestamp": time,
|
|
"datetime": this.Iso8601(time),
|
|
"symbol": this.SafeSymbol(marketId, market, "-"),
|
|
"order": this.SafeString2(trade, "orderId", "i"),
|
|
"type": this.SafeStringLower(trade, "o"),
|
|
"side": this.ParseOrderSide(side),
|
|
"takerOrMaker": takeOrMaker,
|
|
"price": this.SafeStringN(trade, []interface{}{"price", "p", "tradePrice"}),
|
|
"amount": amount,
|
|
"cost": cost,
|
|
"fee": map[string]interface{} {
|
|
"cost": this.ParseNumber(Precise.StringAbs(this.SafeString2(trade, "commission", "n"))),
|
|
"currency": currencyCode,
|
|
},
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchOrderBook
|
|
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
|
|
* @see https://bingx-api.github.io/docs/#/spot/market-api.html#Query%20depth%20information
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Get%20Market%20Depth
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Query%20Depth%20Data
|
|
* @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 *bingx) 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
|
|
|
|
retRes14428 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes14428)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit)
|
|
}
|
|
var response interface{} = nil
|
|
var marketType interface{} = nil
|
|
marketTypeparamsVariable := this.HandleMarketTypeAndParams("fetchOrderBook", market, params);
|
|
marketType = GetValue(marketTypeparamsVariable,0);
|
|
params = GetValue(marketTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(marketType, "spot")) {
|
|
|
|
response = (<-this.SpotV1PublicGetMarketDepth(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketDepth(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuoteDepth(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "data": {
|
|
// "bids": [
|
|
// [
|
|
// "26324.73",
|
|
// "0.37655"
|
|
// ],
|
|
// [
|
|
// "26324.71",
|
|
// "0.31888"
|
|
// ],
|
|
// ],
|
|
// "asks": [
|
|
// [
|
|
// "26340.30",
|
|
// "6.45221"
|
|
// ],
|
|
// [
|
|
// "26340.15",
|
|
// "6.73261"
|
|
// ],
|
|
// ]}
|
|
// }
|
|
//
|
|
// swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "T": 1683914263304,
|
|
// "bids": [
|
|
// [
|
|
// "26300.90000000",
|
|
// "30408.00000000"
|
|
// ],
|
|
// [
|
|
// "26300.80000000",
|
|
// "50906.00000000"
|
|
// ],
|
|
// ],
|
|
// "asks": [
|
|
// [
|
|
// "26301.00000000",
|
|
// "43616.00000000"
|
|
// ],
|
|
// [
|
|
// "26301.10000000",
|
|
// "49402.00000000"
|
|
// ],
|
|
// ]}
|
|
// }
|
|
//
|
|
var orderbook interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var timestamp interface{} = this.SafeInteger2(orderbook, "T", "ts")
|
|
|
|
ch <- this.ParseOrderBook(orderbook, GetValue(market, "symbol"), timestamp, "bids", "asks", 0, 1)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchFundingRate
|
|
* @description fetch the current funding rate
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Current%20Funding%20Rate
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Price%20&%20Current%20Funding%20Rate
|
|
* @param {string} symbol unified market symbol
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
|
|
*/
|
|
func (this *bingx) FetchFundingRate(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
|
|
|
|
retRes15358 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes15358)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketPremiumIndex(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuotePremiumIndex(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// {
|
|
// "code":0,
|
|
// "msg":"",
|
|
// "data":[
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "markPrice": "16884.5",
|
|
// "indexPrice": "16886.9",
|
|
// "lastFundingRate": "0.0001",
|
|
// "nextFundingTime": 1672041600000
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParseFundingRate(data, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchFundingRates
|
|
* @description fetch the current funding rate for multiple symbols
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Current%20Funding%20Rate
|
|
* @param {string[]} [symbols] list of unified market symbols
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} a list of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
|
|
*/
|
|
func (this *bingx) FetchFundingRates(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
|
|
|
|
retRes15768 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes15768)
|
|
symbols = this.MarketSymbols(symbols, "swap", true)
|
|
|
|
response:= (<-this.SwapV2PublicGetQuotePremiumIndex(this.Extend(params)))
|
|
PanicOnError(response)
|
|
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParseFundingRates(data, symbols)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseFundingRate(contract interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "markPrice": "16884.5",
|
|
// "indexPrice": "16886.9",
|
|
// "lastFundingRate": "0.0001",
|
|
// "nextFundingTime": 1672041600000
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(contract, "symbol")
|
|
var nextFundingTimestamp interface{} = this.SafeInteger(contract, "nextFundingTime")
|
|
return map[string]interface{} {
|
|
"info": contract,
|
|
"symbol": this.SafeSymbol(marketId, market, "-", "swap"),
|
|
"markPrice": this.SafeNumber(contract, "markPrice"),
|
|
"indexPrice": this.SafeNumber(contract, "indexPrice"),
|
|
"interestRate": nil,
|
|
"estimatedSettlePrice": nil,
|
|
"timestamp": nil,
|
|
"datetime": nil,
|
|
"fundingRate": this.SafeNumber(contract, "lastFundingRate"),
|
|
"fundingTimestamp": nil,
|
|
"fundingDatetime": nil,
|
|
"nextFundingRate": nil,
|
|
"nextFundingTimestamp": nextFundingTimestamp,
|
|
"nextFundingDatetime": this.Iso8601(nextFundingTimestamp),
|
|
"previousFundingRate": nil,
|
|
"previousFundingTimestamp": nil,
|
|
"previousFundingDatetime": nil,
|
|
"interval": nil,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchFundingRateHistory
|
|
* @description fetches historical funding rate prices
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Funding%20Rate%20History
|
|
* @param {string} symbol unified symbol of the market to fetch the funding rate history for
|
|
* @param {int} [since] timestamp in ms of the earliest funding rate to fetch
|
|
* @param {int} [limit] the maximum amount of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure} to fetch
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] timestamp in ms of the latest funding rate to fetch
|
|
* @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 [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure}
|
|
*/
|
|
func (this *bingx) FetchFundingRateHistory(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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchFundingRateHistory() requires a symbol argument")))
|
|
}
|
|
|
|
retRes16348 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes16348)
|
|
var paginate interface{} = false
|
|
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchFundingRateHistory", "paginate");
|
|
paginate = GetValue(paginateparamsVariable,0);
|
|
params = GetValue(paginateparamsVariable,1)
|
|
if IsTrue(paginate) {
|
|
|
|
retRes163819 := (<-this.FetchPaginatedCallDeterministic("fetchFundingRateHistory", symbol, since, limit, "8h", params))
|
|
PanicOnError(retRes163819)
|
|
ch <- retRes163819
|
|
return nil
|
|
}
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTime", since)
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit)
|
|
}
|
|
var until interface{} = this.SafeInteger2(params, "until", "startTime")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
AddElementToObject(request, "startTime", until)
|
|
}
|
|
|
|
response:= (<-this.SwapV2PublicGetQuoteFundingRate(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code":0,
|
|
// "msg":"",
|
|
// "data":[
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "fundingRate": "0.0001",
|
|
// "fundingTime": 1585684800000
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParseFundingRateHistories(data, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseFundingRateHistory(contract interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "fundingRate": "0.0001",
|
|
// "fundingTime": 1585684800000
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var timestamp interface{} = this.SafeInteger(contract, "fundingTime")
|
|
return map[string]interface{} {
|
|
"info": contract,
|
|
"symbol": this.SafeSymbol(this.SafeString(contract, "symbol"), market, "-", "swap"),
|
|
"fundingRate": this.SafeNumber(contract, "fundingRate"),
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchOpenInterest
|
|
* @description retrieves the open interest of a trading pair
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/market-api.html#Get%20Swap%20Open%20Positions
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Get%20Swap%20Open%20Positions
|
|
* @param {string} symbol unified CCXT market symbol
|
|
* @param {object} [params] exchange specific parameters
|
|
* @returns {object} an open interest structure{@link https://docs.ccxt.com/#/?id=open-interest-structure}
|
|
*/
|
|
func (this *bingx) FetchOpenInterest(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
|
|
|
|
retRes17038 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes17038)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketOpenInterest(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuoteOpenInterest(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "openInterest": "3289641547.10",
|
|
// "symbol": "BTC-USDT",
|
|
// "time": 1672026617364
|
|
// }
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1720328247986,
|
|
// "data": [
|
|
// {
|
|
// "symbol": "BTC-USD",
|
|
// "openInterest": "749.1160",
|
|
// "timestamp": 1720310400000
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var result interface{} = map[string]interface{} {}
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
|
result = this.SafeDict(data, 0, map[string]interface{} {})
|
|
} else {
|
|
result = this.SafeDict(response, "data", map[string]interface{} {})
|
|
}
|
|
|
|
ch <- this.ParseOpenInterest(result, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseOpenInterest(interest interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "openInterest": "3289641547.10",
|
|
// "symbol": "BTC-USDT",
|
|
// "time": 1672026617364
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "symbol": "BTC-USD",
|
|
// "openInterest": "749.1160",
|
|
// "timestamp": 1720310400000
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var timestamp interface{} = this.SafeInteger2(interest, "time", "timestamp")
|
|
var id interface{} = this.SafeString(interest, "symbol")
|
|
var symbol interface{} = this.SafeSymbol(id, market, "-", "swap")
|
|
var openInterest interface{} = this.SafeNumber(interest, "openInterest")
|
|
return this.SafeOpenInterest(map[string]interface{} {
|
|
"symbol": symbol,
|
|
"baseVolume": nil,
|
|
"quoteVolume": nil,
|
|
"openInterestAmount": nil,
|
|
"openInterestValue": openInterest,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"info": interest,
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchTicker
|
|
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#Get%20Ticker
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/market-api.html#24-hour%20price%20changes
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Query%2024-Hour%20Price%20Change
|
|
* @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 *bingx) 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
|
|
|
|
retRes17988 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes17988)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
|
|
response = (<-this.SpotV1PublicGetTicker24hr(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketTicker(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuoteTicker(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
//
|
|
// spot and swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1720647285296,
|
|
// "data": [
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "priceChange": "-2.418",
|
|
// "priceChangePercent": "-1.6900%",
|
|
// "lastPrice": "140.574",
|
|
// "lastQty": "1",
|
|
// "highPrice": "146.190",
|
|
// "lowPrice": "138.586",
|
|
// "volume": "1464648.00",
|
|
// "quoteVolume": "102928.12",
|
|
// "openPrice": "142.994",
|
|
// "closeTime": "1720647284976",
|
|
// "bidPrice": "140.573",
|
|
// "bidQty": "372",
|
|
// "askPrice": "140.577",
|
|
// "askQty": "58"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeList(response, "data")
|
|
if IsTrue(!IsEqual(data, nil)) {
|
|
var first interface{} = this.SafeDict(data, 0, map[string]interface{} {})
|
|
|
|
ch <- this.ParseTicker(first, market)
|
|
return nil
|
|
}
|
|
var dataDict interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
|
|
ch <- this.ParseTicker(dataDict, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchTickers
|
|
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#Get%20Ticker
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/market-api.html#24-hour%20price%20changes
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/market-api.html#Query%2024-Hour%20Price%20Change
|
|
* @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 *bingx) 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
|
|
|
|
retRes18628 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes18628)
|
|
var market interface{} = nil
|
|
if IsTrue(!IsEqual(symbols, nil)) {
|
|
symbols = this.MarketSymbols(symbols)
|
|
var firstSymbol interface{} = this.SafeString(symbols, 0)
|
|
if IsTrue(!IsEqual(firstSymbol, nil)) {
|
|
market = this.Market(firstSymbol)
|
|
}
|
|
}
|
|
var typeVar interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("fetchTickers", market, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchTickers", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
var response interface{} = nil
|
|
if IsTrue(IsEqual(typeVar, "spot")) {
|
|
|
|
response = (<-this.SpotV1PublicGetTicker24hr(params))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketTicker(params))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuoteTicker(params))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
//
|
|
// spot and swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1720647285296,
|
|
// "data": [
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "priceChange": "-2.418",
|
|
// "priceChangePercent": "-1.6900%",
|
|
// "lastPrice": "140.574",
|
|
// "lastQty": "1",
|
|
// "highPrice": "146.190",
|
|
// "lowPrice": "138.586",
|
|
// "volume": "1464648.00",
|
|
// "quoteVolume": "102928.12",
|
|
// "openPrice": "142.994",
|
|
// "closeTime": "1720647284976",
|
|
// "bidPrice": "140.573",
|
|
// "bidQty": "372",
|
|
// "askPrice": "140.577",
|
|
// "askQty": "58"
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
var tickers interface{} = this.SafeList(response, "data")
|
|
|
|
ch <- this.ParseTickers(tickers, symbols)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchMarkPrice
|
|
* @description fetches mark prices for the market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#Mark%20Price%20and%20Funding%20Rate
|
|
* @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 dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes19288 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes19288)
|
|
var market interface{} = this.Market(symbol)
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchMarkPrice", market, params, "linear");
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketPremiumIndex(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuotePremiumIndex(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
if IsTrue(IsArray(GetValue(response, "data"))) {
|
|
|
|
ch <- this.ParseTicker(this.SafeDict(GetValue(response, "data"), 0, map[string]interface{} {}), market)
|
|
return nil
|
|
}
|
|
|
|
ch <- this.ParseTicker(GetValue(response, "data"), market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchMarkPrices
|
|
* @description fetches mark prices for multiple markets
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/market-api.html#Mark%20Price%20and%20Funding%20Rate
|
|
* @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 *bingx) 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
|
|
|
|
retRes19868 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes19868)
|
|
var market interface{} = nil
|
|
if IsTrue(!IsEqual(symbols, nil)) {
|
|
symbols = this.MarketSymbols(symbols)
|
|
var firstSymbol interface{} = this.SafeString(symbols, 0)
|
|
if IsTrue(!IsEqual(firstSymbol, nil)) {
|
|
market = this.Market(firstSymbol)
|
|
}
|
|
}
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchMarkPrices", market, params, "linear");
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
var response interface{} = nil
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PublicGetMarketPremiumIndex(params))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PublicGetQuotePremiumIndex(params))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// spot and swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1720647285296,
|
|
// "data": [
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "priceChange": "-2.418",
|
|
// "priceChangePercent": "-1.6900%",
|
|
// "lastPrice": "140.574",
|
|
// "lastQty": "1",
|
|
// "highPrice": "146.190",
|
|
// "lowPrice": "138.586",
|
|
// "volume": "1464648.00",
|
|
// "quoteVolume": "102928.12",
|
|
// "openPrice": "142.994",
|
|
// "closeTime": "1720647284976",
|
|
// "bidPrice": "140.573",
|
|
// "bidQty": "372",
|
|
// "askPrice": "140.577",
|
|
// "askQty": "58"
|
|
// },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
var tickers interface{} = this.SafeList(response, "data")
|
|
|
|
ch <- this.ParseTickers(tickers, symbols)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// mark price
|
|
// {
|
|
// "symbol": "string",
|
|
// "lastFundingRate": "string",
|
|
// "markPrice": "string",
|
|
// "indexPrice": "string",
|
|
// "nextFundingTime": "int64"
|
|
// }
|
|
//
|
|
// spot
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "openPrice": "26032.08",
|
|
// "highPrice": "26178.86",
|
|
// "lowPrice": "25968.18",
|
|
// "lastPrice": "26113.60",
|
|
// "volume": "1161.79",
|
|
// "quoteVolume": "30288466.44",
|
|
// "openTime": "1693081020762",
|
|
// "closeTime": "1693167420762",
|
|
// added 2023-11-10:
|
|
// "bidPrice": 16726.0,
|
|
// "bidQty": 0.05,
|
|
// "askPrice": 16726.0,
|
|
// "askQty": 0.05,
|
|
// }
|
|
// swap
|
|
//
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "priceChange": "52.5",
|
|
// "priceChangePercent": "0.31%", // they started to add the percent sign in value
|
|
// "lastPrice": "16880.5",
|
|
// "lastQty": "2.2238", // only present in swap!
|
|
// "highPrice": "16897.5",
|
|
// "lowPrice": "16726.0",
|
|
// "volume": "245870.1692",
|
|
// "quoteVolume": "4151395117.73",
|
|
// "openPrice": "16832.0",
|
|
// "openTime": 1672026667803,
|
|
// "closeTime": 1672026648425,
|
|
// added 2023-11-10:
|
|
// "bidPrice": 16726.0,
|
|
// "bidQty": 0.05,
|
|
// "askPrice": 16726.0,
|
|
// "askQty": 0.05,
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(ticker, "symbol")
|
|
var lastQty interface{} = this.SafeString(ticker, "lastQty")
|
|
// in spot markets, lastQty is not present
|
|
// it's (bad, but) the only way we can check the tickers origin
|
|
var typeVar interface{} = Ternary(IsTrue((IsEqual(lastQty, nil))), "spot", "swap")
|
|
market = this.SafeMarket(marketId, market, nil, typeVar)
|
|
var symbol interface{} = GetValue(market, "symbol")
|
|
var open interface{} = this.SafeString(ticker, "openPrice")
|
|
var high interface{} = this.SafeString(ticker, "highPrice")
|
|
var low interface{} = this.SafeString(ticker, "lowPrice")
|
|
var close interface{} = this.SafeString(ticker, "lastPrice")
|
|
var quoteVolume interface{} = this.SafeString(ticker, "quoteVolume")
|
|
var baseVolume interface{} = this.SafeString(ticker, "volume")
|
|
var percentage interface{} = this.SafeString(ticker, "priceChangePercent")
|
|
if IsTrue(!IsEqual(percentage, nil)) {
|
|
percentage = Replace(percentage, "%", "")
|
|
}
|
|
var change interface{} = this.SafeString(ticker, "priceChange")
|
|
var ts interface{} = this.SafeInteger(ticker, "closeTime")
|
|
if IsTrue(IsEqual(ts, 0)) {
|
|
ts = nil
|
|
}
|
|
var datetime interface{} = this.Iso8601(ts)
|
|
var bid interface{} = this.SafeString(ticker, "bidPrice")
|
|
var bidVolume interface{} = this.SafeString(ticker, "bidQty")
|
|
var ask interface{} = this.SafeString(ticker, "askPrice")
|
|
var askVolume interface{} = this.SafeString(ticker, "askQty")
|
|
return this.SafeTicker(map[string]interface{} {
|
|
"symbol": symbol,
|
|
"timestamp": ts,
|
|
"datetime": datetime,
|
|
"high": high,
|
|
"low": low,
|
|
"bid": bid,
|
|
"bidVolume": bidVolume,
|
|
"ask": ask,
|
|
"askVolume": askVolume,
|
|
"vwap": nil,
|
|
"open": open,
|
|
"close": close,
|
|
"last": nil,
|
|
"previousClose": nil,
|
|
"change": change,
|
|
"percentage": percentage,
|
|
"average": nil,
|
|
"baseVolume": baseVolume,
|
|
"quoteVolume": quoteVolume,
|
|
"markPrice": this.SafeString(ticker, "markPrice"),
|
|
"indexPrice": this.SafeString(ticker, "indexPrice"),
|
|
"info": ticker,
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchBalance
|
|
* @description query for balance and get the amount of funds available for trading or funds locked in orders
|
|
* @see https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Assets
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/account-api.html#Get%20Perpetual%20Swap%20Account%20Asset%20Information
|
|
* @see https://bingx-api.github.io/docs/#/standard/contract-interface.html#Query%20standard%20contract%20balance
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Account%20Assets
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {boolean} [params.standard] whether to fetch standard contract balances
|
|
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes21528 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes21528)
|
|
var response interface{} = nil
|
|
var standard interface{} = nil
|
|
standardparamsVariable := this.HandleOptionAndParams(params, "fetchBalance", "standard", false);
|
|
standard = GetValue(standardparamsVariable,0);
|
|
params = GetValue(standardparamsVariable,1)
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchBalance", nil, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
marketTypemarketTypeQueryVariable := this.HandleMarketTypeAndParams("fetchBalance", nil, params);
|
|
marketType := GetValue(marketTypemarketTypeQueryVariable,0);
|
|
marketTypeQuery := GetValue(marketTypemarketTypeQueryVariable,1)
|
|
if IsTrue(standard) {
|
|
|
|
response = (<-this.ContractV1PrivateGetBalance(marketTypeQuery))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsEqual(marketType, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivateGetAccountBalance(marketTypeQuery))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetUserBalance(marketTypeQuery))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetUserBalance(marketTypeQuery))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
|
|
ch <- this.ParseBalance(response)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseBalance(response interface{}) interface{} {
|
|
//
|
|
// standard
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "timestamp": 1721192833454,
|
|
// "data": [
|
|
// {
|
|
// "asset": "USDT",
|
|
// "balance": "4.72644300000000000000",
|
|
// "crossWalletBalance": "4.72644300000000000000",
|
|
// "crossUnPnl": "0",
|
|
// "availableBalance": "4.72644300000000000000",
|
|
// "maxWithdrawAmount": "4.72644300000000000000",
|
|
// "marginAvailable": false,
|
|
// "updateTime": 1721192833443
|
|
// },
|
|
// ]
|
|
// }
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "debugMsg": "",
|
|
// "data": {
|
|
// "balances": [
|
|
// {
|
|
// "asset": "USDT",
|
|
// "free": "45.733046995800514",
|
|
// "locked": "0"
|
|
// },
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1721191833813,
|
|
// "data": [
|
|
// {
|
|
// "asset": "SOL",
|
|
// "balance": "0.35707951",
|
|
// "equity": "0.35791051",
|
|
// "unrealizedProfit": "0.00083099",
|
|
// "availableMargin": "0.35160653",
|
|
// "usedMargin": "0.00630397",
|
|
// "freezedMargin": "0",
|
|
// "shortUid": "12851936"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "balance": {
|
|
// "userId": "1177064765068660742",
|
|
// "asset": "USDT",
|
|
// "balance": "51.5198",
|
|
// "equity": "50.5349",
|
|
// "unrealizedProfit": "-0.9849",
|
|
// "realisedProfit": "-0.2134",
|
|
// "availableMargin": "49.1428",
|
|
// "usedMargin": "1.3922",
|
|
// "freezedMargin": "0.0000",
|
|
// "shortUid": "12851936"
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
var result interface{} = map[string]interface{} {
|
|
"info": response,
|
|
}
|
|
var standardAndInverseBalances interface{} = this.SafeList(response, "data")
|
|
var firstStandardOrInverse interface{} = this.SafeDict(standardAndInverseBalances, 0)
|
|
var isStandardOrInverse interface{} = !IsEqual(firstStandardOrInverse, nil)
|
|
var spotData interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var spotBalances interface{} = this.SafeList(spotData, "balances")
|
|
var firstSpot interface{} = this.SafeDict(spotBalances, 0)
|
|
var isSpot interface{} = !IsEqual(firstSpot, nil)
|
|
if IsTrue(isStandardOrInverse) {
|
|
for i := 0; IsLessThan(i, GetArrayLength(standardAndInverseBalances)); i++ {
|
|
var balance interface{} = GetValue(standardAndInverseBalances, i)
|
|
var currencyId interface{} = this.SafeString(balance, "asset")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId)
|
|
var account interface{} = this.Account()
|
|
AddElementToObject(account, "free", this.SafeString2(balance, "availableMargin", "availableBalance"))
|
|
AddElementToObject(account, "used", this.SafeString(balance, "usedMargin"))
|
|
AddElementToObject(account, "total", this.SafeString(balance, "maxWithdrawAmount"))
|
|
AddElementToObject(result, code, account)
|
|
}
|
|
} else if IsTrue(isSpot) {
|
|
for i := 0; IsLessThan(i, GetArrayLength(spotBalances)); i++ {
|
|
var balance interface{} = GetValue(spotBalances, i)
|
|
var currencyId interface{} = this.SafeString(balance, "asset")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId)
|
|
var account interface{} = this.Account()
|
|
AddElementToObject(account, "free", this.SafeString(balance, "free"))
|
|
AddElementToObject(account, "used", this.SafeString(balance, "locked"))
|
|
AddElementToObject(result, code, account)
|
|
}
|
|
} else {
|
|
var linearSwapData interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var linearSwapBalance interface{} = this.SafeDict(linearSwapData, "balance")
|
|
if IsTrue(linearSwapBalance) {
|
|
var currencyId interface{} = this.SafeString(linearSwapBalance, "asset")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId)
|
|
var account interface{} = this.Account()
|
|
AddElementToObject(account, "free", this.SafeString(linearSwapBalance, "availableMargin"))
|
|
AddElementToObject(account, "used", this.SafeString(linearSwapBalance, "usedMargin"))
|
|
AddElementToObject(result, code, account)
|
|
}
|
|
}
|
|
return this.SafeBalance(result)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchPositionHistory
|
|
* @description fetches historical positions
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Position%20History
|
|
* @param {string} symbol unified contract symbol
|
|
* @param {int} [since] the earliest time in ms to fetch positions for
|
|
* @param {int} [limit] the maximum amount of records to fetch
|
|
* @param {object} [params] extra parameters specific to the exchange api endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch positions for
|
|
* @returns {object[]} a list of [position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
|
|
*/
|
|
func (this *bingx) FetchPositionHistory(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
|
|
|
|
retRes23828 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes23828)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "pageSize", limit)
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTs", since)
|
|
}
|
|
requestparamsVariable := this.HandleUntilOption("endTs", request, params);
|
|
request = GetValue(requestparamsVariable,0);
|
|
params = GetValue(requestparamsVariable,1)
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "linear")) {
|
|
|
|
response = (<-this.SwapV1PrivateGetTradePositionHistory(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
panic(NotSupported(Add(this.Id, " fetchPositionHistory() is not supported for inverse swap positions")))
|
|
}
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "positionHistory": [
|
|
// {
|
|
// "positionId": "1861675561156571136",
|
|
// "symbol": "LTC-USDT",
|
|
// "isolated": false,
|
|
// "positionSide": "LONG",
|
|
// "openTime": 1732693017000,
|
|
// "updateTime": 1733310292000,
|
|
// "avgPrice": "95.18",
|
|
// "avgClosePrice": "129.48",
|
|
// "realisedProfit": "102.89",
|
|
// "netProfit": "99.63",
|
|
// "positionAmt": "30.0",
|
|
// "closePositionAmt": "30.0",
|
|
// "leverage": 6,
|
|
// "closeAllPositions": true,
|
|
// "positionCommission": "-0.33699650000000003",
|
|
// "totalFunding": "-2.921461693902908"
|
|
// },
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var records interface{} = this.SafeList(data, "positionHistory", []interface{}{})
|
|
var positions interface{} = this.ParsePositions(records)
|
|
|
|
ch <- this.FilterBySymbolSinceLimit(positions, symbol, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchPositions
|
|
* @description fetch all open positions
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/account-api.html#Query%20position%20data
|
|
* @see https://bingx-api.github.io/docs/#/en-us/standard/contract-interface.html#position
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20warehouse
|
|
* @param {string[]|undefined} symbols list of unified market symbols
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {boolean} [params.standard] whether to fetch standard contract positions
|
|
* @returns {object[]} a list of [position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
|
|
*/
|
|
func (this *bingx) FetchPositions(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
|
|
|
|
retRes24478 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes24478)
|
|
symbols = this.MarketSymbols(symbols)
|
|
var standard interface{} = nil
|
|
standardparamsVariable := this.HandleOptionAndParams(params, "fetchPositions", "standard", false);
|
|
standard = GetValue(standardparamsVariable,0);
|
|
params = GetValue(standardparamsVariable,1)
|
|
var response interface{} = nil
|
|
if IsTrue(standard) {
|
|
|
|
response = (<-this.ContractV1PrivateGetAllPosition(params))
|
|
PanicOnError(response)
|
|
} else {
|
|
var market interface{} = nil
|
|
if IsTrue(!IsEqual(symbols, nil)) {
|
|
symbols = this.MarketSymbols(symbols)
|
|
var firstSymbol interface{} = this.SafeString(symbols, 0)
|
|
if IsTrue(!IsEqual(firstSymbol, nil)) {
|
|
market = this.Market(firstSymbol)
|
|
}
|
|
}
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchPositions", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetUserPositions(params))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetUserPositions(params))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
var positions interface{} = this.SafeList(response, "data", []interface{}{})
|
|
|
|
ch <- this.ParsePositions(positions, symbols)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchPosition
|
|
* @description fetch data on a single open contract trade position
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/account-api.html#Query%20position%20data
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20warehouse
|
|
* @param {string} symbol unified market symbol of the market the position is held in
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
|
|
*/
|
|
func (this *bingx) FetchPosition(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
|
|
|
|
retRes25438 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes25438)
|
|
var market interface{} = this.Market(symbol)
|
|
if !IsTrue(GetValue(market, "swap")) {
|
|
panic(BadRequest(Add(this.Id, " fetchPosition() supports swap markets only")))
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetUserPositions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetUserPositions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
var data interface{} = this.SafeList(response, "data", []interface{}{})
|
|
var first interface{} = this.SafeDict(data, 0, map[string]interface{} {})
|
|
|
|
ch <- this.ParsePosition(first, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "positionId": "1813080351385337856",
|
|
// "positionSide": "LONG",
|
|
// "isolated": false,
|
|
// "positionAmt": "1",
|
|
// "availableAmt": "1",
|
|
// "unrealizedProfit": "-0.00009074",
|
|
// "initialMargin": "0.00630398",
|
|
// "liquidationPrice": 23.968303426677032,
|
|
// "avgPrice": "158.63",
|
|
// "leverage": 10,
|
|
// "markPrice": "158.402",
|
|
// "riskRate": "0.00123783",
|
|
// "maxMarginReduction": "0",
|
|
// "updateTime": 1721107015848
|
|
// }
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "positionId": "1792480725958881280",
|
|
// "symbol": "LTC-USDT",
|
|
// "currency": "USDT",
|
|
// "positionAmt": "0.1",
|
|
// "availableAmt": "0.1",
|
|
// "positionSide": "LONG",
|
|
// "isolated": false,
|
|
// "avgPrice": "83.53",
|
|
// "initialMargin": "1.3922",
|
|
// "margin": "0.3528",
|
|
// "leverage": 6,
|
|
// "unrealizedProfit": "-1.0393",
|
|
// "realisedProfit": "-0.2119",
|
|
// "liquidationPrice": 0,
|
|
// "pnlRatio": "-0.7465",
|
|
// "maxMarginReduction": "0.0000",
|
|
// "riskRate": "0.0008",
|
|
// "markPrice": "73.14",
|
|
// "positionValue": "7.3136",
|
|
// "onlyOnePosition": true,
|
|
// "updateTime": 1721088016688
|
|
// }
|
|
//
|
|
// standard position
|
|
//
|
|
// {
|
|
// "currentPrice": "82.91",
|
|
// "symbol": "LTC/USDT",
|
|
// "initialMargin": "5.00000000000000000000",
|
|
// "unrealizedProfit": "-0.26464500",
|
|
// "leverage": "20.000000000",
|
|
// "isolated": true,
|
|
// "entryPrice": "83.13",
|
|
// "positionSide": "LONG",
|
|
// "positionAmt": "1.20365912",
|
|
// }
|
|
//
|
|
// linear swap fetchPositionHistory
|
|
//
|
|
// {
|
|
// "positionId": "1861675561156571136",
|
|
// "symbol": "LTC-USDT",
|
|
// "isolated": false,
|
|
// "positionSide": "LONG",
|
|
// "openTime": 1732693017000,
|
|
// "updateTime": 1733310292000,
|
|
// "avgPrice": "95.18",
|
|
// "avgClosePrice": "129.48",
|
|
// "realisedProfit": "102.89",
|
|
// "netProfit": "99.63",
|
|
// "positionAmt": "30.0",
|
|
// "closePositionAmt": "30.0",
|
|
// "leverage": 6,
|
|
// "closeAllPositions": true,
|
|
// "positionCommission": "-0.33699650000000003",
|
|
// "totalFunding": "-2.921461693902908"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(position, "symbol", "")
|
|
marketId = Replace(marketId, "/", "-") // standard return different format
|
|
var isolated interface{} = this.SafeBool(position, "isolated")
|
|
var marginMode interface{} = nil
|
|
if IsTrue(!IsEqual(isolated, nil)) {
|
|
marginMode = Ternary(IsTrue(isolated), "isolated", "cross")
|
|
}
|
|
var timestamp interface{} = this.SafeInteger(position, "openTime")
|
|
return this.SafePosition(map[string]interface{} {
|
|
"info": position,
|
|
"id": this.SafeString(position, "positionId"),
|
|
"symbol": this.SafeSymbol(marketId, market, "-", "swap"),
|
|
"notional": this.SafeNumber(position, "positionValue"),
|
|
"marginMode": marginMode,
|
|
"liquidationPrice": nil,
|
|
"entryPrice": this.SafeNumber2(position, "avgPrice", "entryPrice"),
|
|
"unrealizedPnl": this.SafeNumber(position, "unrealizedProfit"),
|
|
"realizedPnl": this.SafeNumber(position, "realisedProfit"),
|
|
"percentage": nil,
|
|
"contracts": this.SafeNumber(position, "positionAmt"),
|
|
"contractSize": nil,
|
|
"markPrice": this.SafeNumber(position, "markPrice"),
|
|
"lastPrice": nil,
|
|
"side": this.SafeStringLower(position, "positionSide"),
|
|
"hedged": nil,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"lastUpdateTimestamp": this.SafeInteger(position, "updateTime"),
|
|
"maintenanceMargin": nil,
|
|
"maintenanceMarginPercentage": nil,
|
|
"collateral": nil,
|
|
"initialMargin": this.SafeNumber(position, "initialMargin"),
|
|
"initialMarginPercentage": nil,
|
|
"leverage": this.SafeNumber(position, "leverage"),
|
|
"marginRatio": nil,
|
|
"stopLossPrice": nil,
|
|
"takeProfitPrice": nil,
|
|
})
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#createMarketOrderWithCost
|
|
* @description create a market order by providing the symbol, side and cost
|
|
* @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 *bingx) 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
|
|
AddElementToObject(params, "quoteOrderQty", cost)
|
|
|
|
retRes275415 := (<-this.CreateOrder(symbol, "market", side, cost, nil, params))
|
|
PanicOnError(retRes275415)
|
|
ch <- retRes275415
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#createMarketBuyOrderWithCost
|
|
* @description create a market buy order by providing the symbol and cost
|
|
* @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 *bingx) 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
|
|
AddElementToObject(params, "quoteOrderQty", cost)
|
|
|
|
retRes276815 := (<-this.CreateOrder(symbol, "market", "buy", cost, nil, params))
|
|
PanicOnError(retRes276815)
|
|
ch <- retRes276815
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#createMarketSellOrderWithCost
|
|
* @description create a market sell order by providing the symbol and cost
|
|
* @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 *bingx) 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
|
|
AddElementToObject(params, "quoteOrderQty", cost)
|
|
|
|
retRes278215 := (<-this.CreateOrder(symbol, "market", "sell", cost, nil, params))
|
|
PanicOnError(retRes278215)
|
|
ch <- retRes278215
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) CreateOrderRequest(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) interface{} {
|
|
/**
|
|
* @method
|
|
* @ignore
|
|
* @name bingx#createOrderRequest
|
|
* @description helper function to build request
|
|
* @param {string} symbol unified symbol of the market to create an order in
|
|
* @param {string} type 'market' or 'limit'
|
|
* @param {string} side 'buy' or 'sell'
|
|
* @param {float} amount how much 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
|
|
* @returns {object} request to be sent to the exchange
|
|
*/
|
|
price := GetArg(optionalArgs, 0, nil)
|
|
_ = price
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
var market interface{} = this.Market(symbol)
|
|
var postOnly interface{} = nil
|
|
var marketType interface{} = nil
|
|
marketTypeparamsVariable := this.HandleMarketTypeAndParams("createOrder", market, params);
|
|
marketType = GetValue(marketTypeparamsVariable,0);
|
|
params = GetValue(marketTypeparamsVariable,1)
|
|
typeVar = ToUpper(typeVar)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"type": typeVar,
|
|
"side": ToUpper(side),
|
|
}
|
|
var isMarketOrder interface{} = IsEqual(typeVar, "MARKET")
|
|
var isSpot interface{} = IsEqual(marketType, "spot")
|
|
var isTwapOrder interface{} = IsEqual(typeVar, "TWAP")
|
|
if IsTrue(IsTrue(isTwapOrder) && IsTrue(isSpot)) {
|
|
panic(BadSymbol(Add(this.Id, " createOrder() twap order supports swap contracts only")))
|
|
}
|
|
var stopLossPrice interface{} = this.SafeString(params, "stopLossPrice")
|
|
var takeProfitPrice interface{} = this.SafeString(params, "takeProfitPrice")
|
|
var triggerPrice interface{} = this.SafeString2(params, "stopPrice", "triggerPrice")
|
|
var isTriggerOrder interface{} = !IsEqual(triggerPrice, nil)
|
|
var isStopLossPriceOrder interface{} = !IsEqual(stopLossPrice, nil)
|
|
var isTakeProfitPriceOrder interface{} = !IsEqual(takeProfitPrice, nil)
|
|
var exchangeClientOrderId interface{} = Ternary(IsTrue(isSpot), "newClientOrderId", "clientOrderID")
|
|
var clientOrderId interface{} = this.SafeString2(params, exchangeClientOrderId, "clientOrderId")
|
|
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
|
AddElementToObject(request, exchangeClientOrderId, clientOrderId)
|
|
}
|
|
var timeInForce interface{} = this.SafeStringUpper(params, "timeInForce")
|
|
postOnlyparamsVariable := this.HandlePostOnly(isMarketOrder, IsEqual(timeInForce, "PostOnly"), params);
|
|
postOnly = GetValue(postOnlyparamsVariable,0);
|
|
params = GetValue(postOnlyparamsVariable,1)
|
|
if IsTrue(IsTrue(postOnly) || IsTrue((IsEqual(timeInForce, "PostOnly")))) {
|
|
AddElementToObject(request, "timeInForce", "PostOnly")
|
|
} else if IsTrue(IsEqual(timeInForce, "IOC")) {
|
|
AddElementToObject(request, "timeInForce", "IOC")
|
|
} else if IsTrue(IsEqual(timeInForce, "GTC")) {
|
|
AddElementToObject(request, "timeInForce", "GTC")
|
|
}
|
|
if IsTrue(isSpot) {
|
|
var cost interface{} = this.SafeString2(params, "cost", "quoteOrderQty")
|
|
params = this.Omit(params, "cost")
|
|
if IsTrue(!IsEqual(cost, nil)) {
|
|
AddElementToObject(request, "quoteOrderQty", this.ParseToNumeric(this.CostToPrecision(symbol, cost)))
|
|
} else {
|
|
if IsTrue(IsTrue(isMarketOrder) && IsTrue((!IsEqual(price, nil)))) {
|
|
// keep the legacy behavior, to avoid breaking the old spot-market-buying code
|
|
var calculatedCost interface{} = Precise.StringMul(this.NumberToString(amount), this.NumberToString(price))
|
|
AddElementToObject(request, "quoteOrderQty", this.ParseToNumeric(calculatedCost))
|
|
} else {
|
|
AddElementToObject(request, "quantity", this.ParseToNumeric(this.AmountToPrecision(symbol, amount)))
|
|
}
|
|
}
|
|
if !IsTrue(isMarketOrder) {
|
|
AddElementToObject(request, "price", this.ParseToNumeric(this.PriceToPrecision(symbol, price)))
|
|
}
|
|
if IsTrue(!IsEqual(triggerPrice, nil)) {
|
|
if IsTrue(IsTrue(isMarketOrder) && IsTrue(IsEqual(this.SafeString(request, "quoteOrderQty"), nil))) {
|
|
panic(ArgumentsRequired(Add(this.Id, " createOrder() requires the cost parameter (or the amount + price) for placing spot market-buy trigger orders")))
|
|
}
|
|
AddElementToObject(request, "stopPrice", this.PriceToPrecision(symbol, triggerPrice))
|
|
if IsTrue(IsEqual(typeVar, "LIMIT")) {
|
|
AddElementToObject(request, "type", "TRIGGER_LIMIT")
|
|
} else if IsTrue(IsEqual(typeVar, "MARKET")) {
|
|
AddElementToObject(request, "type", "TRIGGER_MARKET")
|
|
}
|
|
} else if IsTrue(IsTrue((!IsEqual(stopLossPrice, nil))) || IsTrue((!IsEqual(takeProfitPrice, nil)))) {
|
|
var stopTakePrice interface{} = Ternary(IsTrue((!IsEqual(stopLossPrice, nil))), stopLossPrice, takeProfitPrice)
|
|
if IsTrue(IsEqual(typeVar, "LIMIT")) {
|
|
AddElementToObject(request, "type", "TAKE_STOP_LIMIT")
|
|
} else if IsTrue(IsEqual(typeVar, "MARKET")) {
|
|
AddElementToObject(request, "type", "TAKE_STOP_MARKET")
|
|
}
|
|
AddElementToObject(request, "stopPrice", this.ParseToNumeric(this.PriceToPrecision(symbol, stopTakePrice)))
|
|
}
|
|
} else {
|
|
if IsTrue(isTwapOrder) {
|
|
var twapRequest interface{} = map[string]interface{} {
|
|
"symbol": GetValue(request, "symbol"),
|
|
"side": GetValue(request, "side"),
|
|
"positionSide": Ternary(IsTrue((IsEqual(side, "buy"))), "LONG", "SHORT"),
|
|
"triggerPrice": this.ParseToNumeric(this.PriceToPrecision(symbol, triggerPrice)),
|
|
"totalAmount": this.ParseToNumeric(this.AmountToPrecision(symbol, amount)),
|
|
}
|
|
// {
|
|
// "symbol": "LTC-USDT",
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "priceType": "constant",
|
|
// "priceVariance": "10",
|
|
// "triggerPrice": "120",
|
|
// "interval": 8,
|
|
// "amountPerOrder": "0.5",
|
|
// "totalAmount": "1"
|
|
// }
|
|
return this.Extend(twapRequest, params)
|
|
}
|
|
if IsTrue(IsEqual(timeInForce, "FOK")) {
|
|
AddElementToObject(request, "timeInForce", "FOK")
|
|
}
|
|
var trailingAmount interface{} = this.SafeString(params, "trailingAmount")
|
|
var trailingPercent interface{} = this.SafeString2(params, "trailingPercent", "priceRate")
|
|
var trailingType interface{} = this.SafeString(params, "trailingType", "TRAILING_STOP_MARKET")
|
|
var isTrailingAmountOrder interface{} = !IsEqual(trailingAmount, nil)
|
|
var isTrailingPercentOrder interface{} = !IsEqual(trailingPercent, nil)
|
|
var isTrailing interface{} = IsTrue(isTrailingAmountOrder) || IsTrue(isTrailingPercentOrder)
|
|
var stopLoss interface{} = this.SafeValue(params, "stopLoss")
|
|
var takeProfit interface{} = this.SafeValue(params, "takeProfit")
|
|
var isStopLoss interface{} = !IsEqual(stopLoss, nil)
|
|
var isTakeProfit interface{} = !IsEqual(takeProfit, nil)
|
|
if IsTrue(IsTrue((IsTrue(IsTrue(IsTrue((IsEqual(typeVar, "LIMIT"))) || IsTrue((IsEqual(typeVar, "TRIGGER_LIMIT")))) || IsTrue((IsEqual(typeVar, "STOP")))) || IsTrue((IsEqual(typeVar, "TAKE_PROFIT"))))) && !IsTrue(isTrailing)) {
|
|
AddElementToObject(request, "price", this.ParseToNumeric(this.PriceToPrecision(symbol, price)))
|
|
}
|
|
var reduceOnly interface{} = this.SafeBool(params, "reduceOnly", false)
|
|
if IsTrue(isTriggerOrder) {
|
|
AddElementToObject(request, "stopPrice", this.ParseToNumeric(this.PriceToPrecision(symbol, triggerPrice)))
|
|
if IsTrue(IsTrue(isMarketOrder) || IsTrue((IsEqual(typeVar, "TRIGGER_MARKET")))) {
|
|
AddElementToObject(request, "type", "TRIGGER_MARKET")
|
|
} else if IsTrue(IsTrue((IsEqual(typeVar, "LIMIT"))) || IsTrue((IsEqual(typeVar, "TRIGGER_LIMIT")))) {
|
|
AddElementToObject(request, "type", "TRIGGER_LIMIT")
|
|
}
|
|
} else if IsTrue(IsTrue(isStopLossPriceOrder) || IsTrue(isTakeProfitPriceOrder)) {
|
|
// This can be used to set the stop loss and take profit, but the position needs to be opened first
|
|
reduceOnly = true
|
|
if IsTrue(isStopLossPriceOrder) {
|
|
AddElementToObject(request, "stopPrice", this.ParseToNumeric(this.PriceToPrecision(symbol, stopLossPrice)))
|
|
if IsTrue(IsTrue(isMarketOrder) || IsTrue((IsEqual(typeVar, "STOP_MARKET")))) {
|
|
AddElementToObject(request, "type", "STOP_MARKET")
|
|
} else if IsTrue(IsTrue((IsEqual(typeVar, "LIMIT"))) || IsTrue((IsEqual(typeVar, "STOP")))) {
|
|
AddElementToObject(request, "type", "STOP")
|
|
}
|
|
} else if IsTrue(isTakeProfitPriceOrder) {
|
|
AddElementToObject(request, "stopPrice", this.ParseToNumeric(this.PriceToPrecision(symbol, takeProfitPrice)))
|
|
if IsTrue(IsTrue(isMarketOrder) || IsTrue((IsEqual(typeVar, "TAKE_PROFIT_MARKET")))) {
|
|
AddElementToObject(request, "type", "TAKE_PROFIT_MARKET")
|
|
} else if IsTrue(IsTrue((IsEqual(typeVar, "LIMIT"))) || IsTrue((IsEqual(typeVar, "TAKE_PROFIT")))) {
|
|
AddElementToObject(request, "type", "TAKE_PROFIT")
|
|
}
|
|
}
|
|
} else if IsTrue(isTrailing) {
|
|
AddElementToObject(request, "type", trailingType)
|
|
if IsTrue(isTrailingAmountOrder) {
|
|
AddElementToObject(request, "price", this.ParseToNumeric(trailingAmount))
|
|
} else if IsTrue(isTrailingPercentOrder) {
|
|
var requestTrailingPercent interface{} = Precise.StringDiv(trailingPercent, "100")
|
|
AddElementToObject(request, "priceRate", this.ParseToNumeric(requestTrailingPercent))
|
|
}
|
|
}
|
|
if IsTrue(IsTrue(isStopLoss) || IsTrue(isTakeProfit)) {
|
|
var stringifiedAmount interface{} = this.NumberToString(amount)
|
|
if IsTrue(isStopLoss) {
|
|
var slTriggerPrice interface{} = this.SafeString2(stopLoss, "triggerPrice", "stopPrice", stopLoss)
|
|
var slWorkingType interface{} = this.SafeString(stopLoss, "workingType", "MARK_PRICE")
|
|
var slType interface{} = this.SafeString(stopLoss, "type", "STOP_MARKET")
|
|
var slRequest interface{} = map[string]interface{} {
|
|
"stopPrice": this.ParseToNumeric(this.PriceToPrecision(symbol, slTriggerPrice)),
|
|
"workingType": slWorkingType,
|
|
"type": slType,
|
|
}
|
|
var slPrice interface{} = this.SafeString(stopLoss, "price")
|
|
if IsTrue(!IsEqual(slPrice, nil)) {
|
|
AddElementToObject(slRequest, "price", this.ParseToNumeric(this.PriceToPrecision(symbol, slPrice)))
|
|
}
|
|
var slQuantity interface{} = this.SafeString(stopLoss, "quantity", stringifiedAmount)
|
|
AddElementToObject(slRequest, "quantity", this.ParseToNumeric(this.AmountToPrecision(symbol, slQuantity)))
|
|
AddElementToObject(request, "stopLoss", this.Json(slRequest))
|
|
}
|
|
if IsTrue(isTakeProfit) {
|
|
var tkTriggerPrice interface{} = this.SafeString2(takeProfit, "triggerPrice", "stopPrice", takeProfit)
|
|
var tkWorkingType interface{} = this.SafeString(takeProfit, "workingType", "MARK_PRICE")
|
|
var tpType interface{} = this.SafeString(takeProfit, "type", "TAKE_PROFIT_MARKET")
|
|
var tpRequest interface{} = map[string]interface{} {
|
|
"stopPrice": this.ParseToNumeric(this.PriceToPrecision(symbol, tkTriggerPrice)),
|
|
"workingType": tkWorkingType,
|
|
"type": tpType,
|
|
}
|
|
var slPrice interface{} = this.SafeString(takeProfit, "price")
|
|
if IsTrue(!IsEqual(slPrice, nil)) {
|
|
AddElementToObject(tpRequest, "price", this.ParseToNumeric(this.PriceToPrecision(symbol, slPrice)))
|
|
}
|
|
var tkQuantity interface{} = this.SafeString(takeProfit, "quantity", stringifiedAmount)
|
|
AddElementToObject(tpRequest, "quantity", this.ParseToNumeric(this.AmountToPrecision(symbol, tkQuantity)))
|
|
AddElementToObject(request, "takeProfit", this.Json(tpRequest))
|
|
}
|
|
}
|
|
var positionSide interface{} = nil
|
|
var hedged interface{} = this.SafeBool(params, "hedged", false)
|
|
if IsTrue(hedged) {
|
|
params = this.Omit(params, "reduceOnly")
|
|
if IsTrue(reduceOnly) {
|
|
positionSide = Ternary(IsTrue((IsEqual(side, "buy"))), "SHORT", "LONG")
|
|
} else {
|
|
positionSide = Ternary(IsTrue((IsEqual(side, "buy"))), "LONG", "SHORT")
|
|
}
|
|
} else {
|
|
positionSide = "BOTH"
|
|
}
|
|
AddElementToObject(request, "positionSide", positionSide)
|
|
var amountReq interface{} = amount
|
|
if !IsTrue(GetValue(market, "inverse")) {
|
|
amountReq = this.ParseToNumeric(this.AmountToPrecision(symbol, amount))
|
|
}
|
|
AddElementToObject(request, "quantity", amountReq) // precision not available for inverse contracts
|
|
}
|
|
params = this.Omit(params, []interface{}{"hedged", "triggerPrice", "stopLossPrice", "takeProfitPrice", "trailingAmount", "trailingPercent", "trailingType", "takeProfit", "stopLoss", "clientOrderId"})
|
|
return this.Extend(request, params)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#createOrder
|
|
* @description create a trade order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Trade%20order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Create%20an%20Order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Trade%20order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Place%20TWAP%20Order
|
|
* @param {string} symbol unified symbol of the market to create an order in
|
|
* @param {string} type 'market' or 'limit'
|
|
* @param {string} side 'buy' or 'sell'
|
|
* @param {float} amount how much 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] a unique id for the order
|
|
* @param {bool} [params.postOnly] true to place a post only order
|
|
* @param {string} [params.timeInForce] spot supports 'PO', 'GTC' and 'IOC', swap supports 'PO', 'GTC', 'IOC' and 'FOK'
|
|
* @param {bool} [params.reduceOnly] *swap only* true or false whether the order is reduce only
|
|
* @param {float} [params.triggerPrice] triggerPrice at which the attached take profit / stop loss order will be triggered
|
|
* @param {float} [params.stopLossPrice] stop loss trigger price
|
|
* @param {float} [params.takeProfitPrice] take profit trigger price
|
|
* @param {float} [params.cost] the quote quantity that can be used as an alternative for the amount
|
|
* @param {float} [params.trailingAmount] *swap only* the quote amount to trail away from the current market price
|
|
* @param {float} [params.trailingPercent] *swap only* the percent to trail away from the current market price
|
|
* @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered
|
|
* @param {float} [params.takeProfit.triggerPrice] take profit trigger price
|
|
* @param {object} [params.stopLoss] *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered
|
|
* @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
|
|
* @param {boolean} [params.test] *swap only* whether to use the test endpoint or not, default is false
|
|
* @param {string} [params.positionSide] *contracts only* "BOTH" for one way mode, "LONG" for buy side of hedged mode, "SHORT" for sell side of hedged mode
|
|
* @param {boolean} [params.hedged] *swap only* whether the order is in hedged mode or one way mode
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes30388 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes30388)
|
|
var market interface{} = this.Market(symbol)
|
|
var test interface{} = this.SafeBool(params, "test", false)
|
|
params = this.Omit(params, "test")
|
|
var request interface{} = this.CreateOrderRequest(symbol, typeVar, side, amount, price, params)
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "swap")) {
|
|
if IsTrue(test) {
|
|
|
|
response = (<-this.SwapV2PrivatePostTradeOrderTest(request))
|
|
PanicOnError(response)
|
|
} else if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivatePostTradeOrder(request))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsEqual(typeVar, "twap")) {
|
|
|
|
response = (<-this.SwapV1PrivatePostTwapOrder(request))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivatePostTradeOrder(request))
|
|
PanicOnError(response)
|
|
}
|
|
} else {
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeOrder(request))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "symbol": "XRP-USDT",
|
|
// "orderId": 1514090846268424192,
|
|
// "transactTime": 1649822362855,
|
|
// "price": "0.5",
|
|
// "origQty": "10",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "PENDING",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY"
|
|
// }
|
|
// }
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "order": {
|
|
// "symbol": "BTC-USDT",
|
|
// "orderId": 1709036527545438208,
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "TRIGGER_LIMIT",
|
|
// "clientOrderID": "",
|
|
// "workingType": ""
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "orderId": 1809841379603398656,
|
|
// "symbol": "SOL-USD",
|
|
// "positionSide": "LONG",
|
|
// "side": "BUY",
|
|
// "type": "LIMIT",
|
|
// "price": 100,
|
|
// "quantity": 1,
|
|
// "stopPrice": 0,
|
|
// "workingType": "",
|
|
// "timeInForce": ""
|
|
// }
|
|
//
|
|
// twap order
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1732693774386,
|
|
// "data": {
|
|
// "mainOrderId": "4633860139993029715"
|
|
// }
|
|
// }
|
|
//
|
|
if IsTrue(IsString(response)) {
|
|
// broken api engine : order-ids are too long numbers (i.e. 1742930526912864656)
|
|
// and JSON.parse can not handle them in JS, so we have to use .parseJson
|
|
// however, when order has an attached SL/TP, their value types need extra parsing
|
|
response = this.FixStringifiedJsonMembers(response)
|
|
response = this.ParseJson(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var result interface{} = map[string]interface{} {}
|
|
if IsTrue(GetValue(market, "swap")) {
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
result = response
|
|
} else {
|
|
result = this.SafeDict(data, "order", data)
|
|
}
|
|
} else {
|
|
result = data
|
|
}
|
|
|
|
ch <- this.ParseOrder(result, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#createOrders
|
|
* @description create a list of trade orders
|
|
* @see https://bingx-api.github.io/docs/#/spot/trade-api.html#Batch%20Placing%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Bulk%20order
|
|
* @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 {boolean} [params.sync] *spot only* if true, multiple orders are ordered serially and all orders do not require the same symbol/side/type
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes31548 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes31548)
|
|
var ordersRequests interface{} = []interface{}{}
|
|
var marketIds interface{} = []interface{}{}
|
|
for i := 0; IsLessThan(i, GetArrayLength(orders)); i++ {
|
|
var rawOrder interface{} = GetValue(orders, i)
|
|
var marketId interface{} = this.SafeString(rawOrder, "symbol")
|
|
var typeVar interface{} = this.SafeString(rawOrder, "type")
|
|
AppendToArray(&marketIds,marketId)
|
|
var side interface{} = this.SafeString(rawOrder, "side")
|
|
var amount interface{} = this.SafeNumber(rawOrder, "amount")
|
|
var price interface{} = this.SafeNumber(rawOrder, "price")
|
|
var orderParams interface{} = this.SafeDict(rawOrder, "params", map[string]interface{} {})
|
|
var orderRequest interface{} = this.CreateOrderRequest(marketId, typeVar, side, amount, price, orderParams)
|
|
AppendToArray(&ordersRequests,orderRequest)
|
|
}
|
|
var symbols interface{} = this.MarketSymbols(marketIds, nil, false, true, true)
|
|
var symbolsLength interface{} = GetArrayLength(symbols)
|
|
var market interface{} = this.Market(GetValue(symbols, 0))
|
|
var request interface{} = map[string]interface{} {}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "swap")) {
|
|
if IsTrue(IsGreaterThan(symbolsLength, 5)) {
|
|
panic(InvalidOrder(Add(this.Id, " createOrders() can not create more than 5 orders at once for swap markets")))
|
|
}
|
|
AddElementToObject(request, "batchOrders", this.Json(ordersRequests))
|
|
|
|
response = (<-this.SwapV2PrivatePostTradeBatchOrders(request))
|
|
PanicOnError(response)
|
|
} else {
|
|
var sync interface{} = this.SafeBool(params, "sync", false)
|
|
if IsTrue(sync) {
|
|
AddElementToObject(request, "sync", true)
|
|
}
|
|
AddElementToObject(request, "data", this.Json(ordersRequests))
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeBatchOrders(request))
|
|
PanicOnError(response)
|
|
}
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "debugMsg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "orderId": 1720661389564968960,
|
|
// "transactTime": 1699072618272,
|
|
// "price": "25000",
|
|
// "origQty": "0.0002",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "PENDING",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY"
|
|
// },
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
// swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "orderId": 1720657081994006528,
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "LIMIT",
|
|
// "clientOrderID": "",
|
|
// "workingType": ""
|
|
// },
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
if IsTrue(IsString(response)) {
|
|
// broken api engine : order-ids are too long numbers (i.e. 1742930526912864656)
|
|
// and JSON.parse can not handle them in JS, so we have to use .parseJson
|
|
// however, when order has an attached SL/TP, their value types need extra parsing
|
|
response = this.FixStringifiedJsonMembers(response)
|
|
response = this.ParseJson(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var result interface{} = this.SafeList(data, "orders", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(result, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseOrderSide(side interface{}) interface{} {
|
|
var sides interface{} = map[string]interface{} {
|
|
"BUY": "buy",
|
|
"SELL": "sell",
|
|
"SHORT": "sell",
|
|
"LONG": "buy",
|
|
"ask": "sell",
|
|
"bid": "buy",
|
|
}
|
|
return this.SafeString(sides, side, side)
|
|
}
|
|
func (this *bingx) ParseOrderType(typeVar interface{}) interface{} {
|
|
var types interface{} = map[string]interface{} {
|
|
"trigger_market": "market",
|
|
"trigger_limit": "limit",
|
|
"stop_limit": "limit",
|
|
"stop_market": "market",
|
|
"take_profit_market": "market",
|
|
"stop": "limit",
|
|
}
|
|
return this.SafeString(types, typeVar, typeVar)
|
|
}
|
|
func (this *bingx) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// spot
|
|
// createOrder, createOrders, cancelOrder
|
|
//
|
|
// {
|
|
// "symbol": "XRP-USDT",
|
|
// "orderId": 1514090846268424192,
|
|
// "transactTime": 1649822362855,
|
|
// "price": "0.5",
|
|
// "origQty": "10",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "PENDING",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY"
|
|
// }
|
|
//
|
|
// fetchOrder
|
|
//
|
|
// {
|
|
// "symbol": "ETH-USDT",
|
|
// "orderId": "1660602123001266176",
|
|
// "price": "1700",
|
|
// "origQty": "0.003",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "PENDING",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY",
|
|
// "time": "1684753373276",
|
|
// "updateTime": "1684753373276",
|
|
// "origQuoteOrderQty": "0",
|
|
// "fee": "0",
|
|
// "feeAsset": "ETH"
|
|
// }
|
|
//
|
|
// fetchOpenOrders, fetchClosedOrders
|
|
//
|
|
// {
|
|
// "symbol": "XRP-USDT",
|
|
// "orderId": 1514073325788200960,
|
|
// "price": "0.5",
|
|
// "StopPrice": "0",
|
|
// "origQty": "20",
|
|
// "executedQty": "10",
|
|
// "cummulativeQuoteQty": "5",
|
|
// "status": "PENDING",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY",
|
|
// "time": 1649818185647,
|
|
// "updateTime": 1649818185647,
|
|
// "origQuoteOrderQty": "0"
|
|
// "fee": "-0.01"
|
|
// }
|
|
//
|
|
//
|
|
// linear swap
|
|
// createOrder, createOrders
|
|
//
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "orderId": 1590973236294713344,
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "LIMIT"
|
|
// }
|
|
//
|
|
// inverse swap createOrder
|
|
//
|
|
// {
|
|
// "orderId": 1809841379603398656,
|
|
// "symbol": "SOL-USD",
|
|
// "positionSide": "LONG",
|
|
// "side": "BUY",
|
|
// "type": "LIMIT",
|
|
// "price": 100,
|
|
// "quantity": 1,
|
|
// "stopPrice": 0,
|
|
// "workingType": "",
|
|
// "timeInForce": ""
|
|
// }
|
|
//
|
|
// fetchOrder, fetchOpenOrders, fetchClosedOrders
|
|
//
|
|
// {
|
|
// "symbol": "BTC-USDT",
|
|
// "orderId": 1709036527545438208,
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "TRIGGER_LIMIT",
|
|
// "origQty": "0.0010",
|
|
// "price": "22000.0",
|
|
// "executedQty": "0.0000",
|
|
// "avgPrice": "0.0",
|
|
// "cumQuote": "",
|
|
// "stopPrice": "23000.0",
|
|
// "profit": "",
|
|
// "commission": "",
|
|
// "status": "NEW",
|
|
// "time": 1696301035187,
|
|
// "updateTime": 1696301035187,
|
|
// "clientOrderId": "",
|
|
// "leverage": "",
|
|
// "takeProfit": "",
|
|
// "stopLoss": "",
|
|
// "advanceAttr": 0,
|
|
// "positionID": 0,
|
|
// "takeProfitEntrustPrice": 0,
|
|
// "stopLossEntrustPrice": 0,
|
|
// "orderType": "",
|
|
// "workingType": "MARK_PRICE"
|
|
// }
|
|
// with tp and sl
|
|
// {
|
|
// orderId: 1741440894764281900,
|
|
// symbol: 'LTC-USDT',
|
|
// positionSide: 'LONG',
|
|
// side: 'BUY',
|
|
// type: 'MARKET',
|
|
// price: 0,
|
|
// quantity: 1,
|
|
// stopPrice: 0,
|
|
// workingType: 'MARK_PRICE',
|
|
// clientOrderID: '',
|
|
// timeInForce: 'GTC',
|
|
// priceRate: 0,
|
|
// stopLoss: '{"stopPrice":50,"workingType":"MARK_PRICE","type":"STOP_MARKET","quantity":1}',
|
|
// takeProfit: '{"stopPrice":150,"workingType":"MARK_PRICE","type":"TAKE_PROFIT_MARKET","quantity":1}',
|
|
// reduceOnly: false
|
|
// }
|
|
//
|
|
// editOrder (swap)
|
|
//
|
|
// {
|
|
// cancelResult: 'true',
|
|
// cancelMsg: '',
|
|
// cancelResponse: {
|
|
// cancelClientOrderId: '',
|
|
// cancelOrderId: '1755336244265705472',
|
|
// symbol: 'SOL-USDT',
|
|
// orderId: '1755336244265705472',
|
|
// side: 'SELL',
|
|
// positionSide: 'SHORT',
|
|
// type: 'LIMIT',
|
|
// origQty: '1',
|
|
// price: '100.000',
|
|
// executedQty: '0',
|
|
// avgPrice: '0.000',
|
|
// cumQuote: '0',
|
|
// stopPrice: '',
|
|
// profit: '0.0000',
|
|
// commission: '0.000000',
|
|
// status: 'PENDING',
|
|
// time: '1707339747860',
|
|
// updateTime: '1707339747860',
|
|
// clientOrderId: '',
|
|
// leverage: '20X',
|
|
// workingType: 'MARK_PRICE',
|
|
// onlyOnePosition: false,
|
|
// reduceOnly: false
|
|
// },
|
|
// replaceResult: 'true',
|
|
// replaceMsg: '',
|
|
// newOrderResponse: {
|
|
// orderId: '1755338440612995072',
|
|
// symbol: 'SOL-USDT',
|
|
// positionSide: 'SHORT',
|
|
// side: 'SELL',
|
|
// type: 'LIMIT',
|
|
// price: '99',
|
|
// quantity: '2',
|
|
// stopPrice: '0',
|
|
// workingType: 'MARK_PRICE',
|
|
// clientOrderID: '',
|
|
// timeInForce: 'GTC',
|
|
// priceRate: '0',
|
|
// stopLoss: '',
|
|
// takeProfit: '',
|
|
// reduceOnly: false
|
|
// }
|
|
// }
|
|
//
|
|
// editOrder (spot)
|
|
//
|
|
// {
|
|
// cancelResult: { code: '0', msg: '', result: true },
|
|
// openResult: { code: '0', msg: '', result: true },
|
|
// orderOpenResponse: {
|
|
// symbol: 'SOL-USDT',
|
|
// orderId: '1755334007697866752',
|
|
// transactTime: '1707339214620',
|
|
// price: '99',
|
|
// stopPrice: '0',
|
|
// origQty: '0.2',
|
|
// executedQty: '0',
|
|
// cummulativeQuoteQty: '0',
|
|
// status: 'PENDING',
|
|
// type: 'LIMIT',
|
|
// side: 'SELL',
|
|
// clientOrderID: ''
|
|
// },
|
|
// orderCancelResponse: {
|
|
// symbol: 'SOL-USDT',
|
|
// orderId: '1755117055251480576',
|
|
// price: '100',
|
|
// stopPrice: '0',
|
|
// origQty: '0.2',
|
|
// executedQty: '0',
|
|
// cummulativeQuoteQty: '0',
|
|
// status: 'CANCELED',
|
|
// type: 'LIMIT',
|
|
// side: 'SELL'
|
|
// }
|
|
// }
|
|
//
|
|
// stop loss order
|
|
//
|
|
// {
|
|
// "symbol": "ETH-USDT",
|
|
// "orderId": "1792461744476422144",
|
|
// "price": "2775.65",
|
|
// "StopPrice": "2778.42",
|
|
// "origQty": "0.032359",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "NEW",
|
|
// "type": "TAKE_STOP_LIMIT",
|
|
// "side": "SELL",
|
|
// "time": "1716191156868",
|
|
// "updateTime": "1716191156868",
|
|
// "origQuoteOrderQty": "0",
|
|
// "fee": "0",
|
|
// "feeAsset": "USDT",
|
|
// "clientOrderID": ""
|
|
// }
|
|
//
|
|
// inverse swap cancelAllOrders, cancelOrder, fetchOrder, fetchOpenOrders, fetchClosedOrders, fetchCanceledOrders
|
|
//
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "orderId": "1809845251327672320",
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "LIMIT",
|
|
// "quantity": 1,
|
|
// "origQty": "0",
|
|
// "price": "90",
|
|
// "executedQty": "0",
|
|
// "avgPrice": "0",
|
|
// "cumQuote": "0",
|
|
// "stopPrice": "",
|
|
// "profit": "0.0000",
|
|
// "commission": "0.000000",
|
|
// "status": "CANCELLED",
|
|
// "time": 1720335707872,
|
|
// "updateTime": 1720335707912,
|
|
// "clientOrderId": "",
|
|
// "leverage": "",
|
|
// "takeProfit": {
|
|
// "type": "",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": "",
|
|
// "stopGuaranteed": ""
|
|
// },
|
|
// "stopLoss": {
|
|
// "type": "",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": "",
|
|
// "stopGuaranteed": ""
|
|
// },
|
|
// "advanceAttr": 0,
|
|
// "positionID": 0,
|
|
// "takeProfitEntrustPrice": 0,
|
|
// "stopLossEntrustPrice": 0,
|
|
// "orderType": "",
|
|
// "workingType": ""
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var info interface{} = order
|
|
var newOrder interface{} = this.SafeDict2(order, "newOrderResponse", "orderOpenResponse")
|
|
if IsTrue(!IsEqual(newOrder, nil)) {
|
|
order = newOrder
|
|
}
|
|
var positionSide interface{} = this.SafeString2(order, "positionSide", "ps")
|
|
var marketType interface{} = Ternary(IsTrue((IsEqual(positionSide, nil))), "spot", "swap")
|
|
var marketId interface{} = this.SafeString2(order, "symbol", "s")
|
|
if IsTrue(IsEqual(market, nil)) {
|
|
market = this.SafeMarket(marketId, nil, nil, marketType)
|
|
}
|
|
var side interface{} = this.SafeStringLower2(order, "side", "S")
|
|
var timestamp interface{} = this.SafeIntegerN(order, []interface{}{"time", "transactTime", "E", "createdTime"})
|
|
var lastTradeTimestamp interface{} = this.SafeInteger2(order, "updateTime", "T")
|
|
var statusId interface{} = this.SafeStringUpperN(order, []interface{}{"status", "X", "orderStatus"})
|
|
var feeCurrencyCode interface{} = this.SafeString2(order, "feeAsset", "N")
|
|
var feeCost interface{} = this.SafeStringN(order, []interface{}{"fee", "commission", "n"})
|
|
if IsTrue((IsEqual(feeCurrencyCode, nil))) {
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
if IsTrue(IsEqual(side, "buy")) {
|
|
feeCurrencyCode = GetValue(market, "base")
|
|
} else {
|
|
feeCurrencyCode = GetValue(market, "quote")
|
|
}
|
|
} else {
|
|
feeCurrencyCode = GetValue(market, "quote")
|
|
}
|
|
}
|
|
var stopLoss interface{} = this.SafeValue(order, "stopLoss")
|
|
var stopLossPrice interface{} = nil
|
|
if IsTrue(IsTrue((!IsEqual(stopLoss, nil))) && IsTrue((!IsEqual(stopLoss, "")))) {
|
|
stopLossPrice = this.OmitZero(this.SafeString(stopLoss, "stopLoss"))
|
|
}
|
|
if IsTrue(IsTrue(IsTrue((!IsEqual(stopLoss, nil))) && IsTrue((!IsNumber(stopLoss)))) && IsTrue((!IsEqual(stopLoss, "")))) {
|
|
// stopLoss: '{"stopPrice":50,"workingType":"MARK_PRICE","type":"STOP_MARKET","quantity":1}',
|
|
if IsTrue(IsString(stopLoss)) {
|
|
stopLoss = this.ParseJson(stopLoss)
|
|
}
|
|
stopLossPrice = this.OmitZero(this.SafeString(stopLoss, "stopPrice"))
|
|
}
|
|
var takeProfit interface{} = this.SafeValue(order, "takeProfit")
|
|
var takeProfitPrice interface{} = nil
|
|
if IsTrue(IsTrue(!IsEqual(takeProfit, nil)) && IsTrue((!IsEqual(takeProfit, "")))) {
|
|
takeProfitPrice = this.OmitZero(this.SafeString(takeProfit, "takeProfit"))
|
|
}
|
|
if IsTrue(IsTrue(IsTrue((!IsEqual(takeProfit, nil))) && IsTrue((!IsNumber(takeProfit)))) && IsTrue((!IsEqual(takeProfit, "")))) {
|
|
// takeProfit: '{"stopPrice":150,"workingType":"MARK_PRICE","type":"TAKE_PROFIT_MARKET","quantity":1}',
|
|
if IsTrue(IsString(takeProfit)) {
|
|
takeProfit = this.ParseJson(takeProfit)
|
|
}
|
|
takeProfitPrice = this.OmitZero(this.SafeString(takeProfit, "stopPrice"))
|
|
}
|
|
var rawType interface{} = this.SafeStringLower2(order, "type", "o")
|
|
var stopPrice interface{} = this.OmitZero(this.SafeString2(order, "StopPrice", "stopPrice"))
|
|
var triggerPrice interface{} = stopPrice
|
|
if IsTrue(!IsEqual(stopPrice, nil)) {
|
|
if IsTrue(IsTrue((IsGreaterThan(GetIndexOf(rawType, "stop"), OpNeg(1)))) && IsTrue((IsEqual(stopLossPrice, nil)))) {
|
|
stopLossPrice = stopPrice
|
|
triggerPrice = nil
|
|
}
|
|
if IsTrue(IsTrue((IsGreaterThan(GetIndexOf(rawType, "take"), OpNeg(1)))) && IsTrue((IsEqual(takeProfitPrice, nil)))) {
|
|
takeProfitPrice = stopPrice
|
|
triggerPrice = nil
|
|
}
|
|
}
|
|
return this.SafeOrder(map[string]interface{} {
|
|
"info": info,
|
|
"id": this.SafeStringN(order, []interface{}{"orderId", "i", "mainOrderId"}),
|
|
"clientOrderId": this.SafeStringN(order, []interface{}{"clientOrderID", "clientOrderId", "origClientOrderId", "c"}),
|
|
"symbol": this.SafeSymbol(marketId, market, "-", marketType),
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"lastTradeTimestamp": lastTradeTimestamp,
|
|
"lastUpdateTimestamp": this.SafeInteger(order, "updateTime"),
|
|
"type": this.ParseOrderType(rawType),
|
|
"timeInForce": this.SafeString(order, "timeInForce"),
|
|
"postOnly": nil,
|
|
"side": this.ParseOrderSide(side),
|
|
"price": this.SafeString2(order, "price", "p"),
|
|
"triggerPrice": triggerPrice,
|
|
"stopLossPrice": stopLossPrice,
|
|
"takeProfitPrice": takeProfitPrice,
|
|
"average": this.SafeString2(order, "avgPrice", "ap"),
|
|
"cost": this.SafeString(order, "cummulativeQuoteQty"),
|
|
"amount": this.SafeStringN(order, []interface{}{"origQty", "q", "quantity", "totalAmount"}),
|
|
"filled": this.SafeString2(order, "executedQty", "z"),
|
|
"remaining": nil,
|
|
"status": this.ParseOrderStatus(statusId),
|
|
"fee": map[string]interface{} {
|
|
"currency": feeCurrencyCode,
|
|
"cost": Precise.StringAbs(feeCost),
|
|
},
|
|
"trades": nil,
|
|
"reduceOnly": this.SafeBool2(order, "reduceOnly", "ro"),
|
|
}, market)
|
|
}
|
|
func (this *bingx) ParseOrderStatus(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"NEW": "open",
|
|
"PENDING": "open",
|
|
"PARTIALLY_FILLED": "open",
|
|
"RUNNING": "open",
|
|
"FILLED": "closed",
|
|
"CANCELED": "canceled",
|
|
"CANCELLED": "canceled",
|
|
"FAILED": "canceled",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#cancelOrder
|
|
* @description cancels an open order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20Order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20Order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Cancel%20an%20Order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20TWAP%20Order
|
|
* @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 {string} [params.clientOrderId] a unique id for the order
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes36788 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes36788)
|
|
var isTwapOrder interface{} = this.SafeBool(params, "twap", false)
|
|
params = this.Omit(params, "twap")
|
|
var response interface{} = nil
|
|
var market interface{} = nil
|
|
if IsTrue(isTwapOrder) {
|
|
var twapRequest interface{} = map[string]interface{} {
|
|
"mainOrderId": id,
|
|
}
|
|
|
|
response = (<-this.SwapV1PrivatePostTwapCancelOrder(this.Extend(twapRequest, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument")))
|
|
}
|
|
market = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var clientOrderId interface{} = this.SafeString2(params, "clientOrderId", "clientOrderID")
|
|
params = this.Omit(params, []interface{}{"clientOrderId"})
|
|
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
|
AddElementToObject(request, "clientOrderID", clientOrderId)
|
|
} else {
|
|
AddElementToObject(request, "orderId", id)
|
|
}
|
|
var typeVar interface{} = nil
|
|
var subType interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("cancelOrder", market, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("cancelOrder", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(typeVar, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeCancel(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateDeleteTradeCancelOrder(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateDeleteTradeOrder(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "symbol": "XRP-USDT",
|
|
// "orderId": 1514090846268424192,
|
|
// "price": "0.5",
|
|
// "origQty": "10",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "CANCELED",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY"
|
|
// }
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "order": {
|
|
// "symbol": "SOL-USD",
|
|
// "orderId": "1816002957423951872",
|
|
// "side": "BUY",
|
|
// "positionSide": "Long",
|
|
// "type": "Pending",
|
|
// "quantity": 0,
|
|
// "origQty": "0",
|
|
// "price": "150",
|
|
// "executedQty": "0",
|
|
// "avgPrice": "0",
|
|
// "cumQuote": "0",
|
|
// "stopPrice": "",
|
|
// "profit": "0.0000",
|
|
// "commission": "0.000000",
|
|
// "status": "CANCELLED",
|
|
// "time": 1721803819410,
|
|
// "updateTime": 1721803819427,
|
|
// "clientOrderId": "",
|
|
// "leverage": "",
|
|
// "takeProfit": {
|
|
// "type": "",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": "",
|
|
// "stopGuaranteed": ""
|
|
// },
|
|
// "stopLoss": {
|
|
// "type": "",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": "",
|
|
// "stopGuaranteed": ""
|
|
// },
|
|
// "advanceAttr": 0,
|
|
// "positionID": 0,
|
|
// "takeProfitEntrustPrice": 0,
|
|
// "stopLossEntrustPrice": 0,
|
|
// "orderType": "",
|
|
// "workingType": ""
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "order": {
|
|
// "symbol": "LINK-USDT",
|
|
// "orderId": 1597783850786750464,
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "TRIGGER_MARKET",
|
|
// "origQty": "5.0",
|
|
// "price": "5.0000",
|
|
// "executedQty": "0.0",
|
|
// "avgPrice": "0.0000",
|
|
// "cumQuote": "0",
|
|
// "stopPrice": "5.0000",
|
|
// "profit": "",
|
|
// "commission": "",
|
|
// "status": "CANCELLED",
|
|
// "time": 1669776330000,
|
|
// "updateTime": 1669776330000
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var order interface{} = this.SafeDict(data, "order", data)
|
|
|
|
ch <- this.ParseOrder(order, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#cancelAllOrders
|
|
* @description cancel all open orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20orders%20by%20symbol
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Cancel%20All%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Cancel%20all%20orders
|
|
* @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
|
|
* @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " cancelAllOrders() requires a symbol argument")))
|
|
}
|
|
|
|
retRes38598 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes38598)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeCancelOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else if IsTrue(GetValue(market, "swap")) {
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateDeleteTradeAllOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateDeleteTradeAllOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
} else {
|
|
panic(BadRequest(Add(this.Id, " cancelAllOrders is only supported for spot and swap markets.")))
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var orders interface{} = this.SafeList2(data, "success", "orders", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(orders)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#cancelOrders
|
|
* @description cancel multiple orders
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Cancel%20a%20Batch%20of%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/spot/trade-api.html#Cancel%20a%20Batch%20of%20Orders
|
|
* @param {string[]} ids order ids
|
|
* @param {string} symbol unified market symbol, default is undefined
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {string[]} [params.clientOrderIds] client order ids
|
|
* @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) CancelOrders(ids 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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " cancelOrders() requires a symbol argument")))
|
|
}
|
|
|
|
retRes40038 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes40038)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var clientOrderIds interface{} = this.SafeValue(params, "clientOrderIds")
|
|
params = this.Omit(params, "clientOrderIds")
|
|
var idsToParse interface{} = ids
|
|
var areClientOrderIds interface{} = (!IsEqual(clientOrderIds, nil))
|
|
if IsTrue(areClientOrderIds) {
|
|
idsToParse = clientOrderIds
|
|
}
|
|
var parsedIds interface{} = []interface{}{}
|
|
for i := 0; IsLessThan(i, GetArrayLength(idsToParse)); i++ {
|
|
var id interface{} = GetValue(idsToParse, i)
|
|
var stringId interface{} = ToString(id)
|
|
AppendToArray(&parsedIds,stringId)
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
var spotReqKey interface{} = Ternary(IsTrue(areClientOrderIds), "clientOrderIDs", "orderIds")
|
|
AddElementToObject(request, spotReqKey, Join(parsedIds, ","))
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeCancelOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(areClientOrderIds) {
|
|
AddElementToObject(request, "clientOrderIDList", this.Json(parsedIds))
|
|
} else {
|
|
AddElementToObject(request, "orderIdList", parsedIds)
|
|
}
|
|
|
|
response = (<-this.SwapV2PrivateDeleteTradeBatchOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var success interface{} = this.SafeList2(data, "success", "orders", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(success)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#cancelAllOrdersAfter
|
|
* @description dead man's switch, cancel all orders after the given timeout
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20all%20orders%20in%20countdown
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20all%20orders%20in%20countdown
|
|
* @param {number} timeout time in milliseconds, 0 represents cancel the timer
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {string} [params.type] spot or swap market
|
|
* @returns {object} the api result
|
|
*/
|
|
func (this *bingx) CancelAllOrdersAfter(timeout 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
|
|
|
|
retRes41068 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes41068)
|
|
var isActive interface{} = (IsGreaterThan(timeout, 0))
|
|
var request interface{} = map[string]interface{} {
|
|
"type": Ternary(IsTrue((isActive)), "ACTIVATE", "CLOSE"),
|
|
"timeOut": Ternary(IsTrue((isActive)), (this.ParseToInt(Divide(timeout, 1000))), 0),
|
|
}
|
|
var response interface{} = nil
|
|
var typeVar interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("cancelAllOrdersAfter", nil, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
if IsTrue(IsEqual(typeVar, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeCancelAllAfter(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsEqual(typeVar, "swap")) {
|
|
|
|
response = (<-this.SwapV2PrivatePostTradeCancelAllAfter(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
panic(NotSupported(Add(Add(Add(this.Id, " cancelAllOrdersAfter() is not supported for "), typeVar), " markets")))
|
|
}
|
|
|
|
//
|
|
// {
|
|
// code: '0',
|
|
// msg: '',
|
|
// data: {
|
|
// triggerTime: '1712645434',
|
|
// status: 'ACTIVATED',
|
|
// note: 'All your perpetual pending orders will be closed automatically at 2024-04-09 06:50:34 UTC(+0),before that you can cancel the timer, or extend triggerTime time by this request'
|
|
// }
|
|
// }
|
|
//
|
|
ch <- response
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchOrder
|
|
* @description fetches information on an order made by the user
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20details
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20details
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#TWAP%20Order%20Details
|
|
* @param {string} id the 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 {boolean} [params.twap] if fetching twap order
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes41518 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes41518)
|
|
var isTwapOrder interface{} = this.SafeBool(params, "twap", false)
|
|
params = this.Omit(params, "twap")
|
|
var response interface{} = nil
|
|
var market interface{} = nil
|
|
if IsTrue(isTwapOrder) {
|
|
var twapRequest interface{} = map[string]interface{} {
|
|
"mainOrderId": id,
|
|
}
|
|
|
|
response = (<-this.SwapV1PrivateGetTwapOrderDetail(this.Extend(twapRequest, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchOrder() requires a symbol argument")))
|
|
}
|
|
market = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"orderId": id,
|
|
}
|
|
var typeVar interface{} = nil
|
|
var subType interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("fetchOrder", market, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchOrder", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(typeVar, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivateGetTradeQuery(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeOrderDetail(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeOrder(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var order interface{} = this.SafeDict(data, "order", data)
|
|
|
|
ch <- this.ParseOrder(order, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchOrders
|
|
* @description fetches information on multiple orders made by the user
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#All%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history (returns less fields than above)
|
|
* @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] the latest time in ms to fetch entries for
|
|
* @param {int} [params.orderId] Only return subsequent orders, and return the latest order by default
|
|
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) FetchOrders(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
|
|
|
|
retRes43288 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes43288)
|
|
var request interface{} = map[string]interface{} {}
|
|
var market interface{} = nil
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
}
|
|
var typeVar interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("fetchOrders", market, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
if IsTrue(!IsEqual(typeVar, "swap")) {
|
|
panic(NotSupported(Add(this.Id, " fetchOrders() is only supported for swap markets")))
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit)
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTime", since)
|
|
}
|
|
requestparamsVariable := this.HandleUntilOption("endTime", request, params);
|
|
request = GetValue(requestparamsVariable,0);
|
|
params = GetValue(requestparamsVariable,1)
|
|
|
|
response:= (<-this.SwapV1PrivateGetTradeFullOrder(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "symbol": "PYTH-USDT",
|
|
// "orderId": 1736007506620112100,
|
|
// "side": "SELL",
|
|
// "positionSide": "SHORT",
|
|
// "type": "LIMIT",
|
|
// "origQty": "33",
|
|
// "price": "0.3916",
|
|
// "executedQty": "33",
|
|
// "avgPrice": "0.3916",
|
|
// "cumQuote": "13",
|
|
// "stopPrice": "",
|
|
// "profit": "0.0000",
|
|
// "commission": "-0.002585",
|
|
// "status": "FILLED",
|
|
// "time": 1702731418000,
|
|
// "updateTime": 1702731470000,
|
|
// "clientOrderId": "",
|
|
// "leverage": "15X",
|
|
// "takeProfit": {
|
|
// "type": "TAKE_PROFIT",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": ""
|
|
// },
|
|
// "stopLoss": {
|
|
// "type": "STOP",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": ""
|
|
// },
|
|
// "advanceAttr": 0,
|
|
// "positionID": 0,
|
|
// "takeProfitEntrustPrice": 0,
|
|
// "stopLossEntrustPrice": 0,
|
|
// "orderType": "",
|
|
// "workingType": "MARK_PRICE",
|
|
// "stopGuaranteed": false,
|
|
// "triggerOrderId": 1736012449498123500
|
|
// }
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var orders interface{} = this.SafeList(data, "orders", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(orders, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchOpenOrders
|
|
* @description fetch all unfilled currently open orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Current%20Open%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Current%20All%20Open%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20all%20current%20pending%20orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20TWAP%20Entrusted%20Order
|
|
* @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 order structures to retrieve
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {boolean} [params.twap] if fetching twap open orders
|
|
* @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes44218 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes44218)
|
|
var market interface{} = nil
|
|
var request interface{} = map[string]interface{} {}
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
}
|
|
var typeVar interface{} = nil
|
|
var subType interface{} = nil
|
|
var response interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("fetchOpenOrders", market, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchOpenOrders", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(typeVar, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivateGetTradeOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
var isTwapOrder interface{} = this.SafeBool(params, "twap", false)
|
|
params = this.Omit(params, "twap")
|
|
if IsTrue(isTwapOrder) {
|
|
|
|
response = (<-this.SwapV1PrivateGetTwapOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
//
|
|
// spot
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "symbol": "XRP-USDT",
|
|
// "orderId": 1514073325788200960,
|
|
// "price": "0.5",
|
|
// "origQty": "20",
|
|
// "executedQty": "0",
|
|
// "cummulativeQuoteQty": "0",
|
|
// "status": "PENDING",
|
|
// "type": "LIMIT",
|
|
// "side": "BUY",
|
|
// "time": 1649818185647,
|
|
// "updateTime": 1649818185647,
|
|
// "origQuoteOrderQty": "0"
|
|
// }
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "orderId": "1816013900044320768",
|
|
// "side": "BUY",
|
|
// "positionSide": "Long",
|
|
// "type": "LIMIT",
|
|
// "quantity": 1,
|
|
// "origQty": "",
|
|
// "price": "150",
|
|
// "executedQty": "0",
|
|
// "avgPrice": "0.000",
|
|
// "cumQuote": "",
|
|
// "stopPrice": "",
|
|
// "profit": "0.0000",
|
|
// "commission": "0.0000",
|
|
// "status": "Pending",
|
|
// "time": 1721806428334,
|
|
// "updateTime": 1721806428352,
|
|
// "clientOrderId": "",
|
|
// "leverage": "",
|
|
// "takeProfit": {
|
|
// "type": "TAKE_PROFIT",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": "MARK_PRICE",
|
|
// "stopGuaranteed": ""
|
|
// },
|
|
// "stopLoss": {
|
|
// "type": "STOP",
|
|
// "quantity": 0,
|
|
// "stopPrice": 0,
|
|
// "price": 0,
|
|
// "workingType": "MARK_PRICE",
|
|
// "stopGuaranteed": ""
|
|
// },
|
|
// "advanceAttr": 0,
|
|
// "positionID": 0,
|
|
// "takeProfitEntrustPrice": 0,
|
|
// "stopLossEntrustPrice": 0,
|
|
// "orderType": "",
|
|
// "workingType": "MARK_PRICE"
|
|
// }
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "symbol": "LINK-USDT",
|
|
// "orderId": 1585839271162413056,
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "type": "TRIGGER_MARKET",
|
|
// "origQty": "5.0",
|
|
// "price": "9",
|
|
// "executedQty": "0.0",
|
|
// "avgPrice": "0",
|
|
// "cumQuote": "0",
|
|
// "stopPrice": "5",
|
|
// "profit": "0.0000",
|
|
// "commission": "0.000000",
|
|
// "status": "CANCELLED",
|
|
// "time": 1667631605000,
|
|
// "updateTime": 1667631605000
|
|
// },
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
// twap
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1702731661854,
|
|
// "data": {
|
|
// "list": [
|
|
// {
|
|
// "symbol": "BNB-USDT",
|
|
// "side": "BUY",
|
|
// "positionSide": "LONG",
|
|
// "priceType": "constant",
|
|
// "priceVariance": "2000",
|
|
// "triggerPrice": "68000",
|
|
// "interval": 8,
|
|
// "amountPerOrder": "0.111",
|
|
// "totalAmount": "0.511",
|
|
// "orderStatus": "Running",
|
|
// "executedQty": "0.1",
|
|
// "duration": 800,
|
|
// "maxDuration": 9000,
|
|
// "createdTime": 1702731661854,
|
|
// "updateTime": 1702731661854
|
|
// }
|
|
// ],
|
|
// "total": 1
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var orders interface{} = this.SafeList2(data, "orders", "list", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(orders, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchClosedOrders
|
|
* @description fetches information on multiple closed orders made by the user
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20history
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
|
|
* @param {string} symbol unified market symbol of the closed orders
|
|
* @param {int} [since] timestamp in ms of the earliest order
|
|
* @param {int} [limit] the max number of closed orders to return
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch orders for
|
|
* @param {boolean} [params.standard] whether to fetch standard contract orders
|
|
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes46078 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes46078)
|
|
|
|
orders:= (<-this.FetchCanceledAndClosedOrders(symbol, since, limit, params))
|
|
PanicOnError(orders)
|
|
|
|
ch <- this.FilterBy(orders, "status", "closed")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchCanceledOrders
|
|
* @description fetches information on multiple canceled orders made by the user
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20history
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
|
|
* @param {string} symbol unified market symbol of the canceled orders
|
|
* @param {int} [since] timestamp in ms of the earliest order
|
|
* @param {int} [limit] the max number of canceled orders to return
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {int} [params.until] the latest time in ms to fetch orders for
|
|
* @param {boolean} [params.standard] whether to fetch standard contract orders
|
|
* @returns {object} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) FetchCanceledOrders(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
|
|
|
|
retRes46298 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes46298)
|
|
|
|
orders:= (<-this.FetchCanceledAndClosedOrders(symbol, since, limit, params))
|
|
PanicOnError(orders)
|
|
|
|
ch <- this.FilterBy(orders, "status", "canceled")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchCanceledAndClosedOrders
|
|
* @description fetches information on multiple closed orders made by the user
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20history
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20TWAP%20Historical%20Orders
|
|
* @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] the latest time in ms to fetch orders for
|
|
* @param {boolean} [params.standard] whether to fetch standard contract orders
|
|
* @param {boolean} [params.twap] if fetching twap orders
|
|
* @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) FetchCanceledAndClosedOrders(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
|
|
|
|
retRes46538 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes46538)
|
|
var market interface{} = nil
|
|
var request interface{} = map[string]interface{} {}
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
}
|
|
var typeVar interface{} = nil
|
|
var subType interface{} = nil
|
|
var standard interface{} = nil
|
|
var response interface{} = nil
|
|
typeVarparamsVariable := this.HandleMarketTypeAndParams("fetchClosedOrders", market, params);
|
|
typeVar = GetValue(typeVarparamsVariable,0);
|
|
params = GetValue(typeVarparamsVariable,1)
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchClosedOrders", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
standardparamsVariable := this.HandleOptionAndParams(params, "fetchClosedOrders", "standard", false);
|
|
standard = GetValue(standardparamsVariable,0);
|
|
params = GetValue(standardparamsVariable,1)
|
|
if IsTrue(standard) {
|
|
|
|
response = (<-this.ContractV1PrivateGetAllOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsEqual(typeVar, "spot")) {
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "pageSize", limit)
|
|
}
|
|
|
|
response = (<-this.SpotV1PrivateGetTradeHistoryOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
var isTwapOrder interface{} = this.SafeBool(params, "twap", false)
|
|
params = this.Omit(params, "twap")
|
|
if IsTrue(isTwapOrder) {
|
|
AddElementToObject(request, "pageIndex", 1)
|
|
AddElementToObject(request, "pageSize", Ternary(IsTrue((IsEqual(limit, nil))), 100, limit))
|
|
AddElementToObject(request, "startTime", Ternary(IsTrue((IsEqual(since, nil))), 1, since))
|
|
var until interface{} = this.SafeInteger(params, "until", this.Milliseconds())
|
|
params = this.Omit(params, "until")
|
|
AddElementToObject(request, "endTime", until)
|
|
|
|
response = (<-this.SwapV1PrivateGetTwapHistoryOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeOrderHistory(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeAllOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var orders interface{} = this.SafeList2(data, "orders", "list", []interface{}{})
|
|
|
|
ch <- this.ParseOrders(orders, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#transfer
|
|
* @description transfer currency internally between wallets on the same account
|
|
* @see https://bingx-api.github.io/docs/#/spot/account-api.html#User%20Universal%20Transfer
|
|
* @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 *bingx) 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
|
|
|
|
retRes48438 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes48438)
|
|
var currency interface{} = this.Currency(code)
|
|
var accountsByType interface{} = this.SafeDict(this.Options, "accountsByType", map[string]interface{} {})
|
|
var fromId interface{} = this.SafeString(accountsByType, fromAccount, fromAccount)
|
|
var toId interface{} = this.SafeString(accountsByType, toAccount, toAccount)
|
|
var request interface{} = map[string]interface{} {
|
|
"asset": GetValue(currency, "id"),
|
|
"amount": this.CurrencyToPrecision(code, amount),
|
|
"type": Add(Add(fromId, "_"), toId),
|
|
}
|
|
|
|
response:= (<-this.SpotV3PrivateGetGetAssetTransfer(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "tranId":13526853623
|
|
// }
|
|
//
|
|
ch <- map[string]interface{} {
|
|
"info": response,
|
|
"id": this.SafeString(response, "tranId"),
|
|
"timestamp": nil,
|
|
"datetime": nil,
|
|
"currency": code,
|
|
"amount": amount,
|
|
"fromAccount": fromAccount,
|
|
"toAccount": toAccount,
|
|
"status": nil,
|
|
}
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchTransfers
|
|
* @description fetch a history of internal transfers made on an account
|
|
* @see https://bingx-api.github.io/docs/#/spot/account-api.html#Query%20User%20Universal%20Transfer%20History%20(USER_DATA)
|
|
* @param {string} [code] unified currency code of the currency transferred
|
|
* @param {int} [since] the earliest time in ms to fetch transfers for
|
|
* @param {int} [limit] the maximum number of transfers structures to retrieve
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure}
|
|
*/
|
|
func (this *bingx) FetchTransfers(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
|
|
|
|
retRes48848 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes48848)
|
|
var currency interface{} = nil
|
|
if IsTrue(!IsEqual(code, nil)) {
|
|
currency = this.Currency(code)
|
|
}
|
|
var accountsByType interface{} = this.SafeDict(this.Options, "accountsByType", map[string]interface{} {})
|
|
var fromAccount interface{} = this.SafeString(params, "fromAccount")
|
|
var toAccount interface{} = this.SafeString(params, "toAccount")
|
|
var fromId interface{} = this.SafeString(accountsByType, fromAccount, fromAccount)
|
|
var toId interface{} = this.SafeString(accountsByType, toAccount, toAccount)
|
|
if IsTrue(IsTrue(IsEqual(fromId, nil)) || IsTrue(IsEqual(toId, nil))) {
|
|
panic(ExchangeError(Add(this.Id, " fromAccount & toAccount parameter are required")))
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"type": Add(Add(fromId, "_"), toId),
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTime", since)
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "size", limit)
|
|
}
|
|
|
|
response:= (<-this.SpotV3PrivateGetAssetTransfer(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "total": 3,
|
|
// "rows": [
|
|
// {
|
|
// "asset":"USDT",
|
|
// "amount":"-100.00000000000000000000",
|
|
// "type":"FUND_SFUTURES",
|
|
// "status":"CONFIRMED",
|
|
// "tranId":1067594500957016069,
|
|
// "timestamp":1658388859000
|
|
// },
|
|
// ]
|
|
// }
|
|
//
|
|
var rows interface{} = this.SafeList(response, "rows", []interface{}{})
|
|
|
|
ch <- this.ParseTransfers(rows, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} {
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var tranId interface{} = this.SafeString(transfer, "tranId")
|
|
var timestamp interface{} = this.SafeInteger(transfer, "timestamp")
|
|
var currencyCode interface{} = this.SafeCurrencyCode(nil, currency)
|
|
var status interface{} = this.SafeString(transfer, "status")
|
|
var accountsById interface{} = this.SafeDict(this.Options, "accountsById", map[string]interface{} {})
|
|
var typeId interface{} = this.SafeString(transfer, "type")
|
|
var typeIdSplit interface{} = Split(typeId, "_")
|
|
var fromId interface{} = this.SafeString(typeIdSplit, 0)
|
|
var toId interface{} = this.SafeString(typeId, 1)
|
|
var fromAccount interface{} = this.SafeString(accountsById, fromId, fromId)
|
|
var toAccount interface{} = this.SafeString(accountsById, toId, toId)
|
|
return map[string]interface{} {
|
|
"info": transfer,
|
|
"id": tranId,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"currency": currencyCode,
|
|
"amount": this.SafeNumber(transfer, "amount"),
|
|
"fromAccount": fromAccount,
|
|
"toAccount": toAccount,
|
|
"status": status,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchDepositAddressesByNetwork
|
|
* @description fetch the deposit addresses for a currency associated with this account
|
|
* @see https://bingx-api.github.io/docs/#/en-us/common/wallet-api.html#Query%20Main%20Account%20Deposit%20Address
|
|
* @param {string} code unified currency code
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a dictionary [address structures]{@link https://docs.ccxt.com/#/?id=address-structure}, indexed by the network
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes49618 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes49618)
|
|
var currency interface{} = this.Currency(code)
|
|
var defaultRecvWindow interface{} = this.SafeInteger(this.Options, "recvWindow")
|
|
var recvWindow interface{} = this.SafeInteger(this.ParseParams, "recvWindow", defaultRecvWindow)
|
|
var request interface{} = map[string]interface{} {
|
|
"coin": GetValue(currency, "id"),
|
|
"offset": 0,
|
|
"limit": 1000,
|
|
"recvWindow": recvWindow,
|
|
}
|
|
|
|
response:= (<-this.WalletsV1PrivateGetCapitalDepositAddress(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": "0",
|
|
// "timestamp": "1695200226859",
|
|
// "data": {
|
|
// "data": [
|
|
// {
|
|
// "coinId": "799",
|
|
// "coin": "USDT",
|
|
// "network": "BEP20",
|
|
// "address": "6a7eda2817462dabb6493277a2cfe0f5c3f2550b",
|
|
// "tag": ''
|
|
// }
|
|
// ],
|
|
// "total": "1"
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeList(this.SafeDict(response, "data"), "data")
|
|
var parsed interface{} = this.ParseDepositAddresses(data, []interface{}{GetValue(currency, "code")}, false)
|
|
|
|
ch <- this.IndexBy(parsed, "network")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchDepositAddress
|
|
* @description fetch the deposit address for a currency associated with this account
|
|
* @see https://bingx-api.github.io/docs/#/en-us/common/wallet-api.html#Query%20Main%20Account%20Deposit%20Address
|
|
* @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
|
|
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
var network interface{} = this.SafeString(params, "network")
|
|
params = this.Omit(params, []interface{}{"network"})
|
|
|
|
addressStructures:= (<-this.FetchDepositAddressesByNetwork(code, params))
|
|
PanicOnError(addressStructures)
|
|
if IsTrue(!IsEqual(network, nil)) {
|
|
|
|
ch <- this.SafeDict(addressStructures, network)
|
|
return nil
|
|
} else {
|
|
var options interface{} = this.SafeDict(this.Options, "defaultNetworks")
|
|
var defaultNetworkForCurrency interface{} = this.SafeString(options, code)
|
|
if IsTrue(!IsEqual(defaultNetworkForCurrency, nil)) {
|
|
|
|
ch <- this.SafeDict(addressStructures, defaultNetworkForCurrency)
|
|
return nil
|
|
} else {
|
|
var keys interface{} = ObjectKeys(addressStructures)
|
|
var key interface{} = this.SafeString(keys, 0)
|
|
|
|
ch <- this.SafeDict(addressStructures, key)
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "coinId":"4",
|
|
// "coin":"USDT",
|
|
// "network":"OMNI",
|
|
// "address":"1HXyx8HVQRY7Nhqz63nwnRB7SpS9xQPzLN",
|
|
// "addressWithPrefix":"1HXyx8HVQRY7Nhqz63nwnRB7SpS9xQPzLN"
|
|
// }
|
|
//
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var tag interface{} = this.SafeString(depositAddress, "tag")
|
|
var currencyId interface{} = this.SafeString(depositAddress, "coin")
|
|
currency = this.SafeCurrency(currencyId, currency)
|
|
var code interface{} = GetValue(currency, "code")
|
|
var address interface{} = this.SafeString(depositAddress, "addressWithPrefix")
|
|
var networkdId interface{} = this.SafeString(depositAddress, "network")
|
|
var networkCode interface{} = this.NetworkIdToCode(networkdId, code)
|
|
this.CheckAddress(address)
|
|
return map[string]interface{} {
|
|
"info": depositAddress,
|
|
"currency": code,
|
|
"network": networkCode,
|
|
"address": address,
|
|
"tag": tag,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchDeposits
|
|
* @description fetch all deposits made to an account
|
|
* @see https://bingx-api.github.io/docs/#/spot/account-api.html#Deposit%20History(supporting%20network)
|
|
* @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
|
|
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes50638 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes50638)
|
|
var request interface{} = map[string]interface{} {}
|
|
var currency interface{} = nil
|
|
if IsTrue(!IsEqual(code, nil)) {
|
|
currency = this.Currency(code)
|
|
AddElementToObject(request, "coin", GetValue(currency, "id"))
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTime", since)
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit) // default 1000
|
|
}
|
|
|
|
response:= (<-this.SpotV3PrivateGetCapitalDepositHisrec(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// [
|
|
// {
|
|
// "amount":"0.00999800",
|
|
// "coin":"PAXG",
|
|
// "network":"ETH",
|
|
// "status":1,
|
|
// "address":"0x788cabe9236ce061e5a892e1a59395a81fc8d62c",
|
|
// "addressTag":"",
|
|
// "txId":"0xaad4654a3234aa6118af9b4b335f5ae81c360b2394721c019b5d1e75328b09f3",
|
|
// "insertTime":1599621997000,
|
|
// "transferType":0,
|
|
// "unlockConfirm":"12/12", // confirm times for unlocking
|
|
// "confirmTimes":"12/12"
|
|
// },
|
|
// ]
|
|
//
|
|
ch <- this.ParseTransactions(response, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchWithdrawals
|
|
* @description fetch all withdrawals made from an account
|
|
* @see https://bingx-api.github.io/docs/#/spot/account-api.html#Withdraw%20History%20(supporting%20network)
|
|
* @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
|
|
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes51108 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes51108)
|
|
var request interface{} = map[string]interface{} {}
|
|
var currency interface{} = nil
|
|
if IsTrue(!IsEqual(code, nil)) {
|
|
currency = this.Currency(code)
|
|
AddElementToObject(request, "coin", GetValue(currency, "id"))
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "startTime", since)
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit) // default 1000
|
|
}
|
|
|
|
response:= (<-this.SpotV3PrivateGetCapitalWithdrawHistory(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// [
|
|
// {
|
|
// "address": "0x94df8b352de7f46f64b01d3666bf6e936e44ce60",
|
|
// "amount": "8.91000000",
|
|
// "applyTime": "2019-10-12 11:12:02",
|
|
// "coin": "USDT",
|
|
// "id": "b6ae22b3aa844210a7041aee7589627c",
|
|
// "withdrawOrderId": "WITHDRAWtest123",
|
|
// "network": "ETH",
|
|
// "transferType": 0
|
|
// "status": 6,
|
|
// "transactionFee": "0.004",
|
|
// "confirmNo":3,
|
|
// "info": "The address is not valid. Please confirm with the recipient",
|
|
// "txId": "0xb5ef8c13b968a406cc62a93a8bd80f9e9a906ef1b3fcf20a2e48573c17659268"
|
|
// },
|
|
// ]
|
|
//
|
|
ch <- this.ParseTransactions(response, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// fetchDeposits
|
|
//
|
|
// {
|
|
// "amount":"0.00999800",
|
|
// "coin":"PAXG",
|
|
// "network":"ETH",
|
|
// "status":1,
|
|
// "address":"0x788cabe9236ce061e5a892e1a59395a81fc8d62c",
|
|
// "addressTag":"",
|
|
// "txId":"0xaad4654a3234aa6118af9b4b335f5ae81c360b2394721c019b5d1e75328b09f3",
|
|
// "insertTime":1599621997000,
|
|
// "transferType":0,
|
|
// "unlockConfirm":"12/12", // confirm times for unlocking
|
|
// "confirmTimes":"12/12"
|
|
// }
|
|
//
|
|
// fetchWithdrawals
|
|
//
|
|
// {
|
|
// "address": "0x94df8b352de7f46f64b01d3666bf6e936e44ce60",
|
|
// "amount": "8.91000000",
|
|
// "applyTime": "2019-10-12 11:12:02",
|
|
// "coin": "USDT",
|
|
// "id": "b6ae22b3aa844210a7041aee7589627c",
|
|
// "withdrawOrderId": "WITHDRAWtest123",
|
|
// "network": "ETH",
|
|
// "transferType": 0
|
|
// "status": 6,
|
|
// "transactionFee": "0.004",
|
|
// "confirmNo":3,
|
|
// "info": "The address is not valid. Please confirm with the recipient",
|
|
// "txId": "0xb5ef8c13b968a406cc62a93a8bd80f9e9a906ef1b3fcf20a2e48573c17659268"
|
|
// }
|
|
//
|
|
// withdraw
|
|
//
|
|
// {
|
|
// "code":0,
|
|
// "timestamp":1705274263621,
|
|
// "data":{
|
|
// "id":"1264246141278773252"
|
|
// }
|
|
// }
|
|
//
|
|
// parse withdraw-type output first...
|
|
//
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var data interface{} = this.SafeValue(transaction, "data")
|
|
var dataId interface{} = Ternary(IsTrue((IsEqual(data, nil))), nil, this.SafeString(data, "id"))
|
|
var id interface{} = this.SafeString(transaction, "id", dataId)
|
|
var address interface{} = this.SafeString(transaction, "address")
|
|
var tag interface{} = this.SafeString(transaction, "addressTag")
|
|
var timestamp interface{} = this.SafeInteger(transaction, "insertTime")
|
|
var datetime interface{} = this.Iso8601(timestamp)
|
|
if IsTrue(IsEqual(timestamp, nil)) {
|
|
datetime = this.SafeString(transaction, "applyTime")
|
|
timestamp = this.Parse8601(datetime)
|
|
}
|
|
var network interface{} = this.SafeString(transaction, "network")
|
|
var currencyId interface{} = this.SafeString(transaction, "coin")
|
|
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
|
|
if IsTrue(IsTrue(IsTrue((!IsEqual(code, nil))) && IsTrue((!IsEqual(code, network)))) && IsTrue(IsGreaterThanOrEqual(GetIndexOf(code, network), 0))) {
|
|
if IsTrue(!IsEqual(network, nil)) {
|
|
code = Replace(code, network, "")
|
|
}
|
|
}
|
|
var rawType interface{} = this.SafeString(transaction, "transferType")
|
|
var typeVar interface{} = Ternary(IsTrue((IsEqual(rawType, "0"))), "deposit", "withdrawal")
|
|
return map[string]interface{} {
|
|
"info": transaction,
|
|
"id": id,
|
|
"txid": this.SafeString(transaction, "txId"),
|
|
"type": typeVar,
|
|
"currency": code,
|
|
"network": this.NetworkIdToCode(network),
|
|
"amount": this.SafeNumber(transaction, "amount"),
|
|
"status": this.ParseTransactionStatus(this.SafeString(transaction, "status")),
|
|
"timestamp": timestamp,
|
|
"datetime": datetime,
|
|
"address": address,
|
|
"addressFrom": nil,
|
|
"addressTo": address,
|
|
"tag": tag,
|
|
"tagFrom": tag,
|
|
"tagTo": nil,
|
|
"updated": nil,
|
|
"comment": this.SafeString(transaction, "info"),
|
|
"fee": map[string]interface{} {
|
|
"currency": code,
|
|
"cost": this.SafeNumber(transaction, "transactionFee"),
|
|
"rate": nil,
|
|
},
|
|
"internal": nil,
|
|
}
|
|
}
|
|
func (this *bingx) ParseTransactionStatus(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"0": "pending",
|
|
"1": "ok",
|
|
"10": "pending",
|
|
"20": "rejected",
|
|
"30": "ok",
|
|
"40": "rejected",
|
|
"50": "ok",
|
|
"60": "pending",
|
|
"70": "rejected",
|
|
"2": "pending",
|
|
"3": "rejected",
|
|
"4": "pending",
|
|
"5": "rejected",
|
|
"6": "ok",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#setMarginMode
|
|
* @description set margin mode to 'cross' or 'isolated'
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Change%20Margin%20Type
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Set%20Margin%20Type
|
|
* @param {string} marginMode 'cross' or 'isolated'
|
|
* @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 *bingx) SetMarginMode(marginMode 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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " setMarginMode() requires a symbol argument")))
|
|
}
|
|
|
|
retRes52798 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes52798)
|
|
var market interface{} = this.Market(symbol)
|
|
if IsTrue(!IsEqual(GetValue(market, "type"), "swap")) {
|
|
panic(BadSymbol(Add(this.Id, " setMarginMode() supports swap contracts only")))
|
|
}
|
|
marginMode = ToUpper(marginMode)
|
|
if IsTrue(IsEqual(marginMode, "CROSS")) {
|
|
marginMode = "CROSSED"
|
|
}
|
|
if IsTrue(IsTrue(!IsEqual(marginMode, "ISOLATED")) && IsTrue(!IsEqual(marginMode, "CROSSED"))) {
|
|
panic(BadRequest(Add(this.Id, " setMarginMode() marginMode argument should be isolated or cross")))
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"marginType": marginMode,
|
|
}
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("setMarginMode", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
retRes529819 := (<-this.CswapV1PrivatePostTradeMarginType(this.Extend(request, params)))
|
|
PanicOnError(retRes529819)
|
|
ch <- retRes529819
|
|
return nil
|
|
} else {
|
|
|
|
retRes530019 := (<-this.SwapV2PrivatePostTradeMarginType(this.Extend(request, params)))
|
|
PanicOnError(retRes530019)
|
|
ch <- retRes530019
|
|
return nil
|
|
}
|
|
return nil
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) AddMargin(symbol 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
|
|
var request interface{} = map[string]interface{} {
|
|
"type": 1,
|
|
}
|
|
|
|
retRes530815 := (<-this.SetMargin(symbol, amount, this.Extend(request, params)))
|
|
PanicOnError(retRes530815)
|
|
ch <- retRes530815
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ReduceMargin(symbol 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
|
|
var request interface{} = map[string]interface{} {
|
|
"type": 2,
|
|
}
|
|
|
|
retRes531515 := (<-this.SetMargin(symbol, amount, this.Extend(request, params)))
|
|
PanicOnError(retRes531515)
|
|
ch <- retRes531515
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#setMargin
|
|
* @description Either adds or reduces margin in an isolated position in order to set the margin to a specific value
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Adjust%20isolated%20margin
|
|
* @param {string} symbol unified market symbol of the market to set margin in
|
|
* @param {float} amount the amount to set the margin to
|
|
* @param {object} [params] parameters specific to the bingx api endpoint
|
|
* @returns {object} A [margin structure]{@link https://docs.ccxt.com/#/?id=add-margin-structure}
|
|
*/
|
|
func (this *bingx) SetMargin(symbol 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
|
|
var typeVar interface{} = this.SafeInteger(params, "type") // 1 increase margin 2 decrease margin
|
|
if IsTrue(IsEqual(typeVar, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " setMargin() requires a type parameter either 1 (increase margin) or 2 (decrease margin)")))
|
|
}
|
|
if !IsTrue(this.InArray(typeVar, []interface{}{1, 2})) {
|
|
panic(ArgumentsRequired(Add(this.Id, " setMargin() requires a type parameter either 1 (increase margin) or 2 (decrease margin)")))
|
|
}
|
|
|
|
retRes53368 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes53368)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"amount": this.AmountToPrecision(GetValue(market, "symbol"), amount),
|
|
"type": typeVar,
|
|
}
|
|
|
|
response:= (<-this.SwapV2PrivatePostTradePositionMargin(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "amount": 1,
|
|
// "type": 1
|
|
// }
|
|
//
|
|
ch <- this.ParseMarginModification(response, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseMarginModification(data interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "amount": 1,
|
|
// "type": 1
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var typeVar interface{} = this.SafeString(data, "type")
|
|
return map[string]interface{} {
|
|
"info": data,
|
|
"symbol": this.SafeString(market, "symbol"),
|
|
"type": Ternary(IsTrue((IsEqual(typeVar, "1"))), "add", "reduce"),
|
|
"marginMode": "isolated",
|
|
"amount": this.SafeNumber(data, "amount"),
|
|
"total": this.SafeNumber(data, "margin"),
|
|
"code": this.SafeString(market, "settle"),
|
|
"status": nil,
|
|
"timestamp": nil,
|
|
"datetime": nil,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchLeverage
|
|
* @description fetch the set leverage for a market
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Query%20Leverage
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Leverage
|
|
* @param {string} symbol unified market symbol
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
|
|
*/
|
|
func (this *bingx) FetchLeverage(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
|
|
|
|
retRes53908 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes53908)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeLeverage(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeLeverage(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
|
|
ch <- this.ParseLeverage(data, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseLeverage(leverage interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// linear swap
|
|
//
|
|
// {
|
|
// "longLeverage": 5,
|
|
// "shortLeverage": 5,
|
|
// "maxLongLeverage": 125,
|
|
// "maxShortLeverage": 125,
|
|
// "availableLongVol": "0.0000",
|
|
// "availableShortVol": "0.0000",
|
|
// "availableLongVal": "0.0",
|
|
// "availableShortVal": "0.0",
|
|
// "maxPositionLongVal": "0.0",
|
|
// "maxPositionShortVal": "0.0"
|
|
// }
|
|
//
|
|
// inverse swap
|
|
//
|
|
// {
|
|
// "symbol": "SOL-USD",
|
|
// "longLeverage": 5,
|
|
// "shortLeverage": 5,
|
|
// "maxLongLeverage": 50,
|
|
// "maxShortLeverage": 50,
|
|
// "availableLongVol": "4000000",
|
|
// "availableShortVol": "4000000"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(leverage, "symbol")
|
|
return map[string]interface{} {
|
|
"info": leverage,
|
|
"symbol": this.SafeSymbol(marketId, market),
|
|
"marginMode": nil,
|
|
"longLeverage": this.SafeInteger(leverage, "longLeverage"),
|
|
"shortLeverage": this.SafeInteger(leverage, "shortLeverage"),
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#setLeverage
|
|
* @description set the level of leverage for a market
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Switch%20Leverage
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Modify%20Leverage
|
|
* @param {float} leverage the rate of leverage
|
|
* @param {string} symbol unified market symbol
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @param {string} [params.side] hedged: ['long' or 'short']. one way: ['both']
|
|
* @returns {object} response from the exchange
|
|
*/
|
|
func (this *bingx) 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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " setLeverage() requires a symbol argument")))
|
|
}
|
|
var side interface{} = this.SafeStringUpper(params, "side")
|
|
this.CheckRequiredArgument("setLeverage", side, "side", []interface{}{"LONG", "SHORT", "BOTH"})
|
|
|
|
retRes54968 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes54968)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
"side": side,
|
|
"leverage": leverage,
|
|
}
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
retRes550419 := (<-this.CswapV1PrivatePostTradeLeverage(this.Extend(request, params)))
|
|
PanicOnError(retRes550419)
|
|
ch <- retRes550419
|
|
return nil
|
|
} else {
|
|
|
|
retRes552219 := (<-this.SwapV2PrivatePostTradeLeverage(this.Extend(request, params)))
|
|
PanicOnError(retRes552219)
|
|
ch <- retRes552219
|
|
return nil
|
|
}
|
|
return nil
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchMyTrades
|
|
* @description fetch all trades made by the user
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20transaction%20details
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20historical%20transaction%20orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20historical%20transaction%20details
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Order%20Trade%20Detail
|
|
* @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] timestamp in ms for the ending date filter, default is undefined
|
|
* @param {string} params.trandingUnit COIN (directly represent assets such as BTC and ETH) or CONT (represents the number of contract sheets)
|
|
* @param {string} params.orderId the order id required for inverse swap
|
|
* @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchMyTrades() requires a symbol argument")))
|
|
}
|
|
|
|
retRes55638 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes55638)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {}
|
|
var fills interface{} = nil
|
|
var response interface{} = nil
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchMyTrades", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
var orderId interface{} = this.SafeString(params, "orderId")
|
|
if IsTrue(IsEqual(orderId, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchMyTrades() requires an orderId argument for inverse swap trades")))
|
|
}
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeAllFillOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
fills = this.SafeList(response, "data", []interface{}{})
|
|
} else {
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
var now interface{} = this.Milliseconds()
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
var startTimeReq interface{} = Ternary(IsTrue(GetValue(market, "spot")), "startTime", "startTs")
|
|
AddElementToObject(request, startTimeReq, since)
|
|
} else if IsTrue(GetValue(market, "swap")) {
|
|
AddElementToObject(request, "startTs", Subtract(now, Multiply(Multiply(Multiply(Multiply(30, 24), 60), 60), 1000))) // 30 days for swap
|
|
}
|
|
var until interface{} = this.SafeInteger(params, "until")
|
|
params = this.Omit(params, "until")
|
|
if IsTrue(!IsEqual(until, nil)) {
|
|
var endTimeReq interface{} = Ternary(IsTrue(GetValue(market, "spot")), "endTime", "endTs")
|
|
AddElementToObject(request, endTimeReq, until)
|
|
} else if IsTrue(GetValue(market, "swap")) {
|
|
AddElementToObject(request, "endTs", now)
|
|
}
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit) // default 500, maximum 1000
|
|
}
|
|
|
|
response = (<-this.SpotV1PrivateGetTradeMyTrades(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
fills = this.SafeList(data, "fills", []interface{}{})
|
|
} else {
|
|
var tradingUnit interface{} = this.SafeStringUpper(params, "tradingUnit", "CONT")
|
|
params = this.Omit(params, "tradingUnit")
|
|
AddElementToObject(request, "tradingUnit", tradingUnit)
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeAllFillOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
fills = this.SafeList(data, "fill_orders", []interface{}{})
|
|
}
|
|
}
|
|
|
|
ch <- this.ParseTrades(fills, market, since, limit, params)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseDepositWithdrawFee(fee interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "coin": "BTC",
|
|
// "name": "BTC",
|
|
// "networkList": [
|
|
// {
|
|
// "name": "BTC",
|
|
// "network": "BTC",
|
|
// "isDefault": true,
|
|
// "minConfirm": "2",
|
|
// "withdrawEnable": true,
|
|
// "withdrawFee": "0.00035",
|
|
// "withdrawMax": "1.62842",
|
|
// "withdrawMin": "0.0005"
|
|
// },
|
|
// {
|
|
// "name": "BTC",
|
|
// "network": "BEP20",
|
|
// "isDefault": false,
|
|
// "minConfirm": "15",
|
|
// "withdrawEnable": true,
|
|
// "withdrawFee": "0.00001",
|
|
// "withdrawMax": "1.62734",
|
|
// "withdrawMin": "0.0001"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var networkList interface{} = this.SafeList(fee, "networkList", []interface{}{})
|
|
var networkListLength interface{} = GetArrayLength(networkList)
|
|
var result interface{} = map[string]interface{} {
|
|
"info": fee,
|
|
"withdraw": map[string]interface{} {
|
|
"fee": nil,
|
|
"percentage": nil,
|
|
},
|
|
"deposit": map[string]interface{} {
|
|
"fee": nil,
|
|
"percentage": nil,
|
|
},
|
|
"networks": map[string]interface{} {},
|
|
}
|
|
if IsTrue(!IsEqual(networkListLength, 0)) {
|
|
for i := 0; IsLessThan(i, networkListLength); i++ {
|
|
var network interface{} = GetValue(networkList, i)
|
|
var networkId interface{} = this.SafeString(network, "network")
|
|
var isDefault interface{} = this.SafeBool(network, "isDefault")
|
|
var currencyCode interface{} = this.SafeString(currency, "code")
|
|
var networkCode interface{} = this.NetworkIdToCode(networkId, currencyCode)
|
|
AddElementToObject(GetValue(result, "networks"), networkCode, map[string]interface{} {
|
|
"deposit": map[string]interface{} {
|
|
"fee": nil,
|
|
"percentage": nil,
|
|
},
|
|
"withdraw": map[string]interface{} {
|
|
"fee": this.SafeNumber(network, "withdrawFee"),
|
|
"percentage": false,
|
|
},
|
|
})
|
|
if IsTrue(isDefault) {
|
|
AddElementToObject(GetValue(result, "withdraw"), "fee", this.SafeNumber(network, "withdrawFee"))
|
|
AddElementToObject(GetValue(result, "withdraw"), "percentage", false)
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchDepositWithdrawFees
|
|
* @description fetch deposit and withdraw fees
|
|
* @see https://bingx-api.github.io/docs/#/common/account-api.html#All%20Coins'%20Information
|
|
* @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 *bingx) 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
|
|
|
|
retRes57568 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes57568)
|
|
|
|
response:= (<-this.WalletsV1PrivateGetCapitalConfigGetall(params))
|
|
PanicOnError(response)
|
|
var coins interface{} = this.SafeList(response, "data")
|
|
|
|
ch <- this.ParseDepositWithdrawFees(coins, codes, "coin")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#withdraw
|
|
* @description make a withdrawal
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/wallet-api.html#Withdraw
|
|
* @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
|
|
* @param {int} [params.walletType] 1 fund account, 2 standard account, 3 perpetual account
|
|
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
|
*/
|
|
func (this *bingx) 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)
|
|
this.CheckAddress(address)
|
|
|
|
retRes57788 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes57788)
|
|
var currency interface{} = this.Currency(code)
|
|
var walletType interface{} = this.SafeInteger(params, "walletType")
|
|
if IsTrue(IsEqual(walletType, nil)) {
|
|
walletType = 1
|
|
}
|
|
if !IsTrue(this.InArray(walletType, []interface{}{1, 2, 3})) {
|
|
panic(BadRequest(Add(this.Id, " withdraw() requires either 1 fund account, 2 standard futures account, 3 perpetual account for walletType")))
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"coin": GetValue(currency, "id"),
|
|
"address": address,
|
|
"amount": this.CurrencyToPrecision(code, amount),
|
|
"walletType": walletType,
|
|
}
|
|
var network interface{} = this.SafeStringUpper(params, "network")
|
|
if IsTrue(!IsEqual(network, nil)) {
|
|
AddElementToObject(request, "network", this.NetworkCodeToId(network))
|
|
}
|
|
if IsTrue(!IsEqual(tag, nil)) {
|
|
AddElementToObject(request, "addressTag", tag)
|
|
}
|
|
params = this.Omit(params, []interface{}{"walletType", "network"})
|
|
|
|
response:= (<-this.WalletsV1PrivatePostCapitalWithdrawApply(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
var data interface{} = this.SafeValue(response, "data")
|
|
|
|
// {
|
|
// "code":0,
|
|
// "timestamp":1689258953651,
|
|
// "data":{
|
|
// "id":"1197073063359000577"
|
|
// }
|
|
// }
|
|
ch <- this.ParseTransaction(data)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseParams(params interface{}) interface{} {
|
|
var sortedParams interface{} = this.Keysort(params)
|
|
var keys interface{} = ObjectKeys(sortedParams)
|
|
for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
|
|
var key interface{} = GetValue(keys, i)
|
|
var value interface{} = GetValue(sortedParams, key)
|
|
if IsTrue(IsArray(value)) {
|
|
var arrStr interface{} = "["
|
|
for j := 0; IsLessThan(j, GetArrayLength(value)); j++ {
|
|
var arrayElement interface{} = GetValue(value, j)
|
|
if IsTrue(IsGreaterThan(j, 0)) {
|
|
arrStr = Add(arrStr, ",")
|
|
}
|
|
arrStr = Add(arrStr, ToString(arrayElement))
|
|
}
|
|
arrStr = Add(arrStr, "]")
|
|
AddElementToObject(sortedParams, key, arrStr)
|
|
}
|
|
}
|
|
return sortedParams
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchMyLiquidations
|
|
* @description retrieves the users liquidated positions
|
|
* @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#User's%20Force%20Orders
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20force%20orders
|
|
* @param {string} [symbol] unified CCXT market symbol
|
|
* @param {int} [since] the earliest time in ms to fetch liquidations for
|
|
* @param {int} [limit] the maximum number of liquidation structures to retrieve
|
|
* @param {object} [params] exchange specific parameters for the bingx api endpoint
|
|
* @param {int} [params.until] timestamp in ms of the latest liquidation
|
|
* @returns {object} an array of [liquidation structures]{@link https://docs.ccxt.com/#/?id=liquidation-structure}
|
|
*/
|
|
func (this *bingx) FetchMyLiquidations(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
|
|
|
|
retRes58498 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes58498)
|
|
var request interface{} = map[string]interface{} {
|
|
"autoCloseType": "LIQUIDATION",
|
|
}
|
|
requestparamsVariable := this.HandleUntilOption("endTime", request, params);
|
|
request = GetValue(requestparamsVariable,0);
|
|
params = GetValue(requestparamsVariable,1)
|
|
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, "startTime", since)
|
|
}
|
|
if IsTrue(!IsEqual(limit, nil)) {
|
|
AddElementToObject(request, "limit", limit)
|
|
}
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchMyLiquidations", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
var response interface{} = nil
|
|
var liquidations interface{} = nil
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeForceOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1721280071678,
|
|
// "data": [
|
|
// {
|
|
// "orderId": "string",
|
|
// "symbol": "string",
|
|
// "type": "string",
|
|
// "side": "string",
|
|
// "positionSide": "string",
|
|
// "price": "string",
|
|
// "quantity": "float64",
|
|
// "stopPrice": "string",
|
|
// "workingType": "string",
|
|
// "status": "string",
|
|
// "time": "int64",
|
|
// "avgPrice": "string",
|
|
// "executedQty": "string",
|
|
// "profit": "string",
|
|
// "commission": "string",
|
|
// "updateTime": "string"
|
|
// }
|
|
// ]
|
|
// }
|
|
//
|
|
liquidations = this.SafeList(response, "data", []interface{}{})
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeForceOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "orders": [
|
|
// {
|
|
// "time": "int64",
|
|
// "symbol": "string",
|
|
// "side": "string",
|
|
// "type": "string",
|
|
// "positionSide": "string",
|
|
// "cumQuote": "string",
|
|
// "status": "string",
|
|
// "stopPrice": "string",
|
|
// "price": "string",
|
|
// "origQty": "string",
|
|
// "avgPrice": "string",
|
|
// "executedQty": "string",
|
|
// "orderId": "int64",
|
|
// "profit": "string",
|
|
// "commission": "string",
|
|
// "workingType": "string",
|
|
// "updateTime": "int64"
|
|
// },
|
|
// ]
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
liquidations = this.SafeList(data, "orders", []interface{}{})
|
|
}
|
|
|
|
ch <- this.ParseLiquidations(liquidations, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseLiquidation(liquidation interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "time": "int64",
|
|
// "symbol": "string",
|
|
// "side": "string",
|
|
// "type": "string",
|
|
// "positionSide": "string",
|
|
// "cumQuote": "string",
|
|
// "status": "string",
|
|
// "stopPrice": "string",
|
|
// "price": "string",
|
|
// "origQty": "string",
|
|
// "avgPrice": "string",
|
|
// "executedQty": "string",
|
|
// "orderId": "int64",
|
|
// "profit": "string",
|
|
// "commission": "string",
|
|
// "workingType": "string",
|
|
// "updateTime": "int64"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(liquidation, "symbol")
|
|
var timestamp interface{} = this.SafeInteger(liquidation, "time")
|
|
var contractsString interface{} = this.SafeString(liquidation, "executedQty")
|
|
var contractSizeString interface{} = this.SafeString(market, "contractSize")
|
|
var priceString interface{} = this.SafeString(liquidation, "avgPrice")
|
|
var baseValueString interface{} = Precise.StringMul(contractsString, contractSizeString)
|
|
var quoteValueString interface{} = Precise.StringMul(baseValueString, priceString)
|
|
return this.SafeLiquidation(map[string]interface{} {
|
|
"info": liquidation,
|
|
"symbol": this.SafeSymbol(marketId, market),
|
|
"contracts": this.ParseNumber(contractsString),
|
|
"contractSize": this.ParseNumber(contractSizeString),
|
|
"price": this.ParseNumber(priceString),
|
|
"baseValue": this.ParseNumber(baseValueString),
|
|
"quoteValue": this.ParseNumber(quoteValueString),
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
})
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#closePosition
|
|
* @description closes open positions for a market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#One-Click%20Close%20All%20Positions
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Close%20all%20positions%20in%20bulk
|
|
* @param {string} symbol Unified CCXT market symbol
|
|
* @param {string} [side] not used by bingx
|
|
* @param {object} [params] extra parameters specific to the bingx api endpoint
|
|
* @param {string|undefined} [params.positionId] the id of the position you would like to close
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) ClosePosition(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
side := GetArg(optionalArgs, 0, nil)
|
|
_ = side
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
|
|
retRes59918 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes59918)
|
|
var market interface{} = this.Market(symbol)
|
|
var positionId interface{} = this.SafeString(params, "positionId")
|
|
var request interface{} = map[string]interface{} {}
|
|
var response interface{} = nil
|
|
if IsTrue(!IsEqual(positionId, nil)) {
|
|
|
|
response = (<-this.SwapV1PrivatePostTradeClosePosition(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
AddElementToObject(request, "symbol", GetValue(market, "id"))
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivatePostTradeCloseAllPositions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivatePostTradeCloseAllPositions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data")
|
|
|
|
ch <- this.ParseOrder(data, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bitget#closePositions
|
|
* @description closes open positions for a market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#One-Click%20Close%20All%20Positions
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Close%20all%20positions%20in%20bulk
|
|
* @param {object} [params] extra parameters specific to the bingx api endpoint
|
|
* @param {string} [params.recvWindow] request valid time window value
|
|
* @returns {object[]} [a list of position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
|
|
*/
|
|
func (this *bingx) CloseAllPositions(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
|
|
|
|
retRes60608 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes60608)
|
|
var defaultRecvWindow interface{} = this.SafeInteger(this.Options, "recvWindow")
|
|
var recvWindow interface{} = this.SafeInteger(this.ParseParams, "recvWindow", defaultRecvWindow)
|
|
var marketType interface{} = nil
|
|
marketTypeparamsVariable := this.HandleMarketTypeAndParams("closeAllPositions", nil, params);
|
|
marketType = GetValue(marketTypeparamsVariable,0);
|
|
params = GetValue(marketTypeparamsVariable,1)
|
|
var subType interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("closeAllPositions", nil, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(marketType, "margin")) {
|
|
panic(BadRequest(Add(Add(Add(this.Id, " closePositions () cannot be used for "), marketType), " markets")))
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"recvWindow": recvWindow,
|
|
}
|
|
var response interface{} = nil
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivatePostTradeCloseAllPositions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivatePostTradeCloseAllPositions(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var success interface{} = this.SafeList(data, "success", []interface{}{})
|
|
var positions interface{} = []interface{}{}
|
|
for i := 0; IsLessThan(i, GetArrayLength(success)); i++ {
|
|
var position interface{} = this.ParsePosition(map[string]interface{} {
|
|
"positionId": GetValue(success, i),
|
|
})
|
|
AppendToArray(&positions,position)
|
|
}
|
|
|
|
ch <- positions
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchPositionMode
|
|
* @description fetchs the position mode, hedged or one way, hedged for binance is set identically for all linear markets or all inverse markets
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Get%20Position%20Mode
|
|
* @param {string} symbol unified symbol of the market to fetch the order book for
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} an object detailing whether the market is in hedged or one-way mode
|
|
*/
|
|
func (this *bingx) FetchPositionMode(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
|
|
|
|
response:= (<-this.SwapV1PrivateGetPositionSideDual(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": "0",
|
|
// "msg": "",
|
|
// "timeStamp": "1709002057516",
|
|
// "data": {
|
|
// "dualSidePosition": "false"
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
var dualSidePosition interface{} = this.SafeString(data, "dualSidePosition")
|
|
|
|
ch <- map[string]interface{} {
|
|
"info": response,
|
|
"hedged": (IsEqual(dualSidePosition, "true")),
|
|
}
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#setPositionMode
|
|
* @description set hedged to true or false for a market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Set%20Position%20Mode
|
|
* @param {bool} hedged set to true to use dualSidePosition
|
|
* @param {string} symbol not used by bingx setPositionMode ()
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} response from the exchange
|
|
*/
|
|
func (this *bingx) SetPositionMode(hedged 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
|
|
var dualSidePosition interface{} = nil
|
|
if IsTrue(hedged) {
|
|
dualSidePosition = "true"
|
|
} else {
|
|
dualSidePosition = "false"
|
|
}
|
|
var request interface{} = map[string]interface{} {
|
|
"dualSidePosition": dualSidePosition,
|
|
}
|
|
|
|
retRes617015 := (<-this.SwapV1PrivatePostPositionSideDual(this.Extend(request, params)))
|
|
PanicOnError(retRes617015)
|
|
//
|
|
// {
|
|
// code: '0',
|
|
// msg: '',
|
|
// timeStamp: '1703327432734',
|
|
// data: { dualSidePosition: 'false' }
|
|
// }
|
|
//
|
|
ch <- retRes617015
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#editOrder
|
|
* @description cancels an order and places a new order
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20order%20and%20place%20a%20new%20order // spot
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20an%20order%20and%20then%20Place%20a%20new%20order // swap
|
|
* @param {string} id order id
|
|
* @param {string} symbol unified symbol of the market to create an order in
|
|
* @param {string} type 'market' or 'limit'
|
|
* @param {string} side 'buy' or 'sell'
|
|
* @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.triggerPrice] Trigger price used for TAKE_STOP_LIMIT, TAKE_STOP_MARKET, TRIGGER_LIMIT, TRIGGER_MARKET order types.
|
|
* @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered
|
|
* @param {float} [params.takeProfit.triggerPrice] take profit trigger price
|
|
* @param {object} [params.stopLoss] *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered
|
|
* @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
|
|
*
|
|
* EXCHANGE SPECIFIC PARAMETERS
|
|
* @param {string} [params.cancelClientOrderID] the user-defined id of the order to be canceled, 1-40 characters, different orders cannot use the same clientOrderID, only supports a query range of 2 hours
|
|
* @param {string} [params.cancelRestrictions] cancel orders with specified status, NEW: New order, PENDING: Pending order, PARTIALLY_FILLED: Partially filled
|
|
* @param {string} [params.cancelReplaceMode] STOP_ON_FAILURE - if the cancel order fails, it will not continue to place a new order, ALLOW_FAILURE - regardless of whether the cancel order succeeds or fails, it will continue to place a new order
|
|
* @param {float} [params.quoteOrderQty] order amount
|
|
* @param {string} [params.newClientOrderId] custom order id consisting of letters, numbers, and _, 1-40 characters, different orders cannot use the same newClientOrderId.
|
|
* @param {string} [params.positionSide] *contract only* position direction, required for single position as BOTH, for both long and short positions only LONG or SHORT can be chosen, defaults to LONG if empty
|
|
* @param {string} [params.reduceOnly] *contract only* true or false, default=false for single position mode. this parameter is not accepted for both long and short positions mode
|
|
* @param {float} [params.priceRate] *contract only* for type TRAILING_STOP_Market or TRAILING_TP_SL, Max = 1
|
|
* @param {string} [params.workingType] *contract only* StopPrice trigger price types, MARK_PRICE (default), CONTRACT_PRICE, or INDEX_PRICE
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *bingx) 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
|
|
|
|
retRes62058 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes62058)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = this.CreateOrderRequest(symbol, typeVar, side, amount, price, params)
|
|
AddElementToObject(request, "cancelOrderId", id)
|
|
AddElementToObject(request, "cancelReplaceMode", "STOP_ON_FAILURE")
|
|
var response interface{} = nil
|
|
if IsTrue(GetValue(market, "swap")) {
|
|
|
|
response = (<-this.SwapV1PrivatePostTradeCancelReplace(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SpotV1PrivatePostTradeOrderCancelReplace(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data")
|
|
|
|
ch <- this.ParseOrder(data, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchMarginMode
|
|
* @description fetches the margin mode of the trading pair
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Margin%20Type
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Margin%20Type
|
|
* @param {string} symbol unified symbol of the market to fetch the margin mode for
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [margin mode structure]{@link https://docs.ccxt.com/#/?id=margin-mode-structure}
|
|
*/
|
|
func (this *bingx) FetchMarginMode(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
|
|
|
|
retRes63228 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes63228)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var subType interface{} = nil
|
|
var response interface{} = nil
|
|
subTypeparamsVariable := this.HandleSubTypeAndParams("fetchMarginMode", market, params);
|
|
subType = GetValue(subTypeparamsVariable,0);
|
|
params = GetValue(subTypeparamsVariable,1)
|
|
if IsTrue(IsEqual(subType, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetTradeMarginType(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetTradeMarginType(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
|
|
ch <- this.ParseMarginMode(data, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseMarginMode(marginMode interface{}, optionalArgs ...interface{}) interface{} {
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var marketId interface{} = this.SafeString(marginMode, "symbol")
|
|
var marginType interface{} = this.SafeStringLower(marginMode, "marginType")
|
|
marginType = Ternary(IsTrue((IsEqual(marginType, "crossed"))), "cross", marginType)
|
|
return map[string]interface{} {
|
|
"info": marginMode,
|
|
"symbol": this.SafeSymbol(marketId, market, "-", "swap"),
|
|
"marginMode": marginType,
|
|
}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name bingx#fetchTradingFee
|
|
* @description fetch the trading fees for a market
|
|
* @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Trading%20Commission%20Rate
|
|
* @see https://bingx-api.github.io/docs/#/en-us/swapV2/account-api.html#Query%20Trading%20Commission%20Rate
|
|
* @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Trade%20Commission%20Rate
|
|
* @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 *bingx) 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
|
|
|
|
retRes63828 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes63828)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"symbol": GetValue(market, "id"),
|
|
}
|
|
var response interface{} = nil
|
|
var commission interface{} = map[string]interface{} {}
|
|
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
|
|
if IsTrue(GetValue(market, "spot")) {
|
|
|
|
response = (<-this.SpotV1PrivateGetUserCommissionRate(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "debugMsg": "",
|
|
// "data": {
|
|
// "takerCommissionRate": 0.001,
|
|
// "makerCommissionRate": 0.001
|
|
// }
|
|
// }
|
|
//
|
|
commission = data
|
|
} else {
|
|
if IsTrue(GetValue(market, "inverse")) {
|
|
|
|
response = (<-this.CswapV1PrivateGetUserCommissionRate(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "timestamp": 1721365261438,
|
|
// "data": {
|
|
// "takerCommissionRate": "0.0005",
|
|
// "makerCommissionRate": "0.0002"
|
|
// }
|
|
// }
|
|
//
|
|
commission = data
|
|
} else {
|
|
|
|
response = (<-this.SwapV2PrivateGetUserCommissionRate(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "code": 0,
|
|
// "msg": "",
|
|
// "data": {
|
|
// "commission": {
|
|
// "takerCommissionRate": 0.0005,
|
|
// "makerCommissionRate": 0.0002
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
commission = this.SafeDict(data, "commission", map[string]interface{} {})
|
|
}
|
|
}
|
|
|
|
ch <- this.ParseTradingFee(commission, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *bingx) ParseTradingFee(fee interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "takerCommissionRate": 0.001,
|
|
// "makerCommissionRate": 0.001
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var symbol interface{} = Ternary(IsTrue((!IsEqual(market, nil))), GetValue(market, "symbol"), nil)
|
|
return map[string]interface{} {
|
|
"info": fee,
|
|
"symbol": symbol,
|
|
"maker": this.SafeNumber(fee, "makerCommissionRate"),
|
|
"taker": this.SafeNumber(fee, "takerCommissionRate"),
|
|
"percentage": false,
|
|
"tierBased": false,
|
|
}
|
|
}
|
|
func (this *bingx) CustomEncode(params interface{}) interface{} {
|
|
var sortedParams interface{} = this.Keysort(params)
|
|
var keys interface{} = ObjectKeys(sortedParams)
|
|
var adjustedValue interface{} = nil
|
|
var result interface{} = nil
|
|
for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
|
|
var key interface{} = GetValue(keys, i)
|
|
var value interface{} = GetValue(sortedParams, key)
|
|
if IsTrue(IsArray(value)) {
|
|
var arrStr interface{} = nil
|
|
for j := 0; IsLessThan(j, GetArrayLength(value)); j++ {
|
|
var arrayElement interface{} = GetValue(value, j)
|
|
var isString interface{} = (IsString(arrayElement))
|
|
if IsTrue(isString) {
|
|
if IsTrue(IsGreaterThan(j, 0)) {
|
|
arrStr = Add(arrStr, Add(Add(Add(",", "\""), ToString(arrayElement)), "\""))
|
|
} else {
|
|
arrStr = Add(Add("\"", ToString(arrayElement)), "\"")
|
|
}
|
|
} else {
|
|
if IsTrue(IsGreaterThan(j, 0)) {
|
|
arrStr = Add(arrStr, Add(",", ToString(arrayElement)))
|
|
} else {
|
|
arrStr = ToString(arrayElement)
|
|
}
|
|
}
|
|
}
|
|
adjustedValue = Add(Add("[", arrStr), "]")
|
|
value = adjustedValue
|
|
}
|
|
if IsTrue(IsEqual(i, 0)) {
|
|
result = Add(Add(key, "="), value)
|
|
} else {
|
|
result = Add(result, Add(Add(Add("&", key), "="), value))
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
func (this *bingx) Sign(path interface{}, optionalArgs ...interface{}) interface{} {
|
|
section := GetArg(optionalArgs, 0, "public")
|
|
_ = section
|
|
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 typeVar interface{} = GetValue(section, 0)
|
|
var version interface{} = GetValue(section, 1)
|
|
var access interface{} = GetValue(section, 2)
|
|
var isSandbox interface{} = this.SafeBool(this.Options, "sandboxMode", false)
|
|
if IsTrue(IsTrue(isSandbox) && IsTrue((!IsEqual(typeVar, "swap")))) {
|
|
panic(NotSupported(Add(Add(Add(this.Id, " does not have a testnet/sandbox URL for "), typeVar), " endpoints")))
|
|
}
|
|
var url interface{} = this.ImplodeHostname(GetValue(GetValue(this.Urls, "api"), typeVar))
|
|
path = this.ImplodeParams(path, params)
|
|
if IsTrue(IsEqual(version, "transfer")) {
|
|
typeVar = "account/transfer"
|
|
version = GetValue(section, 2)
|
|
access = GetValue(section, 3)
|
|
}
|
|
if IsTrue(!IsEqual(path, "account/apiPermissions")) {
|
|
if IsTrue(IsTrue(IsEqual(typeVar, "spot")) && IsTrue(IsEqual(version, "v3"))) {
|
|
url = Add(url, "/api")
|
|
} else {
|
|
url = Add(url, Add("/", typeVar))
|
|
}
|
|
}
|
|
url = Add(url, Add(Add(Add("/", version), "/"), path))
|
|
params = this.Omit(params, this.ExtractParams(path))
|
|
AddElementToObject(params, "timestamp", this.Nonce())
|
|
params = this.Keysort(params)
|
|
if IsTrue(IsEqual(access, "public")) {
|
|
if IsTrue(GetArrayLength(ObjectKeys(params))) {
|
|
url = Add(url, Add("?", this.Urlencode(params)))
|
|
}
|
|
} else if IsTrue(IsEqual(access, "private")) {
|
|
this.CheckRequiredCredentials()
|
|
var isJsonContentType interface{} = (IsTrue((IsTrue((IsEqual(typeVar, "subAccount"))) || IsTrue((IsEqual(typeVar, "account/transfer"))))) && IsTrue((IsEqual(method, "POST"))))
|
|
var parsedParams interface{} = nil
|
|
var encodeRequest interface{} = nil
|
|
if IsTrue(isJsonContentType) {
|
|
encodeRequest = this.CustomEncode(params)
|
|
} else {
|
|
parsedParams = this.ParseParams(params)
|
|
encodeRequest = this.Rawencode(parsedParams)
|
|
}
|
|
var signature interface{} = this.Hmac(this.Encode(encodeRequest), this.Encode(this.Secret), sha256)
|
|
headers = map[string]interface{} {
|
|
"X-BX-APIKEY": this.ApiKey,
|
|
"X-SOURCE-KEY": this.SafeString(this.Options, "broker", "CCXT"),
|
|
}
|
|
if IsTrue(isJsonContentType) {
|
|
AddElementToObject(headers, "Content-Type", "application/json")
|
|
AddElementToObject(params, "signature", signature)
|
|
body = this.Json(params)
|
|
} else {
|
|
var query interface{} = this.Urlencode(parsedParams)
|
|
url = Add(url, Add(Add(Add(Add("?", query), "&"), "signature="), signature))
|
|
}
|
|
}
|
|
return map[string]interface{} {
|
|
"url": url,
|
|
"method": method,
|
|
"body": body,
|
|
"headers": headers,
|
|
}
|
|
}
|
|
func (this *bingx) Nonce() interface{} {
|
|
return this.Milliseconds()
|
|
}
|
|
func (this *bingx) SetSandboxMode(enable interface{}) {
|
|
this.Exchange.SetSandboxMode(enable)
|
|
AddElementToObject(this.Options, "sandboxMode", enable)
|
|
}
|
|
func (this *bingx) HandleErrors(httpCode interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
|
|
if IsTrue(IsEqual(response, nil)) {
|
|
return nil // fallback to default error handler
|
|
}
|
|
//
|
|
// {
|
|
// "code": 80014,
|
|
// "msg": "Invalid parameters, err:Key: 'GetTickerRequest.Symbol' Error:Field validation for "Symbol" failed on the "len=0|endswith=-USDT" tag",
|
|
// "data": {
|
|
// }
|
|
// }
|
|
//
|
|
var code interface{} = this.SafeString(response, "code")
|
|
var message interface{} = this.SafeString(response, "msg")
|
|
if IsTrue(IsTrue(!IsEqual(code, nil)) && IsTrue(!IsEqual(code, "0"))) {
|
|
var feedback interface{} = Add(Add(this.Id, " "), body)
|
|
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), message, feedback)
|
|
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), code, feedback)
|
|
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), message, feedback)
|
|
panic(ExchangeError(feedback))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
|
|
func (this *bingx) Init(userConfig map[string]interface{}) {
|
|
this.Exchange = Exchange{}
|
|
this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
|
|
this.Exchange.DerivedExchange = this
|
|
}
|