1721 lines
72 KiB
Go
1721 lines
72 KiB
Go
package ccxt
|
|
|
|
// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
|
|
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
|
|
|
|
type indodax struct {
|
|
Exchange
|
|
|
|
}
|
|
|
|
func NewIndodaxCore() indodax {
|
|
p := indodax{}
|
|
setDefaults(&p)
|
|
return p
|
|
}
|
|
|
|
func (this *indodax) Describe() interface{} {
|
|
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
|
|
"id": "indodax",
|
|
"name": "INDODAX",
|
|
"countries": []interface{}{"ID"},
|
|
"rateLimit": 50,
|
|
"has": map[string]interface{} {
|
|
"CORS": nil,
|
|
"spot": true,
|
|
"margin": false,
|
|
"swap": false,
|
|
"future": false,
|
|
"option": false,
|
|
"addMargin": false,
|
|
"cancelAllOrders": false,
|
|
"cancelOrder": true,
|
|
"cancelOrders": false,
|
|
"closeAllPositions": false,
|
|
"closePosition": false,
|
|
"createDepositAddress": false,
|
|
"createOrder": true,
|
|
"createReduceOnlyOrder": false,
|
|
"createStopLimitOrder": false,
|
|
"createStopMarketOrder": false,
|
|
"createStopOrder": false,
|
|
"fetchBalance": true,
|
|
"fetchBorrowRateHistories": false,
|
|
"fetchBorrowRateHistory": false,
|
|
"fetchClosedOrders": true,
|
|
"fetchCrossBorrowRate": false,
|
|
"fetchCrossBorrowRates": false,
|
|
"fetchDeposit": false,
|
|
"fetchDepositAddress": "emulated",
|
|
"fetchDepositAddresses": true,
|
|
"fetchDepositAddressesByNetwork": false,
|
|
"fetchDeposits": false,
|
|
"fetchDepositsWithdrawals": true,
|
|
"fetchFundingHistory": false,
|
|
"fetchFundingRate": false,
|
|
"fetchFundingRateHistory": false,
|
|
"fetchFundingRates": false,
|
|
"fetchIndexOHLCV": false,
|
|
"fetchIsolatedBorrowRate": false,
|
|
"fetchIsolatedBorrowRates": false,
|
|
"fetchLeverage": false,
|
|
"fetchLeverageTiers": false,
|
|
"fetchMarginMode": false,
|
|
"fetchMarkets": true,
|
|
"fetchMarkOHLCV": false,
|
|
"fetchOpenInterestHistory": false,
|
|
"fetchOpenOrders": true,
|
|
"fetchOrder": true,
|
|
"fetchOrderBook": true,
|
|
"fetchOrders": false,
|
|
"fetchPosition": false,
|
|
"fetchPositionHistory": false,
|
|
"fetchPositionMode": false,
|
|
"fetchPositions": false,
|
|
"fetchPositionsForSymbol": false,
|
|
"fetchPositionsHistory": false,
|
|
"fetchPositionsRisk": false,
|
|
"fetchPremiumIndexOHLCV": false,
|
|
"fetchTicker": true,
|
|
"fetchTime": true,
|
|
"fetchTrades": true,
|
|
"fetchTradingFee": false,
|
|
"fetchTradingFees": false,
|
|
"fetchTransactionFee": true,
|
|
"fetchTransactionFees": false,
|
|
"fetchTransactions": "emulated",
|
|
"fetchTransfer": false,
|
|
"fetchTransfers": false,
|
|
"fetchWithdrawal": false,
|
|
"fetchWithdrawals": false,
|
|
"reduceMargin": false,
|
|
"setLeverage": false,
|
|
"setMargin": false,
|
|
"setMarginMode": false,
|
|
"setPositionMode": false,
|
|
"transfer": false,
|
|
"withdraw": true,
|
|
},
|
|
"version": "2.0",
|
|
"urls": map[string]interface{} {
|
|
"logo": "https://user-images.githubusercontent.com/51840849/87070508-9358c880-c221-11ea-8dc5-5391afbbb422.jpg",
|
|
"api": map[string]interface{} {
|
|
"public": "https://indodax.com",
|
|
"private": "https://indodax.com/tapi",
|
|
},
|
|
"www": "https://www.indodax.com",
|
|
"doc": "https://github.com/btcid/indodax-official-api-docs",
|
|
"referral": "https://indodax.com/ref/testbitcoincoid/1",
|
|
},
|
|
"api": map[string]interface{} {
|
|
"public": map[string]interface{} {
|
|
"get": map[string]interface{} {
|
|
"api/server_time": 5,
|
|
"api/pairs": 5,
|
|
"api/price_increments": 5,
|
|
"api/summaries": 5,
|
|
"api/ticker/{pair}": 5,
|
|
"api/ticker_all": 5,
|
|
"api/trades/{pair}": 5,
|
|
"api/depth/{pair}": 5,
|
|
"tradingview/history_v2": 5,
|
|
},
|
|
},
|
|
"private": map[string]interface{} {
|
|
"post": map[string]interface{} {
|
|
"getInfo": 4,
|
|
"transHistory": 4,
|
|
"trade": 1,
|
|
"tradeHistory": 4,
|
|
"openOrders": 4,
|
|
"orderHistory": 4,
|
|
"getOrder": 4,
|
|
"cancelOrder": 4,
|
|
"withdrawFee": 4,
|
|
"withdrawCoin": 4,
|
|
"listDownline": 4,
|
|
"checkDownline": 4,
|
|
"createVoucher": 4,
|
|
},
|
|
},
|
|
},
|
|
"fees": map[string]interface{} {
|
|
"trading": map[string]interface{} {
|
|
"tierBased": false,
|
|
"percentage": true,
|
|
"maker": 0,
|
|
"taker": 0.003,
|
|
},
|
|
},
|
|
"exceptions": map[string]interface{} {
|
|
"exact": map[string]interface{} {
|
|
"invalid_pair": BadSymbol,
|
|
"Insufficient balance.": InsufficientFunds,
|
|
"invalid order.": OrderNotFound,
|
|
"Invalid credentials. API not found or session has expired.": AuthenticationError,
|
|
"Invalid credentials. Bad sign.": AuthenticationError,
|
|
},
|
|
"broad": map[string]interface{} {
|
|
"Minimum price": InvalidOrder,
|
|
"Minimum order": InvalidOrder,
|
|
},
|
|
},
|
|
"options": map[string]interface{} {
|
|
"recvWindow": Multiply(5, 1000),
|
|
"timeDifference": 0,
|
|
"adjustForTimeDifference": false,
|
|
"networks": map[string]interface{} {
|
|
"XLM": "Stellar Token",
|
|
"BSC": "bep20",
|
|
"TRC20": "trc20",
|
|
"MATIC": "polygon",
|
|
},
|
|
"timeframes": map[string]interface{} {
|
|
"1m": "1",
|
|
"15m": "15",
|
|
"30m": "30",
|
|
"1h": "60",
|
|
"4h": "240",
|
|
"1d": "1D",
|
|
"3d": "3D",
|
|
"1w": "1W",
|
|
},
|
|
},
|
|
"features": map[string]interface{} {
|
|
"spot": map[string]interface{} {
|
|
"sandbox": false,
|
|
"createOrder": map[string]interface{} {
|
|
"marginMode": false,
|
|
"triggerPrice": false,
|
|
"triggerPriceType": nil,
|
|
"triggerDirection": false,
|
|
"stopLossPrice": false,
|
|
"takeProfitPrice": false,
|
|
"attachedStopLossTakeProfit": nil,
|
|
"timeInForce": map[string]interface{} {
|
|
"IOC": true,
|
|
"FOK": false,
|
|
"PO": false,
|
|
"GTD": false,
|
|
},
|
|
"hedged": false,
|
|
"selfTradePrevention": false,
|
|
"trailing": false,
|
|
"leverage": false,
|
|
"marketBuyByCost": false,
|
|
"marketBuyRequiresPrice": false,
|
|
"iceberg": false,
|
|
},
|
|
"createOrders": nil,
|
|
"fetchMyTrades": nil,
|
|
"fetchOrder": map[string]interface{} {
|
|
"marginMode": false,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": true,
|
|
},
|
|
"fetchOpenOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": nil,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": false,
|
|
},
|
|
"fetchOrders": nil,
|
|
"fetchClosedOrders": map[string]interface{} {
|
|
"marginMode": false,
|
|
"limit": 1000,
|
|
"daysBack": 100000,
|
|
"daysBackCanceled": 1,
|
|
"untilDays": nil,
|
|
"trigger": false,
|
|
"trailing": false,
|
|
"symbolRequired": true,
|
|
},
|
|
"fetchOHLCV": map[string]interface{} {
|
|
"limit": 2000,
|
|
},
|
|
},
|
|
"swap": map[string]interface{} {
|
|
"linear": nil,
|
|
"inverse": nil,
|
|
},
|
|
"future": map[string]interface{} {
|
|
"linear": nil,
|
|
"inverse": nil,
|
|
},
|
|
},
|
|
"commonCurrencies": map[string]interface{} {
|
|
"STR": "XLM",
|
|
"BCHABC": "BCH",
|
|
"BCHSV": "BSV",
|
|
"DRK": "DASH",
|
|
"NEM": "XEM",
|
|
},
|
|
"precisionMode": TICK_SIZE,
|
|
})
|
|
}
|
|
func (this *indodax) Nonce() interface{} {
|
|
return Subtract(this.Milliseconds(), GetValue(this.Options, "timeDifference"))
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchTime
|
|
* @description fetches the current integer timestamp in milliseconds from the exchange server
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Public-RestAPI.md#server-time
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {int} the current integer timestamp in milliseconds from the exchange server
|
|
*/
|
|
func (this *indodax) FetchTime(optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
params := GetArg(optionalArgs, 0, map[string]interface{} {})
|
|
_ = params
|
|
|
|
response:= (<-this.PublicGetApiServerTime(params))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "timezone": "UTC",
|
|
// "server_time": 1571205969552
|
|
// }
|
|
//
|
|
ch <- this.SafeInteger(response, "server_time")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchMarkets
|
|
* @description retrieves data on all markets for indodax
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Public-RestAPI.md#pairs
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object[]} an array of objects representing market data
|
|
*/
|
|
func (this *indodax) 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.PublicGetApiPairs(params))
|
|
PanicOnError(response)
|
|
//
|
|
// [
|
|
// {
|
|
// "id": "btcidr",
|
|
// "symbol": "BTCIDR",
|
|
// "base_currency": "idr",
|
|
// "traded_currency": "btc",
|
|
// "traded_currency_unit": "BTC",
|
|
// "description": "BTC/IDR",
|
|
// "ticker_id": "btc_idr",
|
|
// "volume_precision": 0,
|
|
// "price_precision": 1000,
|
|
// "price_round": 8,
|
|
// "pricescale": 1000,
|
|
// "trade_min_base_currency": 10000,
|
|
// "trade_min_traded_currency": 0.00007457,
|
|
// "has_memo": false,
|
|
// "memo_name": false,
|
|
// "has_payment_id": false,
|
|
// "trade_fee_percent": 0.3,
|
|
// "url_logo": "https://indodax.com/v2/logo/svg/color/btc.svg",
|
|
// "url_logo_png": "https://indodax.com/v2/logo/png/color/btc.png",
|
|
// "is_maintenance": 0
|
|
// }
|
|
// ]
|
|
//
|
|
var result interface{} = []interface{}{}
|
|
for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
|
|
var market interface{} = GetValue(response, i)
|
|
var id interface{} = this.SafeString(market, "ticker_id")
|
|
var baseId interface{} = this.SafeString(market, "traded_currency")
|
|
var quoteId interface{} = this.SafeString(market, "base_currency")
|
|
var base interface{} = this.SafeCurrencyCode(baseId)
|
|
var quote interface{} = this.SafeCurrencyCode(quoteId)
|
|
var isMaintenance interface{} = this.SafeInteger(market, "is_maintenance")
|
|
AppendToArray(&result,map[string]interface{} {
|
|
"id": id,
|
|
"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": Ternary(IsTrue(isMaintenance), false, true),
|
|
"contract": false,
|
|
"linear": nil,
|
|
"inverse": nil,
|
|
"taker": this.SafeNumber(market, "trade_fee_percent"),
|
|
"contractSize": nil,
|
|
"expiry": nil,
|
|
"expiryDatetime": nil,
|
|
"strike": nil,
|
|
"optionType": nil,
|
|
"percentage": true,
|
|
"precision": map[string]interface{} {
|
|
"amount": this.ParseNumber("1e-8"),
|
|
"price": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "price_round"))),
|
|
"cost": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "volume_precision"))),
|
|
},
|
|
"limits": map[string]interface{} {
|
|
"leverage": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
"amount": map[string]interface{} {
|
|
"min": this.SafeNumber(market, "trade_min_traded_currency"),
|
|
"max": nil,
|
|
},
|
|
"price": map[string]interface{} {
|
|
"min": this.SafeNumber(market, "trade_min_base_currency"),
|
|
"max": nil,
|
|
},
|
|
"cost": map[string]interface{} {
|
|
"min": nil,
|
|
"max": nil,
|
|
},
|
|
},
|
|
"created": nil,
|
|
"info": market,
|
|
})
|
|
}
|
|
|
|
ch <- result
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) ParseBalance(response interface{}) interface{} {
|
|
var balances interface{} = this.SafeValue(response, "return", map[string]interface{} {})
|
|
var free interface{} = this.SafeValue(balances, "balance", map[string]interface{} {})
|
|
var used interface{} = this.SafeValue(balances, "balance_hold", map[string]interface{} {})
|
|
var timestamp interface{} = this.SafeTimestamp(balances, "server_time")
|
|
var result interface{} = map[string]interface{} {
|
|
"info": response,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
}
|
|
var currencyIds interface{} = ObjectKeys(free)
|
|
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(free, currencyId))
|
|
AddElementToObject(account, "used", this.SafeString(used, currencyId))
|
|
AddElementToObject(result, code, account)
|
|
}
|
|
return this.SafeBalance(result)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchBalance
|
|
* @description query for balance and get the amount of funds available for trading or funds locked in orders
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#get-info-endpoint
|
|
* @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 *indodax) 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
|
|
|
|
retRes4298 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes4298)
|
|
|
|
response:= (<-this.PrivatePostGetInfo(params))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "success":1,
|
|
// "return":{
|
|
// "server_time":1619562628,
|
|
// "balance":{
|
|
// "idr":167,
|
|
// "btc":"0.00000000",
|
|
// "1inch":"0.00000000",
|
|
// },
|
|
// "balance_hold":{
|
|
// "idr":0,
|
|
// "btc":"0.00000000",
|
|
// "1inch":"0.00000000",
|
|
// },
|
|
// "address":{
|
|
// "btc":"1KMntgzvU7iTSgMBWc11nVuJjAyfW3qJyk",
|
|
// "1inch":"0x1106c8bb3172625e1f411c221be49161dac19355",
|
|
// "xrp":"rwWr7KUZ3ZFwzgaDGjKBysADByzxvohQ3C",
|
|
// "zrx":"0x1106c8bb3172625e1f411c221be49161dac19355"
|
|
// },
|
|
// "user_id":"276011",
|
|
// "name":"",
|
|
// "email":"testbitcoincoid@mailforspam.com",
|
|
// "profile_picture":null,
|
|
// "verification_status":"unverified",
|
|
// "gauth_enable":true
|
|
// }
|
|
// }
|
|
//
|
|
ch <- this.ParseBalance(response)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchOrderBook
|
|
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Public-RestAPI.md#depth
|
|
* @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 *indodax) 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
|
|
|
|
retRes4758 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes4758)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"pair": Add(GetValue(market, "base"), GetValue(market, "quote")),
|
|
}
|
|
|
|
orderbook:= (<-this.PublicGetApiDepthPair(this.Extend(request, params)))
|
|
PanicOnError(orderbook)
|
|
|
|
ch <- this.ParseOrderBook(orderbook, GetValue(market, "symbol"), nil, "buy", "sell")
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "high":"0.01951",
|
|
// "low":"0.01877",
|
|
// "vol_eth":"39.38839319",
|
|
// "vol_btc":"0.75320886",
|
|
// "last":"0.01896",
|
|
// "buy":"0.01896",
|
|
// "sell":"0.019",
|
|
// "server_time":1565248908
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var symbol interface{} = this.SafeSymbol(nil, market)
|
|
var timestamp interface{} = this.SafeTimestamp(ticker, "server_time")
|
|
var baseVolume interface{} = Add("vol_", ToLower(GetValue(market, "baseId")))
|
|
var quoteVolume interface{} = Add("vol_", ToLower(GetValue(market, "quoteId")))
|
|
var last interface{} = this.SafeString(ticker, "last")
|
|
return this.SafeTicker(map[string]interface{} {
|
|
"symbol": symbol,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"high": this.SafeString(ticker, "high"),
|
|
"low": this.SafeString(ticker, "low"),
|
|
"bid": this.SafeString(ticker, "buy"),
|
|
"bidVolume": nil,
|
|
"ask": this.SafeString(ticker, "sell"),
|
|
"askVolume": nil,
|
|
"vwap": nil,
|
|
"open": nil,
|
|
"close": last,
|
|
"last": last,
|
|
"previousClose": nil,
|
|
"change": nil,
|
|
"percentage": nil,
|
|
"average": nil,
|
|
"baseVolume": this.SafeString(ticker, baseVolume),
|
|
"quoteVolume": this.SafeString(ticker, quoteVolume),
|
|
"info": ticker,
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchTicker
|
|
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Public-RestAPI.md#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 *indodax) 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
|
|
|
|
retRes5368 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes5368)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"pair": Add(GetValue(market, "base"), GetValue(market, "quote")),
|
|
}
|
|
|
|
response:= (<-this.PublicGetApiTickerPair(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "ticker": {
|
|
// "high":"0.01951",
|
|
// "low":"0.01877",
|
|
// "vol_eth":"39.38839319",
|
|
// "vol_btc":"0.75320886",
|
|
// "last":"0.01896",
|
|
// "buy":"0.01896",
|
|
// "sell":"0.019",
|
|
// "server_time":1565248908
|
|
// }
|
|
// }
|
|
//
|
|
var ticker interface{} = this.SafeDict(response, "ticker", map[string]interface{} {})
|
|
|
|
ch <- this.ParseTicker(ticker, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchTickers
|
|
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Public-RestAPI.md#ticker-all
|
|
* @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 *indodax) 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
|
|
|
|
retRes5708 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes5708)
|
|
//
|
|
// {
|
|
// "tickers": {
|
|
// "btc_idr": {
|
|
// "high": "120009000",
|
|
// "low": "116735000",
|
|
// "vol_btc": "218.13777777",
|
|
// "vol_idr": "25800033297",
|
|
// "last": "117088000",
|
|
// "buy": "117002000",
|
|
// "sell": "117078000",
|
|
// "server_time": 1571207881
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
|
|
response:= (<-this.PublicGetApiTickerAll(params))
|
|
PanicOnError(response)
|
|
var tickers interface{} = this.SafeDict(response, "tickers", map[string]interface{} {})
|
|
|
|
ch <- this.ParseTickers(tickers, symbols)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var timestamp interface{} = this.SafeTimestamp(trade, "date")
|
|
return this.SafeTrade(map[string]interface{} {
|
|
"id": this.SafeString(trade, "tid"),
|
|
"info": trade,
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"symbol": this.SafeSymbol(nil, market),
|
|
"type": nil,
|
|
"side": this.SafeString(trade, "type"),
|
|
"order": nil,
|
|
"takerOrMaker": nil,
|
|
"price": this.SafeString(trade, "price"),
|
|
"amount": this.SafeString(trade, "amount"),
|
|
"cost": nil,
|
|
"fee": nil,
|
|
}, market)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchTrades
|
|
* @description get the list of most recent trades for a particular symbol
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Public-RestAPI.md#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 *indodax) 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
|
|
|
|
retRes6238 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes6238)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"pair": Add(GetValue(market, "base"), GetValue(market, "quote")),
|
|
}
|
|
|
|
response:= (<-this.PublicGetApiTradesPair(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
ch <- this.ParseTrades(response, market, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "Time": 1708416900,
|
|
// "Open": 51707.52,
|
|
// "High": 51707.52,
|
|
// "Low": 51707.52,
|
|
// "Close": 51707.52,
|
|
// "Volume": "0"
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
return []interface{}{this.SafeTimestamp(ohlcv, "Time"), this.SafeNumber(ohlcv, "Open"), this.SafeNumber(ohlcv, "High"), this.SafeNumber(ohlcv, "Low"), this.SafeNumber(ohlcv, "Close"), this.SafeNumber(ohlcv, "Volume")}
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchOHLCV
|
|
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
|
|
* @param {string} symbol unified symbol of the market to fetch OHLCV data for
|
|
* @param {string} timeframe the length of time each candle represents
|
|
* @param {int} [since] timestamp in ms of the earliest candle to fetch
|
|
* @param {int} [limit] 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 *indodax) 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
|
|
|
|
retRes6668 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes6668)
|
|
var market interface{} = this.Market(symbol)
|
|
var timeframes interface{} = GetValue(this.Options, "timeframes")
|
|
var selectedTimeframe interface{} = this.SafeString(timeframes, timeframe, timeframe)
|
|
var now interface{} = this.Seconds()
|
|
var until interface{} = this.SafeInteger(params, "until", now)
|
|
params = this.Omit(params, []interface{}{"until"})
|
|
var request interface{} = map[string]interface{} {
|
|
"to": until,
|
|
"tf": selectedTimeframe,
|
|
"symbol": Add(GetValue(market, "base"), GetValue(market, "quote")),
|
|
}
|
|
if IsTrue(IsEqual(limit, nil)) {
|
|
limit = 1000
|
|
}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
AddElementToObject(request, "from", MathFloor(Divide(since, 1000)))
|
|
} else {
|
|
var duration interface{} = this.ParseTimeframe(timeframe)
|
|
AddElementToObject(request, "from", Subtract(Subtract(now, Multiply(limit, duration)), 1))
|
|
}
|
|
|
|
response:= (<-this.PublicGetTradingviewHistoryV2(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// [
|
|
// {
|
|
// "Time": 1708416900,
|
|
// "Open": 51707.52,
|
|
// "High": 51707.52,
|
|
// "Low": 51707.52,
|
|
// "Close": 51707.52,
|
|
// "Volume": "0"
|
|
// }
|
|
// ]
|
|
//
|
|
ch <- this.ParseOHLCVs(response, market, timeframe, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) ParseOrderStatus(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"open": "open",
|
|
"filled": "closed",
|
|
"cancelled": "canceled",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
func (this *indodax) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// {
|
|
// "order_id": "12345",
|
|
// "submit_time": "1392228122",
|
|
// "price": "8000000",
|
|
// "type": "sell",
|
|
// "order_ltc": "100000000",
|
|
// "remain_ltc": "100000000"
|
|
// }
|
|
//
|
|
// market closed orders - note that the price is very high
|
|
// and does not reflect actual price the order executed at
|
|
//
|
|
// {
|
|
// "order_id": "49326856",
|
|
// "type": "sell",
|
|
// "price": "1000000000",
|
|
// "submit_time": "1618314671",
|
|
// "finish_time": "1618314671",
|
|
// "status": "filled",
|
|
// "order_xrp": "30.45000000",
|
|
// "remain_xrp": "0.00000000"
|
|
// }
|
|
//
|
|
// cancelOrder
|
|
//
|
|
// {
|
|
// "order_id": 666883,
|
|
// "client_order_id": "clientx-sj82ks82j",
|
|
// "type": "sell",
|
|
// "pair": "btc_idr",
|
|
// "balance": {
|
|
// "idr": "33605800",
|
|
// "btc": "0.00000000",
|
|
// ...
|
|
// "frozen_idr": "0",
|
|
// "frozen_btc": "0.00000000",
|
|
// ...
|
|
// }
|
|
// }
|
|
//
|
|
market := GetArg(optionalArgs, 0, nil)
|
|
_ = market
|
|
var side interface{} = nil
|
|
if IsTrue(InOp(order, "type")) {
|
|
side = GetValue(order, "type")
|
|
}
|
|
var status interface{} = this.ParseOrderStatus(this.SafeString(order, "status", "open"))
|
|
var symbol interface{} = nil
|
|
var cost interface{} = nil
|
|
var price interface{} = this.SafeString(order, "price")
|
|
var amount interface{} = nil
|
|
var remaining interface{} = nil
|
|
var marketId interface{} = this.SafeString(order, "pair")
|
|
market = this.SafeMarket(marketId, market)
|
|
if IsTrue(!IsEqual(market, nil)) {
|
|
symbol = GetValue(market, "symbol")
|
|
var quoteId interface{} = GetValue(market, "quoteId")
|
|
var baseId interface{} = GetValue(market, "baseId")
|
|
if IsTrue(IsTrue((IsEqual(GetValue(market, "quoteId"), "idr"))) && IsTrue((InOp(order, "order_rp")))) {
|
|
quoteId = "rp"
|
|
}
|
|
if IsTrue(IsTrue((IsEqual(GetValue(market, "baseId"), "idr"))) && IsTrue((InOp(order, "remain_rp")))) {
|
|
baseId = "rp"
|
|
}
|
|
cost = this.SafeString(order, Add("order_", quoteId))
|
|
if !IsTrue(cost) {
|
|
amount = this.SafeString(order, Add("order_", baseId))
|
|
remaining = this.SafeString(order, Add("remain_", baseId))
|
|
}
|
|
}
|
|
var timestamp interface{} = this.SafeInteger(order, "submit_time")
|
|
var fee interface{} = nil
|
|
var id interface{} = this.SafeString(order, "order_id")
|
|
return this.SafeOrder(map[string]interface{} {
|
|
"info": order,
|
|
"id": id,
|
|
"clientOrderId": this.SafeString(order, "client_order_id"),
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"lastTradeTimestamp": nil,
|
|
"symbol": symbol,
|
|
"type": "limit",
|
|
"timeInForce": nil,
|
|
"postOnly": nil,
|
|
"side": side,
|
|
"price": price,
|
|
"triggerPrice": nil,
|
|
"cost": cost,
|
|
"average": nil,
|
|
"amount": amount,
|
|
"filled": nil,
|
|
"remaining": remaining,
|
|
"status": status,
|
|
"fee": fee,
|
|
"trades": nil,
|
|
})
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchOrder
|
|
* @description fetches information on an order made by the user
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#get-order-endpoints
|
|
* @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 *indodax) 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
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchOrder() requires a symbol argument")))
|
|
}
|
|
|
|
retRes8248 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes8248)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"pair": GetValue(market, "id"),
|
|
"order_id": id,
|
|
}
|
|
|
|
response:= (<-this.PrivatePostGetOrder(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
var orders interface{} = GetValue(response, "return")
|
|
var order interface{} = this.ParseOrder(this.Extend(map[string]interface{} {
|
|
"id": id,
|
|
}, GetValue(orders, "order")), market)
|
|
AddElementToObject(order, "info", response)
|
|
|
|
ch <- order
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchOpenOrders
|
|
* @description fetch all unfilled currently open orders
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#open-orders-endpoints
|
|
* @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 *indodax) 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
|
|
|
|
retRes8498 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes8498)
|
|
var market interface{} = nil
|
|
var request interface{} = map[string]interface{} {}
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
market = this.Market(symbol)
|
|
AddElementToObject(request, "pair", GetValue(market, "id"))
|
|
}
|
|
|
|
response:= (<-this.PrivatePostOpenOrders(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
var rawOrders interface{} = GetValue(GetValue(response, "return"), "orders")
|
|
// { success: 1, return: { orders: null }} if no orders
|
|
if !IsTrue(rawOrders) {
|
|
|
|
ch <- []interface{}{}
|
|
return nil
|
|
}
|
|
// { success: 1, return: { orders: [ ... objects ] }} for orders fetched by symbol
|
|
if IsTrue(!IsEqual(symbol, nil)) {
|
|
|
|
ch <- this.ParseOrders(rawOrders, market, since, limit)
|
|
return nil
|
|
}
|
|
// { success: 1, return: { orders: { marketid: [ ... objects ] }}} if all orders are fetched
|
|
var marketIds interface{} = ObjectKeys(rawOrders)
|
|
var exchangeOrders interface{} = []interface{}{}
|
|
for i := 0; IsLessThan(i, GetArrayLength(marketIds)); i++ {
|
|
var marketId interface{} = GetValue(marketIds, i)
|
|
var marketOrders interface{} = GetValue(rawOrders, marketId)
|
|
market = this.SafeMarket(marketId)
|
|
var parsedOrders interface{} = this.ParseOrders(marketOrders, market, since, limit)
|
|
exchangeOrders = this.ArrayConcat(exchangeOrders, parsedOrders)
|
|
}
|
|
|
|
ch <- exchangeOrders
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchClosedOrders
|
|
* @description fetches information on multiple closed orders made by the user
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#order-history
|
|
* @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 *indodax) 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(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " fetchClosedOrders() requires a symbol argument")))
|
|
}
|
|
|
|
retRes8948 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes8948)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"pair": GetValue(market, "id"),
|
|
}
|
|
|
|
response:= (<-this.PrivatePostOrderHistory(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
var orders interface{} = this.ParseOrders(GetValue(GetValue(response, "return"), "orders"), market)
|
|
orders = this.FilterBy(orders, "status", "closed")
|
|
|
|
ch <- this.FilterBySymbolSinceLimit(orders, symbol, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#createOrder
|
|
* @description create a trade order
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#trade-endpoints
|
|
* @param {string} symbol unified symbol of the market to create an order in
|
|
* @param {string} type 'market' or 'limit'
|
|
* @param {string} side 'buy' or 'sell'
|
|
* @param {float} amount how much of currency you want to trade in units of base currency
|
|
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
|
|
*/
|
|
func (this *indodax) 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
|
|
|
|
retRes9198 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes9198)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"pair": GetValue(market, "id"),
|
|
"type": side,
|
|
"price": price,
|
|
}
|
|
var priceIsRequired interface{} = false
|
|
var quantityIsRequired interface{} = false
|
|
if IsTrue(IsEqual(typeVar, "market")) {
|
|
if IsTrue(IsEqual(side, "buy")) {
|
|
var quoteAmount interface{} = nil
|
|
var cost interface{} = this.SafeNumber(params, "cost")
|
|
params = this.Omit(params, "cost")
|
|
if IsTrue(!IsEqual(cost, nil)) {
|
|
quoteAmount = this.CostToPrecision(symbol, cost)
|
|
} else {
|
|
if IsTrue(IsEqual(price, nil)) {
|
|
panic(InvalidOrder(Add(this.Id, " createOrder() requires the price argument for market buy orders to calculate the total cost to spend (amount * price).")))
|
|
}
|
|
var amountString interface{} = this.NumberToString(amount)
|
|
var priceString interface{} = this.NumberToString(price)
|
|
var costRequest interface{} = Precise.StringMul(amountString, priceString)
|
|
quoteAmount = this.CostToPrecision(symbol, costRequest)
|
|
}
|
|
AddElementToObject(request, GetValue(market, "quoteId"), quoteAmount)
|
|
} else {
|
|
quantityIsRequired = true
|
|
}
|
|
} else if IsTrue(IsEqual(typeVar, "limit")) {
|
|
priceIsRequired = true
|
|
quantityIsRequired = true
|
|
if IsTrue(IsEqual(side, "buy")) {
|
|
AddElementToObject(request, GetValue(market, "quoteId"), this.ParseToNumeric(Precise.StringMul(this.NumberToString(amount), this.NumberToString(price))))
|
|
}
|
|
}
|
|
if IsTrue(priceIsRequired) {
|
|
if IsTrue(IsEqual(price, nil)) {
|
|
panic(InvalidOrder(Add(Add(Add(this.Id, " createOrder() requires a price argument for a "), typeVar), " order")))
|
|
}
|
|
AddElementToObject(request, "price", price)
|
|
}
|
|
if IsTrue(quantityIsRequired) {
|
|
AddElementToObject(request, GetValue(market, "baseId"), this.AmountToPrecision(symbol, amount))
|
|
}
|
|
|
|
result:= (<-this.PrivatePostTrade(this.Extend(request, params)))
|
|
PanicOnError(result)
|
|
var data interface{} = this.SafeValue(result, "return", map[string]interface{} {})
|
|
var id interface{} = this.SafeString(data, "order_id")
|
|
|
|
ch <- this.SafeOrder(map[string]interface{} {
|
|
"info": result,
|
|
"id": id,
|
|
}, market)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#cancelOrder
|
|
* @description cancels an open order
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#cancel-order-endpoints
|
|
* @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 *indodax) CancelOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
|
|
ch := make(chan interface{})
|
|
go func() interface{} {
|
|
defer close(ch)
|
|
defer ReturnPanicError(ch)
|
|
symbol := GetArg(optionalArgs, 0, nil)
|
|
_ = symbol
|
|
params := GetArg(optionalArgs, 1, map[string]interface{} {})
|
|
_ = params
|
|
if IsTrue(IsEqual(symbol, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument")))
|
|
}
|
|
var side interface{} = this.SafeValue(params, "side")
|
|
if IsTrue(IsEqual(side, nil)) {
|
|
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires an extra \"side\" param")))
|
|
}
|
|
|
|
retRes9918 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes9918)
|
|
var market interface{} = this.Market(symbol)
|
|
var request interface{} = map[string]interface{} {
|
|
"order_id": id,
|
|
"pair": GetValue(market, "id"),
|
|
"type": side,
|
|
}
|
|
|
|
response:= (<-this.PrivatePostCancelOrder(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "success": 1,
|
|
// "return": {
|
|
// "order_id": 666883,
|
|
// "client_order_id": "clientx-sj82ks82j",
|
|
// "type": "sell",
|
|
// "pair": "btc_idr",
|
|
// "balance": {
|
|
// "idr": "33605800",
|
|
// "btc": "0.00000000",
|
|
// ...
|
|
// "frozen_idr": "0",
|
|
// "frozen_btc": "0.00000000",
|
|
// ...
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "return")
|
|
|
|
ch <- this.ParseOrder(data)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchTransactionFee
|
|
* @description fetch the fee for a transaction
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#withdraw-fee-endpoints
|
|
* @param {string} code unified currency code
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
|
|
*/
|
|
func (this *indodax) 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
|
|
|
|
retRes10328 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes10328)
|
|
var currency interface{} = this.Currency(code)
|
|
var request interface{} = map[string]interface{} {
|
|
"currency": GetValue(currency, "id"),
|
|
}
|
|
|
|
response:= (<-this.PrivatePostWithdrawFee(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "success": 1,
|
|
// "return": {
|
|
// "server_time": 1607923272,
|
|
// "withdraw_fee": 0.005,
|
|
// "currency": "eth"
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeValue(response, "return", map[string]interface{} {})
|
|
var currencyId interface{} = this.SafeString(data, "currency")
|
|
|
|
ch <- map[string]interface{} {
|
|
"info": response,
|
|
"rate": this.SafeNumber(data, "withdraw_fee"),
|
|
"currency": this.SafeCurrencyCode(currencyId, currency),
|
|
}
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchDepositsWithdrawals
|
|
* @description fetch history of deposits and withdrawals
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#transaction-history-endpoints
|
|
* @param {string} [code] unified currency code for the currency of the deposit/withdrawals, default is undefined
|
|
* @param {int} [since] timestamp in ms of the earliest deposit/withdrawal, default is undefined
|
|
* @param {int} [limit] max number of deposit/withdrawals to return, default is undefined
|
|
* @param {object} [params] extra parameters specific to the exchange API endpoint
|
|
* @returns {object} a list of [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
|
|
*/
|
|
func (this *indodax) 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
|
|
|
|
retRes10698 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes10698)
|
|
var request interface{} = map[string]interface{} {}
|
|
if IsTrue(!IsEqual(since, nil)) {
|
|
var startTime interface{} = Slice(this.Iso8601(since), 0, 10)
|
|
AddElementToObject(request, "start", startTime)
|
|
AddElementToObject(request, "end", Slice(this.Iso8601(this.Milliseconds()), 0, 10))
|
|
}
|
|
|
|
response:= (<-this.PrivatePostTransHistory(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// "success": 1,
|
|
// "return": {
|
|
// "withdraw": {
|
|
// "idr": [
|
|
// {
|
|
// "status": "success",
|
|
// "type": "coupon",
|
|
// "rp": "115205",
|
|
// "fee": "500",
|
|
// "amount": "114705",
|
|
// "submit_time": "1539844166",
|
|
// "success_time": "1539844189",
|
|
// "withdraw_id": "1783717",
|
|
// "tx": "BTC-IDR-RDTVVO2P-ETD0EVAW-VTNZGMIR-HTNTUAPI-84ULM9OI",
|
|
// "sender": "boris",
|
|
// "used_by": "viginia88"
|
|
// },
|
|
// ...
|
|
// ],
|
|
// "btc": [],
|
|
// "abyss": [],
|
|
// ...
|
|
// },
|
|
// "deposit": {
|
|
// "idr": [
|
|
// {
|
|
// "status": "success",
|
|
// "type": "duitku",
|
|
// "rp": "393000",
|
|
// "fee": "5895",
|
|
// "amount": "387105",
|
|
// "submit_time": "1576555012",
|
|
// "success_time": "1576555012",
|
|
// "deposit_id": "3395438",
|
|
// "tx": "Duitku OVO Settlement"
|
|
// },
|
|
// ...
|
|
// ],
|
|
// "btc": [
|
|
// {
|
|
// "status": "success",
|
|
// "btc": "0.00118769",
|
|
// "amount": "0.00118769",
|
|
// "success_time": "1539529208",
|
|
// "deposit_id": "3602369",
|
|
// "tx": "c816aeb35a5b42f389970325a32aff69bb6b2126784dcda8f23b9dd9570d6573"
|
|
// },
|
|
// ...
|
|
// ],
|
|
// "abyss": [],
|
|
// ...
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeValue(response, "return", map[string]interface{} {})
|
|
var withdraw interface{} = this.SafeValue(data, "withdraw", map[string]interface{} {})
|
|
var deposit interface{} = this.SafeValue(data, "deposit", map[string]interface{} {})
|
|
var transactions interface{} = []interface{}{}
|
|
var currency interface{} = nil
|
|
if IsTrue(IsEqual(code, nil)) {
|
|
var keys interface{} = ObjectKeys(withdraw)
|
|
for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
|
|
var key interface{} = GetValue(keys, i)
|
|
transactions = this.ArrayConcat(transactions, GetValue(withdraw, key))
|
|
}
|
|
keys = ObjectKeys(deposit)
|
|
for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
|
|
var key interface{} = GetValue(keys, i)
|
|
transactions = this.ArrayConcat(transactions, GetValue(deposit, key))
|
|
}
|
|
} else {
|
|
currency = this.Currency(code)
|
|
var withdraws interface{} = this.SafeValue(withdraw, GetValue(currency, "id"), []interface{}{})
|
|
var deposits interface{} = this.SafeValue(deposit, GetValue(currency, "id"), []interface{}{})
|
|
transactions = this.ArrayConcat(withdraws, deposits)
|
|
}
|
|
|
|
ch <- this.ParseTransactions(transactions, currency, since, limit)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#withdraw
|
|
* @description make a withdrawal
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#withdraw-coin-endpoints
|
|
* @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 *indodax) 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)
|
|
|
|
retRes11748 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes11748)
|
|
var currency interface{} = this.Currency(code)
|
|
// Custom string you need to provide to identify each withdrawal.
|
|
// Will be passed to callback URL (assigned via website to the API key)
|
|
// so your system can identify the request and confirm it.
|
|
// Alphanumeric, max length 255.
|
|
var requestId interface{} = this.Milliseconds()
|
|
// Alternatively:
|
|
// let requestId = this.uuid ();
|
|
var request interface{} = map[string]interface{} {
|
|
"currency": GetValue(currency, "id"),
|
|
"withdraw_amount": amount,
|
|
"withdraw_address": address,
|
|
"request_id": ToString(requestId),
|
|
}
|
|
if IsTrue(tag) {
|
|
AddElementToObject(request, "withdraw_memo", tag)
|
|
}
|
|
|
|
response:= (<-this.PrivatePostWithdrawCoin(this.Extend(request, params)))
|
|
PanicOnError(response)
|
|
|
|
//
|
|
// {
|
|
// "success": 1,
|
|
// "status": "approved",
|
|
// "withdraw_currency": "xrp",
|
|
// "withdraw_address": "rwWr7KUZ3ZFwzgaDGjKBysADByzxvohQ3C",
|
|
// "withdraw_amount": "10000.00000000",
|
|
// "fee": "2.00000000",
|
|
// "amount_after_fee": "9998.00000000",
|
|
// "submit_time": "1509469200",
|
|
// "withdraw_id": "xrp-12345",
|
|
// "txid": "",
|
|
// "withdraw_memo": "123123"
|
|
// }
|
|
//
|
|
ch <- this.ParseTransaction(response, currency)
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
|
|
//
|
|
// withdraw
|
|
//
|
|
// {
|
|
// "success": 1,
|
|
// "status": "approved",
|
|
// "withdraw_currency": "xrp",
|
|
// "withdraw_address": "rwWr7KUZ3ZFwzgaDGjKBysADByzxvohQ3C",
|
|
// "withdraw_amount": "10000.00000000",
|
|
// "fee": "2.00000000",
|
|
// "amount_after_fee": "9998.00000000",
|
|
// "submit_time": "1509469200",
|
|
// "withdraw_id": "xrp-12345",
|
|
// "txid": "",
|
|
// "withdraw_memo": "123123"
|
|
// }
|
|
//
|
|
// transHistory
|
|
//
|
|
// {
|
|
// "status": "success",
|
|
// "type": "coupon",
|
|
// "rp": "115205",
|
|
// "fee": "500",
|
|
// "amount": "114705",
|
|
// "submit_time": "1539844166",
|
|
// "success_time": "1539844189",
|
|
// "withdraw_id": "1783717",
|
|
// "tx": "BTC-IDR-RDTVVO2P-ETD0EVAW-VTNZGMIR-HTNTUAPI-84ULM9OI",
|
|
// "sender": "boris",
|
|
// "used_by": "viginia88"
|
|
// }
|
|
//
|
|
// {
|
|
// "status": "success",
|
|
// "btc": "0.00118769",
|
|
// "amount": "0.00118769",
|
|
// "success_time": "1539529208",
|
|
// "deposit_id": "3602369",
|
|
// "tx": "c816aeb35a5b42f389970325a32aff69bb6b2126784dcda8f23b9dd9570d6573"
|
|
// },
|
|
currency := GetArg(optionalArgs, 0, nil)
|
|
_ = currency
|
|
var status interface{} = this.SafeString(transaction, "status")
|
|
var timestamp interface{} = this.SafeTimestamp2(transaction, "success_time", "submit_time")
|
|
var depositId interface{} = this.SafeString(transaction, "deposit_id")
|
|
var feeCost interface{} = this.SafeNumber(transaction, "fee")
|
|
var fee interface{} = nil
|
|
if IsTrue(!IsEqual(feeCost, nil)) {
|
|
fee = map[string]interface{} {
|
|
"currency": this.SafeCurrencyCode(nil, currency),
|
|
"cost": feeCost,
|
|
"rate": nil,
|
|
}
|
|
}
|
|
return map[string]interface{} {
|
|
"id": this.SafeString2(transaction, "withdraw_id", "deposit_id"),
|
|
"txid": this.SafeString2(transaction, "txid", "tx"),
|
|
"timestamp": timestamp,
|
|
"datetime": this.Iso8601(timestamp),
|
|
"network": nil,
|
|
"addressFrom": nil,
|
|
"address": this.SafeString(transaction, "withdraw_address"),
|
|
"addressTo": nil,
|
|
"amount": this.SafeNumberN(transaction, []interface{}{"amount", "withdraw_amount", "deposit_amount"}),
|
|
"type": Ternary(IsTrue((IsEqual(depositId, nil))), "withdraw", "deposit"),
|
|
"currency": this.SafeCurrencyCode(nil, currency),
|
|
"status": this.ParseTransactionStatus(status),
|
|
"updated": nil,
|
|
"tagFrom": nil,
|
|
"tag": nil,
|
|
"tagTo": nil,
|
|
"comment": this.SafeString(transaction, "withdraw_memo"),
|
|
"internal": nil,
|
|
"fee": fee,
|
|
"info": transaction,
|
|
}
|
|
}
|
|
func (this *indodax) ParseTransactionStatus(status interface{}) interface{} {
|
|
var statuses interface{} = map[string]interface{} {
|
|
"success": "ok",
|
|
}
|
|
return this.SafeString(statuses, status, status)
|
|
}
|
|
/**
|
|
* @method
|
|
* @name indodax#fetchDepositAddresses
|
|
* @description fetch deposit addresses for multiple currencies and chain types
|
|
* @see https://github.com/btcid/indodax-official-api-docs/blob/master/Private-RestAPI.md#general-information-on-endpoints
|
|
* @param {string[]} [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 *indodax) 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
|
|
|
|
retRes13068 := (<-this.LoadMarkets())
|
|
PanicOnError(retRes13068)
|
|
|
|
response:= (<-this.PrivatePostGetInfo(params))
|
|
PanicOnError(response)
|
|
//
|
|
// {
|
|
// success: '1',
|
|
// return: {
|
|
// server_time: '1708031570',
|
|
// balance: {
|
|
// idr: '29952',
|
|
// ...
|
|
// },
|
|
// balance_hold: {
|
|
// idr: '0',
|
|
// ...
|
|
// },
|
|
// address: {
|
|
// btc: '1KMntgzvU7iTSgMBWc11nVuJjAyfW3qJyk',
|
|
// ...
|
|
// },
|
|
// memo_is_required: {
|
|
// btc: { mainnet: false },
|
|
// ...
|
|
// },
|
|
// network: {
|
|
// btc: 'mainnet',
|
|
// ...
|
|
// },
|
|
// user_id: '276011',
|
|
// name: '',
|
|
// email: 'testbitcoincoid@mailforspam.com',
|
|
// profile_picture: null,
|
|
// verification_status: 'unverified',
|
|
// gauth_enable: true,
|
|
// withdraw_status: '0'
|
|
// }
|
|
// }
|
|
//
|
|
var data interface{} = this.SafeDict(response, "return")
|
|
var addresses interface{} = this.SafeDict(data, "address", map[string]interface{} {})
|
|
var networks interface{} = this.SafeDict(data, "network", map[string]interface{} {})
|
|
var addressKeys interface{} = ObjectKeys(addresses)
|
|
var result interface{} = map[string]interface{} {
|
|
"info": data,
|
|
}
|
|
for i := 0; IsLessThan(i, GetArrayLength(addressKeys)); i++ {
|
|
var marketId interface{} = GetValue(addressKeys, i)
|
|
var code interface{} = this.SafeCurrencyCode(marketId)
|
|
var address interface{} = this.SafeString(addresses, marketId)
|
|
if IsTrue(IsTrue((!IsEqual(address, nil))) && IsTrue((IsTrue((IsEqual(codes, nil))) || IsTrue((this.InArray(code, codes)))))) {
|
|
this.CheckAddress(address)
|
|
var network interface{} = nil
|
|
if IsTrue(InOp(networks, marketId)) {
|
|
var networkId interface{} = this.SafeString(networks, marketId)
|
|
if IsTrue(IsGreaterThanOrEqual(GetIndexOf(networkId, ","), 0)) {
|
|
network = []interface{}{}
|
|
var networkIds interface{} = Split(networkId, ",")
|
|
for j := 0; IsLessThan(j, GetArrayLength(networkIds)); j++ {
|
|
AppendToArray(&network,ToUpper(this.NetworkIdToCode(GetValue(networkIds, j))))
|
|
}
|
|
} else {
|
|
network = ToUpper(this.NetworkIdToCode(networkId))
|
|
}
|
|
}
|
|
AddElementToObject(result, code, map[string]interface{} {
|
|
"info": map[string]interface{} {},
|
|
"currency": code,
|
|
"network": network,
|
|
"address": address,
|
|
"tag": nil,
|
|
})
|
|
}
|
|
}
|
|
|
|
ch <- result
|
|
return nil
|
|
|
|
}()
|
|
return ch
|
|
}
|
|
func (this *indodax) 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 url interface{} = GetValue(GetValue(this.Urls, "api"), api)
|
|
if IsTrue(IsEqual(api, "public")) {
|
|
var query interface{} = this.Omit(params, this.ExtractParams(path))
|
|
var requestPath interface{} = Add("/", this.ImplodeParams(path, params))
|
|
url = Add(url, requestPath)
|
|
if IsTrue(GetArrayLength(ObjectKeys(query))) {
|
|
url = Add(url, Add("?", this.UrlencodeWithArrayRepeat(query)))
|
|
}
|
|
} else {
|
|
this.CheckRequiredCredentials()
|
|
body = this.Urlencode(this.Extend(map[string]interface{} {
|
|
"method": path,
|
|
"timestamp": this.Nonce(),
|
|
"recvWindow": GetValue(this.Options, "recvWindow"),
|
|
}, params))
|
|
headers = map[string]interface{} {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
"Key": this.ApiKey,
|
|
"Sign": this.Hmac(this.Encode(body), this.Encode(this.Secret), sha512),
|
|
}
|
|
}
|
|
return map[string]interface{} {
|
|
"url": url,
|
|
"method": method,
|
|
"body": body,
|
|
"headers": headers,
|
|
}
|
|
}
|
|
func (this *indodax) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
|
|
if IsTrue(IsEqual(response, nil)) {
|
|
return nil
|
|
}
|
|
// { success: 0, error: "invalid order." }
|
|
// or
|
|
// [{ data, ... }, { ... }, ... ]
|
|
// {"success":"1","status":"approved","withdraw_currency":"strm","withdraw_address":"0x2b9A8cd5535D99b419aEfFBF1ae8D90a7eBdb24E","withdraw_amount":"2165.05767839","fee":"21.11000000","amount_after_fee":"2143.94767839","submit_time":"1730759489","withdraw_id":"strm-3423","txid":""}
|
|
if IsTrue(IsArray(response)) {
|
|
return nil // public endpoints may return []-arrays
|
|
}
|
|
var error interface{} = this.SafeValue(response, "error", "")
|
|
if IsTrue(!IsTrue((InOp(response, "success"))) && IsTrue(IsEqual(error, ""))) {
|
|
return nil // no 'success' property on public responses
|
|
}
|
|
var status interface{} = this.SafeString(response, "success")
|
|
if IsTrue(IsEqual(status, "approved")) {
|
|
return nil
|
|
}
|
|
if IsTrue(IsEqual(this.SafeInteger(response, "success", 0), 1)) {
|
|
// { success: 1, return: { orders: [] }}
|
|
if !IsTrue((InOp(response, "return"))) {
|
|
panic(ExchangeError(Add(Add(this.Id, ": malformed response: "), this.Json(response))))
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
var feedback interface{} = Add(Add(this.Id, " "), body)
|
|
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), error, feedback)
|
|
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), error, feedback)
|
|
panic(ExchangeError(feedback))
|
|
}
|
|
|
|
|
|
func (this *indodax) Init(userConfig map[string]interface{}) {
|
|
this.Exchange = Exchange{}
|
|
this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
|
|
this.Exchange.DerivedExchange = this
|
|
}
|