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 woo struct { Exchange } func NewWooCore() woo { p := woo{} setDefaults(&p) return p } func (this *woo) Describe() interface{} { return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} { "id": "woo", "name": "WOO X", "countries": []interface{}{"KY"}, "rateLimit": 100, "version": "v1", "certified": true, "pro": true, "hostname": "woox.io", "has": map[string]interface{} { "CORS": nil, "spot": true, "margin": true, "swap": true, "future": false, "option": false, "addMargin": true, "cancelAllOrders": true, "cancelAllOrdersAfter": true, "cancelOrder": true, "cancelWithdraw": false, "closeAllPositions": false, "closePosition": false, "createConvertTrade": true, "createDepositAddress": false, "createMarketBuyOrderWithCost": true, "createMarketOrder": false, "createMarketOrderWithCost": false, "createMarketSellOrderWithCost": true, "createOrder": true, "createOrderWithTakeProfitAndStopLoss": true, "createReduceOnlyOrder": true, "createStopLimitOrder": false, "createStopLossOrder": true, "createStopMarketOrder": false, "createStopOrder": false, "createTakeProfitOrder": true, "createTrailingAmountOrder": true, "createTrailingPercentOrder": true, "createTriggerOrder": true, "fetchAccounts": true, "fetchBalance": true, "fetchCanceledOrders": false, "fetchClosedOrder": false, "fetchClosedOrders": true, "fetchConvertCurrencies": true, "fetchConvertQuote": true, "fetchConvertTrade": true, "fetchConvertTradeHistory": true, "fetchCurrencies": true, "fetchDepositAddress": true, "fetchDepositAddresses": false, "fetchDepositAddressesByNetwork": false, "fetchDeposits": true, "fetchDepositsWithdrawals": true, "fetchFundingHistory": true, "fetchFundingInterval": true, "fetchFundingIntervals": false, "fetchFundingRate": true, "fetchFundingRateHistory": true, "fetchFundingRates": true, "fetchIndexOHLCV": false, "fetchLedger": true, "fetchLeverage": true, "fetchMarginAdjustmentHistory": false, "fetchMarginMode": false, "fetchMarkets": true, "fetchMarkOHLCV": false, "fetchMyTrades": true, "fetchOHLCV": true, "fetchOpenInterestHistory": false, "fetchOpenOrder": false, "fetchOpenOrders": true, "fetchOrder": true, "fetchOrderBook": true, "fetchOrders": true, "fetchOrderTrades": true, "fetchPosition": true, "fetchPositionHistory": false, "fetchPositionMode": false, "fetchPositions": true, "fetchPositionsHistory": false, "fetchPremiumIndexOHLCV": false, "fetchStatus": true, "fetchTicker": false, "fetchTickers": false, "fetchTime": true, "fetchTrades": true, "fetchTradingFee": false, "fetchTradingFees": true, "fetchTransactions": "emulated", "fetchTransfers": true, "fetchWithdrawals": true, "reduceMargin": false, "sandbox": true, "setLeverage": true, "setMargin": false, "setPositionMode": true, "transfer": true, "withdraw": true, }, "timeframes": map[string]interface{} { "1m": "1m", "5m": "5m", "15m": "15m", "30m": "30m", "1h": "1h", "4h": "4h", "12h": "12h", "1d": "1d", "1w": "1w", "1M": "1mon", "1y": "1y", }, "urls": map[string]interface{} { "logo": "https://user-images.githubusercontent.com/1294454/150730761-1a00e5e0-d28c-480f-9e65-089ce3e6ef3b.jpg", "api": map[string]interface{} { "pub": "https://api-pub.woox.io", "public": "https://api.{hostname}", "private": "https://api.{hostname}", }, "test": map[string]interface{} { "pub": "https://api-pub.staging.woox.io", "public": "https://api.staging.woox.io", "private": "https://api.staging.woox.io", }, "www": "https://woox.io/", "doc": []interface{}{"https://docs.woox.io/"}, "fees": []interface{}{"https://support.woox.io/hc/en-001/articles/4404611795353--Trading-Fees"}, "referral": map[string]interface{} { "url": "https://woox.io/register?ref=DIJT0CNL", "discount": 0.35, }, }, "api": map[string]interface{} { "v1": map[string]interface{} { "pub": map[string]interface{} { "get": map[string]interface{} { "hist/kline": 10, "hist/trades": 10, }, }, "public": map[string]interface{} { "get": map[string]interface{} { "info": 1, "info/{symbol}": 1, "system_info": 1, "market_trades": 1, "token": 1, "token_network": 1, "funding_rates": 1, "funding_rate/{symbol}": 1, "funding_rate_history": 1, "futures": 1, "futures/{symbol}": 1, "orderbook/{symbol}": 1, "kline": 1, }, }, "private": map[string]interface{} { "get": map[string]interface{} { "client/token": 1, "order/{oid}": 1, "client/order/{client_order_id}": 1, "orders": 1, "client/trade/{tid}": 1, "order/{oid}/trades": 1, "client/trades": 1, "client/hist_trades": 1, "staking/yield_history": 1, "client/holding": 1, "asset/deposit": 10, "asset/history": 60, "sub_account/all": 60, "sub_account/assets": 60, "sub_account/asset_detail": 60, "sub_account/ip_restriction": 10, "asset/main_sub_transfer_history": 30, "token_interest": 60, "token_interest/{token}": 60, "interest/history": 60, "interest/repay": 60, "funding_fee/history": 30, "positions": 3.33, "position/{symbol}": 3.33, "client/transaction_history": 60, "client/futures_leverage": 60, }, "post": map[string]interface{} { "order": 1, "order/cancel_all_after": 1, "asset/main_sub_transfer": 30, "asset/ltv": 30, "asset/withdraw": 30, "asset/internal_withdraw": 30, "interest/repay": 60, "client/account_mode": 120, "client/position_mode": 5, "client/leverage": 120, "client/futures_leverage": 30, "client/isolated_margin": 30, }, "delete": map[string]interface{} { "order": 1, "client/order": 1, "orders": 1, "asset/withdraw": 120, }, }, }, "v2": map[string]interface{} { "private": map[string]interface{} { "get": map[string]interface{} { "client/holding": 1, }, }, }, "v3": map[string]interface{} { "public": map[string]interface{} { "get": map[string]interface{} { "insuranceFund": 3, }, }, "private": map[string]interface{} { "get": map[string]interface{} { "algo/order/{oid}": 1, "algo/orders": 1, "balances": 1, "accountinfo": 60, "positions": 3.33, "buypower": 1, "referrals": 60, "referral_rewards": 60, "convert/exchangeInfo": 1, "convert/assetInfo": 1, "convert/rfq": 60, "convert/trade": 1, "convert/trades": 1, }, "post": map[string]interface{} { "algo/order": 5, "convert/rft": 60, }, "put": map[string]interface{} { "order/{oid}": 2, "order/client/{client_order_id}": 2, "algo/order/{oid}": 2, "algo/order/client/{client_order_id}": 2, }, "delete": map[string]interface{} { "algo/order/{order_id}": 1, "algo/orders/pending": 1, "algo/orders/pending/{symbol}": 1, "orders/pending": 1, }, }, }, }, "fees": map[string]interface{} { "trading": map[string]interface{} { "tierBased": true, "percentage": true, "maker": this.ParseNumber("0.0002"), "taker": this.ParseNumber("0.0005"), }, }, "options": map[string]interface{} { "timeDifference": 0, "adjustForTimeDifference": false, "sandboxMode": false, "createMarketBuyOrderRequiresPrice": true, "network-aliases-for-tokens": map[string]interface{} { "HT": "ERC20", "OMG": "ERC20", "UATOM": "ATOM", "ZRX": "ZRX", }, "networks": map[string]interface{} { "TRX": "TRON", "TRC20": "TRON", "ERC20": "ETH", "BEP20": "BSC", }, "defaultNetworkCodeForCurrencies": map[string]interface{} {}, "transfer": map[string]interface{} { "fillResponseFromRequest": true, }, "brokerId": "bc830de7-50f3-460b-9ee0-f430f83f9dad", }, "features": map[string]interface{} { "default": map[string]interface{} { "sandbox": true, "createOrder": map[string]interface{} { "marginMode": true, "triggerPrice": true, "triggerPriceType": map[string]interface{} { "last": true, "mark": true, "index": false, }, "triggerDirection": false, "stopLossPrice": false, "takeProfitPrice": false, "attachedStopLossTakeProfit": nil, "timeInForce": map[string]interface{} { "IOC": true, "FOK": true, "PO": true, "GTD": true, }, "hedged": false, "trailing": true, "leverage": false, "marketBuyByCost": true, "marketBuyRequiresPrice": false, "selfTradePrevention": false, "iceberg": true, }, "createOrders": nil, "fetchMyTrades": map[string]interface{} { "marginMode": false, "limit": 500, "daysBack": 90, "untilDays": 10000, "symbolRequired": false, }, "fetchOrder": map[string]interface{} { "marginMode": false, "trigger": true, "trailing": false, "symbolRequired": false, }, "fetchOpenOrders": map[string]interface{} { "marginMode": false, "limit": 500, "trigger": true, "trailing": true, "symbolRequired": false, }, "fetchOrders": map[string]interface{} { "marginMode": false, "limit": 500, "daysBack": nil, "untilDays": 100000, "trigger": true, "trailing": true, "symbolRequired": false, }, "fetchClosedOrders": map[string]interface{} { "marginMode": false, "limit": 500, "daysBack": nil, "daysBackCanceled": nil, "untilDays": 100000, "trigger": true, "trailing": true, "symbolRequired": false, }, "fetchOHLCV": map[string]interface{} { "limit": 1000, }, }, "spot": map[string]interface{} { "extends": "default", }, "forSwap": map[string]interface{} { "extends": "default", "createOrder": map[string]interface{} { "hedged": true, }, }, "swap": map[string]interface{} { "linear": map[string]interface{} { "extends": "forSwap", }, "inverse": nil, }, "future": map[string]interface{} { "linear": nil, "inverse": nil, }, }, "commonCurrencies": map[string]interface{} {}, "exceptions": map[string]interface{} { "exact": map[string]interface{} { "-1000": OperationFailed, "-1001": AuthenticationError, "-1002": AuthenticationError, "-1003": RateLimitExceeded, "-1004": BadRequest, "-1005": BadRequest, "-1006": BadRequest, "-1007": BadRequest, "-1008": InvalidOrder, "-1009": BadRequest, "-1012": BadRequest, "-1101": InvalidOrder, "-1102": InvalidOrder, "-1103": InvalidOrder, "-1104": InvalidOrder, "-1105": InvalidOrder, }, "broad": map[string]interface{} { "Can not place": ExchangeError, "maintenance": OnMaintenance, "symbol must not be blank": BadRequest, "The token is not supported": BadRequest, "Your order and symbol are not valid or already canceled": BadRequest, "Insufficient WOO. Please enable margin trading for leverage trading": BadRequest, }, }, "precisionMode": TICK_SIZE, }) } /** * @method * @name woo#fetchStatus * @description the latest known information on the availability of the exchange API * @see https://docs.woox.io/#get-system-maintenance-status-public * @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 *woo) 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.V1PublicGetSystemInfo(params)) PanicOnError(response) // // { // "success": true, // "data": { // "status": "0", // "msg": "System is functioning properly." // }, // "timestamp": "1709274106602" // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var status interface{} = this.SafeString(data, "status") if IsTrue(IsEqual(status, nil)) { status = "error" } else if IsTrue(IsEqual(status, "0")) { status = "ok" } else { status = "maintenance" } ch <- map[string]interface{} { "status": status, "updated": nil, "eta": nil, "url": nil, "info": response, } return nil }() return ch } /** * @method * @name woo#fetchTime * @description fetches the current integer timestamp in milliseconds from the exchange server * @see https://docs.woox.io/#get-system-maintenance-status-public * @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 *woo) 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.V1PublicGetSystemInfo(params)) PanicOnError(response) // // { // "success": true, // "data": { // "status": "0", // "msg": "System is functioning properly." // }, // "timestamp": "1709274106602" // } // ch <- this.SafeInteger(response, "timestamp") return nil }() return ch } /** * @method * @name woo#fetchMarkets * @description retrieves data on all markets for woo * @see https://docs.woox.io/#exchange-information * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} an array of objects representing market data */ func (this *woo) 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")) { retRes51312 := (<-this.LoadTimeDifference()) PanicOnError(retRes51312) } response:= (<-this.V1PublicGetInfo(params)) PanicOnError(response) // // { // "rows": [ // { // "symbol": "SPOT_AAVE_USDT", // "quote_min": 0, // "quote_max": 100000, // "quote_tick": 0.01, // "base_min": 0.01, // "base_max": 7284, // "base_tick": 0.0001, // "min_notional": 10, // "price_range": 0.1, // "created_time": "0", // "updated_time": "1639107647.988", // "is_stable": 0 // }, // ... // "success": true // } // var data interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseMarkets(data) return nil }() return ch } func (this *woo) ParseMarket(market interface{}) interface{} { var marketId interface{} = this.SafeString(market, "symbol") var parts interface{} = Split(marketId, "_") var first interface{} = this.SafeString(parts, 0) var marketType interface{} = nil var spot interface{} = false var swap interface{} = false if IsTrue(IsEqual(first, "SPOT")) { spot = true marketType = "spot" } else if IsTrue(IsEqual(first, "PERP")) { swap = true marketType = "swap" } var baseId interface{} = this.SafeString(parts, 1) var quoteId interface{} = this.SafeString(parts, 2) var base interface{} = this.SafeCurrencyCode(baseId) var quote interface{} = this.SafeCurrencyCode(quoteId) var settleId interface{} = nil var settle interface{} = nil var symbol interface{} = Add(Add(base, "/"), quote) var contractSize interface{} = nil var linear interface{} = nil var margin interface{} = true var contract interface{} = swap if IsTrue(contract) { margin = false settleId = this.SafeString(parts, 2) settle = this.SafeCurrencyCode(settleId) symbol = Add(Add(Add(Add(base, "/"), quote), ":"), settle) contractSize = this.ParseNumber("1") linear = true } return map[string]interface{} { "id": marketId, "symbol": symbol, "base": base, "quote": quote, "settle": settle, "baseId": baseId, "quoteId": quoteId, "settleId": settleId, "type": marketType, "spot": spot, "margin": margin, "swap": swap, "future": false, "option": false, "active": IsEqual(this.SafeString(market, "is_trading"), "1"), "contract": contract, "linear": linear, "inverse": nil, "contractSize": contractSize, "expiry": nil, "expiryDatetime": nil, "strike": nil, "optionType": nil, "precision": map[string]interface{} { "amount": this.SafeNumber(market, "base_tick"), "price": this.SafeNumber(market, "quote_tick"), }, "limits": map[string]interface{} { "leverage": map[string]interface{} { "min": nil, "max": nil, }, "amount": map[string]interface{} { "min": this.SafeNumber(market, "base_min"), "max": this.SafeNumber(market, "base_max"), }, "price": map[string]interface{} { "min": this.SafeNumber(market, "quote_min"), "max": this.SafeNumber(market, "quote_max"), }, "cost": map[string]interface{} { "min": this.SafeNumber(market, "min_notional"), "max": nil, }, }, "created": this.SafeTimestamp(market, "created_time"), "info": market, } } /** * @method * @name woo#fetchTrades * @description get the list of most recent trades for a particular symbol * @see https://docs.woox.io/#market-trades-public * @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 *woo) 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 retRes6378 := (<-this.LoadMarkets()) PanicOnError(retRes6378) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) } response:= (<-this.V1PublicGetMarketTrades(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "rows": [ // { // "symbol": "SPOT_BTC_USDT", // "side": "SELL", // "executed_price": 46222.35, // "executed_quantity": 0.0012, // "executed_timestamp": "1641241162.329" // }, // { // "symbol": "SPOT_BTC_USDT", // "side": "SELL", // "executed_price": 46222.35, // "executed_quantity": 0.0012, // "executed_timestamp": "1641241162.329" // }, // { // "symbol": "SPOT_BTC_USDT", // "side": "BUY", // "executed_price": 46224.32, // "executed_quantity": 0.00039, // "executed_timestamp": "1641241162.287" // }, // ... // ] // } // var resultResponse interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseTrades(resultResponse, market, since, limit) return nil }() return ch } func (this *woo) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} { // // public/market_trades // // { // "symbol": "SPOT_BTC_USDT", // "side": "SELL", // "executed_price": 46222.35, // "executed_quantity": 0.0012, // "executed_timestamp": "1641241162.329" // } // // fetchOrderTrades, fetchOrder // // { // "id": "99119876", // "symbol": "SPOT_WOO_USDT", // "fee": "0.0024", // "side": "BUY", // "executed_timestamp": "1641481113.084", // "order_id": "87001234", // "order_tag": "default", <-- this param only in "fetchOrderTrades" // "executed_price": "1", // "executed_quantity": "12", // "fee_asset": "WOO", // "is_maker": "1" // } // market := GetArg(optionalArgs, 0, nil) _ = market var isFromFetchOrder interface{} = (InOp(trade, "id")) var timestamp interface{} = this.SafeTimestamp(trade, "executed_timestamp") var marketId interface{} = this.SafeString(trade, "symbol") market = this.SafeMarket(marketId, market) var symbol interface{} = GetValue(market, "symbol") var price interface{} = this.SafeString(trade, "executed_price") var amount interface{} = this.SafeString(trade, "executed_quantity") var order_id interface{} = this.SafeString(trade, "order_id") var fee interface{} = this.ParseTokenAndFeeTemp(trade, "fee_asset", "fee") var feeCost interface{} = this.SafeString(fee, "cost") if IsTrue(!IsEqual(feeCost, nil)) { AddElementToObject(fee, "cost", feeCost) } var cost interface{} = Precise.StringMul(price, amount) var side interface{} = this.SafeStringLower(trade, "side") var id interface{} = this.SafeString(trade, "id") var takerOrMaker interface{} = nil if IsTrue(isFromFetchOrder) { var isMaker interface{} = IsEqual(this.SafeString(trade, "is_maker"), "1") takerOrMaker = Ternary(IsTrue(isMaker), "maker", "taker") } return this.SafeTrade(map[string]interface{} { "id": id, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "symbol": symbol, "side": side, "price": price, "amount": amount, "cost": cost, "order": order_id, "takerOrMaker": takerOrMaker, "type": nil, "fee": fee, "info": trade, }, market) } func (this *woo) ParseTokenAndFeeTemp(item interface{}, feeTokenKey interface{}, feeAmountKey interface{}) interface{} { var feeCost interface{} = this.SafeString(item, feeAmountKey) var fee interface{} = nil if IsTrue(!IsEqual(feeCost, nil)) { var feeCurrencyId interface{} = this.SafeString(item, feeTokenKey) var feeCurrencyCode interface{} = this.SafeCurrencyCode(feeCurrencyId) fee = map[string]interface{} { "cost": feeCost, "currency": feeCurrencyCode, } } return fee } /** * @method * @name woo#fetchTradingFees * @description fetch the trading fees for multiple markets * @see https://docs.woox.io/#get-account-information-new * @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 *woo) 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 retRes7688 := (<-this.LoadMarkets()) PanicOnError(retRes7688) response:= (<-this.V3PrivateGetAccountinfo(params)) PanicOnError(response) // // { // "success": true, // "data": { // "applicationId": "dsa", // "account": "dsa", // "alias": "haha", // "accountMode": "MARGIN", // "leverage": 1, // "takerFeeRate": 1, // "makerFeeRate": 1, // "interestRate": 1, // "futuresTakerFeeRate": 1, // "futuresMakerFeeRate": 1, // "otpauth": true, // "marginRatio": 1, // "openMarginRatio": 1, // "initialMarginRatio": 1, // "maintenanceMarginRatio": 1, // "totalCollateral": 1, // "freeCollateral": 1, // "totalAccountValue": 1, // "totalVaultValue": 1, // "totalStakingValue": 1 // }, // "timestamp": 1673323685109 // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var maker interface{} = this.SafeString(data, "makerFeeRate") var taker interface{} = this.SafeString(data, "takerFeeRate") var result interface{} = map[string]interface{} {} for i := 0; IsLessThan(i, GetArrayLength(this.Symbols)); i++ { var symbol interface{} = GetValue(this.Symbols, i) AddElementToObject(result, symbol, map[string]interface{} { "info": response, "symbol": symbol, "maker": this.ParseNumber(Precise.StringDiv(maker, "10000")), "taker": this.ParseNumber(Precise.StringDiv(taker, "10000")), "percentage": true, "tierBased": true, }) } ch <- result return nil }() return ch } /** * @method * @name woo#fetchCurrencies * @description fetches all available currencies on an exchange * @see https://docs.woox.io/#available-token-public * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an associative dictionary of currencies */ func (this *woo) 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 var result interface{} = map[string]interface{} {} tokenResponse:= (<-this.V1PublicGetToken(params)) PanicOnError(tokenResponse) // // { // "rows": [ // { // "token": "ETH_USDT", // "fullname": "Tether", // "decimals": 6, // "balance_token": "USDT", // "created_time": "0", // "updated_time": "0" // }, // { // "token": "BSC_USDT", // "fullname": "Tether", // "decimals": 18, // "balance_token": "USDT", // "created_time": "0", // "updated_time": "0" // }, // { // "token": "ZEC", // "fullname": "ZCash", // "decimals": 8, // "balance_token": "ZEC", // "created_time": "0", // "updated_time": "0" // }, // ... // ], // "success": true // } // // only make one request for currrencies... // const tokenNetworkResponse = await this.v1PublicGetTokenNetwork (params); // // { // "rows": [ // { // "protocol": "ERC20", // "token": "USDT", // "name": "Ethereum", // "minimum_withdrawal": 30, // "withdrawal_fee": 25, // "allow_deposit": 1, // "allow_withdraw": 1 // }, // { // "protocol": "TRC20", // "token": "USDT", // "name": "Tron", // "minimum_withdrawal": 30, // "withdrawal_fee": 1, // "allow_deposit": 1, // "allow_withdraw": 1 // }, // ... // ], // "success": true // } // var tokenRows interface{} = this.SafeList(tokenResponse, "rows", []interface{}{}) var networksByCurrencyId interface{} = this.GroupBy(tokenRows, "balance_token") var currencyIds interface{} = ObjectKeys(networksByCurrencyId) for i := 0; IsLessThan(i, GetArrayLength(currencyIds)); i++ { var currencyId interface{} = GetValue(currencyIds, i) var networks interface{} = GetValue(networksByCurrencyId, currencyId) var code interface{} = this.SafeCurrencyCode(currencyId) var name interface{} = nil var minPrecision interface{} = nil var resultingNetworks interface{} = map[string]interface{} {} for j := 0; IsLessThan(j, GetArrayLength(networks)); j++ { var network interface{} = GetValue(networks, j) name = this.SafeString(network, "fullname") var networkId interface{} = this.SafeString(network, "token") var splitted interface{} = Split(networkId, "_") var unifiedNetwork interface{} = GetValue(splitted, 0) var precision interface{} = this.ParsePrecision(this.SafeString(network, "decimals")) if IsTrue(!IsEqual(precision, nil)) { minPrecision = Ternary(IsTrue((IsEqual(minPrecision, nil))), precision, Precise.StringMin(precision, minPrecision)) } AddElementToObject(resultingNetworks, unifiedNetwork, map[string]interface{} { "id": networkId, "network": unifiedNetwork, "limits": map[string]interface{} { "withdraw": map[string]interface{} { "min": nil, "max": nil, }, "deposit": map[string]interface{} { "min": nil, "max": nil, }, }, "active": nil, "deposit": nil, "withdraw": nil, "fee": nil, "precision": this.ParseNumber(precision), "info": network, }) } AddElementToObject(result, code, map[string]interface{} { "id": currencyId, "name": name, "code": code, "precision": this.ParseNumber(minPrecision), "active": nil, "fee": nil, "networks": resultingNetworks, "deposit": nil, "withdraw": nil, "limits": map[string]interface{} { "deposit": map[string]interface{} { "min": nil, "max": nil, }, "withdraw": map[string]interface{} { "min": nil, "max": nil, }, }, "info": networks, }) } ch <- result return nil }() return ch } /** * @method * @name woo#createMarketBuyOrderWithCost * @description create a market buy order by providing the symbol and cost * @see https://docs.woox.io/#send-order * @param {string} symbol unified symbol of the market to create an order in * @param {float} cost how much you want to trade in units of the quote currency * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 retRes9658 := (<-this.LoadMarkets()) PanicOnError(retRes9658) var market interface{} = this.Market(symbol) if !IsTrue(GetValue(market, "spot")) { panic(NotSupported(Add(this.Id, " createMarketBuyOrderWithCost() supports spot orders only"))) } retRes97015 := (<-this.CreateOrder(symbol, "market", "buy", cost, 1, params)) PanicOnError(retRes97015) ch <- retRes97015 return nil }() return ch } /** * @method * @name woo#createMarketSellOrderWithCost * @description create a market sell order by providing the symbol and cost * @see https://docs.woox.io/#send-order * @param {string} symbol unified symbol of the market to create an order in * @param {float} cost how much you want to trade in units of the quote currency * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) CreateMarketSellOrderWithCost(symbol interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params retRes9848 := (<-this.LoadMarkets()) PanicOnError(retRes9848) var market interface{} = this.Market(symbol) if !IsTrue(GetValue(market, "spot")) { panic(NotSupported(Add(this.Id, " createMarketSellOrderWithCost() supports spot orders only"))) } retRes98915 := (<-this.CreateOrder(symbol, "market", "sell", cost, 1, params)) PanicOnError(retRes98915) ch <- retRes98915 return nil }() return ch } /** * @method * @name woo#createTrailingAmountOrder * @description create a trailing order by providing the symbol, type, side, amount, price and trailingAmount * @see https://docs.woox.io/#send-algo-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 you want to trade in units of the base currency, or number of contracts * @param {float} [price] the price for the order to be filled at, in units of the quote currency, ignored in market orders * @param {float} trailingAmount the quote amount to trail away from the current market price * @param {float} trailingTriggerPrice the price to activate a trailing order, default uses the price argument * @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 *woo) CreateTrailingAmountOrder(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 trailingAmount := GetArg(optionalArgs, 1, nil) _ = trailingAmount trailingTriggerPrice := GetArg(optionalArgs, 2, nil) _ = trailingTriggerPrice params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params if IsTrue(IsEqual(trailingAmount, nil)) { panic(ArgumentsRequired(Add(this.Id, " createTrailingAmountOrder() requires a trailingAmount argument"))) } if IsTrue(IsEqual(trailingTriggerPrice, nil)) { panic(ArgumentsRequired(Add(this.Id, " createTrailingAmountOrder() requires a trailingTriggerPrice argument"))) } AddElementToObject(params, "trailingAmount", trailingAmount) AddElementToObject(params, "trailingTriggerPrice", trailingTriggerPrice) retRes101615 := (<-this.CreateOrder(symbol, typeVar, side, amount, price, params)) PanicOnError(retRes101615) ch <- retRes101615 return nil }() return ch } /** * @method * @name woo#createTrailingPercentOrder * @description create a trailing order by providing the symbol, type, side, amount, price and trailingPercent * @see https://docs.woox.io/#send-algo-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 you want to trade in units of the base currency, or number of contracts * @param {float} [price] the price for the order to be filled at, in units of the quote currency, ignored in market orders * @param {float} trailingPercent the percent to trail away from the current market price * @param {float} trailingTriggerPrice the price to activate a trailing order, default uses the price argument * @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 *woo) CreateTrailingPercentOrder(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 trailingPercent := GetArg(optionalArgs, 1, nil) _ = trailingPercent trailingTriggerPrice := GetArg(optionalArgs, 2, nil) _ = trailingTriggerPrice params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params if IsTrue(IsEqual(trailingPercent, nil)) { panic(ArgumentsRequired(Add(this.Id, " createTrailingPercentOrder() requires a trailingPercent argument"))) } if IsTrue(IsEqual(trailingTriggerPrice, nil)) { panic(ArgumentsRequired(Add(this.Id, " createTrailingPercentOrder() requires a trailingTriggerPrice argument"))) } AddElementToObject(params, "trailingPercent", trailingPercent) AddElementToObject(params, "trailingTriggerPrice", trailingTriggerPrice) retRes104315 := (<-this.CreateOrder(symbol, typeVar, side, amount, price, params)) PanicOnError(retRes104315) ch <- retRes104315 return nil }() return ch } /** * @method * @name woo#createOrder * @description create a trade order * @see https://docs.woox.io/#send-order * @see https://docs.woox.io/#send-algo-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 {string} [params.marginMode] *for swap markets only* 'cross' or 'isolated', default 'cross' * @param {float} [params.triggerPrice] The price a trigger order is triggered at * @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered (perpetual swap markets only) * @param {float} [params.takeProfit.triggerPrice] take profit trigger price * @param {object} [params.stopLoss] *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered (perpetual swap markets only) * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price * @param {float} [params.algoType] 'STOP' or 'TRAILING_STOP' or 'OCO' or 'CLOSE_POSITION' * @param {float} [params.cost] *spot market buy only* the quote quantity that can be used as an alternative for the amount * @param {string} [params.trailingAmount] the quote amount to trail away from the current market price * @param {string} [params.trailingPercent] the percent to trail away from the current market price * @param {string} [params.trailingTriggerPrice] the price to trigger a trailing order, default uses the price argument * @param {string} [params.position_side] 'SHORT' or 'LONG' - if position mode is HEDGE_MODE and the trading involves futures, then is required, otherwise this parameter is not required * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 var reduceOnly interface{} = this.SafeBool2(params, "reduceOnly", "reduce_only") params = this.Omit(params, []interface{}{"reduceOnly", "reduce_only"}) var orderType interface{} = ToUpper(typeVar) retRes10768 := (<-this.LoadMarkets()) PanicOnError(retRes10768) var market interface{} = this.Market(symbol) var orderSide interface{} = ToUpper(side) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), "side": orderSide, } var marginMode interface{} = nil marginModeparamsVariable := this.HandleMarginModeAndParams("createOrder", params); marginMode = GetValue(marginModeparamsVariable,0); params = GetValue(marginModeparamsVariable,1) if IsTrue(!IsEqual(marginMode, nil)) { AddElementToObject(request, "margin_mode", this.EncodeMarginMode(marginMode)) } var triggerPrice interface{} = this.SafeString2(params, "triggerPrice", "stopPrice") var stopLoss interface{} = this.SafeValue(params, "stopLoss") var takeProfit interface{} = this.SafeValue(params, "takeProfit") var algoType interface{} = this.SafeString(params, "algoType") var trailingTriggerPrice interface{} = this.SafeString2(params, "trailingTriggerPrice", "activatedPrice", this.NumberToString(price)) var trailingAmount interface{} = this.SafeString2(params, "trailingAmount", "callbackValue") var trailingPercent interface{} = this.SafeString2(params, "trailingPercent", "callbackRate") var isTrailingAmountOrder interface{} = !IsEqual(trailingAmount, nil) var isTrailingPercentOrder interface{} = !IsEqual(trailingPercent, nil) var isTrailing interface{} = IsTrue(isTrailingAmountOrder) || IsTrue(isTrailingPercentOrder) var isConditional interface{} = IsTrue(IsTrue(IsTrue(IsTrue(isTrailing) || IsTrue(!IsEqual(triggerPrice, nil))) || IsTrue(!IsEqual(stopLoss, nil))) || IsTrue(!IsEqual(takeProfit, nil))) || IsTrue((!IsEqual(this.SafeValue(params, "childOrders"), nil))) var isMarket interface{} = IsEqual(orderType, "MARKET") var timeInForce interface{} = this.SafeStringLower(params, "timeInForce") var postOnly interface{} = this.IsPostOnly(isMarket, nil, params) var reduceOnlyKey interface{} = Ternary(IsTrue(isConditional), "reduceOnly", "reduce_only") var clientOrderIdKey interface{} = Ternary(IsTrue(isConditional), "clientOrderId", "client_order_id") var orderQtyKey interface{} = Ternary(IsTrue(isConditional), "quantity", "order_quantity") var priceKey interface{} = Ternary(IsTrue(isConditional), "price", "order_price") var typeKey interface{} = Ternary(IsTrue(isConditional), "type", "order_type") AddElementToObject(request, typeKey, orderType) // LIMIT/MARKET/IOC/FOK/POST_ONLY/ASK/BID if !IsTrue(isConditional) { if IsTrue(postOnly) { AddElementToObject(request, "order_type", "POST_ONLY") } else if IsTrue(IsEqual(timeInForce, "fok")) { AddElementToObject(request, "order_type", "FOK") } else if IsTrue(IsEqual(timeInForce, "ioc")) { AddElementToObject(request, "order_type", "IOC") } } if IsTrue(reduceOnly) { AddElementToObject(request, reduceOnlyKey, reduceOnly) } if IsTrue(!IsTrue(isMarket) && IsTrue(!IsEqual(price, nil))) { AddElementToObject(request, priceKey, this.PriceToPrecision(symbol, price)) } if IsTrue(IsTrue(isMarket) && !IsTrue(isConditional)) { // for market buy it requires the amount of quote currency to spend var cost interface{} = this.SafeString2(params, "cost", "order_amount") params = this.Omit(params, []interface{}{"cost", "order_amount"}) var isPriceProvided interface{} = !IsEqual(price, nil) if IsTrue(IsTrue(GetValue(market, "spot")) && IsTrue((IsTrue(isPriceProvided) || IsTrue((!IsEqual(cost, nil)))))) { var quoteAmount interface{} = nil if IsTrue(!IsEqual(cost, nil)) { quoteAmount = this.CostToPrecision(symbol, cost) } else { var amountString interface{} = this.NumberToString(amount) var priceString interface{} = this.NumberToString(price) var costRequest interface{} = Precise.StringMul(amountString, priceString) quoteAmount = this.CostToPrecision(symbol, costRequest) } AddElementToObject(request, "order_amount", quoteAmount) } else { AddElementToObject(request, "order_quantity", this.AmountToPrecision(symbol, amount)) } } else if IsTrue(!IsEqual(algoType, "POSITIONAL_TP_SL")) { AddElementToObject(request, orderQtyKey, this.AmountToPrecision(symbol, amount)) } var clientOrderId interface{} = this.SafeStringN(params, []interface{}{"clOrdID", "clientOrderId", "client_order_id"}) if IsTrue(!IsEqual(clientOrderId, nil)) { AddElementToObject(request, clientOrderIdKey, clientOrderId) } if IsTrue(isTrailing) { if IsTrue(IsEqual(trailingTriggerPrice, nil)) { panic(ArgumentsRequired(Add(this.Id, " createOrder() requires a trailingTriggerPrice parameter for trailing orders"))) } AddElementToObject(request, "activatedPrice", this.PriceToPrecision(symbol, trailingTriggerPrice)) AddElementToObject(request, "algoType", "TRAILING_STOP") if IsTrue(isTrailingAmountOrder) { AddElementToObject(request, "callbackValue", trailingAmount) } else if IsTrue(isTrailingPercentOrder) { var convertedTrailingPercent interface{} = Precise.StringDiv(trailingPercent, "100") AddElementToObject(request, "callbackRate", convertedTrailingPercent) } } else if IsTrue(!IsEqual(triggerPrice, nil)) { if IsTrue(!IsEqual(algoType, "TRAILING_STOP")) { AddElementToObject(request, "triggerPrice", this.PriceToPrecision(symbol, triggerPrice)) AddElementToObject(request, "algoType", "STOP") } } else if IsTrue(IsTrue((!IsEqual(stopLoss, nil))) || IsTrue((!IsEqual(takeProfit, nil)))) { AddElementToObject(request, "algoType", "BRACKET") var outterOrder interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), "reduceOnly": false, "algoType": "POSITIONAL_TP_SL", "childOrders": []interface{}{}, } var childOrders interface{} = GetValue(outterOrder, "childOrders") var closeSide interface{} = Ternary(IsTrue((IsEqual(orderSide, "BUY"))), "SELL", "BUY") if IsTrue(!IsEqual(stopLoss, nil)) { var stopLossPrice interface{} = this.SafeString(stopLoss, "triggerPrice", stopLoss) var stopLossOrder interface{} = map[string]interface{} { "side": closeSide, "algoType": "STOP_LOSS", "triggerPrice": this.PriceToPrecision(symbol, stopLossPrice), "type": "CLOSE_POSITION", "reduceOnly": true, } AppendToArray(&childOrders,stopLossOrder) } if IsTrue(!IsEqual(takeProfit, nil)) { var takeProfitPrice interface{} = this.SafeString(takeProfit, "triggerPrice", takeProfit) var takeProfitOrder interface{} = map[string]interface{} { "side": closeSide, "algoType": "TAKE_PROFIT", "triggerPrice": this.PriceToPrecision(symbol, takeProfitPrice), "type": "CLOSE_POSITION", "reduceOnly": true, } AppendToArray(&childOrders,takeProfitOrder) } AddElementToObject(request, "childOrders", []interface{}{outterOrder}) } params = this.Omit(params, []interface{}{"clOrdID", "clientOrderId", "client_order_id", "postOnly", "timeInForce", "stopPrice", "triggerPrice", "stopLoss", "takeProfit", "trailingPercent", "trailingAmount", "trailingTriggerPrice"}) var response interface{} = nil if IsTrue(isConditional) { response = (<-this.V3PrivatePostAlgoOrder(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V1PrivatePostOrder(this.Extend(request, params))) PanicOnError(response) } // { // "success": true, // "timestamp": "1641383206.489", // "order_id": "86980774", // "order_type": "LIMIT", // "order_price": "1", // null for "MARKET" order // "order_quantity": "12", // null for "MARKET" order // "order_amount": null, // NOT-null for "MARKET" order // "client_order_id": "0" // } // stop orders // { // "success": true, // "data": { // "rows": [ // { // "orderId": "1578938", // "clientOrderId": "0", // "algoType": "STOP_LOSS", // "quantity": "0.1" // } // ] // }, // "timestamp": "1686149372216" // } var data interface{} = this.SafeDict(response, "data") if IsTrue(!IsEqual(data, nil)) { var rows interface{} = this.SafeList(data, "rows", []interface{}{}) ch <- this.ParseOrder(GetValue(rows, 0), market) return nil } var order interface{} = this.ParseOrder(response, market) AddElementToObject(order, "type", typeVar) ch <- order return nil }() return ch } func (this *woo) EncodeMarginMode(mode interface{}) interface{} { var modes interface{} = map[string]interface{} { "cross": "CROSS", "isolated": "ISOLATED", } return this.SafeString(modes, mode, mode) } /** * @method * @name woo#editOrder * @description edit a trade order * @see https://docs.woox.io/#edit-order * @see https://docs.woox.io/#edit-order-by-client_order_id * @see https://docs.woox.io/#edit-algo-order * @see https://docs.woox.io/#edit-algo-order-by-client_order_id * @param {string} id order id * @param {string} symbol unified symbol of the market to create an order in * @param {string} type 'market' or 'limit' * @param {string} side 'buy' or 'sell' * @param {float} amount how much of 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.triggerPrice] The price a trigger order is triggered at * @param {float} [params.stopLossPrice] price to trigger stop-loss orders * @param {float} [params.takeProfitPrice] price to trigger take-profit orders * @param {string} [params.trailingAmount] the quote amount to trail away from the current market price * @param {string} [params.trailingPercent] the percent to trail away from the current market price * @param {string} [params.trailingTriggerPrice] the price to trigger a trailing order, default uses the price argument * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 retRes12748 := (<-this.LoadMarkets()) PanicOnError(retRes12748) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(price, nil)) { AddElementToObject(request, "price", this.PriceToPrecision(symbol, price)) } if IsTrue(!IsEqual(amount, nil)) { AddElementToObject(request, "quantity", this.AmountToPrecision(symbol, amount)) } var clientOrderIdUnified interface{} = this.SafeString2(params, "clOrdID", "clientOrderId") var clientOrderIdExchangeSpecific interface{} = this.SafeString(params, "client_order_id", clientOrderIdUnified) var isByClientOrder interface{} = !IsEqual(clientOrderIdExchangeSpecific, nil) var triggerPrice interface{} = this.SafeNumberN(params, []interface{}{"triggerPrice", "stopPrice", "takeProfitPrice", "stopLossPrice"}) if IsTrue(!IsEqual(triggerPrice, nil)) { AddElementToObject(request, "triggerPrice", this.PriceToPrecision(symbol, triggerPrice)) } var trailingTriggerPrice interface{} = this.SafeString2(params, "trailingTriggerPrice", "activatedPrice", this.NumberToString(price)) var trailingAmount interface{} = this.SafeString2(params, "trailingAmount", "callbackValue") var trailingPercent interface{} = this.SafeString2(params, "trailingPercent", "callbackRate") var isTrailingAmountOrder interface{} = !IsEqual(trailingAmount, nil) var isTrailingPercentOrder interface{} = !IsEqual(trailingPercent, nil) var isTrailing interface{} = IsTrue(isTrailingAmountOrder) || IsTrue(isTrailingPercentOrder) if IsTrue(isTrailing) { if IsTrue(!IsEqual(trailingTriggerPrice, nil)) { AddElementToObject(request, "activatedPrice", this.PriceToPrecision(symbol, trailingTriggerPrice)) } if IsTrue(isTrailingAmountOrder) { AddElementToObject(request, "callbackValue", trailingAmount) } else if IsTrue(isTrailingPercentOrder) { var convertedTrailingPercent interface{} = Precise.StringDiv(trailingPercent, "100") AddElementToObject(request, "callbackRate", convertedTrailingPercent) } } params = this.Omit(params, []interface{}{"clOrdID", "clientOrderId", "client_order_id", "stopPrice", "triggerPrice", "takeProfitPrice", "stopLossPrice", "trailingTriggerPrice", "trailingAmount", "trailingPercent"}) var isConditional interface{} = IsTrue(IsTrue(isTrailing) || IsTrue((!IsEqual(triggerPrice, nil)))) || IsTrue((!IsEqual(this.SafeValue(params, "childOrders"), nil))) var response interface{} = nil if IsTrue(isByClientOrder) { AddElementToObject(request, "client_order_id", clientOrderIdExchangeSpecific) if IsTrue(isConditional) { response = (<-this.V3PrivatePutAlgoOrderClientClientOrderId(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V3PrivatePutOrderClientClientOrderId(this.Extend(request, params))) PanicOnError(response) } } else { AddElementToObject(request, "oid", id) if IsTrue(isConditional) { response = (<-this.V3PrivatePutAlgoOrderOid(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V3PrivatePutOrderOid(this.Extend(request, params))) PanicOnError(response) } } // // { // "code": 0, // "data": { // "status": "string", // "success": true // }, // "message": "string", // "success": true, // "timestamp": 0 // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) ch <- this.ParseOrder(data, market) return nil }() return ch } /** * @method * @name woo#cancelOrder * @see https://docs.woox.io/#cancel-algo-order * @see https://docs.woox.io/#cancel-order * @see https://docs.woox.io/#cancel-order-by-client_order_id * @description cancels an open 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 * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 var isTrigger interface{} = this.SafeBool2(params, "trigger", "stop", false) params = this.Omit(params, []interface{}{"trigger", "stop"}) if IsTrue(!IsTrue(isTrigger) && IsTrue((IsEqual(symbol, nil)))) { panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument"))) } retRes13638 := (<-this.LoadMarkets()) PanicOnError(retRes13638) var market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) } var request interface{} = map[string]interface{} {} var clientOrderIdUnified interface{} = this.SafeString2(params, "clOrdID", "clientOrderId") var clientOrderIdExchangeSpecific interface{} = this.SafeString(params, "client_order_id", clientOrderIdUnified) var isByClientOrder interface{} = !IsEqual(clientOrderIdExchangeSpecific, nil) var response interface{} = nil if IsTrue(isTrigger) { AddElementToObject(request, "order_id", id) response = (<-this.V3PrivateDeleteAlgoOrderOrderId(this.Extend(request, params))) PanicOnError(response) } else { AddElementToObject(request, "symbol", GetValue(market, "id")) if IsTrue(isByClientOrder) { AddElementToObject(request, "client_order_id", clientOrderIdExchangeSpecific) params = this.Omit(params, []interface{}{"clOrdID", "clientOrderId", "client_order_id"}) response = (<-this.V1PrivateDeleteClientOrder(this.Extend(request, params))) PanicOnError(response) } else { AddElementToObject(request, "order_id", id) response = (<-this.V1PrivateDeleteOrder(this.Extend(request, params))) PanicOnError(response) } } // // { success: true, status: "CANCEL_SENT" } // var extendParams interface{} = map[string]interface{} { "symbol": symbol, } if IsTrue(isByClientOrder) { AddElementToObject(extendParams, "client_order_id", clientOrderIdExchangeSpecific) } else { AddElementToObject(extendParams, "id", id) } ch <- this.Extend(this.ParseOrder(response), extendParams) return nil }() return ch } /** * @method * @name woo#cancelAllOrders * @see https://docs.woox.io/#cancel-all-pending-orders * @see https://docs.woox.io/#cancel-orders * @see https://docs.woox.io/#cancel-all-pending-algo-orders * @description cancel all open orders in a market * @param {string} symbol unified market symbol * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 retRes14128 := (<-this.LoadMarkets()) PanicOnError(retRes14128) var trigger interface{} = this.SafeBool2(params, "stop", "trigger") params = this.Omit(params, []interface{}{"stop", "trigger"}) if IsTrue(trigger) { retRes141619 := (<-this.V3PrivateDeleteAlgoOrdersPending(params)) PanicOnError(retRes141619) ch <- retRes141619 return nil } if IsTrue(IsEqual(symbol, nil)) { panic(ArgumentsRequired(Add(this.Id, " cancelOrders() requires a symbol argument"))) } var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } response:= (<-this.V1PrivateDeleteOrders(this.Extend(request, params))) PanicOnError(response) // // { // "success":true, // "status":"CANCEL_ALL_SENT" // } // ch <- []interface{}{this.SafeOrder(response)} return nil }() return ch } /** * @method * @name woo#cancelAllOrdersAfter * @description dead man's switch, cancel all orders after the given timeout * @see https://docs.woox.io/#cancel-all-after * @param {number} timeout time in milliseconds, 0 represents cancel the timer * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} the api result */ func (this *woo) 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 retRes14478 := (<-this.LoadMarkets()) PanicOnError(retRes14478) var request interface{} = map[string]interface{} { "trigger_after": Ternary(IsTrue((IsGreaterThan(timeout, 0))), timeout, 0), } response:= (<-this.V1PrivatePostOrderCancelAllAfter(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "data": { // "expected_trigger_time": 1711534302938 // }, // "timestamp": 1711534302943 // } // ch <- []interface{}{this.SafeOrder(response)} return nil }() return ch } /** * @method * @name woo#fetchOrder * @see https://docs.woox.io/#get-algo-order * @see https://docs.woox.io/#get-order * @description fetches information on an order made by the user * @param {string} id the order id * @param {string} symbol unified symbol of the market the order was made in * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) FetchOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbol := GetArg(optionalArgs, 0, nil) _ = symbol params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params retRes14798 := (<-this.LoadMarkets()) PanicOnError(retRes14798) var market interface{} = Ternary(IsTrue((!IsEqual(symbol, nil))), this.Market(symbol), nil) var trigger interface{} = this.SafeBool2(params, "stop", "trigger") params = this.Omit(params, []interface{}{"stop", "trigger"}) var request interface{} = map[string]interface{} {} var clientOrderId interface{} = this.SafeString2(params, "clOrdID", "clientOrderId") var response interface{} = nil if IsTrue(trigger) { AddElementToObject(request, "oid", id) response = (<-this.V3PrivateGetAlgoOrderOid(this.Extend(request, params))) PanicOnError(response) } else if IsTrue(clientOrderId) { AddElementToObject(request, "client_order_id", clientOrderId) response = (<-this.V1PrivateGetClientOrderClientOrderId(this.Extend(request, params))) PanicOnError(response) } else { AddElementToObject(request, "oid", id) response = (<-this.V1PrivateGetOrderOid(this.Extend(request, params))) PanicOnError(response) } // // { // "success": true, // "symbol": "SPOT_WOO_USDT", // "status": "FILLED", // FILLED, NEW // "side": "BUY", // "created_time": "1641480933.000", // "order_id": "87541111", // "order_tag": "default", // "price": "1", // "type": "LIMIT", // "quantity": "12", // "amount": null, // "visible": "12", // "executed": "12", // or any partial amount // "total_fee": "0.0024", // "fee_asset": "WOO", // "client_order_id": null, // "average_executed_price": "1", // "Transactions": [ // { // "id": "99111647", // "symbol": "SPOT_WOO_USDT", // "fee": "0.0024", // "side": "BUY", // "executed_timestamp": "1641482113.084", // "order_id": "87541111", // "executed_price": "1", // "executed_quantity": "12", // "fee_asset": "WOO", // "is_maker": "1" // } // ] // } // var orders interface{} = this.SafeDict(response, "data", response) ch <- this.ParseOrder(orders, market) return nil }() return ch } /** * @method * @name woo#fetchOrders * @description fetches information on multiple orders made by the user * @see https://docs.woox.io/#get-orders * @see https://docs.woox.io/#get-algo-orders * @param {string} symbol unified market symbol of the market orders were made in * @param {int} [since] the earliest time in ms to fetch orders for * @param {int} [limit] the maximum number of order structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @param {boolean} [params.isTriggered] whether the order has been triggered (false by default) * @param {string} [params.side] 'buy' or 'sell' * @param {boolean} [params.trailing] set to true if you want to fetch trailing orders * @param {boolean} [params.paginate] set to true if you want to fetch orders with pagination * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) FetchOrders(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbol := GetArg(optionalArgs, 0, nil) _ = symbol since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params retRes15538 := (<-this.LoadMarkets()) PanicOnError(retRes15538) var paginate interface{} = false paginateparamsVariable := this.HandleOptionAndParams(params, "fetchOrders", "paginate"); paginate = GetValue(paginateparamsVariable,0); params = GetValue(paginateparamsVariable,1) if IsTrue(paginate) { retRes155719 := (<-this.FetchPaginatedCallIncremental("fetchOrders", symbol, since, limit, params, "page", 500)) PanicOnError(retRes155719) ch <- retRes155719 return nil } var request interface{} = map[string]interface{} {} var market interface{} = nil var trigger interface{} = this.SafeBool2(params, "stop", "trigger") var trailing interface{} = this.SafeBool(params, "trailing", false) params = this.Omit(params, []interface{}{"stop", "trailing", "trigger"}) if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "symbol", GetValue(market, "id")) } if IsTrue(!IsEqual(since, nil)) { if IsTrue(IsTrue(trigger) || IsTrue(trailing)) { AddElementToObject(request, "createdTimeStart", since) } else { AddElementToObject(request, "start_t", since) } } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "size", limit) } else { AddElementToObject(request, "size", 500) } if IsTrue(trigger) { AddElementToObject(request, "algoType", "stop") } else if IsTrue(trailing) { AddElementToObject(request, "algoType", "TRAILING_STOP") } var response interface{} = nil if IsTrue(IsTrue(trigger) || IsTrue(trailing)) { response = (<-this.V3PrivateGetAlgoOrders(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V1PrivateGetOrders(this.Extend(request, params))) PanicOnError(response) } // // { // "success":true, // "meta":{ // "total":1, // "records_per_page":100, // "current_page":1 // }, // "rows":[ // { // "symbol":"PERP_BTC_USDT", // "status":"FILLED", // "side":"SELL", // "created_time":"1611617776.000", // "updated_time":"1611617776.000", // "order_id":52121167, // "order_tag":"default", // "price":null, // "type":"MARKET", // "quantity":0.002, // "amount":null, // "visible":0, // "executed":0.002, // "total_fee":0.01732885, // "fee_asset":"USDT", // "client_order_id":null, // "average_executed_price":28881.41 // } // ] // } // var data interface{} = this.SafeValue(response, "data", response) var orders interface{} = this.SafeList(data, "rows") ch <- this.ParseOrders(orders, market, since, limit) return nil }() return ch } /** * @method * @name woo#fetchOpenOrders * @description fetches information on multiple orders made by the user * @see https://docs.woox.io/#get-orders * @see https://docs.woox.io/#get-algo-orders * @param {string} symbol unified market symbol of the market orders were made in * @param {int} [since] the earliest time in ms to fetch orders for * @param {int} [limit] the maximum number of order structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @param {boolean} [params.isTriggered] whether the order has been triggered (false by default) * @param {string} [params.side] 'buy' or 'sell' * @param {boolean} [params.trailing] set to true if you want to fetch trailing orders * @param {boolean} [params.paginate] set to true if you want to fetch orders with pagination * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 retRes16458 := (<-this.LoadMarkets()) PanicOnError(retRes16458) var extendedParams interface{} = this.Extend(params, map[string]interface{} { "status": "INCOMPLETE", }) retRes164715 := (<-this.FetchOrders(symbol, since, limit, extendedParams)) PanicOnError(retRes164715) ch <- retRes164715 return nil }() return ch } /** * @method * @name woo#fetchClosedOrders * @description fetches information on multiple orders made by the user * @see https://docs.woox.io/#get-orders * @see https://docs.woox.io/#get-algo-orders * @param {string} symbol unified market symbol of the market orders were made in * @param {int} [since] the earliest time in ms to fetch orders for * @param {int} [limit] the maximum number of order structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @param {boolean} [params.isTriggered] whether the order has been triggered (false by default) * @param {string} [params.side] 'buy' or 'sell' * @param {boolean} [params.trailing] set to true if you want to fetch trailing orders * @param {boolean} [params.paginate] set to true if you want to fetch orders with pagination * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *woo) 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 retRes16688 := (<-this.LoadMarkets()) PanicOnError(retRes16688) var extendedParams interface{} = this.Extend(params, map[string]interface{} { "status": "COMPLETED", }) retRes167015 := (<-this.FetchOrders(symbol, since, limit, extendedParams)) PanicOnError(retRes167015) ch <- retRes167015 return nil }() return ch } func (this *woo) ParseTimeInForce(timeInForce interface{}) interface{} { var timeInForces interface{} = map[string]interface{} { "ioc": "IOC", "fok": "FOK", "post_only": "PO", } return this.SafeString(timeInForces, timeInForce, nil) } func (this *woo) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} { // // Possible input functions: // * createOrder // * cancelOrder // * fetchOrder // * fetchOrders // const isFromFetchOrder = ('order_tag' in order); TO_DO // // stop order after creating it: // { // "orderId": "1578938", // "clientOrderId": "0", // "algoType": "STOP_LOSS", // "quantity": "0.1" // } // stop order after fetching it: // { // "algoOrderId": "1578958", // "clientOrderId": "0", // "rootAlgoOrderId": "1578958", // "parentAlgoOrderId": "0", // "symbol": "SPOT_LTC_USDT", // "orderTag": "default", // "algoType": "STOP_LOSS", // "side": "BUY", // "quantity": "0.1", // "isTriggered": false, // "triggerPrice": "100", // "triggerStatus": "USELESS", // "type": "LIMIT", // "rootAlgoStatus": "CANCELLED", // "algoStatus": "CANCELLED", // "triggerPriceType": "MARKET_PRICE", // "price": "75", // "triggerTime": "0", // "totalExecutedQuantity": "0", // "averageExecutedPrice": "0", // "totalFee": "0", // "feeAsset": '', // "reduceOnly": false, // "createdTime": "1686149609.744", // "updatedTime": "1686149903.362" // } // market := GetArg(optionalArgs, 0, nil) _ = market var timestamp interface{} = this.SafeTimestampN(order, []interface{}{"timestamp", "created_time", "createdTime"}) var orderId interface{} = this.SafeStringN(order, []interface{}{"order_id", "orderId", "algoOrderId"}) var clientOrderId interface{} = this.OmitZero(this.SafeString2(order, "client_order_id", "clientOrderId")) // Somehow, this always returns 0 for limit order var marketId interface{} = this.SafeString(order, "symbol") market = this.SafeMarket(marketId, market) var symbol interface{} = GetValue(market, "symbol") var price interface{} = this.SafeString2(order, "order_price", "price") var amount interface{} = this.SafeString2(order, "order_quantity", "quantity") // This is base amount var cost interface{} = this.SafeString2(order, "order_amount", "amount") // This is quote amount var orderType interface{} = this.SafeStringLower2(order, "order_type", "type") var status interface{} = this.SafeValue2(order, "status", "algoStatus") var side interface{} = this.SafeStringLower(order, "side") var filled interface{} = this.OmitZero(this.SafeValue2(order, "executed", "totalExecutedQuantity")) var average interface{} = this.OmitZero(this.SafeString2(order, "average_executed_price", "averageExecutedPrice")) // const remaining = Precise.stringSub (cost, filled); var fee interface{} = this.SafeNumber2(order, "total_fee", "totalFee") var feeCurrency interface{} = this.SafeString2(order, "fee_asset", "feeAsset") var transactions interface{} = this.SafeValue(order, "Transactions") var triggerPrice interface{} = this.SafeNumber(order, "triggerPrice") var takeProfitPrice interface{} = nil var stopLossPrice interface{} = nil var childOrders interface{} = this.SafeValue(order, "childOrders") if IsTrue(!IsEqual(childOrders, nil)) { var first interface{} = this.SafeValue(childOrders, 0) var innerChildOrders interface{} = this.SafeValue(first, "childOrders", []interface{}{}) var innerChildOrdersLength interface{} = GetArrayLength(innerChildOrders) if IsTrue(IsGreaterThan(innerChildOrdersLength, 0)) { var takeProfitOrder interface{} = this.SafeValue(innerChildOrders, 0) var stopLossOrder interface{} = this.SafeValue(innerChildOrders, 1) takeProfitPrice = this.SafeNumber(takeProfitOrder, "triggerPrice") stopLossPrice = this.SafeNumber(stopLossOrder, "triggerPrice") } } var lastUpdateTimestamp interface{} = this.SafeTimestamp2(order, "updatedTime", "updated_time") return this.SafeOrder(map[string]interface{} { "id": orderId, "clientOrderId": clientOrderId, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "lastTradeTimestamp": nil, "lastUpdateTimestamp": lastUpdateTimestamp, "status": this.ParseOrderStatus(status), "symbol": symbol, "type": orderType, "timeInForce": this.ParseTimeInForce(orderType), "postOnly": nil, "reduceOnly": this.SafeBool(order, "reduce_only"), "side": side, "price": price, "triggerPrice": triggerPrice, "takeProfitPrice": takeProfitPrice, "stopLossPrice": stopLossPrice, "average": average, "amount": amount, "filled": filled, "remaining": nil, "cost": cost, "trades": transactions, "fee": map[string]interface{} { "cost": fee, "currency": feeCurrency, }, "info": order, }, market) } func (this *woo) ParseOrderStatus(status interface{}) interface{} { if IsTrue(!IsEqual(status, nil)) { var statuses interface{} = map[string]interface{} { "NEW": "open", "FILLED": "closed", "CANCEL_SENT": "canceled", "CANCEL_ALL_SENT": "canceled", "CANCELLED": "canceled", "PARTIAL_FILLED": "open", "REJECTED": "rejected", "INCOMPLETE": "open", "COMPLETED": "closed", } return this.SafeString(statuses, status, status) } return status } /** * @method * @name woo#fetchOrderBook * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data * @see https://docs.woox.io/#orderbook-snapshot-public * @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 *woo) 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 retRes18228 := (<-this.LoadMarkets()) PanicOnError(retRes18228) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } if IsTrue(!IsEqual(limit, nil)) { limit = mathMin(limit, 1000) AddElementToObject(request, "max_level", limit) } response:= (<-this.V1PublicGetOrderbookSymbol(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "timestamp": "1641562961192", // "asks": [ // { price: '0.921', quantity: "76.01" }, // { price: '0.933', quantity: "477.10" }, // ... // ], // "bids": [ // { price: '0.940', quantity: "13502.47" }, // { price: '0.932', quantity: "43.91" }, // ... // ] // } // var timestamp interface{} = this.SafeInteger(response, "timestamp") ch <- this.ParseOrderBook(response, symbol, timestamp, "bids", "asks", "price", "quantity") return nil }() return ch } /** * @method * @name woo#fetchOHLCV * @see https://docs.woox.io/#kline-public * @see https://docs.woox.io/#kline-historical-data-public * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market * @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] max=1000, max=100 when since is defined and is less than (now - (999 * (timeframe in ms))) * @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 *woo) 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 retRes18668 := (<-this.LoadMarkets()) PanicOnError(retRes18668) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), "type": this.SafeString(this.Timeframes, timeframe, timeframe), } var useHistEndpoint interface{} = !IsEqual(since, nil) if IsTrue(IsTrue((!IsEqual(limit, nil))) && IsTrue((!IsEqual(since, nil)))) { var oneThousandCandles interface{} = Multiply(Multiply(this.ParseTimeframe(timeframe), 1000), 999) // 999 because there will be delay between this and the request, causing the latest candle to be excluded sometimes var startWithLimit interface{} = Subtract(this.Milliseconds(), oneThousandCandles) useHistEndpoint = IsLessThan(since, startWithLimit) } if IsTrue(useHistEndpoint) { AddElementToObject(request, "start_time", since) } else if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", mathMin(limit, 1000)) } var response interface{} = nil if !IsTrue(useHistEndpoint) { response = (<-this.V1PublicGetKline(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V1PubGetHistKline(this.Extend(request, params))) PanicOnError(response) response = this.SafeDict(response, "data") } var rows interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseOHLCVs(rows, market, timeframe, since, limit) return nil }() return ch } func (this *woo) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} { // example response in fetchOHLCV market := GetArg(optionalArgs, 0, nil) _ = market return []interface{}{this.SafeInteger(ohlcv, "start_timestamp"), this.SafeNumber(ohlcv, "open"), this.SafeNumber(ohlcv, "high"), this.SafeNumber(ohlcv, "low"), this.SafeNumber(ohlcv, "close"), this.SafeNumber(ohlcv, "volume")} } /** * @method * @name woo#fetchOrderTrades * @description fetch all the trades made from a single order * @see https://docs.woox.io/#get-trades * @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 *woo) 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 market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) } var request interface{} = map[string]interface{} { "oid": id, } response:= (<-this.V1PrivateGetOrderOidTrades(this.Extend(request, params))) PanicOnError(response) // { // "success": true, // "rows": [ // { // "id": "99111647", // "symbol": "SPOT_WOO_USDT", // "fee": "0.0024", // "side": "BUY", // "executed_timestamp": "1641482113.084", // "order_id": "87541111", // "order_tag": "default", // "executed_price": "1", // "executed_quantity": "12", // "fee_asset": "WOO", // "is_maker": "1" // } // ] // } var trades interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseTrades(trades, market, since, limit, params) return nil }() return ch } /** * @method * @name woo#fetchMyTrades * @description fetch all trades made by the user * @see https://docs.woox.io/#get-trade-history * @param {string} symbol unified market symbol * @param {int} [since] the earliest time in ms to fetch trades for * @param {int} [limit] the maximum number of trades structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.paginate] set to true if you want to fetch trades with pagination * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure} */ func (this *woo) 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 retRes20058 := (<-this.LoadMarkets()) PanicOnError(retRes20058) var paginate interface{} = false paginateparamsVariable := this.HandleOptionAndParams(params, "fetchMyTrades", "paginate"); paginate = GetValue(paginateparamsVariable,0); params = GetValue(paginateparamsVariable,1) if IsTrue(paginate) { retRes200919 := (<-this.FetchPaginatedCallIncremental("fetchMyTrades", symbol, since, limit, params, "page", 500)) PanicOnError(retRes200919) ch <- retRes200919 return nil } var request interface{} = map[string]interface{} {} var market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "symbol", GetValue(market, "id")) } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_t", since) } requestparamsVariable := this.HandleUntilOption("end_t", request, params); request = GetValue(requestparamsVariable,0); params = GetValue(requestparamsVariable,1) if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "size", limit) } else { AddElementToObject(request, "size", 500) } response:= (<-this.V1PrivateGetClientTrades(this.Extend(request, params))) PanicOnError(response) // { // "success": true, // "meta": { // "records_per_page": 25, // "current_page": 1 // }, // "rows": [ // { // "id": 5, // "symbol": "SPOT_BTC_USDT", // "order_id": 211, // "order_tag": "default", // "executed_price": 10892.84, // "executed_quantity": 0.002, // "is_maker": 0, // "side": "SELL", // "fee": 0, // "fee_asset": "USDT", // "executed_timestamp": "1566264290.250" // }, // ... // ] // } var trades interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseTrades(trades, market, since, limit, params) return nil }() return ch } /** * @method * @name woo#fetchAccounts * @description fetch all the accounts associated with a profile * @see https://docs.woox.io/#get-assets-of-subaccounts * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a dictionary of [account structures]{@link https://docs.ccxt.com/#/?id=account-structure} indexed by the account type */ func (this *woo) FetchAccounts(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params response:= (<-this.V1PrivateGetSubAccountAssets(params)) PanicOnError(response) // // { // "rows": [{ // "application_id": "13e4fc34-e2ff-4cb7-b1e4-4c22fee7d365", // "account": "Main", // "usdt_balance": "4.0" // }, // { // "application_id": "432952aa-a401-4e26-aff6-972920aebba3", // "account": "subaccount", // "usdt_balance": "1.0" // } // ], // "success": true // } // var rows interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseAccounts(rows, params) return nil }() return ch } func (this *woo) ParseAccount(account interface{}) interface{} { // // { // "application_id": "336952aa-a401-4e26-aff6-972920aebba3", // "account": "subaccount", // "usdt_balance": "1.0", // } // var accountId interface{} = this.SafeString(account, "account") return map[string]interface{} { "info": account, "id": this.SafeString(account, "application_id"), "name": accountId, "code": nil, "type": Ternary(IsTrue(IsEqual(accountId, "Main")), "main", "subaccount"), } } /** * @method * @name woo#fetchBalance * @description query for balance and get the amount of funds available for trading or funds locked in orders * @see https://docs.woox.io/#get-current-holding-get-balance-new * @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 *woo) 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 retRes21118 := (<-this.LoadMarkets()) PanicOnError(retRes21118) response:= (<-this.V3PrivateGetBalances(params)) PanicOnError(response) // // { // "success": true, // "data": { // "holding": [ // { // "token": "0_token", // "holding": 1, // "frozen": 0, // "staked": 0, // "unbonding": 0, // "vault": 0, // "interest": 0, // "pendingShortQty": 0, // "pendingLongQty": 0, // "availableBalance": 0, // "updatedTime": 312321.121 // } // ] // }, // "timestamp": 1673323746259 // } // var data interface{} = this.SafeDict(response, "data") ch <- this.ParseBalance(data) return nil }() return ch } func (this *woo) ParseBalance(response interface{}) interface{} { var result interface{} = map[string]interface{} { "info": response, } var balances interface{} = this.SafeList(response, "holding", []interface{}{}) for i := 0; IsLessThan(i, GetArrayLength(balances)); i++ { var balance interface{} = GetValue(balances, i) var code interface{} = this.SafeCurrencyCode(this.SafeString(balance, "token")) var account interface{} = this.Account() AddElementToObject(account, "total", this.SafeString(balance, "holding")) AddElementToObject(account, "free", this.SafeString(balance, "availableBalance")) AddElementToObject(result, code, account) } return this.SafeBalance(result) } /** * @method * @name woo#fetchDepositAddress * @description fetch the deposit address for a currency associated with this account * @see https://docs.woox.io/#get-token-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 *woo) FetchDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) // this method is TODO because of networks unification params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params retRes21678 := (<-this.LoadMarkets()) PanicOnError(retRes21678) var currency interface{} = this.Currency(code) var networkCodeDefault interface{} = this.DefaultNetworkCodeForCurrency(code) var networkCode interface{} = this.SafeString(params, "network", networkCodeDefault) params = this.Omit(params, "network") var codeForExchange interface{} = Add(Add(networkCode, "_"), GetValue(currency, "code")) var request interface{} = map[string]interface{} { "token": codeForExchange, } response:= (<-this.V1PrivateGetAssetDeposit(this.Extend(request, params))) PanicOnError(response) // { // "success": true, // "address": "3Jmtjx5544T4smrit9Eroe4PCrRkpDeKjP", // "extra": '' // } var tag interface{} = this.SafeString(response, "extra") var address interface{} = this.SafeString(response, "address") this.CheckAddress(address) ch <- map[string]interface{} { "info": response, "currency": code, "network": networkCode, "address": address, "tag": tag, } return nil }() return ch } func (this *woo) GetAssetHistoryRows(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 retRes21958 := (<-this.LoadMarkets()) PanicOnError(retRes21958) var request interface{} = map[string]interface{} {} var currency interface{} = nil if IsTrue(!IsEqual(code, nil)) { currency = this.Currency(code) AddElementToObject(request, "balance_token", GetValue(currency, "id")) } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_t", since) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "pageSize", limit) } var transactionType interface{} = this.SafeString(params, "type") params = this.Omit(params, "type") if IsTrue(!IsEqual(transactionType, nil)) { AddElementToObject(request, "type", transactionType) } response:= (<-this.V1PrivateGetAssetHistory(this.Extend(request, params))) PanicOnError(response) // { // "rows": [ // { // "id": "22010508193900165", // "token": "TRON_USDT", // "extra": '', // "amount": "13.75848500", // "status": "COMPLETED", // "account": null, // "description": null, // "user_id": "42222", // "application_id": "6ad2b303-f354-45c0-8105-9f5f19d0e335", // "external_id": "220105081900134", // "target_address": "TXnyFSnAYad3YCaqtwMw9jvXKkeU39NLnK", // "source_address": "TYDzsYUEpvnYmQk4zGP9sWWcTEd2MiAtW6", // "type": "BALANCE", // "token_side": "DEPOSIT", // "tx_id": "35b0004022f6b3ad07f39a0b7af199f6b258c2c3e2c7cdc93c67efa74fd625ee", // "fee_token": '', // "fee_amount": "0.00000000", // "created_time": "1641370779.442", // "updated_time": "1641370779.465", // "is_new_target_address": null, // "confirmed_number": "29", // "confirming_threshold": "27", // "audit_tag": "1", // "audit_result": "0", // "balance_token": null, // TODO -write to support, that this seems broken. here should be the token id // "network_name": null // TODO -write to support, that this seems broken. here should be the network id // } // ], // "meta": { total: '1', records_per_page: "25", current_page: "1" }, // "success": true // } ch <- []interface{}{currency, this.SafeList(response, "rows", []interface{}{})} return nil }() return ch } /** * @method * @name woo#fetchLedger * @description fetch the history of changes, actions done by the user or operations that altered balance of the user * @see https://docs.woox.io/#get-asset-history * @param {string} [code] unified currency code, default is undefined * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined * @param {int} [limit] max number of ledger entries to return, default is undefined * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger} */ func (this *woo) FetchLedger(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) code := GetArg(optionalArgs, 0, nil) _ = code since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params currencyRows:= (<-this.GetAssetHistoryRows(code, since, limit, params)) PanicOnError(currencyRows) var currency interface{} = this.SafeValue(currencyRows, 0) var rows interface{} = this.SafeList(currencyRows, 1) ch <- this.ParseLedger(rows, currency, since, limit, params) return nil }() return ch } func (this *woo) ParseLedgerEntry(item interface{}, optionalArgs ...interface{}) interface{} { currency := GetArg(optionalArgs, 0, nil) _ = currency var networkizedCode interface{} = this.SafeString(item, "token") var currencyDefined interface{} = this.GetCurrencyFromChaincode(networkizedCode, currency) var code interface{} = GetValue(currencyDefined, "code") currency = this.SafeCurrency(code, currency) var amount interface{} = this.SafeNumber(item, "amount") var side interface{} = this.SafeString(item, "token_side") var direction interface{} = Ternary(IsTrue((IsEqual(side, "DEPOSIT"))), "in", "out") var timestamp interface{} = this.SafeTimestamp(item, "created_time") var fee interface{} = this.ParseTokenAndFeeTemp(item, "fee_token", "fee_amount") return this.SafeLedgerEntry(map[string]interface{} { "info": item, "id": this.SafeString(item, "id"), "currency": code, "account": this.SafeString(item, "account"), "referenceAccount": nil, "referenceId": this.SafeString(item, "tx_id"), "status": this.ParseTransactionStatus(this.SafeString(item, "status")), "amount": amount, "before": nil, "after": nil, "direction": direction, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "type": this.ParseLedgerEntryType(this.SafeString(item, "type")), "fee": fee, }, currency) } func (this *woo) ParseLedgerEntryType(typeVar interface{}) interface{} { var types interface{} = map[string]interface{} { "BALANCE": "transaction", "COLLATERAL": "transfer", } return this.SafeString(types, typeVar, typeVar) } func (this *woo) GetCurrencyFromChaincode(networkizedCode interface{}, currency interface{}) interface{} { if IsTrue(!IsEqual(currency, nil)) { return currency } else { var parts interface{} = Split(networkizedCode, "_") var partsLength interface{} = GetArrayLength(parts) var firstPart interface{} = this.SafeString(parts, 0) var currencyId interface{} = this.SafeString(parts, 1, firstPart) if IsTrue(IsGreaterThan(partsLength, 2)) { currencyId = Add(currencyId, Add("_", this.SafeString(parts, 2))) } currency = this.SafeCurrency(currencyId) } return currency } /** * @method * @name woo#fetchDeposits * @description fetch all deposits made to an account * @see https://docs.woox.io/#get-asset-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 *woo) 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 var request interface{} = map[string]interface{} { "token_side": "DEPOSIT", } retRes233715 := (<-this.FetchDepositsWithdrawals(code, since, limit, this.Extend(request, params))) PanicOnError(retRes233715) ch <- retRes233715 return nil }() return ch } /** * @method * @name woo#fetchWithdrawals * @description fetch all withdrawals made from an account * @see https://docs.woox.io/#get-asset-history * @param {string} code unified currency code * @param {int} [since] the earliest time in ms to fetch withdrawals for * @param {int} [limit] the maximum number of withdrawals structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *woo) FetchWithdrawals(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) code := GetArg(optionalArgs, 0, nil) _ = code since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params var request interface{} = map[string]interface{} { "token_side": "WITHDRAW", } retRes235515 := (<-this.FetchDepositsWithdrawals(code, since, limit, this.Extend(request, params))) PanicOnError(retRes235515) ch <- retRes235515 return nil }() return ch } /** * @method * @name woo#fetchDepositsWithdrawals * @description fetch history of deposits and withdrawals * @see https://docs.woox.io/#get-asset-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 is undefined * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a list of [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *woo) 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 var request interface{} = map[string]interface{} { "type": "BALANCE", } currencyRows:= (<-this.GetAssetHistoryRows(code, since, limit, this.Extend(request, params))) PanicOnError(currencyRows) var currency interface{} = this.SafeValue(currencyRows, 0) var rows interface{} = this.SafeList(currencyRows, 1) // // { // "rows":[], // "meta":{ // "total":0, // "records_per_page":25, // "current_page":1 // }, // "success":true // } // ch <- this.ParseTransactions(rows, currency, since, limit, params) return nil }() return ch } func (this *woo) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} { // example in fetchLedger currency := GetArg(optionalArgs, 0, nil) _ = currency var networkizedCode interface{} = this.SafeString(transaction, "token") var currencyDefined interface{} = this.GetCurrencyFromChaincode(networkizedCode, currency) var code interface{} = GetValue(currencyDefined, "code") var movementDirection interface{} = this.SafeStringLower(transaction, "token_side") if IsTrue(IsEqual(movementDirection, "withdraw")) { movementDirection = "withdrawal" } var fee interface{} = this.ParseTokenAndFeeTemp(transaction, "fee_token", "fee_amount") var addressTo interface{} = this.SafeString(transaction, "target_address") var addressFrom interface{} = this.SafeString(transaction, "source_address") var timestamp interface{} = this.SafeTimestamp(transaction, "created_time") return map[string]interface{} { "info": transaction, "id": this.SafeString2(transaction, "id", "withdraw_id"), "txid": this.SafeString(transaction, "tx_id"), "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "address": nil, "addressFrom": addressFrom, "addressTo": addressTo, "tag": this.SafeString(transaction, "extra"), "tagFrom": nil, "tagTo": nil, "type": movementDirection, "amount": this.SafeNumber(transaction, "amount"), "currency": code, "status": this.ParseTransactionStatus(this.SafeString(transaction, "status")), "updated": this.SafeTimestamp(transaction, "updated_time"), "comment": nil, "internal": nil, "fee": fee, "network": nil, } } func (this *woo) ParseTransactionStatus(status interface{}) interface{} { var statuses interface{} = map[string]interface{} { "NEW": "pending", "CONFIRMING": "pending", "PROCESSING": "pending", "COMPLETED": "ok", "CANCELED": "canceled", } return this.SafeString(statuses, status, status) } /** * @method * @name woo#transfer * @description transfer currency internally between wallets on the same account * @see https://docs.woox.io/#get-transfer-history * @param {string} code unified currency code * @param {float} amount amount to transfer * @param {string} fromAccount account to transfer from * @param {string} toAccount account to transfer to * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure} */ func (this *woo) 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 retRes24518 := (<-this.LoadMarkets()) PanicOnError(retRes24518) var currency interface{} = this.Currency(code) var request interface{} = map[string]interface{} { "token": GetValue(currency, "id"), "amount": this.ParseToNumeric(amount), "from_application_id": fromAccount, "to_application_id": toAccount, } response:= (<-this.V1PrivatePostAssetMainSubTransfer(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "id": 200 // } // var transfer interface{} = this.ParseTransfer(response, currency) var transferOptions interface{} = this.SafeDict(this.Options, "transfer", map[string]interface{} {}) var fillResponseFromRequest interface{} = this.SafeBool(transferOptions, "fillResponseFromRequest", true) if IsTrue(fillResponseFromRequest) { AddElementToObject(transfer, "amount", amount) AddElementToObject(transfer, "fromAccount", fromAccount) AddElementToObject(transfer, "toAccount", toAccount) } ch <- transfer return nil }() return ch } /** * @method * @name woo#fetchTransfers * @description fetch a history of internal transfers made on an account * @see https://docs.woox.io/#get-transfer-history * @param {string} code unified currency code of the currency transferred * @param {int} [since] the earliest time in ms to fetch transfers for * @param {int} [limit] the maximum number of transfers structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {int} [params.until] the latest time in ms to fetch entries for * @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure} */ func (this *woo) FetchTransfers(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) code := GetArg(optionalArgs, 0, nil) _ = code since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "size", limit) } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_t", since) } var until interface{} = this.SafeInteger(params, "until") // unified in milliseconds params = this.Omit(params, []interface{}{"until"}) if IsTrue(!IsEqual(until, nil)) { AddElementToObject(request, "end_t", until) } response:= (<-this.V1PrivateGetAssetMainSubTransferHistory(this.Extend(request, params))) PanicOnError(response) // // { // "rows": [ // { // "id": 46704, // "token": "USDT", // "amount": 30000.00000000, // "status": "COMPLETED", // "from_application_id": "0f1bd3cd-dba2-4563-b8bb-0adb1bfb83a3", // "to_application_id": "c01e6940-a735-4022-9b6c-9d3971cdfdfa", // "from_user": "LeverageLow", // "to_user": "dev", // "created_time": "1709022325.427", // "updated_time": "1709022325.542" // } // ], // "meta": { // "total": 50, // "records_per_page": 25, // "current_page": 1 // }, // "success": true // } // var data interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseTransfers(data, nil, since, limit, params) return nil }() return ch } func (this *woo) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} { // // fetchTransfers // { // "id": 46704, // "token": "USDT", // "amount": 30000.00000000, // "status": "COMPLETED", // "from_application_id": "0f1bd3cd-dba2-4563-b8bb-0adb1bfb83a3", // "to_application_id": "c01e6940-a735-4022-9b6c-9d3971cdfdfa", // "from_user": "LeverageLow", // "to_user": "dev", // "created_time": "1709022325.427", // "updated_time": "1709022325.542" // } // // transfer // { // "success": true, // "id": 200 // } // currency := GetArg(optionalArgs, 0, nil) _ = currency var networkizedCode interface{} = this.SafeString(transfer, "token") var currencyDefined interface{} = this.GetCurrencyFromChaincode(networkizedCode, currency) var code interface{} = GetValue(currencyDefined, "code") var timestamp interface{} = this.SafeTimestamp(transfer, "created_time") var success interface{} = this.SafeBool(transfer, "success") var status interface{} = nil if IsTrue(!IsEqual(success, nil)) { status = Ternary(IsTrue(success), "ok", "failed") } return map[string]interface{} { "id": this.SafeString(transfer, "id"), "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "currency": code, "amount": this.SafeNumber(transfer, "amount"), "fromAccount": this.SafeString(transfer, "from_application_id"), "toAccount": this.SafeString(transfer, "to_application_id"), "status": this.ParseTransferStatus(this.SafeString(transfer, "status", status)), "info": transfer, } } func (this *woo) ParseTransferStatus(status interface{}) interface{} { var statuses interface{} = map[string]interface{} { "NEW": "pending", "CONFIRMING": "pending", "PROCESSING": "pending", "COMPLETED": "ok", "CANCELED": "canceled", } return this.SafeString(statuses, status, status) } /** * @method * @name woo#withdraw * @description make a withdrawal * @see https://docs.woox.io/#token-withdraw * @param {string} code unified currency code * @param {float} amount the amount to withdraw * @param {string} address the address to withdraw to * @param {string} tag * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *woo) Withdraw(code interface{}, amount interface{}, address interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) tag := GetArg(optionalArgs, 0, nil) _ = tag params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params tagparamsVariable := this.HandleWithdrawTagAndParams(tag, params); tag = GetValue(tagparamsVariable,0); params = GetValue(tagparamsVariable,1) retRes26008 := (<-this.LoadMarkets()) PanicOnError(retRes26008) this.CheckAddress(address) var currency interface{} = this.Currency(code) var request interface{} = map[string]interface{} { "amount": amount, "address": address, } if IsTrue(!IsEqual(tag, nil)) { AddElementToObject(request, "extra", tag) } var networks interface{} = this.SafeDict(this.Options, "networks", map[string]interface{} {}) var currencyNetworks interface{} = this.SafeDict(currency, "networks", map[string]interface{} {}) var network interface{} = this.SafeStringUpper(params, "network") var networkId interface{} = this.SafeString(networks, network, network) var coinNetwork interface{} = this.SafeDict(currencyNetworks, networkId, map[string]interface{} {}) var coinNetworkId interface{} = this.SafeString(coinNetwork, "id") if IsTrue(IsEqual(coinNetworkId, nil)) { panic(BadRequest(Add(this.Id, " withdraw() require network parameter"))) } AddElementToObject(request, "token", coinNetworkId) response:= (<-this.V1PrivatePostAssetWithdraw(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "withdraw_id": "20200119145703654" // } // ch <- this.ParseTransaction(response, currency) return nil }() return ch } /** * @method * @name woo#repayMargin * @description repay borrowed margin and interest * @see https://docs.woox.io/#repay-interest * @param {string} code unified currency code of the currency to repay * @param {float} amount the amount to repay * @param {string} symbol not used by woo.repayMargin () * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [margin loan structure]{@link https://docs.ccxt.com/#/?id=margin-loan-structure} */ func (this *woo) RepayMargin(code interface{}, amount 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 retRes26428 := (<-this.LoadMarkets()) PanicOnError(retRes26428) var market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) symbol = GetValue(market, "symbol") } var currency interface{} = this.Currency(code) var request interface{} = map[string]interface{} { "token": GetValue(currency, "id"), "amount": this.CurrencyToPrecision(code, amount), } response:= (<-this.V1PrivatePostInterestRepay(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // } // var transaction interface{} = this.ParseMarginLoan(response, currency) ch <- this.Extend(transaction, map[string]interface{} { "amount": amount, "symbol": symbol, }) return nil }() return ch } func (this *woo) ParseMarginLoan(info interface{}, optionalArgs ...interface{}) interface{} { // // { // "success": true, // } // currency := GetArg(optionalArgs, 0, nil) _ = currency return map[string]interface{} { "id": nil, "currency": this.SafeCurrencyCode(nil, currency), "amount": nil, "symbol": nil, "timestamp": nil, "datetime": nil, "info": info, } } func (this *woo) Nonce() interface{} { return Subtract(this.Milliseconds(), GetValue(this.Options, "timeDifference")) } func (this *woo) Sign(path interface{}, optionalArgs ...interface{}) interface{} { section := GetArg(optionalArgs, 0, "public") _ = section method := GetArg(optionalArgs, 1, "GET") _ = method params := GetArg(optionalArgs, 2, map[string]interface{} {}) _ = params headers := GetArg(optionalArgs, 3, nil) _ = headers body := GetArg(optionalArgs, 4, nil) _ = body var version interface{} = GetValue(section, 0) var access interface{} = GetValue(section, 1) var pathWithParams interface{} = this.ImplodeParams(path, params) var url interface{} = this.ImplodeHostname(GetValue(GetValue(this.Urls, "api"), access)) url = Add(url, Add(Add("/", version), "/")) params = this.Omit(params, this.ExtractParams(path)) params = this.Keysort(params) if IsTrue(IsEqual(access, "public")) { url = Add(url, Add(Add(access, "/"), pathWithParams)) if IsTrue(GetArrayLength(ObjectKeys(params))) { url = Add(url, Add("?", this.Urlencode(params))) } } else if IsTrue(IsEqual(access, "pub")) { url = Add(url, pathWithParams) if IsTrue(GetArrayLength(ObjectKeys(params))) { url = Add(url, Add("?", this.Urlencode(params))) } } else { this.CheckRequiredCredentials() if IsTrue(IsTrue(IsEqual(method, "POST")) && IsTrue((IsTrue(IsEqual(path, "algo/order")) || IsTrue(IsEqual(path, "order"))))) { var isSandboxMode interface{} = this.SafeBool(this.Options, "sandboxMode", false) if !IsTrue(isSandboxMode) { var applicationId interface{} = "bc830de7-50f3-460b-9ee0-f430f83f9dad" var brokerId interface{} = this.SafeString(this.Options, "brokerId", applicationId) var isTrigger interface{} = IsGreaterThan(GetIndexOf(path, "algo"), OpNeg(1)) if IsTrue(isTrigger) { AddElementToObject(params, "brokerId", brokerId) } else { AddElementToObject(params, "broker_id", brokerId) } } params = this.Keysort(params) } var auth interface{} = "" var ts interface{} = ToString(this.Nonce()) url = Add(url, pathWithParams) headers = map[string]interface{} { "x-api-key": this.ApiKey, "x-api-timestamp": ts, } if IsTrue(IsEqual(version, "v3")) { auth = Add(Add(Add(Add(Add(ts, method), "/"), version), "/"), pathWithParams) if IsTrue(IsTrue(IsTrue(IsEqual(method, "POST")) || IsTrue(IsEqual(method, "PUT"))) || IsTrue(IsEqual(method, "DELETE"))) { body = this.Json(params) auth = Add(auth, body) } else { if IsTrue(GetArrayLength(ObjectKeys(params))) { var query interface{} = this.Urlencode(params) url = Add(url, Add("?", query)) auth = Add(auth, Add("?", query)) } } AddElementToObject(headers, "content-type", "application/json") } else { auth = this.Urlencode(params) if IsTrue(IsTrue(IsTrue(IsEqual(method, "POST")) || IsTrue(IsEqual(method, "PUT"))) || IsTrue(IsEqual(method, "DELETE"))) { body = auth } else { if IsTrue(GetArrayLength(ObjectKeys(params))) { url = Add(url, Add("?", auth)) } } auth = Add(auth, Add("|", ts)) AddElementToObject(headers, "content-type", "application/x-www-form-urlencoded") } AddElementToObject(headers, "x-api-signature", this.Hmac(this.Encode(auth), this.Encode(this.Secret), sha256)) } return map[string]interface{} { "url": url, "method": method, "body": body, "headers": headers, } } func (this *woo) HandleErrors(httpCode interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} { if !IsTrue(response) { return nil // fallback to default error handler } // // 400 Bad Request {"success":false,"code":-1012,"message":"Amount is required for buy market orders when margin disabled."} // {"code":"-1011","message":"The system is under maintenance.","success":false} // var success interface{} = this.SafeBool(response, "success") var errorCode interface{} = this.SafeString(response, "code") if !IsTrue(success) { var feedback interface{} = Add(Add(this.Id, " "), this.Json(response)) this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), body, feedback) this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), errorCode, feedback) } return nil } func (this *woo) ParseIncome(income interface{}, optionalArgs ...interface{}) interface{} { // // { // "id":666666, // "symbol":"PERP_BTC_USDT", // "funding_rate":0.00001198, // "mark_price":28941.04000000, // "funding_fee":0.00069343, // "payment_type":"Pay", // "status":"COMPLETED", // "created_time":"1653616000.666", // "updated_time":"1653616000.605" // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(income, "symbol") var symbol interface{} = this.SafeSymbol(marketId, market) var amount interface{} = this.SafeString(income, "funding_fee") var code interface{} = this.SafeCurrencyCode("USD") var id interface{} = this.SafeString(income, "id") var timestamp interface{} = this.SafeTimestamp(income, "updated_time") var rate interface{} = this.SafeNumber(income, "funding_rate") var paymentType interface{} = this.SafeString(income, "payment_type") amount = Ternary(IsTrue((IsEqual(paymentType, "Pay"))), Precise.StringNeg(amount), amount) return map[string]interface{} { "info": income, "symbol": symbol, "code": code, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "id": id, "amount": this.ParseNumber(amount), "rate": rate, } } /** * @method * @name woo#fetchFundingHistory * @description fetch the history of funding payments paid and received on this account * @see https://docs.woox.io/#get-funding-fee-history * @param {string} [symbol] unified market symbol * @param {int} [since] the earliest time in ms to fetch funding history for * @param {int} [limit] the maximum number of funding history structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params) * @returns {object} a [funding history structure]{@link https://docs.ccxt.com/#/?id=funding-history-structure} */ func (this *woo) FetchFundingHistory(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 retRes28248 := (<-this.LoadMarkets()) PanicOnError(retRes28248) var paginate interface{} = false paginateparamsVariable := this.HandleOptionAndParams(params, "fetchFundingHistory", "paginate"); paginate = GetValue(paginateparamsVariable,0); params = GetValue(paginateparamsVariable,1) if IsTrue(paginate) { retRes282819 := (<-this.FetchPaginatedCallCursor("fetchFundingHistory", symbol, since, limit, params, "page", "page", 1, 500)) PanicOnError(retRes282819) ch <- retRes282819 return nil } var request interface{} = map[string]interface{} {} var market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "symbol", GetValue(market, "id")) } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_t", since) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "size", limit) } else { AddElementToObject(request, "size", 5000) } response:= (<-this.V1PrivateGetFundingFeeHistory(this.Extend(request, params))) PanicOnError(response) // // { // "rows":[ // { // "id":666666, // "symbol":"PERP_BTC_USDT", // "funding_rate":0.00001198, // "mark_price":28941.04000000, // "funding_fee":0.00069343, // "payment_type":"Pay", // "status":"COMPLETED", // "created_time":"1653616000.666", // "updated_time":"1653616000.605" // } // ], // "meta":{ // "total":235, // "records_per_page":25, // "current_page":1 // }, // "success":true // } // var meta interface{} = this.SafeDict(response, "meta", map[string]interface{} {}) var cursor interface{} = this.SafeInteger(meta, "current_page") var result interface{} = this.SafeList(response, "rows", []interface{}{}) var resultLength interface{} = GetArrayLength(result) if IsTrue(IsGreaterThan(resultLength, 0)) { var lastItem interface{} = GetValue(result, Subtract(resultLength, 1)) AddElementToObject(lastItem, "page", cursor) AddElementToObject(result, Subtract(resultLength, 1), lastItem) } ch <- this.ParseIncomes(result, market, since, limit) return nil }() return ch } func (this *woo) ParseFundingRate(fundingRate interface{}, optionalArgs ...interface{}) interface{} { // // { // "success": true, // "timestamp": 1727427915529, // "symbol": "PERP_BTC_USDT", // "est_funding_rate": -0.00092719, // "est_funding_rate_timestamp": 1727427899060, // "last_funding_rate": -0.00092610, // "last_funding_rate_timestamp": 1727424000000, // "next_funding_time": 1727452800000, // "last_funding_rate_interval": 8, // "est_funding_rate_interval": 8 // } // market := GetArg(optionalArgs, 0, nil) _ = market var symbol interface{} = this.SafeString(fundingRate, "symbol") market = this.Market(symbol) var nextFundingTimestamp interface{} = this.SafeInteger(fundingRate, "next_funding_time") var estFundingRateTimestamp interface{} = this.SafeInteger(fundingRate, "est_funding_rate_timestamp") var lastFundingRateTimestamp interface{} = this.SafeInteger(fundingRate, "last_funding_rate_timestamp") var intervalString interface{} = this.SafeString(fundingRate, "est_funding_rate_interval") return map[string]interface{} { "info": fundingRate, "symbol": GetValue(market, "symbol"), "markPrice": nil, "indexPrice": nil, "interestRate": this.ParseNumber("0"), "estimatedSettlePrice": nil, "timestamp": estFundingRateTimestamp, "datetime": this.Iso8601(estFundingRateTimestamp), "fundingRate": this.SafeNumber(fundingRate, "est_funding_rate"), "fundingTimestamp": nextFundingTimestamp, "fundingDatetime": this.Iso8601(nextFundingTimestamp), "nextFundingRate": nil, "nextFundingTimestamp": nil, "nextFundingDatetime": nil, "previousFundingRate": this.SafeNumber(fundingRate, "last_funding_rate"), "previousFundingTimestamp": lastFundingRateTimestamp, "previousFundingDatetime": this.Iso8601(lastFundingRateTimestamp), "interval": Add(intervalString, "h"), } } /** * @method * @name woo#fetchFundingInterval * @description fetch the current funding rate interval * @see https://docs.woox.io/#get-predicted-funding-rate-for-one-market-public * @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 *woo) FetchFundingInterval(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 retRes293315 := (<-this.FetchFundingRate(symbol, params)) PanicOnError(retRes293315) ch <- retRes293315 return nil }() return ch } /** * @method * @name woo#fetchFundingRate * @description fetch the current funding rate * @see https://docs.woox.io/#get-predicted-funding-rate-for-one-market-public * @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 *woo) 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 retRes29468 := (<-this.LoadMarkets()) PanicOnError(retRes29468) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } response:= (<-this.V1PublicGetFundingRateSymbol(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "timestamp": 1727428037877, // "symbol": "PERP_BTC_USDT", // "est_funding_rate": -0.00092674, // "est_funding_rate_timestamp": 1727428019064, // "last_funding_rate": -0.00092610, // "last_funding_rate_timestamp": 1727424000000, // "next_funding_time": 1727452800000, // "last_funding_rate_interval": 8, // "est_funding_rate_interval": 8 // } // ch <- this.ParseFundingRate(response, market) return nil }() return ch } /** * @method * @name woo#fetchFundingRates * @description fetch the funding rate for multiple markets * @see https://docs.woox.io/#get-predicted-funding-rate-for-all-markets-public * @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 *woo) 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 retRes29798 := (<-this.LoadMarkets()) PanicOnError(retRes29798) symbols = this.MarketSymbols(symbols) response:= (<-this.V1PublicGetFundingRates(params)) PanicOnError(response) // // { // "success":true, // "rows":[ // { // "symbol":"PERP_AAVE_USDT", // "est_funding_rate":-0.00003447, // "est_funding_rate_timestamp":1653633959001, // "last_funding_rate":-0.00002094, // "last_funding_rate_timestamp":1653631200000, // "next_funding_time":1653634800000 // } // ], // "timestamp":1653633985646 // } // var rows interface{} = this.SafeList(response, "rows", []interface{}{}) ch <- this.ParseFundingRates(rows, symbols) return nil }() return ch } /** * @method * @name woo#fetchFundingRateHistory * @description fetches historical funding rate prices * @see https://docs.woox.io/#get-funding-rate-history-for-one-market-public * @param {string} symbol unified symbol of the market to fetch the funding rate history for * @param {int} [since] timestamp in ms of the earliest funding rate to fetch * @param {int} [limit] the maximum amount of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure} to fetch * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {int} [params.until] timestamp in ms of the latest funding rate * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params) * @returns {object[]} a list of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure} */ func (this *woo) FetchFundingRateHistory(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbol := GetArg(optionalArgs, 0, nil) _ = symbol since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params retRes30168 := (<-this.LoadMarkets()) PanicOnError(retRes30168) var paginate interface{} = false paginateparamsVariable := this.HandleOptionAndParams(params, "fetchFundingRateHistory", "paginate"); paginate = GetValue(paginateparamsVariable,0); params = GetValue(paginateparamsVariable,1) if IsTrue(paginate) { retRes302019 := (<-this.FetchPaginatedCallIncremental("fetchFundingRateHistory", symbol, since, limit, params, "page", 25)) PanicOnError(retRes302019) ch <- retRes302019 return nil } var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(symbol, nil)) { var market interface{} = this.Market(symbol) symbol = GetValue(market, "symbol") AddElementToObject(request, "symbol", GetValue(market, "id")) } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_t", this.ParseToInt(Divide(since, 1000))) } requestparamsVariable := this.HandleUntilOption("end_t", request, params, 0.001); request = GetValue(requestparamsVariable,0); params = GetValue(requestparamsVariable,1) response:= (<-this.V1PublicGetFundingRateHistory(this.Extend(request, params))) PanicOnError(response) // // { // "success":true, // "meta":{ // "total":2464, // "records_per_page":25, // "current_page":1 // }, // "rows":[ // { // "symbol":"PERP_BTC_USDT", // "funding_rate":0.00000629, // "funding_rate_timestamp":1653638400000, // "next_funding_time":1653642000000 // } // ], // "timestamp":1653640814885 // } // var result interface{} = this.SafeList(response, "rows") var rates interface{} = []interface{}{} for i := 0; IsLessThan(i, GetArrayLength(result)); i++ { var entry interface{} = GetValue(result, i) var marketId interface{} = this.SafeString(entry, "symbol") var timestamp interface{} = this.SafeInteger(entry, "funding_rate_timestamp") AppendToArray(&rates,map[string]interface{} { "info": entry, "symbol": this.SafeSymbol(marketId), "fundingRate": this.SafeNumber(entry, "funding_rate"), "timestamp": timestamp, "datetime": this.Iso8601(timestamp), }) } var sorted interface{} = this.SortBy(rates, "timestamp") ch <- this.FilterBySymbolSinceLimit(sorted, symbol, since, limit) return nil }() return ch } /** * @method * @name woo#setPositionMode * @description set hedged to true or false for a market * @see https://docs.woox.io/#update-position-mode * @param {bool} hedged set to true to use HEDGE_MODE, false for ONE_WAY * @param {string} symbol not used by woo setPositionMode * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} response from the exchange */ func (this *woo) SetPositionMode(hedged interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbol := GetArg(optionalArgs, 0, nil) _ = symbol params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params var hedgeMode interface{} = nil if IsTrue(hedged) { hedgeMode = "HEDGE_MODE" } else { hedgeMode = "ONE_WAY" } var request interface{} = map[string]interface{} { "position_mode": hedgeMode, } response:= (<-this.V1PrivatePostClientPositionMode(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "data": {}, // "timestamp": "1709195608551" // } // ch <- response return nil }() return ch } /** * @method * @name woo#fetchLeverage * @description fetch the set leverage for a market * @see https://docs.woox.io/#get-account-information-new * @param {string} symbol unified market symbol * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.marginMode] *for swap markets only* 'cross' or 'isolated' * @param {string} [params.position_mode] *for swap markets only* 'ONE_WAY' or 'HEDGE_MODE' * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure} */ func (this *woo) FetchLeverage(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params retRes31138 := (<-this.LoadMarkets()) PanicOnError(retRes31138) var market interface{} = this.Market(symbol) var response interface{} = nil if IsTrue(GetValue(market, "spot")) { response = (<-this.V3PrivateGetAccountinfo(params)) PanicOnError(response) } else if IsTrue(GetValue(market, "swap")) { var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } var marginMode interface{} = nil marginModeparamsVariable := this.HandleMarginModeAndParams("fetchLeverage", params, "cross"); marginMode = GetValue(marginModeparamsVariable,0); params = GetValue(marginModeparamsVariable,1) AddElementToObject(request, "margin_mode", this.EncodeMarginMode(marginMode)) response = (<-this.V1PrivateGetClientFuturesLeverage(this.Extend(request, params))) PanicOnError(response) } else { panic(NotSupported(Add(Add(Add(this.Id, " fetchLeverage() is not supported for "), GetValue(market, "type")), " markets"))) } var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) ch <- this.ParseLeverage(data, market) return nil }() return ch } func (this *woo) ParseLeverage(leverage interface{}, optionalArgs ...interface{}) interface{} { market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(leverage, "symbol") market = this.SafeMarket(marketId, market) var marginMode interface{} = this.SafeStringLower(leverage, "default_margin_mode") var spotLeverage interface{} = this.SafeInteger(leverage, "leverage") var longLeverage interface{} = spotLeverage var shortLeverage interface{} = spotLeverage var details interface{} = this.SafeList(leverage, "details", []interface{}{}) for i := 0; IsLessThan(i, GetArrayLength(details)); i++ { var position interface{} = this.SafeDict(details, i, map[string]interface{} {}) var positionLeverage interface{} = this.SafeInteger(position, "leverage") var side interface{} = this.SafeString(position, "position_side") if IsTrue(IsEqual(side, "BOTH")) { longLeverage = positionLeverage shortLeverage = positionLeverage } else if IsTrue(IsEqual(side, "LONG")) { longLeverage = positionLeverage } else if IsTrue(IsEqual(side, "SHORT")) { shortLeverage = positionLeverage } } return map[string]interface{} { "info": leverage, "symbol": GetValue(market, "symbol"), "marginMode": marginMode, "longLeverage": longLeverage, "shortLeverage": shortLeverage, } } /** * @method * @name woo#setLeverage * @description set the level of leverage for a market * @see https://docs.woox.io/#update-leverage-setting * @see https://docs.woox.io/#update-futures-leverage-setting * @param {float} leverage the rate of leverage (1, 2, 3, 4 or 5 for spot markets, 1, 2, 3, 4, 5, 10, 15, 20 for swap markets) * @param {string} [symbol] unified market symbol (is mandatory for swap markets) * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.marginMode] *for swap markets only* 'cross' or 'isolated' * @param {string} [params.position_side] *for swap markets only* 'LONG' or 'SHORT' in hedge mode, 'BOTH' in one way mode. * @returns {object} response from the exchange */ func (this *woo) 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 retRes32458 := (<-this.LoadMarkets()) PanicOnError(retRes32458) var request interface{} = map[string]interface{} { "leverage": leverage, } var market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) } if IsTrue(IsTrue((IsEqual(symbol, nil))) || IsTrue(GetValue(market, "spot"))) { retRes325419 := (<-this.V1PrivatePostClientLeverage(this.Extend(request, params))) PanicOnError(retRes325419) ch <- retRes325419 return nil } else if IsTrue(GetValue(market, "swap")) { AddElementToObject(request, "symbol", GetValue(market, "id")) var marginMode interface{} = nil marginModeparamsVariable := this.HandleMarginModeAndParams("fetchLeverage", params, "cross"); marginMode = GetValue(marginModeparamsVariable,0); params = GetValue(marginModeparamsVariable,1) AddElementToObject(request, "margin_mode", this.EncodeMarginMode(marginMode)) retRes326019 := (<-this.V1PrivatePostClientFuturesLeverage(this.Extend(request, params))) PanicOnError(retRes326019) ch <- retRes326019 return nil } else { panic(NotSupported(Add(Add(Add(this.Id, " fetchLeverage() is not supported for "), GetValue(market, "type")), " markets"))) } return nil }() return ch } /** * @method * @name woo#addMargin * @description add margin * @see https://docs.woox.io/#update-isolated-margin-setting * @param {string} symbol unified market symbol * @param {float} amount amount of margin to add * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.position_side] 'LONG' or 'SHORT' in hedge mode, 'BOTH' in one way mode * @returns {object} a [margin structure]{@link https://docs.ccxt.com/#/?id=add-margin-structure} */ func (this *woo) AddMargin(symbol interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params retRes327815 := (<-this.ModifyMarginHelper(symbol, amount, "ADD", params)) PanicOnError(retRes327815) ch <- retRes327815 return nil }() return ch } /** * @method * @name woo#reduceMargin * @description remove margin from a position * @see https://docs.woox.io/#update-isolated-margin-setting * @param {string} symbol unified market symbol * @param {float} amount amount of margin to remove * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.position_side] 'LONG' or 'SHORT' in hedge mode, 'BOTH' in one way mode * @returns {object} a [margin structure]{@link https://docs.ccxt.com/#/?id=reduce-margin-structure} */ func (this *woo) ReduceMargin(symbol interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params retRes329315 := (<-this.ModifyMarginHelper(symbol, amount, "REDUCE", params)) PanicOnError(retRes329315) ch <- retRes329315 return nil }() return ch } func (this *woo) ModifyMarginHelper(symbol interface{}, amount interface{}, typeVar 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 retRes32978 := (<-this.LoadMarkets()) PanicOnError(retRes32978) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), "adjust_token": "USDT", "adjust_amount": amount, "action": typeVar, } retRes330515 := (<-this.V1PrivatePostClientIsolatedMargin(this.Extend(request, params))) PanicOnError(retRes330515) ch <- retRes330515 return nil }() return ch } func (this *woo) FetchPosition(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params retRes33098 := (<-this.LoadMarkets()) PanicOnError(retRes33098) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } response:= (<-this.V1PrivateGetPositionSymbol(this.Extend(request, params))) PanicOnError(response) // // { // "symbol": "PERP_ETH_USDT", // "position_side": "BOTH", // "leverage": 10, // "margin_mode": "CROSS", // "average_open_price": 3139.9, // "isolated_margin_amount": 0.0, // "isolated_margin_token": "", // "opening_time": "1720627963.094", // "mark_price": 3155.19169891, // "pending_short_qty": 0.0, // "pending_long_qty": 0.0, // "holding": -0.7, // "pnl_24_h": 0.0, // "est_liq_price": 9107.40055552, // "settle_price": 3151.0319904, // "success": true, // "fee_24_h": 0.0, // "isolated_frozen_long": 0.0, // "isolated_frozen_short": 0.0, // "timestamp": "1720867502.544" // } // ch <- this.ParsePosition(response, market) return nil }() return ch } func (this *woo) FetchPositions(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbols := GetArg(optionalArgs, 0, nil) _ = symbols params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params retRes33438 := (<-this.LoadMarkets()) PanicOnError(retRes33438) response:= (<-this.V3PrivateGetPositions(params)) PanicOnError(response) // // { // "success": true, // "data": // { // "positions": [ // { // "symbol": "PERP_ETH_USDT", // "holding": -1.0, // "pendingLongQty": 0.0, // "pendingShortQty": 0.0, // "settlePrice": 3143.2, // "averageOpenPrice": 3143.2, // "pnl24H": 0.0, // "fee24H": 1.5716, // "markPrice": 3134.97984158, // "estLiqPrice": 3436.176349, // "timestamp": 1720628031.463, // "adlQuantile": 5, // "positionSide": "BOTH", // "marginMode": "ISOLATED", // "isolatedMarginToken": "USDT", // "isolatedMarginAmount": 314.62426, // "isolatedFrozenLong": 0.0, // "isolatedFrozenShort": 0.0, // "leverage": 10 // }, // { // "symbol": "PERP_SOL_USDT", // "holding": -1.0, // "pendingLongQty": 0.0, // "pendingShortQty": 0.0, // "settlePrice": 141.89933923, // "averageOpenPrice": 171.38, // "pnl24H": 0.0, // "fee24H": 0.0, // "markPrice": 141.65155427, // "estLiqPrice": 4242.73548551, // "timestamp": 1720616702.68, // "adlQuantile": 5, // "positionSide": "BOTH", // "marginMode": "CROSS", // "isolatedMarginToken": "", // "isolatedMarginAmount": 0.0, // "isolatedFrozenLong": 0.0, // "isolatedFrozenShort": 0.0, // "leverage": 10 // } // ] // }, // "timestamp": 1720628675078 // } // var result interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var positions interface{} = this.SafeList(result, "positions", []interface{}{}) ch <- this.ParsePositions(positions, symbols) return nil }() return ch } func (this *woo) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{} { // // v1PrivateGetPositionSymbol // { // "symbol": "PERP_ETH_USDT", // "position_side": "BOTH", // "leverage": 10, // "margin_mode": "CROSS", // "average_open_price": 3139.9, // "isolated_margin_amount": 0.0, // "isolated_margin_token": "", // "opening_time": "1720627963.094", // "mark_price": 3155.19169891, // "pending_short_qty": 0.0, // "pending_long_qty": 0.0, // "holding": -0.7, // "pnl_24_h": 0.0, // "est_liq_price": 9107.40055552, // "settle_price": 3151.0319904, // "success": true, // "fee_24_h": 0.0, // "isolated_frozen_long": 0.0, // "isolated_frozen_short": 0.0, // "timestamp": "1720867502.544" // } // // v3PrivateGetPositions // { // "symbol": "PERP_ETH_USDT", // "holding": -1.0, // "pendingLongQty": 0.0, // todo: check // "pendingShortQty": 0.0, // todo: check // "settlePrice": 3143.2, // "averageOpenPrice": 3143.2, // "pnl24H": 0.0, // todo: check // "fee24H": 1.5716, // todo: check // "markPrice": 3134.97984158, // "estLiqPrice": 3436.176349, // "timestamp": 1720628031.463, // "adlQuantile": 5, // "positionSide": "BOTH", // "marginMode": "ISOLATED", // "isolatedMarginToken": "USDT", // todo: check // "isolatedMarginAmount": 314.62426, // todo: check // "isolatedFrozenLong": 0.0, // todo: check // "isolatedFrozenShort": 0.0, // todo: check // "leverage": 10 // } // market := GetArg(optionalArgs, 0, nil) _ = market var contract interface{} = this.SafeString(position, "symbol") market = this.SafeMarket(contract, market) var size interface{} = this.SafeString(position, "holding") var side interface{} = nil if IsTrue(Precise.StringGt(size, "0")) { side = "long" } else { side = "short" } var contractSize interface{} = this.SafeString(market, "contractSize") var markPrice interface{} = this.SafeString2(position, "markPrice", "mark_price") var timestamp interface{} = this.SafeTimestamp(position, "timestamp") var entryPrice interface{} = this.SafeString2(position, "averageOpenPrice", "average_open_price") var priceDifference interface{} = Precise.StringSub(markPrice, entryPrice) var unrealisedPnl interface{} = Precise.StringMul(priceDifference, size) size = Precise.StringAbs(size) var notional interface{} = Precise.StringMul(size, markPrice) var positionSide interface{} = this.SafeString(position, "positionSide") // 'SHORT' or 'LONG' for hedged, 'BOTH' for non-hedged return this.SafePosition(map[string]interface{} { "info": position, "id": nil, "symbol": this.SafeString(market, "symbol"), "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "lastUpdateTimestamp": nil, "initialMargin": nil, "initialMarginPercentage": nil, "maintenanceMargin": nil, "maintenanceMarginPercentage": nil, "entryPrice": this.ParseNumber(entryPrice), "notional": this.ParseNumber(notional), "leverage": this.SafeNumber(position, "leverage"), "unrealizedPnl": this.ParseNumber(unrealisedPnl), "contracts": this.ParseNumber(size), "contractSize": this.ParseNumber(contractSize), "marginRatio": nil, "liquidationPrice": this.SafeNumber2(position, "estLiqPrice", "est_liq_price"), "markPrice": this.ParseNumber(markPrice), "lastPrice": nil, "collateral": nil, "marginMode": this.SafeStringLower2(position, "marginMode", "margin_mode"), "side": side, "percentage": nil, "hedged": !IsEqual(positionSide, "BOTH"), "stopLossPrice": nil, "takeProfitPrice": nil, }) } /** * @method * @name woo#fetchConvertQuote * @description fetch a quote for converting from one currency to another * @see https://docs.woox.io/#get-quote-rfq * @param {string} fromCode the currency that you want to sell and convert from * @param {string} toCode the currency that you want to buy and convert into * @param {float} [amount] how much you want to trade in units of the from currency * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [conversion structure]{@link https://docs.ccxt.com/#/?id=conversion-structure} */ func (this *woo) FetchConvertQuote(fromCode interface{}, toCode interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) amount := GetArg(optionalArgs, 0, nil) _ = amount params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params retRes35138 := (<-this.LoadMarkets()) PanicOnError(retRes35138) var request interface{} = map[string]interface{} { "sellToken": ToUpper(fromCode), "buyToken": ToUpper(toCode), "sellQuantity": this.NumberToString(amount), } response:= (<-this.V3PrivateGetConvertRfq(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "data": { // "quoteId": 123123123, // "counterPartyId": "", // "sellToken": "ETH", // "sellQuantity": "0.0445", // "buyToken": "USDT", // "buyQuantity": "33.45", // "buyPrice": "6.77", // "expireTimestamp": 1659084466000, // "message": 1659084466000 // } // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var fromCurrencyId interface{} = this.SafeString(data, "sellToken", fromCode) var fromCurrency interface{} = this.Currency(fromCurrencyId) var toCurrencyId interface{} = this.SafeString(data, "buyToken", toCode) var toCurrency interface{} = this.Currency(toCurrencyId) ch <- this.ParseConversion(data, fromCurrency, toCurrency) return nil }() return ch } /** * @method * @name woo#createConvertTrade * @description convert from one currency to another * @see https://docs.woox.io/#send-quote-rft * @param {string} id the id of the trade that you want to make * @param {string} fromCode the currency that you want to sell and convert from * @param {string} toCode the currency that you want to buy and convert into * @param {float} [amount] how much you want to trade in units of the from currency * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [conversion structure]{@link https://docs.ccxt.com/#/?id=conversion-structure} */ func (this *woo) CreateConvertTrade(id interface{}, fromCode interface{}, toCode interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) amount := GetArg(optionalArgs, 0, nil) _ = amount params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params retRes35578 := (<-this.LoadMarkets()) PanicOnError(retRes35578) var request interface{} = map[string]interface{} { "quoteId": id, } response:= (<-this.V3PrivatePostConvertRft(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "data": { // "quoteId": 123123123, // "counterPartyId": "", // "rftAccepted": 1 // 1 -> success; 2 -> processing; 3 -> fail // } // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) ch <- this.ParseConversion(data) return nil }() return ch } /** * @method * @name woo#fetchConvertTrade * @description fetch the data for a conversion trade * @see https://docs.woox.io/#get-quote-trade * @param {string} id the id of the trade that you want to fetch * @param {string} [code] the unified currency code of the conversion trade * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [conversion structure]{@link https://docs.ccxt.com/#/?id=conversion-structure} */ func (this *woo) FetchConvertTrade(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 retRes35878 := (<-this.LoadMarkets()) PanicOnError(retRes35878) var request interface{} = map[string]interface{} { "quoteId": id, } response:= (<-this.V3PrivateGetConvertTrade(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "data": { // "quoteId": 12, // "buyAsset": "", // "sellAsset": "", // "buyAmount": 12.11, // "sellAmount": 12.11, // "tradeStatus": 12, // "createdTime": "" // } // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var fromCurrencyId interface{} = this.SafeString(data, "sellAsset") var toCurrencyId interface{} = this.SafeString(data, "buyAsset") var fromCurrency interface{} = nil var toCurrency interface{} = nil if IsTrue(!IsEqual(fromCurrencyId, nil)) { fromCurrency = this.Currency(fromCurrencyId) } if IsTrue(!IsEqual(toCurrencyId, nil)) { toCurrency = this.Currency(toCurrencyId) } ch <- this.ParseConversion(data, fromCurrency, toCurrency) return nil }() return ch } /** * @method * @name woo#fetchConvertTradeHistory * @description fetch the users history of conversion trades * @see https://docs.woox.io/#get-quote-trades * @param {string} [code] the unified currency code * @param {int} [since] the earliest time in ms to fetch conversions for * @param {int} [limit] the maximum number of conversion structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {int} [params.until] timestamp in ms of the latest conversion to fetch * @returns {object[]} a list of [conversion structures]{@link https://docs.ccxt.com/#/?id=conversion-structure} */ func (this *woo) FetchConvertTradeHistory(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 retRes36338 := (<-this.LoadMarkets()) PanicOnError(retRes36338) var request interface{} = map[string]interface{} {} requestparamsVariable := this.HandleUntilOption("endTime", request, params); request = GetValue(requestparamsVariable,0); params = GetValue(requestparamsVariable,1) if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "startTime", since) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "size", limit) } response:= (<-this.V3PrivateGetConvertTrades(this.Extend(request, params))) PanicOnError(response) // // { // "success": true, // "data": { // "count": 12, // "tradeVos":[ // { // "quoteId": 12, // "buyAsset": "", // "sellAsset": "", // "buyAmount": 12.11, // "sellAmount": 12.11, // "tradeStatus": 12, // "createdTime": "" // } // ... // ] // } // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var rows interface{} = this.SafeList(data, "tradeVos", []interface{}{}) ch <- this.ParseConversions(rows, code, "sellAsset", "buyAsset", since, limit) return nil }() return ch } func (this *woo) ParseConversion(conversion interface{}, optionalArgs ...interface{}) interface{} { // // fetchConvertQuote // // { // "quoteId": 123123123, // "counterPartyId": "", // "sellToken": "ETH", // "sellQuantity": "0.0445", // "buyToken": "USDT", // "buyQuantity": "33.45", // "buyPrice": "6.77", // "expireTimestamp": 1659084466000, // "message": 1659084466000 // } // // createConvertTrade // // { // "quoteId": 123123123, // "counterPartyId": "", // "rftAccepted": 1 // 1 -> success; 2 -> processing; 3 -> fail // } // // fetchConvertTrade, fetchConvertTradeHistory // // { // "quoteId": 12, // "buyAsset": "", // "sellAsset": "", // "buyAmount": 12.11, // "sellAmount": 12.11, // "tradeStatus": 12, // "createdTime": "" // } // fromCurrency := GetArg(optionalArgs, 0, nil) _ = fromCurrency toCurrency := GetArg(optionalArgs, 1, nil) _ = toCurrency var timestamp interface{} = this.SafeInteger2(conversion, "expireTimestamp", "createdTime") var fromCurr interface{} = this.SafeString2(conversion, "sellToken", "buyAsset") var fromCode interface{} = this.SafeCurrencyCode(fromCurr, fromCurrency) var to interface{} = this.SafeString2(conversion, "buyToken", "sellAsset") var toCode interface{} = this.SafeCurrencyCode(to, toCurrency) return map[string]interface{} { "info": conversion, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "id": this.SafeString(conversion, "quoteId"), "fromCurrency": fromCode, "fromAmount": this.SafeNumber2(conversion, "sellQuantity", "sellAmount"), "toCurrency": toCode, "toAmount": this.SafeNumber2(conversion, "buyQuantity", "buyAmount"), "price": this.SafeNumber(conversion, "buyPrice"), "fee": nil, } } /** * @method * @name woo#fetchConvertCurrencies * @description fetches all available currencies that can be converted * @see https://docs.woox.io/#get-quote-asset-info * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an associative dictionary of currencies */ func (this *woo) FetchConvertCurrencies(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 retRes37328 := (<-this.LoadMarkets()) PanicOnError(retRes37328) response:= (<-this.V3PrivateGetConvertAssetInfo(params)) PanicOnError(response) // // { // "success": true, // "rows": [ // { // "token": "BTC", // "tick": 0.0001, // "createdTime": "1575014248.99", // Unix epoch time in seconds // "updatedTime": "1575014248.99" // Unix epoch time in seconds // }, // ] // } // var result interface{} = map[string]interface{} {} var data interface{} = this.SafeList(response, "rows", []interface{}{}) for i := 0; IsLessThan(i, GetArrayLength(data)); i++ { var entry interface{} = GetValue(data, i) var id interface{} = this.SafeString(entry, "token") var code interface{} = this.SafeCurrencyCode(id) AddElementToObject(result, code, map[string]interface{} { "info": entry, "id": id, "code": code, "networks": nil, "type": nil, "name": nil, "active": nil, "deposit": nil, "withdraw": nil, "fee": nil, "precision": this.SafeNumber(entry, "tick"), "limits": map[string]interface{} { "amount": map[string]interface{} { "min": nil, "max": nil, }, "withdraw": map[string]interface{} { "min": nil, "max": nil, }, "deposit": map[string]interface{} { "min": nil, "max": nil, }, }, "created": this.SafeTimestamp(entry, "createdTime"), }) } ch <- result return nil }() return ch } func (this *woo) DefaultNetworkCodeForCurrency(code interface{}) interface{} { var currencyItem interface{} = this.Currency(code) var networks interface{} = GetValue(currencyItem, "networks") var networkKeys interface{} = ObjectKeys(networks) for i := 0; IsLessThan(i, GetArrayLength(networkKeys)); i++ { var network interface{} = GetValue(networkKeys, i) if IsTrue(IsEqual(network, "ETH")) { return network } } // if it was not returned according to above options, then return the first network of currency return this.SafeValue(networkKeys, 0) } func (this *woo) SetSandboxMode(enable interface{}) { this.Exchange.SetSandboxMode(enable) AddElementToObject(this.Options, "sandboxMode", enable) } func (this *woo) Init(userConfig map[string]interface{}) { this.Exchange = Exchange{} this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this) this.Exchange.DerivedExchange = this }