ccxt-go/exchange_generated.go

package ccxt
// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

func  (this *Exchange) Describe() interface{}  {
    return map[string]interface{} {
        "id": nil,
        "name": nil,
        "countries": nil,
        "enableRateLimit": true,
        "rateLimit": 2000,
        "timeout": this.Timeout,
        "certified": false,
        "pro": false,
        "alias": false,
        "dex": false,
        "has": map[string]interface{} {
            "publicAPI": true,
            "privateAPI": true,
            "CORS": nil,
            "sandbox": nil,
            "spot": nil,
            "margin": nil,
            "swap": nil,
            "future": nil,
            "option": nil,
            "addMargin": nil,
            "borrowCrossMargin": nil,
            "borrowIsolatedMargin": nil,
            "borrowMargin": nil,
            "cancelAllOrders": nil,
            "cancelAllOrdersWs": nil,
            "cancelOrder": true,
            "cancelOrderWs": nil,
            "cancelOrders": nil,
            "cancelOrdersWs": nil,
            "closeAllPositions": nil,
            "closePosition": nil,
            "createDepositAddress": nil,
            "createLimitBuyOrder": nil,
            "createLimitBuyOrderWs": nil,
            "createLimitOrder": true,
            "createLimitOrderWs": nil,
            "createLimitSellOrder": nil,
            "createLimitSellOrderWs": nil,
            "createMarketBuyOrder": nil,
            "createMarketBuyOrderWs": nil,
            "createMarketBuyOrderWithCost": nil,
            "createMarketBuyOrderWithCostWs": nil,
            "createMarketOrder": true,
            "createMarketOrderWs": true,
            "createMarketOrderWithCost": nil,
            "createMarketOrderWithCostWs": nil,
            "createMarketSellOrder": nil,
            "createMarketSellOrderWs": nil,
            "createMarketSellOrderWithCost": nil,
            "createMarketSellOrderWithCostWs": nil,
            "createOrder": true,
            "createOrderWs": nil,
            "createOrders": nil,
            "createOrderWithTakeProfitAndStopLoss": nil,
            "createOrderWithTakeProfitAndStopLossWs": nil,
            "createPostOnlyOrder": nil,
            "createPostOnlyOrderWs": nil,
            "createReduceOnlyOrder": nil,
            "createReduceOnlyOrderWs": nil,
            "createStopLimitOrder": nil,
            "createStopLimitOrderWs": nil,
            "createStopLossOrder": nil,
            "createStopLossOrderWs": nil,
            "createStopMarketOrder": nil,
            "createStopMarketOrderWs": nil,
            "createStopOrder": nil,
            "createStopOrderWs": nil,
            "createTakeProfitOrder": nil,
            "createTakeProfitOrderWs": nil,
            "createTrailingAmountOrder": nil,
            "createTrailingAmountOrderWs": nil,
            "createTrailingPercentOrder": nil,
            "createTrailingPercentOrderWs": nil,
            "createTriggerOrder": nil,
            "createTriggerOrderWs": nil,
            "deposit": nil,
            "editOrder": "emulated",
            "editOrders": nil,
            "editOrderWs": nil,
            "fetchAccounts": nil,
            "fetchBalance": true,
            "fetchBalanceWs": nil,
            "fetchBidsAsks": nil,
            "fetchBorrowInterest": nil,
            "fetchBorrowRate": nil,
            "fetchBorrowRateHistories": nil,
            "fetchBorrowRateHistory": nil,
            "fetchBorrowRates": nil,
            "fetchBorrowRatesPerSymbol": nil,
            "fetchCanceledAndClosedOrders": nil,
            "fetchCanceledOrders": nil,
            "fetchClosedOrder": nil,
            "fetchClosedOrders": nil,
            "fetchClosedOrdersWs": nil,
            "fetchConvertCurrencies": nil,
            "fetchConvertQuote": nil,
            "fetchConvertTrade": nil,
            "fetchConvertTradeHistory": nil,
            "fetchCrossBorrowRate": nil,
            "fetchCrossBorrowRates": nil,
            "fetchCurrencies": "emulated",
            "fetchCurrenciesWs": "emulated",
            "fetchDeposit": nil,
            "fetchDepositAddress": nil,
            "fetchDepositAddresses": nil,
            "fetchDepositAddressesByNetwork": nil,
            "fetchDeposits": nil,
            "fetchDepositsWithdrawals": nil,
            "fetchDepositsWs": nil,
            "fetchDepositWithdrawFee": nil,
            "fetchDepositWithdrawFees": nil,
            "fetchFundingHistory": nil,
            "fetchFundingRate": nil,
            "fetchFundingRateHistory": nil,
            "fetchFundingInterval": nil,
            "fetchFundingIntervals": nil,
            "fetchFundingRates": nil,
            "fetchGreeks": nil,
            "fetchIndexOHLCV": nil,
            "fetchIsolatedBorrowRate": nil,
            "fetchIsolatedBorrowRates": nil,
            "fetchMarginAdjustmentHistory": nil,
            "fetchIsolatedPositions": nil,
            "fetchL2OrderBook": true,
            "fetchL3OrderBook": nil,
            "fetchLastPrices": nil,
            "fetchLedger": nil,
            "fetchLedgerEntry": nil,
            "fetchLeverage": nil,
            "fetchLeverages": nil,
            "fetchLeverageTiers": nil,
            "fetchLiquidations": nil,
            "fetchLongShortRatio": nil,
            "fetchLongShortRatioHistory": nil,
            "fetchMarginMode": nil,
            "fetchMarginModes": nil,
            "fetchMarketLeverageTiers": nil,
            "fetchMarkets": true,
            "fetchMarketsWs": nil,
            "fetchMarkOHLCV": nil,
            "fetchMyLiquidations": nil,
            "fetchMySettlementHistory": nil,
            "fetchMyTrades": nil,
            "fetchMyTradesWs": nil,
            "fetchOHLCV": nil,
            "fetchOHLCVWs": nil,
            "fetchOpenInterest": nil,
            "fetchOpenInterests": nil,
            "fetchOpenInterestHistory": nil,
            "fetchOpenOrder": nil,
            "fetchOpenOrders": nil,
            "fetchOpenOrdersWs": nil,
            "fetchOption": nil,
            "fetchOptionChain": nil,
            "fetchOrder": nil,
            "fetchOrderBook": true,
            "fetchOrderBooks": nil,
            "fetchOrderBookWs": nil,
            "fetchOrders": nil,
            "fetchOrdersByStatus": nil,
            "fetchOrdersWs": nil,
            "fetchOrderTrades": nil,
            "fetchOrderWs": nil,
            "fetchPosition": nil,
            "fetchPositionHistory": nil,
            "fetchPositionsHistory": nil,
            "fetchPositionWs": nil,
            "fetchPositionMode": nil,
            "fetchPositions": nil,
            "fetchPositionsWs": nil,
            "fetchPositionsForSymbol": nil,
            "fetchPositionsForSymbolWs": nil,
            "fetchPositionsRisk": nil,
            "fetchPremiumIndexOHLCV": nil,
            "fetchSettlementHistory": nil,
            "fetchStatus": nil,
            "fetchTicker": true,
            "fetchTickerWs": nil,
            "fetchTickers": nil,
            "fetchMarkPrices": nil,
            "fetchTickersWs": nil,
            "fetchTime": nil,
            "fetchTrades": true,
            "fetchTradesWs": nil,
            "fetchTradingFee": nil,
            "fetchTradingFees": nil,
            "fetchTradingFeesWs": nil,
            "fetchTradingLimits": nil,
            "fetchTransactionFee": nil,
            "fetchTransactionFees": nil,
            "fetchTransactions": nil,
            "fetchTransfer": nil,
            "fetchTransfers": nil,
            "fetchUnderlyingAssets": nil,
            "fetchVolatilityHistory": nil,
            "fetchWithdrawAddresses": nil,
            "fetchWithdrawal": nil,
            "fetchWithdrawals": nil,
            "fetchWithdrawalsWs": nil,
            "fetchWithdrawalWhitelist": nil,
            "reduceMargin": nil,
            "repayCrossMargin": nil,
            "repayIsolatedMargin": nil,
            "setLeverage": nil,
            "setMargin": nil,
            "setMarginMode": nil,
            "setPositionMode": nil,
            "signIn": nil,
            "transfer": nil,
            "watchBalance": nil,
            "watchMyTrades": nil,
            "watchOHLCV": nil,
            "watchOHLCVForSymbols": nil,
            "watchOrderBook": nil,
            "watchOrderBookForSymbols": nil,
            "watchOrders": nil,
            "watchOrdersForSymbols": nil,
            "watchPosition": nil,
            "watchPositions": nil,
            "watchStatus": nil,
            "watchTicker": nil,
            "watchTickers": nil,
            "watchTrades": nil,
            "watchTradesForSymbols": nil,
            "watchLiquidations": nil,
            "watchLiquidationsForSymbols": nil,
            "watchMyLiquidations": nil,
            "watchMyLiquidationsForSymbols": nil,
            "withdraw": nil,
            "ws": nil,
        },
        "urls": map[string]interface{} {
            "logo": nil,
            "api": nil,
            "www": nil,
            "doc": nil,
            "fees": nil,
        },
        "api": nil,
        "requiredCredentials": map[string]interface{} {
            "apiKey": true,
            "secret": true,
            "uid": false,
            "accountId": false,
            "login": false,
            "password": false,
            "twofa": false,
            "privateKey": false,
            "walletAddress": false,
            "token": false,
        },
        "markets": nil,
        "currencies": map[string]interface{} {},
        "timeframes": nil,
        "fees": map[string]interface{} {
            "trading": map[string]interface{} {
                "tierBased": nil,
                "percentage": nil,
                "taker": nil,
                "maker": nil,
            },
            "funding": map[string]interface{} {
                "tierBased": nil,
                "percentage": nil,
                "withdraw": map[string]interface{} {},
                "deposit": map[string]interface{} {},
            },
        },
        "status": map[string]interface{} {
            "status": "ok",
            "updated": nil,
            "eta": nil,
            "url": nil,
        },
        "exceptions": nil,
        "httpExceptions": map[string]interface{} {
            "422": ExchangeError,
            "418": DDoSProtection,
            "429": RateLimitExceeded,
            "404": ExchangeNotAvailable,
            "409": ExchangeNotAvailable,
            "410": ExchangeNotAvailable,
            "451": ExchangeNotAvailable,
            "500": ExchangeNotAvailable,
            "501": ExchangeNotAvailable,
            "502": ExchangeNotAvailable,
            "520": ExchangeNotAvailable,
            "521": ExchangeNotAvailable,
            "522": ExchangeNotAvailable,
            "525": ExchangeNotAvailable,
            "526": ExchangeNotAvailable,
            "400": ExchangeNotAvailable,
            "403": ExchangeNotAvailable,
            "405": ExchangeNotAvailable,
            "503": ExchangeNotAvailable,
            "530": ExchangeNotAvailable,
            "408": RequestTimeout,
            "504": RequestTimeout,
            "401": AuthenticationError,
            "407": AuthenticationError,
            "511": AuthenticationError,
        },
        "commonCurrencies": map[string]interface{} {
            "XBT": "BTC",
            "BCC": "BCH",
            "BCHSV": "BSV",
        },
        "precisionMode": TICK_SIZE,
        "paddingMode": NO_PADDING,
        "limits": map[string]interface{} {
            "leverage": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "amount": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "price": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "cost": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
        },
    }
}
func  (this *Exchange) SafeBoolN(dictionaryOrList interface{}, keys interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract boolean value from dictionary or list
    * @returns {bool | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeValueN(dictionaryOrList, keys, defaultValue)
    if IsTrue(IsBool(value)) {
        return value
    }
    return defaultValue
}
func  (this *Exchange) SafeBool2(dictionary interface{}, key1 interface{}, key2 interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract boolean value from dictionary or list
    * @returns {bool | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    return this.SafeBoolN(dictionary, []interface{}{key1, key2}, defaultValue)
}
func  (this *Exchange) SafeBool(dictionary interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract boolean value from dictionary or list
    * @returns {bool | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    return this.SafeBoolN(dictionary, []interface{}{key}, defaultValue)
}
func  (this *Exchange) SafeDictN(dictionaryOrList interface{}, keys interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract a dictionary from dictionary or list
    * @returns {object | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeValueN(dictionaryOrList, keys, defaultValue)
    if IsTrue(IsEqual(value, nil)) {
        return defaultValue
    }
    if IsTrue((IsObject(value))) {
        if !IsTrue(IsArray(value)) {
            return value
        }
    }
    return defaultValue
}
func  (this *Exchange) SafeDict(dictionary interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract a dictionary from dictionary or list
    * @returns {object | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    return this.SafeDictN(dictionary, []interface{}{key}, defaultValue)
}
func  (this *Exchange) SafeDict2(dictionary interface{}, key1 interface{}, key2 interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract a dictionary from dictionary or list
    * @returns {object | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    return this.SafeDictN(dictionary, []interface{}{key1, key2}, defaultValue)
}
func  (this *Exchange) SafeListN(dictionaryOrList interface{}, keys interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract an Array from dictionary or list
    * @returns {Array | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeValueN(dictionaryOrList, keys, defaultValue)
    if IsTrue(IsEqual(value, nil)) {
        return defaultValue
    }
    if IsTrue(IsArray(value)) {
        return value
    }
    return defaultValue
}
func  (this *Exchange) SafeList2(dictionaryOrList interface{}, key1 interface{}, key2 interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract an Array from dictionary or list
    * @returns {Array | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    return this.SafeListN(dictionaryOrList, []interface{}{key1, key2}, defaultValue)
}
func  (this *Exchange) SafeList(dictionaryOrList interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description safely extract an Array from dictionary or list
    * @returns {Array | undefined}
    */
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    return this.SafeListN(dictionaryOrList, []interface{}{key}, defaultValue)
}
func  (this *Exchange) HandleDeltas(orderbook interface{}, deltas interface{})  {
    for i := 0; IsLessThan(i, GetArrayLength(deltas)); i++ {
        this.HandleDelta(orderbook, GetValue(deltas, i))
    }
}
func  (this *Exchange) HandleDelta(bookside interface{}, delta interface{})  {
    panic(NotSupported(Add(this.Id, " handleDelta not supported yet")))
}
func  (this *Exchange) HandleDeltasWithKeys(bookSide interface{}, deltas interface{}, optionalArgs ...interface{})  {
    priceKey := GetArg(optionalArgs, 0, 0)
    _ = priceKey
    amountKey := GetArg(optionalArgs, 1, 1)
    _ = amountKey
    countOrIdKey := GetArg(optionalArgs, 2, 2)
    _ = countOrIdKey
    for i := 0; IsLessThan(i, GetArrayLength(deltas)); i++ {
        var bidAsk interface{} = this.ParseBidAsk(GetValue(deltas, i), priceKey, amountKey, countOrIdKey)
        (bookSide.(*OrderBookSide)).StoreArray(bidAsk)
    }
}
func  (this *Exchange) GetCacheIndex(orderbook interface{}, deltas interface{}) interface{}  {
    // return the first index of the cache that can be applied to the orderbook or -1 if not possible
    return OpNeg(1)
}
func  (this *Exchange) FindTimeframe(timeframe interface{}, optionalArgs ...interface{}) interface{}  {
    timeframes := GetArg(optionalArgs, 0, nil)
    _ = timeframes
    if IsTrue(IsEqual(timeframes, nil)) {
        timeframes = this.Timeframes
    }
    var keys interface{} = ObjectKeys(timeframes)
    for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
        var key interface{} = GetValue(keys, i)
        if IsTrue(IsEqual(GetValue(timeframes, key), timeframe)) {
            return key
        }
    }
    return nil
}
func  (this *Exchange) CheckProxyUrlSettings(optionalArgs ...interface{}) interface{}  {
    url := GetArg(optionalArgs, 0, nil)
    _ = url
    method := GetArg(optionalArgs, 1, nil)
    _ = method
    headers := GetArg(optionalArgs, 2, nil)
    _ = headers
    body := GetArg(optionalArgs, 3, nil)
    _ = body
    var usedProxies interface{} = []interface{}{}
    var proxyUrl interface{} = nil
    if IsTrue(!IsEqual(this.ProxyUrl, nil)) {
        AppendToArray(&usedProxies,"proxyUrl")
        proxyUrl = this.ProxyUrl
    }
    if IsTrue(!IsEqual(this.Proxy_url, nil)) {
        AppendToArray(&usedProxies,"proxy_url")
        proxyUrl = this.Proxy_url
    }
    if IsTrue(!IsEqual(this.ProxyUrlCallback, nil)) {
        AppendToArray(&usedProxies,"proxyUrlCallback")
        proxyUrl = this.callDynamically("proxyUrlCallback", url, method, headers, body)
    }
    if IsTrue(!IsEqual(this.Proxy_url_callback, nil)) {
        AppendToArray(&usedProxies,"proxy_url_callback")
        proxyUrl = this.callDynamically("proxy_url_callback", url, method, headers, body)
    }
    // backwards-compatibility
    if IsTrue(!IsEqual(this.Proxy, nil)) {
        AppendToArray(&usedProxies,"proxy")
        if IsTrue(IsFunction(this.Proxy)) {
            proxyUrl = this.callDynamically("proxy", url, method, headers, body)
        } else {
            proxyUrl = this.Proxy
        }
    }
    var length interface{} =     GetArrayLength(usedProxies)
    if IsTrue(IsGreaterThan(length, 1)) {
        var joinedProxyNames interface{} = Join(usedProxies, ",")
        panic(InvalidProxySettings(Add(Add(Add(this.Id, " you have multiple conflicting proxy settings ("), joinedProxyNames), "), please use only one from : proxyUrl, proxy_url, proxyUrlCallback, proxy_url_callback")))
    }
    return proxyUrl
}
func  (this *Exchange) CheckProxySettings(optionalArgs ...interface{}) interface{}  {
    url := GetArg(optionalArgs, 0, nil)
    _ = url
    method := GetArg(optionalArgs, 1, nil)
    _ = method
    headers := GetArg(optionalArgs, 2, nil)
    _ = headers
    body := GetArg(optionalArgs, 3, nil)
    _ = body
    var usedProxies interface{} = []interface{}{}
    var httpProxy interface{} = nil
    var httpsProxy interface{} = nil
    var socksProxy interface{} = nil
    // httpProxy
    var isHttpProxyDefined interface{} = this.ValueIsDefined(this.HttpProxy)
    var isHttp_proxy_defined interface{} = this.ValueIsDefined(this.Http_proxy)
    if IsTrue(IsTrue(isHttpProxyDefined) || IsTrue(isHttp_proxy_defined)) {
        AppendToArray(&usedProxies,"httpProxy")
        httpProxy = Ternary(IsTrue(isHttpProxyDefined), this.HttpProxy, this.Http_proxy)
    }
    var ishttpProxyCallbackDefined interface{} = this.ValueIsDefined(this.HttpProxyCallback)
    var ishttp_proxy_callback_defined interface{} = this.ValueIsDefined(this.Http_proxy_callback)
    if IsTrue(IsTrue(ishttpProxyCallbackDefined) || IsTrue(ishttp_proxy_callback_defined)) {
        AppendToArray(&usedProxies,"httpProxyCallback")
        httpProxy = Ternary(IsTrue(ishttpProxyCallbackDefined), this.callDynamically("httpProxyCallback", url, method, headers, body), this.callDynamically("http_proxy_callback", url, method, headers, body))
    }
    // httpsProxy
    var isHttpsProxyDefined interface{} = this.ValueIsDefined(this.HttpsProxy)
    var isHttps_proxy_defined interface{} = this.ValueIsDefined(this.Https_proxy)
    if IsTrue(IsTrue(isHttpsProxyDefined) || IsTrue(isHttps_proxy_defined)) {
        AppendToArray(&usedProxies,"httpsProxy")
        httpsProxy = Ternary(IsTrue(isHttpsProxyDefined), this.HttpsProxy, this.Https_proxy)
    }
    var ishttpsProxyCallbackDefined interface{} = this.ValueIsDefined(this.HttpsProxyCallback)
    var ishttps_proxy_callback_defined interface{} = this.ValueIsDefined(this.Https_proxy_callback)
    if IsTrue(IsTrue(ishttpsProxyCallbackDefined) || IsTrue(ishttps_proxy_callback_defined)) {
        AppendToArray(&usedProxies,"httpsProxyCallback")
        httpsProxy = Ternary(IsTrue(ishttpsProxyCallbackDefined), this.callDynamically("httpsProxyCallback", url, method, headers, body), this.callDynamically("https_proxy_callback", url, method, headers, body))
    }
    // socksProxy
    var isSocksProxyDefined interface{} = this.ValueIsDefined(this.SocksProxy)
    var isSocks_proxy_defined interface{} = this.ValueIsDefined(this.Socks_proxy)
    if IsTrue(IsTrue(isSocksProxyDefined) || IsTrue(isSocks_proxy_defined)) {
        AppendToArray(&usedProxies,"socksProxy")
        socksProxy = Ternary(IsTrue(isSocksProxyDefined), this.SocksProxy, this.Socks_proxy)
    }
    var issocksProxyCallbackDefined interface{} = this.ValueIsDefined(this.SocksProxyCallback)
    var issocks_proxy_callback_defined interface{} = this.ValueIsDefined(this.Socks_proxy_callback)
    if IsTrue(IsTrue(issocksProxyCallbackDefined) || IsTrue(issocks_proxy_callback_defined)) {
        AppendToArray(&usedProxies,"socksProxyCallback")
        socksProxy = Ternary(IsTrue(issocksProxyCallbackDefined), this.callDynamically("socksProxyCallback", url, method, headers, body), this.callDynamically("socks_proxy_callback", url, method, headers, body))
    }
    // check
    var length interface{} =     GetArrayLength(usedProxies)
    if IsTrue(IsGreaterThan(length, 1)) {
        var joinedProxyNames interface{} = Join(usedProxies, ",")
        panic(InvalidProxySettings(Add(Add(Add(this.Id, " you have multiple conflicting proxy settings ("), joinedProxyNames), "), please use only one from: httpProxy, httpsProxy, httpProxyCallback, httpsProxyCallback, socksProxy, socksProxyCallback")))
    }
    return []interface{}{httpProxy, httpsProxy, socksProxy}
}
func  (this *Exchange) CheckWsProxySettings() interface{}  {
    var usedProxies interface{} = []interface{}{}
    var wsProxy interface{} = nil
    var wssProxy interface{} = nil
    var wsSocksProxy interface{} = nil
    // ws proxy
    var isWsProxyDefined interface{} = this.ValueIsDefined(this.WsProxy)
    var is_ws_proxy_defined interface{} = this.ValueIsDefined(this.Ws_proxy)
    if IsTrue(IsTrue(isWsProxyDefined) || IsTrue(is_ws_proxy_defined)) {
        AppendToArray(&usedProxies,"wsProxy")
        wsProxy = Ternary(IsTrue((isWsProxyDefined)), this.WsProxy, this.Ws_proxy)
    }
    // wss proxy
    var isWssProxyDefined interface{} = this.ValueIsDefined(this.WssProxy)
    var is_wss_proxy_defined interface{} = this.ValueIsDefined(this.Wss_proxy)
    if IsTrue(IsTrue(isWssProxyDefined) || IsTrue(is_wss_proxy_defined)) {
        AppendToArray(&usedProxies,"wssProxy")
        wssProxy = Ternary(IsTrue((isWssProxyDefined)), this.WssProxy, this.Wss_proxy)
    }
    // ws socks proxy
    var isWsSocksProxyDefined interface{} = this.ValueIsDefined(this.WsSocksProxy)
    var is_ws_socks_proxy_defined interface{} = this.ValueIsDefined(this.Ws_socks_proxy)
    if IsTrue(IsTrue(isWsSocksProxyDefined) || IsTrue(is_ws_socks_proxy_defined)) {
        AppendToArray(&usedProxies,"wsSocksProxy")
        wsSocksProxy = Ternary(IsTrue((isWsSocksProxyDefined)), this.WsSocksProxy, this.Ws_socks_proxy)
    }
    // check
    var length interface{} =     GetArrayLength(usedProxies)
    if IsTrue(IsGreaterThan(length, 1)) {
        var joinedProxyNames interface{} = Join(usedProxies, ",")
        panic(InvalidProxySettings(Add(Add(Add(this.Id, " you have multiple conflicting proxy settings ("), joinedProxyNames), "), please use only one from: wsProxy, wssProxy, wsSocksProxy")))
    }
    return []interface{}{wsProxy, wssProxy, wsSocksProxy}
}
func  (this *Exchange) CheckConflictingProxies(proxyAgentSet interface{}, proxyUrlSet interface{})  {
    if IsTrue(IsTrue(proxyAgentSet) && IsTrue(proxyUrlSet)) {
        panic(InvalidProxySettings(Add(this.Id, " you have multiple conflicting proxy settings, please use only one from : proxyUrl, httpProxy, httpsProxy, socksProxy")))
    }
}
func  (this *Exchange) CheckAddress(optionalArgs ...interface{}) interface{}  {
    address := GetArg(optionalArgs, 0, nil)
    _ = address
    if IsTrue(IsEqual(address, nil)) {
        panic(InvalidAddress(Add(this.Id, " address is undefined")))
    }
    // check the address is not the same letter like 'aaaaa' nor too short nor has a space
    var uniqChars interface{} =     (this.Unique(this.StringToCharsArray(address)))
    var length interface{} =     GetArrayLength(uniqChars) // py transpiler trick
    if IsTrue(IsTrue(IsTrue(IsEqual(length, 1)) || IsTrue(IsLessThan(GetLength(address), this.MinFundingAddressLength))) || IsTrue(IsGreaterThan(GetIndexOf(address, " "), OpNeg(1)))) {
        panic(InvalidAddress(Add(Add(Add(Add(Add(this.Id, " address is invalid or has less than "), ToString(this.MinFundingAddressLength)), " characters: \""), ToString(address)), "\"")))
    }
    return address
}
func  (this *Exchange) FindMessageHashes(client Client, element interface{}) interface{}  {
    var result interface{} = []interface{}{}
    var messageHashes interface{} = ObjectKeys(client.Futures)
    for i := 0; IsLessThan(i, GetArrayLength(messageHashes)); i++ {
        var messageHash interface{} = GetValue(messageHashes, i)
        if IsTrue(IsGreaterThanOrEqual(GetIndexOf(messageHash, element), 0)) {
            AppendToArray(&result,messageHash)
        }
    }
    return result
}
func  (this *Exchange) FilterByLimit(array interface{}, optionalArgs ...interface{}) interface{}  {
    // array = ascending ? this.arraySlice (array, 0, limit) : this.arraySlice (array, -limit);
    // array = ascending ? this.arraySlice (array, -limit) : this.arraySlice (array, 0, limit);
    limit := GetArg(optionalArgs, 0, nil)
    _ = limit
    key := GetArg(optionalArgs, 1, "timestamp")
    _ = key
    fromStart := GetArg(optionalArgs, 2, false)
    _ = fromStart
    if IsTrue(this.ValueIsDefined(limit)) {
        var arrayLength interface{} =         GetArrayLength(array)
        if IsTrue(IsGreaterThan(arrayLength, 0)) {
            var ascending interface{} = true
            if IsTrue((InOp(GetValue(array, 0), key))) {
                var first interface{} = GetValue(GetValue(array, 0), key)
                var last interface{} = GetValue(GetValue(array, Subtract(arrayLength, 1)), key)
                if IsTrue(IsTrue(!IsEqual(first, nil)) && IsTrue(!IsEqual(last, nil))) {
                    ascending = IsLessThanOrEqual(first, last) // true if array is sorted in ascending order based on 'timestamp'
                }
            }
            if IsTrue(fromStart) {
                if IsTrue(IsGreaterThan(limit, arrayLength)) {
                    limit = arrayLength
                }
                if IsTrue(ascending) {
                    array = this.ArraySlice(array, 0, limit)
                } else {
                    array = this.ArraySlice(array, OpNeg(limit))
                }
            } else {
                if IsTrue(ascending) {
                    array = this.ArraySlice(array, OpNeg(limit))
                } else {
                    array = this.ArraySlice(array, 0, limit)
                }
            }
        }
    }
    return array
}
func  (this *Exchange) FilterBySinceLimit(array interface{}, optionalArgs ...interface{}) interface{}  {
    since := GetArg(optionalArgs, 0, nil)
    _ = since
    limit := GetArg(optionalArgs, 1, nil)
    _ = limit
    key := GetArg(optionalArgs, 2, "timestamp")
    _ = key
    tail := GetArg(optionalArgs, 3, false)
    _ = tail
    var sinceIsDefined interface{} = this.ValueIsDefined(since)
    var parsedArray interface{} = this.ToArray(array)
    var result interface{} = parsedArray
    if IsTrue(sinceIsDefined) {
        result = []interface{}{}
        for i := 0; IsLessThan(i, GetArrayLength(parsedArray)); i++ {
            var entry interface{} = GetValue(parsedArray, i)
            var value interface{} = this.SafeValue(entry, key)
            if IsTrue(IsTrue(value) && IsTrue((IsGreaterThanOrEqual(value, since)))) {
                AppendToArray(&result,entry)
            }
        }
    }
    if IsTrue(IsTrue(tail) && IsTrue(!IsEqual(limit, nil))) {
        return this.ArraySlice(result, OpNeg(limit))
    }
    // if the user provided a 'since' argument
    // we want to limit the result starting from the 'since'
    var shouldFilterFromStart interface{} = !IsTrue(tail) && IsTrue(sinceIsDefined)
    return this.FilterByLimit(result, limit, key, shouldFilterFromStart)
}
func  (this *Exchange) FilterByValueSinceLimit(array interface{}, field interface{}, optionalArgs ...interface{}) interface{}  {
    value := GetArg(optionalArgs, 0, nil)
    _ = value
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    key := GetArg(optionalArgs, 3, "timestamp")
    _ = key
    tail := GetArg(optionalArgs, 4, false)
    _ = tail
    var valueIsDefined interface{} = this.ValueIsDefined(value)
    var sinceIsDefined interface{} = this.ValueIsDefined(since)
    var parsedArray interface{} = this.ToArray(array)
    var result interface{} = parsedArray
    // single-pass filter for both symbol and since
    if IsTrue(IsTrue(valueIsDefined) || IsTrue(sinceIsDefined)) {
        result = []interface{}{}
        for i := 0; IsLessThan(i, GetArrayLength(parsedArray)); i++ {
            var entry interface{} = GetValue(parsedArray, i)
            var entryFiledEqualValue interface{} = IsEqual(GetValue(entry, field), value)
            var firstCondition interface{} = Ternary(IsTrue(valueIsDefined), entryFiledEqualValue, true)
            var entryKeyValue interface{} = this.SafeValue(entry, key)
            var entryKeyGESince interface{} = IsTrue(IsTrue((entryKeyValue)) && IsTrue((!IsEqual(since, nil)))) && IsTrue((IsGreaterThanOrEqual(entryKeyValue, since)))
            var secondCondition interface{} = Ternary(IsTrue(sinceIsDefined), entryKeyGESince, true)
            if IsTrue(IsTrue(firstCondition) && IsTrue(secondCondition)) {
                AppendToArray(&result,entry)
            }
        }
    }
    if IsTrue(IsTrue(tail) && IsTrue(!IsEqual(limit, nil))) {
        return this.ArraySlice(result, OpNeg(limit))
    }
    return this.FilterByLimit(result, limit, key, sinceIsDefined)
}
/**
 * @method
 * @name Exchange#setSandboxMode
 * @description set the sandbox mode for the exchange
 * @param {boolean} enabled true to enable sandbox mode, false to disable it
 */
func  (this *Exchange) SetSandboxMode(enabled interface{})  {
    if IsTrue(enabled) {
        if IsTrue(InOp(this.Urls, "test")) {
            if IsTrue(IsString(GetValue(this.Urls, "api"))) {
                AddElementToObject(this.Urls, "apiBackup", GetValue(this.Urls, "api"))
                AddElementToObject(this.Urls, "api", GetValue(this.Urls, "test"))
            } else {
                AddElementToObject(this.Urls, "apiBackup", this.Clone(GetValue(this.Urls, "api")))
                AddElementToObject(this.Urls, "api", this.Clone(GetValue(this.Urls, "test")))
            }
        } else {
            panic(NotSupported(Add(this.Id, " does not have a sandbox URL")))
        }
        // set flag
        this.IsSandboxModeEnabled = true
    } else if IsTrue(InOp(this.Urls, "apiBackup")) {
        if IsTrue(IsString(GetValue(this.Urls, "api"))) {
            AddElementToObject(this.Urls, "api", GetValue(this.Urls, "apiBackup"))
        } else {
            AddElementToObject(this.Urls, "api", this.Clone(GetValue(this.Urls, "apiBackup")))
        }
        var newUrls interface{} = this.Omit(this.Urls, "apiBackup")
        this.Urls = newUrls
        // set flag
        this.IsSandboxModeEnabled = false
    }
}
func  (this *Exchange) Sign(path interface{}, optionalArgs ...interface{}) interface{}  {
    api := GetArg(optionalArgs, 0, "public")
    _ = api
    method := GetArg(optionalArgs, 1, "GET")
    _ = method
    params := GetArg(optionalArgs, 2, map[string]interface{} {})
    _ = params
    headers := GetArg(optionalArgs, 3, nil)
    _ = headers
    body := GetArg(optionalArgs, 4, nil)
    _ = body
    return map[string]interface{} {}
}
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchAccounts() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchTrades() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTradesWs(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
            panic(NotSupported(Add(this.Id, " fetchTradesWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchLiquidations(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
            if IsTrue(GetValue(this.Has, "watchLiquidationsForSymbols")) {
        
                    retRes235619 :=  (<-this.WatchLiquidationsForSymbols([]interface{}{symbol}, since, limit, params))
                    PanicOnError(retRes235619)
                    ch <- retRes235619
                    return nil
            }
            panic(NotSupported(Add(this.Id, " watchLiquidations() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchLiquidationsForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " watchLiquidationsForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchMyLiquidations(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
            if IsTrue(GetValue(this.Has, "watchMyLiquidationsForSymbols")) {
        
                ch <- this.WatchMyLiquidationsForSymbols([]interface{}{symbol}, since, limit, params)
                return nil
            }
            panic(NotSupported(Add(this.Id, " watchMyLiquidations() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchMyLiquidationsForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " watchMyLiquidationsForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchTrades(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
            panic(NotSupported(Add(this.Id, " watchTrades() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) UnWatchTrades(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
            panic(NotSupported(Add(this.Id, " unWatchTrades() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchTradesForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " watchTradesForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) UnWatchTradesForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " unWatchTradesForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchMyTradesForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " watchMyTradesForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchOrdersForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " watchOrdersForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchOHLCVForSymbols(symbolsAndTimeframes 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
            panic(NotSupported(Add(this.Id, " watchOHLCVForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) UnWatchOHLCVForSymbols(symbolsAndTimeframes 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
            panic(NotSupported(Add(this.Id, " unWatchOHLCVForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchOrderBookForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " watchOrderBookForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) UnWatchOrderBookForSymbols(symbols 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
            panic(NotSupported(Add(this.Id, " unWatchOrderBookForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchDepositAddresses(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    codes := GetArg(optionalArgs, 0, nil)
            _ = codes
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchDepositAddresses() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchOrderBook() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOrderBookWs(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
            panic(NotSupported(Add(this.Id, " fetchOrderBookWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchMarginMode(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchMarginModes")) {
        
                marginModes:= <-this.DerivedExchange.FetchMarginModes([]interface{}{symbol}, params)
                PanicOnError(marginModes)
        
                ch <- this.SafeDict(marginModes, symbol)
                return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchMarginMode() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchMarginModes(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
            panic(NotSupported(Add(this.Id, " fetchMarginModes () is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchRestOrderBookSafe(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
            var fetchSnapshotMaxRetries interface{} = this.HandleOption("watchOrderBook", "maxRetries", 3)
            for i := 0; IsLessThan(i, fetchSnapshotMaxRetries); i++ {
                
                {		ret__ := func(this *Exchange) (ret_ interface{}) {
                		defer func() {
                			if e := recover(); e != nil {
                                if e == "break" {
                				    return
                			    }
                				ret_ = func(this *Exchange) interface{} {
                					// catch block:
                                                if IsTrue(IsEqual((Add(i, 1)), fetchSnapshotMaxRetries)) {
                                panic(e)
                            }
                                    return nil
                				}(this)
                			}
                		}()
                		// try block:
                        
                            orderBook:= <-this.DerivedExchange.FetchOrderBook(symbol, limit, params)
                            PanicOnError(orderBook)
                
                            ch <- orderBook
                            return nil
                		return nil
                	}(this)
                	if ret__ != nil {
                		return ret__
                	}
                }
            }
        
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) WatchOrderBook(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
            panic(NotSupported(Add(this.Id, " watchOrderBook() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) UnWatchOrderBook(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
            panic(NotSupported(Add(this.Id, " unWatchOrderBook() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchTime() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTradingLimits(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
            panic(NotSupported(Add(this.Id, " fetchTradingLimits() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseCurrency(rawCurrency interface{}) interface{}  {
    panic(NotSupported(Add(this.Id, " parseCurrency() is not supported yet")))
}
func  (this *Exchange) ParseCurrencies(rawCurrencies interface{}) interface{}  {
    var result interface{} = map[string]interface{} {}
    var arr interface{} = this.ToArray(rawCurrencies)
    for i := 0; IsLessThan(i, GetArrayLength(arr)); i++ {

        var parsed interface{} = this.DerivedExchange.ParseCurrency(GetValue(arr, i))
        PanicOnError(parsed)
        var code interface{} = GetValue(parsed, "code")
        AddElementToObject(result, code, parsed)
    }
    return result
}
func  (this *Exchange) ParseMarket(market interface{}) interface{}  {
    panic(NotSupported(Add(this.Id, " parseMarket() is not supported yet")))
}
func  (this *Exchange) ParseMarkets(markets interface{}) interface{}  {
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(markets)); i++ {
        AppendToArray(&result,this.DerivedExchange.ParseMarket(GetValue(markets, i)))
    }
    return result
}
func  (this *Exchange) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseTicker() is not supported yet")))
}
func  (this *Exchange) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    panic(NotSupported(Add(this.Id, " parseDepositAddress() is not supported yet")))
}
func  (this *Exchange) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseTrade() is not supported yet")))
}
func  (this *Exchange) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    panic(NotSupported(Add(this.Id, " parseTransaction() is not supported yet")))
}
func  (this *Exchange) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    panic(NotSupported(Add(this.Id, " parseTransfer() is not supported yet")))
}
func  (this *Exchange) ParseAccount(account interface{}) interface{}  {
    panic(NotSupported(Add(this.Id, " parseAccount() is not supported yet")))
}
func  (this *Exchange) ParseLedgerEntry(item interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    panic(NotSupported(Add(this.Id, " parseLedgerEntry() is not supported yet")))
}
func  (this *Exchange) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseOrder() is not supported yet")))
}
func  (this *Exchange) FetchCrossBorrowRates(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
            panic(NotSupported(Add(this.Id, " fetchCrossBorrowRates() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchIsolatedBorrowRates(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
            panic(NotSupported(Add(this.Id, " fetchIsolatedBorrowRates() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseMarketLeverageTiers(info interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseMarketLeverageTiers() is not supported yet")))
}
func  (this *Exchange) FetchLeverageTiers(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
            panic(NotSupported(Add(this.Id, " fetchLeverageTiers() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parsePosition() is not supported yet")))
}
func  (this *Exchange) ParseFundingRateHistory(info interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseFundingRateHistory() is not supported yet")))
}
func  (this *Exchange) ParseBorrowInterest(info interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseBorrowInterest() is not supported yet")))
}
func  (this *Exchange) ParseIsolatedBorrowRate(info interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseIsolatedBorrowRate() is not supported yet")))
}
func  (this *Exchange) ParseWsTrade(trade interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseWsTrade() is not supported yet")))
}
func  (this *Exchange) ParseWsOrder(order interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseWsOrder() is not supported yet")))
}
func  (this *Exchange) ParseWsOrderTrade(trade interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseWsOrderTrade() is not supported yet")))
}
func  (this *Exchange) ParseWsOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    return this.DerivedExchange.ParseOHLCV(ohlcv, market)
}
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchFundingRates() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchFundingIntervals(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
            panic(NotSupported(Add(this.Id, " fetchFundingIntervals() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchFundingRate(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
            panic(NotSupported(Add(this.Id, " watchFundingRate() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchFundingRates(symbols 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
            panic(NotSupported(Add(this.Id, " watchFundingRates() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchFundingRatesForSymbols(symbols 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
        
                retRes259615 :=  (<-this.WatchFundingRates(symbols, params))
                PanicOnError(retRes259615)
                ch <- retRes259615
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " transfer() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " withdraw() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " createDepositAddress() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " setLeverage() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            if IsTrue(GetValue(this.Has, "fetchLeverages")) {
        
                leverages:= <-this.DerivedExchange.FetchLeverages([]interface{}{symbol}, params)
                PanicOnError(leverages)
        
                ch <- this.SafeDict(leverages, symbol)
                return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchLeverage() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchLeverages(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
            panic(NotSupported(Add(this.Id, " fetchLeverages() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " setPositionMode() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " addMargin() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " reduceMargin() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) SetMargin(symbol interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " setMargin() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchLongShortRatio(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    timeframe := GetArg(optionalArgs, 0, nil)
            _ = timeframe
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchLongShortRatio() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchLongShortRatioHistory(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            timeframe := GetArg(optionalArgs, 1, nil)
            _ = timeframe
            since := GetArg(optionalArgs, 2, nil)
            _ = since
            limit := GetArg(optionalArgs, 3, nil)
            _ = limit
            params := GetArg(optionalArgs, 4, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchLongShortRatioHistory() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchMarginAdjustmentHistory(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            typeVar := GetArg(optionalArgs, 1, nil)
            _ = typeVar
            since := GetArg(optionalArgs, 2, nil)
            _ = since
            limit := GetArg(optionalArgs, 3, nil)
            _ = limit
            params := GetArg(optionalArgs, 4, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchMarginAdjustmentHistory() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) SetMarginMode(marginMode interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " setMarginMode() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchDepositAddressesByNetwork(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchDepositAddressesByNetwork() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOpenInterestHistory(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    timeframe := GetArg(optionalArgs, 0, "1h")
            _ = timeframe
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchOpenInterestHistory() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOpenInterest(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchOpenInterest() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOpenInterests(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
            panic(NotSupported(Add(this.Id, " fetchOpenInterests() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) SignIn(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
            panic(NotSupported(Add(this.Id, " signIn() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPaymentMethods(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
            panic(NotSupported(Add(this.Id, " fetchPaymentMethods() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseToInt(number interface{}) interface{}  {
    // Solve Common parseInt misuse ex: parseInt ((since / 1000).toString ())
    // using a number as parameter which is not valid in ts
    var stringifiedNumber interface{} = this.NumberToString(number)
    var convertedNumber interface{} = ParseFloat(stringifiedNumber)
    return ParseInt(convertedNumber)
}
func  (this *Exchange) ParseToNumeric(number interface{}) interface{}  {
    var stringVersion interface{} = this.NumberToString(number) // this will convert 1.0 and 1 to "1" and 1.1 to "1.1"
    // keep this in mind:
    // in JS: 1 == 1.0 is true;  1 === 1.0 is true
    // in Python: 1 == 1.0 is true
    // in PHP 1 == 1.0 is true, but 1 === 1.0 is false
    if IsTrue(IsGreaterThanOrEqual(GetIndexOf(stringVersion, "."), 0)) {
        return ParseFloat(stringVersion)
    }
    return ParseInt(stringVersion)
}
func  (this *Exchange) IsRoundNumber(value interface{}) interface{}  {
    // this method is similar to isInteger, but this is more loyal and does not check for types.
    // i.e. isRoundNumber(1.000) returns true, while isInteger(1.000) returns false
    var res interface{} = this.ParseToNumeric((Mod(value, 1)))
    return IsEqual(res, 0)
}
func  (this *Exchange) SafeNumberOmitZero(obj interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeString(obj, key)
    var final interface{} = this.ParseNumber(this.OmitZero(value))
    return Ternary(IsTrue((IsEqual(final, nil))), defaultValue, final)
}
func  (this *Exchange) SafeIntegerOmitZero(obj interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var timestamp interface{} = this.SafeInteger(obj, key, defaultValue)
    if IsTrue(IsTrue(IsEqual(timestamp, nil)) || IsTrue(IsEqual(timestamp, 0))) {
        return nil
    }
    return timestamp
}
func  (this *Exchange) AfterConstruct()  {
    // networks
    this.CreateNetworksByIdObject()
    this.FeaturesGenerator()
    // init predefined markets if any
    if IsTrue(this.Markets) {
        this.SetMarkets(this.Markets)
    }
    // init the request rate limiter
    this.InitRestRateLimiter()
    // sanbox mode
    var isSandbox interface{} = this.SafeBool2(this.Options, "sandbox", "testnet", false)
    if IsTrue(isSandbox) {
        this.DerivedExchange.SetSandboxMode(isSandbox)
    }
}
func  (this *Exchange) InitRestRateLimiter()  {
    if IsTrue(IsTrue(IsEqual(this.RateLimit, nil)) || IsTrue((IsTrue(!IsEqual(this.Id, nil)) && IsTrue(IsEqual(this.RateLimit, OpNeg(1)))))) {
        panic(ExchangeError(Add(this.Id, ".rateLimit property is not configured")))
    }
    var refillRate interface{} = this.MAX_VALUE
    if IsTrue(IsGreaterThan(this.RateLimit, 0)) {
        refillRate = Divide(1, this.RateLimit)
    }
    var defaultBucket interface{} = map[string]interface{} {
        "delay": 0.001,
        "capacity": 1,
        "cost": 1,
        "maxCapacity": 1000,
        "refillRate": refillRate,
    }
    var existingBucket interface{} = Ternary(IsTrue((IsEqual(this.TokenBucket, nil))), map[string]interface{} {}, this.TokenBucket)
    this.TokenBucket = this.Extend(defaultBucket, existingBucket)
    this.InitThrottler()
}
func  (this *Exchange) FeaturesGenerator()  {
    //
    // in the exchange-specific features can be something like this, where we support 'string' aliases too:
    //
    //     {
    //         'my' : {
    //             'createOrder' : {...},
    //         },
    //         'swap': {
    //             'linear': {
    //                 'extends': my',
    //             },
    //         },
    //     }
    //
    if IsTrue(IsEqual(this.Features, nil)) {
        return
    }
    // reconstruct
    var initialFeatures interface{} = this.Features
    this.Features = map[string]interface{} {}
    var unifiedMarketTypes interface{} = []interface{}{"spot", "swap", "future", "option"}
    var subTypes interface{} = []interface{}{"linear", "inverse"}
    // atm only support basic methods, eg: 'createOrder', 'fetchOrder', 'fetchOrders', 'fetchMyTrades'
    for i := 0; IsLessThan(i, GetArrayLength(unifiedMarketTypes)); i++ {
        var marketType interface{} = GetValue(unifiedMarketTypes, i)
        // if marketType is not filled for this exchange, don't add that in `features`
        if !IsTrue((InOp(initialFeatures, marketType))) {
            AddElementToObject(this.Features, marketType, nil)
        } else {
            if IsTrue(IsEqual(marketType, "spot")) {
                AddElementToObject(this.Features, marketType, this.FeaturesMapper(initialFeatures, marketType, nil))
            } else {
                AddElementToObject(this.Features, marketType, map[string]interface{} {})
                for j := 0; IsLessThan(j, GetArrayLength(subTypes)); j++ {
                    var subType interface{} = GetValue(subTypes, j)
                    AddElementToObject(GetValue(this.Features, marketType), subType, this.FeaturesMapper(initialFeatures, marketType, subType))
                }
            }
        }
    }
}
func  (this *Exchange) FeaturesMapper(initialFeatures interface{}, marketType interface{}, optionalArgs ...interface{}) interface{}  {
    subType := GetArg(optionalArgs, 0, nil)
    _ = subType
    var featuresObj interface{} = Ternary(IsTrue((!IsEqual(subType, nil))), GetValue(GetValue(initialFeatures, marketType), subType), GetValue(initialFeatures, marketType))
    // if exchange does not have that market-type (eg. future>inverse)
    if IsTrue(IsEqual(featuresObj, nil)) {
        return nil
    }
    var extendsStr interface{} = this.SafeString(featuresObj, "extends")
    if IsTrue(!IsEqual(extendsStr, nil)) {
        featuresObj = this.Omit(featuresObj, "extends")
        var extendObj interface{} = this.FeaturesMapper(initialFeatures, extendsStr)
        featuresObj = this.DeepExtend(extendObj, featuresObj)
    }
    //
    // ### corrections ###
    //
    // createOrder
    if IsTrue(InOp(featuresObj, "createOrder")) {
        var value interface{} = this.SafeDict(GetValue(featuresObj, "createOrder"), "attachedStopLossTakeProfit")
        AddElementToObject(GetValue(featuresObj, "createOrder"), "stopLoss", value)
        AddElementToObject(GetValue(featuresObj, "createOrder"), "takeProfit", value)
        if IsTrue(IsEqual(marketType, "spot")) {
            // default 'hedged': false
            AddElementToObject(GetValue(featuresObj, "createOrder"), "hedged", false)
            // default 'leverage': false
            if !IsTrue((InOp(GetValue(featuresObj, "createOrder"), "leverage"))) {
                AddElementToObject(GetValue(featuresObj, "createOrder"), "leverage", false)
            }
        }
        // default 'GTC' to true
        if IsTrue(IsEqual(this.SafeBool(GetValue(GetValue(featuresObj, "createOrder"), "timeInForce"), "GTC"), nil)) {
            AddElementToObject(GetValue(GetValue(featuresObj, "createOrder"), "timeInForce"), "GTC", true)
        }
    }
    // other methods
    var keys interface{} = ObjectKeys(featuresObj)
    for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
        var key interface{} = GetValue(keys, i)
        var featureBlock interface{} = GetValue(featuresObj, key)
        if IsTrue(!IsTrue(this.InArray(key, []interface{}{"sandbox"})) && IsTrue(!IsEqual(featureBlock, nil))) {
            // default "symbolRequired" to false to all methods (except `createOrder`)
            if !IsTrue((InOp(featureBlock, "symbolRequired"))) {
                AddElementToObject(featureBlock, "symbolRequired", this.InArray(key, []interface{}{"createOrder", "createOrders", "fetchOHLCV"}))
            }
        }
    }
    return featuresObj
}
func  (this *Exchange) OrderbookChecksumMessage(symbol interface{}) interface{}  {
    return Add(Add(symbol, " : "), "orderbook data checksum validation failed. You can reconnect by calling watchOrderBook again or you can mute the error by setting exchange.options[\"watchOrderBook\"][\"checksum\"] = false")
}
func  (this *Exchange) CreateNetworksByIdObject()  {
    // automatically generate network-id-to-code mappings
    var networkIdsToCodesGenerated interface{} = this.InvertFlatStringDictionary(this.SafeValue(this.Options, "networks", map[string]interface{} {})) // invert defined networks dictionary
    AddElementToObject(this.Options, "networksById", this.Extend(networkIdsToCodesGenerated, this.SafeValue(this.Options, "networksById", map[string]interface{} {}))) // support manually overriden "networksById" dictionary too
}
func  (this *Exchange) GetDefaultOptions() interface{}  {
    return map[string]interface{} {
        "defaultNetworkCodeReplacements": map[string]interface{} {
            "ETH": map[string]interface{} {
                "ERC20": "ETH",
            },
            "TRX": map[string]interface{} {
                "TRC20": "TRX",
            },
            "CRO": map[string]interface{} {
                "CRC20": "CRONOS",
            },
            "BRC20": map[string]interface{} {
                "BRC20": "BTC",
            },
        },
    }
}
func  (this *Exchange) SafeLedgerEntry(entry interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    currency = this.SafeCurrency(nil, currency)
    var direction interface{} = this.SafeString(entry, "direction")
    var before interface{} = this.SafeString(entry, "before")
    var after interface{} = this.SafeString(entry, "after")
    var amount interface{} = this.SafeString(entry, "amount")
    if IsTrue(!IsEqual(amount, nil)) {
        if IsTrue(IsTrue(IsEqual(before, nil)) && IsTrue(!IsEqual(after, nil))) {
            before = Precise.StringSub(after, amount)
        } else if IsTrue(IsTrue(!IsEqual(before, nil)) && IsTrue(IsEqual(after, nil))) {
            after = Precise.StringAdd(before, amount)
        }
    }
    if IsTrue(IsTrue(!IsEqual(before, nil)) && IsTrue(!IsEqual(after, nil))) {
        if IsTrue(IsEqual(direction, nil)) {
            if IsTrue(Precise.StringGt(before, after)) {
                direction = "out"
            }
            if IsTrue(Precise.StringGt(after, before)) {
                direction = "in"
            }
        }
    }
    var fee interface{} = this.SafeValue(entry, "fee")
    if IsTrue(!IsEqual(fee, nil)) {
        AddElementToObject(fee, "cost", this.SafeNumber(fee, "cost"))
    }
    var timestamp interface{} = this.SafeInteger(entry, "timestamp")
    var info interface{} = this.SafeDict(entry, "info", map[string]interface{} {})
    return map[string]interface{} {
        "id": this.SafeString(entry, "id"),
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "direction": direction,
        "account": this.SafeString(entry, "account"),
        "referenceId": this.SafeString(entry, "referenceId"),
        "referenceAccount": this.SafeString(entry, "referenceAccount"),
        "type": this.SafeString(entry, "type"),
        "currency": GetValue(currency, "code"),
        "amount": this.ParseNumber(amount),
        "before": this.ParseNumber(before),
        "after": this.ParseNumber(after),
        "status": this.SafeString(entry, "status"),
        "fee": fee,
        "info": info,
    }
}
func  (this *Exchange) SafeCurrencyStructure(currency interface{}) interface{}  {
    // derive data from networks: deposit, withdraw, active, fee, limits, precision
    var currencyDeposit interface{} = this.SafeBool(currency, "deposit")
    var currencyWithdraw interface{} = this.SafeBool(currency, "withdraw")
    var currencyActive interface{} = this.SafeBool(currency, "active")
    var networks interface{} = this.SafeDict(currency, "networks", map[string]interface{} {})
    var keys interface{} = ObjectKeys(networks)
    var length interface{} =     GetArrayLength(keys)
    if IsTrue(!IsEqual(length, 0)) {
        for i := 0; IsLessThan(i, length); i++ {
            var network interface{} = GetValue(networks, GetValue(keys, i))
            var deposit interface{} = this.SafeBool(network, "deposit")
            if IsTrue(IsTrue(IsEqual(currencyDeposit, nil)) || IsTrue(deposit)) {
                AddElementToObject(currency, "deposit", deposit)
            }
            var withdraw interface{} = this.SafeBool(network, "withdraw")
            if IsTrue(IsTrue(IsEqual(currencyWithdraw, nil)) || IsTrue(withdraw)) {
                AddElementToObject(currency, "withdraw", withdraw)
            }
            var active interface{} = this.SafeBool(network, "active")
            if IsTrue(IsTrue(IsEqual(currencyActive, nil)) || IsTrue(active)) {
                AddElementToObject(currency, "active", active)
            }
            // find lowest fee (which is more desired)
            var fee interface{} = this.SafeString(network, "fee")
            var feeMain interface{} = this.SafeString(currency, "fee")
            if IsTrue(IsTrue(IsEqual(feeMain, nil)) || IsTrue(Precise.StringLt(fee, feeMain))) {
                AddElementToObject(currency, "fee", this.ParseNumber(fee))
            }
            // find lowest precision (which is more desired)
            var precision interface{} = this.SafeString(network, "precision")
            var precisionMain interface{} = this.SafeString(currency, "precision")
            if IsTrue(IsTrue(IsEqual(precisionMain, nil)) || IsTrue(Precise.StringLt(precision, precisionMain))) {
                AddElementToObject(currency, "precision", this.ParseNumber(precision))
            }
            // limits
            var limits interface{} = this.SafeDict(network, "limits")
            var limitsMain interface{} = this.SafeDict(currency, "limits")
            if IsTrue(IsEqual(limitsMain, nil)) {
                AddElementToObject(currency, "limits", map[string]interface{} {})
            }
            // deposits
            var limitsDeposit interface{} = this.SafeDict(limits, "deposit")
            var limitsDepositMain interface{} = this.SafeDict(limitsMain, "deposit")
            if IsTrue(IsEqual(limitsDepositMain, nil)) {
                AddElementToObject(GetValue(currency, "limits"), "deposit", map[string]interface{} {})
            }
            var limitsDepositMin interface{} = this.SafeString(limitsDeposit, "min")
            var limitsDepositMax interface{} = this.SafeString(limitsDeposit, "max")
            var limitsDepositMinMain interface{} = this.SafeString(limitsDepositMain, "min")
            var limitsDepositMaxMain interface{} = this.SafeString(limitsDepositMain, "max")
            // find min
            if IsTrue(IsTrue(IsEqual(limitsDepositMinMain, nil)) || IsTrue(Precise.StringLt(limitsDepositMin, limitsDepositMinMain))) {
                AddElementToObject(GetValue(GetValue(currency, "limits"), "deposit"), "min", this.ParseNumber(limitsDepositMin))
            }
            // find max
            if IsTrue(IsTrue(IsEqual(limitsDepositMaxMain, nil)) || IsTrue(Precise.StringGt(limitsDepositMax, limitsDepositMaxMain))) {
                AddElementToObject(GetValue(GetValue(currency, "limits"), "deposit"), "max", this.ParseNumber(limitsDepositMax))
            }
            // withdrawals
            var limitsWithdraw interface{} = this.SafeDict(limits, "withdraw")
            var limitsWithdrawMain interface{} = this.SafeDict(limitsMain, "withdraw")
            if IsTrue(IsEqual(limitsWithdrawMain, nil)) {
                AddElementToObject(GetValue(currency, "limits"), "withdraw", map[string]interface{} {})
            }
            var limitsWithdrawMin interface{} = this.SafeString(limitsWithdraw, "min")
            var limitsWithdrawMax interface{} = this.SafeString(limitsWithdraw, "max")
            var limitsWithdrawMinMain interface{} = this.SafeString(limitsWithdrawMain, "min")
            var limitsWithdrawMaxMain interface{} = this.SafeString(limitsWithdrawMain, "max")
            // find min
            if IsTrue(IsTrue(IsEqual(limitsWithdrawMinMain, nil)) || IsTrue(Precise.StringLt(limitsWithdrawMin, limitsWithdrawMinMain))) {
                AddElementToObject(GetValue(GetValue(currency, "limits"), "withdraw"), "min", this.ParseNumber(limitsWithdrawMin))
            }
            // find max
            if IsTrue(IsTrue(IsEqual(limitsWithdrawMaxMain, nil)) || IsTrue(Precise.StringGt(limitsWithdrawMax, limitsWithdrawMaxMain))) {
                AddElementToObject(GetValue(GetValue(currency, "limits"), "withdraw"), "max", this.ParseNumber(limitsWithdrawMax))
            }
        }
    }
    return this.Extend(map[string]interface{} {
        "info": nil,
        "id": nil,
        "numericId": nil,
        "code": nil,
        "precision": nil,
        "type": nil,
        "name": nil,
        "active": nil,
        "deposit": nil,
        "withdraw": nil,
        "fee": nil,
        "fees": map[string]interface{} {},
        "networks": map[string]interface{} {},
        "limits": map[string]interface{} {
            "deposit": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "withdraw": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
        },
    }, currency)
}
func  (this *Exchange) SafeMarketStructure(optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var cleanStructure interface{} = map[string]interface{} {
        "id": nil,
        "lowercaseId": nil,
        "symbol": nil,
        "base": nil,
        "quote": nil,
        "settle": nil,
        "baseId": nil,
        "quoteId": nil,
        "settleId": nil,
        "type": nil,
        "spot": nil,
        "margin": nil,
        "swap": nil,
        "future": nil,
        "option": nil,
        "index": nil,
        "active": nil,
        "contract": nil,
        "linear": nil,
        "inverse": nil,
        "subType": nil,
        "taker": nil,
        "maker": nil,
        "contractSize": nil,
        "expiry": nil,
        "expiryDatetime": nil,
        "strike": nil,
        "optionType": nil,
        "precision": map[string]interface{} {
            "amount": nil,
            "price": nil,
            "cost": nil,
            "base": nil,
            "quote": nil,
        },
        "limits": map[string]interface{} {
            "leverage": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "amount": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "price": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "cost": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
        },
        "marginModes": map[string]interface{} {
            "cross": nil,
            "isolated": nil,
        },
        "created": nil,
        "info": nil,
    }
    if IsTrue(!IsEqual(market, nil)) {
        var result interface{} = this.Extend(cleanStructure, market)
        // set undefined swap/future/etc
        if IsTrue(GetValue(result, "spot")) {
            if IsTrue(IsEqual(GetValue(result, "contract"), nil)) {
                AddElementToObject(result, "contract", false)
            }
            if IsTrue(IsEqual(GetValue(result, "swap"), nil)) {
                AddElementToObject(result, "swap", false)
            }
            if IsTrue(IsEqual(GetValue(result, "future"), nil)) {
                AddElementToObject(result, "future", false)
            }
            if IsTrue(IsEqual(GetValue(result, "option"), nil)) {
                AddElementToObject(result, "option", false)
            }
            if IsTrue(IsEqual(GetValue(result, "index"), nil)) {
                AddElementToObject(result, "index", false)
            }
        }
        return result
    }
    return cleanStructure
}
func  (this *Exchange) SetMarkets(markets interface{}, optionalArgs ...interface{}) interface{}  {
    currencies := GetArg(optionalArgs, 0, nil)
    _ = currencies
    var values interface{} = []interface{}{}
    this.Markets_by_id = map[string]interface{} {}
    // handle marketId conflicts
    // we insert spot markets first
    var marketValues interface{} = this.SortBy(this.ToArray(markets), "spot", true, true)
    for i := 0; IsLessThan(i, GetArrayLength(marketValues)); i++ {
        var value interface{} = GetValue(marketValues, i)
        if IsTrue(InOp(this.Markets_by_id, GetValue(value, "id"))) {
            var marketsByIdArray interface{} =             GetValue(this.Markets_by_id, GetValue(value, "id"))
            AppendToArray(&marketsByIdArray,value)
            AddElementToObject(this.Markets_by_id, GetValue(value, "id"), marketsByIdArray)
        } else {
            AddElementToObject(this.Markets_by_id, GetValue(value, "id"), []interface{}{value})
        }
        var market interface{} = this.DeepExtend(this.SafeMarketStructure(), map[string]interface{} {
            "precision": this.Precision,
            "limits": this.Limits,
        }, GetValue(this.Fees, "trading"), value)
        if IsTrue(GetValue(market, "linear")) {
            AddElementToObject(market, "subType", "linear")
        } else if IsTrue(GetValue(market, "inverse")) {
            AddElementToObject(market, "subType", "inverse")
        } else {
            AddElementToObject(market, "subType", nil)
        }
        AppendToArray(&values,market)
    }
    this.Markets = this.IndexBy(values, "symbol")
    var marketsSortedBySymbol interface{} = this.Keysort(this.Markets)
    var marketsSortedById interface{} = this.Keysort(this.Markets_by_id)
    this.Symbols = ObjectKeys(marketsSortedBySymbol)
    this.Ids = ObjectKeys(marketsSortedById)
    if IsTrue(!IsEqual(currencies, nil)) {
        // currencies is always undefined when called in constructor but not when called from loadMarkets
        this.Currencies = this.DeepExtend(this.Currencies, currencies)
    } else {
        var baseCurrencies interface{} = []interface{}{}
        var quoteCurrencies interface{} = []interface{}{}
        for i := 0; IsLessThan(i, GetArrayLength(values)); i++ {
            var market interface{} = GetValue(values, i)
            var defaultCurrencyPrecision interface{} = Ternary(IsTrue((IsEqual(this.PrecisionMode, DECIMAL_PLACES))), 8, this.ParseNumber("1e-8"))
            var marketPrecision interface{} = this.SafeDict(market, "precision", map[string]interface{} {})
            if IsTrue(InOp(market, "base")) {
                var currency interface{} = this.SafeCurrencyStructure(map[string]interface{} {
                    "id": this.SafeString2(market, "baseId", "base"),
                    "numericId": this.SafeInteger(market, "baseNumericId"),
                    "code": this.SafeString(market, "base"),
                    "precision": this.SafeValue2(marketPrecision, "base", "amount", defaultCurrencyPrecision),
                })
                AppendToArray(&baseCurrencies,currency)
            }
            if IsTrue(InOp(market, "quote")) {
                var currency interface{} = this.SafeCurrencyStructure(map[string]interface{} {
                    "id": this.SafeString2(market, "quoteId", "quote"),
                    "numericId": this.SafeInteger(market, "quoteNumericId"),
                    "code": this.SafeString(market, "quote"),
                    "precision": this.SafeValue2(marketPrecision, "quote", "price", defaultCurrencyPrecision),
                })
                AppendToArray(&quoteCurrencies,currency)
            }
        }
        baseCurrencies = this.SortBy(baseCurrencies, "code", false, "")
        quoteCurrencies = this.SortBy(quoteCurrencies, "code", false, "")
        this.BaseCurrencies = this.IndexBy(baseCurrencies, "code")
        this.QuoteCurrencies = this.IndexBy(quoteCurrencies, "code")
        var allCurrencies interface{} = this.ArrayConcat(baseCurrencies, quoteCurrencies)
        var groupedCurrencies interface{} = this.GroupBy(allCurrencies, "code")
        var codes interface{} = ObjectKeys(groupedCurrencies)
        var resultingCurrencies interface{} = []interface{}{}
        for i := 0; IsLessThan(i, GetArrayLength(codes)); i++ {
            var code interface{} = GetValue(codes, i)
            var groupedCurrenciesCode interface{} = this.SafeList(groupedCurrencies, code, []interface{}{})
            var highestPrecisionCurrency interface{} = this.SafeValue(groupedCurrenciesCode, 0)
            for j := 1; IsLessThan(j, GetArrayLength(groupedCurrenciesCode)); j++ {
                var currentCurrency interface{} = GetValue(groupedCurrenciesCode, j)
                if IsTrue(IsEqual(this.PrecisionMode, TICK_SIZE)) {
                    highestPrecisionCurrency = Ternary(IsTrue((IsLessThan(GetValue(currentCurrency, "precision"), GetValue(highestPrecisionCurrency, "precision")))), currentCurrency, highestPrecisionCurrency)
                } else {
                    highestPrecisionCurrency = Ternary(IsTrue((IsGreaterThan(GetValue(currentCurrency, "precision"), GetValue(highestPrecisionCurrency, "precision")))), currentCurrency, highestPrecisionCurrency)
                }
            }
            AppendToArray(&resultingCurrencies,highestPrecisionCurrency)
        }
        var sortedCurrencies interface{} = this.SortBy(resultingCurrencies, "code")
        this.Currencies = this.DeepExtend(this.Currencies, this.IndexBy(sortedCurrencies, "code"))
    }
    this.Currencies_by_id = this.IndexBy(this.Currencies, "id")
    var currenciesSortedByCode interface{} = this.Keysort(this.Currencies)
    this.Codes = ObjectKeys(currenciesSortedByCode)
    return this.Markets
}
func  (this *Exchange) GetDescribeForExtendedWsExchange(currentRestInstance Exchange, parentRestInstance Exchange, wsBaseDescribe interface{}) interface{}  {
    var extendedRestDescribe interface{} = this.DeepExtend(parentRestInstance.Describe(), currentRestInstance.Describe())
    var superWithRestDescribe interface{} = this.DeepExtend(extendedRestDescribe, wsBaseDescribe)
    return superWithRestDescribe
}
func  (this *Exchange) SafeBalance(balance interface{}) interface{}  {
    var balances interface{} = this.Omit(balance, []interface{}{"info", "timestamp", "datetime", "free", "used", "total"})
    var codes interface{} = ObjectKeys(balances)
    AddElementToObject(balance, "free", map[string]interface{} {})
    AddElementToObject(balance, "used", map[string]interface{} {})
    AddElementToObject(balance, "total", map[string]interface{} {})
    var debtBalance interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(codes)); i++ {
        var code interface{} = GetValue(codes, i)
        var total interface{} = this.SafeString(GetValue(balance, code), "total")
        var free interface{} = this.SafeString(GetValue(balance, code), "free")
        var used interface{} = this.SafeString(GetValue(balance, code), "used")
        var debt interface{} = this.SafeString(GetValue(balance, code), "debt")
        if IsTrue(IsTrue(IsTrue((IsEqual(total, nil))) && IsTrue((!IsEqual(free, nil)))) && IsTrue((!IsEqual(used, nil)))) {
            total = Precise.StringAdd(free, used)
        }
        if IsTrue(IsTrue(IsTrue((IsEqual(free, nil))) && IsTrue((!IsEqual(total, nil)))) && IsTrue((!IsEqual(used, nil)))) {
            free = Precise.StringSub(total, used)
        }
        if IsTrue(IsTrue(IsTrue((IsEqual(used, nil))) && IsTrue((!IsEqual(total, nil)))) && IsTrue((!IsEqual(free, nil)))) {
            used = Precise.StringSub(total, free)
        }
        AddElementToObject(GetValue(balance, code), "free", this.ParseNumber(free))
        AddElementToObject(GetValue(balance, code), "used", this.ParseNumber(used))
        AddElementToObject(GetValue(balance, code), "total", this.ParseNumber(total))
        AddElementToObject(GetValue(balance, "free"), code, GetValue(GetValue(balance, code), "free"))
        AddElementToObject(GetValue(balance, "used"), code, GetValue(GetValue(balance, code), "used"))
        AddElementToObject(GetValue(balance, "total"), code, GetValue(GetValue(balance, code), "total"))
        if IsTrue(!IsEqual(debt, nil)) {
            AddElementToObject(GetValue(balance, code), "debt", this.ParseNumber(debt))
            AddElementToObject(debtBalance, code, GetValue(GetValue(balance, code), "debt"))
        }
    }
    var debtBalanceArray interface{} = ObjectKeys(debtBalance)
    var length interface{} =     GetArrayLength(debtBalanceArray)
    if IsTrue(length) {
        AddElementToObject(balance, "debt", debtBalance)
    }
    return balance
}
func  (this *Exchange) SafeOrder(order interface{}, optionalArgs ...interface{}) interface{}  {
    // parses numbers as strings
    // * it is important pass the trades as unparsed rawTrades
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var amount interface{} = this.OmitZero(this.SafeString(order, "amount"))
    var remaining interface{} = this.SafeString(order, "remaining")
    var filled interface{} = this.SafeString(order, "filled")
    var cost interface{} = this.SafeString(order, "cost")
    var average interface{} = this.OmitZero(this.SafeString(order, "average"))
    var price interface{} = this.OmitZero(this.SafeString(order, "price"))
    var lastTradeTimeTimestamp interface{} = this.SafeInteger(order, "lastTradeTimestamp")
    var symbol interface{} = this.SafeString(order, "symbol")
    var side interface{} = this.SafeString(order, "side")
    var status interface{} = this.SafeString(order, "status")
    var parseFilled interface{} =     (IsEqual(filled, nil))
    var parseCost interface{} =     (IsEqual(cost, nil))
    var parseLastTradeTimeTimestamp interface{} =     (IsEqual(lastTradeTimeTimestamp, nil))
    var fee interface{} = this.SafeValue(order, "fee")
    var parseFee interface{} =     (IsEqual(fee, nil))
    var parseFees interface{} = IsEqual(this.SafeValue(order, "fees"), nil)
    var parseSymbol interface{} = IsEqual(symbol, nil)
    var parseSide interface{} = IsEqual(side, nil)
    var shouldParseFees interface{} = IsTrue(parseFee) || IsTrue(parseFees)
    var fees interface{} = this.SafeList(order, "fees", []interface{}{})
    var trades interface{} = []interface{}{}
    var isTriggerOrSLTpOrder interface{} =     (IsTrue((IsTrue(!IsEqual(this.SafeString(order, "triggerPrice"), nil)) || IsTrue((!IsEqual(this.SafeString(order, "stopLossPrice"), nil))))) || IsTrue((!IsEqual(this.SafeString(order, "takeProfitPrice"), nil))))
    if IsTrue(IsTrue(IsTrue(parseFilled) || IsTrue(parseCost)) || IsTrue(shouldParseFees)) {
        var rawTrades interface{} = this.SafeValue(order, "trades", trades)
        // const oldNumber = this.number;
        // we parse trades as strings here!
        // i don't think this is needed anymore
        // (this as any).number = String;
        var firstTrade interface{} = this.SafeValue(rawTrades, 0)
        // parse trades if they haven't already been parsed
        var tradesAreParsed interface{} =         (IsTrue(IsTrue((!IsEqual(firstTrade, nil))) && IsTrue((InOp(firstTrade, "info")))) && IsTrue((InOp(firstTrade, "id"))))
        if !IsTrue(tradesAreParsed) {
            trades = this.ParseTrades(rawTrades, market)
        } else {
            trades = rawTrades
        }
        // this.number = oldNumber; why parse trades as strings if you read the value using `safeString` ?
        var tradesLength interface{} = 0
        var isArray interface{} = IsArray(trades)
        if IsTrue(isArray) {
            tradesLength = GetArrayLength(trades)
        }
        if IsTrue(IsTrue(isArray) && IsTrue((IsGreaterThan(tradesLength, 0)))) {
            // move properties that are defined in trades up into the order
            if IsTrue(IsEqual(GetValue(order, "symbol"), nil)) {
                AddElementToObject(order, "symbol", GetValue(GetValue(trades, 0), "symbol"))
            }
            if IsTrue(IsEqual(GetValue(order, "side"), nil)) {
                AddElementToObject(order, "side", GetValue(GetValue(trades, 0), "side"))
            }
            if IsTrue(IsEqual(GetValue(order, "type"), nil)) {
                AddElementToObject(order, "type", GetValue(GetValue(trades, 0), "type"))
            }
            if IsTrue(IsEqual(GetValue(order, "id"), nil)) {
                AddElementToObject(order, "id", GetValue(GetValue(trades, 0), "order"))
            }
            if IsTrue(parseFilled) {
                filled = "0"
            }
            if IsTrue(parseCost) {
                cost = "0"
            }
            for i := 0; IsLessThan(i, GetArrayLength(trades)); i++ {
                var trade interface{} = GetValue(trades, i)
                var tradeAmount interface{} = this.SafeString(trade, "amount")
                if IsTrue(IsTrue(parseFilled) && IsTrue((!IsEqual(tradeAmount, nil)))) {
                    filled = Precise.StringAdd(filled, tradeAmount)
                }
                var tradeCost interface{} = this.SafeString(trade, "cost")
                if IsTrue(IsTrue(parseCost) && IsTrue((!IsEqual(tradeCost, nil)))) {
                    cost = Precise.StringAdd(cost, tradeCost)
                }
                if IsTrue(parseSymbol) {
                    symbol = this.SafeString(trade, "symbol")
                }
                if IsTrue(parseSide) {
                    side = this.SafeString(trade, "side")
                }
                var tradeTimestamp interface{} = this.SafeValue(trade, "timestamp")
                if IsTrue(IsTrue(parseLastTradeTimeTimestamp) && IsTrue((!IsEqual(tradeTimestamp, nil)))) {
                    if IsTrue(IsEqual(lastTradeTimeTimestamp, nil)) {
                        lastTradeTimeTimestamp = tradeTimestamp
                    } else {
                        lastTradeTimeTimestamp = mathMax(lastTradeTimeTimestamp, tradeTimestamp)
                    }
                }
                if IsTrue(shouldParseFees) {
                    var tradeFees interface{} = this.SafeValue(trade, "fees")
                    if IsTrue(!IsEqual(tradeFees, nil)) {
                        for j := 0; IsLessThan(j, GetArrayLength(tradeFees)); j++ {
                            var tradeFee interface{} = GetValue(tradeFees, j)
                            AppendToArray(&fees,this.Extend(map[string]interface{} {}, tradeFee))
                        }
                    } else {
                        var tradeFee interface{} = this.SafeValue(trade, "fee")
                        if IsTrue(!IsEqual(tradeFee, nil)) {
                            AppendToArray(&fees,this.Extend(map[string]interface{} {}, tradeFee))
                        }
                    }
                }
            }
        }
    }
    if IsTrue(shouldParseFees) {
        var reducedFees interface{} = Ternary(IsTrue(this.ReduceFees), this.ReduceFeesByCurrency(fees), fees)
        var reducedLength interface{} =         GetArrayLength(reducedFees)
        for i := 0; IsLessThan(i, reducedLength); i++ {
            AddElementToObject(GetValue(reducedFees, i), "cost", this.SafeNumber(GetValue(reducedFees, i), "cost"))
            if IsTrue(InOp(GetValue(reducedFees, i), "rate")) {
                AddElementToObject(GetValue(reducedFees, i), "rate", this.SafeNumber(GetValue(reducedFees, i), "rate"))
            }
        }
        if IsTrue(!IsTrue(parseFee) && IsTrue((IsEqual(reducedLength, 0)))) {
            // copy fee to avoid modification by reference
            var feeCopy interface{} = this.DeepExtend(fee)
            AddElementToObject(feeCopy, "cost", this.SafeNumber(feeCopy, "cost"))
            if IsTrue(InOp(feeCopy, "rate")) {
                AddElementToObject(feeCopy, "rate", this.SafeNumber(feeCopy, "rate"))
            }
            AppendToArray(&reducedFees,feeCopy)
        }
        AddElementToObject(order, "fees", reducedFees)
        if IsTrue(IsTrue(parseFee) && IsTrue((IsEqual(reducedLength, 1)))) {
            AddElementToObject(order, "fee", GetValue(reducedFees, 0))
        }
    }
    if IsTrue(IsEqual(amount, nil)) {
        // ensure amount = filled + remaining
        if IsTrue(IsTrue(!IsEqual(filled, nil)) && IsTrue(!IsEqual(remaining, nil))) {
            amount = Precise.StringAdd(filled, remaining)
        } else if IsTrue(IsEqual(status, "closed")) {
            amount = filled
        }
    }
    if IsTrue(IsEqual(filled, nil)) {
        if IsTrue(IsTrue(!IsEqual(amount, nil)) && IsTrue(!IsEqual(remaining, nil))) {
            filled = Precise.StringSub(amount, remaining)
        } else if IsTrue(IsTrue(IsEqual(status, "closed")) && IsTrue(!IsEqual(amount, nil))) {
            filled = amount
        }
    }
    if IsTrue(IsEqual(remaining, nil)) {
        if IsTrue(IsTrue(!IsEqual(amount, nil)) && IsTrue(!IsEqual(filled, nil))) {
            remaining = Precise.StringSub(amount, filled)
        } else if IsTrue(IsEqual(status, "closed")) {
            remaining = "0"
        }
    }
    // ensure that the average field is calculated correctly
    var inverse interface{} = this.SafeBool(market, "inverse", false)
    var contractSize interface{} = this.NumberToString(this.SafeValue(market, "contractSize", 1))
    // inverse
    // price = filled * contract size / cost
    //
    // linear
    // price = cost / (filled * contract size)
    if IsTrue(IsEqual(average, nil)) {
        if IsTrue(IsTrue(IsTrue((!IsEqual(filled, nil))) && IsTrue((!IsEqual(cost, nil)))) && IsTrue(Precise.StringGt(filled, "0"))) {
            var filledTimesContractSize interface{} = Precise.StringMul(filled, contractSize)
            if IsTrue(inverse) {
                average = Precise.StringDiv(filledTimesContractSize, cost)
            } else {
                average = Precise.StringDiv(cost, filledTimesContractSize)
            }
        }
    }
    // similarly
    // inverse
    // cost = filled * contract size / price
    //
    // linear
    // cost = filled * contract size * price
    var costPriceExists interface{} = IsTrue((!IsEqual(average, nil))) || IsTrue((!IsEqual(price, nil)))
    if IsTrue(IsTrue(IsTrue(parseCost) && IsTrue((!IsEqual(filled, nil)))) && IsTrue(costPriceExists)) {
        var multiplyPrice interface{} = nil
        if IsTrue(IsEqual(average, nil)) {
            multiplyPrice = price
        } else {
            multiplyPrice = average
        }
        // contract trading
        var filledTimesContractSize interface{} = Precise.StringMul(filled, contractSize)
        if IsTrue(inverse) {
            cost = Precise.StringDiv(filledTimesContractSize, multiplyPrice)
        } else {
            cost = Precise.StringMul(filledTimesContractSize, multiplyPrice)
        }
    }
    // support for market orders
    var orderType interface{} = this.SafeValue(order, "type")
    var emptyPrice interface{} = IsTrue((IsEqual(price, nil))) || IsTrue(Precise.StringEquals(price, "0"))
    if IsTrue(IsTrue(emptyPrice) && IsTrue((IsEqual(orderType, "market")))) {
        price = average
    }
    // we have trades with string values at this point so we will mutate them
    for i := 0; IsLessThan(i, GetArrayLength(trades)); i++ {
        var entry interface{} = GetValue(trades, i)
        AddElementToObject(entry, "amount", this.SafeNumber(entry, "amount"))
        AddElementToObject(entry, "price", this.SafeNumber(entry, "price"))
        AddElementToObject(entry, "cost", this.SafeNumber(entry, "cost"))
        var tradeFee interface{} = this.SafeDict(entry, "fee", map[string]interface{} {})
        AddElementToObject(tradeFee, "cost", this.SafeNumber(tradeFee, "cost"))
        if IsTrue(InOp(tradeFee, "rate")) {
            AddElementToObject(tradeFee, "rate", this.SafeNumber(tradeFee, "rate"))
        }
        var entryFees interface{} = this.SafeList(entry, "fees", []interface{}{})
        for j := 0; IsLessThan(j, GetArrayLength(entryFees)); j++ {
            AddElementToObject(GetValue(entryFees, j), "cost", this.SafeNumber(GetValue(entryFees, j), "cost"))
        }
        AddElementToObject(entry, "fees", entryFees)
        AddElementToObject(entry, "fee", tradeFee)
    }
    var timeInForce interface{} = this.SafeString(order, "timeInForce")
    var postOnly interface{} = this.SafeValue(order, "postOnly")
    // timeInForceHandling
    if IsTrue(IsEqual(timeInForce, nil)) {
        if IsTrue(!IsTrue(isTriggerOrSLTpOrder) && IsTrue((IsEqual(this.SafeString(order, "type"), "market")))) {
            timeInForce = "IOC"
        }
        // allow postOnly override
        if IsTrue(postOnly) {
            timeInForce = "PO"
        }
    } else if IsTrue(IsEqual(postOnly, nil)) {
        // timeInForce is not undefined here
        postOnly = IsEqual(timeInForce, "PO")
    }
    var timestamp interface{} = this.SafeInteger(order, "timestamp")
    var lastUpdateTimestamp interface{} = this.SafeInteger(order, "lastUpdateTimestamp")
    var datetime interface{} = this.SafeString(order, "datetime")
    if IsTrue(IsEqual(datetime, nil)) {
        datetime = this.Iso8601(timestamp)
    }
    var triggerPrice interface{} = this.ParseNumber(this.SafeString2(order, "triggerPrice", "stopPrice"))
    var takeProfitPrice interface{} = this.ParseNumber(this.SafeString(order, "takeProfitPrice"))
    var stopLossPrice interface{} = this.ParseNumber(this.SafeString(order, "stopLossPrice"))
    return this.Extend(order, map[string]interface{} {
        "id": this.SafeString(order, "id"),
        "clientOrderId": this.SafeString(order, "clientOrderId"),
        "timestamp": timestamp,
        "datetime": datetime,
        "symbol": symbol,
        "type": this.SafeString(order, "type"),
        "side": side,
        "lastTradeTimestamp": lastTradeTimeTimestamp,
        "lastUpdateTimestamp": lastUpdateTimestamp,
        "price": this.ParseNumber(price),
        "amount": this.ParseNumber(amount),
        "cost": this.ParseNumber(cost),
        "average": this.ParseNumber(average),
        "filled": this.ParseNumber(filled),
        "remaining": this.ParseNumber(remaining),
        "timeInForce": timeInForce,
        "postOnly": postOnly,
        "trades": trades,
        "reduceOnly": this.SafeValue(order, "reduceOnly"),
        "stopPrice": triggerPrice,
        "triggerPrice": triggerPrice,
        "takeProfitPrice": takeProfitPrice,
        "stopLossPrice": stopLossPrice,
        "status": status,
        "fee": this.SafeValue(order, "fee"),
    })
}
func  (this *Exchange) ParseOrders(orders interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // the value of orders is either a dict or a list
    //
    // dict
    //
    //     {
    //         'id1': { ... },
    //         'id2': { ... },
    //         'id3': { ... },
    //         ...
    //     }
    //
    // list
    //
    //     [
    //         { 'id': 'id1', ... },
    //         { 'id': 'id2', ... },
    //         { 'id': 'id3', ... },
    //         ...
    //     ]
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    params := GetArg(optionalArgs, 3, map[string]interface{} {})
    _ = params
    var results interface{} = []interface{}{}
    if IsTrue(IsArray(orders)) {
        for i := 0; IsLessThan(i, GetArrayLength(orders)); i++ {

            var parsed interface{} = this.DerivedExchange.ParseOrder(GetValue(orders, i), market)
            PanicOnError(parsed) // don't inline this call
            var order interface{} = this.Extend(parsed, params)
            AppendToArray(&results,order)
        }
    } else {
        var ids interface{} = ObjectKeys(orders)
        for i := 0; IsLessThan(i, GetArrayLength(ids)); i++ {
            var id interface{} = GetValue(ids, i)
            var idExtended interface{} = this.Extend(map[string]interface{} {
                "id": id,
            }, GetValue(orders, id))

            var parsedOrder interface{} = this.DerivedExchange.ParseOrder(idExtended, market)
            PanicOnError(parsedOrder) // don't  inline these calls
            var order interface{} = this.Extend(parsedOrder, params)
            AppendToArray(&results,order)
        }
    }
    results = this.SortBy(results, "timestamp")
    var symbol interface{} = Ternary(IsTrue((!IsEqual(market, nil))), GetValue(market, "symbol"), nil)
    return this.FilterBySymbolSinceLimit(results, symbol, since, limit)
}
func  (this *Exchange) CalculateFee(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, price interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @method
    * @description calculates the presumptive fee that would be charged for an order
    * @param {string} symbol unified market symbol
    * @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 on most exchanges, or number of contracts
    * @param {float} price the price for the order to be filled at, in units of the quote currency
    * @param {string} takerOrMaker 'taker' or 'maker'
    * @param {object} params
    * @returns {object} contains the rate, the percentage multiplied to the order amount to obtain the fee amount, and cost, the total value of the fee in units of the quote currency, for the order
    */
    takerOrMaker := GetArg(optionalArgs, 0, "taker")
    _ = takerOrMaker
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    if IsTrue(IsTrue(IsEqual(typeVar, "market")) && IsTrue(IsEqual(takerOrMaker, "maker"))) {
        panic(ArgumentsRequired(Add(this.Id, " calculateFee() - you have provided incompatible arguments - \"market\" type order can not be \"maker\". Change either the \"type\" or the \"takerOrMaker\" argument to calculate the fee.")))
    }
    var market interface{} = GetValue(this.Markets, symbol)
    var feeSide interface{} = this.SafeString(market, "feeSide", "quote")
    var useQuote interface{} = nil
    if IsTrue(IsEqual(feeSide, "get")) {
        // the fee is always in the currency you get
        useQuote = IsEqual(side, "sell")
    } else if IsTrue(IsEqual(feeSide, "give")) {
        // the fee is always in the currency you give
        useQuote = IsEqual(side, "buy")
    } else {
        // the fee is always in feeSide currency
        useQuote = IsEqual(feeSide, "quote")
    }
    var cost interface{} = this.NumberToString(amount)
    var key interface{} = nil
    if IsTrue(useQuote) {
        var priceString interface{} = this.NumberToString(price)
        cost = Precise.StringMul(cost, priceString)
        key = "quote"
    } else {
        key = "base"
    }
    // for derivatives, the fee is in 'settle' currency
    if !IsTrue(GetValue(market, "spot")) {
        key = "settle"
    }
    // even if `takerOrMaker` argument was set to 'maker', for 'market' orders we should forcefully override it to 'taker'
    if IsTrue(IsEqual(typeVar, "market")) {
        takerOrMaker = "taker"
    }
    var rate interface{} = this.SafeString(market, takerOrMaker)
    cost = Precise.StringMul(cost, rate)
    return map[string]interface{} {
        "type": takerOrMaker,
        "currency": GetValue(market, key),
        "rate": this.ParseNumber(rate),
        "cost": this.ParseNumber(cost),
    }
}
func  (this *Exchange) SafeLiquidation(liquidation interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var contracts interface{} = this.SafeString(liquidation, "contracts")
    var contractSize interface{} = this.SafeString(market, "contractSize")
    var price interface{} = this.SafeString(liquidation, "price")
    var baseValue interface{} = this.SafeString(liquidation, "baseValue")
    var quoteValue interface{} = this.SafeString(liquidation, "quoteValue")
    if IsTrue(IsTrue(IsTrue(IsTrue((IsEqual(baseValue, nil))) && IsTrue((!IsEqual(contracts, nil)))) && IsTrue((!IsEqual(contractSize, nil)))) && IsTrue((!IsEqual(price, nil)))) {
        baseValue = Precise.StringMul(contracts, contractSize)
    }
    if IsTrue(IsTrue(IsTrue((IsEqual(quoteValue, nil))) && IsTrue((!IsEqual(baseValue, nil)))) && IsTrue((!IsEqual(price, nil)))) {
        quoteValue = Precise.StringMul(baseValue, price)
    }
    AddElementToObject(liquidation, "contracts", this.ParseNumber(contracts))
    AddElementToObject(liquidation, "contractSize", this.ParseNumber(contractSize))
    AddElementToObject(liquidation, "price", this.ParseNumber(price))
    AddElementToObject(liquidation, "baseValue", this.ParseNumber(baseValue))
    AddElementToObject(liquidation, "quoteValue", this.ParseNumber(quoteValue))
    return liquidation
}
func  (this *Exchange) SafeTrade(trade interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var amount interface{} = this.SafeString(trade, "amount")
    var price interface{} = this.SafeString(trade, "price")
    var cost interface{} = this.SafeString(trade, "cost")
    if IsTrue(IsEqual(cost, nil)) {
        // contract trading
        var contractSize interface{} = this.SafeString(market, "contractSize")
        var multiplyPrice interface{} = price
        if IsTrue(!IsEqual(contractSize, nil)) {
            var inverse interface{} = this.SafeBool(market, "inverse", false)
            if IsTrue(inverse) {
                multiplyPrice = Precise.StringDiv("1", price)
            }
            multiplyPrice = Precise.StringMul(multiplyPrice, contractSize)
        }
        cost = Precise.StringMul(multiplyPrice, amount)
    }
    resultFeeresultFeesVariable := this.ParsedFeeAndFees(trade);
    resultFee := GetValue(resultFeeresultFeesVariable,0);
    resultFees := GetValue(resultFeeresultFeesVariable,1)
    AddElementToObject(trade, "fee", resultFee)
    AddElementToObject(trade, "fees", resultFees)
    AddElementToObject(trade, "amount", this.ParseNumber(amount))
    AddElementToObject(trade, "price", this.ParseNumber(price))
    AddElementToObject(trade, "cost", this.ParseNumber(cost))
    return trade
}
func  (this *Exchange) ParsedFeeAndFees(container interface{}) interface{}  {
    var fee interface{} = this.SafeDict(container, "fee")
    var fees interface{} = this.SafeList(container, "fees")
    var feeDefined interface{} = !IsEqual(fee, nil)
    var feesDefined interface{} = !IsEqual(fees, nil)
    // parsing only if at least one of them is defined
    var shouldParseFees interface{} =     (IsTrue(feeDefined) || IsTrue(feesDefined))
    if IsTrue(shouldParseFees) {
        if IsTrue(feeDefined) {
            fee = this.ParseFeeNumeric(fee)
        }
        if !IsTrue(feesDefined) {
            // just set it directly, no further processing needed
            fees = []interface{}{fee}
        }
        // 'fees' were set, so reparse them
        var reducedFees interface{} = Ternary(IsTrue(this.ReduceFees), this.ReduceFeesByCurrency(fees), fees)
        var reducedLength interface{} =         GetArrayLength(reducedFees)
        for i := 0; IsLessThan(i, reducedLength); i++ {
            AddElementToObject(reducedFees, i, this.ParseFeeNumeric(GetValue(reducedFees, i)))
        }
        fees = reducedFees
        if IsTrue(IsEqual(reducedLength, 1)) {
            fee = GetValue(reducedFees, 0)
        } else if IsTrue(IsEqual(reducedLength, 0)) {
            fee = nil
        }
    }
    // in case `fee & fees` are undefined, set `fees` as empty array
    if IsTrue(IsEqual(fee, nil)) {
        fee = map[string]interface{} {
            "cost": nil,
            "currency": nil,
        }
    }
    if IsTrue(IsEqual(fees, nil)) {
        fees = []interface{}{}
    }
    return []interface{}{fee, fees}
}
func  (this *Exchange) ParseFeeNumeric(fee interface{}) interface{}  {
    AddElementToObject(fee, "cost", this.SafeNumber(fee, "cost")) // ensure numeric
    if IsTrue(InOp(fee, "rate")) {
        AddElementToObject(fee, "rate", this.SafeNumber(fee, "rate"))
    }
    return fee
}
func  (this *Exchange) FindNearestCeiling(arr interface{}, providedValue interface{}) interface{}  {
    //  i.e. findNearestCeiling ([ 10, 30, 50],  23) returns 30
    var length interface{} =     GetArrayLength(arr)
    for i := 0; IsLessThan(i, length); i++ {
        var current interface{} = GetValue(arr, i)
        if IsTrue(IsLessThanOrEqual(providedValue, current)) {
            return current
        }
    }
    return GetValue(arr, Subtract(length, 1))
}
func  (this *Exchange) InvertFlatStringDictionary(dict interface{}) interface{}  {
    var reversed interface{} = map[string]interface{} {}
    var keys interface{} = ObjectKeys(dict)
    for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
        var key interface{} = GetValue(keys, i)
        var value interface{} = GetValue(dict, key)
        if IsTrue(IsString(value)) {
            AddElementToObject(reversed, value, key)
        }
    }
    return reversed
}
func  (this *Exchange) ReduceFeesByCurrency(fees interface{}) interface{}  {
    //
    // this function takes a list of fee structures having the following format
    //
    //     string = true
    //
    //     [
    //         { 'currency': 'BTC', 'cost': '0.1' },
    //         { 'currency': 'BTC', 'cost': '0.2'  },
    //         { 'currency': 'BTC', 'cost': '0.2', 'rate': '0.00123' },
    //         { 'currency': 'BTC', 'cost': '0.4', 'rate': '0.00123' },
    //         { 'currency': 'BTC', 'cost': '0.5', 'rate': '0.00456' },
    //         { 'currency': 'USDT', 'cost': '12.3456' },
    //     ]
    //
    //     string = false
    //
    //     [
    //         { 'currency': 'BTC', 'cost': 0.1 },
    //         { 'currency': 'BTC', 'cost': 0.2 },
    //         { 'currency': 'BTC', 'cost': 0.2, 'rate': 0.00123 },
    //         { 'currency': 'BTC', 'cost': 0.4, 'rate': 0.00123 },
    //         { 'currency': 'BTC', 'cost': 0.5, 'rate': 0.00456 },
    //         { 'currency': 'USDT', 'cost': 12.3456 },
    //     ]
    //
    // and returns a reduced fee list, where fees are summed per currency and rate (if any)
    //
    //     string = true
    //
    //     [
    //         { 'currency': 'BTC', 'cost': '0.4'  },
    //         { 'currency': 'BTC', 'cost': '0.6', 'rate': '0.00123' },
    //         { 'currency': 'BTC', 'cost': '0.5', 'rate': '0.00456' },
    //         { 'currency': 'USDT', 'cost': '12.3456' },
    //     ]
    //
    //     string  = false
    //
    //     [
    //         { 'currency': 'BTC', 'cost': 0.3  },
    //         { 'currency': 'BTC', 'cost': 0.6, 'rate': 0.00123 },
    //         { 'currency': 'BTC', 'cost': 0.5, 'rate': 0.00456 },
    //         { 'currency': 'USDT', 'cost': 12.3456 },
    //     ]
    //
    var reduced interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(fees)); i++ {
        var fee interface{} = GetValue(fees, i)
        var code interface{} = this.SafeString(fee, "currency")
        var feeCurrencyCode interface{} = Ternary(IsTrue(!IsEqual(code, nil)), code, ToString(i))
        if IsTrue(!IsEqual(feeCurrencyCode, nil)) {
            var rate interface{} = this.SafeString(fee, "rate")
            var cost interface{} = this.SafeString(fee, "cost")
            if IsTrue(IsEqual(cost, nil)) {
                continue
            }
            if !IsTrue((InOp(reduced, feeCurrencyCode))) {
                AddElementToObject(reduced, feeCurrencyCode, map[string]interface{} {})
            }
            var rateKey interface{} = Ternary(IsTrue((IsEqual(rate, nil))), "", rate)
            if IsTrue(InOp(GetValue(reduced, feeCurrencyCode), rateKey)) {
                AddElementToObject(GetValue(GetValue(reduced, feeCurrencyCode), rateKey), "cost", Precise.StringAdd(GetValue(GetValue(GetValue(reduced, feeCurrencyCode), rateKey), "cost"), cost))
            } else {
                AddElementToObject(GetValue(reduced, feeCurrencyCode), rateKey, map[string]interface{} {
    "currency": code,
    "cost": cost,
})
                if IsTrue(!IsEqual(rate, nil)) {
                    AddElementToObject(GetValue(GetValue(reduced, feeCurrencyCode), rateKey), "rate", rate)
                }
            }
        }
    }
    var result interface{} = []interface{}{}
    var feeValues interface{} = ObjectValues(reduced)
    for i := 0; IsLessThan(i, GetArrayLength(feeValues)); i++ {
        var reducedFeeValues interface{} = ObjectValues(GetValue(feeValues, i))
        result = this.ArrayConcat(result, reducedFeeValues)
    }
    return result
}
func  (this *Exchange) SafeTicker(ticker interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var open interface{} = this.OmitZero(this.SafeString(ticker, "open"))
    var close interface{} = this.OmitZero(this.SafeString(ticker, "close"))
    var last interface{} = this.OmitZero(this.SafeString(ticker, "last"))
    var change interface{} = this.OmitZero(this.SafeString(ticker, "change"))
    var percentage interface{} = this.OmitZero(this.SafeString(ticker, "percentage"))
    var average interface{} = this.OmitZero(this.SafeString(ticker, "average"))
    var vwap interface{} = this.SafeString(ticker, "vwap")
    var baseVolume interface{} = this.SafeString(ticker, "baseVolume")
    var quoteVolume interface{} = this.SafeString(ticker, "quoteVolume")
    if IsTrue(IsEqual(vwap, nil)) {
        vwap = Precise.StringDiv(this.OmitZero(quoteVolume), baseVolume)
    }
    if IsTrue(IsTrue((!IsEqual(last, nil))) && IsTrue((IsEqual(close, nil)))) {
        close = last
    } else if IsTrue(IsTrue((IsEqual(last, nil))) && IsTrue((!IsEqual(close, nil)))) {
        last = close
    }
    if IsTrue(IsTrue((!IsEqual(last, nil))) && IsTrue((!IsEqual(open, nil)))) {
        if IsTrue(IsEqual(change, nil)) {
            change = Precise.StringSub(last, open)
        }
        if IsTrue(IsEqual(average, nil)) {
            var precision interface{} = 18
            if IsTrue(IsTrue(!IsEqual(market, nil)) && IsTrue(this.IsTickPrecision())) {
                var marketPrecision interface{} = this.SafeDict(market, "precision")
                var precisionPrice interface{} = this.SafeString(marketPrecision, "price")
                if IsTrue(!IsEqual(precisionPrice, nil)) {
                    precision = this.PrecisionFromString(precisionPrice)
                }
            }
            average = Precise.StringDiv(Precise.StringAdd(last, open), "2", precision)
        }
    }
    if IsTrue(IsTrue(IsTrue(IsTrue((IsEqual(percentage, nil))) && IsTrue((!IsEqual(change, nil)))) && IsTrue((!IsEqual(open, nil)))) && IsTrue(Precise.StringGt(open, "0"))) {
        percentage = Precise.StringMul(Precise.StringDiv(change, open), "100")
    }
    if IsTrue(IsTrue(IsTrue((IsEqual(change, nil))) && IsTrue((!IsEqual(percentage, nil)))) && IsTrue((!IsEqual(open, nil)))) {
        change = Precise.StringDiv(Precise.StringMul(percentage, open), "100")
    }
    if IsTrue(IsTrue(IsTrue((IsEqual(open, nil))) && IsTrue((!IsEqual(last, nil)))) && IsTrue((!IsEqual(change, nil)))) {
        open = Precise.StringSub(last, change)
    }
    // timestamp and symbol operations don't belong in safeTicker
    // they should be done in the derived classes
    return this.Extend(ticker, map[string]interface{} {
        "bid": this.ParseNumber(this.OmitZero(this.SafeString(ticker, "bid"))),
        "bidVolume": this.SafeNumber(ticker, "bidVolume"),
        "ask": this.ParseNumber(this.OmitZero(this.SafeString(ticker, "ask"))),
        "askVolume": this.SafeNumber(ticker, "askVolume"),
        "high": this.ParseNumber(this.OmitZero(this.SafeString(ticker, "high"))),
        "low": this.ParseNumber(this.OmitZero(this.SafeString(ticker, "low"))),
        "open": this.ParseNumber(this.OmitZero(open)),
        "close": this.ParseNumber(this.OmitZero(close)),
        "last": this.ParseNumber(this.OmitZero(last)),
        "change": this.ParseNumber(change),
        "percentage": this.ParseNumber(percentage),
        "average": this.ParseNumber(average),
        "vwap": this.ParseNumber(vwap),
        "baseVolume": this.ParseNumber(baseVolume),
        "quoteVolume": this.ParseNumber(quoteVolume),
        "previousClose": this.SafeNumber(ticker, "previousClose"),
        "indexPrice": this.SafeNumber(ticker, "indexPrice"),
        "markPrice": this.SafeNumber(ticker, "markPrice"),
    })
}
func  (this *Exchange) FetchBorrowRate(code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchBorrowRate is deprecated, please use fetchCrossBorrowRate or fetchIsolatedBorrowRate instead")))
        
            }()
            return ch
        }
func  (this *Exchange) RepayCrossMargin(code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " repayCrossMargin is not support yet")))
        
            }()
            return ch
        }
func  (this *Exchange) RepayIsolatedMargin(symbol interface{}, code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " repayIsolatedMargin is not support yet")))
        
            }()
            return ch
        }
func  (this *Exchange) BorrowCrossMargin(code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " borrowCrossMargin is not support yet")))
        
            }()
            return ch
        }
func  (this *Exchange) BorrowIsolatedMargin(symbol interface{}, code interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " borrowIsolatedMargin is not support yet")))
        
            }()
            return ch
        }
func  (this *Exchange) BorrowMargin(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
            panic(NotSupported(Add(this.Id, " borrowMargin is deprecated, please use borrowCrossMargin or borrowIsolatedMargin instead")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " repayMargin is deprecated, please use repayCrossMargin or repayIsolatedMargin instead")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            var message interface{} = ""
            if IsTrue(GetValue(this.Has, "fetchTrades")) {
                message = ". If you want to build OHLCV candles from trade executions data, visit https://github.com/ccxt/ccxt/tree/master/examples/ and see \"build-ohlcv-bars\" file"
            }
            panic(NotSupported(Add(Add(this.Id, " fetchOHLCV() is not supported yet"), message)))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOHLCVWs(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
            var message interface{} = ""
            if IsTrue(GetValue(this.Has, "fetchTradesWs")) {
                message = ". If you want to build OHLCV candles from trade executions data, visit https://github.com/ccxt/ccxt/tree/master/examples/ and see \"build-ohlcv-bars\" file"
            }
            panic(NotSupported(Add(Add(this.Id, " fetchOHLCVWs() is not supported yet. Try using fetchOHLCV instead."), message)))
        
            }()
            return ch
        }
func  (this *Exchange) WatchOHLCV(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
            panic(NotSupported(Add(this.Id, " watchOHLCV() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ConvertTradingViewToOHLCV(ohlcvs interface{}, optionalArgs ...interface{}) interface{}  {
    timestamp := GetArg(optionalArgs, 0, "t")
    _ = timestamp
    open := GetArg(optionalArgs, 1, "o")
    _ = open
    high := GetArg(optionalArgs, 2, "h")
    _ = high
    low := GetArg(optionalArgs, 3, "l")
    _ = low
    close := GetArg(optionalArgs, 4, "c")
    _ = close
    volume := GetArg(optionalArgs, 5, "v")
    _ = volume
    ms := GetArg(optionalArgs, 6, false)
    _ = ms
    var result interface{} = []interface{}{}
    var timestamps interface{} = this.SafeList(ohlcvs, timestamp, []interface{}{})
    var opens interface{} = this.SafeList(ohlcvs, open, []interface{}{})
    var highs interface{} = this.SafeList(ohlcvs, high, []interface{}{})
    var lows interface{} = this.SafeList(ohlcvs, low, []interface{}{})
    var closes interface{} = this.SafeList(ohlcvs, close, []interface{}{})
    var volumes interface{} = this.SafeList(ohlcvs, volume, []interface{}{})
    for i := 0; IsLessThan(i, GetArrayLength(timestamps)); i++ {
        AppendToArray(&result,[]interface{}{Ternary(IsTrue(ms), this.SafeInteger(timestamps, i), this.SafeTimestamp(timestamps, i)), this.SafeValue(opens, i), this.SafeValue(highs, i), this.SafeValue(lows, i), this.SafeValue(closes, i), this.SafeValue(volumes, i)})
    }
    return result
}
func  (this *Exchange) ConvertOHLCVToTradingView(ohlcvs interface{}, optionalArgs ...interface{}) interface{}  {
    timestamp := GetArg(optionalArgs, 0, "t")
    _ = timestamp
    open := GetArg(optionalArgs, 1, "o")
    _ = open
    high := GetArg(optionalArgs, 2, "h")
    _ = high
    low := GetArg(optionalArgs, 3, "l")
    _ = low
    close := GetArg(optionalArgs, 4, "c")
    _ = close
    volume := GetArg(optionalArgs, 5, "v")
    _ = volume
    ms := GetArg(optionalArgs, 6, false)
    _ = ms
    var result interface{} = map[string]interface{} {}
    AddElementToObject(result, timestamp, []interface{}{})
    AddElementToObject(result, open, []interface{}{})
    AddElementToObject(result, high, []interface{}{})
    AddElementToObject(result, low, []interface{}{})
    AddElementToObject(result, close, []interface{}{})
    AddElementToObject(result, volume, []interface{}{})
    for i := 0; IsLessThan(i, GetArrayLength(ohlcvs)); i++ {
        var ts interface{} = Ternary(IsTrue(ms), GetValue(GetValue(ohlcvs, i), 0), this.ParseToInt(Divide(GetValue(GetValue(ohlcvs, i), 0), 1000)))
        var resultTimestamp interface{} = GetValue(result, timestamp)
        AppendToArray(&resultTimestamp,ts)
        var resultOpen interface{} = GetValue(result, open)
        AppendToArray(&resultOpen,GetValue(GetValue(ohlcvs, i), 1))
        var resultHigh interface{} = GetValue(result, high)
        AppendToArray(&resultHigh,GetValue(GetValue(ohlcvs, i), 2))
        var resultLow interface{} = GetValue(result, low)
        AppendToArray(&resultLow,GetValue(GetValue(ohlcvs, i), 3))
        var resultClose interface{} = GetValue(result, close)
        AppendToArray(&resultClose,GetValue(GetValue(ohlcvs, i), 4))
        var resultVolume interface{} = GetValue(result, volume)
        AppendToArray(&resultVolume,GetValue(GetValue(ohlcvs, i), 5))
    }
    return result
}
func  (this *Exchange) FetchWebEndpoint(method interface{}, endpointMethod interface{}, returnAsJson interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    startRegex := GetArg(optionalArgs, 0, nil)
            _ = startRegex
            endRegex := GetArg(optionalArgs, 1, nil)
            _ = endRegex
            var errorMessage interface{} = ""
            var options interface{} = this.SafeValue(this.Options, method, map[string]interface{} {})
            var muteOnFailure interface{} = this.SafeBool(options, "webApiMuteFailure", true)
            
            {		ret__ := func(this *Exchange) (ret_ interface{}) {
            		defer func() {
            			if e := recover(); e != nil {
                            if e == "break" {
            				    return
            			    }
            				ret_ = func(this *Exchange) interface{} {
            					// catch block:
                                        errorMessage = Add(Add(Add(this.Id, " "), method), "() failed to fetch correct data from website. Probably webpage markup has been changed, breaking the page custom parser.")
                                return nil
            				}(this)
            			}
            		}()
            		// try block:
                            // if it was not explicitly disabled, then don't fetch
                    if IsTrue(!IsEqual(this.SafeBool(options, "webApiEnable", true), true)) {
            
                        return nil
                    }
                    var maxRetries interface{} = this.SafeValue(options, "webApiRetries", 10)
                    var response interface{} = nil
                    var retry interface{} = 0
                    var shouldBreak interface{} = false
                    for IsLessThan(retry, maxRetries) {
                        
                        {		ret__ := func(this *Exchange) (ret_ interface{}) {
                        		defer func() {
                        			if e := recover(); e != nil {
                                        if e == "break" {
                        				    return
                        			    }
                        				ret_ = func(this *Exchange) interface{} {
                        					// catch block:
                                                            retry = Add(retry, 1)
                                        if IsTrue(IsEqual(retry, maxRetries)) {
                                            panic(e)
                                        }
                                            return nil
                        				}(this)
                        			}
                        		}()
                        		// try block:
                                                
                        response = (<-this.callDynamically(endpointMethod, map[string]interface{} {}))
                                        PanicOnError(response)
                                        shouldBreak = true
                                        panic("break")
                        		return nil
                        	}(this)
                        	if ret__ != nil {
                        		return ret__
                        	}
                        }
                        if IsTrue(shouldBreak) {
                            break // this is needed because of GO
                        }
                    }
                    var content interface{} = response
                    if IsTrue(!IsEqual(startRegex, nil)) {
                        var splitted_by_start interface{} = Split(content, startRegex)
                        content = GetValue(splitted_by_start, 1) // we need second part after start
                    }
                    if IsTrue(!IsEqual(endRegex, nil)) {
                        var splitted_by_end interface{} = Split(content, endRegex)
                        content = GetValue(splitted_by_end, 0) // we need first part after start
                    }
                    if IsTrue(IsTrue(returnAsJson) && IsTrue((IsString(content)))) {
                        var jsoned interface{} = this.ParseJson(Trim(content)) // content should be trimmed before json parsing
                        if IsTrue(jsoned) {
            
                            ch <- jsoned  // if parsing was not successfull, exception should be thrown
                            return nil
                        } else {
                            panic(BadResponse("could not parse the response into json"))
                        }
                    } else {
            
                        ch <- content
                        return nil
                    }
            		return nil
            	}(this)
            	if ret__ != nil {
            		return ret__
            	}
            }
            if IsTrue(muteOnFailure) {
        
                return nil
            } else {
                panic(BadResponse(errorMessage))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) MarketIds(optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    if IsTrue(IsEqual(symbols, nil)) {
        return symbols
    }
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(symbols)); i++ {
        AppendToArray(&result,this.MarketId(GetValue(symbols, i)))
    }
    return result
}
func  (this *Exchange) CurrencyIds(optionalArgs ...interface{}) interface{}  {
    codes := GetArg(optionalArgs, 0, nil)
    _ = codes
    if IsTrue(IsEqual(codes, nil)) {
        return codes
    }
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(codes)); i++ {
        AppendToArray(&result,this.CurrencyId(GetValue(codes, i)))
    }
    return result
}
func  (this *Exchange) MarketsForSymbols(optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    if IsTrue(IsEqual(symbols, nil)) {
        return symbols
    }
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(symbols)); i++ {
        AppendToArray(&result,this.DerivedExchange.Market(GetValue(symbols, i)))
    }
    return result
}
func  (this *Exchange) MarketSymbols(optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    typeVar := GetArg(optionalArgs, 1, nil)
    _ = typeVar
    allowEmpty := GetArg(optionalArgs, 2, true)
    _ = allowEmpty
    sameTypeOnly := GetArg(optionalArgs, 3, false)
    _ = sameTypeOnly
    sameSubTypeOnly := GetArg(optionalArgs, 4, false)
    _ = sameSubTypeOnly
    if IsTrue(IsEqual(symbols, nil)) {
        if !IsTrue(allowEmpty) {
            panic(ArgumentsRequired(Add(this.Id, " empty list of symbols is not supported")))
        }
        return symbols
    }
    var symbolsLength interface{} =     GetArrayLength(symbols)
    if IsTrue(IsEqual(symbolsLength, 0)) {
        if !IsTrue(allowEmpty) {
            panic(ArgumentsRequired(Add(this.Id, " empty list of symbols is not supported")))
        }
        return symbols
    }
    var result interface{} = []interface{}{}
    var marketType interface{} = nil
    var isLinearSubType interface{} = nil
    for i := 0; IsLessThan(i, GetArrayLength(symbols)); i++ {

        var market interface{} = this.DerivedExchange.Market(GetValue(symbols, i))
        PanicOnError(market)
        if IsTrue(IsTrue(sameTypeOnly) && IsTrue((!IsEqual(marketType, nil)))) {
            if IsTrue(!IsEqual(GetValue(market, "type"), marketType)) {
                panic(BadRequest(Add(Add(Add(Add(Add(this.Id, " symbols must be of the same type, either "), marketType), " or "), GetValue(market, "type")), ".")))
            }
        }
        if IsTrue(IsTrue(sameSubTypeOnly) && IsTrue((!IsEqual(isLinearSubType, nil)))) {
            if IsTrue(!IsEqual(GetValue(market, "linear"), isLinearSubType)) {
                panic(BadRequest(Add(this.Id, " symbols must be of the same subType, either linear or inverse.")))
            }
        }
        if IsTrue(IsTrue(!IsEqual(typeVar, nil)) && IsTrue(!IsEqual(GetValue(market, "type"), typeVar))) {
            panic(BadRequest(Add(Add(Add(this.Id, " symbols must be of the same type "), typeVar), ". If the type is incorrect you can change it in options or the params of the request")))
        }
        marketType = GetValue(market, "type")
        if !IsTrue(GetValue(market, "spot")) {
            isLinearSubType = GetValue(market, "linear")
        }
        var symbol interface{} = this.SafeString(market, "symbol", GetValue(symbols, i))
        AppendToArray(&result,symbol)
    }
    return result
}
func  (this *Exchange) MarketCodes(optionalArgs ...interface{}) interface{}  {
    codes := GetArg(optionalArgs, 0, nil)
    _ = codes
    if IsTrue(IsEqual(codes, nil)) {
        return codes
    }
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(codes)); i++ {
        AppendToArray(&result,this.CommonCurrencyCode(GetValue(codes, i)))
    }
    return result
}
func  (this *Exchange) ParseBidsAsks(bidasks interface{}, optionalArgs ...interface{}) interface{}  {
    priceKey := GetArg(optionalArgs, 0, 0)
    _ = priceKey
    amountKey := GetArg(optionalArgs, 1, 1)
    _ = amountKey
    countOrIdKey := GetArg(optionalArgs, 2, 2)
    _ = countOrIdKey
    bidasks = this.ToArray(bidasks)
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(bidasks)); i++ {
        AppendToArray(&result,this.ParseBidAsk(GetValue(bidasks, i), priceKey, amountKey, countOrIdKey))
    }
    return result
}
func  (this *Exchange) FetchL2OrderBook(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
        
            orderbook:= <-this.DerivedExchange.FetchOrderBook(symbol, limit, params)
            PanicOnError(orderbook)
        
            ch <- this.Extend(orderbook, map[string]interface{} {
                "asks": this.SortBy(this.Aggregate(GetValue(orderbook, "asks")), 0),
                "bids": this.SortBy(this.Aggregate(GetValue(orderbook, "bids")), 0, true),
            })
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FilterBySymbol(objects interface{}, optionalArgs ...interface{}) interface{}  {
    symbol := GetArg(optionalArgs, 0, nil)
    _ = symbol
    if IsTrue(IsEqual(symbol, nil)) {
        return objects
    }
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(objects)); i++ {
        var objectSymbol interface{} = this.SafeString(GetValue(objects, i), "symbol")
        if IsTrue(IsEqual(objectSymbol, symbol)) {
            AppendToArray(&result,GetValue(objects, i))
        }
    }
    return result
}
func  (this *Exchange) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    if IsTrue(IsArray(ohlcv)) {
        return []interface{}{this.SafeInteger(ohlcv, 0), this.SafeNumber(ohlcv, 1), this.SafeNumber(ohlcv, 2), this.SafeNumber(ohlcv, 3), this.SafeNumber(ohlcv, 4), this.SafeNumber(ohlcv, 5)}
    }
    return ohlcv
}
func  (this *Exchange) NetworkCodeToId(networkCode interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @name exchange#networkCodeToId
    * @description tries to convert the provided networkCode (which is expected to be an unified network code) to a network id. In order to achieve this, derived class needs to have 'options->networks' defined.
    * @param {string} networkCode unified network code
    * @param {string} currencyCode unified currency code, but this argument is not required by default, unless there is an exchange (like huobi) that needs an override of the method to be able to pass currencyCode argument additionally
    * @returns {string|undefined} exchange-specific network id
    */
    currencyCode := GetArg(optionalArgs, 0, nil)
    _ = currencyCode
    if IsTrue(IsEqual(networkCode, nil)) {
        return nil
    }
    var networkIdsByCodes interface{} = this.SafeValue(this.Options, "networks", map[string]interface{} {})
    var networkId interface{} = this.SafeString(networkIdsByCodes, networkCode)
    // for example, if 'ETH' is passed for networkCode, but 'ETH' key not defined in `options->networks` object
    if IsTrue(IsEqual(networkId, nil)) {
        if IsTrue(IsEqual(currencyCode, nil)) {
            var currencies interface{} = ObjectValues(this.Currencies)
            for i := 0; IsLessThan(i, GetArrayLength(currencies)); i++ {
                var currency interface{} = GetValue(currencies, i)
                var networks interface{} = this.SafeDict(currency, "networks")
                var network interface{} = this.SafeDict(networks, networkCode)
                networkId = this.SafeString(network, "id")
                if IsTrue(!IsEqual(networkId, nil)) {
                    break
                }
            }
        } else {
            // if currencyCode was provided, then we try to find if that currencyCode has a replacement (i.e. ERC20 for ETH) or is in the currency
            var defaultNetworkCodeReplacements interface{} = this.SafeValue(this.Options, "defaultNetworkCodeReplacements", map[string]interface{} {})
            if IsTrue(InOp(defaultNetworkCodeReplacements, currencyCode)) {
                // if there is a replacement for the passed networkCode, then we use it to find network-id in `options->networks` object
                var replacementObject interface{} = GetValue(defaultNetworkCodeReplacements, currencyCode) // i.e. { 'ERC20': 'ETH' }
                var keys interface{} = ObjectKeys(replacementObject)
                for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
                    var key interface{} = GetValue(keys, i)
                    var value interface{} = GetValue(replacementObject, key)
                    // if value matches to provided unified networkCode, then we use it's key to find network-id in `options->networks` object
                    if IsTrue(IsEqual(value, networkCode)) {
                        networkId = this.SafeString(networkIdsByCodes, key)
                        break
                    }
                }
            } else {
                // serach for network inside currency
                var currency interface{} = this.SafeDict(this.Currencies, currencyCode)
                var networks interface{} = this.SafeDict(currency, "networks")
                var network interface{} = this.SafeDict(networks, networkCode)
                networkId = this.SafeString(network, "id")
            }
        }
        // if it wasn't found, we just set the provided value to network-id
        if IsTrue(IsEqual(networkId, nil)) {
            networkId = networkCode
        }
    }
    return networkId
}
func  (this *Exchange) NetworkIdToCode(optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @name exchange#networkIdToCode
    * @description tries to convert the provided exchange-specific networkId to an unified network Code. In order to achieve this, derived class needs to have "options['networksById']" defined.
    * @param {string} networkId exchange specific network id/title, like: TRON, Trc-20, usdt-erc20, etc
    * @param {string|undefined} currencyCode unified currency code, but this argument is not required by default, unless there is an exchange (like huobi) that needs an override of the method to be able to pass currencyCode argument additionally
    * @returns {string|undefined} unified network code
    */
    networkId := GetArg(optionalArgs, 0, nil)
    _ = networkId
    currencyCode := GetArg(optionalArgs, 1, nil)
    _ = currencyCode
    if IsTrue(IsEqual(networkId, nil)) {
        return nil
    }
    var networkCodesByIds interface{} = this.SafeDict(this.Options, "networksById", map[string]interface{} {})
    var networkCode interface{} = this.SafeString(networkCodesByIds, networkId, networkId)
    // replace mainnet network-codes (i.e. ERC20->ETH)
    if IsTrue(!IsEqual(currencyCode, nil)) {
        var defaultNetworkCodeReplacements interface{} = this.SafeDict(this.Options, "defaultNetworkCodeReplacements", map[string]interface{} {})
        if IsTrue(InOp(defaultNetworkCodeReplacements, currencyCode)) {
            var replacementObject interface{} = this.SafeDict(defaultNetworkCodeReplacements, currencyCode, map[string]interface{} {})
            networkCode = this.SafeString(replacementObject, networkCode, networkCode)
        }
    }
    return networkCode
}
func  (this *Exchange) HandleNetworkCodeAndParams(params interface{}) interface{}  {
    var networkCodeInParams interface{} = this.SafeString2(params, "networkCode", "network")
    if IsTrue(!IsEqual(networkCodeInParams, nil)) {
        params = this.Omit(params, []interface{}{"networkCode", "network"})
    }
    // if it was not defined by user, we should not set it from 'defaultNetworks', because handleNetworkCodeAndParams is for only request-side and thus we do not fill it with anything. We can only use 'defaultNetworks' after parsing response-side
    return []interface{}{networkCodeInParams, params}
}
func  (this *Exchange) DefaultNetworkCode(currencyCode interface{}) interface{}  {
    var defaultNetworkCode interface{} = nil
    var defaultNetworks interface{} = this.SafeDict(this.Options, "defaultNetworks", map[string]interface{} {})
    if IsTrue(InOp(defaultNetworks, currencyCode)) {
        // if currency had set its network in "defaultNetworks", use it
        defaultNetworkCode = GetValue(defaultNetworks, currencyCode)
    } else {
        // otherwise, try to use the global-scope 'defaultNetwork' value (even if that network is not supported by currency, it doesn't make any problem, this will be just used "at first" if currency supports this network at all)
        var defaultNetwork interface{} = this.SafeString(this.Options, "defaultNetwork")
        if IsTrue(!IsEqual(defaultNetwork, nil)) {
            defaultNetworkCode = defaultNetwork
        }
    }
    return defaultNetworkCode
}
func  (this *Exchange) SelectNetworkCodeFromUnifiedNetworks(currencyCode interface{}, networkCode interface{}, indexedNetworkEntries interface{}) interface{}  {
    return this.SelectNetworkKeyFromNetworks(currencyCode, networkCode, indexedNetworkEntries, true)
}
func  (this *Exchange) SelectNetworkIdFromRawNetworks(currencyCode interface{}, networkCode interface{}, indexedNetworkEntries interface{}) interface{}  {
    return this.SelectNetworkKeyFromNetworks(currencyCode, networkCode, indexedNetworkEntries, false)
}
func  (this *Exchange) SelectNetworkKeyFromNetworks(currencyCode interface{}, networkCode interface{}, indexedNetworkEntries interface{}, optionalArgs ...interface{}) interface{}  {
    // this method is used against raw & unparse network entries, which are just indexed by network id
    isIndexedByUnifiedNetworkCode := GetArg(optionalArgs, 0, false)
    _ = isIndexedByUnifiedNetworkCode
    var chosenNetworkId interface{} = nil
    var availableNetworkIds interface{} = ObjectKeys(indexedNetworkEntries)
    var responseNetworksLength interface{} =     GetArrayLength(availableNetworkIds)
    if IsTrue(!IsEqual(networkCode, nil)) {
        if IsTrue(IsEqual(responseNetworksLength, 0)) {
            panic(NotSupported(Add(Add(Add(Add(this.Id, " - "), networkCode), " network did not return any result for "), currencyCode)))
        } else {
            // if networkCode was provided by user, we should check it after response, as the referenced exchange doesn't support network-code during request
            var networkId interface{} = Ternary(IsTrue(isIndexedByUnifiedNetworkCode), networkCode, this.NetworkCodeToId(networkCode, currencyCode))
            if IsTrue(InOp(indexedNetworkEntries, networkId)) {
                chosenNetworkId = networkId
            } else {
                panic(NotSupported(Add(Add(Add(Add(Add(Add(this.Id, " - "), networkId), " network was not found for "), currencyCode), ", use one of "), Join(availableNetworkIds, ", "))))
            }
        }
    } else {
        if IsTrue(IsEqual(responseNetworksLength, 0)) {
            panic(NotSupported(Add(Add(this.Id, " - no networks were returned for "), currencyCode)))
        } else {
            // if networkCode was not provided by user, then we try to use the default network (if it was defined in "defaultNetworks"), otherwise, we just return the first network entry
            var defaultNetworkCode interface{} = this.DefaultNetworkCode(currencyCode)
            var defaultNetworkId interface{} = Ternary(IsTrue(isIndexedByUnifiedNetworkCode), defaultNetworkCode, this.NetworkCodeToId(defaultNetworkCode, currencyCode))
            if IsTrue(InOp(indexedNetworkEntries, defaultNetworkId)) {
                return defaultNetworkId
            }
            panic(NotSupported(Add(Add(this.Id, " - can not determine the default network, please pass param[\"network\"] one from : "), Join(availableNetworkIds, ", "))))
        }
    }
    return chosenNetworkId
}
func  (this *Exchange) SafeNumber2(dictionary interface{}, key1 interface{}, key2 interface{}, optionalArgs ...interface{}) interface{}  {
    d := GetArg(optionalArgs, 0, nil)
    _ = d
    var value interface{} = this.SafeString2(dictionary, key1, key2)
    return this.ParseNumber(value, d)
}
func  (this *Exchange) ParseOrderBook(orderbook interface{}, symbol interface{}, optionalArgs ...interface{}) interface{}  {
    timestamp := GetArg(optionalArgs, 0, nil)
    _ = timestamp
    bidsKey := GetArg(optionalArgs, 1, "bids")
    _ = bidsKey
    asksKey := GetArg(optionalArgs, 2, "asks")
    _ = asksKey
    priceKey := GetArg(optionalArgs, 3, 0)
    _ = priceKey
    amountKey := GetArg(optionalArgs, 4, 1)
    _ = amountKey
    countOrIdKey := GetArg(optionalArgs, 5, 2)
    _ = countOrIdKey

    var bids interface{} = this.DerivedExchange.ParseBidsAsks(this.SafeValue(orderbook, bidsKey, []interface{}{}), priceKey, amountKey, countOrIdKey)
    PanicOnError(bids)

    var asks interface{} = this.DerivedExchange.ParseBidsAsks(this.SafeValue(orderbook, asksKey, []interface{}{}), priceKey, amountKey, countOrIdKey)
    PanicOnError(asks)
    return map[string]interface{} {
        "symbol": symbol,
        "bids": this.SortBy(bids, 0, true),
        "asks": this.SortBy(asks, 0),
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "nonce": nil,
    }
}
func  (this *Exchange) ParseOHLCVs(ohlcvs interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    timeframe := GetArg(optionalArgs, 1, "1m")
    _ = timeframe
    since := GetArg(optionalArgs, 2, nil)
    _ = since
    limit := GetArg(optionalArgs, 3, nil)
    _ = limit
    tail := GetArg(optionalArgs, 4, false)
    _ = tail
    var results interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(ohlcvs)); i++ {
        AppendToArray(&results,this.DerivedExchange.ParseOHLCV(GetValue(ohlcvs, i), market))
    }
    var sorted interface{} = this.SortBy(results, 0)
    return this.FilterBySinceLimit(sorted, since, limit, 0, tail)
}
func  (this *Exchange) ParseLeverageTiers(response interface{}, optionalArgs ...interface{}) interface{}  {
    // marketIdKey should only be undefined when response is a dictionary
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    marketIdKey := GetArg(optionalArgs, 1, nil)
    _ = marketIdKey
    symbols = this.MarketSymbols(symbols)
    var tiers interface{} = map[string]interface{} {}
    var symbolsLength interface{} = 0
    if IsTrue(!IsEqual(symbols, nil)) {
        symbolsLength = GetArrayLength(symbols)
    }
    var noSymbols interface{} = IsTrue((IsEqual(symbols, nil))) || IsTrue((IsEqual(symbolsLength, 0)))
    if IsTrue(IsArray(response)) {
        for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
            var item interface{} = GetValue(response, i)
            var id interface{} = this.SafeString(item, marketIdKey)

            var market interface{} = this.DerivedExchange.SafeMarket(id, nil, nil, "swap")
            PanicOnError(market)
            var symbol interface{} = GetValue(market, "symbol")
            var contract interface{} = this.SafeBool(market, "contract", false)
            if IsTrue(IsTrue(contract) && IsTrue((IsTrue(noSymbols) || IsTrue(this.InArray(symbol, symbols))))) {
                AddElementToObject(tiers, symbol, this.DerivedExchange.ParseMarketLeverageTiers(item, market))
            }
        }
    } else {
        var keys interface{} = ObjectKeys(response)
        for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
            var marketId interface{} = GetValue(keys, i)
            var item interface{} = GetValue(response, marketId)

            var market interface{} = this.DerivedExchange.SafeMarket(marketId, nil, nil, "swap")
            PanicOnError(market)
            var symbol interface{} = GetValue(market, "symbol")
            var contract interface{} = this.SafeBool(market, "contract", false)
            if IsTrue(IsTrue(contract) && IsTrue((IsTrue(noSymbols) || IsTrue(this.InArray(symbol, symbols))))) {
                AddElementToObject(tiers, symbol, this.DerivedExchange.ParseMarketLeverageTiers(item, market))
            }
        }
    }
    return tiers
}
func  (this *Exchange) LoadTradingLimits(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            reload := GetArg(optionalArgs, 1, false)
            _ = reload
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchTradingLimits")) {
                if IsTrue(IsTrue(reload) || !IsTrue((InOp(this.Options, "limitsLoaded")))) {
        
                    response:= (<-this.FetchTradingLimits(symbols))
                    PanicOnError(response)
                    for i := 0; IsLessThan(i, GetArrayLength(symbols)); i++ {
                        var symbol interface{} = GetValue(symbols, i)
                        AddElementToObject(this.Markets, symbol, this.DeepExtend(GetValue(this.Markets, symbol), GetValue(response, symbol)))
                    }
                    AddElementToObject(this.Options, "limitsLoaded", this.Milliseconds())
                }
            }
        
            ch <- this.Markets
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) SafePosition(position interface{}) interface{}  {
    // simplified version of: /pull/12765/
    var unrealizedPnlString interface{} = this.SafeString(position, "unrealisedPnl")
    var initialMarginString interface{} = this.SafeString(position, "initialMargin")
    //
    // PERCENTAGE
    //
    var percentage interface{} = this.SafeValue(position, "percentage")
    if IsTrue(IsTrue(IsTrue((IsEqual(percentage, nil))) && IsTrue((!IsEqual(unrealizedPnlString, nil)))) && IsTrue((!IsEqual(initialMarginString, nil)))) {
        // as it was done in all implementations ( aax, btcex, bybit, deribit, ftx, gate, kucoinfutures, phemex )
        var percentageString interface{} = Precise.StringMul(Precise.StringDiv(unrealizedPnlString, initialMarginString, 4), "100")
        AddElementToObject(position, "percentage", this.ParseNumber(percentageString))
    }
    // if contractSize is undefined get from market
    var contractSize interface{} = this.SafeNumber(position, "contractSize")
    var symbol interface{} = this.SafeString(position, "symbol")
    var market interface{} = nil
    if IsTrue(!IsEqual(symbol, nil)) {
        market = this.SafeValue(this.Markets, symbol)
    }
    if IsTrue(IsTrue(IsEqual(contractSize, nil)) && IsTrue(!IsEqual(market, nil))) {
        contractSize = this.SafeNumber(market, "contractSize")
        AddElementToObject(position, "contractSize", contractSize)
    }
    return position
}
func  (this *Exchange) ParsePositions(positions interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    symbols = this.MarketSymbols(symbols)
    positions = this.ToArray(positions)
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(positions)); i++ {
        var position interface{} = this.Extend(this.DerivedExchange.ParsePosition(GetValue(positions, i), nil), params)
        AppendToArray(&result,position)
    }
    return this.FilterByArrayPositions(result, "symbol", symbols, false)
}
func  (this *Exchange) ParseAccounts(accounts interface{}, optionalArgs ...interface{}) interface{}  {
    params := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = params
    accounts = this.ToArray(accounts)
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(accounts)); i++ {
        var account interface{} = this.Extend(this.DerivedExchange.ParseAccount(GetValue(accounts, i)), params)
        AppendToArray(&result,account)
    }
    return result
}
func  (this *Exchange) ParseTrades(trades interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    params := GetArg(optionalArgs, 3, map[string]interface{} {})
    _ = params
    trades = this.ToArray(trades)
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(trades)); i++ {
        var trade interface{} = this.Extend(this.DerivedExchange.ParseTrade(GetValue(trades, i), market), params)
        AppendToArray(&result,trade)
    }
    result = this.SortBy2(result, "timestamp", "id")
    var symbol interface{} = Ternary(IsTrue((!IsEqual(market, nil))), GetValue(market, "symbol"), nil)
    return this.FilterBySymbolSinceLimit(result, symbol, since, limit)
}
func  (this *Exchange) ParseTransactions(transactions interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    params := GetArg(optionalArgs, 3, map[string]interface{} {})
    _ = params
    transactions = this.ToArray(transactions)
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(transactions)); i++ {
        var transaction interface{} = this.Extend(this.DerivedExchange.ParseTransaction(GetValue(transactions, i), currency), params)
        AppendToArray(&result,transaction)
    }
    result = this.SortBy(result, "timestamp")
    var code interface{} = Ternary(IsTrue((!IsEqual(currency, nil))), GetValue(currency, "code"), nil)
    return this.FilterByCurrencySinceLimit(result, code, since, limit)
}
func  (this *Exchange) ParseTransfers(transfers interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    params := GetArg(optionalArgs, 3, map[string]interface{} {})
    _ = params
    transfers = this.ToArray(transfers)
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(transfers)); i++ {
        var transfer interface{} = this.Extend(this.DerivedExchange.ParseTransfer(GetValue(transfers, i), currency), params)
        AppendToArray(&result,transfer)
    }
    result = this.SortBy(result, "timestamp")
    var code interface{} = Ternary(IsTrue((!IsEqual(currency, nil))), GetValue(currency, "code"), nil)
    return this.FilterByCurrencySinceLimit(result, code, since, limit)
}
func  (this *Exchange) ParseLedger(data interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    params := GetArg(optionalArgs, 3, map[string]interface{} {})
    _ = params
    var result interface{} = []interface{}{}
    var arrayData interface{} = this.ToArray(data)
    for i := 0; IsLessThan(i, GetArrayLength(arrayData)); i++ {

        var itemOrItems interface{} = this.DerivedExchange.ParseLedgerEntry(GetValue(arrayData, i), currency)
        PanicOnError(itemOrItems)
        if IsTrue(IsArray(itemOrItems)) {
            for j := 0; IsLessThan(j, GetArrayLength(itemOrItems)); j++ {
                AppendToArray(&result,this.Extend(GetValue(itemOrItems, j), params))
            }
        } else {
            AppendToArray(&result,this.Extend(itemOrItems, params))
        }
    }
    result = this.SortBy(result, "timestamp")
    var code interface{} = Ternary(IsTrue((!IsEqual(currency, nil))), GetValue(currency, "code"), nil)
    return this.FilterByCurrencySinceLimit(result, code, since, limit)
}
func  (this *Exchange) Nonce() interface{}  {
    return this.Seconds()
}
func  (this *Exchange) SetHeaders(headers interface{}) interface{}  {
    return headers
}
func  (this *Exchange) CurrencyId(code interface{}) interface{}  {
    var currency interface{} = this.SafeDict(this.Currencies, code)
    if IsTrue(IsEqual(currency, nil)) {
        currency = this.SafeCurrency(code)
    }
    if IsTrue(!IsEqual(currency, nil)) {
        return GetValue(currency, "id")
    }
    return code
}
func  (this *Exchange) MarketId(symbol interface{}) interface{}  {

    var market interface{} = this.DerivedExchange.Market(symbol)
    PanicOnError(market)
    if IsTrue(!IsEqual(market, nil)) {
        return GetValue(market, "id")
    }
    return symbol
}
func  (this *Exchange) Symbol(symbol interface{}) interface{}  {

    var market interface{} = this.DerivedExchange.Market(symbol)
    PanicOnError(market)
    return this.SafeString(market, "symbol", symbol)
}
func  (this *Exchange) HandleParamString(params interface{}, paramName interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeString(params, paramName, defaultValue)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, paramName)
    }
    return []interface{}{value, params}
}
func  (this *Exchange) HandleParamString2(params interface{}, paramName1 interface{}, paramName2 interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeString2(params, paramName1, paramName2, defaultValue)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, []interface{}{paramName1, paramName2})
    }
    return []interface{}{value, params}
}
func  (this *Exchange) HandleParamInteger(params interface{}, paramName interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeInteger(params, paramName, defaultValue)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, paramName)
    }
    return []interface{}{value, params}
}
func  (this *Exchange) HandleParamInteger2(params interface{}, paramName1 interface{}, paramName2 interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeInteger2(params, paramName1, paramName2, defaultValue)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, []interface{}{paramName1, paramName2})
    }
    return []interface{}{value, params}
}
func  (this *Exchange) HandleParamBool(params interface{}, paramName interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeBool(params, paramName, defaultValue)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, paramName)
    }
    return []interface{}{value, params}
}
func  (this *Exchange) HandleParamBool2(params interface{}, paramName1 interface{}, paramName2 interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = this.SafeBool2(params, paramName1, paramName2, defaultValue)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, []interface{}{paramName1, paramName2})
    }
    return []interface{}{value, params}
}
func  (this *Exchange) ResolvePath(path interface{}, params interface{}) interface{}  {
    return []interface{}{this.ImplodeParams(path, params), this.Omit(params, this.ExtractParams(path))}
}
func  (this *Exchange) GetListFromObjectValues(objects interface{}, key interface{}) interface{}  {
    var newArray interface{} = objects
    if !IsTrue(IsArray(objects)) {
        newArray = this.ToArray(objects)
    }
    var results interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(newArray)); i++ {
        AppendToArray(&results,GetValue(GetValue(newArray, i), key))
    }
    return results
}
func  (this *Exchange) GetSymbolsForMarketType(optionalArgs ...interface{}) interface{}  {
    marketType := GetArg(optionalArgs, 0, nil)
    _ = marketType
    subType := GetArg(optionalArgs, 1, nil)
    _ = subType
    symbolWithActiveStatus := GetArg(optionalArgs, 2, true)
    _ = symbolWithActiveStatus
    symbolWithUnknownStatus := GetArg(optionalArgs, 3, true)
    _ = symbolWithUnknownStatus
    var filteredMarkets interface{} = this.Markets
    if IsTrue(!IsEqual(marketType, nil)) {
        filteredMarkets = this.FilterBy(filteredMarkets, "type", marketType)
    }
    if IsTrue(!IsEqual(subType, nil)) {
        this.CheckRequiredArgument("getSymbolsForMarketType", subType, "subType", []interface{}{"linear", "inverse", "quanto"})
        filteredMarkets = this.FilterBy(filteredMarkets, "subType", subType)
    }
    var activeStatuses interface{} = []interface{}{}
    if IsTrue(symbolWithActiveStatus) {
        AppendToArray(&activeStatuses,true)
    }
    if IsTrue(symbolWithUnknownStatus) {
        AppendToArray(&activeStatuses,nil)
    }
    filteredMarkets = this.FilterByArray(filteredMarkets, "active", activeStatuses, false)
    return this.GetListFromObjectValues(filteredMarkets, "symbol")
}
func  (this *Exchange) FilterByArray(objects interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    values := GetArg(optionalArgs, 0, nil)
    _ = values
    indexed := GetArg(optionalArgs, 1, true)
    _ = indexed
    objects = this.ToArray(objects)
    // return all of them if no values were passed
    if IsTrue(IsTrue(IsEqual(values, nil)) || !IsTrue(values)) {
        // return indexed ? this.indexBy (objects, key) : objects;
        if IsTrue(indexed) {
            return this.IndexBy(objects, key)
        } else {
            return objects
        }
    }
    var results interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(objects)); i++ {
        if IsTrue(this.InArray(GetValue(GetValue(objects, i), key), values)) {
            AppendToArray(&results,GetValue(objects, i))
        }
    }
    // return indexed ? this.indexBy (results, key) : results;
    if IsTrue(indexed) {
        return this.IndexBy(results, key)
    }
    return results
}
func  (this *Exchange) Fetch2(path interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    api := GetArg(optionalArgs, 0, "public")
            _ = api
            method := GetArg(optionalArgs, 1, "GET")
            _ = method
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            headers := GetArg(optionalArgs, 3, nil)
            _ = headers
            body := GetArg(optionalArgs, 4, nil)
            _ = body
            config := GetArg(optionalArgs, 5, map[string]interface{} {})
            _ = config
            if IsTrue(this.EnableRateLimit) {
                var cost interface{} = this.CalculateRateLimiterCost(api, method, path, params, config)
        
                retRes466512 := (<-this.Throttle(cost))
                PanicOnError(retRes466512)
            }
            this.LastRestRequestTimestamp = this.Milliseconds()
        
            var request interface{} = this.DerivedExchange.Sign(path, api, method, params, headers, body)
            PanicOnError(request)
            this.Last_request_headers = GetValue(request, "headers")
            this.Last_request_body = GetValue(request, "body")
            this.Last_request_url = GetValue(request, "url")
            var retries interface{} = nil
            retriesparamsVariable := this.HandleOptionAndParams(params, path, "maxRetriesOnFailure", 0);
            retries = GetValue(retriesparamsVariable,0);
            params = GetValue(retriesparamsVariable,1)
            var retryDelay interface{} = nil
            retryDelayparamsVariable := this.HandleOptionAndParams(params, path, "maxRetriesOnFailureDelay", 0);
            retryDelay = GetValue(retryDelayparamsVariable,0);
            params = GetValue(retryDelayparamsVariable,1)
            for i := 0; IsLessThan(i, Add(retries, 1)); i++ {
                
                {		ret__ := func(this *Exchange) (ret_ interface{}) {
                		defer func() {
                			if e := recover(); e != nil {
                                if e == "break" {
                				    return
                			    }
                				ret_ = func(this *Exchange) interface{} {
                					// catch block:
                                                if IsTrue(IsInstance(e, NetworkError)) {
                                if IsTrue(IsLessThan(i, retries)) {
                                    if IsTrue(this.Verbose) {
                                        this.Log(Add(Add(Add(Add(Add(Add("Request failed with the error: ", ToString(e)), ", retrying "), ToString((Add(i, 1)))), " of "), ToString(retries)), "..."))
                                    }
                                    if IsTrue(IsTrue((!IsEqual(retryDelay, nil))) && IsTrue((!IsEqual(retryDelay, 0)))) {
                
                                        retRes468628 := (<-this.Sleep(retryDelay))
                                        PanicOnError(retRes468628)
                                    }
                                }
                            }
                            if IsTrue(IsGreaterThanOrEqual(i, retries)) {
                                panic(e)
                            }
                                    return nil
                				}(this)
                			}
                		}()
                		// try block:
                        
                                retRes467823 :=  (<-this.Fetch(GetValue(request, "url"), GetValue(request, "method"), GetValue(request, "headers"), GetValue(request, "body")))
                                PanicOnError(retRes467823)
                                ch <- retRes467823
                                return nil
                		return nil
                	}(this)
                	if ret__ != nil {
                		return ret__
                	}
                }
            }
        
            ch <- nil  // this line is never reached, but exists for c# value return requirement
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) Request(path interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    api := GetArg(optionalArgs, 0, "public")
            _ = api
            method := GetArg(optionalArgs, 1, "GET")
            _ = method
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            headers := GetArg(optionalArgs, 3, nil)
            _ = headers
            body := GetArg(optionalArgs, 4, nil)
            _ = body
            config := GetArg(optionalArgs, 5, map[string]interface{} {})
            _ = config
        
                retRes470015 :=  (<-this.Fetch2(path, api, method, params, headers, body, config))
                PanicOnError(retRes470015)
                ch <- retRes470015
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) LoadAccounts(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    reload := GetArg(optionalArgs, 0, false)
            _ = reload
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            if IsTrue(reload) {
                
        this.Accounts = <-this.DerivedExchange.FetchAccounts(params)
                PanicOnError(this.Accounts)
            } else {
                if IsTrue(this.Accounts) {
        
                    ch <- this.Accounts
                    return nil
                } else {
                    
        this.Accounts = <-this.DerivedExchange.FetchAccounts(params)
                    PanicOnError(this.Accounts)
                }
            }
            this.AccountsById = this.IndexBy(this.Accounts, "id")
        
            ch <- this.Accounts
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) BuildOHLCVC(trades interface{}, optionalArgs ...interface{}) interface{}  {
    // given a sorted arrays of trades (recent last) and a timeframe builds an array of OHLCV candles
    // note, default limit value (2147483647) is max int32 value
    timeframe := GetArg(optionalArgs, 0, "1m")
    _ = timeframe
    since := GetArg(optionalArgs, 1, 0)
    _ = since
    limit := GetArg(optionalArgs, 2, 2147483647)
    _ = limit
    var ms interface{} = Multiply(this.ParseTimeframe(timeframe), 1000)
    var ohlcvs interface{} = []interface{}{}
    var i_timestamp interface{} = 0
    // const open = 1;
    var i_high interface{} = 2
    var i_low interface{} = 3
    var i_close interface{} = 4
    var i_volume interface{} = 5
    var i_count interface{} = 6
    var tradesLength interface{} =     GetArrayLength(trades)
    var oldest interface{} = mathMin(tradesLength, limit)
    for i := 0; IsLessThan(i, oldest); i++ {
        var trade interface{} = GetValue(trades, i)
        var ts interface{} = GetValue(trade, "timestamp")
        if IsTrue(IsLessThan(ts, since)) {
            continue
        }
        var openingTime interface{} = Multiply(MathFloor(Divide(ts, ms)), ms) // shift to the edge of m/h/d (but not M)
        if IsTrue(IsLessThan(openingTime, since)) {
            continue
        }
        var ohlcv_length interface{} =         GetArrayLength(ohlcvs)
        var candle interface{} = Subtract(ohlcv_length, 1)
        if IsTrue(IsTrue((IsEqual(candle, OpNeg(1)))) || IsTrue((IsGreaterThanOrEqual(openingTime, this.Sum(GetValue(GetValue(ohlcvs, candle), i_timestamp), ms))))) {
            // moved to a new timeframe -> create a new candle from opening trade
            AppendToArray(&ohlcvs,[]interface{}{openingTime, GetValue(trade, "price"), GetValue(trade, "price"), GetValue(trade, "price"), GetValue(trade, "price"), GetValue(trade, "amount"), 1})
        } else {
            // still processing the same timeframe -> update opening trade
            AddElementToObject(GetValue(ohlcvs, candle), i_high, mathMax(GetValue(GetValue(ohlcvs, candle), i_high), GetValue(trade, "price")))
            AddElementToObject(GetValue(ohlcvs, candle), i_low, mathMin(GetValue(GetValue(ohlcvs, candle), i_low), GetValue(trade, "price")))
            AddElementToObject(GetValue(ohlcvs, candle), i_close, GetValue(trade, "price"))
            AddElementToObject(GetValue(ohlcvs, candle), i_volume, this.Sum(GetValue(GetValue(ohlcvs, candle), i_volume), GetValue(trade, "amount")))
            AddElementToObject(GetValue(ohlcvs, candle), i_count, this.Sum(GetValue(GetValue(ohlcvs, candle), i_count), 1))
        }
    }
    return ohlcvs
}
func  (this *Exchange) ParseTradingViewOHLCV(ohlcvs interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    timeframe := GetArg(optionalArgs, 1, "1m")
    _ = timeframe
    since := GetArg(optionalArgs, 2, nil)
    _ = since
    limit := GetArg(optionalArgs, 3, nil)
    _ = limit
    var result interface{} = this.ConvertTradingViewToOHLCV(ohlcvs)
    return this.ParseOHLCVs(result, market, timeframe, since, limit)
}
func  (this *Exchange) EditLimitBuyOrder(id interface{}, symbol 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
        
                retRes477215 :=  (<-this.EditLimitOrder(id, symbol, "buy", amount, price, params))
                PanicOnError(retRes477215)
                ch <- retRes477215
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) EditLimitSellOrder(id interface{}, symbol 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
        
                retRes477615 :=  (<-this.EditLimitOrder(id, symbol, "sell", amount, price, params))
                PanicOnError(retRes477615)
                ch <- retRes477615
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) EditLimitOrder(id interface{}, symbol 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
        
                retRes478015 :=  <-this.DerivedExchange.EditOrder(id, symbol, "limit", side, amount, price, params)
                PanicOnError(retRes478015)
                ch <- retRes478015
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
        
            retRes47848 := <-this.DerivedExchange.CancelOrder(id, symbol)
            PanicOnError(retRes47848)
        
                retRes478515 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                PanicOnError(retRes478515)
                ch <- retRes478515
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) EditOrderWs(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
        
            retRes47898 := (<-this.CancelOrderWs(id, symbol))
            PanicOnError(retRes47898)
        
                retRes479015 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                PanicOnError(retRes479015)
                ch <- retRes479015
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchPosition() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPositionWs(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
            panic(NotSupported(Add(this.Id, " fetchPositionWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchPosition(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
            panic(NotSupported(Add(this.Id, " watchPosition() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchPositions(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " watchPositions() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchPositionForSymbols(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
                retRes481015 :=  (<-this.WatchPositions(symbols, since, limit, params))
                PanicOnError(retRes481015)
                ch <- retRes481015
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchPositionsForSymbol(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
            panic(NotSupported(Add(this.Id, " fetchPositionsForSymbol() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPositionsForSymbolWs(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
            panic(NotSupported(Add(this.Id, " fetchPositionsForSymbol() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchPositions() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPositionsWs(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
            panic(NotSupported(Add(this.Id, " fetchPositions() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPositionsRisk(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
            panic(NotSupported(Add(this.Id, " fetchPositionsRisk() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchBidsAsks(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
            panic(NotSupported(Add(this.Id, " fetchBidsAsks() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchBorrowInterest(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    code := GetArg(optionalArgs, 0, nil)
            _ = code
            symbol := GetArg(optionalArgs, 1, nil)
            _ = symbol
            since := GetArg(optionalArgs, 2, nil)
            _ = since
            limit := GetArg(optionalArgs, 3, nil)
            _ = limit
            params := GetArg(optionalArgs, 4, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchBorrowInterest() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchLedger() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchLedgerEntry(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
            panic(NotSupported(Add(this.Id, " fetchLedgerEntry() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseBidAsk(bidask interface{}, optionalArgs ...interface{}) interface{}  {
    priceKey := GetArg(optionalArgs, 0, 0)
    _ = priceKey
    amountKey := GetArg(optionalArgs, 1, 1)
    _ = amountKey
    countOrIdKey := GetArg(optionalArgs, 2, 2)
    _ = countOrIdKey
    var price interface{} = this.SafeNumber(bidask, priceKey)
    var amount interface{} = this.SafeNumber(bidask, amountKey)
    var countOrId interface{} = this.SafeInteger(bidask, countOrIdKey)
    var bidAsk interface{} = []interface{}{price, amount}
    if IsTrue(!IsEqual(countOrId, nil)) {
        AppendToArray(&bidAsk,countOrId)
    }
    return bidAsk
}
func  (this *Exchange) SafeCurrency(currencyId interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    if IsTrue(IsTrue((IsEqual(currencyId, nil))) && IsTrue((!IsEqual(currency, nil)))) {
        return currency
    }
    if IsTrue(IsTrue(IsTrue((!IsEqual(this.Currencies_by_id, nil))) && IsTrue((InOp(this.Currencies_by_id, currencyId)))) && IsTrue((!IsEqual(GetValue(this.Currencies_by_id, currencyId), nil)))) {
        return GetValue(this.Currencies_by_id, currencyId)
    }
    var code interface{} = currencyId
    if IsTrue(!IsEqual(currencyId, nil)) {
        code = this.CommonCurrencyCode(ToUpper(currencyId))
    }
    return this.SafeCurrencyStructure(map[string]interface{} {
        "id": currencyId,
        "code": code,
        "precision": nil,
    })
}
func  (this *Exchange) SafeMarket(optionalArgs ...interface{}) interface{}  {
    marketId := GetArg(optionalArgs, 0, nil)
    _ = marketId
    market := GetArg(optionalArgs, 1, nil)
    _ = market
    delimiter := GetArg(optionalArgs, 2, nil)
    _ = delimiter
    marketType := GetArg(optionalArgs, 3, nil)
    _ = marketType
    var result interface{} = this.SafeMarketStructure(map[string]interface{} {
        "symbol": marketId,
        "marketId": marketId,
    })
    if IsTrue(!IsEqual(marketId, nil)) {
        if IsTrue(IsTrue((!IsEqual(this.Markets_by_id, nil))) && IsTrue((InOp(this.Markets_by_id, marketId)))) {
            var markets interface{} = GetValue(this.Markets_by_id, marketId)
            var numMarkets interface{} =             GetArrayLength(markets)
            if IsTrue(IsEqual(numMarkets, 1)) {
                return GetValue(markets, 0)
            } else {
                if IsTrue(IsEqual(marketType, nil)) {
                    if IsTrue(IsEqual(market, nil)) {
                        panic(ArgumentsRequired(Add(Add(Add(this.Id, " safeMarket() requires a fourth argument for "), marketId), " to disambiguate between different markets with the same market id")))
                    } else {
                        marketType = GetValue(market, "type")
                    }
                }
                for i := 0; IsLessThan(i, GetArrayLength(markets)); i++ {
                    var currentMarket interface{} = GetValue(markets, i)
                    if IsTrue(GetValue(currentMarket, marketType)) {
                        return currentMarket
                    }
                }
            }
        } else if IsTrue(IsTrue(!IsEqual(delimiter, nil)) && IsTrue(!IsEqual(delimiter, ""))) {
            var parts interface{} = Split(marketId, delimiter)
            var partsLength interface{} =             GetArrayLength(parts)
            if IsTrue(IsEqual(partsLength, 2)) {
                AddElementToObject(result, "baseId", this.SafeString(parts, 0))
                AddElementToObject(result, "quoteId", this.SafeString(parts, 1))
                AddElementToObject(result, "base", this.SafeCurrencyCode(GetValue(result, "baseId")))
                AddElementToObject(result, "quote", this.SafeCurrencyCode(GetValue(result, "quoteId")))
                AddElementToObject(result, "symbol", Add(Add(GetValue(result, "base"), "/"), GetValue(result, "quote")))
                return result
            } else {
                return result
            }
        }
    }
    if IsTrue(!IsEqual(market, nil)) {
        return market
    }
    return result
}
func  (this *Exchange) CheckRequiredCredentials(optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @param {boolean} error throw an error that a credential is required if true
    * @returns {boolean} true if all required credentials have been set, otherwise false or an error is thrown is param error=true
    */
    error := GetArg(optionalArgs, 0, true)
    _ = error
    var keys interface{} = ObjectKeys(this.RequiredCredentials)
    for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
        var key interface{} = GetValue(keys, i)
        if IsTrue(IsTrue(GetValue(this.RequiredCredentials, key)) && !IsTrue(GetValue(this, key))) {
            if IsTrue(error) {
                panic(AuthenticationError(Add(Add(Add(this.Id, " requires \""), key), "\" credential")))
            } else {
                return false
            }
        }
    }
    return true
}
func  (this *Exchange) Oath() interface{}  {
    if IsTrue(!IsEqual(this.Twofa, nil)) {
        return Totp(this.Twofa)
    } else {
        panic(ExchangeError(Add(this.Id, " exchange.twofa has not been set for 2FA Two-Factor Authentication")))
    }
}
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchBalance() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchBalanceWs(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
            panic(NotSupported(Add(this.Id, " fetchBalanceWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseBalance(response interface{}) interface{}  {
    panic(NotSupported(Add(this.Id, " parseBalance() is not supported yet")))
}
func  (this *Exchange) WatchBalance(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
            panic(NotSupported(Add(this.Id, " watchBalance() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPartialBalance(part 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
        
            balance:= <-this.DerivedExchange.FetchBalance(params)
            PanicOnError(balance)
        
            ch <- GetValue(balance, part)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchFreeBalance(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
        
                retRes499215 :=  (<-this.FetchPartialBalance("free", params))
                PanicOnError(retRes499215)
                ch <- retRes499215
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchUsedBalance(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
        
                retRes499615 :=  (<-this.FetchPartialBalance("used", params))
                PanicOnError(retRes499615)
                ch <- retRes499615
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchTotalBalance(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
        
                retRes500015 :=  (<-this.FetchPartialBalance("total", params))
                PanicOnError(retRes500015)
                ch <- retRes500015
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchStatus() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTransactionFee(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if !IsTrue(GetValue(this.Has, "fetchTransactionFees")) {
                panic(NotSupported(Add(this.Id, " fetchTransactionFee() is not supported yet")))
            }
        
                retRes501115 :=  (<-this.FetchTransactionFees([]interface{}{code}, params))
                PanicOnError(retRes501115)
                ch <- retRes501115
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchTransactionFees(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    codes := GetArg(optionalArgs, 0, nil)
            _ = codes
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchTransactionFees() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchDepositWithdrawFees(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    codes := GetArg(optionalArgs, 0, nil)
            _ = codes
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchDepositWithdrawFees() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchDepositWithdrawFee(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if !IsTrue(GetValue(this.Has, "fetchDepositWithdrawFees")) {
                panic(NotSupported(Add(this.Id, " fetchDepositWithdrawFee() is not supported yet")))
            }
        
            fees:= <-this.DerivedExchange.FetchDepositWithdrawFees([]interface{}{code}, params)
            PanicOnError(fees)
        
            ch <- this.SafeValue(fees, code)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) GetSupportedMapping(key interface{}, optionalArgs ...interface{}) interface{}  {
    mapping := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = mapping
    if IsTrue(InOp(mapping, key)) {
        return GetValue(mapping, key)
    } else {
        panic(NotSupported(Add(Add(Add(this.Id, " "), key), " does not have a value in mapping")))
    }
}
func  (this *Exchange) FetchCrossBorrowRate(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes50398 := (<-this.LoadMarkets())
            PanicOnError(retRes50398)
            if !IsTrue(GetValue(this.Has, "fetchBorrowRates")) {
                panic(NotSupported(Add(this.Id, " fetchCrossBorrowRate() is not supported yet")))
            }
        
            borrowRates:= (<-this.FetchCrossBorrowRates(params))
            PanicOnError(borrowRates)
            var rate interface{} = this.SafeValue(borrowRates, code)
            if IsTrue(IsEqual(rate, nil)) {
                panic(ExchangeError(Add(Add(this.Id, " fetchCrossBorrowRate() could not find the borrow rate for currency code "), code)))
            }
        
            ch <- rate
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchIsolatedBorrowRate(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
        
            retRes50528 := (<-this.LoadMarkets())
            PanicOnError(retRes50528)
            if !IsTrue(GetValue(this.Has, "fetchBorrowRates")) {
                panic(NotSupported(Add(this.Id, " fetchIsolatedBorrowRate() is not supported yet")))
            }
        
            borrowRates:= (<-this.FetchIsolatedBorrowRates(params))
            PanicOnError(borrowRates)
            var rate interface{} = this.SafeDict(borrowRates, symbol)
            if IsTrue(IsEqual(rate, nil)) {
                panic(ExchangeError(Add(Add(this.Id, " fetchIsolatedBorrowRate() could not find the borrow rate for market symbol "), symbol)))
            }
        
            ch <- rate
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) HandleOptionAndParams(params interface{}, methodName interface{}, optionName interface{}, optionalArgs ...interface{}) interface{}  {
    // This method can be used to obtain method specific properties, i.e: this.handleOptionAndParams (params, 'fetchPosition', 'marginMode', 'isolated')
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var defaultOptionName interface{} = Add("default", this.Capitalize(optionName)) // we also need to check the 'defaultXyzWhatever'
    // check if params contain the key
    var value interface{} = this.SafeValue2(params, optionName, defaultOptionName)
    if IsTrue(!IsEqual(value, nil)) {
        params = this.Omit(params, []interface{}{optionName, defaultOptionName})
    } else {
        // handle routed methods like "watchTrades > watchTradesForSymbols" (or "watchTicker > watchTickers")
        methodNameparamsVariable := this.HandleParamString(params, "callerMethodName", methodName);
        methodName = GetValue(methodNameparamsVariable,0);
        params = GetValue(methodNameparamsVariable,1)
        // check if exchange has properties for this method
        var exchangeWideMethodOptions interface{} = this.SafeValue(this.Options, methodName)
        if IsTrue(!IsEqual(exchangeWideMethodOptions, nil)) {
            // check if the option is defined inside this method's props
            value = this.SafeValue2(exchangeWideMethodOptions, optionName, defaultOptionName)
        }
        if IsTrue(IsEqual(value, nil)) {
            // if it's still undefined, check if global exchange-wide option exists
            value = this.SafeValue2(this.Options, optionName, defaultOptionName)
        }
        // if it's still undefined, use the default value
        value = Ternary(IsTrue((!IsEqual(value, nil))), value, defaultValue)
    }
    return []interface{}{value, params}
}
func  (this *Exchange) HandleOptionAndParams2(params interface{}, methodName1 interface{}, optionName1 interface{}, optionName2 interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var value interface{} = nil
    valueparamsVariable := this.HandleOptionAndParams(params, methodName1, optionName1);
    value = GetValue(valueparamsVariable,0);
    params = GetValue(valueparamsVariable,1)
    if IsTrue(!IsEqual(value, nil)) {
        // omit optionName2 too from params
        params = this.Omit(params, optionName2)
        return []interface{}{value, params}
    }
    // if still undefined, try optionName2
    var value2 interface{} = nil
    value2paramsVariable := this.HandleOptionAndParams(params, methodName1, optionName2, defaultValue);
    value2 = GetValue(value2paramsVariable,0);
    params = GetValue(value2paramsVariable,1)
    return []interface{}{value2, params}
}
func  (this *Exchange) HandleOption(methodName interface{}, optionName interface{}, optionalArgs ...interface{}) interface{}  {
    defaultValue := GetArg(optionalArgs, 0, nil)
    _ = defaultValue
    var res interface{} = this.HandleOptionAndParams(map[string]interface{} {}, methodName, optionName, defaultValue)
    return this.SafeValue(res, 0)
}
func  (this *Exchange) HandleMarketTypeAndParams(methodName interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @name exchange#handleMarketTypeAndParams
    * @param methodName the method calling handleMarketTypeAndParams
    * @param {Market} market
    * @param {object} params
    * @param {string} [params.type] type assigned by user
    * @param {string} [params.defaultType] same as params.type
    * @param {string} [defaultValue] assigned programatically in the method calling handleMarketTypeAndParams
    * @returns {[string, object]} the market type and params with type and defaultType omitted
    */
    // type from param
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    defaultValue := GetArg(optionalArgs, 2, nil)
    _ = defaultValue
    var typeVar interface{} = this.SafeString2(params, "defaultType", "type")
    if IsTrue(!IsEqual(typeVar, nil)) {
        params = this.Omit(params, []interface{}{"defaultType", "type"})
        return []interface{}{typeVar, params}
    }
    // type from market
    if IsTrue(!IsEqual(market, nil)) {
        return []interface{}{GetValue(market, "type"), params}
    }
    // type from default-argument
    if IsTrue(!IsEqual(defaultValue, nil)) {
        return []interface{}{defaultValue, params}
    }
    var methodOptions interface{} = this.SafeDict(this.Options, methodName)
    if IsTrue(!IsEqual(methodOptions, nil)) {
        if IsTrue(IsString(methodOptions)) {
            return []interface{}{methodOptions, params}
        } else {
            var typeFromMethod interface{} = this.SafeString2(methodOptions, "defaultType", "type")
            if IsTrue(!IsEqual(typeFromMethod, nil)) {
                return []interface{}{typeFromMethod, params}
            }
        }
    }
    var defaultType interface{} = this.SafeString2(this.Options, "defaultType", "type", "spot")
    return []interface{}{defaultType, params}
}
func  (this *Exchange) HandleSubTypeAndParams(methodName interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    defaultValue := GetArg(optionalArgs, 2, nil)
    _ = defaultValue
    var subType interface{} = nil
    // if set in params, it takes precedence
    var subTypeInParams interface{} = this.SafeString2(params, "subType", "defaultSubType")
    // avoid omitting if it's not present
    if IsTrue(!IsEqual(subTypeInParams, nil)) {
        subType = subTypeInParams
        params = this.Omit(params, []interface{}{"subType", "defaultSubType"})
    } else {
        // at first, check from market object
        if IsTrue(!IsEqual(market, nil)) {
            if IsTrue(GetValue(market, "linear")) {
                subType = "linear"
            } else if IsTrue(GetValue(market, "inverse")) {
                subType = "inverse"
            }
        }
        // if it was not defined in market object
        if IsTrue(IsEqual(subType, nil)) {
            var values interface{} = this.HandleOptionAndParams(map[string]interface{} {}, methodName, "subType", defaultValue) // no need to re-test params here
            subType = GetValue(values, 0)
        }
    }
    return []interface{}{subType, params}
}
func  (this *Exchange) HandleMarginModeAndParams(methodName interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @param {object} [params] extra parameters specific to the exchange API endpoint
    * @returns {Array} the marginMode in lowercase as specified by params["marginMode"], params["defaultMarginMode"] this.options["marginMode"] or this.options["defaultMarginMode"]
    */
    params := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = params
    defaultValue := GetArg(optionalArgs, 1, nil)
    _ = defaultValue
    return this.HandleOptionAndParams(params, methodName, "marginMode", defaultValue)
}
func  (this *Exchange) ThrowExactlyMatchedException(exact interface{}, string interface{}, message interface{})  {
    if IsTrue(IsEqual(string, nil)) {
        return
    }
    if IsTrue(InOp(exact, string)) {
        throwDynamicException(GetValue(exact, string), message);
    }
}
func  (this *Exchange) ThrowBroadlyMatchedException(broad interface{}, string interface{}, message interface{})  {
    var broadKey interface{} = this.FindBroadlyMatchedKey(broad, string)
    if IsTrue(!IsEqual(broadKey, nil)) {
        throwDynamicException(GetValue(broad, broadKey), message);
    }
}
func  (this *Exchange) FindBroadlyMatchedKey(broad interface{}, string interface{}) interface{}  {
    // a helper for matching error strings exactly vs broadly
    var keys interface{} = ObjectKeys(broad)
    for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
        var key interface{} = GetValue(keys, i)
        if IsTrue(!IsEqual(string, nil)) {
            if IsTrue(IsGreaterThanOrEqual(GetIndexOf(string, key), 0)) {
                return key
            }
        }
    }
    return nil
}
func  (this *Exchange) HandleErrors(statusCode interface{}, statusText interface{}, url interface{}, method interface{}, responseHeaders interface{}, responseBody interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{}  {
    // it is a stub method that must be overrided in the derived exchange classes
    // throw new NotSupported (this.id + ' handleErrors() not implemented yet');
    return nil
}
func  (this *Exchange) CalculateRateLimiterCost(api interface{}, method interface{}, path interface{}, params interface{}, optionalArgs ...interface{}) interface{}  {
    config := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = config
    return this.SafeValue(config, "cost", 1)
}
func  (this *Exchange) FetchTicker(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchTickers")) {
        
                retRes522912 := (<-this.LoadMarkets())
                PanicOnError(retRes522912)
        
                var market interface{} = this.DerivedExchange.Market(symbol)
                PanicOnError(market)
                symbol = GetValue(market, "symbol")
        
                tickers:= <-this.DerivedExchange.FetchTickers([]interface{}{symbol}, params)
                PanicOnError(tickers)
                var ticker interface{} = this.SafeDict(tickers, symbol)
                if IsTrue(IsEqual(ticker, nil)) {
                    panic(NullResponse(Add(Add(this.Id, " fetchTickers() could not find a ticker for "), symbol)))
                } else {
        
                    ch <- ticker
                    return nil
                }
            } else {
                panic(NotSupported(Add(this.Id, " fetchTicker() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchMarkPrice(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchMarkPrices")) {
        
                retRes524612 := (<-this.LoadMarkets())
                PanicOnError(retRes524612)
        
                var market interface{} = this.DerivedExchange.Market(symbol)
                PanicOnError(market)
                symbol = GetValue(market, "symbol")
        
                tickers:= (<-this.FetchMarkPrices([]interface{}{symbol}, params))
                PanicOnError(tickers)
                var ticker interface{} = this.SafeDict(tickers, symbol)
                if IsTrue(IsEqual(ticker, nil)) {
                    panic(NullResponse(Add(Add(this.Id, " fetchMarkPrices() could not find a ticker for "), symbol)))
                } else {
        
                    ch <- ticker
                    return nil
                }
            } else {
                panic(NotSupported(Add(this.Id, " fetchMarkPrices() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchTickerWs(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
            if IsTrue(GetValue(this.Has, "fetchTickersWs")) {
        
                retRes526312 := (<-this.LoadMarkets())
                PanicOnError(retRes526312)
        
                var market interface{} = this.DerivedExchange.Market(symbol)
                PanicOnError(market)
                symbol = GetValue(market, "symbol")
        
                tickers:= (<-this.FetchTickersWs([]interface{}{symbol}, params))
                PanicOnError(tickers)
                var ticker interface{} = this.SafeDict(tickers, symbol)
                if IsTrue(IsEqual(ticker, nil)) {
                    panic(NullResponse(Add(Add(this.Id, " fetchTickerWs() could not find a ticker for "), symbol)))
                } else {
        
                    ch <- ticker
                    return nil
                }
            } else {
                panic(NotSupported(Add(this.Id, " fetchTickerWs() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) WatchTicker(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
            panic(NotSupported(Add(this.Id, " watchTicker() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTickers(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchTickers() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchMarkPrices(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchMarkPrices() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTickersWs(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
            panic(NotSupported(Add(this.Id, " fetchTickers() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOrderBooks(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            limit := GetArg(optionalArgs, 1, nil)
            _ = limit
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchOrderBooks() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchBidsAsks(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
            panic(NotSupported(Add(this.Id, " watchBidsAsks() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchTickers(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
            panic(NotSupported(Add(this.Id, " watchTickers() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) UnWatchTickers(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
            panic(NotSupported(Add(this.Id, " unWatchTickers() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOrderWs(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
            panic(NotSupported(Add(this.Id, " fetchOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOrderStatus(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    // TODO: TypeScript: change method signature by replacing
            // Promise<string> with Promise<Order['status']>.
            symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            order:= <-this.DerivedExchange.FetchOrder(id, symbol, params)
            PanicOnError(order)
        
            ch <- GetValue(order, "status")
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchUnifiedOrder(order 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
        
                retRes532615 :=  <-this.DerivedExchange.FetchOrder(this.SafeString(order, "id"), this.SafeString(order, "symbol"), params)
                PanicOnError(retRes532615)
                ch <- retRes532615
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " createOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " createConvertTrade() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchConvertTrade() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchConvertTradeHistory() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchPositionMode(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchPositionMode() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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)
                    /**
            * @method
            * @name createTrailingAmountOrder
            * @description create a trailing order by providing the symbol, type, side, amount, price and trailingAmount
            * @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}
            */
            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")))
            }
            AddElementToObject(params, "trailingAmount", trailingAmount)
            if IsTrue(!IsEqual(trailingTriggerPrice, nil)) {
                AddElementToObject(params, "trailingTriggerPrice", trailingTriggerPrice)
            }
            if IsTrue(GetValue(this.Has, "createTrailingAmountOrder")) {
        
                    retRes537219 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                    PanicOnError(retRes537219)
                    ch <- retRes537219
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTrailingAmountOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateTrailingAmountOrderWs(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)
                    /**
            * @method
            * @name createTrailingAmountOrderWs
            * @description create a trailing order by providing the symbol, type, side, amount, price and trailingAmount
            * @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}
            */
            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, " createTrailingAmountOrderWs() requires a trailingAmount argument")))
            }
            AddElementToObject(params, "trailingAmount", trailingAmount)
            if IsTrue(!IsEqual(trailingTriggerPrice, nil)) {
                AddElementToObject(params, "trailingTriggerPrice", trailingTriggerPrice)
            }
            if IsTrue(GetValue(this.Has, "createTrailingAmountOrderWs")) {
        
                    retRes540019 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                    PanicOnError(retRes540019)
                    ch <- retRes540019
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTrailingAmountOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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)
                    /**
            * @method
            * @name createTrailingPercentOrder
            * @description create a trailing order by providing the symbol, type, side, amount, price and trailingPercent
            * @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}
            */
            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")))
            }
            AddElementToObject(params, "trailingPercent", trailingPercent)
            if IsTrue(!IsEqual(trailingTriggerPrice, nil)) {
                AddElementToObject(params, "trailingTriggerPrice", trailingTriggerPrice)
            }
            if IsTrue(GetValue(this.Has, "createTrailingPercentOrder")) {
        
                    retRes542819 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                    PanicOnError(retRes542819)
                    ch <- retRes542819
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTrailingPercentOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateTrailingPercentOrderWs(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)
                    /**
            * @method
            * @name createTrailingPercentOrderWs
            * @description create a trailing order by providing the symbol, type, side, amount, price and trailingPercent
            * @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}
            */
            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, " createTrailingPercentOrderWs() requires a trailingPercent argument")))
            }
            AddElementToObject(params, "trailingPercent", trailingPercent)
            if IsTrue(!IsEqual(trailingTriggerPrice, nil)) {
                AddElementToObject(params, "trailingTriggerPrice", trailingTriggerPrice)
            }
            if IsTrue(GetValue(this.Has, "createTrailingPercentOrderWs")) {
        
                    retRes545619 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                    PanicOnError(retRes545619)
                    ch <- retRes545619
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTrailingPercentOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketOrderWithCost(symbol interface{}, side interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name createMarketOrderWithCost
            * @description create a market order by providing the symbol, side and cost
            * @param {string} symbol unified symbol of the market to create an order in
            * @param {string} side 'buy' or 'sell'
            * @param {float} cost how much you want to trade in units of the quote currency
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
            */
            params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(IsTrue(GetValue(this.Has, "createMarketOrderWithCost")) || IsTrue((IsTrue(GetValue(this.Has, "createMarketBuyOrderWithCost")) && IsTrue(GetValue(this.Has, "createMarketSellOrderWithCost"))))) {
        
                    retRes547319 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", side, cost, 1, params)
                    PanicOnError(retRes547319)
                    ch <- retRes547319
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createMarketOrderWithCost() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketBuyOrderWithCost(symbol interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name createMarketBuyOrderWithCost
            * @description create a market buy order by providing the symbol and cost
            * @param {string} symbol unified symbol of the market to create an order in
            * @param {float} cost how much you want to trade in units of the quote currency
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
            */
            params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(IsTrue(GetValue(this.Options, "createMarketBuyOrderRequiresPrice")) || IsTrue(GetValue(this.Has, "createMarketBuyOrderWithCost"))) {
        
                    retRes548919 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", "buy", cost, 1, params)
                    PanicOnError(retRes548919)
                    ch <- retRes548919
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createMarketBuyOrderWithCost() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketSellOrderWithCost(symbol interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name createMarketSellOrderWithCost
            * @description create a market sell order by providing the symbol and cost
            * @param {string} symbol unified symbol of the market to create an order in
            * @param {float} cost how much you want to trade in units of the quote currency
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
            */
            params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(IsTrue(GetValue(this.Options, "createMarketSellOrderRequiresPrice")) || IsTrue(GetValue(this.Has, "createMarketSellOrderWithCost"))) {
        
                    retRes550519 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", "sell", cost, 1, params)
                    PanicOnError(retRes550519)
                    ch <- retRes550519
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createMarketSellOrderWithCost() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketOrderWithCostWs(symbol interface{}, side interface{}, cost interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name createMarketOrderWithCostWs
            * @description create a market order by providing the symbol, side and cost
            * @param {string} symbol unified symbol of the market to create an order in
            * @param {string} side 'buy' or 'sell'
            * @param {float} cost how much you want to trade in units of the quote currency
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
            */
            params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(IsTrue(GetValue(this.Has, "createMarketOrderWithCostWs")) || IsTrue((IsTrue(GetValue(this.Has, "createMarketBuyOrderWithCostWs")) && IsTrue(GetValue(this.Has, "createMarketSellOrderWithCostWs"))))) {
        
                    retRes552219 :=  (<-this.CreateOrderWs(symbol, "market", side, cost, 1, params))
                    PanicOnError(retRes552219)
                    ch <- retRes552219
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createMarketOrderWithCostWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateTriggerOrder(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)
                    /**
            * @method
            * @name createTriggerOrder
            * @description create a trigger stop order (type 1)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} triggerPrice the price to trigger the stop order, 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}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            triggerPrice := GetArg(optionalArgs, 1, nil)
            _ = triggerPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(triggerPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createTriggerOrder() requires a triggerPrice argument")))
            }
            AddElementToObject(params, "triggerPrice", triggerPrice)
            if IsTrue(GetValue(this.Has, "createTriggerOrder")) {
        
                    retRes554619 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                    PanicOnError(retRes554619)
                    ch <- retRes554619
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTriggerOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateTriggerOrderWs(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)
                    /**
            * @method
            * @name createTriggerOrderWs
            * @description create a trigger stop order (type 1)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} triggerPrice the price to trigger the stop order, 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}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            triggerPrice := GetArg(optionalArgs, 1, nil)
            _ = triggerPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(triggerPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createTriggerOrderWs() requires a triggerPrice argument")))
            }
            AddElementToObject(params, "triggerPrice", triggerPrice)
            if IsTrue(GetValue(this.Has, "createTriggerOrderWs")) {
        
                    retRes557019 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                    PanicOnError(retRes557019)
                    ch <- retRes557019
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTriggerOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopLossOrder(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)
                    /**
            * @method
            * @name createStopLossOrder
            * @description create a trigger stop loss order (type 2)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} stopLossPrice the price to trigger the stop loss order, 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}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            stopLossPrice := GetArg(optionalArgs, 1, nil)
            _ = stopLossPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(stopLossPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createStopLossOrder() requires a stopLossPrice argument")))
            }
            AddElementToObject(params, "stopLossPrice", stopLossPrice)
            if IsTrue(GetValue(this.Has, "createStopLossOrder")) {
        
                    retRes559419 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                    PanicOnError(retRes559419)
                    ch <- retRes559419
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createStopLossOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopLossOrderWs(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)
                    /**
            * @method
            * @name createStopLossOrderWs
            * @description create a trigger stop loss order (type 2)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} stopLossPrice the price to trigger the stop loss order, 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}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            stopLossPrice := GetArg(optionalArgs, 1, nil)
            _ = stopLossPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(stopLossPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createStopLossOrderWs() requires a stopLossPrice argument")))
            }
            AddElementToObject(params, "stopLossPrice", stopLossPrice)
            if IsTrue(GetValue(this.Has, "createStopLossOrderWs")) {
        
                    retRes561819 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                    PanicOnError(retRes561819)
                    ch <- retRes561819
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createStopLossOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateTakeProfitOrder(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)
                    /**
            * @method
            * @name createTakeProfitOrder
            * @description create a trigger take profit order (type 2)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} takeProfitPrice the price to trigger the take profit order, 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}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            takeProfitPrice := GetArg(optionalArgs, 1, nil)
            _ = takeProfitPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(takeProfitPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createTakeProfitOrder() requires a takeProfitPrice argument")))
            }
            AddElementToObject(params, "takeProfitPrice", takeProfitPrice)
            if IsTrue(GetValue(this.Has, "createTakeProfitOrder")) {
        
                    retRes564219 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                    PanicOnError(retRes564219)
                    ch <- retRes564219
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTakeProfitOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateTakeProfitOrderWs(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)
                    /**
            * @method
            * @name createTakeProfitOrderWs
            * @description create a trigger take profit order (type 2)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} takeProfitPrice the price to trigger the take profit order, 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}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            takeProfitPrice := GetArg(optionalArgs, 1, nil)
            _ = takeProfitPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(takeProfitPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createTakeProfitOrderWs() requires a takeProfitPrice argument")))
            }
            AddElementToObject(params, "takeProfitPrice", takeProfitPrice)
            if IsTrue(GetValue(this.Has, "createTakeProfitOrderWs")) {
        
                    retRes566619 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                    PanicOnError(retRes566619)
                    ch <- retRes566619
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createTakeProfitOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateOrderWithTakeProfitAndStopLoss(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)
                    /**
            * @method
            * @name createOrderWithTakeProfitAndStopLoss
            * @description create an order with a stop loss or take profit attached (type 3)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} [takeProfit] the take profit price, in units of the quote currency
            * @param {float} [stopLoss] the stop loss price, in units of the quote currency
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @param {string} [params.takeProfitType] *not available on all exchanges* 'limit' or 'market'
            * @param {string} [params.stopLossType] *not available on all exchanges* 'limit' or 'market'
            * @param {string} [params.takeProfitPriceType] *not available on all exchanges* 'last', 'mark' or 'index'
            * @param {string} [params.stopLossPriceType] *not available on all exchanges* 'last', 'mark' or 'index'
            * @param {float} [params.takeProfitLimitPrice] *not available on all exchanges* limit price for a limit take profit order
            * @param {float} [params.stopLossLimitPrice] *not available on all exchanges* stop loss for a limit stop loss order
            * @param {float} [params.takeProfitAmount] *not available on all exchanges* the amount for a take profit
            * @param {float} [params.stopLossAmount] *not available on all exchanges* the amount for a stop loss
            * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            takeProfit := GetArg(optionalArgs, 1, nil)
            _ = takeProfit
            stopLoss := GetArg(optionalArgs, 2, nil)
            _ = stopLoss
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            params = this.SetTakeProfitAndStopLossParams(symbol, typeVar, side, amount, price, takeProfit, stopLoss, params)
            if IsTrue(GetValue(this.Has, "createOrderWithTakeProfitAndStopLoss")) {
        
                    retRes569619 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, params)
                    PanicOnError(retRes569619)
                    ch <- retRes569619
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createOrderWithTakeProfitAndStopLoss() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) SetTakeProfitAndStopLossParams(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) interface{}  {
    price := GetArg(optionalArgs, 0, nil)
    _ = price
    takeProfit := GetArg(optionalArgs, 1, nil)
    _ = takeProfit
    stopLoss := GetArg(optionalArgs, 2, nil)
    _ = stopLoss
    params := GetArg(optionalArgs, 3, map[string]interface{} {})
    _ = params
    if IsTrue(IsTrue((IsEqual(takeProfit, nil))) && IsTrue((IsEqual(stopLoss, nil)))) {
        panic(ArgumentsRequired(Add(this.Id, " createOrderWithTakeProfitAndStopLoss() requires either a takeProfit or stopLoss argument")))
    }
    if IsTrue(!IsEqual(takeProfit, nil)) {
        AddElementToObject(params, "takeProfit", map[string]interface{} {
    "triggerPrice": takeProfit,
})
    }
    if IsTrue(!IsEqual(stopLoss, nil)) {
        AddElementToObject(params, "stopLoss", map[string]interface{} {
    "triggerPrice": stopLoss,
})
    }
    var takeProfitType interface{} = this.SafeString(params, "takeProfitType")
    var takeProfitPriceType interface{} = this.SafeString(params, "takeProfitPriceType")
    var takeProfitLimitPrice interface{} = this.SafeString(params, "takeProfitLimitPrice")
    var takeProfitAmount interface{} = this.SafeString(params, "takeProfitAmount")
    var stopLossType interface{} = this.SafeString(params, "stopLossType")
    var stopLossPriceType interface{} = this.SafeString(params, "stopLossPriceType")
    var stopLossLimitPrice interface{} = this.SafeString(params, "stopLossLimitPrice")
    var stopLossAmount interface{} = this.SafeString(params, "stopLossAmount")
    if IsTrue(!IsEqual(takeProfitType, nil)) {
        AddElementToObject(GetValue(params, "takeProfit"), "type", takeProfitType)
    }
    if IsTrue(!IsEqual(takeProfitPriceType, nil)) {
        AddElementToObject(GetValue(params, "takeProfit"), "priceType", takeProfitPriceType)
    }
    if IsTrue(!IsEqual(takeProfitLimitPrice, nil)) {
        AddElementToObject(GetValue(params, "takeProfit"), "price", this.ParseToNumeric(takeProfitLimitPrice))
    }
    if IsTrue(!IsEqual(takeProfitAmount, nil)) {
        AddElementToObject(GetValue(params, "takeProfit"), "amount", this.ParseToNumeric(takeProfitAmount))
    }
    if IsTrue(!IsEqual(stopLossType, nil)) {
        AddElementToObject(GetValue(params, "stopLoss"), "type", stopLossType)
    }
    if IsTrue(!IsEqual(stopLossPriceType, nil)) {
        AddElementToObject(GetValue(params, "stopLoss"), "priceType", stopLossPriceType)
    }
    if IsTrue(!IsEqual(stopLossLimitPrice, nil)) {
        AddElementToObject(GetValue(params, "stopLoss"), "price", this.ParseToNumeric(stopLossLimitPrice))
    }
    if IsTrue(!IsEqual(stopLossAmount, nil)) {
        AddElementToObject(GetValue(params, "stopLoss"), "amount", this.ParseToNumeric(stopLossAmount))
    }
    params = this.Omit(params, []interface{}{"takeProfitType", "takeProfitPriceType", "takeProfitLimitPrice", "takeProfitAmount", "stopLossType", "stopLossPriceType", "stopLossLimitPrice", "stopLossAmount"})
    return params
}
func  (this *Exchange) CreateOrderWithTakeProfitAndStopLossWs(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)
                    /**
            * @method
            * @name createOrderWithTakeProfitAndStopLossWs
            * @description create an order with a stop loss or take profit attached (type 3)
            * @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 the number of contracts
            * @param {float} [price] the price to fulfill the order, in units of the quote currency, ignored in market orders
            * @param {float} [takeProfit] the take profit price, in units of the quote currency
            * @param {float} [stopLoss] the stop loss price, in units of the quote currency
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @param {string} [params.takeProfitType] *not available on all exchanges* 'limit' or 'market'
            * @param {string} [params.stopLossType] *not available on all exchanges* 'limit' or 'market'
            * @param {string} [params.takeProfitPriceType] *not available on all exchanges* 'last', 'mark' or 'index'
            * @param {string} [params.stopLossPriceType] *not available on all exchanges* 'last', 'mark' or 'index'
            * @param {float} [params.takeProfitLimitPrice] *not available on all exchanges* limit price for a limit take profit order
            * @param {float} [params.stopLossLimitPrice] *not available on all exchanges* stop loss for a limit stop loss order
            * @param {float} [params.takeProfitAmount] *not available on all exchanges* the amount for a take profit
            * @param {float} [params.stopLossAmount] *not available on all exchanges* the amount for a stop loss
            * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
            */
            price := GetArg(optionalArgs, 0, nil)
            _ = price
            takeProfit := GetArg(optionalArgs, 1, nil)
            _ = takeProfit
            stopLoss := GetArg(optionalArgs, 2, nil)
            _ = stopLoss
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            params = this.SetTakeProfitAndStopLossParams(symbol, typeVar, side, amount, price, takeProfit, stopLoss, params)
            if IsTrue(GetValue(this.Has, "createOrderWithTakeProfitAndStopLossWs")) {
        
                    retRes577619 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, params))
                    PanicOnError(retRes577619)
                    ch <- retRes577619
                    return nil
            }
            panic(NotSupported(Add(this.Id, " createOrderWithTakeProfitAndStopLossWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateOrders(orders interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " createOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) EditOrders(orders interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " editOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CreateOrderWs(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
            panic(NotSupported(Add(this.Id, " createOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " cancelOrder() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CancelOrderWs(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
            panic(NotSupported(Add(this.Id, " cancelOrderWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CancelOrdersWs(ids interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " cancelOrdersWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " cancelAllOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " cancelAllOrdersAfter() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CancelOrdersForSymbols(orders interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " cancelOrdersForSymbols() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CancelAllOrdersWs(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
            panic(NotSupported(Add(this.Id, " cancelAllOrdersWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CancelUnifiedOrder(order 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
        
            ch <- <-this.DerivedExchange.CancelOrder(this.SafeString(order, "id"), this.SafeString(order, "symbol"), params)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
            if IsTrue(IsTrue(GetValue(this.Has, "fetchOpenOrders")) && IsTrue(GetValue(this.Has, "fetchClosedOrders"))) {
                panic(NotSupported(Add(this.Id, " fetchOrders() is not supported yet, consider using fetchOpenOrders() and fetchClosedOrders() instead")))
            }
            panic(NotSupported(Add(this.Id, " fetchOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOrdersWs(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
            panic(NotSupported(Add(this.Id, " fetchOrdersWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchOrderTrades() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchOrders(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
            panic(NotSupported(Add(this.Id, " watchOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            if IsTrue(GetValue(this.Has, "fetchOrders")) {
        
                orders:= <-this.DerivedExchange.FetchOrders(symbol, since, limit, params)
                PanicOnError(orders)
        
                ch <- this.FilterBy(orders, "status", "open")
                return nil
            }
            panic(NotSupported(Add(this.Id, " fetchOpenOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOpenOrdersWs(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchOrdersWs")) {
        
                orders:= (<-this.FetchOrdersWs(symbol, since, limit, params))
                PanicOnError(orders)
        
                ch <- this.FilterBy(orders, "status", "open")
                return nil
            }
            panic(NotSupported(Add(this.Id, " fetchOpenOrdersWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            if IsTrue(GetValue(this.Has, "fetchOrders")) {
        
                orders:= <-this.DerivedExchange.FetchOrders(symbol, since, limit, params)
                PanicOnError(orders)
        
                ch <- this.FilterBy(orders, "status", "closed")
                return nil
            }
            panic(NotSupported(Add(this.Id, " fetchClosedOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchCanceledAndClosedOrders(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchCanceledAndClosedOrders() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchClosedOrdersWs(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchOrdersWs")) {
        
                orders:= (<-this.FetchOrdersWs(symbol, since, limit, params))
                PanicOnError(orders)
        
                ch <- this.FilterBy(orders, "status", "closed")
                return nil
            }
            panic(NotSupported(Add(this.Id, " fetchClosedOrdersWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchMyTrades() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchMyLiquidations(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchMyLiquidations() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchLiquidations(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
            panic(NotSupported(Add(this.Id, " fetchLiquidations() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchMyTradesWs(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
            panic(NotSupported(Add(this.Id, " fetchMyTradesWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) WatchMyTrades(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
            panic(NotSupported(Add(this.Id, " watchMyTrades() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchGreeks(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
            panic(NotSupported(Add(this.Id, " fetchGreeks() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOptionChain(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchOptionChain() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchOption(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
            panic(NotSupported(Add(this.Id, " fetchOption() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchConvertQuote() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchDepositsWithdrawals() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchDeposits(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
            panic(NotSupported(Add(this.Id, " fetchDeposits() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchWithdrawals(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
            panic(NotSupported(Add(this.Id, " fetchWithdrawals() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchDepositsWs(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
            panic(NotSupported(Add(this.Id, " fetchDepositsWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchWithdrawalsWs(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
            panic(NotSupported(Add(this.Id, " fetchWithdrawalsWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchFundingRateHistory() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchFundingHistory() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ClosePosition(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    side := GetArg(optionalArgs, 0, nil)
            _ = side
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " closePosition() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CloseAllPositions(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " closeAllPositions() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchL3OrderBook(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
            panic(BadRequest(Add(this.Id, " fetchL3OrderBook() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseLastPrice(price interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseLastPrice() is not supported yet")))
}
func  (this *Exchange) FetchDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchDepositAddresses")) {
        
                depositAddresses:= (<-this.FetchDepositAddresses([]interface{}{code}, params))
                PanicOnError(depositAddresses)
                var depositAddress interface{} = this.SafeValue(depositAddresses, code)
                if IsTrue(IsEqual(depositAddress, nil)) {
                    panic(InvalidAddress(Add(Add(Add(this.Id, " fetchDepositAddress() could not find a deposit address for "), code), ", make sure you have created a corresponding deposit address in your wallet on the exchange website")))
                } else {
        
                    ch <- depositAddress
                    return nil
                }
            } else if IsTrue(GetValue(this.Has, "fetchDepositAddressesByNetwork")) {
                var network interface{} = this.SafeString(params, "network")
                params = this.Omit(params, "network")
        
                addressStructures:= (<-this.FetchDepositAddressesByNetwork(code, params))
                PanicOnError(addressStructures)
                if IsTrue(!IsEqual(network, nil)) {
        
                    ch <- this.SafeDict(addressStructures, network)
                    return nil
                } else {
                    var keys interface{} = ObjectKeys(addressStructures)
                    var key interface{} = this.SafeString(keys, 0)
        
                    ch <- this.SafeDict(addressStructures, key)
                    return nil
                }
            } else {
                panic(NotSupported(Add(this.Id, " fetchDepositAddress() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) Account() interface{}  {
    return map[string]interface{} {
        "free": nil,
        "used": nil,
        "total": nil,
    }
}
func  (this *Exchange) CommonCurrencyCode(code interface{}) interface{}  {
    if !IsTrue(this.SubstituteCommonCurrencyCodes) {
        return code
    }
    return this.SafeString(this.CommonCurrencies, code, code)
}
func  (this *Exchange) Currency(code interface{}) interface{}  {
    if IsTrue(IsEqual(this.Currencies, nil)) {
        panic(ExchangeError(Add(this.Id, " currencies not loaded")))
    }
    if IsTrue(IsString(code)) {
        if IsTrue(InOp(this.Currencies, code)) {
            return GetValue(this.Currencies, code)
        } else if IsTrue(InOp(this.Currencies_by_id, code)) {
            return GetValue(this.Currencies_by_id, code)
        }
    }
    panic(ExchangeError(Add(Add(this.Id, " does not have currency code "), code)))
}
func  (this *Exchange) Market(symbol interface{}) interface{}  {
    if IsTrue(IsEqual(this.Markets, nil)) {
        panic(ExchangeError(Add(this.Id, " markets not loaded")))
    }
    if IsTrue(InOp(this.Markets, symbol)) {
        return GetValue(this.Markets, symbol)
    } else if IsTrue(InOp(this.Markets_by_id, symbol)) {
        var markets interface{} = GetValue(this.Markets_by_id, symbol)
        var defaultType interface{} = this.SafeString2(this.Options, "defaultType", "defaultSubType", "spot")
        for i := 0; IsLessThan(i, GetArrayLength(markets)); i++ {
            var market interface{} = GetValue(markets, i)
            if IsTrue(GetValue(market, defaultType)) {
                return market
            }
        }
        return GetValue(markets, 0)
    } else if IsTrue(IsTrue(IsTrue(IsTrue((EndsWith(symbol, "-C"))) || IsTrue((EndsWith(symbol, "-P")))) || IsTrue((StartsWith(symbol, "C-")))) || IsTrue((StartsWith(symbol, "P-")))) {
        return this.DerivedExchange.CreateExpiredOptionMarket(symbol)
    }
    panic(BadSymbol(Add(Add(this.Id, " does not have market symbol "), symbol)))
}
func  (this *Exchange) CreateExpiredOptionMarket(symbol interface{}) interface{}  {
    panic(NotSupported(Add(this.Id, " createExpiredOptionMarket () is not supported yet")))
}
func  (this *Exchange) HandleWithdrawTagAndParams(tag interface{}, params interface{}) interface{}  {
    if IsTrue(IsTrue((!IsEqual(tag, nil))) && IsTrue((IsObject(tag)))) {
        params = this.Extend(tag, params)
        tag = nil
    }
    if IsTrue(IsEqual(tag, nil)) {
        tag = this.SafeString(params, "tag")
        if IsTrue(!IsEqual(tag, nil)) {
            params = this.Omit(params, "tag")
        }
    }
    return []interface{}{tag, params}
}
func  (this *Exchange) CreateLimitOrder(symbol interface{}, side interface{}, amount interface{}, price 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
        
                retRes606515 :=  <-this.DerivedExchange.CreateOrder(symbol, "limit", side, amount, price, params)
                PanicOnError(retRes606515)
                ch <- retRes606515
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateLimitOrderWs(symbol interface{}, side interface{}, amount interface{}, price 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
        
                retRes606915 :=  (<-this.CreateOrderWs(symbol, "limit", side, amount, price, params))
                PanicOnError(retRes606915)
                ch <- retRes606915
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketOrder(symbol 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
        
                retRes607315 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", side, amount, price, params)
                PanicOnError(retRes607315)
                ch <- retRes607315
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketOrderWs(symbol 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
        
                retRes607715 :=  (<-this.CreateOrderWs(symbol, "market", side, amount, price, params))
                PanicOnError(retRes607715)
                ch <- retRes607715
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateLimitBuyOrder(symbol interface{}, amount interface{}, price 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
        
                retRes608115 :=  <-this.DerivedExchange.CreateOrder(symbol, "limit", "buy", amount, price, params)
                PanicOnError(retRes608115)
                ch <- retRes608115
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateLimitBuyOrderWs(symbol interface{}, amount interface{}, price 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
        
                retRes608515 :=  (<-this.CreateOrderWs(symbol, "limit", "buy", amount, price, params))
                PanicOnError(retRes608515)
                ch <- retRes608515
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateLimitSellOrder(symbol interface{}, amount interface{}, price 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
        
                retRes608915 :=  <-this.DerivedExchange.CreateOrder(symbol, "limit", "sell", amount, price, params)
                PanicOnError(retRes608915)
                ch <- retRes608915
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateLimitSellOrderWs(symbol interface{}, amount interface{}, price 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
        
                retRes609315 :=  (<-this.CreateOrderWs(symbol, "limit", "sell", amount, price, params))
                PanicOnError(retRes609315)
                ch <- retRes609315
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketBuyOrder(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
        
                retRes609715 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", "buy", amount, nil, params)
                PanicOnError(retRes609715)
                ch <- retRes609715
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketBuyOrderWs(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
        
                retRes610115 :=  (<-this.CreateOrderWs(symbol, "market", "buy", amount, nil, params))
                PanicOnError(retRes610115)
                ch <- retRes610115
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketSellOrder(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
        
                retRes610515 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", "sell", amount, nil, params)
                PanicOnError(retRes610515)
                ch <- retRes610515
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateMarketSellOrderWs(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
        
                retRes610915 :=  (<-this.CreateOrderWs(symbol, "market", "sell", amount, nil, params))
                PanicOnError(retRes610915)
                ch <- retRes610915
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CostToPrecision(symbol interface{}, cost interface{}) interface{}  {
    if IsTrue(IsEqual(cost, nil)) {
        return nil
    }

    var market interface{} = this.DerivedExchange.Market(symbol)
    PanicOnError(market)
    return this.DecimalToPrecision(cost, TRUNCATE, GetValue(GetValue(market, "precision"), "price"), this.PrecisionMode, this.PaddingMode)
}
func  (this *Exchange) PriceToPrecision(symbol interface{}, price interface{}) interface{}  {
    if IsTrue(IsEqual(price, nil)) {
        return nil
    }

    var market interface{} = this.DerivedExchange.Market(symbol)
    PanicOnError(market)
    var result interface{} = this.DecimalToPrecision(price, ROUND, GetValue(GetValue(market, "precision"), "price"), this.PrecisionMode, this.PaddingMode)
    if IsTrue(IsEqual(result, "0")) {
        panic(InvalidOrder(Add(Add(Add(Add(this.Id, " price of "), GetValue(market, "symbol")), " must be greater than minimum price precision of "), this.NumberToString(GetValue(GetValue(market, "precision"), "price")))))
    }
    return result
}
func  (this *Exchange) AmountToPrecision(symbol interface{}, amount interface{}) interface{}  {
    if IsTrue(IsEqual(amount, nil)) {
        return nil
    }

    var market interface{} = this.DerivedExchange.Market(symbol)
    PanicOnError(market)
    var result interface{} = this.DecimalToPrecision(amount, TRUNCATE, GetValue(GetValue(market, "precision"), "amount"), this.PrecisionMode, this.PaddingMode)
    if IsTrue(IsEqual(result, "0")) {
        panic(InvalidOrder(Add(Add(Add(Add(this.Id, " amount of "), GetValue(market, "symbol")), " must be greater than minimum amount precision of "), this.NumberToString(GetValue(GetValue(market, "precision"), "amount")))))
    }
    return result
}
func  (this *Exchange) FeeToPrecision(symbol interface{}, fee interface{}) interface{}  {
    if IsTrue(IsEqual(fee, nil)) {
        return nil
    }

    var market interface{} = this.DerivedExchange.Market(symbol)
    PanicOnError(market)
    return this.DecimalToPrecision(fee, ROUND, GetValue(GetValue(market, "precision"), "price"), this.PrecisionMode, this.PaddingMode)
}
func  (this *Exchange) CurrencyToPrecision(code interface{}, fee interface{}, optionalArgs ...interface{}) interface{}  {
    networkCode := GetArg(optionalArgs, 0, nil)
    _ = networkCode
    var currency interface{} = GetValue(this.Currencies, code)
    var precision interface{} = this.SafeValue(currency, "precision")
    if IsTrue(!IsEqual(networkCode, nil)) {
        var networks interface{} = this.SafeDict(currency, "networks", map[string]interface{} {})
        var networkItem interface{} = this.SafeDict(networks, networkCode, map[string]interface{} {})
        precision = this.SafeValue(networkItem, "precision", precision)
    }
    if IsTrue(IsEqual(precision, nil)) {
        return this.ForceString(fee)
    } else {
        var roundingMode interface{} = this.SafeInteger(this.Options, "currencyToPrecisionRoundingMode", ROUND)
        return this.DecimalToPrecision(fee, roundingMode, precision, this.PrecisionMode, this.PaddingMode)
    }
}
func  (this *Exchange) ForceString(value interface{}) interface{}  {
    if IsTrue(!IsString(value)) {
        return this.NumberToString(value)
    }
    return value
}
func  (this *Exchange) IsTickPrecision() interface{}  {
    return IsEqual(this.PrecisionMode, TICK_SIZE)
}
func  (this *Exchange) IsDecimalPrecision() interface{}  {
    return IsEqual(this.PrecisionMode, DECIMAL_PLACES)
}
func  (this *Exchange) IsSignificantPrecision() interface{}  {
    return IsEqual(this.PrecisionMode, SIGNIFICANT_DIGITS)
}
func  (this *Exchange) SafeNumber(obj interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    defaultNumber := GetArg(optionalArgs, 0, nil)
    _ = defaultNumber
    var value interface{} = this.SafeString(obj, key)
    return this.ParseNumber(value, defaultNumber)
}
func  (this *Exchange) SafeNumberN(obj interface{}, arr interface{}, optionalArgs ...interface{}) interface{}  {
    defaultNumber := GetArg(optionalArgs, 0, nil)
    _ = defaultNumber
    var value interface{} = this.SafeStringN(obj, arr)
    return this.ParseNumber(value, defaultNumber)
}
func  (this *Exchange) ParsePrecision(precision interface{}) interface{}  {
    /**
     * @ignore
     * @method
     * @param {string} precision The number of digits to the right of the decimal
     * @returns {string} a string number equal to 1e-precision
     */
    if IsTrue(IsEqual(precision, nil)) {
        return nil
    }
    var precisionNumber interface{} = ParseInt(precision)
    if IsTrue(IsEqual(precisionNumber, 0)) {
        return "1"
    }
    var parsedPrecision interface{} = "0."
    for i := 0; IsLessThan(i, Subtract(precisionNumber, 1)); i++ {
        parsedPrecision = Add(parsedPrecision, "0")
    }
    return Add(parsedPrecision, "1")
}
func  (this *Exchange) IntegerPrecisionToAmount(precision interface{}) interface{}  {
    /**
     * @ignore
     * @method
     * @description handles positive & negative numbers too. parsePrecision() does not handle negative numbers, but this method handles
     * @param {string} precision The number of digits to the right of the decimal
     * @returns {string} a string number equal to 1e-precision
     */
    if IsTrue(IsEqual(precision, nil)) {
        return nil
    }
    if IsTrue(Precise.StringGe(precision, "0")) {
        return this.ParsePrecision(precision)
    } else {
        var positivePrecisionString interface{} = Precise.StringAbs(precision)
        var positivePrecision interface{} = ParseInt(positivePrecisionString)
        var parsedPrecision interface{} = "1"
        for i := 0; IsLessThan(i, Subtract(positivePrecision, 1)); i++ {
            parsedPrecision = Add(parsedPrecision, "0")
        }
        return Add(parsedPrecision, "0")
    }
}
func  (this *Exchange) LoadTimeDifference(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
        
            serverTime:= <-this.DerivedExchange.FetchTime(params)
            PanicOnError(serverTime)
            var after interface{} = this.Milliseconds()
            AddElementToObject(this.Options, "timeDifference", Subtract(after, serverTime))
        
            ch <- GetValue(this.Options, "timeDifference")
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) ImplodeHostname(url interface{}) interface{}  {
    return this.ImplodeParams(url, map[string]interface{} {
        "hostname": this.Hostname,
    })
}
func  (this *Exchange) FetchMarketLeverageTiers(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
            if IsTrue(GetValue(this.Has, "fetchLeverageTiers")) {
        
                var market interface{} = this.DerivedExchange.Market(symbol)
                PanicOnError(market)
                if !IsTrue(GetValue(market, "contract")) {
                    panic(BadSymbol(Add(this.Id, " fetchMarketLeverageTiers() supports contract markets only")))
                }
        
                tiers:= <-this.DerivedExchange.FetchLeverageTiers([]interface{}{symbol})
                PanicOnError(tiers)
        
                ch <- this.SafeValue(tiers, symbol)
                return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchMarketLeverageTiers() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) CreatePostOnlyOrder(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
            if !IsTrue(GetValue(this.Has, "createPostOnlyOrder")) {
                panic(NotSupported(Add(this.Id, " createPostOnlyOrder() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "postOnly": true,
            })
        
                retRes627115 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, query)
                PanicOnError(retRes627115)
                ch <- retRes627115
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreatePostOnlyOrderWs(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
            if !IsTrue(GetValue(this.Has, "createPostOnlyOrderWs")) {
                panic(NotSupported(Add(this.Id, " createPostOnlyOrderWs() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "postOnly": true,
            })
        
                retRes627915 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, query))
                PanicOnError(retRes627915)
                ch <- retRes627915
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateReduceOnlyOrder(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
            if !IsTrue(GetValue(this.Has, "createReduceOnlyOrder")) {
                panic(NotSupported(Add(this.Id, " createReduceOnlyOrder() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "reduceOnly": true,
            })
        
                retRes628715 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, query)
                PanicOnError(retRes628715)
                ch <- retRes628715
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateReduceOnlyOrderWs(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
            if !IsTrue(GetValue(this.Has, "createReduceOnlyOrderWs")) {
                panic(NotSupported(Add(this.Id, " createReduceOnlyOrderWs() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "reduceOnly": true,
            })
        
                retRes629515 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, query))
                PanicOnError(retRes629515)
                ch <- retRes629515
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopOrder(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
            triggerPrice := GetArg(optionalArgs, 1, nil)
            _ = triggerPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if !IsTrue(GetValue(this.Has, "createStopOrder")) {
                panic(NotSupported(Add(this.Id, " createStopOrder() is not supported yet")))
            }
            if IsTrue(IsEqual(triggerPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " create_stop_order() requires a stopPrice argument")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "stopPrice": triggerPrice,
            })
        
                retRes630615 :=  <-this.DerivedExchange.CreateOrder(symbol, typeVar, side, amount, price, query)
                PanicOnError(retRes630615)
                ch <- retRes630615
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopOrderWs(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
            triggerPrice := GetArg(optionalArgs, 1, nil)
            _ = triggerPrice
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if !IsTrue(GetValue(this.Has, "createStopOrderWs")) {
                panic(NotSupported(Add(this.Id, " createStopOrderWs() is not supported yet")))
            }
            if IsTrue(IsEqual(triggerPrice, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " createStopOrderWs() requires a stopPrice argument")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "stopPrice": triggerPrice,
            })
        
                retRes631715 :=  (<-this.CreateOrderWs(symbol, typeVar, side, amount, price, query))
                PanicOnError(retRes631715)
                ch <- retRes631715
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopLimitOrder(symbol interface{}, side interface{}, amount interface{}, price interface{}, triggerPrice 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
            if !IsTrue(GetValue(this.Has, "createStopLimitOrder")) {
                panic(NotSupported(Add(this.Id, " createStopLimitOrder() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "stopPrice": triggerPrice,
            })
        
                retRes632515 :=  <-this.DerivedExchange.CreateOrder(symbol, "limit", side, amount, price, query)
                PanicOnError(retRes632515)
                ch <- retRes632515
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopLimitOrderWs(symbol interface{}, side interface{}, amount interface{}, price interface{}, triggerPrice 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
            if !IsTrue(GetValue(this.Has, "createStopLimitOrderWs")) {
                panic(NotSupported(Add(this.Id, " createStopLimitOrderWs() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "stopPrice": triggerPrice,
            })
        
                retRes633315 :=  (<-this.CreateOrderWs(symbol, "limit", side, amount, price, query))
                PanicOnError(retRes633315)
                ch <- retRes633315
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopMarketOrder(symbol interface{}, side interface{}, amount interface{}, triggerPrice 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
            if !IsTrue(GetValue(this.Has, "createStopMarketOrder")) {
                panic(NotSupported(Add(this.Id, " createStopMarketOrder() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "stopPrice": triggerPrice,
            })
        
                retRes634115 :=  <-this.DerivedExchange.CreateOrder(symbol, "market", side, amount, nil, query)
                PanicOnError(retRes634115)
                ch <- retRes634115
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) CreateStopMarketOrderWs(symbol interface{}, side interface{}, amount interface{}, triggerPrice 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
            if !IsTrue(GetValue(this.Has, "createStopMarketOrderWs")) {
                panic(NotSupported(Add(this.Id, " createStopMarketOrderWs() is not supported yet")))
            }
            var query interface{} = this.Extend(params, map[string]interface{} {
                "stopPrice": triggerPrice,
            })
        
                retRes634915 :=  (<-this.CreateOrderWs(symbol, "market", side, amount, nil, query))
                PanicOnError(retRes634915)
                ch <- retRes634915
                return nil
        
            }()
            return ch
        }
func  (this *Exchange) SafeCurrencyCode(currencyId interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    currency = this.SafeCurrency(currencyId, currency)
    return GetValue(currency, "code")
}
func  (this *Exchange) FilterBySymbolSinceLimit(array interface{}, optionalArgs ...interface{}) interface{}  {
    symbol := GetArg(optionalArgs, 0, nil)
    _ = symbol
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    tail := GetArg(optionalArgs, 3, false)
    _ = tail
    return this.FilterByValueSinceLimit(array, "symbol", symbol, since, limit, "timestamp", tail)
}
func  (this *Exchange) FilterByCurrencySinceLimit(array interface{}, optionalArgs ...interface{}) interface{}  {
    code := GetArg(optionalArgs, 0, nil)
    _ = code
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    tail := GetArg(optionalArgs, 3, false)
    _ = tail
    return this.FilterByValueSinceLimit(array, "currency", code, since, limit, "timestamp", tail)
}
func  (this *Exchange) FilterBySymbolsSinceLimit(array interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    tail := GetArg(optionalArgs, 3, false)
    _ = tail
    var result interface{} = this.FilterByArray(array, "symbol", symbols, false)
    return this.FilterBySinceLimit(result, since, limit, "timestamp", tail)
}
func  (this *Exchange) ParseLastPrices(pricesData interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // the value of tickers is either a dict or a list
    //
    // dict
    //
    //     {
    //         'marketId1': { ... },
    //         'marketId2': { ... },
    //         ...
    //     }
    //
    // list
    //
    //     [
    //         { 'market': 'marketId1', ... },
    //         { 'market': 'marketId2', ... },
    //         ...
    //     ]
    //
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    var results interface{} = []interface{}{}
    if IsTrue(IsArray(pricesData)) {
        for i := 0; IsLessThan(i, GetArrayLength(pricesData)); i++ {
            var priceData interface{} = this.Extend(this.ParseLastPrice(GetValue(pricesData, i)), params)
            AppendToArray(&results,priceData)
        }
    } else {
        var marketIds interface{} = ObjectKeys(pricesData)
        for i := 0; IsLessThan(i, GetArrayLength(marketIds)); i++ {
            var marketId interface{} = GetValue(marketIds, i)

            var market interface{} = this.DerivedExchange.SafeMarket(marketId)
            PanicOnError(market)
            var priceData interface{} = this.Extend(this.ParseLastPrice(GetValue(pricesData, marketId), market), params)
            AppendToArray(&results,priceData)
        }
    }
    symbols = this.MarketSymbols(symbols)
    return this.FilterByArray(results, "symbol", symbols)
}
func  (this *Exchange) ParseTickers(tickers interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // the value of tickers is either a dict or a list
    //
    //
    // dict
    //
    //     {
    //         'marketId1': { ... },
    //         'marketId2': { ... },
    //         'marketId3': { ... },
    //         ...
    //     }
    //
    // list
    //
    //     [
    //         { 'market': 'marketId1', ... },
    //         { 'market': 'marketId2', ... },
    //         { 'market': 'marketId3', ... },
    //         ...
    //     ]
    //
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    var results interface{} = []interface{}{}
    if IsTrue(IsArray(tickers)) {
        for i := 0; IsLessThan(i, GetArrayLength(tickers)); i++ {

            var parsedTicker interface{} = this.DerivedExchange.ParseTicker(GetValue(tickers, i))
            PanicOnError(parsedTicker)
            var ticker interface{} = this.Extend(parsedTicker, params)
            AppendToArray(&results,ticker)
        }
    } else {
        var marketIds interface{} = ObjectKeys(tickers)
        for i := 0; IsLessThan(i, GetArrayLength(marketIds)); i++ {
            var marketId interface{} = GetValue(marketIds, i)

            var market interface{} = this.DerivedExchange.SafeMarket(marketId)
            PanicOnError(market)

            var parsed interface{} = this.DerivedExchange.ParseTicker(GetValue(tickers, marketId), market)
            PanicOnError(parsed)
            var ticker interface{} = this.Extend(parsed, params)
            AppendToArray(&results,ticker)
        }
    }
    symbols = this.MarketSymbols(symbols)
    return this.FilterByArray(results, "symbol", symbols)
}
func  (this *Exchange) ParseDepositAddresses(addresses interface{}, optionalArgs ...interface{}) interface{}  {
    codes := GetArg(optionalArgs, 0, nil)
    _ = codes
    indexed := GetArg(optionalArgs, 1, true)
    _ = indexed
    params := GetArg(optionalArgs, 2, map[string]interface{} {})
    _ = params
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(addresses)); i++ {
        var address interface{} = this.Extend(this.DerivedExchange.ParseDepositAddress(GetValue(addresses, i)), params)
        AppendToArray(&result,address)
    }
    if IsTrue(!IsEqual(codes, nil)) {
        result = this.FilterByArray(result, "currency", codes, false)
    }
    if IsTrue(indexed) {
        result = this.FilterByArray(result, "currency", nil, indexed)
    }
    return result
}
func  (this *Exchange) ParseBorrowInterests(response interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var interests interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var row interface{} = GetValue(response, i)
        AppendToArray(&interests,this.DerivedExchange.ParseBorrowInterest(row, market))
    }
    return interests
}
func  (this *Exchange) ParseBorrowRate(info interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    panic(NotSupported(Add(this.Id, " parseBorrowRate() is not supported yet")))
}
func  (this *Exchange) ParseBorrowRateHistory(response interface{}, code interface{}, since interface{}, limit interface{}) interface{}  {
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var item interface{} = GetValue(response, i)

        var borrowRate interface{} = this.DerivedExchange.ParseBorrowRate(item)
        PanicOnError(borrowRate)
        AppendToArray(&result,borrowRate)
    }
    var sorted interface{} = this.SortBy(result, "timestamp")
    return this.FilterByCurrencySinceLimit(sorted, code, since, limit)
}
func  (this *Exchange) ParseIsolatedBorrowRates(info interface{}) interface{}  {
    var result interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(info)); i++ {
        var item interface{} = GetValue(info, i)
        var borrowRate interface{} = this.ParseIsolatedBorrowRate(item)
        var symbol interface{} = this.SafeString(borrowRate, "symbol")
        AddElementToObject(result, symbol, borrowRate)
    }
    return result
}
func  (this *Exchange) ParseFundingRateHistories(response interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    var rates interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var entry interface{} = GetValue(response, i)
        AppendToArray(&rates,this.DerivedExchange.ParseFundingRateHistory(entry, market))
    }
    var sorted interface{} = this.SortBy(rates, "timestamp")
    var symbol interface{} = Ternary(IsTrue((IsEqual(market, nil))), nil, GetValue(market, "symbol"))
    return this.FilterBySymbolSinceLimit(sorted, symbol, since, limit)
}
func  (this *Exchange) SafeSymbol(marketId interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    delimiter := GetArg(optionalArgs, 1, nil)
    _ = delimiter
    marketType := GetArg(optionalArgs, 2, nil)
    _ = marketType
    
market = this.DerivedExchange.SafeMarket(marketId, market, delimiter, marketType)
    PanicOnError(market)
    return GetValue(market, "symbol")
}
func  (this *Exchange) ParseFundingRate(contract interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseFundingRate() is not supported yet")))
}
func  (this *Exchange) ParseFundingRates(response interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    var fundingRates interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var entry interface{} = GetValue(response, i)

        var parsed interface{} = this.DerivedExchange.ParseFundingRate(entry)
        PanicOnError(parsed)
        AddElementToObject(fundingRates, GetValue(parsed, "symbol"), parsed)
    }
    return this.FilterByArray(fundingRates, "symbol", symbols)
}
func  (this *Exchange) ParseLongShortRatio(info interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseLongShortRatio() is not supported yet")))
}
func  (this *Exchange) ParseLongShortRatioHistory(response interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    var rates interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var entry interface{} = GetValue(response, i)
        AppendToArray(&rates,this.ParseLongShortRatio(entry, market))
    }
    var sorted interface{} = this.SortBy(rates, "timestamp")
    var symbol interface{} = Ternary(IsTrue((IsEqual(market, nil))), nil, GetValue(market, "symbol"))
    return this.FilterBySymbolSinceLimit(sorted, symbol, since, limit)
}
func  (this *Exchange) HandleTriggerDirectionAndParams(params interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @returns {[string, object]} the trigger-direction value and omited params
    */
    exchangeSpecificKey := GetArg(optionalArgs, 0, nil)
    _ = exchangeSpecificKey
    allowEmpty := GetArg(optionalArgs, 1, false)
    _ = allowEmpty
    var triggerDirection interface{} = this.SafeString(params, "triggerDirection")
    var exchangeSpecificDefined interface{} = IsTrue((!IsEqual(exchangeSpecificKey, nil))) && IsTrue((InOp(params, exchangeSpecificKey)))
    if IsTrue(!IsEqual(triggerDirection, nil)) {
        params = this.Omit(params, "triggerDirection")
    }
    // throw exception if:
    // A) if provided value is not unified (support old "up/down" strings too)
    // B) if exchange specific "trigger direction key" (eg. "stopPriceSide") was not provided
    if IsTrue(IsTrue(!IsTrue(this.InArray(triggerDirection, []interface{}{"ascending", "descending", "up", "down", "above", "below"})) && !IsTrue(exchangeSpecificDefined)) && !IsTrue(allowEmpty)) {
        panic(ArgumentsRequired(Add(this.Id, " createOrder() : trigger orders require params[\"triggerDirection\"] to be either \"ascending\" or \"descending\"")))
    }
    // if old format was provided, overwrite to new
    if IsTrue(IsTrue(IsEqual(triggerDirection, "up")) || IsTrue(IsEqual(triggerDirection, "above"))) {
        triggerDirection = "ascending"
    } else if IsTrue(IsTrue(IsEqual(triggerDirection, "down")) || IsTrue(IsEqual(triggerDirection, "below"))) {
        triggerDirection = "descending"
    }
    return []interface{}{triggerDirection, params}
}
func  (this *Exchange) HandleTriggerAndParams(params interface{}) interface{}  {
    var isTrigger interface{} = this.SafeBool2(params, "trigger", "stop")
    if IsTrue(isTrigger) {
        params = this.Omit(params, []interface{}{"trigger", "stop"})
    }
    return []interface{}{isTrigger, params}
}
func  (this *Exchange) IsTriggerOrder(params interface{}) interface{}  {
    // for backwards compatibility
    return this.HandleTriggerAndParams(params)
}
func  (this *Exchange) IsPostOnly(isMarketOrder interface{}, exchangeSpecificParam interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @param {string} type Order type
    * @param {boolean} exchangeSpecificParam exchange specific postOnly
    * @param {object} [params] exchange specific params
    * @returns {boolean} true if a post only order, false otherwise
    */
    params := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = params
    var timeInForce interface{} = this.SafeStringUpper(params, "timeInForce")
    var postOnly interface{} = this.SafeBool2(params, "postOnly", "post_only", false)
    // we assume timeInForce is uppercase from safeStringUpper (params, 'timeInForce')
    var ioc interface{} = IsEqual(timeInForce, "IOC")
    var fok interface{} = IsEqual(timeInForce, "FOK")
    var timeInForcePostOnly interface{} = IsEqual(timeInForce, "PO")
    postOnly = IsTrue(IsTrue(postOnly) || IsTrue(timeInForcePostOnly)) || IsTrue(exchangeSpecificParam)
    if IsTrue(postOnly) {
        if IsTrue(IsTrue(ioc) || IsTrue(fok)) {
            panic(InvalidOrder(Add(Add(this.Id, " postOnly orders cannot have timeInForce equal to "), timeInForce)))
        } else if IsTrue(isMarketOrder) {
            panic(InvalidOrder(Add(this.Id, " market orders cannot be postOnly")))
        } else {
            return true
        }
    } else {
        return false
    }
}
func  (this *Exchange) HandlePostOnly(isMarketOrder interface{}, exchangeSpecificPostOnlyOption interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @param {string} type Order type
    * @param {boolean} exchangeSpecificBoolean exchange specific postOnly
    * @param {object} [params] exchange specific params
    * @returns {Array}
    */
    params := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = params
    var timeInForce interface{} = this.SafeStringUpper(params, "timeInForce")
    var postOnly interface{} = this.SafeBool(params, "postOnly", false)
    var ioc interface{} = IsEqual(timeInForce, "IOC")
    var fok interface{} = IsEqual(timeInForce, "FOK")
    var po interface{} = IsEqual(timeInForce, "PO")
    postOnly = IsTrue(IsTrue(postOnly) || IsTrue(po)) || IsTrue(exchangeSpecificPostOnlyOption)
    if IsTrue(postOnly) {
        if IsTrue(IsTrue(ioc) || IsTrue(fok)) {
            panic(InvalidOrder(Add(Add(this.Id, " postOnly orders cannot have timeInForce equal to "), timeInForce)))
        } else if IsTrue(isMarketOrder) {
            panic(InvalidOrder(Add(this.Id, " market orders cannot be postOnly")))
        } else {
            if IsTrue(po) {
                params = this.Omit(params, "timeInForce")
            }
            params = this.Omit(params, "postOnly")
            return []interface{}{true, params}
        }
    }
    return []interface{}{false, params}
}
func  (this *Exchange) FetchLastPrices(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
            panic(NotSupported(Add(this.Id, " fetchLastPrices() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchTradingFees() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTradingFeesWs(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
            panic(NotSupported(Add(this.Id, " fetchTradingFeesWs() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) FetchTradingFee(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
            if !IsTrue(GetValue(this.Has, "fetchTradingFees")) {
                panic(NotSupported(Add(this.Id, " fetchTradingFee() is not supported yet")))
            }
        
            fees:= (<-this.FetchTradingFees(params))
            PanicOnError(fees)
        
            ch <- this.SafeDict(fees, symbol)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchConvertCurrencies() is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseOpenInterest(interest interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseOpenInterest () is not supported yet")))
}
func  (this *Exchange) ParseOpenInterests(response interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    var result interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var entry interface{} = GetValue(response, i)

        var parsed interface{} = this.DerivedExchange.ParseOpenInterest(entry)
        PanicOnError(parsed)
        AddElementToObject(result, GetValue(parsed, "symbol"), parsed)
    }
    return this.FilterByArray(result, "symbol", symbols)
}
func  (this *Exchange) ParseOpenInterestsHistory(response interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    var interests interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var entry interface{} = GetValue(response, i)

        var interest interface{} = this.DerivedExchange.ParseOpenInterest(entry, market)
        PanicOnError(interest)
        AppendToArray(&interests,interest)
    }
    var sorted interface{} = this.SortBy(interests, "timestamp")
    var symbol interface{} = this.SafeString(market, "symbol")
    return this.FilterBySymbolSinceLimit(sorted, symbol, since, limit)
}
func  (this *Exchange) 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
            if IsTrue(GetValue(this.Has, "fetchFundingRates")) {
        
                retRes669912 := (<-this.LoadMarkets())
                PanicOnError(retRes669912)
        
                var market interface{} = this.DerivedExchange.Market(symbol)
                PanicOnError(market)
                symbol = GetValue(market, "symbol")
                if !IsTrue(GetValue(market, "contract")) {
                    panic(BadSymbol(Add(this.Id, " fetchFundingRate() supports contract markets only")))
                }
        
                rates:= <-this.DerivedExchange.FetchFundingRates([]interface{}{symbol}, params)
                PanicOnError(rates)
                var rate interface{} = this.SafeValue(rates, symbol)
                if IsTrue(IsEqual(rate, nil)) {
                    panic(NullResponse(Add(Add(this.Id, " fetchFundingRate () returned no data for "), symbol)))
                } else {
        
                    ch <- rate
                    return nil
                }
            } else {
                panic(NotSupported(Add(this.Id, " fetchFundingRate () is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) 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
            if IsTrue(GetValue(this.Has, "fetchFundingIntervals")) {
        
                retRes671912 := (<-this.LoadMarkets())
                PanicOnError(retRes671912)
        
                var market interface{} = this.DerivedExchange.Market(symbol)
                PanicOnError(market)
                symbol = GetValue(market, "symbol")
                if !IsTrue(GetValue(market, "contract")) {
                    panic(BadSymbol(Add(this.Id, " fetchFundingInterval() supports contract markets only")))
                }
        
                rates:= <-this.DerivedExchange.FetchFundingIntervals([]interface{}{symbol}, params)
                PanicOnError(rates)
                var rate interface{} = this.SafeValue(rates, symbol)
                if IsTrue(IsEqual(rate, nil)) {
                    panic(NullResponse(Add(Add(this.Id, " fetchFundingInterval() returned no data for "), symbol)))
                } else {
        
                    ch <- rate
                    return nil
                }
            } else {
                panic(NotSupported(Add(this.Id, " fetchFundingInterval() is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchMarkOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name exchange#fetchMarkOHLCV
            * @description fetches historical mark price candlestick data containing the open, high, low, and close price 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] the maximum amount of candles to fetch
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {float[][]} A list of candles ordered as timestamp, open, high, low, close, undefined
            */
            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
            if IsTrue(GetValue(this.Has, "fetchMarkOHLCV")) {
                var request interface{} = map[string]interface{} {
                    "price": "mark",
                }
        
                    retRes675319 :=  <-this.DerivedExchange.FetchOHLCV(symbol, timeframe, since, limit, this.Extend(request, params))
                    PanicOnError(retRes675319)
                    ch <- retRes675319
                    return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchMarkOHLCV () is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchIndexOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name exchange#fetchIndexOHLCV
            * @description fetches historical index price candlestick data containing the open, high, low, and close price 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] the maximum amount of candles to fetch
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {} A list of candles ordered as timestamp, open, high, low, close, undefined
            */
            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
            if IsTrue(GetValue(this.Has, "fetchIndexOHLCV")) {
                var request interface{} = map[string]interface{} {
                    "price": "index",
                }
        
                    retRes677519 :=  <-this.DerivedExchange.FetchOHLCV(symbol, timeframe, since, limit, this.Extend(request, params))
                    PanicOnError(retRes677519)
                    ch <- retRes677519
                    return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchIndexOHLCV () is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchPremiumIndexOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name exchange#fetchPremiumIndexOHLCV
            * @description fetches historical premium index price candlestick data containing the open, high, low, and close price 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] the maximum amount of candles to fetch
            * @param {object} [params] extra parameters specific to the exchange API endpoint
            * @returns {float[][]} A list of candles ordered as timestamp, open, high, low, close, undefined
            */
            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
            if IsTrue(GetValue(this.Has, "fetchPremiumIndexOHLCV")) {
                var request interface{} = map[string]interface{} {
                    "price": "premiumIndex",
                }
        
                    retRes679719 :=  <-this.DerivedExchange.FetchOHLCV(symbol, timeframe, since, limit, this.Extend(request, params))
                    PanicOnError(retRes679719)
                    ch <- retRes679719
                    return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchPremiumIndexOHLCV () is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) HandleTimeInForce(optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * Must add timeInForce to this.options to use this method
    * @returns {string} returns the exchange specific value for timeInForce
    */
    params := GetArg(optionalArgs, 0, map[string]interface{} {})
    _ = params
    var timeInForce interface{} = this.SafeStringUpper(params, "timeInForce") // supported values GTC, IOC, PO
    if IsTrue(!IsEqual(timeInForce, nil)) {
        var exchangeValue interface{} = this.SafeString(GetValue(this.Options, "timeInForce"), timeInForce)
        if IsTrue(IsEqual(exchangeValue, nil)) {
            panic(ExchangeError(Add(Add(Add(this.Id, " does not support timeInForce \""), timeInForce), "\"")))
        }
        return exchangeValue
    }
    return nil
}
func  (this *Exchange) ConvertTypeToAccount(account interface{}) interface{}  {
    /**
     * @ignore
     * @method
     * Must add accountsByType to this.options to use this method
     * @param {string} account key for account name in this.options['accountsByType']
     * @returns the exchange specific account name or the isolated margin id for transfers
     */
    var accountsByType interface{} = this.SafeDict(this.Options, "accountsByType", map[string]interface{} {})
    var lowercaseAccount interface{} = ToLower(account)
    if IsTrue(InOp(accountsByType, lowercaseAccount)) {
        return GetValue(accountsByType, lowercaseAccount)
    } else if IsTrue(IsTrue((InOp(this.Markets, account))) || IsTrue((InOp(this.Markets_by_id, account)))) {

        var market interface{} = this.DerivedExchange.Market(account)
        PanicOnError(market)
        return GetValue(market, "id")
    } else {
        return account
    }
}
func  (this *Exchange) CheckRequiredArgument(methodName interface{}, argument interface{}, argumentName interface{}, optionalArgs ...interface{})  {
    /**
    * @ignore
    * @method
    * @param {string} methodName the name of the method that the argument is being checked for
    * @param {string} argument the argument's actual value provided
    * @param {string} argumentName the name of the argument being checked (for logging purposes)
    * @param {string[]} options a list of options that the argument can be
    * @returns {undefined}
    */
    options := GetArg(optionalArgs, 0, []interface{}{})
    _ = options
    var optionsLength interface{} =     GetArrayLength(options)
    if IsTrue(IsTrue((IsEqual(argument, nil))) || IsTrue((IsTrue((IsGreaterThan(optionsLength, 0))) && IsTrue((!IsTrue((this.InArray(argument, options)))))))) {
        var messageOptions interface{} = Join(options, ", ")
        var message interface{} = Add(Add(Add(Add(Add(this.Id, " "), methodName), "() requires a "), argumentName), " argument")
        if IsTrue(!IsEqual(messageOptions, "")) {
            message = Add(message, Add(Add(Add(", one of ", "("), messageOptions), ")"))
        }
        panic(ArgumentsRequired(message))
    }
}
func  (this *Exchange) CheckRequiredMarginArgument(methodName interface{}, symbol interface{}, marginMode interface{})  {
    /**
     * @ignore
     * @method
     * @param {string} symbol unified symbol of the market
     * @param {string} methodName name of the method that requires a symbol
     * @param {string} marginMode is either 'isolated' or 'cross'
     */
    if IsTrue(IsTrue((IsEqual(marginMode, "isolated"))) && IsTrue((IsEqual(symbol, nil)))) {
        panic(ArgumentsRequired(Add(Add(Add(this.Id, " "), methodName), "() requires a symbol argument for isolated margin")))
    } else if IsTrue(IsTrue((IsEqual(marginMode, "cross"))) && IsTrue((!IsEqual(symbol, nil)))) {
        panic(ArgumentsRequired(Add(Add(Add(this.Id, " "), methodName), "() cannot have a symbol argument for cross margin")))
    }
}
func  (this *Exchange) ParseDepositWithdrawFees(response interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @param {object[]|object} response unparsed response from the exchange
    * @param {string[]|undefined} codes the unified currency codes to fetch transactions fees for, returns all currencies when undefined
    * @param {str} currencyIdKey *should only be undefined when response is a dictionary* the object key that corresponds to the currency id
    * @returns {object} objects with withdraw and deposit fees, indexed by currency codes
    */
    codes := GetArg(optionalArgs, 0, nil)
    _ = codes
    currencyIdKey := GetArg(optionalArgs, 1, nil)
    _ = currencyIdKey
    var depositWithdrawFees interface{} = map[string]interface{} {}
    var isArray interface{} = IsArray(response)
    var responseKeys interface{} = response
    if !IsTrue(isArray) {
        responseKeys = ObjectKeys(response)
    }
    for i := 0; IsLessThan(i, GetArrayLength(responseKeys)); i++ {
        var entry interface{} = GetValue(responseKeys, i)
        var dictionary interface{} = Ternary(IsTrue(isArray), entry, GetValue(response, entry))
        var currencyId interface{} = Ternary(IsTrue(isArray), this.SafeString(dictionary, currencyIdKey), entry)
        var currency interface{} = this.SafeCurrency(currencyId)
        var code interface{} = this.SafeString(currency, "code")
        if IsTrue(IsTrue((IsEqual(codes, nil))) || IsTrue((this.InArray(code, codes)))) {
            AddElementToObject(depositWithdrawFees, code, this.DerivedExchange.ParseDepositWithdrawFee(dictionary, currency))
        }
    }
    return depositWithdrawFees
}
func  (this *Exchange) ParseDepositWithdrawFee(fee interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    panic(NotSupported(Add(this.Id, " parseDepositWithdrawFee() is not supported yet")))
}
func  (this *Exchange) DepositWithdrawFee(info interface{}) interface{}  {
    return map[string]interface{} {
        "info": info,
        "withdraw": map[string]interface{} {
            "fee": nil,
            "percentage": nil,
        },
        "deposit": map[string]interface{} {
            "fee": nil,
            "percentage": nil,
        },
        "networks": map[string]interface{} {},
    }
}
func  (this *Exchange) AssignDefaultDepositWithdrawFees(fee interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description Takes a depositWithdrawFee structure and assigns the default values for withdraw and deposit
    * @param {object} fee A deposit withdraw fee structure
    * @param {object} currency A currency structure, the response from this.currency ()
    * @returns {object} A deposit withdraw fee structure
    */
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    var networkKeys interface{} = ObjectKeys(GetValue(fee, "networks"))
    var numNetworks interface{} =     GetArrayLength(networkKeys)
    if IsTrue(IsEqual(numNetworks, 1)) {
        AddElementToObject(fee, "withdraw", GetValue(GetValue(GetValue(fee, "networks"), GetValue(networkKeys, 0)), "withdraw"))
        AddElementToObject(fee, "deposit", GetValue(GetValue(GetValue(fee, "networks"), GetValue(networkKeys, 0)), "deposit"))
        return fee
    }
    var currencyCode interface{} = this.SafeString(currency, "code")
    for i := 0; IsLessThan(i, numNetworks); i++ {
        var network interface{} = GetValue(networkKeys, i)
        if IsTrue(IsEqual(network, currencyCode)) {
            AddElementToObject(fee, "withdraw", GetValue(GetValue(GetValue(fee, "networks"), GetValue(networkKeys, i)), "withdraw"))
            AddElementToObject(fee, "deposit", GetValue(GetValue(GetValue(fee, "networks"), GetValue(networkKeys, i)), "deposit"))
        }
    }
    return fee
}
func  (this *Exchange) ParseIncome(info interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseIncome () is not supported yet")))
}
func  (this *Exchange) ParseIncomes(incomes interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description parses funding fee info from exchange response
    * @param {object[]} incomes each item describes once instance of currency being received or paid
    * @param {object} market ccxt market
    * @param {int} [since] when defined, the response items are filtered to only include items after this timestamp
    * @param {int} [limit] limits the number of items in the response
    * @returns {object[]} an array of [funding history structures]{@link https://docs.ccxt.com/#/?id=funding-history-structure}
    */
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(incomes)); i++ {
        var entry interface{} = GetValue(incomes, i)

        var parsed interface{} = this.DerivedExchange.ParseIncome(entry, market)
        PanicOnError(parsed)
        AppendToArray(&result,parsed)
    }
    var sorted interface{} = this.SortBy(result, "timestamp")
    var symbol interface{} = this.SafeString(market, "symbol")
    return this.FilterBySymbolSinceLimit(sorted, symbol, since, limit)
}
func  (this *Exchange) GetMarketFromSymbols(optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    if IsTrue(IsEqual(symbols, nil)) {
        return nil
    }
    var firstMarket interface{} = this.SafeString(symbols, 0)

    var market interface{} = this.DerivedExchange.Market(firstMarket)
    PanicOnError(market)
    return market
}
func  (this *Exchange) ParseWsOHLCVs(ohlcvs interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    timeframe := GetArg(optionalArgs, 1, "1m")
    _ = timeframe
    since := GetArg(optionalArgs, 2, nil)
    _ = since
    limit := GetArg(optionalArgs, 3, nil)
    _ = limit
    var results interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(ohlcvs)); i++ {
        AppendToArray(&results,this.ParseWsOHLCV(GetValue(ohlcvs, i), market))
    }
    return results
}
func  (this *Exchange) FetchTransactions(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name exchange#fetchTransactions
            * @deprecated
            * @description *DEPRECATED* use fetchDepositsWithdrawals instead
            * @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 structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
            */
            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
            if IsTrue(GetValue(this.Has, "fetchDepositsWithdrawals")) {
        
                    retRes700719 :=  <-this.DerivedExchange.FetchDepositsWithdrawals(code, since, limit, params)
                    PanicOnError(retRes700719)
                    ch <- retRes700719
                    return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchTransactions () is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FilterByArrayPositions(objects interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description Typed wrapper for filterByArray that returns a list of positions
    */
    values := GetArg(optionalArgs, 0, nil)
    _ = values
    indexed := GetArg(optionalArgs, 1, true)
    _ = indexed
    return this.FilterByArray(objects, key, values, indexed)
}
func  (this *Exchange) FilterByArrayTickers(objects interface{}, key interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description Typed wrapper for filterByArray that returns a dictionary of tickers
    */
    values := GetArg(optionalArgs, 0, nil)
    _ = values
    indexed := GetArg(optionalArgs, 1, true)
    _ = indexed
    return this.FilterByArray(objects, key, values, indexed)
}
func  (this *Exchange) CreateOHLCVObject(symbol interface{}, timeframe interface{}, data interface{}) interface{}  {
    var res interface{} = map[string]interface{} {}
    AddElementToObject(res, symbol, map[string]interface{} {})
    AddElementToObject(GetValue(res, symbol), timeframe, data)
    return res
}
func  (this *Exchange) HandleMaxEntriesPerRequestAndParams(method interface{}, optionalArgs ...interface{}) interface{}  {
    maxEntriesPerRequest := GetArg(optionalArgs, 0, nil)
    _ = maxEntriesPerRequest
    params := GetArg(optionalArgs, 1, map[string]interface{} {})
    _ = params
    var newMaxEntriesPerRequest interface{} = nil
    newMaxEntriesPerRequestparamsVariable := this.HandleOptionAndParams(params, method, "maxEntriesPerRequest");
    newMaxEntriesPerRequest = GetValue(newMaxEntriesPerRequestparamsVariable,0);
    params = GetValue(newMaxEntriesPerRequestparamsVariable,1)
    if IsTrue(IsTrue((!IsEqual(newMaxEntriesPerRequest, nil))) && IsTrue((!IsEqual(newMaxEntriesPerRequest, maxEntriesPerRequest)))) {
        maxEntriesPerRequest = newMaxEntriesPerRequest
    }
    if IsTrue(IsEqual(maxEntriesPerRequest, nil)) {
        maxEntriesPerRequest = 1000 // default to 1000
    }
    return []interface{}{maxEntriesPerRequest, params}
}
func  (this *Exchange) FetchPaginatedCallDynamic(method 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
            maxEntriesPerRequest := GetArg(optionalArgs, 4, nil)
            _ = maxEntriesPerRequest
            removeRepeated := GetArg(optionalArgs, 5, true)
            _ = removeRepeated
            var maxCalls interface{} = nil
            maxCallsparamsVariable := this.HandleOptionAndParams(params, method, "paginationCalls", 10);
            maxCalls = GetValue(maxCallsparamsVariable,0);
            params = GetValue(maxCallsparamsVariable,1)
            var maxRetries interface{} = nil
            maxRetriesparamsVariable := this.HandleOptionAndParams(params, method, "maxRetries", 3);
            maxRetries = GetValue(maxRetriesparamsVariable,0);
            params = GetValue(maxRetriesparamsVariable,1)
            var paginationDirection interface{} = nil
            paginationDirectionparamsVariable := this.HandleOptionAndParams(params, method, "paginationDirection", "backward");
            paginationDirection = GetValue(paginationDirectionparamsVariable,0);
            params = GetValue(paginationDirectionparamsVariable,1)
            var paginationTimestamp interface{} = nil
            var removeRepeatedOption interface{} = removeRepeated
            removeRepeatedOptionparamsVariable := this.HandleOptionAndParams(params, method, "removeRepeated", removeRepeated);
            removeRepeatedOption = GetValue(removeRepeatedOptionparamsVariable,0);
            params = GetValue(removeRepeatedOptionparamsVariable,1)
            var calls interface{} = 0
            var result interface{} = []interface{}{}
            var errors interface{} = 0
            var until interface{} = this.SafeInteger2(params, "untill", "till") // do not omit it from params here
            maxEntriesPerRequestparamsVariable := this.HandleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
            maxEntriesPerRequest = GetValue(maxEntriesPerRequestparamsVariable,0);
            params = GetValue(maxEntriesPerRequestparamsVariable,1)
            if IsTrue((IsEqual(paginationDirection, "forward"))) {
                if IsTrue(IsEqual(since, nil)) {
                    panic(ArgumentsRequired(Add(this.Id, " pagination requires a since argument when paginationDirection set to forward")))
                }
                paginationTimestamp = since
            }
            for (IsLessThan(calls, maxCalls)) {
                calls = Add(calls, 1)
                
                {		ret__ := func(this *Exchange) (ret_ interface{}) {
                		defer func() {
                			if e := recover(); e != nil {
                                if e == "break" {
                				    return
                			    }
                				ret_ = func(this *Exchange) interface{} {
                					// catch block:
                                                errors = Add(errors, 1)
                            if IsTrue(IsGreaterThan(errors, maxRetries)) {
                                panic(e)
                            }
                                    return nil
                				}(this)
                			}
                		}()
                		// try block:
                                    if IsTrue(IsEqual(paginationDirection, "backward")) {
                                // do it backwards, starting from the last
                                // UNTIL filtering is required in order to work
                                if IsTrue(!IsEqual(paginationTimestamp, nil)) {
                                    AddElementToObject(params, "until", Subtract(paginationTimestamp, 1))
                                }
                
                                response:= (<-this.callDynamically(method, symbol, nil, maxEntriesPerRequest, params))
                                PanicOnError(response)
                                var responseLength interface{} =                 GetArrayLength(response)
                                if IsTrue(this.Verbose) {
                                    var backwardMessage interface{} = Add(Add(Add(Add(Add("Dynamic pagination call ", this.NumberToString(calls)), " method "), method), " response length "), this.NumberToString(responseLength))
                                    if IsTrue(!IsEqual(paginationTimestamp, nil)) {
                                        backwardMessage = Add(backwardMessage, Add(" timestamp ", this.NumberToString(paginationTimestamp)))
                                    }
                                    this.Log(backwardMessage)
                                }
                                if IsTrue(IsEqual(responseLength, 0)) {
                                    panic("break")
                                }
                                errors = 0
                                result = this.ArrayConcat(result, response)
                                var firstElement interface{} = this.SafeValue(response, 0)
                                paginationTimestamp = this.SafeInteger2(firstElement, "timestamp", 0)
                                if IsTrue(IsTrue((!IsEqual(since, nil))) && IsTrue((IsLessThanOrEqual(paginationTimestamp, since)))) {
                                    panic("break")
                                }
                            } else {
                                // do it forwards, starting from the since
                
                                response:= (<-this.callDynamically(method, symbol, paginationTimestamp, maxEntriesPerRequest, params))
                                PanicOnError(response)
                                var responseLength interface{} =                 GetArrayLength(response)
                                if IsTrue(this.Verbose) {
                                    var forwardMessage interface{} = Add(Add(Add(Add(Add("Dynamic pagination call ", this.NumberToString(calls)), " method "), method), " response length "), this.NumberToString(responseLength))
                                    if IsTrue(!IsEqual(paginationTimestamp, nil)) {
                                        forwardMessage = Add(forwardMessage, Add(" timestamp ", this.NumberToString(paginationTimestamp)))
                                    }
                                    this.Log(forwardMessage)
                                }
                                if IsTrue(IsEqual(responseLength, 0)) {
                                    panic("break")
                                }
                                errors = 0
                                result = this.ArrayConcat(result, response)
                                var last interface{} = this.SafeValue(response, Subtract(responseLength, 1))
                                paginationTimestamp = Add(this.SafeInteger(last, "timestamp"), 1)
                                if IsTrue(IsTrue((!IsEqual(until, nil))) && IsTrue((IsGreaterThanOrEqual(paginationTimestamp, until)))) {
                                    panic("break")
                                }
                            }
                		return nil
                	}(this)
                	if ret__ != nil {
                		return ret__
                	}
                }
            }
            var uniqueResults interface{} = result
            if IsTrue(removeRepeatedOption) {
                uniqueResults = this.RemoveRepeatedElementsFromArray(result)
            }
            var key interface{} = Ternary(IsTrue((IsEqual(method, "fetchOHLCV"))), 0, "timestamp")
        
            ch <- this.FilterBySinceLimit(uniqueResults, since, limit, key)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) SafeDeterministicCall(method 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
            timeframe := GetArg(optionalArgs, 3, nil)
            _ = timeframe
            params := GetArg(optionalArgs, 4, map[string]interface{} {})
            _ = params
            var maxRetries interface{} = nil
            maxRetriesparamsVariable := this.HandleOptionAndParams(params, method, "maxRetries", 3);
            maxRetries = GetValue(maxRetriesparamsVariable,0);
            params = GetValue(maxRetriesparamsVariable,1)
            var errors interface{} = 0
            for IsLessThanOrEqual(errors, maxRetries) {
                
                {		ret__ := func(this *Exchange) (ret_ interface{}) {
                		defer func() {
                			if e := recover(); e != nil {
                                if e == "break" {
                				    return
                			    }
                				ret_ = func(this *Exchange) interface{} {
                					// catch block:
                                                if IsTrue(IsInstance(e, RateLimitExceeded)) {
                                panic(e)
                            }
                            errors = Add(errors, 1)
                            if IsTrue(IsGreaterThan(errors, maxRetries)) {
                                panic(e)
                            }
                                    return nil
                				}(this)
                			}
                		}()
                		// try block:
                                    if IsTrue(IsTrue(timeframe) && IsTrue(!IsEqual(method, "fetchFundingRateHistory"))) {
                
                                    retRes714327 :=  (<-this.callDynamically(method, symbol, timeframe, since, limit, params))
                                    PanicOnError(retRes714327)
                                    ch <- retRes714327
                                    return nil
                            } else {
                
                                    retRes714527 :=  (<-this.callDynamically(method, symbol, since, limit, params))
                                    PanicOnError(retRes714527)
                                    ch <- retRes714527
                                    return nil
                            }
                		return nil
                	}(this)
                	if ret__ != nil {
                		return ret__
                	}
                }
            }
        
            ch <- []interface{}{}
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchPaginatedCallDeterministic(method 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
            timeframe := GetArg(optionalArgs, 3, nil)
            _ = timeframe
            params := GetArg(optionalArgs, 4, map[string]interface{} {})
            _ = params
            maxEntriesPerRequest := GetArg(optionalArgs, 5, nil)
            _ = maxEntriesPerRequest
            var maxCalls interface{} = nil
            maxCallsparamsVariable := this.HandleOptionAndParams(params, method, "paginationCalls", 10);
            maxCalls = GetValue(maxCallsparamsVariable,0);
            params = GetValue(maxCallsparamsVariable,1)
            maxEntriesPerRequestparamsVariable := this.HandleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
            maxEntriesPerRequest = GetValue(maxEntriesPerRequestparamsVariable,0);
            params = GetValue(maxEntriesPerRequestparamsVariable,1)
            var current interface{} = this.Milliseconds()
            var tasks interface{} = []interface{}{}
            var time interface{} = Multiply(this.ParseTimeframe(timeframe), 1000)
            var step interface{} = Multiply(time, maxEntriesPerRequest)
            var currentSince interface{} = Subtract(Subtract(current, (Multiply(maxCalls, step))), 1)
            if IsTrue(!IsEqual(since, nil)) {
                currentSince = mathMax(currentSince, since)
            } else {
                currentSince = mathMax(currentSince, 1241440531000) // avoid timestamps older than 2009
            }
            var until interface{} = this.SafeInteger2(params, "until", "till") // do not omit it here
            if IsTrue(!IsEqual(until, nil)) {
                var requiredCalls interface{} = MathCeil(Divide((Subtract(until, since)), step))
                if IsTrue(IsGreaterThan(requiredCalls, maxCalls)) {
                    panic(BadRequest(Add(Add(Add(Add(this.Id, " the number of required calls is greater than the max number of calls allowed, either increase the paginationCalls or decrease the since-until gap. Current paginationCalls limit is "), ToString(maxCalls)), " required calls is "), ToString(requiredCalls))))
                }
            }
            for i := 0; IsLessThan(i, maxCalls); i++ {
                if IsTrue(IsTrue((!IsEqual(until, nil))) && IsTrue((IsGreaterThanOrEqual(currentSince, until)))) {
                    break
                }
                if IsTrue(IsGreaterThanOrEqual(currentSince, current)) {
                    break
                }
                AppendToArray(&tasks,this.SafeDeterministicCall(method, symbol, currentSince, maxEntriesPerRequest, timeframe, params))
                currentSince = Subtract(this.Sum(currentSince, step), 1)
            }
        
            results:= (<-promiseAll(tasks))
            PanicOnError(results)
            var result interface{} = []interface{}{}
            for i := 0; IsLessThan(i, GetArrayLength(results)); i++ {
                result = this.ArrayConcat(result, GetValue(results, i))
            }
            var uniqueResults interface{} = this.RemoveRepeatedElementsFromArray(result)
            var key interface{} = Ternary(IsTrue((IsEqual(method, "fetchOHLCV"))), 0, "timestamp")
        
            ch <- this.FilterBySinceLimit(uniqueResults, since, limit, key)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchPaginatedCallCursor(method 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
            cursorReceived := GetArg(optionalArgs, 4, nil)
            _ = cursorReceived
            cursorSent := GetArg(optionalArgs, 5, nil)
            _ = cursorSent
            cursorIncrement := GetArg(optionalArgs, 6, nil)
            _ = cursorIncrement
            maxEntriesPerRequest := GetArg(optionalArgs, 7, nil)
            _ = maxEntriesPerRequest
            var maxCalls interface{} = nil
            maxCallsparamsVariable := this.HandleOptionAndParams(params, method, "paginationCalls", 10);
            maxCalls = GetValue(maxCallsparamsVariable,0);
            params = GetValue(maxCallsparamsVariable,1)
            var maxRetries interface{} = nil
            maxRetriesparamsVariable := this.HandleOptionAndParams(params, method, "maxRetries", 3);
            maxRetries = GetValue(maxRetriesparamsVariable,0);
            params = GetValue(maxRetriesparamsVariable,1)
            maxEntriesPerRequestparamsVariable := this.HandleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
            maxEntriesPerRequest = GetValue(maxEntriesPerRequestparamsVariable,0);
            params = GetValue(maxEntriesPerRequestparamsVariable,1)
            var cursorValue interface{} = nil
            var i interface{} = 0
            var errors interface{} = 0
            var result interface{} = []interface{}{}
            var timeframe interface{} = this.SafeString(params, "timeframe")
            params = this.Omit(params, "timeframe") // reading the timeframe from the method arguments to avoid changing the signature
            for IsLessThan(i, maxCalls) {
                
                {		ret__ := func(this *Exchange) (ret_ interface{}) {
                		defer func() {
                			if e := recover(); e != nil {
                                if e == "break" {
                				    return
                			    }
                				ret_ = func(this *Exchange) interface{} {
                					// catch block:
                                                errors = Add(errors, 1)
                            if IsTrue(IsGreaterThan(errors, maxRetries)) {
                                panic(e)
                            }
                                    return nil
                				}(this)
                			}
                		}()
                		// try block:
                                    if IsTrue(!IsEqual(cursorValue, nil)) {
                                if IsTrue(!IsEqual(cursorIncrement, nil)) {
                                    cursorValue = Add(this.ParseToInt(cursorValue), cursorIncrement)
                                }
                                AddElementToObject(params, cursorSent, cursorValue)
                            }
                            var response interface{} = nil
                            if IsTrue(IsEqual(method, "fetchAccounts")) {
                                
                response = (<-this.callDynamically(method, params))
                                PanicOnError(response)
                            } else if IsTrue(IsTrue(IsEqual(method, "getLeverageTiersPaginated")) || IsTrue(IsEqual(method, "fetchPositions"))) {
                                
                response = (<-this.callDynamically(method, symbol, params))
                                PanicOnError(response)
                            } else if IsTrue(IsEqual(method, "fetchOpenInterestHistory")) {
                                
                response = (<-this.callDynamically(method, symbol, timeframe, since, maxEntriesPerRequest, params))
                                PanicOnError(response)
                            } else {
                                
                response = (<-this.callDynamically(method, symbol, since, maxEntriesPerRequest, params))
                                PanicOnError(response)
                            }
                            errors = 0
                            var responseLength interface{} =             GetArrayLength(response)
                            if IsTrue(this.Verbose) {
                                var cursorString interface{} = Ternary(IsTrue((IsEqual(cursorValue, nil))), "", cursorValue)
                                var iteration interface{} =                 (Add(i, 1))
                                var cursorMessage interface{} = Add(Add(Add(Add(Add(Add(Add("Cursor pagination call ", ToString(iteration)), " method "), method), " response length "), ToString(responseLength)), " cursor "), cursorString)
                                this.Log(cursorMessage)
                            }
                            if IsTrue(IsEqual(responseLength, 0)) {
                                panic("break")
                            }
                            result = this.ArrayConcat(result, response)
                            var last interface{} = this.SafeDict(response, Subtract(responseLength, 1))
                            // cursorValue = this.safeValue (last['info'], cursorReceived);
                            cursorValue = nil // search for the cursor
                            for j := 0; IsLessThan(j, responseLength); j++ {
                                var index interface{} = Subtract(Subtract(responseLength, j), 1)
                                var entry interface{} = this.SafeDict(response, index)
                                var info interface{} = this.SafeDict(entry, "info")
                                var cursor interface{} = this.SafeValue(info, cursorReceived)
                                if IsTrue(!IsEqual(cursor, nil)) {
                                    cursorValue = cursor
                                    panic("break")
                                }
                            }
                            if IsTrue(IsEqual(cursorValue, nil)) {
                                panic("break")
                            }
                            var lastTimestamp interface{} = this.SafeInteger(last, "timestamp")
                            if IsTrue(IsTrue(!IsEqual(lastTimestamp, nil)) && IsTrue(IsLessThan(lastTimestamp, since))) {
                                panic("break")
                            }
                		return nil
                	}(this)
                	if ret__ != nil {
                		return ret__
                	}
                }
                i = Add(i, 1)
            }
            var sorted interface{} = this.SortCursorPaginatedResult(result)
            var key interface{} = Ternary(IsTrue((IsEqual(method, "fetchOHLCV"))), 0, "timestamp")
        
            ch <- this.FilterBySinceLimit(sorted, since, limit, key)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) FetchPaginatedCallIncremental(method 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
            pageKey := GetArg(optionalArgs, 4, nil)
            _ = pageKey
            maxEntriesPerRequest := GetArg(optionalArgs, 5, nil)
            _ = maxEntriesPerRequest
            var maxCalls interface{} = nil
            maxCallsparamsVariable := this.HandleOptionAndParams(params, method, "paginationCalls", 10);
            maxCalls = GetValue(maxCallsparamsVariable,0);
            params = GetValue(maxCallsparamsVariable,1)
            var maxRetries interface{} = nil
            maxRetriesparamsVariable := this.HandleOptionAndParams(params, method, "maxRetries", 3);
            maxRetries = GetValue(maxRetriesparamsVariable,0);
            params = GetValue(maxRetriesparamsVariable,1)
            maxEntriesPerRequestparamsVariable := this.HandleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
            maxEntriesPerRequest = GetValue(maxEntriesPerRequestparamsVariable,0);
            params = GetValue(maxEntriesPerRequestparamsVariable,1)
            var i interface{} = 0
            var errors interface{} = 0
            var result interface{} = []interface{}{}
            for IsLessThan(i, maxCalls) {
                
                {		ret__ := func(this *Exchange) (ret_ interface{}) {
                		defer func() {
                			if e := recover(); e != nil {
                                if e == "break" {
                				    return
                			    }
                				ret_ = func(this *Exchange) interface{} {
                					// catch block:
                                                errors = Add(errors, 1)
                            if IsTrue(IsGreaterThan(errors, maxRetries)) {
                                panic(e)
                            }
                                    return nil
                				}(this)
                			}
                		}()
                		// try block:
                                    AddElementToObject(params, pageKey, Add(i, 1))
                
                            response:= (<-this.callDynamically(method, symbol, since, maxEntriesPerRequest, params))
                            PanicOnError(response)
                            errors = 0
                            var responseLength interface{} =             GetArrayLength(response)
                            if IsTrue(this.Verbose) {
                                var iteration interface{} = ToString((Add(i, 1)))
                                var incrementalMessage interface{} = Add(Add(Add(Add(Add("Incremental pagination call ", iteration), " method "), method), " response length "), ToString(responseLength))
                                this.Log(incrementalMessage)
                            }
                            if IsTrue(IsEqual(responseLength, 0)) {
                                panic("break")
                            }
                            result = this.ArrayConcat(result, response)
                		return nil
                	}(this)
                	if ret__ != nil {
                		return ret__
                	}
                }
                i = Add(i, 1)
            }
            var sorted interface{} = this.SortCursorPaginatedResult(result)
            var key interface{} = Ternary(IsTrue((IsEqual(method, "fetchOHLCV"))), 0, "timestamp")
        
            ch <- this.FilterBySinceLimit(sorted, since, limit, key)
            return nil
        
            }()
            return ch
        }
func  (this *Exchange) SortCursorPaginatedResult(result interface{}) interface{}  {
    var first interface{} = this.SafeValue(result, 0)
    if IsTrue(!IsEqual(first, nil)) {
        if IsTrue(InOp(first, "timestamp")) {
            return this.SortBy(result, "timestamp", true)
        }
        if IsTrue(InOp(first, "id")) {
            return this.SortBy(result, "id", true)
        }
    }
    return result
}
func  (this *Exchange) RemoveRepeatedElementsFromArray(input interface{}) interface{}  {
    var uniqueResult interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(input)); i++ {
        var entry interface{} = GetValue(input, i)
        var id interface{} = this.SafeString(entry, "id")
        if IsTrue(!IsEqual(id, nil)) {
            if IsTrue(IsEqual(this.SafeString(uniqueResult, id), nil)) {
                AddElementToObject(uniqueResult, id, entry)
            }
        } else {
            var timestamp interface{} = this.SafeInteger2(entry, "timestamp", 0)
            if IsTrue(!IsEqual(timestamp, nil)) {
                if IsTrue(IsEqual(this.SafeString(uniqueResult, timestamp), nil)) {
                    AddElementToObject(uniqueResult, timestamp, entry)
                }
            }
        }
    }
    var values interface{} = ObjectValues(uniqueResult)
    var valuesLength interface{} =     GetArrayLength(values)
    if IsTrue(IsGreaterThan(valuesLength, 0)) {
        return values
    }
    return input
}
func  (this *Exchange) HandleUntilOption(key interface{}, request interface{}, params interface{}, optionalArgs ...interface{}) interface{}  {
    multiplier := GetArg(optionalArgs, 0, 1)
    _ = multiplier
    var until interface{} = this.SafeInteger2(params, "until", "till")
    if IsTrue(!IsEqual(until, nil)) {
        AddElementToObject(request, key, this.ParseToInt(Multiply(until, multiplier)))
        params = this.Omit(params, []interface{}{"until", "till"})
    }
    return []interface{}{request, params}
}
func  (this *Exchange) SafeOpenInterest(interest interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var symbol interface{} = this.SafeString(interest, "symbol")
    if IsTrue(IsEqual(symbol, nil)) {
        symbol = this.SafeString(market, "symbol")
    }
    return this.Extend(interest, map[string]interface{} {
        "symbol": symbol,
        "baseVolume": this.SafeNumber(interest, "baseVolume"),
        "quoteVolume": this.SafeNumber(interest, "quoteVolume"),
        "openInterestAmount": this.SafeNumber(interest, "openInterestAmount"),
        "openInterestValue": this.SafeNumber(interest, "openInterestValue"),
        "timestamp": this.SafeInteger(interest, "timestamp"),
        "datetime": this.SafeString(interest, "datetime"),
        "info": this.SafeValue(interest, "info"),
    })
}
func  (this *Exchange) ParseLiquidation(liquidation interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseLiquidation () is not supported yet")))
}
func  (this *Exchange) ParseLiquidations(liquidations interface{}, optionalArgs ...interface{}) interface{}  {
    /**
    * @ignore
    * @method
    * @description parses liquidation info from the exchange response
    * @param {object[]} liquidations each item describes an instance of a liquidation event
    * @param {object} market ccxt market
    * @param {int} [since] when defined, the response items are filtered to only include items after this timestamp
    * @param {int} [limit] limits the number of items in the response
    * @returns {object[]} an array of [liquidation structures]{@link https://docs.ccxt.com/#/?id=liquidation-structure}
    */
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    since := GetArg(optionalArgs, 1, nil)
    _ = since
    limit := GetArg(optionalArgs, 2, nil)
    _ = limit
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(liquidations)); i++ {
        var entry interface{} = GetValue(liquidations, i)

        var parsed interface{} = this.DerivedExchange.ParseLiquidation(entry, market)
        PanicOnError(parsed)
        AppendToArray(&result,parsed)
    }
    var sorted interface{} = this.SortBy(result, "timestamp")
    var symbol interface{} = this.SafeString(market, "symbol")
    return this.FilterBySymbolSinceLimit(sorted, symbol, since, limit)
}
func  (this *Exchange) ParseGreeks(greeks interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseGreeks () is not supported yet")))
}
func  (this *Exchange) ParseOption(chain interface{}, optionalArgs ...interface{}) interface{}  {
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    market := GetArg(optionalArgs, 1, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseOption () is not supported yet")))
}
func  (this *Exchange) ParseOptionChain(response interface{}, optionalArgs ...interface{}) interface{}  {
    currencyKey := GetArg(optionalArgs, 0, nil)
    _ = currencyKey
    symbolKey := GetArg(optionalArgs, 1, nil)
    _ = symbolKey
    var optionStructures interface{} = map[string]interface{} {}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var info interface{} = GetValue(response, i)
        var currencyId interface{} = this.SafeString(info, currencyKey)
        var currency interface{} = this.SafeCurrency(currencyId)
        var marketId interface{} = this.SafeString(info, symbolKey)

        var market interface{} = this.DerivedExchange.SafeMarket(marketId, nil, nil, "option")
        PanicOnError(market)
        AddElementToObject(optionStructures, GetValue(market, "symbol"), this.DerivedExchange.ParseOption(info, currency, market))
    }
    return optionStructures
}
func  (this *Exchange) ParseMarginModes(response interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    symbolKey := GetArg(optionalArgs, 1, nil)
    _ = symbolKey
    marketType := GetArg(optionalArgs, 2, nil)
    _ = marketType
    var marginModeStructures interface{} = map[string]interface{} {}
    if IsTrue(IsEqual(marketType, nil)) {
        marketType = "swap" // default to swap
    }
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var info interface{} = GetValue(response, i)
        var marketId interface{} = this.SafeString(info, symbolKey)

        var market interface{} = this.DerivedExchange.SafeMarket(marketId, nil, nil, marketType)
        PanicOnError(market)
        if IsTrue(IsTrue((IsEqual(symbols, nil))) || IsTrue(this.InArray(GetValue(market, "symbol"), symbols))) {
            AddElementToObject(marginModeStructures, GetValue(market, "symbol"), this.DerivedExchange.ParseMarginMode(info, market))
        }
    }
    return marginModeStructures
}
func  (this *Exchange) ParseMarginMode(marginMode interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseMarginMode () is not supported yet")))
}
func  (this *Exchange) ParseLeverages(response interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    symbolKey := GetArg(optionalArgs, 1, nil)
    _ = symbolKey
    marketType := GetArg(optionalArgs, 2, nil)
    _ = marketType
    var leverageStructures interface{} = map[string]interface{} {}
    if IsTrue(IsEqual(marketType, nil)) {
        marketType = "swap" // default to swap
    }
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var info interface{} = GetValue(response, i)
        var marketId interface{} = this.SafeString(info, symbolKey)

        var market interface{} = this.DerivedExchange.SafeMarket(marketId, nil, nil, marketType)
        PanicOnError(market)
        if IsTrue(IsTrue((IsEqual(symbols, nil))) || IsTrue(this.InArray(GetValue(market, "symbol"), symbols))) {
            AddElementToObject(leverageStructures, GetValue(market, "symbol"), this.ParseLeverage(info, market))
        }
    }
    return leverageStructures
}
func  (this *Exchange) ParseLeverage(leverage interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseLeverage () is not supported yet")))
}
func  (this *Exchange) ParseConversions(conversions interface{}, optionalArgs ...interface{}) interface{}  {
    code := GetArg(optionalArgs, 0, nil)
    _ = code
    fromCurrencyKey := GetArg(optionalArgs, 1, nil)
    _ = fromCurrencyKey
    toCurrencyKey := GetArg(optionalArgs, 2, nil)
    _ = toCurrencyKey
    since := GetArg(optionalArgs, 3, nil)
    _ = since
    limit := GetArg(optionalArgs, 4, nil)
    _ = limit
    params := GetArg(optionalArgs, 5, map[string]interface{} {})
    _ = params
    conversions = this.ToArray(conversions)
    var result interface{} = []interface{}{}
    var fromCurrency interface{} = nil
    var toCurrency interface{} = nil
    for i := 0; IsLessThan(i, GetArrayLength(conversions)); i++ {
        var entry interface{} = GetValue(conversions, i)
        var fromId interface{} = this.SafeString(entry, fromCurrencyKey)
        var toId interface{} = this.SafeString(entry, toCurrencyKey)
        if IsTrue(!IsEqual(fromId, nil)) {
            fromCurrency = this.SafeCurrency(fromId)
        }
        if IsTrue(!IsEqual(toId, nil)) {
            toCurrency = this.SafeCurrency(toId)
        }
        var conversion interface{} = this.Extend(this.DerivedExchange.ParseConversion(entry, fromCurrency, toCurrency), params)
        AppendToArray(&result,conversion)
    }
    var sorted interface{} = this.SortBy(result, "timestamp")
    var currency interface{} = nil
    if IsTrue(!IsEqual(code, nil)) {
        currency = this.SafeCurrency(code)
        code = GetValue(currency, "code")
    }
    if IsTrue(IsEqual(code, nil)) {
        return this.FilterBySinceLimit(sorted, since, limit)
    }
    var fromConversion interface{} = this.FilterBy(sorted, "fromCurrency", code)
    var toConversion interface{} = this.FilterBy(sorted, "toCurrency", code)
    var both interface{} = this.ArrayConcat(fromConversion, toConversion)
    return this.FilterBySinceLimit(both, since, limit)
}
func  (this *Exchange) ParseConversion(conversion interface{}, optionalArgs ...interface{}) interface{}  {
    fromCurrency := GetArg(optionalArgs, 0, nil)
    _ = fromCurrency
    toCurrency := GetArg(optionalArgs, 1, nil)
    _ = toCurrency
    panic(NotSupported(Add(this.Id, " parseConversion () is not supported yet")))
}
func  (this *Exchange) ConvertExpireDate(date interface{}) interface{}  {
    // parse YYMMDD to datetime string
    var year interface{} = Slice(date, 0, 2)
    var month interface{} = Slice(date, 2, 4)
    var day interface{} = Slice(date, 4, 6)
    var reconstructedDate interface{} = Add(Add(Add(Add(Add(Add("20", year), "-"), month), "-"), day), "T00:00:00Z")
    return reconstructedDate
}
func  (this *Exchange) ConvertExpireDateToMarketIdDate(date interface{}) interface{}  {
    // parse 240119 to 19JAN24
    var year interface{} = Slice(date, 0, 2)
    var monthRaw interface{} = Slice(date, 2, 4)
    var month interface{} = nil
    var day interface{} = Slice(date, 4, 6)
    if IsTrue(IsEqual(monthRaw, "01")) {
        month = "JAN"
    } else if IsTrue(IsEqual(monthRaw, "02")) {
        month = "FEB"
    } else if IsTrue(IsEqual(monthRaw, "03")) {
        month = "MAR"
    } else if IsTrue(IsEqual(monthRaw, "04")) {
        month = "APR"
    } else if IsTrue(IsEqual(monthRaw, "05")) {
        month = "MAY"
    } else if IsTrue(IsEqual(monthRaw, "06")) {
        month = "JUN"
    } else if IsTrue(IsEqual(monthRaw, "07")) {
        month = "JUL"
    } else if IsTrue(IsEqual(monthRaw, "08")) {
        month = "AUG"
    } else if IsTrue(IsEqual(monthRaw, "09")) {
        month = "SEP"
    } else if IsTrue(IsEqual(monthRaw, "10")) {
        month = "OCT"
    } else if IsTrue(IsEqual(monthRaw, "11")) {
        month = "NOV"
    } else if IsTrue(IsEqual(monthRaw, "12")) {
        month = "DEC"
    }
    var reconstructedDate interface{} = Add(Add(day, month), year)
    return reconstructedDate
}
func  (this *Exchange) ConvertMarketIdExpireDate(date interface{}) interface{}  {
    // parse 03JAN24 to 240103
    var monthMappping interface{} = map[string]interface{} {
        "JAN": "01",
        "FEB": "02",
        "MAR": "03",
        "APR": "04",
        "MAY": "05",
        "JUN": "06",
        "JUL": "07",
        "AUG": "08",
        "SEP": "09",
        "OCT": "10",
        "NOV": "11",
        "DEC": "12",
    }
    // if exchange omits first zero and provides i.e. '3JAN24' instead of '03JAN24'
    if IsTrue(IsEqual(GetLength(date), 6)) {
        date = Add("0", date)
    }
    var year interface{} = Slice(date, 0, 2)
    var monthName interface{} = Slice(date, 2, 5)
    var month interface{} = this.SafeString(monthMappping, monthName)
    var day interface{} = Slice(date, 5, 7)
    var reconstructedDate interface{} = Add(Add(day, month), year)
    return reconstructedDate
}
func  (this *Exchange) FetchPositionHistory(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    /**
            * @method
            * @name exchange#fetchPositionHistory
            * @description fetches the history of margin added or reduced from contract isolated positions
            * @param {string} [symbol] unified market symbol
            * @param {int} [since] timestamp in ms of the position
            * @param {int} [limit] the maximum amount of candles to fetch, default=1000
            * @param {object} params extra parameters specific to the exchange api endpoint
            * @returns {object[]} a list of [position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
            */
            since := GetArg(optionalArgs, 0, nil)
            _ = since
            limit := GetArg(optionalArgs, 1, nil)
            _ = limit
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
            if IsTrue(GetValue(this.Has, "fetchPositionsHistory")) {
        
                positions:= <-this.DerivedExchange.FetchPositionsHistory([]interface{}{symbol}, since, limit, params)
                PanicOnError(positions)
        
                ch <- positions
                return nil
            } else {
                panic(NotSupported(Add(this.Id, " fetchPositionHistory () is not supported yet")))
            }
                return nil
            }()
            return ch
        }
func  (this *Exchange) FetchPositionsHistory(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
            panic(NotSupported(Add(this.Id, " fetchPositionsHistory () is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) ParseMarginModification(data interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    panic(NotSupported(Add(this.Id, " parseMarginModification() is not supported yet")))
}
func  (this *Exchange) ParseMarginModifications(response interface{}, optionalArgs ...interface{}) interface{}  {
    symbols := GetArg(optionalArgs, 0, nil)
    _ = symbols
    symbolKey := GetArg(optionalArgs, 1, nil)
    _ = symbolKey
    marketType := GetArg(optionalArgs, 2, nil)
    _ = marketType
    var marginModifications interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var info interface{} = GetValue(response, i)
        var marketId interface{} = this.SafeString(info, symbolKey)

        var market interface{} = this.DerivedExchange.SafeMarket(marketId, nil, nil, marketType)
        PanicOnError(market)
        if IsTrue(IsTrue((IsEqual(symbols, nil))) || IsTrue(this.InArray(GetValue(market, "symbol"), symbols))) {
            AppendToArray(&marginModifications,this.DerivedExchange.ParseMarginModification(info, market))
        }
    }
    return marginModifications
}
func  (this *Exchange) FetchTransfer(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
            panic(NotSupported(Add(this.Id, " fetchTransfer () is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) 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
            panic(NotSupported(Add(this.Id, " fetchTransfers () is not supported yet")))
        
            }()
            return ch
        }
func  (this *Exchange) CleanUnsubscription(client Client, subHash interface{}, unsubHash interface{})  {
    if IsTrue(InOp(client.Subscriptions, unsubHash)) {
        Remove(client.Subscriptions, unsubHash)
    }
    if IsTrue(InOp(client.Subscriptions, subHash)) {
        Remove(client.Subscriptions, subHash)
    }
    if IsTrue(InOp(client.Futures, subHash)) {
        error := UnsubscribeError(Add(Add(this.Id, " "), subHash))
        client.Reject(error, subHash)
    }
    client.Resolve(true, unsubHash)
}
func  (this *Exchange) CleanCache(subscription interface{})  {
    var topic interface{} = this.SafeString(subscription, "topic")
    var symbols interface{} = this.SafeList(subscription, "symbols", []interface{}{})
    var symbolsLength interface{} =     GetArrayLength(symbols)
    if IsTrue(IsEqual(topic, "ohlcv")) {
        var symbolsAndTimeFrames interface{} = this.SafeList(subscription, "symbolsAndTimeframes", []interface{}{})
        for i := 0; IsLessThan(i, GetArrayLength(symbolsAndTimeFrames)); i++ {
            var symbolAndTimeFrame interface{} = GetValue(symbolsAndTimeFrames, i)
            var symbol interface{} = this.SafeString(symbolAndTimeFrame, 0)
            var timeframe interface{} = this.SafeString(symbolAndTimeFrame, 1)
            if IsTrue(InOp(this.Ohlcvs, symbol)) {
                if IsTrue(InOp(GetValue(this.Ohlcvs, symbol), timeframe)) {
                    Remove(GetValue(this.Ohlcvs, symbol), timeframe)
                }
            }
        }
    } else if IsTrue(IsGreaterThan(symbolsLength, 0)) {
        for i := 0; IsLessThan(i, GetArrayLength(symbols)); i++ {
            var symbol interface{} = GetValue(symbols, i)
            if IsTrue(IsEqual(topic, "trades")) {
                if IsTrue(InOp(this.Trades, symbol)) {
                    Remove(this.Trades, symbol)
                }
            } else if IsTrue(IsEqual(topic, "orderbook")) {
                if IsTrue(InOp(this.Orderbooks, symbol)) {
                    Remove(this.Orderbooks, symbol)
                }
            } else if IsTrue(IsEqual(topic, "ticker")) {
                if IsTrue(InOp(this.Tickers, symbol)) {
                    Remove(this.Tickers, symbol)
                }
            }
        }
    } else {
        if IsTrue(IsEqual(topic, "myTrades")) {
            // don't reset this.myTrades directly here
            // because in c# we need to use a different object (thread-safe dict)
            var keys interface{} = ObjectKeys(this.MyTrades)
            for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
                var key interface{} = GetValue(keys, i)
                if IsTrue(InOp(this.MyTrades, key)) {
                    Remove(this.MyTrades, key)
                }
            }
        } else if IsTrue(IsEqual(topic, "orders")) {
            var orderSymbols interface{} = ObjectKeys(this.Orders)
            for i := 0; IsLessThan(i, GetArrayLength(orderSymbols)); i++ {
                var orderSymbol interface{} = GetValue(orderSymbols, i)
                if IsTrue(InOp(this.Orders, orderSymbol)) {
                    Remove(this.Orders, orderSymbol)
                }
            }
        } else if IsTrue(IsEqual(topic, "ticker")) {
            var tickerSymbols interface{} = ObjectKeys(this.Tickers)
            for i := 0; IsLessThan(i, GetArrayLength(tickerSymbols)); i++ {
                var tickerSymbol interface{} = GetValue(tickerSymbols, i)
                if IsTrue(InOp(this.Tickers, tickerSymbol)) {
                    Remove(this.Tickers, tickerSymbol)
                }
            }
        }
    }
}