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 zaif struct { Exchange } func NewZaifCore() zaif { p := zaif{} setDefaults(&p) return p } func (this *zaif) Describe() interface{} { return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} { "id": "zaif", "name": "Zaif", "countries": []interface{}{"JP"}, "rateLimit": 100, "version": "1", "has": map[string]interface{} { "CORS": nil, "spot": true, "margin": nil, "swap": false, "future": false, "option": false, "cancelOrder": true, "createMarketOrder": false, "createOrder": true, "fetchBalance": true, "fetchClosedOrders": true, "fetchFundingHistory": false, "fetchFundingRate": false, "fetchFundingRateHistory": false, "fetchFundingRates": false, "fetchIndexOHLCV": false, "fetchMarkets": true, "fetchMarkOHLCV": false, "fetchOpenInterestHistory": false, "fetchOpenOrders": true, "fetchOrderBook": true, "fetchPremiumIndexOHLCV": false, "fetchTicker": true, "fetchTrades": true, "fetchTradingFee": false, "fetchTradingFees": false, "withdraw": true, }, "urls": map[string]interface{} { "logo": "https://user-images.githubusercontent.com/1294454/27766927-39ca2ada-5eeb-11e7-972f-1b4199518ca6.jpg", "api": map[string]interface{} { "rest": "https://api.zaif.jp", }, "www": "https://zaif.jp", "doc": []interface{}{"https://techbureau-api-document.readthedocs.io/ja/latest/index.html", "https://corp.zaif.jp/api-docs", "https://corp.zaif.jp/api-docs/api_links", "https://www.npmjs.com/package/zaif.jp", "https://github.com/you21979/node-zaif"}, "fees": "https://zaif.jp/fee?lang=en", }, "fees": map[string]interface{} { "trading": map[string]interface{} { "percentage": true, "taker": this.ParseNumber("0.001"), "maker": this.ParseNumber("0"), }, }, "api": map[string]interface{} { "public": map[string]interface{} { "get": map[string]interface{} { "depth/{pair}": 1, "currencies/{pair}": 1, "currencies/all": 1, "currency_pairs/{pair}": 1, "currency_pairs/all": 1, "last_price/{pair}": 1, "ticker/{pair}": 1, "trades/{pair}": 1, }, }, "private": map[string]interface{} { "post": map[string]interface{} { "active_orders": 5, "cancel_order": 5, "deposit_history": 5, "get_id_info": 5, "get_info": 10, "get_info2": 5, "get_personal_info": 5, "trade": 5, "trade_history": 50, "withdraw": 5, "withdraw_history": 5, }, }, "ecapi": map[string]interface{} { "post": map[string]interface{} { "createInvoice": 1, "getInvoice": 1, "getInvoiceIdsByOrderNumber": 1, "cancelInvoice": 1, }, }, "tlapi": map[string]interface{} { "post": map[string]interface{} { "get_positions": 66, "position_history": 66, "active_positions": 5, "create_position": 33, "change_position": 33, "cancel_position": 33, }, }, "fapi": map[string]interface{} { "get": map[string]interface{} { "groups/{group_id}": 1, "last_price/{group_id}/{pair}": 1, "ticker/{group_id}/{pair}": 1, "trades/{group_id}/{pair}": 1, "depth/{group_id}/{pair}": 1, }, }, }, "options": map[string]interface{} {}, "features": map[string]interface{} { "spot": map[string]interface{} { "sandbox": false, "createOrder": map[string]interface{} { "marginMode": true, "triggerPrice": true, "triggerDirection": false, "triggerPriceType": nil, "stopLossPrice": false, "takeProfitPrice": false, "attachedStopLossTakeProfit": nil, "timeInForce": map[string]interface{} { "IOC": false, "FOK": false, "PO": false, "GTD": false, }, "hedged": false, "trailing": false, "leverage": true, "marketBuyByCost": false, "marketBuyRequiresPrice": false, "selfTradePrevention": false, "iceberg": false, }, "createOrders": nil, "fetchMyTrades": nil, "fetchOrder": nil, "fetchOpenOrders": map[string]interface{} { "marginMode": true, "limit": nil, "trigger": false, "trailing": false, "symbolRequired": false, }, "fetchOrders": nil, "fetchClosedOrders": map[string]interface{} { "marginMode": true, "limit": 1000, "daysBack": 100000, "daysBackCanceled": 1, "untilDays": 100000, "trigger": false, "trailing": false, "symbolRequired": false, }, "fetchOHLCV": nil, }, "swap": map[string]interface{} { "linear": nil, "inverse": nil, }, "future": map[string]interface{} { "linear": nil, "inverse": nil, }, }, "precisionMode": TICK_SIZE, "exceptions": map[string]interface{} { "exact": map[string]interface{} { "unsupported currency_pair": BadRequest, }, "broad": map[string]interface{} {}, }, }) } /** * @method * @name zaif#fetchMarkets * @see https://zaif-api-document.readthedocs.io/ja/latest/PublicAPI.html#id12 * @description retrieves data on all markets for zaif * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} an array of objects representing market data */ func (this *zaif) 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 markets:= (<-this.PublicGetCurrencyPairsAll(params)) PanicOnError(markets) // // [ // { // "aux_unit_point": 0, // "item_japanese": "\u30d3\u30c3\u30c8\u30b3\u30a4\u30f3", // "aux_unit_step": 5.0, // "description": "\u30d3\u30c3\u30c8\u30b3\u30a4\u30f3\u30fb\u65e5\u672c\u5186\u306e\u53d6\u5f15\u3092\u884c\u3046\u3053\u3068\u304c\u3067\u304d\u307e\u3059", // "item_unit_min": 0.001, // "event_number": 0, // "currency_pair": "btc_jpy", // "is_token": false, // "aux_unit_min": 5.0, // "aux_japanese": "\u65e5\u672c\u5186", // "id": 1, // "item_unit_step": 0.0001, // "name": "BTC/JPY", // "seq": 0, // "title": "BTC/JPY" // } // ] // ch <- this.ParseMarkets(markets) return nil }() return ch } func (this *zaif) ParseMarket(market interface{}) interface{} { var id interface{} = this.SafeString(market, "currency_pair") var name interface{} = this.SafeString(market, "name") baseIdquoteIdVariable := Split(name, "/"); baseId := GetValue(baseIdquoteIdVariable,0); quoteId := GetValue(baseIdquoteIdVariable,1) var base interface{} = this.SafeCurrencyCode(baseId) var quote interface{} = this.SafeCurrencyCode(quoteId) var symbol interface{} = Add(Add(base, "/"), quote) return map[string]interface{} { "id": id, "symbol": symbol, "base": base, "quote": quote, "settle": nil, "baseId": baseId, "quoteId": quoteId, "settleId": nil, "type": "spot", "spot": true, "margin": nil, "swap": false, "future": false, "option": false, "active": nil, "contract": false, "linear": nil, "inverse": nil, "contractSize": nil, "expiry": nil, "expiryDatetime": nil, "strike": nil, "optionType": nil, "precision": map[string]interface{} { "amount": this.SafeNumber(market, "item_unit_step"), "price": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "aux_unit_point"))), }, "limits": map[string]interface{} { "leverage": map[string]interface{} { "min": nil, "max": nil, }, "amount": map[string]interface{} { "min": this.SafeNumber(market, "item_unit_min"), "max": nil, }, "price": map[string]interface{} { "min": this.SafeNumber(market, "aux_unit_min"), "max": nil, }, "cost": map[string]interface{} { "min": nil, "max": nil, }, }, "created": nil, "info": market, } } func (this *zaif) ParseBalance(response interface{}) interface{} { var balances interface{} = this.SafeValue(response, "return", map[string]interface{} {}) var deposit interface{} = this.SafeValue(balances, "deposit") var result interface{} = map[string]interface{} { "info": response, "timestamp": nil, "datetime": nil, } var funds interface{} = this.SafeValue(balances, "funds", map[string]interface{} {}) var currencyIds interface{} = ObjectKeys(funds) for i := 0; IsLessThan(i, GetArrayLength(currencyIds)); i++ { var currencyId interface{} = GetValue(currencyIds, i) var code interface{} = this.SafeCurrencyCode(currencyId) var balance interface{} = this.SafeString(funds, currencyId) var account interface{} = this.Account() AddElementToObject(account, "free", balance) AddElementToObject(account, "total", balance) if IsTrue(!IsEqual(deposit, nil)) { if IsTrue(InOp(deposit, currencyId)) { AddElementToObject(account, "total", this.SafeString(deposit, currencyId)) } } AddElementToObject(result, code, account) } return this.SafeBalance(result) } /** * @method * @name zaif#fetchBalance * @see https://zaif-api-document.readthedocs.io/ja/latest/TradingAPI.html#id10 * @description query for balance and get the amount of funds available for trading or funds locked in orders * @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 *zaif) 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 retRes3308 := (<-this.LoadMarkets()) PanicOnError(retRes3308) response:= (<-this.PrivatePostGetInfo(params)) PanicOnError(response) ch <- this.ParseBalance(response) return nil }() return ch } /** * @method * @name zaif#fetchOrderBook * @see https://zaif-api-document.readthedocs.io/ja/latest/PublicAPI.html#id34 * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data * @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 *zaif) 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 retRes3468 := (<-this.LoadMarkets()) PanicOnError(retRes3468) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "pair": GetValue(market, "id"), } response:= (<-this.PublicGetDepthPair(this.Extend(request, params))) PanicOnError(response) ch <- this.ParseOrderBook(response, GetValue(market, "symbol")) return nil }() return ch } func (this *zaif) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} { // // { // "last": 9e-08, // "high": 1e-07, // "low": 9e-08, // "vwap": 0.0, // "volume": 135250.0, // "bid": 9e-08, // "ask": 1e-07 // } // market := GetArg(optionalArgs, 0, nil) _ = market var symbol interface{} = this.SafeSymbol(nil, market) var vwap interface{} = this.SafeString(ticker, "vwap") var baseVolume interface{} = this.SafeString(ticker, "volume") var quoteVolume interface{} = Precise.StringMul(baseVolume, vwap) var last interface{} = this.SafeString(ticker, "last") return this.SafeTicker(map[string]interface{} { "symbol": symbol, "timestamp": nil, "datetime": nil, "high": this.SafeString(ticker, "high"), "low": this.SafeString(ticker, "low"), "bid": this.SafeString(ticker, "bid"), "bidVolume": nil, "ask": this.SafeString(ticker, "ask"), "askVolume": nil, "vwap": vwap, "open": nil, "close": last, "last": last, "previousClose": nil, "change": nil, "percentage": nil, "average": nil, "baseVolume": baseVolume, "quoteVolume": quoteVolume, "info": ticker, }, market) } /** * @method * @name zaif#fetchTicker * @see https://zaif-api-document.readthedocs.io/ja/latest/PublicAPI.html#id22 * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market * @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 *zaif) 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 retRes4068 := (<-this.LoadMarkets()) PanicOnError(retRes4068) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "pair": GetValue(market, "id"), } ticker:= (<-this.PublicGetTickerPair(this.Extend(request, params))) PanicOnError(ticker) // // { // "last": 9e-08, // "high": 1e-07, // "low": 9e-08, // "vwap": 0.0, // "volume": 135250.0, // "bid": 9e-08, // "ask": 1e-07 // } // ch <- this.ParseTicker(ticker, market) return nil }() return ch } func (this *zaif) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} { // // fetchTrades (public) // // { // "date": 1648559414, // "price": 5880375.0, // "amount": 0.017, // "tid": 176126557, // "currency_pair": "btc_jpy", // "trade_type": "ask" // } // market := GetArg(optionalArgs, 0, nil) _ = market var side interface{} = this.SafeString(trade, "trade_type") side = Ternary(IsTrue((IsEqual(side, "bid"))), "buy", "sell") var timestamp interface{} = this.SafeTimestamp(trade, "date") var id interface{} = this.SafeString2(trade, "id", "tid") var priceString interface{} = this.SafeString(trade, "price") var amountString interface{} = this.SafeString(trade, "amount") var marketId interface{} = this.SafeString(trade, "currency_pair") var symbol interface{} = this.SafeSymbol(marketId, market, "_") return this.SafeTrade(map[string]interface{} { "id": id, "info": trade, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "symbol": symbol, "type": nil, "side": side, "order": nil, "takerOrMaker": nil, "price": priceString, "amount": amountString, "cost": nil, "fee": nil, }, market) } /** * @method * @name zaif#fetchTrades * @see https://zaif-api-document.readthedocs.io/ja/latest/PublicAPI.html#id28 * @description get the list of most recent trades for a particular symbol * @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 *zaif) 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 retRes4768 := (<-this.LoadMarkets()) PanicOnError(retRes4768) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "pair": GetValue(market, "id"), } response:= (<-this.PublicGetTradesPair(this.Extend(request, params))) PanicOnError(response) // // [ // { // "date": 1648559414, // "price": 5880375.0, // "amount": 0.017, // "tid": 176126557, // "currency_pair": "btc_jpy", // "trade_type": "ask" // }, ... // ] // var numTrades interface{} = GetArrayLength(response) if IsTrue(IsEqual(numTrades, 1)) { var firstTrade interface{} = GetValue(response, 0) if !IsTrue(GetArrayLength(ObjectKeys(firstTrade))) { response = []interface{}{} } } ch <- this.ParseTrades(response, market, since, limit) return nil }() return ch } /** * @method * @name zaif#createOrder * @see https://zaif-api-document.readthedocs.io/ja/latest/MarginTradingAPI.html#id23 * @description create a trade order * @param {string} symbol unified symbol of the market to create an order in * @param {string} type must be '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 *zaif) 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 retRes5188 := (<-this.LoadMarkets()) PanicOnError(retRes5188) if IsTrue(!IsEqual(typeVar, "limit")) { panic(ExchangeError(Add(this.Id, " createOrder() allows limit orders only"))) } var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "currency_pair": GetValue(market, "id"), "action": Ternary(IsTrue((IsEqual(side, "buy"))), "bid", "ask"), "amount": amount, "price": price, } response:= (<-this.PrivatePostTrade(this.Extend(request, params))) PanicOnError(response) ch <- this.SafeOrder(map[string]interface{} { "info": response, "id": ToString(GetValue(GetValue(response, "return"), "order_id")), }, market) return nil }() return ch } /** * @method * @name zaif#cancelOrder * @see https://zaif-api-document.readthedocs.io/ja/latest/TradingAPI.html#id37 * @description cancels an open order * @param {string} id order id * @param {string} symbol not used by zaif cancelOrder () * @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 *zaif) CancelOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbol := GetArg(optionalArgs, 0, nil) _ = symbol params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params var request interface{} = map[string]interface{} { "order_id": id, } response:= (<-this.PrivatePostCancelOrder(this.Extend(request, params))) PanicOnError(response) // // { // "success": 1, // "return": { // "order_id": 184, // "funds": { // "jpy": 15320, // "btc": 1.392, // "mona": 2600, // "kaori": 0.1 // } // } // } // var data interface{} = this.SafeDict(response, "return") ch <- this.ParseOrder(data) return nil }() return ch } func (this *zaif) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} { // // { // "currency_pair": "btc_jpy", // "action": "ask", // "amount": 0.03, // "price": 56000, // "timestamp": 1402021125, // "comment" : "demo" // } // // cancelOrder // // { // "order_id": 184, // "funds": { // "jpy": 15320, // "btc": 1.392, // "mona": 2600, // "kaori": 0.1 // } // } // market := GetArg(optionalArgs, 0, nil) _ = market var side interface{} = this.SafeString(order, "action") side = Ternary(IsTrue((IsEqual(side, "bid"))), "buy", "sell") var timestamp interface{} = this.SafeTimestamp(order, "timestamp") var marketId interface{} = this.SafeString(order, "currency_pair") var symbol interface{} = this.SafeSymbol(marketId, market, "_") var price interface{} = this.SafeString(order, "price") var amount interface{} = this.SafeString(order, "amount") var id interface{} = this.SafeString2(order, "id", "order_id") return this.SafeOrder(map[string]interface{} { "id": id, "clientOrderId": nil, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "lastTradeTimestamp": nil, "status": "open", "symbol": symbol, "type": "limit", "timeInForce": nil, "postOnly": nil, "side": side, "price": price, "triggerPrice": nil, "cost": nil, "amount": amount, "filled": nil, "remaining": nil, "trades": nil, "fee": nil, "info": order, "average": nil, }, market) } /** * @method * @name zaif#fetchOpenOrders * @see https://zaif-api-document.readthedocs.io/ja/latest/MarginTradingAPI.html#id28 * @description fetch all unfilled currently open 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 *zaif) 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 retRes6378 := (<-this.LoadMarkets()) PanicOnError(retRes6378) var market interface{} = nil var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "currency_pair", GetValue(market, "id")) } response:= (<-this.PrivatePostActiveOrders(this.Extend(request, params))) PanicOnError(response) ch <- this.ParseOrders(GetValue(response, "return"), market, since, limit) return nil }() return ch } /** * @method * @name zaif#fetchClosedOrders * @see https://zaif-api-document.readthedocs.io/ja/latest/TradingAPI.html#id24 * @description fetches information on multiple closed orders made by the user * @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 *zaif) 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 retRes6638 := (<-this.LoadMarkets()) PanicOnError(retRes6638) var market interface{} = nil var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "currency_pair", GetValue(market, "id")) } response:= (<-this.PrivatePostTradeHistory(this.Extend(request, params))) PanicOnError(response) ch <- this.ParseOrders(GetValue(response, "return"), market, since, limit) return nil }() return ch } /** * @method * @name zaif#withdraw * @see https://zaif-api-document.readthedocs.io/ja/latest/TradingAPI.html#id41 * @description make a 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 *zaif) 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) retRes6988 := (<-this.LoadMarkets()) PanicOnError(retRes6988) var currency interface{} = this.Currency(code) if IsTrue(IsEqual(code, "JPY")) { panic(ExchangeError(Add(Add(Add(this.Id, " withdraw() does not allow "), code), " withdrawals"))) } var request interface{} = map[string]interface{} { "currency": GetValue(currency, "id"), "amount": amount, "address": address, } if IsTrue(!IsEqual(tag, nil)) { AddElementToObject(request, "message", tag) } result:= (<-this.PrivatePostWithdraw(this.Extend(request, params))) PanicOnError(result) // // { // "success": 1, // "return": { // "id": 23634, // "fee": 0.001, // "txid":, // "funds": { // "jpy": 15320, // "btc": 1.392, // "xem": 100.2, // "mona": 2600 // } // } // } // var returnData interface{} = this.SafeDict(result, "return") ch <- this.ParseTransaction(returnData, currency) return nil }() return ch } func (this *zaif) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} { // // { // "id": 23634, // "fee": 0.001, // "txid":, // "funds": { // "jpy": 15320, // "btc": 1.392, // "xem": 100.2, // "mona": 2600 // } // } // currency := GetArg(optionalArgs, 0, nil) _ = currency currency = this.SafeCurrency(nil, currency) var fee interface{} = nil var feeCost interface{} = this.SafeValue(transaction, "fee") if IsTrue(!IsEqual(feeCost, nil)) { fee = map[string]interface{} { "cost": feeCost, "currency": GetValue(currency, "code"), } } return map[string]interface{} { "id": this.SafeString(transaction, "id"), "txid": this.SafeString(transaction, "txid"), "timestamp": nil, "datetime": nil, "network": nil, "addressFrom": nil, "address": nil, "addressTo": nil, "amount": nil, "type": nil, "currency": GetValue(currency, "code"), "status": nil, "updated": nil, "tagFrom": nil, "tag": nil, "tagTo": nil, "comment": nil, "internal": nil, "fee": fee, "info": transaction, } } func (this *zaif) CustomNonce() interface{} { var num interface{} = this.NumberToString(Divide(this.Milliseconds(), 1000)) var nonce interface{} = ParseFloat(num) return toFixed(nonce, 8) } func (this *zaif) 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{} = Add(GetValue(GetValue(this.Urls, "api"), "rest"), "/") if IsTrue(IsEqual(api, "public")) { url = Add(url, Add(Add(Add("api/", this.Version), "/"), this.ImplodeParams(path, params))) } else if IsTrue(IsEqual(api, "fapi")) { url = Add(url, Add(Add(Add("fapi/", this.Version), "/"), this.ImplodeParams(path, params))) } else { this.CheckRequiredCredentials() if IsTrue(IsEqual(api, "ecapi")) { url = Add(url, "ecapi") } else if IsTrue(IsEqual(api, "tlapi")) { url = Add(url, "tlapi") } else { url = Add(url, "tapi") } var nonce interface{} = this.CustomNonce() body = this.Urlencode(this.Extend(map[string]interface{} { "method": path, "nonce": nonce, }, 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 *zaif) HandleErrors(httpCode 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 } // // {"error": "unsupported currency_pair"} // var feedback interface{} = Add(Add(this.Id, " "), body) var error interface{} = this.SafeString(response, "error") if IsTrue(!IsEqual(error, nil)) { this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), error, feedback) this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), error, feedback) panic(ExchangeError(feedback)) } var success interface{} = this.SafeBool(response, "success", true) if !IsTrue(success) { panic(ExchangeError(feedback)) } return nil } func (this *zaif) Init(userConfig map[string]interface{}) { this.Exchange = Exchange{} this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this) this.Exchange.DerivedExchange = this }