package ccxt // PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN: // https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code type hollaex struct { Exchange } func NewHollaexCore() hollaex { p := hollaex{} setDefaults(&p) return p } func (this *hollaex) Describe() interface{} { return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} { "id": "hollaex", "name": "HollaEx", "countries": []interface{}{"KR"}, "rateLimit": 250, "version": "v2", "pro": true, "has": map[string]interface{} { "CORS": nil, "spot": true, "margin": nil, "swap": false, "future": false, "option": false, "addMargin": false, "cancelAllOrders": true, "cancelOrder": true, "createLimitBuyOrder": true, "createLimitSellOrder": true, "createMarketBuyOrder": true, "createMarketSellOrder": true, "createOrder": true, "createPostOnlyOrder": true, "createReduceOnlyOrder": false, "createStopLimitOrder": true, "createStopMarketOrder": true, "createStopOrder": true, "fetchBalance": true, "fetchBorrowRateHistories": false, "fetchBorrowRateHistory": false, "fetchClosedOrders": true, "fetchCrossBorrowRate": false, "fetchCrossBorrowRates": false, "fetchCurrencies": true, "fetchDepositAddress": "emulated", "fetchDepositAddresses": true, "fetchDepositAddressesByNetwork": false, "fetchDeposits": true, "fetchFundingHistory": false, "fetchFundingRate": false, "fetchFundingRateHistory": false, "fetchFundingRates": false, "fetchIndexOHLCV": false, "fetchIsolatedBorrowRate": false, "fetchIsolatedBorrowRates": false, "fetchLeverage": false, "fetchMarginMode": false, "fetchMarkets": true, "fetchMarkOHLCV": false, "fetchMyTrades": true, "fetchOHLCV": true, "fetchOpenInterestHistory": false, "fetchOpenOrder": true, "fetchOpenOrders": true, "fetchOrder": true, "fetchOrderBook": true, "fetchOrderBooks": true, "fetchOrders": true, "fetchPosition": false, "fetchPositionMode": false, "fetchPositions": false, "fetchPositionsRisk": false, "fetchPremiumIndexOHLCV": false, "fetchTicker": true, "fetchTickers": true, "fetchTrades": true, "fetchTradingFee": false, "fetchTradingFees": true, "fetchTransactions": false, "fetchTransfer": false, "fetchTransfers": false, "fetchWithdrawal": true, "fetchWithdrawals": true, "reduceMargin": false, "sandbox": true, "setLeverage": false, "setMarginMode": false, "setPositionMode": false, "transfer": false, "withdraw": true, }, "timeframes": map[string]interface{} { "1m": "1m", "5m": "5m", "15m": "15m", "1h": "1h", "4h": "4h", "1d": "1d", "1w": "1w", }, "urls": map[string]interface{} { "logo": "https://user-images.githubusercontent.com/1294454/75841031-ca375180-5ddd-11ea-8417-b975674c23cb.jpg", "test": map[string]interface{} { "rest": "https://api.sandbox.hollaex.com", }, "api": map[string]interface{} { "rest": "https://api.hollaex.com", }, "www": "https://hollaex.com", "doc": "https://apidocs.hollaex.com", "referral": "https://pro.hollaex.com/signup?affiliation_code=QSWA6G", }, "precisionMode": TICK_SIZE, "requiredCredentials": map[string]interface{} { "apiKey": true, "secret": true, }, "api": map[string]interface{} { "public": map[string]interface{} { "get": map[string]interface{} { "health": 1, "constants": 1, "kit": 1, "tiers": 1, "ticker": 1, "tickers": 1, "orderbook": 1, "orderbooks": 1, "trades": 1, "chart": 1, "charts": 1, "minicharts": 1, "oracle/prices": 1, "quick-trade": 1, "udf/config": 1, "udf/history": 1, "udf/symbols": 1, }, }, "private": map[string]interface{} { "get": map[string]interface{} { "user": 1, "user/balance": 1, "user/deposits": 1, "user/withdrawals": 1, "user/withdrawal/fee": 1, "user/trades": 1, "orders": 1, "order": 1, }, "post": map[string]interface{} { "user/withdrawal": 1, "order": 1, }, "delete": map[string]interface{} { "order/all": 1, "order": 1, }, }, }, "features": map[string]interface{} { "spot": map[string]interface{} { "sandbox": true, "createOrder": map[string]interface{} { "marginMode": false, "triggerPrice": true, "triggerPriceType": nil, "triggerDirection": false, "stopLossPrice": false, "takeProfitPrice": false, "attachedStopLossTakeProfit": nil, "timeInForce": map[string]interface{} { "IOC": false, "FOK": false, "PO": true, "GTD": false, }, "hedged": false, "selfTradePrevention": false, "trailing": false, "leverage": false, "marketBuyByCost": false, "marketBuyRequiresPrice": false, "iceberg": false, }, "createOrders": nil, "fetchMyTrades": map[string]interface{} { "marginMode": false, "limit": 100, "daysBack": 100000, "untilDays": 100000, "symbolRequired": false, }, "fetchOrder": map[string]interface{} { "marginMode": false, "trigger": false, "trailing": false, "symbolRequired": false, }, "fetchOpenOrders": map[string]interface{} { "marginMode": false, "limit": 100, "trigger": false, "trailing": false, "symbolRequired": false, }, "fetchOrders": map[string]interface{} { "marginMode": false, "limit": 100, "daysBack": 100000, "untilDays": 100000, "trigger": false, "trailing": false, "symbolRequired": false, }, "fetchClosedOrders": map[string]interface{} { "marginMode": false, "limit": 100, "daysBack": 100000, "daysBackCanceled": 1, "untilDays": 100000, "trigger": false, "trailing": false, "symbolRequired": false, }, "fetchOHLCV": map[string]interface{} { "limit": 1000, }, }, "swap": map[string]interface{} { "linear": nil, "inverse": nil, }, "future": map[string]interface{} { "linear": nil, "inverse": nil, }, }, "fees": map[string]interface{} { "trading": map[string]interface{} { "tierBased": true, "percentage": true, "taker": 0.001, "maker": 0.001, }, }, "exceptions": map[string]interface{} { "broad": map[string]interface{} { "Invalid token": AuthenticationError, "Order not found": OrderNotFound, "Insufficient balance": InsufficientFunds, "Error 1001 - Order rejected. Order could not be submitted as this order was set to a post only order.": OrderImmediatelyFillable, }, "exact": map[string]interface{} { "400": BadRequest, "403": AuthenticationError, "404": BadRequest, "405": BadRequest, "410": BadRequest, "429": BadRequest, "500": NetworkError, "503": NetworkError, }, }, "options": map[string]interface{} { "api-expires": this.ParseToInt(Divide(this.Timeout, 1000)), "networks": map[string]interface{} { "BTC": "btc", "ETH": "eth", "ERC20": "eth", "TRX": "trx", "TRC20": "trx", "XRP": "xrp", "XLM": "xlm", "BNB": "bnb", "MATIC": "matic", }, }, }) } /** * @method * @name hollaex#fetchMarkets * @description retrieves data on all markets for hollaex * @see https://apidocs.hollaex.com/#constants * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} an array of objects representing market data */ func (this *hollaex) FetchMarkets(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params response:= (<-this.PublicGetConstants(params)) PanicOnError(response) // // { // "coins": { // "xmr": { // "id": 7, // "fullname": "Monero", // "symbol": "xmr", // "active": true, // "allow_deposit": true, // "allow_withdrawal": true, // "withdrawal_fee": 0.02, // "min": 0.001, // "max": 100000, // "increment_unit": 0.001, // "deposit_limits": { '1': 0, '2': 0, '3': 0, '4': 0, "5": 0, "6": 0 }, // "withdrawal_limits": { '1': 10, '2': 15, '3': 100, '4': 100, '5': 200, '6': 300, '7': 350, '8': 400, "9": 500, "10": -1 }, // "created_at": "2019-12-09T07:14:02.720Z", // "updated_at": "2020-01-16T12:12:53.162Z" // }, // // ... // }, // "pairs": { // "btc-usdt": { // "id": 2, // "name": "btc-usdt", // "pair_base": "btc", // "pair_2": "usdt", // "taker_fees": { '1': 0.3, '2': 0.25, '3': 0.2, '4': 0.18, '5': 0.1, '6': 0.09, '7': 0.08, '8': 0.06, "9": 0.04, "10": 0 }, // "maker_fees": { '1': 0.1, '2': 0.08, '3': 0.05, '4': 0.03, '5': 0, '6': 0, '7': 0, '8': 0, "9": 0, "10": 0 }, // "min_size": 0.0001, // "max_size": 1000, // "min_price": 100, // "max_price": 100000, // "increment_size": 0.0001, // "increment_price": 0.05, // "active": true, // "created_at": "2019-12-09T07:15:54.537Z", // "updated_at": "2019-12-09T07:15:54.537Z" // }, // }, // "config": { tiers: 10 }, // "status": true // } // var pairs interface{} = this.SafeValue(response, "pairs", map[string]interface{} {}) var keys interface{} = ObjectKeys(pairs) var result interface{} = []interface{}{} for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ { var key interface{} = GetValue(keys, i) var market interface{} = GetValue(pairs, key) var baseId interface{} = this.SafeString(market, "pair_base") var quoteId interface{} = this.SafeString(market, "pair_2") var base interface{} = this.CommonCurrencyCode(ToUpper(baseId)) var quote interface{} = this.CommonCurrencyCode(ToUpper(quoteId)) AppendToArray(&result,map[string]interface{} { "id": this.SafeString(market, "name"), "symbol": Add(Add(base, "/"), quote), "base": base, "quote": quote, "settle": nil, "baseId": baseId, "quoteId": quoteId, "settleId": nil, "type": "spot", "spot": true, "margin": false, "swap": false, "future": false, "option": false, "active": this.SafeValue(market, "active"), "contract": false, "linear": nil, "inverse": nil, "contractSize": nil, "expiry": nil, "expiryDatetime": nil, "strike": nil, "optionType": nil, "precision": map[string]interface{} { "amount": this.SafeNumber(market, "increment_size"), "price": this.SafeNumber(market, "increment_price"), }, "limits": map[string]interface{} { "leverage": map[string]interface{} { "min": nil, "max": nil, }, "amount": map[string]interface{} { "min": this.SafeNumber(market, "min_size"), "max": this.SafeNumber(market, "max_size"), }, "price": map[string]interface{} { "min": this.SafeNumber(market, "min_price"), "max": this.SafeNumber(market, "max_price"), }, "cost": map[string]interface{} { "min": nil, "max": nil, }, }, "created": this.Parse8601(this.SafeString(market, "created_at")), "info": market, }) } ch <- result return nil }() return ch } /** * @method * @name hollaex#fetchCurrencies * @description fetches all available currencies on an exchange * @see https://apidocs.hollaex.com/#constants * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an associative dictionary of currencies */ func (this *hollaex) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params response:= (<-this.PublicGetConstants(params)) PanicOnError(response) // // { // "coins":{ // "bch":{ // "id":4, // "fullname":"Bitcoin Cash", // "symbol":"bch", // "active":true, // "verified":true, // "allow_deposit":true, // "allow_withdrawal":true, // "withdrawal_fee":0.0002, // "min":0.001, // "max":100000, // "increment_unit":0.001, // "logo":"https://bitholla.s3.ap-northeast-2.amazonaws.com/icon/BCH-hollaex-asset-01.svg", // "code":"bch", // "is_public":true, // "meta":{}, // "estimated_price":null, // "description":null, // "type":"blockchain", // "network":null, // "standard":null, // "issuer":"HollaEx", // "withdrawal_fees":null, // "created_at":"2019-08-09T10:45:43.367Z", // "updated_at":"2021-12-13T03:08:32.372Z", // "created_by":1, // "owner_id":1 // }, // }, // "network":"https://api.hollaex.network" // } // var coins interface{} = this.SafeValue(response, "coins", map[string]interface{} {}) var keys interface{} = ObjectKeys(coins) var result interface{} = map[string]interface{} {} for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ { var key interface{} = GetValue(keys, i) var currency interface{} = GetValue(coins, key) var id interface{} = this.SafeString(currency, "symbol") var numericId interface{} = this.SafeInteger(currency, "id") var code interface{} = this.SafeCurrencyCode(id) var name interface{} = this.SafeString(currency, "fullname") var depositEnabled interface{} = this.SafeValue(currency, "allow_deposit") var withdrawEnabled interface{} = this.SafeValue(currency, "allow_withdrawal") var isActive interface{} = this.SafeValue(currency, "active") var active interface{} = IsTrue(IsTrue(isActive) && IsTrue(depositEnabled)) && IsTrue(withdrawEnabled) var fee interface{} = this.SafeNumber(currency, "withdrawal_fee") var withdrawalLimits interface{} = this.SafeValue(currency, "withdrawal_limits", []interface{}{}) AddElementToObject(result, code, map[string]interface{} { "id": id, "numericId": numericId, "code": code, "info": currency, "name": name, "active": active, "deposit": depositEnabled, "withdraw": withdrawEnabled, "fee": fee, "precision": this.SafeNumber(currency, "increment_unit"), "limits": map[string]interface{} { "amount": map[string]interface{} { "min": this.SafeNumber(currency, "min"), "max": this.SafeNumber(currency, "max"), }, "withdraw": map[string]interface{} { "min": nil, "max": this.SafeValue(withdrawalLimits, 0), }, }, "networks": map[string]interface{} {}, }) } ch <- result return nil }() return ch } /** * @method * @name hollaex#fetchOrderBooks * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data for multiple markets * @see https://apidocs.hollaex.com/#orderbooks * @param {string[]|undefined} symbols not used by hollaex fetchOrderBooks () * @param {int} [limit] not used by hollaex fetchOrderBooks () * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbol */ func (this *hollaex) 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 retRes5088 := (<-this.LoadMarkets()) PanicOnError(retRes5088) response:= (<-this.PublicGetOrderbooks(params)) PanicOnError(response) var result interface{} = map[string]interface{} {} var marketIds interface{} = ObjectKeys(response) for i := 0; IsLessThan(i, GetArrayLength(marketIds)); i++ { var marketId interface{} = GetValue(marketIds, i) var orderbook interface{} = GetValue(response, marketId) var symbol interface{} = this.SafeSymbol(marketId, nil, "-") var timestamp interface{} = this.Parse8601(this.SafeString(orderbook, "timestamp")) AddElementToObject(result, symbol, this.ParseOrderBook(GetValue(response, marketId), symbol, timestamp)) } ch <- result return nil }() return ch } /** * @method * @name hollaex#fetchOrderBook * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data * @see https://apidocs.hollaex.com/#orderbook * @param {string} symbol unified symbol of the market to fetch the order book for * @param {int} [limit] the maximum amount of order book entries to return * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols */ func (this *hollaex) 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 retRes5338 := (<-this.LoadMarkets()) PanicOnError(retRes5338) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } response:= (<-this.PublicGetOrderbook(this.Extend(request, params))) PanicOnError(response) // // { // "btc-usdt": { // "bids": [ // [ 8836.4, 1.022 ], // [ 8800, 0.0668 ], // [ 8797.75, 0.2398 ], // ], // "asks": [ // [ 8839.35, 1.5334 ], // [ 8852.6, 0.0579 ], // [ 8860.45, 0.1815 ], // ], // "timestamp": "2020-03-03T02:27:25.147Z" // }, // "eth-usdt": {}, // // ... // } // var orderbook interface{} = this.SafeValue(response, GetValue(market, "id")) var timestamp interface{} = this.Parse8601(this.SafeString(orderbook, "timestamp")) ch <- this.ParseOrderBook(orderbook, GetValue(market, "symbol"), timestamp) return nil }() return ch } /** * @method * @name hollaex#fetchTicker * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market * @see https://apidocs.hollaex.com/#ticker * @param {string} symbol unified symbol of the market to fetch the ticker for * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure} */ func (this *hollaex) 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 retRes5738 := (<-this.LoadMarkets()) PanicOnError(retRes5738) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } response:= (<-this.PublicGetTicker(this.Extend(request, params))) PanicOnError(response) // // { // "open": 8615.55, // "close": 8841.05, // "high": 8921.1, // "low": 8607, // "last": 8841.05, // "volume": 20.2802, // "timestamp": "2020-03-03T03:11:18.964Z" // } // ch <- this.ParseTicker(response, market) return nil }() return ch } /** * @method * @name hollaex#fetchTickers * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market * @see https://apidocs.hollaex.com/#tickers * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure} */ func (this *hollaex) 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 retRes6038 := (<-this.LoadMarkets()) PanicOnError(retRes6038) symbols = this.MarketSymbols(symbols) response:= (<-this.PublicGetTickers(params)) PanicOnError(response) // // { // "bch-usdt": { // "time": "2020-03-02T04:29:45.011Z", // "open": 341.65, // "close":337.9, // "high":341.65, // "low":337.3, // "last":337.9, // "volume":0.054, // "symbol":"bch-usdt" // }, // // ... // } // ch <- this.ParseTickers(response, symbols) return nil }() return ch } func (this *hollaex) ParseTickers(tickers interface{}, optionalArgs ...interface{}) interface{} { symbols := GetArg(optionalArgs, 0, nil) _ = symbols params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params var result interface{} = map[string]interface{} {} var keys interface{} = ObjectKeys(tickers) for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ { var key interface{} = GetValue(keys, i) var ticker interface{} = GetValue(tickers, key) var marketId interface{} = this.SafeString(ticker, "symbol", key) var market interface{} = this.SafeMarket(marketId, nil, "-") var symbol interface{} = GetValue(market, "symbol") AddElementToObject(result, symbol, this.Extend(this.ParseTicker(ticker, market), params)) } return this.FilterByArrayTickers(result, "symbol", symbols) } func (this *hollaex) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} { // // fetchTicker // // { // "open": 8615.55, // "close": 8841.05, // "high": 8921.1, // "low": 8607, // "last": 8841.05, // "volume": 20.2802, // "timestamp": "2020-03-03T03:11:18.964Z", // } // // fetchTickers // // { // "time": "2020-03-02T04:29:45.011Z", // "open": 341.65, // "close": 337.9, // "high": 341.65, // "low": 337.3, // "last": 337.9, // "volume": 0.054, // "symbol": "bch-usdt" // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(ticker, "symbol") market = this.SafeMarket(marketId, market, "-") var symbol interface{} = GetValue(market, "symbol") var timestamp interface{} = this.Parse8601(this.SafeString2(ticker, "time", "timestamp")) var close interface{} = this.SafeString(ticker, "close") return this.SafeTicker(map[string]interface{} { "symbol": symbol, "info": ticker, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "high": this.SafeString(ticker, "high"), "low": this.SafeString(ticker, "low"), "bid": nil, "bidVolume": nil, "ask": nil, "askVolume": nil, "vwap": nil, "open": this.SafeString(ticker, "open"), "close": close, "last": this.SafeString(ticker, "last", close), "previousClose": nil, "change": nil, "percentage": nil, "average": nil, "baseVolume": this.SafeString(ticker, "volume"), "quoteVolume": nil, }, market) } /** * @method * @name hollaex#fetchTrades * @description get the list of most recent trades for a particular symbol * @see https://apidocs.hollaex.com/#trades * @param {string} symbol unified symbol of the market to fetch trades for * @param {int} [since] timestamp in ms of the earliest trade to fetch * @param {int} [limit] the maximum amount of trades to fetch * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades} */ func (this *hollaex) 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 retRes7068 := (<-this.LoadMarkets()) PanicOnError(retRes7068) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), } response:= (<-this.PublicGetTrades(this.Extend(request, params))) PanicOnError(response) // // { // "btc-usdt": [ // { // "size": 0.5, // "price": 8830, // "side": "buy", // "timestamp": "2020-03-03T04:44:33.034Z" // }, // // ... // ] // } // var trades interface{} = this.SafeList(response, GetValue(market, "id"), []interface{}{}) ch <- this.ParseTrades(trades, market, since, limit) return nil }() return ch } func (this *hollaex) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} { // // fetchTrades (public) // // { // "size": 0.5, // "price": 8830, // "side": "buy", // "timestamp": "2020-03-03T04:44:33.034Z" // } // // fetchMyTrades (private) // { // "side":"sell", // "symbol":"doge-usdt", // "size":70, // "price":0.147411, // "timestamp":"2022-01-26T17:53:34.650Z", // "order_id":"cba78ecb-4187-4da2-9d2f-c259aa693b5a", // "fee":0.01031877,"fee_coin":"usdt" // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(trade, "symbol") market = this.SafeMarket(marketId, market, "-") var symbol interface{} = GetValue(market, "symbol") var datetime interface{} = this.SafeString(trade, "timestamp") var timestamp interface{} = this.Parse8601(datetime) var side interface{} = this.SafeString(trade, "side") var orderId interface{} = this.SafeString(trade, "order_id") var priceString interface{} = this.SafeString(trade, "price") var amountString interface{} = this.SafeString(trade, "size") var feeCostString interface{} = this.SafeString(trade, "fee") var fee interface{} = nil if IsTrue(!IsEqual(feeCostString, nil)) { fee = map[string]interface{} { "cost": feeCostString, "currency": GetValue(market, "quote"), } } return this.SafeTrade(map[string]interface{} { "info": trade, "id": nil, "timestamp": timestamp, "datetime": datetime, "symbol": symbol, "order": orderId, "type": nil, "side": side, "takerOrMaker": nil, "price": priceString, "amount": amountString, "cost": nil, "fee": fee, }, market) } /** * @method * @name hollaex#fetchTradingFees * @description fetch the trading fees for multiple markets * @see https://apidocs.hollaex.com/#tiers * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a dictionary of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure} indexed by market symbols */ func (this *hollaex) 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 retRes7948 := (<-this.LoadMarkets()) PanicOnError(retRes7948) response:= (<-this.PublicGetTiers(params)) PanicOnError(response) // // { // "1": { // "id": "1", // "name": "Silver", // "icon": '', // "description": "Your crypto journey starts here! Make your first deposit to start trading, and verify your account to level up!", // "deposit_limit": "0", // "withdrawal_limit": "1000", // "fees": { // "maker": { // 'eth-btc': "0.1", // 'ada-usdt': "0.1", // ... // }, // "taker": { // 'eth-btc': "0.1", // 'ada-usdt': "0.1", // ... // } // }, // "note": "\n", // "created_at": "2021-03-22T03:51:39.129Z", // "updated_at": "2021-11-01T02:51:56.214Z" // }, // ... // } // var firstTier interface{} = this.SafeValue(response, "1", map[string]interface{} {}) var fees interface{} = this.SafeValue(firstTier, "fees", map[string]interface{} {}) var makerFees interface{} = this.SafeValue(fees, "maker", map[string]interface{} {}) var takerFees interface{} = this.SafeValue(fees, "taker", map[string]interface{} {}) var result interface{} = map[string]interface{} {} for i := 0; IsLessThan(i, GetArrayLength(this.Symbols)); i++ { var symbol interface{} = GetValue(this.Symbols, i) var market interface{} = this.Market(symbol) var makerString interface{} = this.SafeString(makerFees, GetValue(market, "id")) var takerString interface{} = this.SafeString(takerFees, GetValue(market, "id")) AddElementToObject(result, symbol, map[string]interface{} { "info": fees, "symbol": symbol, "maker": this.ParseNumber(Precise.StringDiv(makerString, "100")), "taker": this.ParseNumber(Precise.StringDiv(takerString, "100")), "percentage": true, "tierBased": true, }) } ch <- result return nil }() return ch } /** * @method * @name hollaex#fetchOHLCV * @description hollaex has large gaps between candles, so it's recommended to specify since * @see https://apidocs.hollaex.com/#chart * @param {string} symbol unified symbol of the market to fetch OHLCV data for * @param {string} timeframe the length of time each candle represents * @param {int} [since] timestamp in ms of the earliest candle to fetch * @param {int} [limit] the maximum amount of candles to fetch * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {int} [params.until] timestamp in ms of the latest candle to fetch * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume */ func (this *hollaex) 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 retRes8608 := (<-this.LoadMarkets()) PanicOnError(retRes8608) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), "resolution": this.SafeString(this.Timeframes, timeframe, timeframe), } var until interface{} = this.SafeInteger(params, "until") var end interface{} = this.Seconds() if IsTrue(!IsEqual(until, nil)) { end = this.ParseToInt(Divide(until, 1000)) } var defaultSpan interface{} = 2592000 // 30 days if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "from", this.ParseToInt(Divide(since, 1000))) } else { AddElementToObject(request, "from", Subtract(end, defaultSpan)) } AddElementToObject(request, "to", end) params = this.Omit(params, "until") response:= (<-this.PublicGetChart(this.Extend(request, params))) PanicOnError(response) // // [ // { // "time":"2020-03-02T20:00:00.000Z", // "close":8872.1, // "high":8872.1, // "low":8858.6, // "open":8858.6, // "symbol":"btc-usdt", // "volume":1.2922 // }, // ] // ch <- this.ParseOHLCVs(response, market, timeframe, since, limit) return nil }() return ch } func (this *hollaex) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} { // // { // "time":"2020-03-02T20:00:00.000Z", // "close":8872.1, // "high":8872.1, // "low":8858.6, // "open":8858.6, // "symbol":"btc-usdt", // "volume":1.2922 // } // market := GetArg(optionalArgs, 0, nil) _ = market return []interface{}{this.Parse8601(this.SafeString(ohlcv, "time")), this.SafeNumber(ohlcv, "open"), this.SafeNumber(ohlcv, "high"), this.SafeNumber(ohlcv, "low"), this.SafeNumber(ohlcv, "close"), this.SafeNumber(ohlcv, "volume")} } func (this *hollaex) ParseBalance(response interface{}) interface{} { var timestamp interface{} = this.Parse8601(this.SafeString(response, "updated_at")) var result interface{} = map[string]interface{} { "info": response, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), } var currencyIds interface{} = ObjectKeys(this.Currencies_by_id) for i := 0; IsLessThan(i, GetArrayLength(currencyIds)); i++ { var currencyId interface{} = GetValue(currencyIds, i) var code interface{} = this.SafeCurrencyCode(currencyId) var account interface{} = this.Account() AddElementToObject(account, "free", this.SafeString(response, Add(currencyId, "_available"))) AddElementToObject(account, "total", this.SafeString(response, Add(currencyId, "_balance"))) AddElementToObject(result, code, account) } return this.SafeBalance(result) } /** * @method * @name hollaex#fetchBalance * @description query for balance and get the amount of funds available for trading or funds locked in orders * @see https://apidocs.hollaex.com/#get-balance * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure} */ func (this *hollaex) 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 retRes9468 := (<-this.LoadMarkets()) PanicOnError(retRes9468) response:= (<-this.PrivateGetUserBalance(params)) PanicOnError(response) // // { // "updated_at": "2020-03-02T22:27:38.428Z", // "btc_balance": 0, // "btc_pending": 0, // "btc_available": 0, // "eth_balance": 0, // "eth_pending": 0, // "eth_available": 0, // // ... // } // ch <- this.ParseBalance(response) return nil }() return ch } /** * @method * @name hollaex#fetchOpenOrder * @description fetch an open order by it's id * @see https://apidocs.hollaex.com/#get-order * @param {string} id order id * @param {string} symbol not used by hollaex fetchOpenOrder () * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) FetchOpenOrder(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 retRes9748 := (<-this.LoadMarkets()) PanicOnError(retRes9748) var request interface{} = map[string]interface{} { "order_id": id, } response:= (<-this.PrivateGetOrder(this.Extend(request, params))) PanicOnError(response) // // { // "id": "string", // "side": "sell", // "symbol": "xht-usdt", // "size": 0.1, // "filled": 0, // "stop": null, // "fee": 0, // "fee_coin": "usdt", // "type": "limit", // "price": 1.09, // "status": "new", // "created_by": 116, // "created_at": "2021-02-17T02:32:38.910Z", // "updated_at": "2021-02-17T02:32:38.910Z", // "User": { // "id": 116, // "email": "fight@club.com", // "username": "narrator", // "exchange_id": 176 // } // } // ch <- this.ParseOrder(response) return nil }() return ch } /** * @method * @name hollaex#fetchOpenOrders * @description fetch all unfilled currently open orders * @see https://apidocs.hollaex.com/#get-all-orders * @param {string} symbol unified market symbol * @param {int} [since] the earliest time in ms to fetch open orders for * @param {int} [limit] the maximum number of open orders structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) 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 var request interface{} = map[string]interface{} { "open": true, } retRes102115 := (<-this.FetchOrders(symbol, since, limit, this.Extend(request, params))) PanicOnError(retRes102115) ch <- retRes102115 return nil }() return ch } /** * @method * @name hollaex#fetchClosedOrders * @description fetches information on multiple closed orders made by the user * @see https://apidocs.hollaex.com/#get-all-orders * @param {string} symbol unified market symbol of the market orders were made in * @param {int} [since] the earliest time in ms to fetch orders for * @param {int} [limit] the maximum number of order structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) 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 var request interface{} = map[string]interface{} { "open": false, } retRes103915 := (<-this.FetchOrders(symbol, since, limit, this.Extend(request, params))) PanicOnError(retRes103915) ch <- retRes103915 return nil }() return ch } /** * @method * @name hollaex#fetchOrder * @description fetches information on an order made by the user * @see https://apidocs.hollaex.com/#get-order * @param {string} id * @param {string} symbol unified symbol of the market the order was made in * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) 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 retRes10538 := (<-this.LoadMarkets()) PanicOnError(retRes10538) var request interface{} = map[string]interface{} { "order_id": id, } response:= (<-this.PrivateGetOrder(this.Extend(request, params))) PanicOnError(response) // { // "id": "string", // "side": "sell", // "symbol": "xht-usdt", // "size": 0.1, // "filled": 0, // "stop": null, // "fee": 0, // "fee_coin": "usdt", // "type": "limit", // "price": 1.09, // "status": "new", // "created_by": 116, // "created_at": "2021-02-17T02:32:38.910Z", // "updated_at": "2021-02-17T02:32:38.910Z", // "User": { // "id": 116, // "email": "fight@club.com", // "username": "narrator", // "exchange_id": 176 // } // } var order interface{} = response if IsTrue(IsEqual(order, nil)) { panic(OrderNotFound(Add(Add(this.Id, " fetchOrder() could not find order id "), id))) } ch <- this.ParseOrder(order) return nil }() return ch } /** * @method * @name hollaex#fetchOrders * @description fetches information on multiple orders made by the user * @see https://apidocs.hollaex.com/#get-all-orders * @param {string} symbol unified market symbol of the market orders were made in * @param {int} [since] the earliest time in ms to fetch orders for * @param {int} [limit] the maximum number of order structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) 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 retRes10998 := (<-this.LoadMarkets()) PanicOnError(retRes10998) var market interface{} = nil var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "symbol", GetValue(market, "id")) } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_date", this.Iso8601(since)) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) // default 50, max 100 } response:= (<-this.PrivateGetOrders(this.Extend(request, params))) PanicOnError(response) // // { // "count": 1, // "data": [ // { // "id": "string", // "side": "sell", // "symbol": "xht-usdt", // "size": 0.1, // "filled": 0, // "stop": null, // "fee": 0, // "fee_coin": "usdt", // "type": "limit", // "price": 1.09, // "status": "new", // "created_by": 116, // "created_at": "2021-02-17T02:32:38.910Z", // "updated_at": "2021-02-17T02:32:38.910Z", // "User": { // "id": 116, // "email": "fight@club.com", // "username": "narrator", // "exchange_id": 176 // } // } // ] // } // var data interface{} = this.SafeList(response, "data", []interface{}{}) ch <- this.ParseOrders(data, market, since, limit) return nil }() return ch } func (this *hollaex) ParseOrderStatus(status interface{}) interface{} { var statuses interface{} = map[string]interface{} { "new": "open", "pfilled": "open", "filled": "closed", "canceled": "canceled", } return this.SafeString(statuses, status, status) } func (this *hollaex) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} { // // createOrder, fetchOpenOrder, fetchOpenOrders // // { // "id":"10644b7e-3c90-4ba9-bc3b-188f3a4e9cfd", // "created_by":140093, // "exchange_id":22, // "side":"buy", // "symbol":"doge-usdt", // "type":"limit", // "price":0.05, // "size":10, // "stop":null, // "filled":0, // "status":"canceled", // "fee":0, // "fee_coin":"doge", // "meta": { // optional field only returned for postOnly orders // "post_only":true // }, // "fee_structure": { // "maker":0.1, // "taker":0.1 // }, // "created_at":"2022-05-31T08:14:14.747Z", // "updated_at":"2022-05-31T08:14:23.727Z" // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(order, "symbol") var symbol interface{} = this.SafeSymbol(marketId, market, "-") var id interface{} = this.SafeString(order, "id") var timestamp interface{} = this.Parse8601(this.SafeString(order, "created_at")) var typeVar interface{} = this.SafeString(order, "type") var side interface{} = this.SafeString(order, "side") var price interface{} = this.SafeString(order, "price") var amount interface{} = this.SafeString(order, "size") var filled interface{} = this.SafeString(order, "filled") var status interface{} = this.ParseOrderStatus(this.SafeString(order, "status")) var meta interface{} = this.SafeValue(order, "meta", map[string]interface{} {}) var postOnly interface{} = this.SafeBool(meta, "post_only", false) return this.SafeOrder(map[string]interface{} { "id": id, "clientOrderId": nil, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "lastTradeTimestamp": nil, "status": status, "symbol": symbol, "type": typeVar, "timeInForce": nil, "postOnly": postOnly, "side": side, "price": price, "triggerPrice": this.SafeString(order, "stop"), "amount": amount, "filled": filled, "remaining": nil, "cost": nil, "trades": nil, "fee": nil, "info": order, "average": nil, }, market) } /** * @method * @name hollaex#createOrder * @description create a trade order * @see https://apidocs.hollaex.com/#create-order * @param {string} symbol unified symbol of the market to create an order in * @param {string} type 'market' or 'limit' * @param {string} side 'buy' or 'sell' * @param {float} amount how much of currency you want to trade in units of base currency * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {float} [params.triggerPrice] the price at which a trigger order is triggered at * @param {bool} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) 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 retRes12498 := (<-this.LoadMarkets()) PanicOnError(retRes12498) var market interface{} = this.Market(symbol) var convertedAmount interface{} = ParseFloat(this.AmountToPrecision(symbol, amount)) var request interface{} = map[string]interface{} { "symbol": GetValue(market, "id"), "side": side, "size": this.NormalizeNumberIfNeeded(convertedAmount), "type": typeVar, } var triggerPrice interface{} = this.SafeNumberN(params, []interface{}{"triggerPrice", "stopPrice", "stop"}) var meta interface{} = this.SafeValue(params, "meta", map[string]interface{} {}) var exchangeSpecificParam interface{} = this.SafeBool(meta, "post_only", false) var isMarketOrder interface{} = IsEqual(typeVar, "market") var postOnly interface{} = this.IsPostOnly(isMarketOrder, exchangeSpecificParam, params) if !IsTrue(isMarketOrder) { var convertedPrice interface{} = ParseFloat(this.PriceToPrecision(symbol, price)) AddElementToObject(request, "price", this.NormalizeNumberIfNeeded(convertedPrice)) } if IsTrue(!IsEqual(triggerPrice, nil)) { AddElementToObject(request, "stop", this.NormalizeNumberIfNeeded(ParseFloat(this.PriceToPrecision(symbol, triggerPrice)))) } if IsTrue(postOnly) { AddElementToObject(request, "meta", map[string]interface{} { "post_only": true, }) } params = this.Omit(params, []interface{}{"postOnly", "timeInForce", "stopPrice", "triggerPrice", "stop"}) response:= (<-this.PrivatePostOrder(this.Extend(request, params))) PanicOnError(response) // // { // "fee": 0, // "meta": {}, // "symbol": "xht-usdt", // "side": "sell", // "size": 0.1, // "type": "limit", // "price": 1, // "fee_structure": { // "maker": 0.2, // "taker": 0.2 // }, // "fee_coin": "usdt", // "id": "string", // "created_by": 116, // "filled": 0, // "status": "new", // "updated_at": "2021-02-17T03:03:19.231Z", // "created_at": "2021-02-17T03:03:19.231Z", // "stop": null // } // ch <- this.ParseOrder(response, market) return nil }() return ch } /** * @method * @name hollaex#cancelOrder * @description cancels an open order * @see https://apidocs.hollaex.com/#cancel-order * @param {string} id order id * @param {string} symbol unified symbol of the market the order was made in * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) 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 retRes13148 := (<-this.LoadMarkets()) PanicOnError(retRes13148) var request interface{} = map[string]interface{} { "order_id": id, } response:= (<-this.PrivateDeleteOrder(this.Extend(request, params))) PanicOnError(response) // // { // "title": "string", // "symbol": "xht-usdt", // "side": "sell", // "size": 1, // "type": "limit", // "price": 0.1, // "id": "string", // "created_by": 34, // "filled": 0 // } // ch <- this.ParseOrder(response) return nil }() return ch } /** * @method * @name hollaex#cancelAllOrders * @description cancel all open orders in a market * @see https://apidocs.hollaex.com/#cancel-all-orders * @param {string} symbol unified market symbol of the market to cancel orders in * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *hollaex) CancelAllOrders(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbol := GetArg(optionalArgs, 0, nil) _ = symbol params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params if IsTrue(IsEqual(symbol, nil)) { panic(ArgumentsRequired(Add(this.Id, " cancelAllOrders() requires a symbol argument"))) } retRes13488 := (<-this.LoadMarkets()) PanicOnError(retRes13488) var request interface{} = map[string]interface{} {} var market interface{} = nil market = this.Market(symbol) AddElementToObject(request, "symbol", GetValue(market, "id")) response:= (<-this.PrivateDeleteOrderAll(this.Extend(request, params))) PanicOnError(response) // // [ // { // "title": "string", // "symbol": "xht-usdt", // "side": "sell", // "size": 1, // "type": "limit", // "price": 0.1, // "id": "string", // "created_by": 34, // "filled": 0 // } // ] // ch <- this.ParseOrders(response, market) return nil }() return ch } /** * @method * @name hollaex#fetchMyTrades * @description fetch all trades made by the user * @see https://apidocs.hollaex.com/#get-trades * @param {string} symbol unified market symbol * @param {int} [since] the earliest time in ms to fetch trades for * @param {int} [limit] the maximum number of trades structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure} */ func (this *hollaex) 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 retRes13848 := (<-this.LoadMarkets()) PanicOnError(retRes13848) var request interface{} = map[string]interface{} {} var market interface{} = nil if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "symbol", GetValue(market, "id")) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) // default 50, max 100 } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_date", this.Iso8601(since)) } response:= (<-this.PrivateGetUserTrades(this.Extend(request, params))) PanicOnError(response) // // { // "count": 1, // "data": [ // { // "side": "buy", // "symbol": "eth-usdt", // "size": 0.086, // "price": 226.19, // "timestamp": "2020-03-03T08:03:55.459Z", // "fee": 0.1 // } // ] // } // var data interface{} = this.SafeList(response, "data", []interface{}{}) ch <- this.ParseTrades(data, market, since, limit) return nil }() return ch } func (this *hollaex) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{} { // // { // "currency":"usdt", // "address":"TECLD9XBH31XpyykdHU3uEAeUK7E6Lrmik", // "network":"trx", // "standard":null, // "is_valid":true, // "created_at":"2021-05-12T02:43:05.446Z" // } // currency := GetArg(optionalArgs, 0, nil) _ = currency var address interface{} = this.SafeString(depositAddress, "address") var tag interface{} = nil if IsTrue(!IsEqual(address, nil)) { var parts interface{} = Split(address, ":") address = this.SafeString(parts, 0) tag = this.SafeString(parts, 1) } this.CheckAddress(address) var currencyId interface{} = this.SafeString(depositAddress, "currency") currency = this.SafeCurrency(currencyId, currency) var network interface{} = this.SafeString(depositAddress, "network") return map[string]interface{} { "info": depositAddress, "currency": GetValue(currency, "code"), "network": network, "address": address, "tag": tag, } } /** * @method * @name hollaex#fetchDepositAddresses * @description fetch deposit addresses for multiple currencies and chain types * @see https://apidocs.hollaex.com/#get-user * @param {string[]|undefined} codes list of unified currency codes, default is undefined * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a list of [address structures]{@link https://docs.ccxt.com/#/?id=address-structure} */ func (this *hollaex) 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 retRes14668 := (<-this.LoadMarkets()) PanicOnError(retRes14668) var network interface{} = this.SafeString(params, "network") params = this.Omit(params, "network") response:= (<-this.PrivateGetUser(params)) PanicOnError(response) // // { // "id":620, // "email":"igor.kroitor@gmail.com", // "full_name":"", // "gender":false, // "nationality":"", // "dob":null, // "phone_number":"", // "address":{"city":"","address":"","country":"","postal_code":""}, // "id_data":{"note":"","type":"","number":"","status":0,"issued_date":"","expiration_date":""}, // "bank_account":[], // "crypto_wallet":{}, // "verification_level":1, // "email_verified":true, // "otp_enabled":true, // "activated":true, // "username":"igor.kroitor", // "affiliation_code":"QSWA6G", // "settings":{ // "chat":{"set_username":false}, // "risk":{"popup_warning":false,"order_portfolio_percentage":20}, // "audio":{"public_trade":false,"order_completed":true,"order_partially_completed":true}, // "language":"en", // "interface":{"theme":"white","order_book_levels":10}, // "notification":{"popup_order_completed":true,"popup_order_confirmation":true,"popup_order_partially_filled":true} // }, // "affiliation_rate":0, // "network_id":10620, // "discount":0, // "created_at":"2021-03-24T02:37:57.379Z", // "updated_at":"2021-03-24T02:37:57.379Z", // "balance":{ // "btc_balance":0, // "btc_available":0, // "eth_balance":0.000914, // "eth_available":0.000914, // "updated_at":"2020-03-04T04:03:27.174Z // "}, // "wallet":[ // {"currency":"usdt","address":"TECLD9XBH31XpyykdHU3uEAeUK7E6Lrmik","network":"trx","standard":null,"is_valid":true,"created_at":"2021-05-12T02:43:05.446Z"}, // {"currency":"xrp","address":"rGcSzmuRx8qngPRnrvpCKkP9V4njeCPGCv:286741597","network":"xrp","standard":null,"is_valid":true,"created_at":"2021-05-12T02:49:01.273Z"} // ] // } // var wallet interface{} = this.SafeValue(response, "wallet", []interface{}{}) var addresses interface{} = Ternary(IsTrue((IsEqual(network, nil))), wallet, this.FilterBy(wallet, "network", network)) ch <- this.ParseDepositAddresses(addresses, codes) return nil }() return ch } /** * @method * @name hollaex#fetchDeposits * @description fetch all deposits made to an account * @see https://apidocs.hollaex.com/#get-deposits * @param {string} code unified currency code * @param {int} [since] the earliest time in ms to fetch deposits for * @param {int} [limit] the maximum number of deposits structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *hollaex) FetchDeposits(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) code := GetArg(optionalArgs, 0, nil) _ = code since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params retRes15328 := (<-this.LoadMarkets()) PanicOnError(retRes15328) var request interface{} = map[string]interface{} {} var currency interface{} = nil if IsTrue(!IsEqual(code, nil)) { currency = this.Currency(code) AddElementToObject(request, "currency", GetValue(currency, "id")) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) // default 50, max 100 } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_date", this.Iso8601(since)) } response:= (<-this.PrivateGetUserDeposits(this.Extend(request, params))) PanicOnError(response) // // { // "count": 1, // "data": [ // { // "id": 539, // "amount": 20, // "fee": 0, // "address": "0x5c0cc98270d7089408fcbcc8e2131287f5be2306", // "transaction_id": "0xd4006327a5ec2c41adbdcf566eaaba6597c3d45906abe78ea1a4a022647c2e28", // "status": true, // "dismissed": false, // "rejected": false, // "description": "", // "type": "deposit", // "currency": "usdt", // "created_at": "2020-03-03T07:56:36.198Z", // "updated_at": "2020-03-03T08:00:05.674Z", // "user_id": 620 // } // ] // } // var data interface{} = this.SafeList(response, "data", []interface{}{}) ch <- this.ParseTransactions(data, currency, since, limit) return nil }() return ch } /** * @method * @name hollaex#fetchWithdrawal * @description fetch data on a currency withdrawal via the withdrawal id * @see https://apidocs.hollaex.com/#get-withdrawals * @param {string} id withdrawal id * @param {string} code unified currency code of the currency withdrawn, default is undefined * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *hollaex) FetchWithdrawal(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 retRes15928 := (<-this.LoadMarkets()) PanicOnError(retRes15928) var request interface{} = map[string]interface{} { "transaction_id": id, } var currency interface{} = nil if IsTrue(!IsEqual(code, nil)) { currency = this.Currency(code) AddElementToObject(request, "currency", GetValue(currency, "id")) } response:= (<-this.PrivateGetUserWithdrawals(this.Extend(request, params))) PanicOnError(response) // // { // "count": 1, // "data": [ // { // "id": 539, // "amount": 20, // "fee": 0, // "address": "0x5c0cc98270d7089408fcbcc8e2131287f5be2306", // "transaction_id": "0xd4006327a5ec2c41adbdcf566eaaba6597c3d45906abe78ea1a4a022647c2e28", // "status": true, // "dismissed": false, // "rejected": false, // "description": "", // "type": "withdrawal", // "currency": "usdt", // "created_at": "2020-03-03T07:56:36.198Z", // "updated_at": "2020-03-03T08:00:05.674Z", // "user_id": 620 // } // ] // } // var data interface{} = this.SafeValue(response, "data", []interface{}{}) var transaction interface{} = this.SafeDict(data, 0, map[string]interface{} {}) ch <- this.ParseTransaction(transaction, currency) return nil }() return ch } /** * @method * @name hollaex#fetchWithdrawals * @description fetch all withdrawals made from an account * @see https://apidocs.hollaex.com/#get-withdrawals * @param {string} code unified currency code * @param {int} [since] the earliest time in ms to fetch withdrawals for * @param {int} [limit] the maximum number of withdrawals structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *hollaex) FetchWithdrawals(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) code := GetArg(optionalArgs, 0, nil) _ = code since := GetArg(optionalArgs, 1, nil) _ = since limit := GetArg(optionalArgs, 2, nil) _ = limit params := GetArg(optionalArgs, 3, map[string]interface{} {}) _ = params retRes16428 := (<-this.LoadMarkets()) PanicOnError(retRes16428) var request interface{} = map[string]interface{} {} var currency interface{} = nil if IsTrue(!IsEqual(code, nil)) { currency = this.Currency(code) AddElementToObject(request, "currency", GetValue(currency, "id")) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) // default 50, max 100 } if IsTrue(!IsEqual(since, nil)) { AddElementToObject(request, "start_date", this.Iso8601(since)) } response:= (<-this.PrivateGetUserWithdrawals(this.Extend(request, params))) PanicOnError(response) // // { // "count": 1, // "data": [ // { // "id": 539, // "amount": 20, // "fee": 0, // "address": "0x5c0cc98270d7089408fcbcc8e2131287f5be2306", // "transaction_id": "0xd4006327a5ec2c41adbdcf566eaaba6597c3d45906abe78ea1a4a022647c2e28", // "status": true, // "dismissed": false, // "rejected": false, // "description": "", // "type": "withdrawal", // "currency": "usdt", // "created_at": "2020-03-03T07:56:36.198Z", // "updated_at": "2020-03-03T08:00:05.674Z", // "user_id": 620 // } // ] // } // var data interface{} = this.SafeList(response, "data", []interface{}{}) ch <- this.ParseTransactions(data, currency, since, limit) return nil }() return ch } func (this *hollaex) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} { // // fetchWithdrawals, fetchDeposits // // { // "id": 539, // "amount": 20, // "fee": 0, // "address": "0x5c0cc98270d7089408fcbcc8e2131287f5be2306", // "transaction_id": "0xd4006327a5ec2c41adbdcf566eaaba6597c3d45906abe78ea1a4a022647c2e28", // "status": true, // "dismissed": false, // "rejected": false, // "description": "", // "type": "withdrawal", // "currency": "usdt", // "created_at": "2020-03-03T07:56:36.198Z", // "updated_at": "2020-03-03T08:00:05.674Z", // "user_id": 620 // } // // withdraw // // { // "message": "Withdrawal request is in the queue and will be processed.", // "transaction_id": "1d1683c3-576a-4d53-8ff5-27c93fd9758a", // "amount": 1, // "currency": "xht", // "fee": 0, // "fee_coin": "xht" // } // currency := GetArg(optionalArgs, 0, nil) _ = currency var id interface{} = this.SafeString(transaction, "id") var txid interface{} = this.SafeString(transaction, "transaction_id") var timestamp interface{} = this.Parse8601(this.SafeString(transaction, "created_at")) var updated interface{} = this.Parse8601(this.SafeString(transaction, "updated_at")) var typeVar interface{} = this.SafeString(transaction, "type") var amount interface{} = this.SafeNumber(transaction, "amount") var address interface{} = this.SafeString(transaction, "address") var addressTo interface{} = nil var addressFrom interface{} = nil var tag interface{} = nil var tagTo interface{} = nil var tagFrom interface{} = nil if IsTrue(!IsEqual(address, nil)) { var parts interface{} = Split(address, ":") address = this.SafeString(parts, 0) tag = this.SafeString(parts, 1) addressTo = address tagTo = tag } var currencyId interface{} = this.SafeString(transaction, "currency") currency = this.SafeCurrency(currencyId, currency) var status interface{} = this.SafeValue(transaction, "status") var dismissed interface{} = this.SafeValue(transaction, "dismissed") var rejected interface{} = this.SafeValue(transaction, "rejected") if IsTrue(status) { status = "ok" } else if IsTrue(dismissed) { status = "canceled" } else if IsTrue(rejected) { status = "failed" } else { status = "pending" } var feeCurrencyId interface{} = this.SafeString(transaction, "fee_coin") var feeCurrencyCode interface{} = this.SafeCurrencyCode(feeCurrencyId, currency) var feeCost interface{} = this.SafeNumber(transaction, "fee") var fee interface{} = nil if IsTrue(!IsEqual(feeCost, nil)) { fee = map[string]interface{} { "currency": feeCurrencyCode, "cost": feeCost, } } return map[string]interface{} { "info": transaction, "id": id, "txid": txid, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "network": nil, "addressFrom": addressFrom, "address": address, "addressTo": addressTo, "tagFrom": tagFrom, "tag": tag, "tagTo": tagTo, "type": typeVar, "amount": amount, "currency": GetValue(currency, "code"), "status": status, "updated": updated, "comment": this.SafeString(transaction, "message"), "internal": nil, "fee": fee, } } /** * @method * @name hollaex#withdraw * @description make a withdrawal * @see https://apidocs.hollaex.com/#withdrawal * @param {string} code unified currency code * @param {float} amount the amount to withdraw * @param {string} address the address to withdraw to * @param {string} tag * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure} */ func (this *hollaex) Withdraw(code interface{}, amount interface{}, address interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) tag := GetArg(optionalArgs, 0, nil) _ = tag params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params tagparamsVariable := this.HandleWithdrawTagAndParams(tag, params); tag = GetValue(tagparamsVariable,0); params = GetValue(tagparamsVariable,1) this.CheckAddress(address) retRes18058 := (<-this.LoadMarkets()) PanicOnError(retRes18058) var currency interface{} = this.Currency(code) if IsTrue(!IsEqual(tag, nil)) { address = Add(address, Add(":", tag)) } var network interface{} = this.SafeString(params, "network") if IsTrue(IsEqual(network, nil)) { panic(ArgumentsRequired(Add(this.Id, " withdraw() requires a network parameter"))) } params = this.Omit(params, "network") var request interface{} = map[string]interface{} { "currency": GetValue(currency, "id"), "amount": amount, "address": address, "network": this.NetworkCodeToId(network, code), } response:= (<-this.PrivatePostUserWithdrawal(this.Extend(request, params))) PanicOnError(response) // // { // "message": "Withdrawal request is in the queue and will be processed.", // "transaction_id": "1d1683c3-576a-4d53-8ff5-27c93fd9758a", // "amount": 1, // "currency": "xht", // "fee": 0, // "fee_coin": "xht" // } // ch <- this.ParseTransaction(response, currency) return nil }() return ch } func (this *hollaex) ParseDepositWithdrawFee(fee interface{}, optionalArgs ...interface{}) interface{} { // // "bch":{ // "id":4, // "fullname":"Bitcoin Cash", // "symbol":"bch", // "active":true, // "verified":true, // "allow_deposit":true, // "allow_withdrawal":true, // "withdrawal_fee":0.0001, // "min":0.001, // "max":100000, // "increment_unit":0.001, // "logo":"https://bitholla.s3.ap-northeast-2.amazonaws.com/icon/BCH-hollaex-asset-01.svg", // "code":"bch", // "is_public":true, // "meta":{}, // "estimated_price":null, // "description":null, // "type":"blockchain", // "network":null, // "standard":null, // "issuer":"HollaEx", // "withdrawal_fees":null, // "created_at":"2019-08-09T10:45:43.367Z", // "updated_at":"2021-12-13T03:08:32.372Z", // "created_by":1, // "owner_id":1 // } // currency := GetArg(optionalArgs, 0, nil) _ = currency var result interface{} = map[string]interface{} { "info": fee, "withdraw": map[string]interface{} { "fee": nil, "percentage": nil, }, "deposit": map[string]interface{} { "fee": nil, "percentage": nil, }, "networks": map[string]interface{} {}, } var allowWithdrawal interface{} = this.SafeValue(fee, "allow_withdrawal") if IsTrue(allowWithdrawal) { AddElementToObject(result, "withdraw", map[string]interface{} { "fee": this.SafeNumber(fee, "withdrawal_fee"), "percentage": false, }) } var withdrawalFees interface{} = this.SafeValue(fee, "withdrawal_fees") if IsTrue(!IsEqual(withdrawalFees, nil)) { var keys interface{} = ObjectKeys(withdrawalFees) var keysLength interface{} = GetArrayLength(keys) for i := 0; IsLessThan(i, keysLength); i++ { var key interface{} = GetValue(keys, i) var value interface{} = GetValue(withdrawalFees, key) var currencyId interface{} = this.SafeString(value, "symbol") var currencyCode interface{} = this.SafeCurrencyCode(currencyId) var networkCode interface{} = this.NetworkIdToCode(key, currencyCode) var networkCodeUpper interface{} = ToUpper(networkCode) // default to the upper case network code var withdrawalFee interface{} = this.SafeNumber(value, "value") AddElementToObject(GetValue(result, "networks"), networkCodeUpper, map[string]interface{} { "deposit": nil, "withdraw": withdrawalFee, }) } } return result } /** * @method * @name hollaex#fetchDepositWithdrawFees * @description fetch deposit and withdraw fees * @see https://apidocs.hollaex.com/#constants * @param {string[]|undefined} codes list of unified currency codes * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} a list of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure} */ func (this *hollaex) 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 response:= (<-this.PublicGetConstants(params)) PanicOnError(response) // // { // "coins":{ // "bch":{ // "id":4, // "fullname":"Bitcoin Cash", // "symbol":"bch", // "active":true, // "verified":true, // "allow_deposit":true, // "allow_withdrawal":true, // "withdrawal_fee":0.0001, // "min":0.001, // "max":100000, // "increment_unit":0.001, // "logo":"https://bitholla.s3.ap-northeast-2.amazonaws.com/icon/BCH-hollaex-asset-01.svg", // "code":"bch", // "is_public":true, // "meta":{}, // "estimated_price":null, // "description":null, // "type":"blockchain", // "network":null, // "standard":null, // "issuer":"HollaEx", // "withdrawal_fees":null, // "created_at":"2019-08-09T10:45:43.367Z", // "updated_at":"2021-12-13T03:08:32.372Z", // "created_by":1, // "owner_id":1 // }, // }, // "network":"https://api.hollaex.network" // } // var coins interface{} = this.SafeDict(response, "coins", map[string]interface{} {}) ch <- this.ParseDepositWithdrawFees(coins, codes, "symbol") return nil }() return ch } func (this *hollaex) NormalizeNumberIfNeeded(number interface{}) interface{} { if IsTrue(this.IsRoundNumber(number)) { number = ParseInt(number) } return number } func (this *hollaex) Sign(path interface{}, optionalArgs ...interface{}) interface{} { api := GetArg(optionalArgs, 0, "public") _ = api method := GetArg(optionalArgs, 1, "GET") _ = method params := GetArg(optionalArgs, 2, map[string]interface{} {}) _ = params headers := GetArg(optionalArgs, 3, nil) _ = headers body := GetArg(optionalArgs, 4, nil) _ = body var query interface{} = this.Omit(params, this.ExtractParams(path)) path = Add(Add(Add("/", this.Version), "/"), this.ImplodeParams(path, params)) if IsTrue(IsTrue((IsEqual(method, "GET"))) || IsTrue((IsEqual(method, "DELETE")))) { if IsTrue(GetArrayLength(ObjectKeys(query))) { path = Add(path, Add("?", this.Urlencode(query))) } } var url interface{} = Add(GetValue(GetValue(this.Urls, "api"), "rest"), path) if IsTrue(IsEqual(api, "private")) { this.CheckRequiredCredentials() var defaultExpires interface{} = this.SafeInteger2(this.Options, "api-expires", "expires", this.ParseToInt(Divide(this.Timeout, 1000))) var expires interface{} = this.Sum(this.Seconds(), defaultExpires) var expiresString interface{} = ToString(expires) var auth interface{} = Add(Add(method, path), expiresString) headers = map[string]interface{} { "api-key": this.ApiKey, "api-expires": expiresString, } if IsTrue(IsEqual(method, "POST")) { AddElementToObject(headers, "Content-type", "application/json") if IsTrue(GetArrayLength(ObjectKeys(query))) { body = this.Json(query) auth = Add(auth, body) } } var signature interface{} = this.Hmac(this.Encode(auth), this.Encode(this.Secret), sha256) AddElementToObject(headers, "api-signature", signature) } return map[string]interface{} { "url": url, "method": method, "body": body, "headers": headers, } } func (this *hollaex) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} { // { "message": "Invalid token" } if IsTrue(IsEqual(response, nil)) { return nil } if IsTrue(IsTrue((IsGreaterThanOrEqual(code, 400))) && IsTrue((IsLessThanOrEqual(code, 503)))) { // // { "message": "Invalid token" } // // different errors return the same code eg // // { "message":"Error 1001 - Order rejected. Order could not be submitted as this order was set to a post only order." } // // { "message":"Error 1001 - POST ONLY order can not be of type market" } // var feedback interface{} = Add(Add(this.Id, " "), body) var message interface{} = this.SafeString(response, "message") this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), message, feedback) var status interface{} = ToString(code) this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), status, feedback) } return nil } func (this *hollaex) Init(userConfig map[string]interface{}) { this.Exchange = Exchange{} this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this) this.Exchange.DerivedExchange = this }