3294 lines
150 KiB
Go
3294 lines
150 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 whitebit struct {
|
||
Exchange
|
||
|
||
}
|
||
|
||
func NewWhitebitCore() whitebit {
|
||
p := whitebit{}
|
||
setDefaults(&p)
|
||
return p
|
||
}
|
||
|
||
func (this *whitebit) Describe() interface{} {
|
||
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
|
||
"id": "whitebit",
|
||
"name": "WhiteBit",
|
||
"version": "v4",
|
||
"countries": []interface{}{"EE"},
|
||
"rateLimit": 50,
|
||
"pro": true,
|
||
"has": map[string]interface{} {
|
||
"CORS": nil,
|
||
"spot": true,
|
||
"margin": true,
|
||
"swap": false,
|
||
"future": false,
|
||
"option": false,
|
||
"cancelAllOrders": true,
|
||
"cancelAllOrdersAfter": true,
|
||
"cancelOrder": true,
|
||
"cancelOrders": false,
|
||
"createMarketBuyOrderWithCost": true,
|
||
"createMarketOrderWithCost": false,
|
||
"createMarketSellOrderWithCost": false,
|
||
"createOrder": true,
|
||
"createStopLimitOrder": true,
|
||
"createStopMarketOrder": true,
|
||
"createStopOrder": true,
|
||
"editOrder": false,
|
||
"fetchBalance": true,
|
||
"fetchBorrowRateHistories": false,
|
||
"fetchBorrowRateHistory": false,
|
||
"fetchClosedOrders": true,
|
||
"fetchCrossBorrowRate": false,
|
||
"fetchCrossBorrowRates": false,
|
||
"fetchCurrencies": true,
|
||
"fetchDeposit": true,
|
||
"fetchDepositAddress": true,
|
||
"fetchDepositAddresses": false,
|
||
"fetchDepositAddressesByNetwork": false,
|
||
"fetchDeposits": true,
|
||
"fetchDepositsWithdrawals": true,
|
||
"fetchDepositWithdrawFee": "emulated",
|
||
"fetchDepositWithdrawFees": true,
|
||
"fetchFundingHistory": false,
|
||
"fetchFundingRate": true,
|
||
"fetchFundingRateHistory": false,
|
||
"fetchFundingRates": true,
|
||
"fetchIndexOHLCV": false,
|
||
"fetchIsolatedBorrowRate": false,
|
||
"fetchIsolatedBorrowRates": false,
|
||
"fetchMarginMode": false,
|
||
"fetchMarkets": true,
|
||
"fetchMarkOHLCV": false,
|
||
"fetchMyTrades": true,
|
||
"fetchOHLCV": true,
|
||
"fetchOpenInterestHistory": false,
|
||
"fetchOpenOrders": true,
|
||
"fetchOrderBook": true,
|
||
"fetchOrderTrades": true,
|
||
"fetchPositionMode": false,
|
||
"fetchPremiumIndexOHLCV": false,
|
||
"fetchStatus": true,
|
||
"fetchTicker": true,
|
||
"fetchTickers": true,
|
||
"fetchTime": true,
|
||
"fetchTrades": true,
|
||
"fetchTradingFee": false,
|
||
"fetchTradingFees": true,
|
||
"fetchTransactionFees": true,
|
||
"repayCrossMargin": false,
|
||
"repayIsolatedMargin": false,
|
||
"setLeverage": true,
|
||
"transfer": true,
|
||
"withdraw": true,
|
||
},
|
||
"timeframes": map[string]interface{} {
|
||
"1m": "1m",
|
||
"3m": "3m",
|
||
"5m": "5m",
|
||
"15m": "15m",
|
||
"30m": "30m",
|
||
"1h": "1h",
|
||
"2h": "2h",
|
||
"4h": "4h",
|
||
"6h": "6h",
|
||
"8h": "8h",
|
||
"12h": "12h",
|
||
"1d": "1d",
|
||
"3d": "3d",
|
||
"1w": "1w",
|
||
"1M": "1M",
|
||
},
|
||
"urls": map[string]interface{} {
|
||
"logo": "https://user-images.githubusercontent.com/1294454/66732963-8eb7dd00-ee66-11e9-849b-10d9282bb9e0.jpg",
|
||
"api": map[string]interface{} {
|
||
"v1": map[string]interface{} {
|
||
"public": "https://whitebit.com/api/v1/public",
|
||
"private": "https://whitebit.com/api/v1",
|
||
},
|
||
"v2": map[string]interface{} {
|
||
"public": "https://whitebit.com/api/v2/public",
|
||
},
|
||
"v4": map[string]interface{} {
|
||
"public": "https://whitebit.com/api/v4/public",
|
||
"private": "https://whitebit.com/api/v4",
|
||
},
|
||
},
|
||
"www": "https://www.whitebit.com",
|
||
"doc": "https://github.com/whitebit-exchange/api-docs",
|
||
"fees": "https://whitebit.com/fee-schedule",
|
||
"referral": "https://whitebit.com/referral/d9bdf40e-28f2-4b52-b2f9-cd1415d82963",
|
||
},
|
||
"api": map[string]interface{} {
|
||
"web": map[string]interface{} {
|
||
"get": []interface{}{"v1/healthcheck"},
|
||
},
|
||
"v1": map[string]interface{} {
|
||
"public": map[string]interface{} {
|
||
"get": []interface{}{"markets", "tickers", "ticker", "symbols", "depth/result", "history", "kline"},
|
||
},
|
||
"private": map[string]interface{} {
|
||
"post": []interface{}{"account/balance", "order/new", "order/cancel", "orders", "account/order_history", "account/executed_history", "account/executed_history/all", "account/order"},
|
||
},
|
||
},
|
||
"v2": map[string]interface{} {
|
||
"public": map[string]interface{} {
|
||
"get": []interface{}{"markets", "ticker", "assets", "fee", "depth/{market}", "trades/{market}"},
|
||
},
|
||
},
|
||
"v4": map[string]interface{} {
|
||
"public": map[string]interface{} {
|
||
"get": []interface{}{"assets", "collateral/markets", "fee", "orderbook/{market}", "ticker", "trades/{market}", "time", "ping", "markets", "futures", "platform/status"},
|
||
},
|
||
"private": map[string]interface{} {
|
||
"post": []interface{}{"collateral-account/balance", "collateral-account/balance-summary", "collateral-account/positions/history", "collateral-account/leverage", "collateral-account/positions/open", "collateral-account/summary", "main-account/address", "main-account/balance", "main-account/create-new-address", "main-account/codes", "main-account/codes/apply", "main-account/codes/my", "main-account/codes/history", "main-account/fiat-deposit-url", "main-account/history", "main-account/withdraw", "main-account/withdraw-pay", "main-account/transfer", "main-account/smart/plans", "main-account/smart/investment", "main-account/smart/investment/close", "main-account/smart/investments", "main-account/fee", "main-account/smart/interest-payment-history", "trade-account/balance", "trade-account/executed-history", "trade-account/order", "trade-account/order/history", "order/collateral/limit", "order/collateral/market", "order/collateral/stop-limit", "order/collateral/trigger-market", "order/new", "order/market", "order/stock_market", "order/stop_limit", "order/stop_market", "order/cancel", "order/cancel/all", "order/kill-switch", "order/kill-switch/status", "order/bulk", "order/modify", "orders", "oco-orders", "order/collateral/oco", "order/oco-cancel", "order/oto-cancel", "profile/websocket_token", "convert/estimate", "convert/confirm", "convert/history", "sub-account/create", "sub-account/delete", "sub-account/edit", "sub-account/list", "sub-account/transfer", "sub-account/block", "sub-account/unblock", "sub-account/balances", "sub-account/transfer/history"},
|
||
},
|
||
},
|
||
},
|
||
"fees": map[string]interface{} {
|
||
"trading": map[string]interface{} {
|
||
"tierBased": false,
|
||
"percentage": true,
|
||
"taker": this.ParseNumber("0.001"),
|
||
"maker": this.ParseNumber("0.001"),
|
||
},
|
||
},
|
||
"options": map[string]interface{} {
|
||
"timeDifference": 0,
|
||
"adjustForTimeDifference": false,
|
||
"fiatCurrencies": []interface{}{"EUR", "USD", "RUB", "UAH"},
|
||
"fetchBalance": map[string]interface{} {
|
||
"account": "spot",
|
||
},
|
||
"accountsByType": map[string]interface{} {
|
||
"funding": "main",
|
||
"main": "main",
|
||
"spot": "spot",
|
||
"margin": "collateral",
|
||
"trade": "spot",
|
||
},
|
||
"networksById": map[string]interface{} {
|
||
"BEP20": "BSC",
|
||
},
|
||
"defaultType": "spot",
|
||
"brokerId": "ccxt",
|
||
},
|
||
"features": map[string]interface{} {
|
||
"default": map[string]interface{} {
|
||
"sandbox": false,
|
||
"createOrder": map[string]interface{} {
|
||
"marginMode": true,
|
||
"triggerPrice": true,
|
||
"triggerDirection": false,
|
||
"triggerPriceType": nil,
|
||
"stopLossPrice": false,
|
||
"takeProfitPrice": false,
|
||
"attachedStopLossTakeProfit": nil,
|
||
"timeInForce": map[string]interface{} {
|
||
"IOC": true,
|
||
"FOK": false,
|
||
"PO": true,
|
||
"GTD": false,
|
||
},
|
||
"hedged": false,
|
||
"trailing": false,
|
||
"leverage": false,
|
||
"marketBuyByCost": true,
|
||
"marketBuyRequiresPrice": false,
|
||
"selfTradePrevention": false,
|
||
"iceberg": false,
|
||
},
|
||
"createOrders": nil,
|
||
"fetchMyTrades": map[string]interface{} {
|
||
"marginMode": false,
|
||
"limit": 100,
|
||
"daysBack": nil,
|
||
"untilDays": nil,
|
||
"symbolRequired": false,
|
||
},
|
||
"fetchOrder": nil,
|
||
"fetchOpenOrders": map[string]interface{} {
|
||
"marginMode": false,
|
||
"limit": 100,
|
||
"trigger": false,
|
||
"trailing": false,
|
||
"symbolRequired": false,
|
||
},
|
||
"fetchOrders": nil,
|
||
"fetchClosedOrders": map[string]interface{} {
|
||
"marginMode": false,
|
||
"limit": 100,
|
||
"daysBack": nil,
|
||
"daysBackCanceled": nil,
|
||
"untilDays": nil,
|
||
"trigger": false,
|
||
"trailing": false,
|
||
"symbolRequired": false,
|
||
},
|
||
"fetchOHLCV": map[string]interface{} {
|
||
"limit": 1440,
|
||
},
|
||
},
|
||
"spot": map[string]interface{} {
|
||
"extends": "default",
|
||
},
|
||
"swap": map[string]interface{} {
|
||
"linear": map[string]interface{} {
|
||
"extends": "default",
|
||
},
|
||
"inverse": map[string]interface{} {
|
||
"extends": "default",
|
||
},
|
||
},
|
||
"future": map[string]interface{} {
|
||
"linear": nil,
|
||
"inverse": nil,
|
||
},
|
||
},
|
||
"precisionMode": TICK_SIZE,
|
||
"exceptions": map[string]interface{} {
|
||
"exact": map[string]interface{} {
|
||
"Unauthorized request.": AuthenticationError,
|
||
"The market format is invalid.": BadSymbol,
|
||
"Market is not available": BadSymbol,
|
||
"Invalid payload.": BadRequest,
|
||
"Amount must be greater than 0": InvalidOrder,
|
||
"Not enough balance.": InsufficientFunds,
|
||
"The order id field is required.": InvalidOrder,
|
||
"Not enough balance": InsufficientFunds,
|
||
"This action is unauthorized.": PermissionDenied,
|
||
"This API Key is not authorized to perform this action.": PermissionDenied,
|
||
"Unexecuted order was not found.": OrderNotFound,
|
||
"The selected from is invalid.": BadRequest,
|
||
"503": ExchangeNotAvailable,
|
||
"422": OrderNotFound,
|
||
},
|
||
"broad": map[string]interface{} {
|
||
"This action is unauthorized": PermissionDenied,
|
||
"Given amount is less than min amount": InvalidOrder,
|
||
"Min amount step": InvalidOrder,
|
||
"Total is less than": InvalidOrder,
|
||
"fee must be no less than": InvalidOrder,
|
||
"Enable your key in API settings": PermissionDenied,
|
||
"You don\\'t have such amount for transfer": InsufficientFunds,
|
||
},
|
||
},
|
||
})
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchMarkets
|
||
* @description retrieves data on all markets for whitebit
|
||
* @see https://docs.whitebit.com/public/http-v4/#market-info
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object[]} an array of objects representing market data
|
||
*/
|
||
func (this *whitebit) 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
|
||
if IsTrue(GetValue(this.Options, "adjustForTimeDifference")) {
|
||
|
||
retRes39512 := (<-this.LoadTimeDifference())
|
||
PanicOnError(retRes39512)
|
||
}
|
||
|
||
markets:= (<-this.V4PublicGetMarkets())
|
||
PanicOnError(markets)
|
||
|
||
//
|
||
// [
|
||
// {
|
||
// "name": "SON_USD", // Market pair name
|
||
// "stock": "SON", // Ticker of stock currency
|
||
// "money": "USD", // Ticker of money currency
|
||
// "stockPrec": "3", // Stock currency precision
|
||
// "moneyPrec": "2", // Precision of money currency
|
||
// "feePrec": "4", // Fee precision
|
||
// "makerFee": "0.1", // Default maker fee ratio
|
||
// "takerFee": "0.1", // Default taker fee ratio
|
||
// "minAmount": "0.001", // Minimal amount of stock to trade
|
||
// "minTotal": "0.001", // Minimal amount of money to trade
|
||
// "tradesEnabled": true, // Is trading enabled
|
||
// "isCollateral": true, // Is margin trading enabled
|
||
// "type": "spot", // Market type. Possible values: "spot", "futures"
|
||
// "maxTotal": "1000000000" // Maximum total(amount * price) of money to trade
|
||
// },
|
||
// {
|
||
// ...
|
||
// }
|
||
// ]
|
||
//
|
||
ch <- this.ParseMarkets(markets)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseMarket(market interface{}) interface{} {
|
||
var id interface{} = this.SafeString(market, "name")
|
||
var baseId interface{} = this.SafeString(market, "stock")
|
||
var quoteId interface{} = this.SafeString(market, "money")
|
||
quoteId = Ternary(IsTrue((IsEqual(quoteId, "PERP"))), "USDT", quoteId)
|
||
var base interface{} = this.SafeCurrencyCode(baseId)
|
||
var quote interface{} = this.SafeCurrencyCode(quoteId)
|
||
var active interface{} = this.SafeValue(market, "tradesEnabled")
|
||
var isCollateral interface{} = this.SafeValue(market, "isCollateral")
|
||
var typeId interface{} = this.SafeString(market, "type")
|
||
var typeVar interface{} = nil
|
||
var settle interface{} = nil
|
||
var settleId interface{} = nil
|
||
var symbol interface{} = Add(Add(base, "/"), quote)
|
||
var swap interface{} = IsEqual(typeId, "futures")
|
||
var margin interface{} = IsTrue(isCollateral) && !IsTrue(swap)
|
||
var contract interface{} = false
|
||
var amountPrecision interface{} = this.ParseNumber(this.ParsePrecision(this.SafeString(market, "stockPrec")))
|
||
var contractSize interface{} = amountPrecision
|
||
var linear interface{} = nil
|
||
var inverse interface{} = nil
|
||
if IsTrue(swap) {
|
||
settleId = quoteId
|
||
settle = this.SafeCurrencyCode(settleId)
|
||
symbol = Add(Add(symbol, ":"), settle)
|
||
typeVar = "swap"
|
||
contract = true
|
||
linear = true
|
||
inverse = false
|
||
} else {
|
||
typeVar = "spot"
|
||
}
|
||
var takerFeeRate interface{} = this.SafeString(market, "takerFee")
|
||
var taker interface{} = Precise.StringDiv(takerFeeRate, "100")
|
||
var makerFeeRate interface{} = this.SafeString(market, "makerFee")
|
||
var maker interface{} = Precise.StringDiv(makerFeeRate, "100")
|
||
return map[string]interface{} {
|
||
"id": id,
|
||
"symbol": symbol,
|
||
"base": base,
|
||
"quote": quote,
|
||
"settle": settle,
|
||
"baseId": baseId,
|
||
"quoteId": quoteId,
|
||
"settleId": settleId,
|
||
"type": typeVar,
|
||
"spot": !IsTrue(swap),
|
||
"margin": margin,
|
||
"swap": swap,
|
||
"future": false,
|
||
"option": false,
|
||
"active": active,
|
||
"contract": contract,
|
||
"linear": linear,
|
||
"inverse": inverse,
|
||
"taker": this.ParseNumber(taker),
|
||
"maker": this.ParseNumber(maker),
|
||
"contractSize": contractSize,
|
||
"expiry": nil,
|
||
"expiryDatetime": nil,
|
||
"strike": nil,
|
||
"optionType": nil,
|
||
"precision": map[string]interface{} {
|
||
"amount": amountPrecision,
|
||
"price": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "moneyPrec"))),
|
||
},
|
||
"limits": map[string]interface{} {
|
||
"leverage": map[string]interface{} {
|
||
"min": nil,
|
||
"max": nil,
|
||
},
|
||
"amount": map[string]interface{} {
|
||
"min": this.SafeNumber(market, "minAmount"),
|
||
"max": nil,
|
||
},
|
||
"price": map[string]interface{} {
|
||
"min": nil,
|
||
"max": nil,
|
||
},
|
||
"cost": map[string]interface{} {
|
||
"min": this.SafeNumber(market, "minTotal"),
|
||
"max": this.SafeNumber(market, "maxTotal"),
|
||
},
|
||
},
|
||
"created": nil,
|
||
"info": market,
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchCurrencies
|
||
* @description fetches all available currencies on an exchange
|
||
* @see https://docs.whitebit.com/public/http-v4/#asset-status-list
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an associative dictionary of currencies
|
||
*/
|
||
func (this *whitebit) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
response:= (<-this.V4PublicGetAssets(params))
|
||
PanicOnError(response)
|
||
//
|
||
// "BTC": {
|
||
// "name": "Bitcoin",
|
||
// "unified_cryptoasset_id": 1,
|
||
// "can_withdraw": true,
|
||
// "can_deposit": true,
|
||
// "min_withdraw": "0.001",
|
||
// "max_withdraw": "2",
|
||
// "maker_fee": "0.1",
|
||
// "taker_fee": "0.1",
|
||
// "min_deposit": "0.0001",
|
||
// "max_deposit": "0",
|
||
// },
|
||
//
|
||
var ids interface{} = ObjectKeys(response)
|
||
var result interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(ids)); i++ {
|
||
var id interface{} = GetValue(ids, i)
|
||
var currency interface{} = GetValue(response, id)
|
||
// breaks down in Python due to utf8 encoding issues on the exchange side
|
||
// const name = this.safeString (currency, 'name');
|
||
var canDeposit interface{} = this.SafeBool(currency, "can_deposit", true)
|
||
var canWithdraw interface{} = this.SafeBool(currency, "can_withdraw", true)
|
||
var active interface{} = IsTrue(canDeposit) && IsTrue(canWithdraw)
|
||
var code interface{} = this.SafeCurrencyCode(id)
|
||
AddElementToObject(result, code, map[string]interface{} {
|
||
"id": id,
|
||
"code": code,
|
||
"info": currency,
|
||
"name": nil,
|
||
"active": active,
|
||
"deposit": canDeposit,
|
||
"withdraw": canWithdraw,
|
||
"fee": nil,
|
||
"precision": nil,
|
||
"limits": map[string]interface{} {
|
||
"amount": map[string]interface{} {
|
||
"min": nil,
|
||
"max": nil,
|
||
},
|
||
"withdraw": map[string]interface{} {
|
||
"min": this.SafeNumber(currency, "min_withdraw"),
|
||
"max": this.SafeNumber(currency, "max_withdraw"),
|
||
},
|
||
},
|
||
})
|
||
}
|
||
|
||
ch <- result
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchTransactionFees
|
||
* @deprecated
|
||
* @description please use fetchDepositWithdrawFees instead
|
||
* @see https://docs.whitebit.com/public/http-v4/#fee
|
||
* @param {string[]|undefined} codes not used by fetchTransactionFees ()
|
||
* @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 *whitebit) FetchTransactionFees(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
|
||
|
||
retRes5848 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes5848)
|
||
|
||
response:= (<-this.V4PublicGetFee(params))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "1INCH":{
|
||
// "is_depositable":true,
|
||
// "is_withdrawal":true,
|
||
// "ticker":"1INCH",
|
||
// "name":"1inch",
|
||
// "providers":[
|
||
// ],
|
||
// "withdraw":{
|
||
// "max_amount":"0",
|
||
// "min_amount":"21.5",
|
||
// "fixed":"17.5",
|
||
// "flex":null
|
||
// },
|
||
// "deposit":{
|
||
// "max_amount":"0",
|
||
// "min_amount":"19.5",
|
||
// "fixed":null,
|
||
// "flex":null
|
||
// }
|
||
// },
|
||
// {...}
|
||
// }
|
||
//
|
||
var currenciesIds interface{} = ObjectKeys(response)
|
||
var withdrawFees interface{} = map[string]interface{} {}
|
||
var depositFees interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(currenciesIds)); i++ {
|
||
var currency interface{} = GetValue(currenciesIds, i)
|
||
var data interface{} = GetValue(response, currency)
|
||
var code interface{} = this.SafeCurrencyCode(currency)
|
||
var withdraw interface{} = this.SafeValue(data, "withdraw", map[string]interface{} {})
|
||
AddElementToObject(withdrawFees, code, this.SafeString(withdraw, "fixed"))
|
||
var deposit interface{} = this.SafeValue(data, "deposit", map[string]interface{} {})
|
||
AddElementToObject(depositFees, code, this.SafeString(deposit, "fixed"))
|
||
}
|
||
|
||
ch <- map[string]interface{} {
|
||
"withdraw": withdrawFees,
|
||
"deposit": depositFees,
|
||
"info": response,
|
||
}
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchDepositWithdrawFees
|
||
* @description fetch deposit and withdraw fees
|
||
* @see https://docs.whitebit.com/public/http-v4/#fee
|
||
* @param {string[]|undefined} codes not used by fetchDepositWithdrawFees ()
|
||
* @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 *whitebit) 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
|
||
|
||
retRes6408 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes6408)
|
||
|
||
response:= (<-this.V4PublicGetFee(params))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// {
|
||
// "1INCH": {
|
||
// "is_depositable": true,
|
||
// "is_withdrawal": true,
|
||
// "ticker": "1INCH",
|
||
// "name": "1inch",
|
||
// "providers": [],
|
||
// "withdraw": {
|
||
// "max_amount": "0",
|
||
// "min_amount": "21.5",
|
||
// "fixed": "17.5",
|
||
// "flex": null
|
||
// },
|
||
// "deposit": {
|
||
// "max_amount": "0",
|
||
// "min_amount": "19.5",
|
||
// "fixed": null,
|
||
// "flex": null
|
||
// }
|
||
// },
|
||
// "WBT (ERC20)": {
|
||
// "is_depositable": true,
|
||
// "is_withdrawal": true,
|
||
// "ticker": "WBT",
|
||
// "name": "WhiteBIT Token",
|
||
// "providers": [],
|
||
// "withdraw": { max_amount: "0", min_amount: '0.7', fixed: "0.253", flex: null },
|
||
// "deposit": { max_amount: "0", min_amount: "0.35", fixed: null, flex: null }
|
||
// },
|
||
// "WBT (TRC20)": {
|
||
// "is_depositable": true,
|
||
// "is_withdrawal": true,
|
||
// "ticker": "WBT",
|
||
// "name": "WhiteBIT Token",
|
||
// "providers": [],
|
||
// "withdraw": { max_amount: "0", min_amount: "1.5", fixed: "0.075", flex: null },
|
||
// "deposit": { max_amount: "0", min_amount: "0.75", fixed: null, flex: null }
|
||
// },
|
||
// ...
|
||
// }
|
||
//
|
||
ch <- this.ParseDepositWithdrawFees(response, codes)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseDepositWithdrawFees(response interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "1INCH": {
|
||
// "is_depositable": true,
|
||
// "is_withdrawal": true,
|
||
// "ticker": "1INCH",
|
||
// "name": "1inch",
|
||
// "providers": [],
|
||
// "withdraw": {
|
||
// "max_amount": "0",
|
||
// "min_amount": "21.5",
|
||
// "fixed": "17.5",
|
||
// "flex": null
|
||
// },
|
||
// "deposit": {
|
||
// "max_amount": "0",
|
||
// "min_amount": "19.5",
|
||
// "fixed": null,
|
||
// "flex": null
|
||
// }
|
||
// },
|
||
// "WBT (ERC20)": {
|
||
// "is_depositable": true,
|
||
// "is_withdrawal": true,
|
||
// "ticker": "WBT",
|
||
// "name": "WhiteBIT Token",
|
||
// "providers": [],
|
||
// "withdraw": { max_amount: "0", min_amount: "0.7", fixed: "0.253", flex: null },
|
||
// "deposit": { max_amount: "0", min_amount: "0.35", fixed: null, flex: null }
|
||
// },
|
||
// "WBT (TRC20)": {
|
||
// "is_depositable": true,
|
||
// "is_withdrawal": true,
|
||
// "ticker": "WBT",
|
||
// "name": "WhiteBIT Token",
|
||
// "providers": [],
|
||
// "withdraw": { max_amount: "0", min_amount: "1.5", fixed: "0.075", flex: null },
|
||
// "deposit": { max_amount: "0", min_amount: "0.75", fixed: null, flex: null }
|
||
// },
|
||
// ...
|
||
// }
|
||
//
|
||
codes := GetArg(optionalArgs, 0, nil)
|
||
_ = codes
|
||
currencyIdKey := GetArg(optionalArgs, 1, nil)
|
||
_ = currencyIdKey
|
||
var depositWithdrawFees interface{} = map[string]interface{} {}
|
||
codes = this.MarketCodes(codes)
|
||
var currencyIds interface{} = ObjectKeys(response)
|
||
for i := 0; IsLessThan(i, GetArrayLength(currencyIds)); i++ {
|
||
var entry interface{} = GetValue(currencyIds, i)
|
||
var splitEntry interface{} = Split(entry, " ")
|
||
var currencyId interface{} = GetValue(splitEntry, 0)
|
||
var feeInfo interface{} = GetValue(response, entry)
|
||
var code interface{} = this.SafeCurrencyCode(currencyId)
|
||
if IsTrue(IsTrue((IsEqual(codes, nil))) || IsTrue((this.InArray(code, codes)))) {
|
||
var depositWithdrawFee interface{} = this.SafeValue(depositWithdrawFees, code)
|
||
if IsTrue(IsEqual(depositWithdrawFee, nil)) {
|
||
AddElementToObject(depositWithdrawFees, code, this.DepositWithdrawFee(map[string]interface{} {}))
|
||
}
|
||
AddElementToObject(GetValue(GetValue(depositWithdrawFees, code), "info"), entry, feeInfo)
|
||
var networkId interface{} = this.SafeString(splitEntry, 1)
|
||
var withdraw interface{} = this.SafeValue(feeInfo, "withdraw")
|
||
var deposit interface{} = this.SafeValue(feeInfo, "deposit")
|
||
var withdrawFee interface{} = this.SafeNumber(withdraw, "fixed")
|
||
var depositFee interface{} = this.SafeNumber(deposit, "fixed")
|
||
var withdrawResult interface{} = map[string]interface{} {
|
||
"fee": withdrawFee,
|
||
"percentage": Ternary(IsTrue((!IsEqual(withdrawFee, nil))), false, nil),
|
||
}
|
||
var depositResult interface{} = map[string]interface{} {
|
||
"fee": depositFee,
|
||
"percentage": Ternary(IsTrue((!IsEqual(depositFee, nil))), false, nil),
|
||
}
|
||
if IsTrue(!IsEqual(networkId, nil)) {
|
||
var networkLength interface{} = GetLength(networkId)
|
||
networkId = Slice(networkId, 1, Subtract(networkLength, 1))
|
||
var networkCode interface{} = this.NetworkIdToCode(networkId)
|
||
AddElementToObject(GetValue(GetValue(depositWithdrawFees, code), "networks"), networkCode, map[string]interface{} {
|
||
"withdraw": withdrawResult,
|
||
"deposit": depositResult,
|
||
})
|
||
} else {
|
||
AddElementToObject(GetValue(depositWithdrawFees, code), "withdraw", withdrawResult)
|
||
AddElementToObject(GetValue(depositWithdrawFees, code), "deposit", depositResult)
|
||
}
|
||
}
|
||
}
|
||
var depositWithdrawCodes interface{} = ObjectKeys(depositWithdrawFees)
|
||
for i := 0; IsLessThan(i, GetArrayLength(depositWithdrawCodes)); i++ {
|
||
var code interface{} = GetValue(depositWithdrawCodes, i)
|
||
var currency interface{} = this.Currency(code)
|
||
AddElementToObject(depositWithdrawFees, code, this.AssignDefaultDepositWithdrawFees(GetValue(depositWithdrawFees, code), currency))
|
||
}
|
||
return depositWithdrawFees
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchTradingFees
|
||
* @description fetch the trading fees for multiple markets
|
||
* @see https://docs.whitebit.com/public/http-v4/#asset-status-list
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a dictionary of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure} indexed by market symbols
|
||
*/
|
||
func (this *whitebit) FetchTradingFees(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
|
||
|
||
retRes7908 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes7908)
|
||
|
||
response:= (<-this.V4PublicGetAssets(params))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "1INCH": {
|
||
// "name": "1inch",
|
||
// "unified_cryptoasset_id": "8104",
|
||
// "can_withdraw": true,
|
||
// "can_deposit": true,
|
||
// "min_withdraw": "33",
|
||
// "max_withdraw": "0",
|
||
// "maker_fee": "0.1",
|
||
// "taker_fee": "0.1",
|
||
// "min_deposit": "30",
|
||
// "max_deposit": "0"
|
||
// },
|
||
// ...
|
||
// }
|
||
//
|
||
var result interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(this.Symbols)); i++ {
|
||
var symbol interface{} = GetValue(this.Symbols, i)
|
||
var market interface{} = this.Market(symbol)
|
||
var fee interface{} = this.SafeValue(response, GetValue(market, "baseId"), map[string]interface{} {})
|
||
var makerFee interface{} = this.SafeString(fee, "maker_fee")
|
||
var takerFee interface{} = this.SafeString(fee, "taker_fee")
|
||
makerFee = Precise.StringDiv(makerFee, "100")
|
||
takerFee = Precise.StringDiv(takerFee, "100")
|
||
AddElementToObject(result, symbol, map[string]interface{} {
|
||
"info": fee,
|
||
"symbol": GetValue(market, "symbol"),
|
||
"percentage": true,
|
||
"tierBased": false,
|
||
"maker": this.ParseNumber(makerFee),
|
||
"taker": this.ParseNumber(takerFee),
|
||
})
|
||
}
|
||
|
||
ch <- result
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchTicker
|
||
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
|
||
* @see https://docs.whitebit.com/public/http-v4/#market-activity
|
||
* @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 *whitebit) 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
|
||
|
||
retRes8408 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes8408)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
}
|
||
|
||
response:= (<-this.V1PublicGetTicker(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "success":true,
|
||
// "message":"",
|
||
// "result": {
|
||
// "bid":"0.021979",
|
||
// "ask":"0.021996",
|
||
// "open":"0.02182",
|
||
// "high":"0.022039",
|
||
// "low":"0.02161",
|
||
// "last":"0.021987",
|
||
// "volume":"2810.267",
|
||
// "deal":"61.383565474",
|
||
// "change":"0.76",
|
||
// },
|
||
// }
|
||
//
|
||
var ticker interface{} = this.SafeDict(response, "result", map[string]interface{} {})
|
||
|
||
ch <- this.ParseTicker(ticker, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// FetchTicker (v1)
|
||
//
|
||
// {
|
||
// "bid": "0.021979",
|
||
// "ask": "0.021996",
|
||
// "open": "0.02182",
|
||
// "high": "0.022039",
|
||
// "low": "0.02161",
|
||
// "last": "0.021987",
|
||
// "volume": "2810.267",
|
||
// "deal": "61.383565474",
|
||
// "change": "0.76",
|
||
// }
|
||
//
|
||
// FetchTickers (v4)
|
||
//
|
||
// "BCH_RUB": {
|
||
// "base_id": 1831,
|
||
// "quote_id": 0,
|
||
// "last_price": "32830.21",
|
||
// "quote_volume": "1494659.8024096",
|
||
// "base_volume": "46.1083",
|
||
// "isFrozen": false,
|
||
// "change": "2.12" // in percent
|
||
// }
|
||
//
|
||
// WS market_update
|
||
//
|
||
// {
|
||
// "open": "52853.04",
|
||
// "close": "55913.88",
|
||
// "high": "56272",
|
||
// "low": "49549.67",
|
||
// "volume": "57331.067185",
|
||
// "deal": "3063860382.42985338",
|
||
// "last": "55913.88",
|
||
// "period": 86400
|
||
// }
|
||
// v2
|
||
// {
|
||
// lastUpdateTimestamp: '2025-01-02T09:16:36.000Z',
|
||
// tradingPairs: 'ARB_USDC',
|
||
// lastPrice: '0.7727',
|
||
// lowestAsk: '0.7735',
|
||
// highestBid: '0.7732',
|
||
// baseVolume24h: '1555793.74',
|
||
// quoteVolume24h: '1157602.622406',
|
||
// tradesEnabled: true
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(ticker, "tradingPairs")
|
||
market = this.SafeMarket(marketId, market)
|
||
// last price is provided as "last" or "last_price"
|
||
var last interface{} = this.SafeStringN(ticker, []interface{}{"last", "last_price", "lastPrice"})
|
||
// if "close" is provided, use it, otherwise use <last>
|
||
var close interface{} = this.SafeString(ticker, "close", last)
|
||
return this.SafeTicker(map[string]interface{} {
|
||
"symbol": GetValue(market, "symbol"),
|
||
"timestamp": nil,
|
||
"datetime": nil,
|
||
"high": this.SafeString(ticker, "high"),
|
||
"low": this.SafeString(ticker, "low"),
|
||
"bid": this.SafeString2(ticker, "bid", "highestBid"),
|
||
"bidVolume": nil,
|
||
"ask": this.SafeString2(ticker, "ask", "lowestAsk"),
|
||
"askVolume": nil,
|
||
"vwap": nil,
|
||
"open": this.SafeString(ticker, "open"),
|
||
"close": close,
|
||
"last": last,
|
||
"previousClose": nil,
|
||
"change": nil,
|
||
"percentage": this.SafeString(ticker, "change"),
|
||
"average": nil,
|
||
"baseVolume": this.SafeStringN(ticker, []interface{}{"base_volume", "volume", "baseVolume24h"}),
|
||
"quoteVolume": this.SafeStringN(ticker, []interface{}{"quote_volume", "deal", "quoteVolume24h"}),
|
||
"info": ticker,
|
||
}, market)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchTickers
|
||
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
|
||
* @see https://docs.whitebit.com/public/http-v4/#market-activity
|
||
* @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
|
||
* @param {string} [params.method] either v2PublicGetTicker or v4PublicGetTicker default is v4PublicGetTicker
|
||
* @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes9608 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes9608)
|
||
symbols = this.MarketSymbols(symbols)
|
||
var method interface{} = "v4PublicGetTicker"
|
||
methodparamsVariable := this.HandleOptionAndParams(params, "fetchTickers", "method", method);
|
||
method = GetValue(methodparamsVariable,0);
|
||
params = GetValue(methodparamsVariable,1)
|
||
var response interface{} = nil
|
||
if IsTrue(IsEqual(method, "v4PublicGetTicker")) {
|
||
|
||
response = (<-this.V4PublicGetTicker(params))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.V2PublicGetTicker(params))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// "BCH_RUB": {
|
||
// "base_id":1831,
|
||
// "quote_id":0,
|
||
// "last_price":"32830.21",
|
||
// "quote_volume":"1494659.8024096",
|
||
// "base_volume":"46.1083",
|
||
// "isFrozen":false,
|
||
// "change":"2.12"
|
||
// },
|
||
//
|
||
var resultList interface{} = this.SafeList(response, "result")
|
||
if IsTrue(!IsEqual(resultList, nil)) {
|
||
|
||
ch <- this.ParseTickers(resultList, symbols)
|
||
return nil
|
||
}
|
||
var marketIds interface{} = ObjectKeys(response)
|
||
var result interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(marketIds)); i++ {
|
||
var marketId interface{} = GetValue(marketIds, i)
|
||
var market interface{} = this.SafeMarket(marketId)
|
||
var ticker interface{} = this.ParseTicker(GetValue(response, marketId), market)
|
||
var symbol interface{} = GetValue(ticker, "symbol")
|
||
AddElementToObject(result, symbol, ticker)
|
||
}
|
||
|
||
ch <- this.FilterByArrayTickers(result, "symbol", symbols)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchOrderBook
|
||
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
|
||
* @see https://docs.whitebit.com/public/http-v4/#orderbook
|
||
* @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 *whitebit) 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
|
||
|
||
retRes10088 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes10088)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", limit) // default = 100, maximum = 100
|
||
}
|
||
|
||
response:= (<-this.V4PublicGetOrderbookMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "timestamp": 1594391413,
|
||
// "asks": [
|
||
// [
|
||
// "9184.41",
|
||
// "0.773162"
|
||
// ],
|
||
// [ ... ]
|
||
// ],
|
||
// "bids": [
|
||
// [
|
||
// "9181.19",
|
||
// "0.010873"
|
||
// ],
|
||
// [ ... ]
|
||
// ]
|
||
// }
|
||
//
|
||
var timestamp interface{} = this.SafeTimestamp(response, "timestamp")
|
||
|
||
ch <- this.ParseOrderBook(response, symbol, timestamp)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchTrades
|
||
* @description get the list of most recent trades for a particular symbol
|
||
* @see https://docs.whitebit.com/public/http-v4/#recent-trades
|
||
* @param {string} symbol unified symbol of the market to fetch trades for
|
||
* @param {int} [since] timestamp in ms of the earliest trade to fetch
|
||
* @param {int} [limit] the maximum amount of trades to fetch
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes10528 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes10528)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
}
|
||
|
||
response:= (<-this.V4PublicGetTradesMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// [
|
||
// {
|
||
// "tradeID": 158056419,
|
||
// "price": "9186.13",
|
||
// "quote_volume": "0.0021",
|
||
// "base_volume": "9186.13",
|
||
// "trade_timestamp": 1594391747,
|
||
// "type": "sell"
|
||
// },
|
||
// ],
|
||
//
|
||
ch <- this.ParseTrades(response, market, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchMyTrades
|
||
* @description fetch all trades made by the user
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#query-executed-order-history
|
||
* @param {string} symbol unified symbol of the market to fetch trades for
|
||
* @param {int} [since] timestamp in ms of the earliest trade to fetch
|
||
* @param {int} [limit] the maximum amount of trades to fetch
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes10858 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes10858)
|
||
var market interface{} = nil
|
||
var request interface{} = map[string]interface{} {}
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "market", GetValue(market, "id"))
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostTradeAccountExecutedHistory(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// when no symbol is provided
|
||
//
|
||
// {
|
||
// "USDC_USDT":[
|
||
// {
|
||
// "id":"1343815269",
|
||
// "clientOrderId":"",
|
||
// "time":"1641051917.532965",
|
||
// "side":"sell",
|
||
// "role":"2",
|
||
// "amount":"9.986",
|
||
// "price":"0.9995",
|
||
// "deal":"9.981007",
|
||
// "fee":"0.009981007",
|
||
// "orderId":"58166729555"
|
||
// },
|
||
// ]
|
||
// }
|
||
//
|
||
// when a symbol is provided
|
||
//
|
||
// [
|
||
// {
|
||
// "id": 1343815269,
|
||
// "clientOrderId": '',
|
||
// "time": 1641051917.532965,
|
||
// "side": "sell",
|
||
// "role": 2,
|
||
// "amount": "9.986",
|
||
// "price": "0.9995",
|
||
// "deal": "9.981007",
|
||
// "fee": "0.009981007",
|
||
// "orderId": 58166729555,
|
||
// },
|
||
// ]
|
||
//
|
||
if IsTrue(IsArray(response)) {
|
||
|
||
ch <- this.ParseTrades(response, market, since, limit)
|
||
return nil
|
||
} else {
|
||
var results interface{} = []interface{}{}
|
||
var keys interface{} = ObjectKeys(response)
|
||
for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
|
||
var marketId interface{} = GetValue(keys, i)
|
||
var marketNew interface{} = this.SafeMarket(marketId, nil, "_")
|
||
var rawTrades interface{} = this.SafeValue(response, marketId, []interface{}{})
|
||
var parsed interface{} = this.ParseTrades(rawTrades, marketNew, since, limit)
|
||
results = this.ArrayConcat(results, parsed)
|
||
}
|
||
results = this.SortBy2(results, "timestamp", "id")
|
||
|
||
ch <- this.FilterBySinceLimit(results, since, limit, "timestamp")
|
||
return nil
|
||
}
|
||
return nil
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// fetchTradesV4
|
||
//
|
||
// {
|
||
// "tradeID": 158056419,
|
||
// "price": "9186.13",
|
||
// "quote_volume": "0.0021",
|
||
// "base_volume": "9186.13",
|
||
// "trade_timestamp": 1594391747,
|
||
// "type": "sell"
|
||
// }
|
||
//
|
||
// orderTrades (v4Private)
|
||
//
|
||
// {
|
||
// "time": 1593342324.613711,
|
||
// "fee": "0.00000419198",
|
||
// "price": "0.00000701",
|
||
// "amount": "598",
|
||
// "id": 149156519, // trade id
|
||
// "dealOrderId": 3134995325, // orderId
|
||
// "clientOrderId": "customId11",
|
||
// "role": 2, // 1 = maker, 2 = taker
|
||
// "deal": "0.00419198" // amount in money
|
||
// "feeAsset": "USDT"
|
||
// }
|
||
//
|
||
// fetchMyTrades
|
||
//
|
||
// {
|
||
// "id": 1343815269,
|
||
// "clientOrderId": '',
|
||
// "time": 1641051917.532965,
|
||
// "side": "sell",
|
||
// "role": 2,
|
||
// "amount": "9.986",
|
||
// "price": "0.9995",
|
||
// "deal": "9.981007",
|
||
// "fee": "0.009981007",
|
||
// "orderId": 58166729555,
|
||
// "feeAsset": "USDT"
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
market = this.SafeMarket(nil, market)
|
||
var timestamp interface{} = this.SafeTimestamp2(trade, "time", "trade_timestamp")
|
||
var orderId interface{} = this.SafeString2(trade, "dealOrderId", "orderId")
|
||
var cost interface{} = this.SafeString(trade, "deal")
|
||
var price interface{} = this.SafeString(trade, "price")
|
||
var amount interface{} = this.SafeString2(trade, "amount", "quote_volume")
|
||
var id interface{} = this.SafeString2(trade, "id", "tradeID")
|
||
var side interface{} = this.SafeString2(trade, "type", "side")
|
||
var symbol interface{} = GetValue(market, "symbol")
|
||
var role interface{} = this.SafeInteger(trade, "role")
|
||
var takerOrMaker interface{} = nil
|
||
if IsTrue(!IsEqual(role, nil)) {
|
||
takerOrMaker = Ternary(IsTrue((IsEqual(role, 1))), "maker", "taker")
|
||
}
|
||
var fee interface{} = nil
|
||
var feeCost interface{} = this.SafeString(trade, "fee")
|
||
if IsTrue(!IsEqual(feeCost, nil)) {
|
||
fee = map[string]interface{} {
|
||
"cost": feeCost,
|
||
"currency": this.SafeCurrencyCode(this.SafeString(trade, "feeAsset")),
|
||
}
|
||
}
|
||
return this.SafeTrade(map[string]interface{} {
|
||
"info": trade,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"symbol": symbol,
|
||
"id": id,
|
||
"order": orderId,
|
||
"type": nil,
|
||
"takerOrMaker": takerOrMaker,
|
||
"side": side,
|
||
"price": price,
|
||
"amount": amount,
|
||
"cost": cost,
|
||
"fee": fee,
|
||
}, market)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchOHLCV
|
||
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
||
* @see https://docs.whitebit.com/public/http-v1/#kline
|
||
* @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
|
||
* @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes12438 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes12438)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
"interval": this.SafeString(this.Timeframes, timeframe, timeframe),
|
||
}
|
||
if IsTrue(!IsEqual(since, nil)) {
|
||
var maxLimit interface{} = 1440
|
||
if IsTrue(IsEqual(limit, nil)) {
|
||
limit = maxLimit
|
||
}
|
||
limit = mathMin(limit, maxLimit)
|
||
var start interface{} = this.ParseToInt(Divide(since, 1000))
|
||
AddElementToObject(request, "start", start)
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", mathMin(limit, 1440))
|
||
}
|
||
|
||
response:= (<-this.V1PublicGetKline(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "success":true,
|
||
// "message":"",
|
||
// "result":[
|
||
// [1591488000,"0.025025","0.025025","0.025029","0.025023","6.181","0.154686629"],
|
||
// [1591488060,"0.025028","0.025033","0.025035","0.025026","8.067","0.201921167"],
|
||
// [1591488120,"0.025034","0.02505","0.02505","0.025034","20.089","0.503114696"],
|
||
// ]
|
||
// }
|
||
//
|
||
var result interface{} = this.SafeList(response, "result", []interface{}{})
|
||
|
||
ch <- this.ParseOHLCVs(result, market, timeframe, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// [
|
||
// 1591488000,
|
||
// "0.025025",
|
||
// "0.025025",
|
||
// "0.025029",
|
||
// "0.025023",
|
||
// "6.181",
|
||
// "0.154686629"
|
||
// ]
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
return []interface{}{this.SafeTimestamp(ohlcv, 0), this.SafeNumber(ohlcv, 1), this.SafeNumber(ohlcv, 3), this.SafeNumber(ohlcv, 4), this.SafeNumber(ohlcv, 2), this.SafeNumber(ohlcv, 5)}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchStatus
|
||
* @description the latest known information on the availability of the exchange API
|
||
* @see https://docs.whitebit.com/public/http-v4/#server-status
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [status structure]{@link https://docs.ccxt.com/#/?id=exchange-status-structure}
|
||
*/
|
||
func (this *whitebit) FetchStatus(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
||
_ = params
|
||
|
||
response:= (<-this.V4PublicGetPing(params))
|
||
PanicOnError(response)
|
||
//
|
||
// [
|
||
// "pong"
|
||
// ]
|
||
//
|
||
var status interface{} = this.SafeString(response, 0)
|
||
|
||
ch <- map[string]interface{} {
|
||
"status": Ternary(IsTrue((IsEqual(status, "pong"))), "ok", status),
|
||
"updated": nil,
|
||
"eta": nil,
|
||
"url": nil,
|
||
"info": response,
|
||
}
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchTime
|
||
* @description fetches the current integer timestamp in milliseconds from the exchange server
|
||
* @see https://docs.whitebit.com/public/http-v4/#server-time
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {int} the current integer timestamp in milliseconds from the exchange server
|
||
*/
|
||
func (this *whitebit) 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.V4PublicGetTime(params))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// {
|
||
// "time":1737380046
|
||
// }
|
||
//
|
||
ch <- this.SafeInteger(response, "time")
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#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 *whitebit) 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, "cost", cost)
|
||
|
||
retRes135515 := (<-this.CreateOrder(symbol, "market", side, 0, nil, params))
|
||
PanicOnError(retRes135515)
|
||
// only buy side is supported
|
||
ch <- retRes135515
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#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 *whitebit) 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
|
||
|
||
retRes136815 := (<-this.CreateMarketOrderWithCost(symbol, "buy", cost, params))
|
||
PanicOnError(retRes136815)
|
||
ch <- retRes136815
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#createOrder
|
||
* @description create a trade order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#create-limit-order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#create-market-order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#create-buy-stock-market-order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#create-stop-limit-order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#create-stop-market-order
|
||
* @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 currency you want to trade in units of 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 {float} [params.cost] *market orders only* the cost of the order in units of the base currency
|
||
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes13908 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes13908)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
"side": side,
|
||
}
|
||
var cost interface{} = nil
|
||
costparamsVariable := this.HandleParamString(params, "cost");
|
||
cost = GetValue(costparamsVariable,0);
|
||
params = GetValue(costparamsVariable,1)
|
||
if IsTrue(!IsEqual(cost, nil)) {
|
||
if IsTrue(IsTrue((!IsEqual(side, "buy"))) || IsTrue((!IsEqual(typeVar, "market")))) {
|
||
panic(InvalidOrder(Add(this.Id, " createOrder() cost is only supported for market buy orders")))
|
||
}
|
||
AddElementToObject(request, "amount", this.CostToPrecision(symbol, cost))
|
||
} else {
|
||
AddElementToObject(request, "amount", this.AmountToPrecision(symbol, amount))
|
||
}
|
||
var clientOrderId interface{} = this.SafeString2(params, "clOrdId", "clientOrderId")
|
||
if IsTrue(IsEqual(clientOrderId, nil)) {
|
||
var brokerId interface{} = this.SafeString(this.Options, "brokerId")
|
||
if IsTrue(!IsEqual(brokerId, nil)) {
|
||
AddElementToObject(request, "clientOrderId", Add(brokerId, this.Uuid16()))
|
||
}
|
||
} else {
|
||
AddElementToObject(request, "clientOrderId", clientOrderId)
|
||
params = this.Omit(params, []interface{}{"clientOrderId"})
|
||
}
|
||
var marketType interface{} = this.SafeString(market, "type")
|
||
var isLimitOrder interface{} = IsEqual(typeVar, "limit")
|
||
var isMarketOrder interface{} = IsEqual(typeVar, "market")
|
||
var triggerPrice interface{} = this.SafeNumberN(params, []interface{}{"triggerPrice", "stopPrice", "activation_price"})
|
||
var isStopOrder interface{} = (!IsEqual(triggerPrice, nil))
|
||
var postOnly interface{} = this.IsPostOnly(isMarketOrder, false, params)
|
||
marginModequeryVariable := this.HandleMarginModeAndParams("createOrder", params);
|
||
marginMode := GetValue(marginModequeryVariable,0);
|
||
query := GetValue(marginModequeryVariable,1)
|
||
if IsTrue(postOnly) {
|
||
AddElementToObject(request, "postOnly", true)
|
||
}
|
||
if IsTrue(IsTrue(!IsEqual(marginMode, nil)) && IsTrue(!IsEqual(marginMode, "cross"))) {
|
||
panic(NotSupported(Add(this.Id, " createOrder() is only available for cross margin")))
|
||
}
|
||
params = this.Omit(query, []interface{}{"postOnly", "triggerPrice", "stopPrice"})
|
||
var useCollateralEndpoint interface{} = IsTrue(!IsEqual(marginMode, nil)) || IsTrue(IsEqual(marketType, "swap"))
|
||
var response interface{} = nil
|
||
if IsTrue(isStopOrder) {
|
||
AddElementToObject(request, "activation_price", this.PriceToPrecision(symbol, triggerPrice))
|
||
if IsTrue(isLimitOrder) {
|
||
// stop limit order
|
||
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
||
|
||
response = (<-this.V4PrivatePostOrderStopLimit(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
// stop market order
|
||
if IsTrue(useCollateralEndpoint) {
|
||
|
||
response = (<-this.V4PrivatePostOrderCollateralTriggerMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.V4PrivatePostOrderStopMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
}
|
||
} else {
|
||
if IsTrue(isLimitOrder) {
|
||
// limit order
|
||
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
||
if IsTrue(useCollateralEndpoint) {
|
||
|
||
response = (<-this.V4PrivatePostOrderCollateralLimit(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.V4PrivatePostOrderNew(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
} else {
|
||
// market order
|
||
if IsTrue(useCollateralEndpoint) {
|
||
|
||
response = (<-this.V4PrivatePostOrderCollateralMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
if IsTrue(!IsEqual(cost, nil)) {
|
||
|
||
response = (<-this.V4PrivatePostOrderMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.V4PrivatePostOrderStockMarket(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
ch <- this.ParseOrder(response)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#editOrder
|
||
* @description edit a trade order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#modify-order
|
||
* @param {string} id cancel 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 currency you want to trade in units of 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} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
if IsTrue(IsEqual(id, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " editOrder() requires a id argument")))
|
||
}
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " editOrder() requires a symbol argument")))
|
||
}
|
||
|
||
retRes14928 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes14928)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"orderId": id,
|
||
"market": GetValue(market, "id"),
|
||
}
|
||
var clientOrderId interface{} = this.SafeString2(params, "clOrdId", "clientOrderId")
|
||
if IsTrue(!IsEqual(clientOrderId, nil)) {
|
||
// Update clientOrderId of the order
|
||
AddElementToObject(request, "clientOrderId", clientOrderId)
|
||
}
|
||
var isLimitOrder interface{} = IsEqual(typeVar, "limit")
|
||
var triggerPrice interface{} = this.SafeNumberN(params, []interface{}{"triggerPrice", "stopPrice", "activation_price"})
|
||
var isStopOrder interface{} = (!IsEqual(triggerPrice, nil))
|
||
params = this.Omit(params, []interface{}{"clOrdId", "clientOrderId", "triggerPrice", "stopPrice"})
|
||
if IsTrue(isStopOrder) {
|
||
AddElementToObject(request, "activation_price", this.PriceToPrecision(symbol, triggerPrice))
|
||
if IsTrue(isLimitOrder) {
|
||
// stop limit order
|
||
AddElementToObject(request, "amount", this.AmountToPrecision(symbol, amount))
|
||
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
||
} else {
|
||
// stop market order
|
||
if IsTrue(IsEqual(side, "buy")) {
|
||
// Use total parameter instead of amount for modify buy stop market order
|
||
AddElementToObject(request, "total", this.AmountToPrecision(symbol, amount))
|
||
} else {
|
||
AddElementToObject(request, "amount", this.AmountToPrecision(symbol, amount))
|
||
}
|
||
}
|
||
} else {
|
||
AddElementToObject(request, "amount", this.AmountToPrecision(symbol, amount))
|
||
if IsTrue(isLimitOrder) {
|
||
// limit order
|
||
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
|
||
}
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostOrderModify(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
ch <- this.ParseOrder(response)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#cancelOrder
|
||
* @description cancels an open order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#cancel-order
|
||
* @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
|
||
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument")))
|
||
}
|
||
|
||
retRes15478 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes15478)
|
||
var market interface{} = this.Market(symbol)
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
"orderId": ParseInt(id),
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostOrderCancel(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// {
|
||
// "orderId": 4180284841, // order id
|
||
// "clientOrderId": "customId11", // custom order identifier; "clientOrderId": "" - if not specified.
|
||
// "market": "BTC_USDT", // deal market
|
||
// "side": "buy", // order side
|
||
// "type": "stop market", // order type
|
||
// "timestamp": 1595792396.165973, // current timestamp
|
||
// "dealMoney": "0", // if order finished - amount in money currency that is finished
|
||
// "dealStock": "0", // if order finished - amount in stock currency that is finished
|
||
// "amount": "0.001", // amount
|
||
// "takerFee": "0.001", // maker fee ratio. If the number less than 0.0001 - it will be rounded to zero
|
||
// "makerFee": "0.001", // maker fee ratio. If the number less than 0.0001 - it will be rounded to zero
|
||
// "left": "0.001", // if order not finished - rest of the amount that must be finished
|
||
// "dealFee": "0", // fee in money that you pay if order is finished
|
||
// "price": "40000", // price if price isset
|
||
// "activation_price": "40000" // activation price if activation price is set
|
||
// }
|
||
//
|
||
ch <- this.ParseOrder(response)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#cancelAllOrders
|
||
* @description cancel all open orders
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#cancel-all-orders
|
||
* @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @param {string} [params.type] market type, ['swap', 'spot']
|
||
* @param {boolean} [params.isMargin] cancel all margin orders
|
||
* @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes15888 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes15888)
|
||
var market interface{} = nil
|
||
var request interface{} = map[string]interface{} {}
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "market", GetValue(market, "id"))
|
||
}
|
||
var typeVar interface{} = nil
|
||
typeVarparamsVariable := this.HandleMarketTypeAndParams("cancelAllOrders", market, params);
|
||
typeVar = GetValue(typeVarparamsVariable,0);
|
||
params = GetValue(typeVarparamsVariable,1)
|
||
var requestType interface{} = []interface{}{}
|
||
if IsTrue(IsEqual(typeVar, "spot")) {
|
||
var isMargin interface{} = nil
|
||
isMarginparamsVariable := this.HandleOptionAndParams(params, "cancelAllOrders", "isMargin", false);
|
||
isMargin = GetValue(isMarginparamsVariable,0);
|
||
params = GetValue(isMarginparamsVariable,1)
|
||
if IsTrue(isMargin) {
|
||
AppendToArray(&requestType,"margin")
|
||
} else {
|
||
AppendToArray(&requestType,"spot")
|
||
}
|
||
} else if IsTrue(IsEqual(typeVar, "swap")) {
|
||
AppendToArray(&requestType,"futures")
|
||
} else {
|
||
panic(NotSupported(Add(Add(Add(this.Id, " cancelAllOrders() does not support "), typeVar), " type")))
|
||
}
|
||
AddElementToObject(request, "type", requestType)
|
||
|
||
response:= (<-this.V4PrivatePostOrderCancelAll(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// []
|
||
//
|
||
ch <- this.ParseOrders(response, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#cancelAllOrdersAfter
|
||
* @description dead man's switch, cancel all orders after the given timeout
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#sync-kill-switch-timer
|
||
* @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.types] Order types value. Example: "spot", "margin", "futures" or null
|
||
* @param {string} [params.symbol] symbol unified symbol of the market the order was made in
|
||
* @returns {object} the api result
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes16318 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes16318)
|
||
var symbol interface{} = this.SafeString(params, "symbol")
|
||
if IsTrue(IsEqual(symbol, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " cancelAllOrdersAfter() requires a symbol argument in params")))
|
||
}
|
||
var market interface{} = this.Market(symbol)
|
||
params = this.Omit(params, "symbol")
|
||
var isBiggerThanZero interface{} = (IsGreaterThan(timeout, 0))
|
||
var request interface{} = map[string]interface{} {
|
||
"market": GetValue(market, "id"),
|
||
}
|
||
if IsTrue(isBiggerThanZero) {
|
||
AddElementToObject(request, "timeout", this.NumberToString(Divide(timeout, 1000)))
|
||
} else {
|
||
AddElementToObject(request, "timeout", "null")
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostOrderKillSwitch(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// {
|
||
// "market": "BTC_USDT", // currency market,
|
||
// "startTime": 1662478154, // now timestamp,
|
||
// "cancellationTime": 1662478154, // now + timer_value,
|
||
// "types": ["spot", "margin"]
|
||
// }
|
||
//
|
||
ch <- response
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseBalance(response interface{}) interface{} {
|
||
var balanceKeys interface{} = ObjectKeys(response)
|
||
var result interface{} = map[string]interface{} {}
|
||
for i := 0; IsLessThan(i, GetArrayLength(balanceKeys)); i++ {
|
||
var id interface{} = GetValue(balanceKeys, i)
|
||
var code interface{} = this.SafeCurrencyCode(id)
|
||
var balance interface{} = GetValue(response, id)
|
||
if IsTrue(IsTrue(IsObject(balance)) && IsTrue(!IsEqual(balance, nil))) {
|
||
var account interface{} = this.Account()
|
||
AddElementToObject(account, "free", this.SafeString2(balance, "available", "main_balance"))
|
||
AddElementToObject(account, "used", this.SafeString(balance, "freeze"))
|
||
AddElementToObject(account, "total", this.SafeString(balance, "main_balance"))
|
||
AddElementToObject(result, code, account)
|
||
} else {
|
||
var account interface{} = this.Account()
|
||
AddElementToObject(account, "total", balance)
|
||
AddElementToObject(result, code, account)
|
||
}
|
||
}
|
||
return this.SafeBalance(result)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchBalance
|
||
* @description query for balance and get the amount of funds available for trading or funds locked in orders
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#main-balance
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#trading-balance
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes16928 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes16928)
|
||
var marketType interface{} = nil
|
||
marketTypeparamsVariable := this.HandleMarketTypeAndParams("fetchBalance", nil, params);
|
||
marketType = GetValue(marketTypeparamsVariable,0);
|
||
params = GetValue(marketTypeparamsVariable,1)
|
||
var response interface{} = nil
|
||
if IsTrue(IsEqual(marketType, "swap")) {
|
||
|
||
response = (<-this.V4PrivatePostCollateralAccountBalance(params))
|
||
PanicOnError(response)
|
||
} else {
|
||
var options interface{} = this.SafeValue(this.Options, "fetchBalance", map[string]interface{} {})
|
||
var defaultAccount interface{} = this.SafeString(options, "account")
|
||
var account interface{} = this.SafeString2(params, "account", "type", defaultAccount)
|
||
params = this.Omit(params, []interface{}{"account", "type"})
|
||
if IsTrue(IsTrue(IsEqual(account, "main")) || IsTrue(IsEqual(account, "funding"))) {
|
||
|
||
response = (<-this.V4PrivatePostMainAccountBalance(params))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.V4PrivatePostTradeAccountBalance(params))
|
||
PanicOnError(response)
|
||
}
|
||
}
|
||
|
||
//
|
||
// main account
|
||
//
|
||
// {
|
||
// "BTC":{"main_balance":"0.0013929494020316"},
|
||
// "ETH":{"main_balance":"0.001398289308"},
|
||
// }
|
||
//
|
||
// spot trade account
|
||
//
|
||
// {
|
||
// "BTC": { "available": "0.123", "freeze": "1" },
|
||
// "XMR": { "available": "3013", "freeze": "100" },
|
||
// }
|
||
//
|
||
// swap
|
||
//
|
||
// {
|
||
// "BTC": 1,
|
||
// "USDT": 1000
|
||
// }
|
||
//
|
||
ch <- this.ParseBalance(response)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchOpenOrders
|
||
* @description fetch all unfilled currently open orders
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#query-unexecutedactive-orders
|
||
* @param {string} [symbol] unified market symbol
|
||
* @param {int} [since] the earliest time in ms to fetch open orders for
|
||
* @param {int} [limit] the maximum number of open order structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes17468 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes17468)
|
||
var market interface{} = nil
|
||
var request interface{} = map[string]interface{} {}
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "market", GetValue(market, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", mathMin(limit, 100))
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostOrders(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// [
|
||
// {
|
||
// "orderId": 3686033640,
|
||
// "clientOrderId": "customId11",
|
||
// "market": "BTC_USDT",
|
||
// "side": "buy",
|
||
// "type": "limit",
|
||
// "timestamp": 1594605801.49815, // current timestamp of unexecuted order
|
||
// "dealMoney": "0", // executed amount in money
|
||
// "dealStock": "0", // executed amount in stock
|
||
// "amount": "2.241379", // active order amount
|
||
// "takerFee": "0.001",
|
||
// "makerFee": "0.001",
|
||
// "left": "2.241379", // unexecuted amount in stock
|
||
// "dealFee": "0", // executed fee by deal
|
||
// "price": "40000"
|
||
// },
|
||
// ]
|
||
//
|
||
ch <- this.ParseOrders(response, market, since, limit, map[string]interface{} {
|
||
"status": "open",
|
||
})
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchClosedOrders
|
||
* @description fetches information on multiple closed orders made by the user
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#query-executed-orders
|
||
* @param {string} symbol unified market symbol of the market orders were made in
|
||
* @param {int} [since] the earliest time in ms to fetch orders for
|
||
* @param {int} [limit] the maximum number of order structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes17928 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes17928)
|
||
var request interface{} = map[string]interface{} {}
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
symbol = GetValue(market, "symbol")
|
||
AddElementToObject(request, "market", GetValue(market, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", mathMin(limit, 100)) // default 50 max 100
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostTradeAccountOrderHistory(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "BTC_USDT": [
|
||
// {
|
||
// "id": 160305483,
|
||
// "clientOrderId": "customId11",
|
||
// "time": 1594667731.724403,
|
||
// "side": "sell",
|
||
// "role": 2, // 1 = maker, 2 = taker
|
||
// "amount": "0.000076",
|
||
// "price": "9264.21",
|
||
// "deal": "0.70407996",
|
||
// "fee": "0.00070407996"
|
||
// },
|
||
// ],
|
||
// }
|
||
//
|
||
var marketIds interface{} = ObjectKeys(response)
|
||
var results interface{} = []interface{}{}
|
||
for i := 0; IsLessThan(i, GetArrayLength(marketIds)); i++ {
|
||
var marketId interface{} = GetValue(marketIds, i)
|
||
var marketNew interface{} = this.SafeMarket(marketId, nil, "_")
|
||
var orders interface{} = GetValue(response, marketId)
|
||
for j := 0; IsLessThan(j, GetArrayLength(orders)); j++ {
|
||
var order interface{} = this.ParseOrder(GetValue(orders, j), marketNew)
|
||
AppendToArray(&results,this.Extend(order, map[string]interface{} {
|
||
"status": "closed",
|
||
}))
|
||
}
|
||
}
|
||
results = this.SortBy(results, "timestamp")
|
||
results = this.FilterBySymbolSinceLimit(results, symbol, since, limit)
|
||
|
||
ch <- results
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseOrderType(typeVar interface{}) interface{} {
|
||
var types interface{} = map[string]interface{} {
|
||
"limit": "limit",
|
||
"market": "market",
|
||
"stop market": "market",
|
||
"stop limit": "limit",
|
||
"stock market": "market",
|
||
"margin limit": "limit",
|
||
"margin market": "market",
|
||
}
|
||
return this.SafeString(types, typeVar, typeVar)
|
||
}
|
||
func (this *whitebit) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// createOrder, fetchOpenOrders, cancelOrder
|
||
//
|
||
// {
|
||
// "orderId":105687928629,
|
||
// "clientOrderId":"",
|
||
// "market":"DOGE_USDT",
|
||
// "side":"sell",
|
||
// "type":"stop market",
|
||
// "timestamp":1659091079.729576,
|
||
// "dealMoney":"0", // executed amount in quote
|
||
// "dealStock":"0", // base filled amount
|
||
// "amount":"100",
|
||
// "takerFee":"0.001",
|
||
// "makerFee":"0",
|
||
// "left":"100",
|
||
// "price": "40000", // price if price isset
|
||
// "dealFee":"0",
|
||
// "activation_price":"0.065" // stop price (if stop limit or stop market)
|
||
// }
|
||
//
|
||
// fetchClosedOrders
|
||
//
|
||
// {
|
||
// "id":105531094719,
|
||
// "clientOrderId":"",
|
||
// "ctime":1659045334.550127,
|
||
// "ftime":1659045334.550127,
|
||
// "side":"buy",
|
||
// "amount":"5.9940059", // cost in terms of quote for regular market orders, amount in terms or base for all other order types
|
||
// "price":"0",
|
||
// "type":"market",
|
||
// "takerFee":"0.001",
|
||
// "makerFee":"0",
|
||
// "dealFee":"0.0059375815",
|
||
// "dealStock":"85", // base filled amount
|
||
// "dealMoney":"5.9375815", // executed amount in quote
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(order, "market")
|
||
market = this.SafeMarket(marketId, market, "_")
|
||
var symbol interface{} = GetValue(market, "symbol")
|
||
var side interface{} = this.SafeString(order, "side")
|
||
var filled interface{} = this.SafeString(order, "dealStock")
|
||
var remaining interface{} = this.SafeString(order, "left")
|
||
var clientOrderId interface{} = this.SafeString(order, "clientOrderId")
|
||
if IsTrue(IsEqual(clientOrderId, "")) {
|
||
clientOrderId = nil
|
||
}
|
||
var price interface{} = this.SafeString(order, "price")
|
||
var triggerPrice interface{} = this.SafeNumber(order, "activation_price")
|
||
var orderId interface{} = this.SafeString2(order, "orderId", "id")
|
||
var typeVar interface{} = this.SafeString(order, "type")
|
||
var orderType interface{} = this.ParseOrderType(typeVar)
|
||
if IsTrue(IsEqual(orderType, "market")) {
|
||
remaining = nil
|
||
}
|
||
var amount interface{} = this.SafeString(order, "amount")
|
||
var cost interface{} = this.SafeString(order, "dealMoney")
|
||
if IsTrue(IsTrue((IsEqual(side, "buy"))) && IsTrue((IsTrue((IsEqual(typeVar, "market"))) || IsTrue((IsEqual(typeVar, "stop market")))))) {
|
||
amount = filled
|
||
}
|
||
var dealFee interface{} = this.SafeString(order, "dealFee")
|
||
var fee interface{} = nil
|
||
if IsTrue(!IsEqual(dealFee, nil)) {
|
||
fee = map[string]interface{} {
|
||
"cost": this.ParseNumber(dealFee),
|
||
"currency": GetValue(market, "quote"),
|
||
}
|
||
}
|
||
var timestamp interface{} = this.SafeTimestamp2(order, "ctime", "timestamp")
|
||
var lastTradeTimestamp interface{} = this.SafeTimestamp(order, "ftime")
|
||
return this.SafeOrder(map[string]interface{} {
|
||
"info": order,
|
||
"id": orderId,
|
||
"symbol": symbol,
|
||
"clientOrderId": clientOrderId,
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"lastTradeTimestamp": lastTradeTimestamp,
|
||
"timeInForce": nil,
|
||
"postOnly": nil,
|
||
"status": nil,
|
||
"side": side,
|
||
"price": price,
|
||
"type": orderType,
|
||
"triggerPrice": triggerPrice,
|
||
"amount": amount,
|
||
"filled": filled,
|
||
"remaining": remaining,
|
||
"average": nil,
|
||
"cost": cost,
|
||
"fee": fee,
|
||
"trades": nil,
|
||
}, market)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchOrderTrades
|
||
* @description fetch all the trades made from a single order
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#query-executed-order-deals
|
||
* @param {string} id order id
|
||
* @param {string} symbol unified market symbol
|
||
* @param {int} [since] the earliest time in ms to fetch trades for
|
||
* @param {int} [limit] the maximum number of trades to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
|
||
*/
|
||
func (this *whitebit) FetchOrderTrades(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
symbol := GetArg(optionalArgs, 0, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 1, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 2, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 3, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes19618 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes19618)
|
||
var request interface{} = map[string]interface{} {
|
||
"orderId": ParseInt(id),
|
||
}
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "market", GetValue(market, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", mathMin(limit, 100))
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostTradeAccountOrder(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "records": [
|
||
// {
|
||
// "time": 1593342324.613711,
|
||
// "fee": "0.00000419198",
|
||
// "price": "0.00000701",
|
||
// "amount": "598",
|
||
// "id": 149156519, // trade id
|
||
// "dealOrderId": 3134995325, // orderId
|
||
// "clientOrderId": "customId11", // empty string if not specified
|
||
// "role": 2, // 1 = maker, 2 = taker
|
||
// "deal": "0.00419198"
|
||
// }
|
||
// ],
|
||
// "offset": 0,
|
||
// "limit": 100
|
||
// }
|
||
//
|
||
var data interface{} = this.SafeList(response, "records", []interface{}{})
|
||
|
||
ch <- this.ParseTrades(data, market)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchDepositAddress
|
||
* @description fetch the deposit address for a currency associated with this account
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#get-fiat-deposit-address
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#get-cryptocurrency-deposit-address
|
||
* @param {string} code unified currency code
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes20088 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes20088)
|
||
var currency interface{} = this.Currency(code)
|
||
var request interface{} = map[string]interface{} {
|
||
"ticker": GetValue(currency, "id"),
|
||
}
|
||
var response interface{} = nil
|
||
if IsTrue(this.IsFiat(code)) {
|
||
var provider interface{} = this.SafeString(params, "provider")
|
||
if IsTrue(IsEqual(provider, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " fetchDepositAddress() requires a provider when the ticker is fiat")))
|
||
}
|
||
AddElementToObject(request, "provider", provider)
|
||
var amount interface{} = this.SafeNumber(params, "amount")
|
||
if IsTrue(IsEqual(amount, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " fetchDepositAddress() requires an amount when the ticker is fiat")))
|
||
}
|
||
AddElementToObject(request, "amount", amount)
|
||
var uniqueId interface{} = this.SafeValue(params, "uniqueId")
|
||
if IsTrue(IsEqual(uniqueId, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " fetchDepositAddress() requires an uniqueId when the ticker is fiat")))
|
||
}
|
||
|
||
response = (<-this.V4PrivatePostMainAccountFiatDepositUrl(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
} else {
|
||
|
||
response = (<-this.V4PrivatePostMainAccountAddress(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
}
|
||
//
|
||
// fiat
|
||
//
|
||
// {
|
||
// "url": "https://someaddress.com"
|
||
// }
|
||
//
|
||
// crypto
|
||
//
|
||
// {
|
||
// "account": {
|
||
// "address": "GDTSOI56XNVAKJNJBLJGRNZIVOCIZJRBIDKTWSCYEYNFAZEMBLN75RMN",
|
||
// "memo": "48565488244493"
|
||
// },
|
||
// "required": {
|
||
// "fixedFee": "0",
|
||
// "flexFee": {
|
||
// "maxFee": "0",
|
||
// "minFee": "0",
|
||
// "percent": "0"
|
||
// },
|
||
// "maxAmount": "0",
|
||
// "minAmount": "1"
|
||
// }
|
||
// }
|
||
//
|
||
var url interface{} = this.SafeString(response, "url")
|
||
var account interface{} = this.SafeValue(response, "account", map[string]interface{} {})
|
||
var address interface{} = this.SafeString(account, "address", url)
|
||
var tag interface{} = this.SafeString(account, "memo")
|
||
this.CheckAddress(address)
|
||
|
||
ch <- map[string]interface{} {
|
||
"info": response,
|
||
"currency": code,
|
||
"network": nil,
|
||
"address": address,
|
||
"tag": tag,
|
||
}
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#setLeverage
|
||
* @description set the level of leverage for a market
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#change-collateral-account-leverage
|
||
* @param {float} leverage the rate of leverage
|
||
* @param {string} symbol unified market symbol
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} response from the exchange
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes20848 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes20848)
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
panic(NotSupported(Add(this.Id, " setLeverage() does not allow to set per symbol")))
|
||
}
|
||
if IsTrue(IsTrue((IsLessThan(leverage, 1))) || IsTrue((IsGreaterThan(leverage, 20)))) {
|
||
panic(BadRequest(Add(this.Id, " setLeverage() leverage should be between 1 and 20")))
|
||
}
|
||
var request interface{} = map[string]interface{} {
|
||
"leverage": leverage,
|
||
}
|
||
|
||
retRes209415 := (<-this.V4PrivatePostCollateralAccountLeverage(this.Extend(request, params)))
|
||
PanicOnError(retRes209415)
|
||
ch <- retRes209415
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#transfer
|
||
* @description transfer currency internally between wallets on the same account
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#transfer-between-main-and-trade-balances
|
||
* @param {string} code unified currency code
|
||
* @param {float} amount amount to transfer
|
||
* @param {string} fromAccount account to transfer from - main, spot, collateral
|
||
* @param {string} toAccount account to transfer to - main, spot, collateral
|
||
* @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 *whitebit) 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
|
||
|
||
retRes21138 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes21138)
|
||
var currency interface{} = this.Currency(code)
|
||
var accountsByType interface{} = this.SafeValue(this.Options, "accountsByType")
|
||
var fromAccountId interface{} = this.SafeString(accountsByType, fromAccount, fromAccount)
|
||
var toAccountId interface{} = this.SafeString(accountsByType, toAccount, toAccount)
|
||
var amountString interface{} = this.CurrencyToPrecision(code, amount)
|
||
var request interface{} = map[string]interface{} {
|
||
"ticker": GetValue(currency, "id"),
|
||
"amount": amountString,
|
||
"from": fromAccountId,
|
||
"to": toAccountId,
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostMainAccountTransfer(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// []
|
||
//
|
||
ch <- this.ParseTransfer(response, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// []
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
return map[string]interface{} {
|
||
"info": transfer,
|
||
"id": nil,
|
||
"timestamp": nil,
|
||
"datetime": nil,
|
||
"currency": this.SafeCurrencyCode(nil, currency),
|
||
"amount": nil,
|
||
"fromAccount": nil,
|
||
"toAccount": nil,
|
||
"status": nil,
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#withdraw
|
||
* @description make a withdrawal
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#create-withdraw-request
|
||
* @param {string} code unified currency code
|
||
* @param {float} amount the amount to withdraw
|
||
* @param {string} address the address to withdraw to
|
||
* @param {string} tag
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes21628 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes21628)
|
||
var currency interface{} = this.Currency(code) // check if it has canDeposit
|
||
var request interface{} = map[string]interface{} {
|
||
"ticker": GetValue(currency, "id"),
|
||
"amount": this.CurrencyToPrecision(code, amount),
|
||
"address": address,
|
||
}
|
||
var uniqueId interface{} = this.SafeValue(params, "uniqueId")
|
||
if IsTrue(IsEqual(uniqueId, nil)) {
|
||
uniqueId = this.Uuid22()
|
||
}
|
||
AddElementToObject(request, "uniqueId", uniqueId)
|
||
if IsTrue(!IsEqual(tag, nil)) {
|
||
AddElementToObject(request, "memo", tag)
|
||
}
|
||
if IsTrue(this.IsFiat(code)) {
|
||
var provider interface{} = this.SafeValue(params, "provider")
|
||
if IsTrue(IsEqual(provider, nil)) {
|
||
panic(ArgumentsRequired(Add(this.Id, " withdraw() requires a provider when the ticker is fiat")))
|
||
}
|
||
AddElementToObject(request, "provider", provider)
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostMainAccountWithdraw(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
|
||
//
|
||
// empty array with a success status
|
||
// go to deposit/withdraw history and check you request status by uniqueId
|
||
//
|
||
// []
|
||
//
|
||
ch <- this.Extend(map[string]interface{} {
|
||
"id": uniqueId,
|
||
}, this.ParseTransaction(response, currency))
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "address": "3ApEASLcrQtZpg1TsssFgYF5V5YQJAKvuE", // deposit address
|
||
// "uniqueId": null, // unique Id of deposit
|
||
// "transactionId": "a6d71d69-2b17-4ad8-8b15-2d686c54a1a5",
|
||
// "createdAt": 1593437922, // timestamp of deposit
|
||
// "currency": "Bitcoin", // deposit currency
|
||
// "ticker": "BTC", // deposit currency ticker
|
||
// "method": 1, // called method 1 - deposit, 2 - withdraw
|
||
// "amount": "0.0006", // amount of deposit
|
||
// "description": "", // deposit description
|
||
// "memo": "", // deposit memo
|
||
// "fee": "0", // deposit fee
|
||
// "status": 15, // transactions status
|
||
// "network": null, // if currency is multinetwork
|
||
// "transactionHash": "a275a514013e4e0f927fd0d1bed215e7f6f2c4c6ce762836fe135ec22529d886", // deposit transaction hash
|
||
// "details": {
|
||
// "partial": { // details about partially successful withdrawals
|
||
// "requestAmount": "50000", // requested withdrawal amount
|
||
// "processedAmount": "39000", // processed withdrawal amount
|
||
// "processedFee": "273", // fee for processed withdrawal amount
|
||
// "normalizeTransaction": "" // deposit id
|
||
// }
|
||
// },
|
||
// "confirmations": { // if transaction status == 15 you can see this object
|
||
// "actual": 1, // current block confirmations
|
||
// "required": 2 // required block confirmation for successful deposit
|
||
// }
|
||
// "centralized": false,
|
||
// }
|
||
//
|
||
currency := GetArg(optionalArgs, 0, nil)
|
||
_ = currency
|
||
currency = this.SafeCurrency(nil, currency)
|
||
var address interface{} = this.SafeString(transaction, "address")
|
||
var timestamp interface{} = this.SafeTimestamp(transaction, "createdAt")
|
||
var currencyId interface{} = this.SafeString(transaction, "ticker")
|
||
var status interface{} = this.SafeString(transaction, "status")
|
||
var method interface{} = this.SafeString(transaction, "method")
|
||
return map[string]interface{} {
|
||
"id": this.SafeString(transaction, "uniqueId"),
|
||
"txid": this.SafeString(transaction, "transactionId"),
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
"network": this.SafeString(transaction, "network"),
|
||
"addressFrom": Ternary(IsTrue((IsEqual(method, "1"))), address, nil),
|
||
"address": address,
|
||
"addressTo": Ternary(IsTrue((IsEqual(method, "2"))), address, nil),
|
||
"amount": this.SafeNumber(transaction, "amount"),
|
||
"type": Ternary(IsTrue((IsEqual(method, "1"))), "deposit", "withdrawal"),
|
||
"currency": this.SafeCurrencyCode(currencyId, currency),
|
||
"status": this.ParseTransactionStatus(status),
|
||
"updated": nil,
|
||
"tagFrom": nil,
|
||
"tag": nil,
|
||
"tagTo": nil,
|
||
"comment": this.SafeString(transaction, "description"),
|
||
"internal": nil,
|
||
"fee": map[string]interface{} {
|
||
"cost": this.SafeNumber(transaction, "fee"),
|
||
"currency": this.SafeCurrencyCode(currencyId, currency),
|
||
},
|
||
"info": transaction,
|
||
}
|
||
}
|
||
func (this *whitebit) ParseTransactionStatus(status interface{}) interface{} {
|
||
var statuses interface{} = map[string]interface{} {
|
||
"1": "pending",
|
||
"2": "pending",
|
||
"3": "ok",
|
||
"4": "canceled",
|
||
"5": "pending",
|
||
"6": "pending",
|
||
"7": "ok",
|
||
"9": "canceled",
|
||
"10": "pending",
|
||
"11": "pending",
|
||
"12": "pending",
|
||
"13": "pending",
|
||
"14": "pending",
|
||
"15": "pending",
|
||
"16": "pending",
|
||
"17": "pending",
|
||
}
|
||
return this.SafeString(statuses, status, status)
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchDeposit
|
||
* @description fetch information on a deposit
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#get-depositwithdraw-history
|
||
* @param {string} id deposit id
|
||
* @param {string} code not used by whitebit fetchDeposit ()
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
||
*/
|
||
func (this *whitebit) FetchDeposit(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
code := GetArg(optionalArgs, 0, nil)
|
||
_ = code
|
||
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes22928 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes22928)
|
||
var currency interface{} = nil
|
||
var request interface{} = map[string]interface{} {
|
||
"transactionMethod": 1,
|
||
"uniqueId": id,
|
||
"limit": 1,
|
||
"offset": 0,
|
||
}
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
AddElementToObject(request, "ticker", GetValue(currency, "id"))
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostMainAccountHistory(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "limit": 100,
|
||
// "offset": 0,
|
||
// "records": [
|
||
// {
|
||
// "address": "3ApEASLcrQtZpg1TsssFgYF5V5YQJAKvuE", // deposit address
|
||
// "uniqueId": null, // unique Id of deposit
|
||
// "createdAt": 1593437922, // timestamp of deposit
|
||
// "currency": "Bitcoin", // deposit currency
|
||
// "ticker": "BTC", // deposit currency ticker
|
||
// "method": 1, // called method 1 - deposit, 2 - withdraw
|
||
// "amount": "0.0006", // amount of deposit
|
||
// "description": "", // deposit description
|
||
// "memo": "", // deposit memo
|
||
// "fee": "0", // deposit fee
|
||
// "status": 15, // transactions status
|
||
// "network": null, // if currency is multinetwork
|
||
// "transactionHash": "a275a514013e4e0f927fd0d1bed215e7f6f2c4c6ce762836fe135ec22529d886", // deposit transaction hash
|
||
// "details": {
|
||
// "partial": { // details about partially successful withdrawals
|
||
// "requestAmount": "50000", // requested withdrawal amount
|
||
// "processedAmount": "39000", // processed withdrawal amount
|
||
// "processedFee": "273", // fee for processed withdrawal amount
|
||
// "normalizeTransaction": "" // deposit id
|
||
// }
|
||
// },
|
||
// "confirmations": { // if transaction status == 15 you can see this object
|
||
// "actual": 1, // current block confirmations
|
||
// "required": 2 // required block confirmation for successful deposit
|
||
// }
|
||
// },
|
||
// {...},
|
||
// ],
|
||
// "total": 300 // total number of transactions, use this for calculating ‘limit’ and ‘offset'
|
||
// }
|
||
//
|
||
var records interface{} = this.SafeValue(response, "records", []interface{}{})
|
||
var first interface{} = this.SafeDict(records, 0, map[string]interface{} {})
|
||
|
||
ch <- this.ParseTransaction(first, currency)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchDeposits
|
||
* @description fetch all deposits made to an account
|
||
* @see https://docs.whitebit.com/private/http-main-v4/#get-depositwithdraw-history
|
||
* @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 *whitebit) 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
|
||
|
||
retRes23598 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes23598)
|
||
var currency interface{} = nil
|
||
var request interface{} = map[string]interface{} {
|
||
"transactionMethod": 1,
|
||
"limit": 100,
|
||
"offset": 0,
|
||
}
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
AddElementToObject(request, "ticker", GetValue(currency, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", mathMin(limit, 100))
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostMainAccountHistory(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "limit": 100,
|
||
// "offset": 0,
|
||
// "records": [
|
||
// {
|
||
// "address": "3ApEASLcrQtZpg1TsssFgYF5V5YQJAKvuE", // deposit address
|
||
// "uniqueId": null, // unique Id of deposit
|
||
// "createdAt": 1593437922, // timestamp of deposit
|
||
// "currency": "Bitcoin", // deposit currency
|
||
// "ticker": "BTC", // deposit currency ticker
|
||
// "method": 1, // called method 1 - deposit, 2 - withdraw
|
||
// "amount": "0.0006", // amount of deposit
|
||
// "description": "", // deposit description
|
||
// "memo": "", // deposit memo
|
||
// "fee": "0", // deposit fee
|
||
// "status": 15, // transactions status
|
||
// "network": null, // if currency is multinetwork
|
||
// "transactionHash": "a275a514013e4e0f927fd0d1bed215e7f6f2c4c6ce762836fe135ec22529d886", // deposit transaction hash
|
||
// "details": {
|
||
// "partial": { // details about partially successful withdrawals
|
||
// "requestAmount": "50000", // requested withdrawal amount
|
||
// "processedAmount": "39000", // processed withdrawal amount
|
||
// "processedFee": "273", // fee for processed withdrawal amount
|
||
// "normalizeTransaction": "" // deposit id
|
||
// }
|
||
// },
|
||
// "confirmations": { // if transaction status == 15 you can see this object
|
||
// "actual": 1, // current block confirmations
|
||
// "required": 2 // required block confirmation for successful deposit
|
||
// }
|
||
// },
|
||
// {...},
|
||
// ],
|
||
// "total": 300 // total number of transactions, use this for calculating ‘limit’ and ‘offset'
|
||
// }
|
||
//
|
||
var records interface{} = this.SafeList(response, "records", []interface{}{})
|
||
|
||
ch <- this.ParseTransactions(records, currency, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchBorrowInterest
|
||
* @description fetch the interest owed by the user for borrowing currency for margin trading
|
||
* @see https://docs.whitebit.com/private/http-trade-v4/#open-positions
|
||
* @param {string} code unified currency code
|
||
* @param {string} symbol unified market symbol
|
||
* @param {int} [since] the earliest time in ms to fetch borrrow interest for
|
||
* @param {int} [limit] the maximum number of structures to retrieve
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
* @returns {object[]} a list of [borrow interest structures]{@link https://docs.ccxt.com/#/?id=borrow-interest-structure}
|
||
*/
|
||
func (this *whitebit) FetchBorrowInterest(optionalArgs ...interface{}) <- chan interface{} {
|
||
ch := make(chan interface{})
|
||
go func() interface{} {
|
||
defer close(ch)
|
||
defer ReturnPanicError(ch)
|
||
code := GetArg(optionalArgs, 0, nil)
|
||
_ = code
|
||
symbol := GetArg(optionalArgs, 1, nil)
|
||
_ = symbol
|
||
since := GetArg(optionalArgs, 2, nil)
|
||
_ = since
|
||
limit := GetArg(optionalArgs, 3, nil)
|
||
_ = limit
|
||
params := GetArg(optionalArgs, 4, map[string]interface{} {})
|
||
_ = params
|
||
|
||
retRes24288 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes24288)
|
||
var request interface{} = map[string]interface{} {}
|
||
var market interface{} = nil
|
||
if IsTrue(!IsEqual(symbol, nil)) {
|
||
market = this.Market(symbol)
|
||
AddElementToObject(request, "market", GetValue(market, "id"))
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostCollateralAccountPositionsOpen(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// [
|
||
// {
|
||
// "positionId": 191823,
|
||
// "market": "BTC_USDT",
|
||
// "openDate": 1660340344.027163,
|
||
// "modifyDate": 1660340344.027163,
|
||
// "amount": "0.003075",
|
||
// "basePrice": "24149.24512",
|
||
// "liquidationPrice": "7059.02",
|
||
// "leverage": "5",
|
||
// "pnl": "-0.15",
|
||
// "pnlPercent": "-0.20",
|
||
// "margin": "14.86",
|
||
// "freeMargin": "44.99",
|
||
// "funding": "0",
|
||
// "unrealizedFunding": "0.0000307828284903",
|
||
// "liquidationState": null
|
||
// }
|
||
// ]
|
||
//
|
||
var interest interface{} = this.ParseBorrowInterests(response, market)
|
||
|
||
ch <- this.FilterByCurrencySinceLimit(interest, code, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseBorrowInterest(info interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "positionId": 191823,
|
||
// "market": "BTC_USDT",
|
||
// "openDate": 1660340344.027163,
|
||
// "modifyDate": 1660340344.027163,
|
||
// "amount": "0.003075",
|
||
// "basePrice": "24149.24512",
|
||
// "liquidationPrice": "7059.02",
|
||
// "leverage": "5",
|
||
// "pnl": "-0.15",
|
||
// "pnlPercent": "-0.20",
|
||
// "margin": "14.86",
|
||
// "freeMargin": "44.99",
|
||
// "funding": "0",
|
||
// "unrealizedFunding": "0.0000307828284903",
|
||
// "liquidationState": null
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(info, "market")
|
||
var symbol interface{} = this.SafeSymbol(marketId, market, "_")
|
||
var timestamp interface{} = this.SafeTimestamp(info, "modifyDate")
|
||
return map[string]interface{} {
|
||
"info": info,
|
||
"symbol": symbol,
|
||
"currency": "USDT",
|
||
"interest": this.SafeNumber(info, "unrealizedFunding"),
|
||
"interestRate": 0.00098,
|
||
"amountBorrowed": this.SafeNumber(info, "amount"),
|
||
"marginMode": "cross",
|
||
"timestamp": timestamp,
|
||
"datetime": this.Iso8601(timestamp),
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchFundingRate
|
||
* @description fetch the current funding rate
|
||
* @see https://docs.whitebit.com/public/http-v4/#available-futures-markets-list
|
||
* @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 *whitebit) 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
|
||
|
||
retRes25078 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes25078)
|
||
symbol = this.Symbol(symbol)
|
||
|
||
response:= (<-this.FetchFundingRates([]interface{}{symbol}, params))
|
||
PanicOnError(response)
|
||
|
||
ch <- this.SafeValue(response, symbol)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchFundingRates
|
||
* @description fetch the funding rate for multiple markets
|
||
* @see https://docs.whitebit.com/public/http-v4/#available-futures-markets-list
|
||
* @param {string[]|undefined} 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-rates-structure}, indexed by market symbols
|
||
*/
|
||
func (this *whitebit) 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
|
||
|
||
retRes25238 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes25238)
|
||
symbols = this.MarketSymbols(symbols)
|
||
|
||
response:= (<-this.V4PublicGetFutures(params))
|
||
PanicOnError(response)
|
||
//
|
||
// [
|
||
// {
|
||
// "name": "BTC_USDT",
|
||
// "type": "direct",
|
||
// "quanto_multiplier": "0.0001",
|
||
// "ref_discount_rate": "0",
|
||
// "order_price_deviate": "0.5",
|
||
// "maintenance_rate": "0.005",
|
||
// "mark_type": "index",
|
||
// "last_price": "38026",
|
||
// "mark_price": "37985.6",
|
||
// "index_price": "37954.92",
|
||
// "funding_rate_indicative": "0.000219",
|
||
// "mark_price_round": "0.01",
|
||
// "funding_offset": 0,
|
||
// "in_delisting": false,
|
||
// "risk_limit_base": "1000000",
|
||
// "interest_rate": "0.0003",
|
||
// "order_price_round": "0.1",
|
||
// "order_size_min": 1,
|
||
// "ref_rebate_rate": "0.2",
|
||
// "funding_interval": 28800,
|
||
// "risk_limit_step": "1000000",
|
||
// "leverage_min": "1",
|
||
// "leverage_max": "100",
|
||
// "risk_limit_max": "8000000",
|
||
// "maker_fee_rate": "-0.00025",
|
||
// "taker_fee_rate": "0.00075",
|
||
// "funding_rate": "0.002053",
|
||
// "order_size_max": 1000000,
|
||
// "funding_next_apply": 1610035200,
|
||
// "short_users": 977,
|
||
// "config_change_time": 1609899548,
|
||
// "trade_size": 28530850594,
|
||
// "position_size": 5223816,
|
||
// "long_users": 455,
|
||
// "funding_impact_value": "60000",
|
||
// "orders_limit": 50,
|
||
// "trade_id": 10851092,
|
||
// "orderbook_id": 2129638396
|
||
// }
|
||
// ]
|
||
//
|
||
var data interface{} = this.SafeList(response, "result", []interface{}{})
|
||
|
||
ch <- this.ParseFundingRates(data, symbols)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) ParseFundingRate(contract interface{}, optionalArgs ...interface{}) interface{} {
|
||
//
|
||
// {
|
||
// "ticker_id":"ADA_PERP",
|
||
// "stock_currency":"ADA",
|
||
// "money_currency":"USDT",
|
||
// "last_price":"0.296708",
|
||
// "stock_volume":"7982130",
|
||
// "money_volume":"2345758.29189",
|
||
// "bid":"0.296608",
|
||
// "ask":"0.296758",
|
||
// "high":"0.298338",
|
||
// "low":"0.290171",
|
||
// "product_type":"Perpetual",
|
||
// "open_interest":"46533000",
|
||
// "index_price":"0.29659",
|
||
// "index_name":"Cardano",
|
||
// "index_currency":"ADA",
|
||
// "funding_rate":"0.0001",
|
||
// "next_funding_rate_timestamp":"1691193600000",
|
||
// "brackets":{
|
||
// "1":"0",
|
||
// "2":"0",
|
||
// "3":"0",
|
||
// "5":"0",
|
||
// "10":"0",
|
||
// "20":"0",
|
||
// "50":"-10000",
|
||
// "100":"-5000"
|
||
// },
|
||
// "max_leverage":"100"
|
||
// }
|
||
//
|
||
market := GetArg(optionalArgs, 0, nil)
|
||
_ = market
|
||
var marketId interface{} = this.SafeString(contract, "ticker_id")
|
||
var symbol interface{} = this.SafeSymbol(marketId, market)
|
||
var markPrice interface{} = this.SafeNumber(contract, "markPrice")
|
||
var indexPrice interface{} = this.SafeNumber(contract, "indexPrice")
|
||
var interestRate interface{} = this.SafeNumber(contract, "interestRate")
|
||
var fundingRate interface{} = this.SafeNumber(contract, "funding_rate")
|
||
var fundingTime interface{} = this.SafeInteger(contract, "next_funding_rate_timestamp")
|
||
return map[string]interface{} {
|
||
"info": contract,
|
||
"symbol": symbol,
|
||
"markPrice": markPrice,
|
||
"indexPrice": indexPrice,
|
||
"interestRate": interestRate,
|
||
"timestamp": nil,
|
||
"datetime": nil,
|
||
"fundingRate": fundingRate,
|
||
"fundingTimestamp": fundingTime,
|
||
"fundingDatetime": this.Iso8601(fundingTime),
|
||
"nextFundingRate": nil,
|
||
"nextFundingTimestamp": nil,
|
||
"nextFundingDatetime": nil,
|
||
"previousFundingRate": nil,
|
||
"previousFundingTimestamp": nil,
|
||
"previousFundingDatetime": nil,
|
||
"interval": nil,
|
||
}
|
||
}
|
||
/**
|
||
* @method
|
||
* @name whitebit#fetchDepositsWithdrawals
|
||
* @description fetch history of deposits and withdrawals
|
||
* @see https://github.com/whitebit-exchange/api-docs/blob/main/pages/private/http-main-v4.md#get-depositwithdraw-history
|
||
* @param {string} [code] unified currency code for the currency of the deposit/withdrawals, default is undefined
|
||
* @param {int} [since] timestamp in ms of the earliest deposit/withdrawal, default is undefined
|
||
* @param {int} [limit] max number of deposit/withdrawals to return, default = 50, Min: 1, Max: 100
|
||
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
||
*
|
||
* EXCHANGE SPECIFIC PARAMETERS
|
||
* @param {number} [params.transactionMethod] Method. Example: 1 to display deposits / 2 to display withdraws. Do not send this parameter in order to receive both deposits and withdraws.
|
||
* @param {string} [params.address] Can be used for filtering transactions by specific address or memo.
|
||
* @param {string[]} [params.addresses] Can be used for filtering transactions by specific addresses or memos (max: 20).
|
||
* @param {string} [params.uniqueId] Can be used for filtering transactions by specific unique id
|
||
* @param {int} [params.offset] If you want the request to return entries starting from a particular line, you can use OFFSET clause to tell it where it should start. Default: 0, Min: 0, Max: 10000
|
||
* @param {string[]} [params.status] Can be used for filtering transactions by status codes. Caution: You must use this parameter with appropriate transactionMethod and use valid status codes for this method. You can find them below. Example: "status": [3,7]
|
||
* @returns {object} a list of [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
||
*/
|
||
func (this *whitebit) FetchDepositsWithdrawals(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
|
||
|
||
retRes26558 := (<-this.LoadMarkets())
|
||
PanicOnError(retRes26558)
|
||
var request interface{} = map[string]interface{} {}
|
||
var currency interface{} = nil
|
||
if IsTrue(!IsEqual(code, nil)) {
|
||
currency = this.Currency(code)
|
||
AddElementToObject(request, "ticker", GetValue(currency, "id"))
|
||
}
|
||
if IsTrue(!IsEqual(limit, nil)) {
|
||
AddElementToObject(request, "limit", limit) // default 1000
|
||
}
|
||
|
||
response:= (<-this.V4PrivatePostMainAccountHistory(this.Extend(request, params)))
|
||
PanicOnError(response)
|
||
//
|
||
// {
|
||
// "limit": 100,
|
||
// "offset": 0,
|
||
// "records": [
|
||
// {
|
||
// "address": "3ApEASLcrQtZpg1TsssFgYF5V5YQJAKvuE", // deposit address
|
||
// "uniqueId": null, // unique Id of deposit
|
||
// "createdAt": 1593437922, // timestamp of deposit
|
||
// "currency": "Bitcoin", // deposit currency
|
||
// "ticker": "BTC", // deposit currency ticker
|
||
// "method": 1, // called method 1 - deposit, 2 - withdraw
|
||
// "amount": "0.0006", // amount of deposit
|
||
// "description": "", // deposit description
|
||
// "memo": "", // deposit memo
|
||
// "fee": "0", // deposit fee
|
||
// "status": 15, // transactions status
|
||
// "network": null, // if currency is multinetwork
|
||
// "transactionHash": "a275a514013e4e0f927fd0d1bed215e7f6f2c4c6ce762836fe135ec22529d886", // deposit transaction hash
|
||
// "transactionId": "5e112b38-9652-11ed-a1eb-0242ac120002", // transaction id
|
||
// "details": {
|
||
// "partial": { // details about partially successful withdrawals
|
||
// "requestAmount": "50000", // requested withdrawal amount
|
||
// "processedAmount": "39000", // processed withdrawal amount
|
||
// "processedFee": "273", // fee for processed withdrawal amount
|
||
// "normalizeTransaction": "" // deposit id
|
||
// }
|
||
// },
|
||
// "confirmations": { // if transaction status == 15 (Pending) you can see this object
|
||
// "actual": 1, // current block confirmations
|
||
// "required": 2 // required block confirmation for successful deposit
|
||
// }
|
||
// },
|
||
// {...},
|
||
// ],
|
||
// "total": 300 // total number of transactions, use this for calculating ‘limit’ and ‘offset'
|
||
// }
|
||
//
|
||
var records interface{} = this.SafeList(response, "records")
|
||
|
||
ch <- this.ParseTransactions(records, currency, since, limit)
|
||
return nil
|
||
|
||
}()
|
||
return ch
|
||
}
|
||
func (this *whitebit) IsFiat(currency interface{}) interface{} {
|
||
var fiatCurrencies interface{} = this.SafeValue(this.Options, "fiatCurrencies", []interface{}{})
|
||
return this.InArray(currency, fiatCurrencies)
|
||
}
|
||
func (this *whitebit) Nonce() interface{} {
|
||
return Subtract(this.Milliseconds(), GetValue(this.Options, "timeDifference"))
|
||
}
|
||
func (this *whitebit) Sign(path interface{}, optionalArgs ...interface{}) interface{} {
|
||
api := GetArg(optionalArgs, 0, "public")
|
||
_ = api
|
||
method := GetArg(optionalArgs, 1, "GET")
|
||
_ = method
|
||
params := GetArg(optionalArgs, 2, map[string]interface{} {})
|
||
_ = params
|
||
headers := GetArg(optionalArgs, 3, nil)
|
||
_ = headers
|
||
body := GetArg(optionalArgs, 4, nil)
|
||
_ = body
|
||
var query interface{} = this.Omit(params, this.ExtractParams(path))
|
||
var version interface{} = this.SafeValue(api, 0)
|
||
var accessibility interface{} = this.SafeValue(api, 1)
|
||
var pathWithParams interface{} = Add("/", this.ImplodeParams(path, params))
|
||
var url interface{} = Add(GetValue(GetValue(GetValue(this.Urls, "api"), version), accessibility), pathWithParams)
|
||
if IsTrue(IsEqual(accessibility, "public")) {
|
||
if IsTrue(GetArrayLength(ObjectKeys(query))) {
|
||
url = Add(url, Add("?", this.Urlencode(query)))
|
||
}
|
||
}
|
||
if IsTrue(IsEqual(accessibility, "private")) {
|
||
this.CheckRequiredCredentials()
|
||
var nonce interface{} = ToString(this.Nonce())
|
||
var secret interface{} = this.Encode(this.Secret)
|
||
var request interface{} = Add(Add(Add(Add("/", "api"), "/"), version), pathWithParams)
|
||
body = this.Json(this.Extend(map[string]interface{} {
|
||
"request": request,
|
||
"nonce": nonce,
|
||
}, params))
|
||
var payload interface{} = this.StringToBase64(body)
|
||
var signature interface{} = this.Hmac(this.Encode(payload), secret, sha512)
|
||
headers = map[string]interface{} {
|
||
"Content-Type": "application/json",
|
||
"X-TXC-APIKEY": this.ApiKey,
|
||
"X-TXC-PAYLOAD": payload,
|
||
"X-TXC-SIGNATURE": signature,
|
||
}
|
||
}
|
||
return map[string]interface{} {
|
||
"url": url,
|
||
"method": method,
|
||
"body": body,
|
||
"headers": headers,
|
||
}
|
||
}
|
||
func (this *whitebit) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
|
||
if IsTrue(IsTrue((IsEqual(code, 418))) || IsTrue((IsEqual(code, 429)))) {
|
||
panic(DDoSProtection(Add(Add(Add(Add(Add(Add(this.Id, " "), ToString(code)), " "), reason), " "), body)))
|
||
}
|
||
if IsTrue(IsEqual(code, 404)) {
|
||
panic(ExchangeError(Add(Add(Add(this.Id, " "), ToString(code)), " endpoint not found")))
|
||
}
|
||
if IsTrue(!IsEqual(response, nil)) {
|
||
// For cases where we have a meaningful status
|
||
// {"response":null,"status":422,"errors":{"orderId":["Finished order id 435453454535 not found on your account"]},"notification":null,"warning":"Finished order id 435453454535 not found on your account","_token":null}
|
||
var status interface{} = this.SafeString(response, "status")
|
||
var errors interface{} = this.SafeValue(response, "errors")
|
||
// {"code":10,"message":"Unauthorized request."}
|
||
var message interface{} = this.SafeString(response, "message")
|
||
// For these cases where we have a generic code variable error key
|
||
// {"code":0,"message":"Validation failed","errors":{"amount":["Amount must be greater than 0"]}}
|
||
var codeNew interface{} = this.SafeInteger(response, "code")
|
||
var hasErrorStatus interface{} = IsTrue(IsTrue(!IsEqual(status, nil)) && IsTrue(!IsEqual(status, "200"))) && IsTrue(!IsEqual(errors, nil))
|
||
if IsTrue(IsTrue(hasErrorStatus) || IsTrue(!IsEqual(codeNew, nil))) {
|
||
var feedback interface{} = Add(Add(this.Id, " "), body)
|
||
var errorInfo interface{} = message
|
||
if IsTrue(hasErrorStatus) {
|
||
errorInfo = status
|
||
} else {
|
||
var errorObject interface{} = this.SafeDict(response, "errors", map[string]interface{} {})
|
||
var errorKeys interface{} = ObjectKeys(errorObject)
|
||
var errorsLength interface{} = GetArrayLength(errorKeys)
|
||
if IsTrue(IsGreaterThan(errorsLength, 0)) {
|
||
var errorKey interface{} = GetValue(errorKeys, 0)
|
||
var errorMessageArray interface{} = this.SafeValue(errorObject, errorKey, []interface{}{})
|
||
var errorMessageLength interface{} = GetArrayLength(errorMessageArray)
|
||
errorInfo = Ternary(IsTrue((IsGreaterThan(errorMessageLength, 0))), GetValue(errorMessageArray, 0), body)
|
||
}
|
||
}
|
||
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), errorInfo, feedback)
|
||
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), body, feedback)
|
||
panic(ExchangeError(feedback))
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
|
||
func (this *whitebit) Init(userConfig map[string]interface{}) {
|
||
this.Exchange = Exchange{}
|
||
this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
|
||
this.Exchange.DerivedExchange = this
|
||
}
|