ext/ccxt-go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ccxt-go/ellipx.go

2224 lines
96 KiB
Go
Raw Normal View History

first add
2025-02-28 10:33:20 +08:00
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 ellipx struct {
Exchange
}
func NewEllipxCore() ellipx {
p := ellipx{}
setDefaults(&p)
return p
}
func (this *ellipx) Describe() interface{} {
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
"id": "ellipx",
"name": "Ellipx",
"countries": []interface{}{"PL"},
"rateLimit": 200,
"version": "v1",
"certified": false,
"pro": false,
"has": map[string]interface{} {
"CORS": nil,
"spot": true,
"margin": false,
"swap": false,
"future": false,
"option": false,
"addMargin": false,
"cancelAllOrders": false,
"cancelAllOrdersAfter": false,
"cancelOrder": true,
"cancelOrders": false,
"cancelWithdraw": false,
"closePosition": false,
"createConvertTrade": false,
"createDepositAddress": false,
"createMarketBuyOrderWithCost": false,
"createMarketOrder": false,
"createMarketOrderWithCost": false,
"createMarketSellOrderWithCost": false,
"createOrder": true,
"createOrderWithTakeProfitAndStopLoss": false,
"createReduceOnlyOrder": false,
"createStopLimitOrder": false,
"createStopLossOrder": false,
"createStopMarketOrder": false,
"createStopOrder": false,
"createTakeProfitOrder": false,
"createTrailingAmountOrder": false,
"createTrailingPercentOrder": false,
"createTriggerOrder": false,
"fetchAccounts": false,
"fetchBalance": true,
"fetchCanceledAndClosedOrders": false,
"fetchCanceledOrders": false,
"fetchClosedOrder": false,
"fetchClosedOrders": false,
"fetchConvertCurrencies": false,
"fetchConvertQuote": false,
"fetchConvertTrade": false,
"fetchConvertTradeHistory": false,
"fetchCurrencies": true,
"fetchDepositAddress": true,
"fetchDeposits": false,
"fetchDepositsWithdrawals": false,
"fetchFundingHistory": false,
"fetchFundingRate": false,
"fetchFundingRateHistory": false,
"fetchFundingRates": false,
"fetchIndexOHLCV": false,
"fetchLedger": false,
"fetchLeverage": false,
"fetchLeverageTiers": false,
"fetchMarginAdjustmentHistory": false,
"fetchMarginMode": false,
"fetchMarkets": true,
"fetchMarkOHLCV": false,
"fetchMyTrades": false,
"fetchOHLCV": true,
"fetchOpenInterestHistory": false,
"fetchOpenOrder": false,
"fetchOpenOrders": true,
"fetchOrder": true,
"fetchOrderBook": true,
"fetchOrders": true,
"fetchOrderTrades": true,
"fetchPosition": false,
"fetchPositionHistory": false,
"fetchPositionMode": false,
"fetchPositions": false,
"fetchPositionsForSymbol": false,
"fetchPositionsHistory": false,
"fetchPremiumIndexOHLCV": false,
"fetchStatus": false,
"fetchTicker": true,
"fetchTickers": false,
"fetchTime": false,
"fetchTrades": true,
"fetchTradingFee": true,
"fetchTradingFees": false,
"fetchTransactions": false,
"fetchTransfers": false,
"fetchWithdrawals": false,
"reduceMargin": false,
"sandbox": false,
"setLeverage": false,
"setMargin": false,
"setPositionMode": false,
"transfer": false,
"withdraw": true,
},
"timeframes": map[string]interface{} {
"1m": "1m",
"5m": "5m",
"10m": "10m",
"1h": "1h",
"6h": "6h",
"12h": "12h",
"1d": "1d",
},
"urls": map[string]interface{} {
"logo": "https://github.com/user-attachments/assets/e07c3f40-281c-4cdf-bacf-fa1c58218a2c",
"api": map[string]interface{} {
"public": "https://data.ellipx.com",
"private": "https://app.ellipx.com/_rest",
"_rest": "https://app.ellipx.com/_rest",
},
"www": "https://www.ellipx.com",
"doc": "https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM",
"fees": "https://www.ellipx.com/pages/pricing",
"referral": "",
},
"api": map[string]interface{} {
"_rest": map[string]interface{} {
"get": map[string]interface{} {
"Market": 1,
"Market/{currencyPair}": 1,
"Crypto/Token/Info": 1,
},
},
"public": map[string]interface{} {
"get": map[string]interface{} {
"Market/{currencyPair}:getDepth": 1,
"Market/{currencyPair}:ticker": 1,
"Market/{currencyPair}:getTrades": 1,
"Market/{currencyPair}:getGraph": 1,
"CMC:summary": 1,
"CMC/{currencyPair}:ticker": 1,
},
},
"private": map[string]interface{} {
"get": map[string]interface{} {
"User/Wallet": 1,
"Market/{currencyPair}/Order": 1,
"Market/Order/{orderUuid}": 1,
"Market/{currencyPair}/Trade": 1,
"Market/TradeFee:query": 1,
"Unit/{currency}": 1,
"Crypto/Token/{currency}": 1,
"Crypto/Token/{currency}:chains": 1,
},
"post": map[string]interface{} {
"Market/{currencyPair}/Order": 1,
"Crypto/Address:fetch": 1,
"Crypto/Disbursement:withdraw": 1,
},
"delete": map[string]interface{} {
"Market/Order/{orderUuid}": 1,
},
},
},
"fees": map[string]interface{} {
"trading": map[string]interface{} {
"tierBased": true,
"feeSide": "get",
"percentage": true,
"maker": this.ParseNumber("0.0025"),
"taker": this.ParseNumber("0.0030"),
"tiers": map[string]interface{} {
"maker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.0025")}, []interface{}{this.ParseNumber("10000"), this.ParseNumber("0.0020")}, []interface{}{this.ParseNumber("50000"), this.ParseNumber("0.0015")}, []interface{}{this.ParseNumber("100000"), this.ParseNumber("0.0010")}, []interface{}{this.ParseNumber("1000000"), this.ParseNumber("0.0008")}, []interface{}{this.ParseNumber("5000000"), this.ParseNumber("0.0003")}, []interface{}{this.ParseNumber("15000000"), this.ParseNumber("0.0000")}, []interface{}{this.ParseNumber("75000000"), this.ParseNumber("0.0000")}, []interface{}{this.ParseNumber("100000000"), this.ParseNumber("0.0000")}},
"taker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.0030")}, []interface{}{this.ParseNumber("10000"), this.ParseNumber("0.0025")}, []interface{}{this.ParseNumber("50000"), this.ParseNumber("0.0020")}, []interface{}{this.ParseNumber("100000"), this.ParseNumber("0.0015")}, []interface{}{this.ParseNumber("1000000"), this.ParseNumber("0.0012")}, []interface{}{this.ParseNumber("5000000"), this.ParseNumber("0.0010")}, []interface{}{this.ParseNumber("15000000"), this.ParseNumber("0.0008")}, []interface{}{this.ParseNumber("75000000"), this.ParseNumber("0.0005")}, []interface{}{this.ParseNumber("100000000"), this.ParseNumber("0.0003")}},
},
},
"stablecoin": map[string]interface{} {
"tierBased": false,
"percentage": true,
"maker": this.ParseNumber("0.0000"),
"taker": this.ParseNumber("0.000015"),
},
},
"options": map[string]interface{} {
"defaultType": "spot",
"recvWindow": Multiply(5, 1000),
"broker": "CCXT",
"networks": map[string]interface{} {
"Bitcoin": "Bitcoin",
"Ethereum": "ERC20",
},
"defaultNetwork": "defaultNetwork",
"defaultNetworkCodeReplacements": map[string]interface{} {
"BTC": "Bitcoin",
"ETH": "Ethereum",
},
},
"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": false,
"FOK": false,
"PO": false,
"GTD": false,
},
"hedged": false,
"selfTradePrevention": false,
"trailing": false,
"leverage": false,
"marketBuyByCost": true,
"marketBuyRequiresPrice": false,
"iceberg": false,
},
"createOrders": nil,
"fetchMyTrades": nil,
"fetchOrder": map[string]interface{} {
"marginMode": false,
"trigger": false,
"trailing": false,
"symbolRequired": false,
},
"fetchOpenOrders": map[string]interface{} {
"marginMode": false,
"limit": nil,
"trigger": false,
"trailing": false,
"symbolRequired": true,
},
"fetchOrders": map[string]interface{} {
"marginMode": false,
"limit": nil,
"daysBack": nil,
"untilDays": nil,
"trigger": false,
"trailing": false,
"symbolRequired": true,
},
"fetchClosedOrders": nil,
"fetchOHLCV": map[string]interface{} {
"limit": 100,
},
},
"swap": map[string]interface{} {
"linear": nil,
"inverse": nil,
},
"future": map[string]interface{} {
"linear": nil,
"inverse": nil,
},
},
"commonCurrencies": map[string]interface{} {},
"exceptions": map[string]interface{} {
"exact": map[string]interface{} {
"400": BadRequest,
"401": AuthenticationError,
"403": PermissionDenied,
"404": BadRequest,
"429": DDoSProtection,
"418": PermissionDenied,
"500": ExchangeError,
"504": ExchangeError,
},
"broad": map[string]interface{} {},
},
"precisionMode": TICK_SIZE,
})
}
func (this *ellipx) 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
path = this.ImplodeParams(path, params)
var url interface{} = Add(Add(GetValue(GetValue(this.Urls, "api"), api), "/"), path)
if IsTrue(IsEqual(api, "private")) {
this.CheckRequiredCredentials()
var nonce interface{} = this.Uuid()
var timestamp interface{} = ToString(this.Seconds())
if IsTrue(IsEqual(method, "GET")) {
body = ""
} else {
body = this.Json(params)
}
params = this.Extend(map[string]interface{} {
"_key": this.ApiKey,
"_time": timestamp,
"_nonce": nonce,
}, params)
var query interface{} = this.Urlencode(params)
var bodyHash interface{} = this.Hash(this.Encode(body), sha256)
// Create sign string components
var bodyHashBytes interface{} = this.Base16ToBinary(bodyHash)
var nulByte interface{} = this.NumberToBE(0, 1)
var components interface{} = []interface{}{this.Encode(method), nulByte, this.Encode(path), nulByte, this.Encode(query), nulByte, bodyHashBytes}
// Join with null byte separator using encode
var signString interface{} = this.BinaryConcatArray(components)
var sec interface{} = this.Secret
var remainder interface{} = this.CalculateMod(GetLength(sec), 4)
var paddingLength interface{} = Ternary(IsTrue(remainder), Subtract(4, remainder), 0)
var secretWithPadding interface{} = Replace(this.Secret, "-", "+")
secretWithPadding = Replace(secretWithPadding, "_", "/")
secretWithPadding = PadEnd(secretWithPadding, Add(GetLength(this.Secret), paddingLength), "=")
var secretBytes interface{} = this.Base64ToBinary(secretWithPadding)
var seed interface{} = this.ArraySlice(secretBytes, 0, 32) // Extract first 32 bytes as seed
var signature interface{} = Eddsa(signString, seed, ed25519)
AddElementToObject(params, "_sign", signature)
}
if IsTrue(GetArrayLength(ObjectKeys(params))) {
url = Add(url, Add("?", this.Urlencode(params)))
}
if IsTrue(IsEqual(method, "GET")) {
body = nil
} else {
headers = map[string]interface{} {
"Content-Type": "application/json",
}
}
return map[string]interface{} {
"url": url,
"method": method,
"body": body,
"headers": headers,
}
}
func (this *ellipx) CalculateMod(a interface{}, b interface{}) interface{} {
// trick to fix php transpiling error
return Mod(a, b)
}
/**
* @method
* @name ellipx#fetchMarkets
* @description Fetches market information from the exchange.
* @see https://docs.ccxt.com/en/latest/manual.html#markets
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.1a1t05wpgfof
* @param {object} [params] - Extra parameters specific to the exchange API endpoint
* @returns {Promise<Market[]>} An array of market structures.
*/
func (this *ellipx) 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._restGetMarket(params))
PanicOnError(response)
// {
// Market__: "mkt-lrnp2e-eaor-eobj-ua73-75j6sjxe",
// Primary_Unit__: "unit-aebkye-u35b-e5zm-zt22-2qvwhsqa",
// Secondary_Unit__: "unit-jcevlk-soxf-fepb-yjwm-b32q5bom",
// Primary_Step: null,
// Secondary_Step: null,
// Status: "active",
// Default_Scale: "5",
// Priority: "100",
// Created: {
// unix: "1728113809",
// us: "0",
// iso: "2024-10-05 07:36:49.000000",
// tz: "UTC",
// full: "1728113809000000",
// unixms: "1728113809000",
// },
// Start: {
// unix: "1728295200",
// us: "0",
// iso: "2024-10-07 10:00:00.000000",
// tz: "UTC",
// full: "1728295200000000",
// unixms: "1728295200000",
// },
// Key: "BTC_USDC",
// Primary: {
// Unit__: "unit-aebkye-u35b-e5zm-zt22-2qvwhsqa",
// Currency__: "BTC",
// Crypto_Token__: "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
// Key: "BTC",
// Symbol: "BTC",
// Symbol_Position: "after",
// Name: "Bitcoin",
// Decimals: "8",
// Display_Decimals: "8",
// Legacy_Decimals: null,
// Type: "crypto_token",
// Visible: "Y",
// Created: {
// unix: "1495247415",
// us: "0",
// iso: "2017-05-20 02:30:15.000000",
// tz: "UTC",
// full: "1495247415000000",
// unixms: "1495247415000",
// },
// },
// Secondary: {
// Unit__: "unit-jcevlk-soxf-fepb-yjwm-b32q5bom",
// Currency__: null,
// Crypto_Token__: "crtok-ptabkh-ra4r-anbd-cqra-bqfbtnba",
// Key: "USDC",
// Symbol: null,
// Symbol_Position: "before",
// Name: "Circle USD",
// Decimals: "6",
// Display_Decimals: "6",
// Legacy_Decimals: null,
// Type: "crypto_token",
// Visible: "Y",
// Created: {
// unix: "1694859829",
// us: "0",
// iso: "2023-09-16 10:23:49.000000",
// tz: "UTC",
// full: "1694859829000000",
// unixms: "1694859829000",
// },
// },
// }
var markets interface{} = this.SafeValue(response, "data", []interface{}{})
ch <- this.ParseMarkets(markets)
return nil
}()
return ch
}
func (this *ellipx) ParseMarket(market interface{}) interface{} {
var id interface{} = this.SafeString(market, "Key")
var base interface{} = this.SafeString(GetValue(market, "Primary"), "Key")
var quote interface{} = this.SafeString(GetValue(market, "Secondary"), "Key")
var baseId interface{} = this.SafeString(GetValue(market, "Primary"), "Crypto_Token__")
var quoteId interface{} = this.SafeString(GetValue(market, "Secondary"), "Crypto_Token__")
var status interface{} = IsEqual(this.SafeString(market, "Status"), "active")
var created interface{} = this.SafeTimestamp(GetValue(market, "Created"), "unix")
var amountPrecision interface{} = this.ParseNumber(this.ParsePrecision(this.SafeString(GetValue(market, "Primary"), "Decimals")))
var pricePrecision interface{} = this.ParseNumber(this.ParsePrecision(this.SafeString(GetValue(market, "Secondary"), "Decimals")))
var fees interface{} = this.Fees // should use fetchTradingFees
return this.SafeMarketStructure(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": status,
"contract": false,
"linear": nil,
"inverse": nil,
"taker": GetValue(GetValue(fees, "trading"), "taker"),
"maker": GetValue(GetValue(fees, "trading"), "maker"),
"contractSize": nil,
"expiry": nil,
"expiryDatetime": nil,
"strike": nil,
"optionType": nil,
"precision": map[string]interface{} {
"amount": amountPrecision,
"price": pricePrecision,
},
"limits": map[string]interface{} {
"amount": map[string]interface{} {
"min": nil,
"max": nil,
},
"price": map[string]interface{} {
"min": nil,
"max": nil,
},
"cost": map[string]interface{} {
"min": nil,
"max": nil,
},
},
"info": market,
"created": created,
})
}
/**
* @method
* @name ellipx#fetchTicker
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.d2jylz4u6pmu
* @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 *ellipx) 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
retRes5338 := (<-this.LoadMarkets())
PanicOnError(retRes5338)
var market interface{} = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
var request interface{} = map[string]interface{} {
"currencyPair": marketId,
}
response:= (<-this.PublicGetMarketCurrencyPairTicker(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "data": {
// "market": "BTC_USDC",
// "ticker": {
// "time": 1730814600,
// "count": 2135,
// "high": {
// "v": "74766990000",
// "e": 6,
// "f": 74766.99
// },
// "low": {
// "v": "68734020000",
// "e": 6,
// "f": 68734.02
// },
// "avg": {
// "v": "72347941430",
// "e": 6,
// "f": 72347.94143
// },
// "vwap": {
// "v": "73050064447",
// "e": 6,
// "f": 73050.064447
// },
// "vol": {
// "v": "4885361",
// "e": 8,
// "f": 0.04885361
// },
// "secvol": {
// "v": "3568759346",
// "e": 6,
// "f": 3568.759346
// },
// "open": {
// "v": "68784020000",
// "e": 6,
// "f": 68784.02
// },
// "close": {
// "v": "73955570000",
// "e": 6,
// "f": 73955.57
// }
// }
// },
// "request_id": "cbf183e0-7a62-4674-838c-6693031fa240",
// "result": "success",
// "time": 0.015463566
// }
//
var ticker interface{} = this.SafeValue(GetValue(response, "data"), "ticker", map[string]interface{} {})
ch <- this.ParseTicker(ticker, market)
return nil
}()
return ch
}
func (this *ellipx) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
var timestamp interface{} = this.SafeIntegerProduct(ticker, "time", 1000)
var open interface{} = this.ParseAmount(this.SafeValue(ticker, "open"))
var high interface{} = this.ParseAmount(this.SafeValue(ticker, "high"))
var low interface{} = this.ParseAmount(this.SafeValue(ticker, "low"))
var close interface{} = this.ParseAmount(this.SafeValue(ticker, "close"))
var avg interface{} = this.ParseAmount(this.SafeValue(ticker, "avg"))
var vwap interface{} = this.ParseAmount(this.SafeValue(ticker, "vwap"))
var baseVolume interface{} = this.ParseAmount(this.SafeValue(ticker, "vol"))
var quoteVolume interface{} = this.ParseAmount(this.SafeValue(ticker, "secvol"))
// const count = this.safeInteger(ticker, 'count'); not used
return this.SafeTicker(map[string]interface{} {
"symbol": this.SafeSymbol(nil, market),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"high": high,
"low": low,
"bid": nil,
"bidVolume": nil,
"ask": nil,
"askVolume": nil,
"vwap": vwap,
"open": open,
"close": close,
"last": close,
"previousClose": nil,
"change": nil,
"percentage": nil,
"average": avg,
"baseVolume": baseVolume,
"quoteVolume": quoteVolume,
"info": ticker,
}, market)
}
/**
* @method
* @name ellipx#fetchOrderBook
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.bqmucewhkpdz
* @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 the exchange not supported yet.
* @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 *ellipx) 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
retRes6448 := (<-this.LoadMarkets())
PanicOnError(retRes6448)
var market interface{} = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
var request interface{} = map[string]interface{} {
"currencyPair": marketId,
}
response:= (<-this.PublicGetMarketCurrencyPairGetDepth(this.Extend(request, params)))
PanicOnError(response)
// {
// "data": {
// "asks": [
// {
// "price": {
// "v": "74941875231",
// "e": 6,
// "f": 74941.875231
// },
// "amount": {
// "v": "149",
// "e": 8,
// "f": 0.00000149
// }
// },
// {
// "price": {
// "v": "75063426037",
// "e": 6,
// "f": 75063.426037
// },
// "amount": {
// "v": "335",
// "e": 8,
// "f": 0.00000335
// }
// }
// ],
// "bids": [
// {
// "price": {
// "v": "64518711040",
// "e": 6,
// "f": 64518.71104
// },
// "amount": {
// "v": "132",
// "e": 8,
// "f": 0.00000132
// }
// },
// {
// "price": {
// "v": "64263569273",
// "e": 6,
// "f": 64263.569273
// },
// "amount": {
// "v": "210",
// "e": 8,
// "f": 0.0000021
// }
// }
// ],
// "market": "BTC_USDC"
// },
// "request_id": "71b7dffc-3120-4e46-a0bb-49ece5aea7e1",
// "result": "success",
// "time": 0.000074661
// }
var data interface{} = this.SafeValue(response, "data", map[string]interface{} {}) // exchange specific v e f params
var timestamp interface{} = this.Milliseconds() // the exchange does not provide timestamp for this.
var dataBidsLength interface{} = GetArrayLength(GetValue(data, "bids"))
var dataAsksLength interface{} = GetArrayLength(GetValue(data, "asks"))
for i := 0; IsLessThan(i, dataBidsLength); i++ {
AddElementToObject(GetValue(GetValue(data, "bids"), i), "price", this.ParseAmount(GetValue(GetValue(GetValue(data, "bids"), i), "price")))
AddElementToObject(GetValue(GetValue(data, "bids"), i), "amount", this.ParseAmount(GetValue(GetValue(GetValue(data, "bids"), i), "amount")))
}
for i := 0; IsLessThan(i, dataAsksLength); i++ {
AddElementToObject(GetValue(GetValue(data, "asks"), i), "price", this.ParseAmount(GetValue(GetValue(GetValue(data, "asks"), i), "price")))
AddElementToObject(GetValue(GetValue(data, "asks"), i), "amount", this.ParseAmount(GetValue(GetValue(GetValue(data, "asks"), i), "amount")))
}
ch <- this.ParseOrderBook(data, symbol, timestamp, "bids", "asks", "price", "amount")
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchOHLCV
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market, default will return the last 24h period.
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.w65baeuhxwt8
* @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 API endpoint
* @param {int} [params.until] timestamp in ms of the earliest candle to fetch
* @returns {OHLCV[]} A list of candles ordered as timestamp, open, high, low, close, volume
*/
func (this *ellipx) 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
retRes7408 := (<-this.LoadMarkets())
PanicOnError(retRes7408)
var methodName interface{} = "fetchOHLCV"
var paginate interface{} = false
paginateparamsVariable := this.HandleOptionAndParams(params, methodName, "paginate");
paginate = GetValue(paginateparamsVariable,0);
params = GetValue(paginateparamsVariable,1)
if IsTrue(paginate) {
retRes74519 := (<-this.FetchPaginatedCallDeterministic("fetchOHLCV", symbol, since, limit, timeframe, params, 1000))
PanicOnError(retRes74519)
ch <- retRes74519
return nil
}
var market interface{} = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
var time_frame interface{} = this.SafeString(this.Timeframes, timeframe, nil)
var request interface{} = map[string]interface{} {
"currencyPair": marketId,
"interval": time_frame,
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "start", MathFloor(Divide(since, 1000)))
}
var until interface{} = nil
untilparamsVariable := this.HandleOptionAndParams(params, methodName, "until");
until = GetValue(untilparamsVariable,0);
params = GetValue(untilparamsVariable,1)
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "end", until)
}
// {
// "data": {
// "market": "BTC_USDC",
// "real_end": 1730970780,
// "requested_end": 1730970784,
// "start": 1730884200,
// "stats": [
// {
// "time": 1730884200,
// "count": 48,
// "high": {"v": "73898950000", "e": 6, "f": 73898.95},
// "low": {"v": "73642930000", "e": 6, "f": 73642.93},
// "open": {"v": "73830990000", "e": 6, "f": 73830.99},
// "close": {"v": "73682510000", "e": 6, "f": 73682.51},
// "vol": {"v": "88159", "e": 8, "f": 0.00088159}
// }
// ]
// }
// }
// No limit parameter supported by the API
response:= (<-this.PublicGetMarketCurrencyPairGetGraph(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
var ohlcv interface{} = this.SafeList(data, "stats", []interface{}{})
ch <- this.ParseOHLCVs(ohlcv, market, timeframe, since, limit)
return nil
}()
return ch
}
func (this *ellipx) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
return []interface{}{Multiply(this.SafeInteger(ohlcv, "time"), 1000), this.ParseNumber(this.ParseAmount(this.SafeDict(ohlcv, "open"))), this.ParseNumber(this.ParseAmount(this.SafeDict(ohlcv, "high"))), this.ParseNumber(this.ParseAmount(this.SafeDict(ohlcv, "low"))), this.ParseNumber(this.ParseAmount(this.SafeDict(ohlcv, "close"))), this.ParseNumber(this.ParseAmount(this.SafeDict(ohlcv, "vol")))}
}
/**
* @method
* @name ellipx#fetchCurrencies
* @description fetches information on all currencies from the exchange, including deposit/withdrawal details and available chains
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.x65f9s9j74jf
* @param {object} [params] extra parameters specific to the ellipx API endpoint
* @param {string} [params.Can_Deposit] filter currencies by deposit availability, Y for available
* @param {number} [params.results_per_page] number of results per page, default 100
* @param {string} [params._expand] additional fields to expand in response, default '/Crypto_Token,/Crypto_Chain'
* @returns {Promise<Currencies>} An object of currency structures indexed by currency codes
*/
func (this *ellipx) 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._restGetCryptoTokenInfo(this.Extend(map[string]interface{} {
"Can_Deposit": "Y",
"results_per_page": 100,
"_expand": "/Crypto_Token,/Crypto_Chain",
}, params)))
PanicOnError(response)
var currencies interface{} = map[string]interface{} {}
var data interface{} = this.SafeValue(response, "data", []interface{}{})
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var currency interface{} = this.ParseCurrency(GetValue(data, i))
var code interface{} = this.SafeString(currency, "code")
if IsTrue(!IsEqual(code, nil)) {
AddElementToObject(currencies, code, currency)
}
}
ch <- currencies
return nil
}()
return ch
}
func (this *ellipx) ParseCurrency(currency interface{}) interface{} {
var id interface{} = this.SafeString(currency, "Crypto_Token__")
var token interface{} = this.SafeValue(currency, "Crypto_Token", map[string]interface{} {})
var code interface{} = this.SafeCurrencyCode(this.SafeString(token, "Symbol"))
var name interface{} = this.SafeString(token, "Name")
var active interface{} = IsEqual(this.SafeString(currency, "Status"), "valid")
var deposit interface{} = IsEqual(this.SafeString(currency, "Can_Deposit"), "Y")
var withdraw interface{} = IsEqual(this.SafeString(currency, "Status"), "valid")
var fee interface{} = nil
if IsTrue(!IsEqual(GetValue(currency, "Withdraw_Fee"), nil)) {
fee = this.ParseNumber(this.ParseAmount(GetValue(currency, "Withdraw_Fee")))
}
var precision interface{} = this.ParseNumber(this.ParsePrecision(this.SafeString(token, "Decimals")))
var minDeposit interface{} = nil
if IsTrue(!IsEqual(GetValue(currency, "Minimum_Deposit"), nil)) {
minDeposit = this.ParseAmount(GetValue(currency, "Minimum_Deposit"))
}
var minWithdraw interface{} = nil
if IsTrue(!IsEqual(GetValue(currency, "Minimum_Withdraw"), nil)) {
minWithdraw = this.ParseAmount(GetValue(currency, "Minimum_Withdraw"))
}
var networkId interface{} = this.SafeString(currency, "Crypto_Chain__")
var networkData interface{} = this.SafeValue(currency, "Crypto_Chain", map[string]interface{} {})
var networkCode interface{} = this.SafeString(networkData, "Type", "default")
var networks interface{} = map[string]interface{} {
"string": nil,
"info": Ternary(IsTrue(IsEqual(networkCode, "default")), map[string]interface{} {}, networkData),
"id": IsTrue(IsTrue(networkId) || IsTrue(id)) || IsTrue(""),
"network": networkCode,
"active": active,
"deposit": deposit,
"withdraw": withdraw,
"fee": fee,
"precision": precision,
"limits": map[string]interface{} {
"deposit": map[string]interface{} {
"min": minDeposit,
"max": nil,
},
"withdraw": map[string]interface{} {
"min": minWithdraw,
"max": nil,
},
},
}
var result interface{} = map[string]interface{} {
"info": currency,
"id": id,
"code": code,
"name": name,
"active": active,
"deposit": deposit,
"withdraw": withdraw,
"fee": fee,
"precision": precision,
"type": nil,
"limits": map[string]interface{} {
"amount": map[string]interface{} {
"min": nil,
"max": nil,
},
"withdraw": map[string]interface{} {
"min": minWithdraw,
"max": nil,
},
},
"networks": networks,
}
return result
}
/**
* @method
* @name ellipx#fetchTrades
* @description fetches all completed trades for a particular market/symbol
* @param {string} symbol unified market symbol (e.g. 'BTC/USDT')
* @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 EllipX API endpoint
* @param {string} [params.before] get trades before the given trade ID
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
*/
func (this *ellipx) 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
retRes9118 := (<-this.LoadMarkets())
PanicOnError(retRes9118)
var market interface{} = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
var request interface{} = map[string]interface{} {
"currencyPair": marketId,
}
// endpoint support before trade id.
// The actual endpoint URL will be: https://data.ellipx.com/Market/{currencyPair}:getTrades
// {
// "id": "BTC_USDC:1731053859:914141972:0",
// "pair": [
// "BTC",
// "USDC"
// ],
// "bid": {
// "id": "mktor-swishf-uv6n-hrzj-63ye-bdqnk33q",
// "iss": "ellipx:beta",
// "uniq": "order:1731053859:914141972:0"
// },
// "ask": {
// "id": "mktor-p3ozvt-qurz-gmzo-bf5n-g4rcuy6u",
// "iss": "ellipx:beta",
// "uniq": "order:1731053859:874659786:0"
// },
// "type": "bid",
// "amount": {
// "v": "412",
// "e": 8,
// "f": 0.00000412
// },
// "price": {
// "v": "75878090000",
// "e": 6,
// "f": 75878.09
// },
// "date": "2024-11-08T08:17:39.914141972Z"
// }
response:= (<-this.PublicGetMarketCurrencyPairGetTrades(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
var trades interface{} = this.SafeList(data, "trades", []interface{}{})
ch <- this.ParseTrades(trades, market, since, limit)
return nil
}()
return ch
}
func (this *ellipx) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
// Format of trade ID: "BTC_USDC:1731053859:914141972:0"
market := GetArg(optionalArgs, 0, nil)
_ = market
var id interface{} = this.SafeString(trade, "id")
// fetchTrades and fetchMyTrades return different trade structures
var date interface{} = this.SafeDict(trade, "date")
var timestamp interface{} = nil
if IsTrue(IsEqual(date, nil)) {
timestamp = this.Parse8601(this.SafeString(trade, "date"))
} else {
timestamp = this.SafeInteger(date, "unixms")
}
var typeVar interface{} = this.SafeString(trade, "type")
var side interface{} = Ternary(IsTrue((IsEqual(typeVar, "bid"))), "buy", "sell")
var amount interface{} = this.SafeDict(trade, "amount")
var price interface{} = this.SafeDict(trade, "price")
var amountFloat interface{} = this.ParseAmount(amount)
var priceFloat interface{} = this.ParseAmount(price)
// fetchTrades and fetchMyTrades return different trade structures
var pair interface{} = this.SafeList(trade, "pair")
var marketSymbol interface{} = nil
if IsTrue(IsEqual(pair, nil)) {
var symbol interface{} = this.SafeString(trade, "pair")
basequoteVariable := Split(symbol, "_");
base := GetValue(basequoteVariable,0);
quote := GetValue(basequoteVariable,1)
marketSymbol = Add(Add(base, "/"), quote)
} else {
marketSymbol = Add(Add(this.SafeString(pair, 0), "/"), this.SafeString(pair, 1))
}
var bidOrder interface{} = this.SafeDict(trade, "bid")
var askOrder interface{} = this.SafeDict(trade, "ask")
var isBuy interface{} = (IsEqual(side, "buy"))
var orderId interface{} = Ternary(IsTrue(isBuy), this.SafeString(bidOrder, "id"), this.SafeString(askOrder, "id"))
return this.SafeTrade(map[string]interface{} {
"id": id,
"info": trade,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"symbol": marketSymbol,
"type": nil,
"side": side,
"order": orderId,
"takerOrMaker": nil,
"price": priceFloat,
"amount": amountFloat,
"cost": nil,
"fee": nil,
})
}
/**
* @method
* @name ellipx#fetchBalance
* @description query for balance and get the amount of funds available for trading or funds locked in orders
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.ihrjov144txg
* @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 *ellipx) 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
retRes10118 := (<-this.LoadMarkets())
PanicOnError(retRes10118)
response:= (<-this.PrivateGetUserWallet(params))
PanicOnError(response)
// {
// "User_Wallet__": "usw-vv7hzo-qel5-gupk-neqi-7f3wz5pq",
// "User__": "usr-...",
// "Realm__": "usrr-cb3c7n-qvxv-fdrb-uc2q-gpja2foi",
// "Unit__": "unit-aebkye-u35b-e5zm-zt22-2qvwhsqa",
// "Balance": {
// "value": "0.00006394",
// "value_int": "6394",
// "value_disp": "0.00006394",
// "value_xint": {
// "v": "6394",
// "e": 8,
// "f": 0.00006394
// },
// "display": "0.00006394BTC",
// "display_short": "0.00006394BTC",
// "currency": "BTC",
// "unit": "BTC",
// "has_vat": false,
// "tax_profile": null
// },
// "Balance_Date": {
// "unix": 1731128270,
// "us": 426208,
// "iso": "2024-11-09 04:57:50.426208",
// "tz": "UTC",
// "full": "1731128270426208",
// "unixms": "1731128270426"
// },
// "Liabilities": {
// "value": "0.00000000",
// "value_int": "0",
// "value_disp": "0.00000000",
// "value_xint": {
// "v": "0",
// "e": 8,
// "f": 0
// },
// "display": "0.00000000BTC",
// "display_short": "0.00000000BTC",
// "currency": "BTC",
// "unit": "BTC",
// "has_vat": false,
// "tax_profile": null
// },
// "Index": "5",
// "Backend": "virtual",
// "Disable_Limits": "N",
// "Unencumbered_Balance": {
// "value": "0.00006394",
// "value_int": "6394",
// "value_disp": "0.00006394",
// "value_xint": {
// "v": "6394",
// "e": 8,
// "f": 0.00006394
// },
// "display": "0.00006394BTC",
// "display_short": "0.00006394BTC",
// "currency": "BTC",
// "unit": "BTC",
// "has_vat": false,
// "tax_profile": null
// }
// }
var result interface{} = map[string]interface{} {
"info": response,
"timestamp": nil,
"datetime": nil,
}
var dataArray interface{} = this.SafeList(response, "data", []interface{}{})
// Use first item's timestamp if available
var dataArrayLength interface{} = GetArrayLength(dataArray)
if IsTrue(IsGreaterThan(dataArrayLength, 0)) {
var firstItem interface{} = GetValue(dataArray, 0)
var balanceDate interface{} = this.SafeDict(firstItem, "Balance_Date", map[string]interface{} {})
AddElementToObject(result, "timestamp", this.SafeInteger(balanceDate, "unixms"))
AddElementToObject(result, "datetime", this.Iso8601(GetValue(result, "timestamp")))
}
// Process each balance entry
for i := 0; IsLessThan(i, GetArrayLength(dataArray)); i++ {
var entry interface{} = GetValue(dataArray, i)
var balance interface{} = this.SafeDict(entry, "Balance", map[string]interface{} {})
var currency interface{} = this.SafeString(balance, "currency")
if IsTrue(!IsEqual(currency, nil)) {
var account interface{} = map[string]interface{} {
"free": this.ParseAmount(GetValue(GetValue(entry, "Unencumbered_Balance"), "value_xint")),
"used": this.ParseAmount(GetValue(GetValue(entry, "Liabilities"), "value_xint")),
"total": this.ParseAmount(GetValue(balance, "value_xint")),
}
AddElementToObject(result, currency, account)
}
}
ch <- this.SafeBalance(result)
return nil
}()
return ch
}
/**
* @method
* @name ellipx#createOrder
* @description create a new order in a market
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.yzfak2n2bwpo
* @param {string} symbol unified market symbol (e.g. 'BTC/USDT')
* @param {string} type order type - the exchange automatically sets type to 'limit' if price defined, 'market' if undefined
* @param {string} side 'buy' or 'sell'
* @param {float} [amount] amount of base currency to trade (can be undefined if using Spend_Limit)
* @param {float} [price] price per unit of base currency for limit orders
* @param {object} [params] extra parameters specific to the EllipX API endpoint
* @param {float} [params.cost] maximum amount to spend in quote currency (required for market orders if amount undefined)
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *ellipx) 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
retRes11248 := (<-this.LoadMarkets())
PanicOnError(retRes11248)
var market interface{} = this.Market(symbol)
// the exchange automatically sets the type to 'limit' if the price is defined and to 'market' if it is not
var marketId interface{} = GetValue(market, "id")
var orderType interface{} = "bid"
if IsTrue(IsEqual(side, "buy")) {
orderType = "bid"
} else {
orderType = "ask"
}
var request interface{} = map[string]interface{} {
"currencyPair": marketId,
"Type": orderType,
}
if IsTrue(!IsEqual(amount, nil)) {
AddElementToObject(request, "Amount", this.AmountToPrecision(symbol, amount))
}
if IsTrue(!IsEqual(price, nil)) {
AddElementToObject(request, "Price", this.PriceToPrecision(symbol, price))
}
var cost interface{} = this.SafeString(params, "cost")
if IsTrue(!IsEqual(cost, nil)) {
params = this.Omit(params, "cost")
AddElementToObject(request, "Spend_Limit", this.PriceToPrecision(symbol, cost))
}
response:= (<-this.PrivatePostMarketCurrencyPairOrder(this.Extend(request, params)))
PanicOnError(response)
// {
// "result": "success",
// "data": {
// "Market_Order__": "mktor-x2grmu-zwo5-fyxc-4gue-vd4ouvsa",
// "Market__": "mkt-lrnp2e-eaor-eobj-ua73-75j6sjxe",
// "User__": "usr-...",
// "Uniq": "order:1728719021:583795548:0",
// "Type": "bid",
// "Status": "pending",
// "Flags": {},
// "Amount": {
// "v": "100000000",
// "e": 8,
// "f": 1
// },
// "Price": null,
// "Spend_Limit": {
// "v": "1000000",
// "e": 6,
// "f": 1
// },
// "Executed": {
// "v": "0",
// "e": 0,
// "f": 0
// },
// "Secured": {
// "v": "1000000",
// "e": 6,
// "f": 1
// },
// "Version": "0",
// "Created": {
// "unix": 1728719020,
// "us": 315195,
// "iso": "2024-10-12 07:43:40.315195",
// "tz": "UTC",
// "full": "1728719020315195",
// "unixms": "1728719020315"
// },
// "Updated": {
// "unix": 1728719020,
// "us": 315195,
// "iso": "2024-10-12 07:43:40.315195",
// "tz": "UTC",
// "full": "1728719020315195",
// "unixms": "1728719020315"
// }
// }
// }
var order interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- this.ParseOrder(order, market)
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchOrder
* @description fetches information on an order made by the user
* @param {string} id the order ID as returned by createOrder or fetchOrders
* @param {string|undefined} symbol not used by ellipx.fetchOrder
* @param {object} [params] extra parameters specific to the EllipX API endpoint
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *ellipx) 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
retRes12148 := (<-this.LoadMarkets())
PanicOnError(retRes12148)
var request interface{} = map[string]interface{} {
"orderUuid": id,
}
response:= (<-this.PrivateGetMarketOrderOrderUuid(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- this.ParseOrder(data, nil)
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchOrdersByStatus
* @description fetches a list of orders placed on the exchange
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.5z2nh2b5s81n
* @param {string} status 'open' or 'closed', omit for all orders
* @param {string} symbol unified market symbol
* @param {int} [since] timestamp in ms of the earliest order
* @param {int} [limit] the maximum amount of orders to fetch
* @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 *ellipx) FetchOrdersByStatus(status interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes12368 := (<-this.LoadMarkets())
PanicOnError(retRes12368)
var market interface{} = nil
var request interface{} = map[string]interface{} {}
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
AddElementToObject(request, "currencyPair", marketId)
}
if IsTrue(!IsEqual(status, nil)) {
AddElementToObject(request, "Status", status)
}
response:= (<-this.PrivateGetMarketCurrencyPairOrder(this.Extend(request, params)))
PanicOnError(response)
// {
// "result": "success",
// "data": [
// {
// "Market_Order__": "mktor-aglvd2-iy5v-enbj-nwrb-scqsnosa",
// "Market__": "mkt-lrnp2e-eaor-eobj-ua73-75j6sjxe",
// "User__": "usr-...",
// "Uniq": "order:1728712511:964332600:0",
// "Type": "ask",
// "Status": "open",
// "Flags": {},
// "Amount": {
// "v": "1",
// "e": 8,
// "f": 1.0e-8
// },
// "Price": {
// "v": "63041306872",
// "e": 6,
// "f": 63041.306872
// },
// "Spend_Limit": null,
// "Executed": {
// "v": "892",
// "e": 8,
// "f": 8.92e-6
// },
// "Secured": null,
// "Version": "3",
// "Created": {
// "unix": 1728712510,
// "us": 669096,
// "iso": "2024-10-12 05:55:10.669096",
// "tz": "UTC",
// "full": "1728712510669096",
// "unixms": "1728712510669"
// },
// "Updated": {
// "unix": 1728712510,
// "us": 669096,
// "iso": "2024-10-12 05:55:10.669096",
// "tz": "UTC",
// "full": "1728712510669096",
// "unixms": "1728712510669"
// }
// }
// ],
// "paging": {
// "page_no": 1,
// "count": "1",
// "page_max": 1,
// "results_per_page": 20
// }
// }
var data interface{} = this.SafeValue(response, "data", []interface{}{})
ch <- this.ParseOrders(data, market, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchOrders
* @description fetches information on multiple orders made by the user
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.5z2nh2b5s81n
* @param {string} symbol unified market symbol of the market orders were made in
* @param {int|undefined} since timestamp in ms of the earliest order
* @param {int|undefined} limit the maximum amount of orders to fetch
* @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 *ellipx) FetchOrders(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchOrders requires a symbol parameter")))
}
retRes132115 := (<-this.FetchOrdersByStatus(nil, symbol, since, limit, params))
PanicOnError(retRes132115)
ch <- retRes132115
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchOpenOrders
* @description fetches information on open orders made by the user
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.5z2nh2b5s81n
* @param {string} symbol unified market symbol of the market orders were made in
* @param {int|undefined} since timestamp in ms of the earliest order
* @param {int|undefined} limit the maximum amount of orders to fetch
* @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 *ellipx) FetchOpenOrders(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchOpenOrders requires a symbol parameter")))
}
retRes133915 := (<-this.FetchOrdersByStatus("open", symbol, since, limit, params))
PanicOnError(retRes133915)
ch <- retRes133915
return nil
}()
return ch
}
func (this *ellipx) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
var id interface{} = this.SafeString(order, "Market_Order__")
var timestamp interface{} = this.SafeInteger(this.SafeDict(order, "Created"), "unixms")
var orderType interface{} = this.SafeString(order, "Type")
var side interface{} = "sell"
if IsTrue(IsEqual(orderType, "bid")) {
side = "buy"
}
var status interface{} = this.ParseOrderStatus(this.SafeString(order, "Status"))
var amount interface{} = this.ParseNumber(this.ParseAmount(this.SafeDict(order, "Amount")))
var price interface{} = this.ParseNumber(this.ParseAmount(this.SafeDict(order, "Price")))
var typeVar interface{} = Ternary(IsTrue((IsEqual(price, nil))), "market", "limit")
var executed interface{} = this.ParseNumber(this.ParseAmount(this.SafeDict(order, "Executed")))
var filled interface{} = executed
var remaining interface{} = this.ParseNumber(this.ParseAmount(this.SafeDict(order, "Secured")))
var cost interface{} = this.ParseNumber(this.ParseAmount(this.SafeDict(order, "Total_Spent")))
var symbol interface{} = Ternary(IsTrue(market), GetValue(market, "symbol"), nil)
var clientOrderId interface{} = nil
var timeInForce interface{} = "GTC" // default to Good Till Cancelled
var postOnly interface{} = false
var updated interface{} = this.SafeDict(order, "Updated", map[string]interface{} {})
var lastTradeTimestamp interface{} = this.SafeInteger(updated, "unixms", nil)
return this.SafeOrder(map[string]interface{} {
"id": id,
"clientOrderId": clientOrderId,
"info": order,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"lastTradeTimestamp": lastTradeTimestamp,
"status": this.ParseOrderStatus(status),
"symbol": symbol,
"type": typeVar,
"timeInForce": timeInForce,
"postOnly": postOnly,
"side": side,
"price": price,
"triggerPrice": nil,
"average": nil,
"cost": cost,
"amount": amount,
"filled": filled,
"remaining": remaining,
"fee": nil,
"trades": nil,
}, market)
}
/**
* @method
* @name ellipx#cancelOrder
* @description Cancels an open order on the exchange
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.f1qu1pb1rebn
* @param {string} id - The order ID to cancel (format: mktor-xxxxx-xxxx-xxxx-xxxx-xxxxxxxx)
* @param {string} [symbol] - ellipx.cancelOrder does not use the symbol parameter
* @param {object} [params] - Extra parameters specific to the exchange API
* @returns {Promise<object>} A Promise that resolves to the canceled order info
*/
func (this *ellipx) 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
retRes14008 := (<-this.LoadMarkets())
PanicOnError(retRes14008)
var request interface{} = map[string]interface{} {
"orderUuid": id,
}
response:= (<-this.PrivateDeleteMarketOrderOrderUuid(this.Extend(request, params)))
PanicOnError(response)
// {
// result: "success",
// request_id: "887dba33-d11b-43f0-8034-dd7890882cc5",
// time: "0.8975801467895508",
// data: true,
// access: {
// "mktor-rf5k5b-5fhf-dmde-wxqj-3y23jeii": {
// required: "A",
// available: "O",
// },
// },
// }
// this endpoint always returns true and a warning message if the order cancelled before.
var warningResponse interface{} = this.SafeValue(response, "warning", nil)
var statusResponse interface{} = this.SafeBool(response, "data")
var status interface{} = "canceled"
if IsTrue(IsTrue(!IsEqual(statusResponse, true)) || IsTrue(!IsEqual(warningResponse, nil))) {
status = "closed"
}
ch <- this.SafeOrder(map[string]interface{} {
"id": id,
"clientOrderId": nil,
"info": this.Json(response),
"timestamp": nil,
"datetime": nil,
"lastTradeTimestamp": nil,
"status": status,
"symbol": nil,
"type": nil,
"timeInForce": nil,
"postOnly": nil,
"side": nil,
"price": nil,
"triggerPrice": nil,
"average": nil,
"cost": nil,
"amount": nil,
"filled": nil,
"remaining": nil,
"fee": nil,
"trades": nil,
}, nil)
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchOrderTrades
* @description fetch all the trades made from a single order
* @param {string} id order id
* @param {string} symbol unified market symbol
* @param {int} [since] the earliest time in ms to fetch trades for
* @param {int} [limit] the maximum number of trades to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
*/
func (this *ellipx) FetchOrderTrades(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired("fetchMyTrades requires a symbol parameter"))
}
retRes14648 := (<-this.LoadMarkets())
PanicOnError(retRes14648)
var market interface{} = this.Market(symbol)
var currencyPair interface{} = GetValue(market, "id")
var request interface{} = map[string]interface{} {
"Market_Order__": id,
"currencyPair": currencyPair,
}
response:= (<-this.PrivateGetMarketCurrencyPairTrade(this.Extend(request, params)))
PanicOnError(response)
// {
// "result": "success",
// "request_id": "fc5be99d-d085-46f8-9228-e46d0996f112",
// "time": 0.030913114547729492,
// "data": [
// {
// "id": "DOGE_USDC:1731505789:911642994:0",
// "pair": "DOGE_USDC",
// "bid": {
// "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
// },
// "ask": {
// "id": "mktor-oxmac4-mtkf-gi3o-mamg-u2cboqe4"
// },
// "type": "bid",
// "amount": {
// "v": "334609419",
// "e": 8,
// "f": 3.34609419
// },
// "price": {
// "v": "410673",
// "e": 6,
// "f": 0.410673
// },
// "date": {
// "unix": 1731505789,
// "us": 911642,
// "iso": "2024-11-13 13:49:49.911642",
// "tz": "UTC",
// "full": "1731505789911642",
// "unixms": "1731505789911"
// }
// },
// {
// "id": "DOGE_USDC:1731505789:911642994:4",
// "pair": "DOGE_USDC",
// "bid": {
// "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
// },
// "ask": {
// "id": "mktor-cmtztk-3z3n-gupp-uqdg-74g4wjfq"
// },
// "type": "bid",
// "amount": {
// "v": "145453950",
// "e": 8,
// "f": 1.4545395
// },
// "price": {
// "v": "412589",
// "e": 6,
// "f": 0.412589
// },
// "date": {
// "unix": 1731505789,
// "us": 911642,
// "iso": "2024-11-13 13:49:49.911642",
// "tz": "UTC",
// "full": "1731505789911642",
// "unixms": "1731505789911"
// }
// },
// {
// "id": "DOGE_USDC:1731505789:911642994:2",
// "pair": "DOGE_USDC",
// "bid": {
// "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
// },
// "ask": {
// "id": "mktor-6tyslh-b33b-flnm-2ata-acjkco4y"
// },
// "type": "bid",
// "amount": {
// "v": "587627076",
// "e": 8,
// "f": 5.87627076
// },
// "price": {
// "v": "411005",
// "e": 6,
// "f": 0.411005
// },
// "date": {
// "unix": 1731505789,
// "us": 911642,
// "iso": "2024-11-13 13:49:49.911642",
// "tz": "UTC",
// "full": "1731505789911642",
// "unixms": "1731505789911"
// }
// },
// {
// "id": "DOGE_USDC:1731505789:911642994:1",
// "pair": "DOGE_USDC",
// "bid": {
// "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
// },
// "ask": {
// "id": "mktor-ihpjlj-5ufj-dm5l-fmud-oftkqcgu"
// },
// "type": "bid",
// "amount": {
// "v": "475845734",
// "e": 8,
// "f": 4.75845734
// },
// "price": {
// "v": "410830",
// "e": 6,
// "f": 0.41083
// },
// "date": {
// "unix": 1731505789,
// "us": 911642,
// "iso": "2024-11-13 13:49:49.911642",
// "tz": "UTC",
// "full": "1731505789911642",
// "unixms": "1731505789911"
// }
// },
// {
// "id": "DOGE_USDC:1731505789:911642994:3",
// "pair": "DOGE_USDC",
// "bid": {
// "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
// },
// "ask": {
// "id": "mktor-d2uyb3-nzsj-aevn-dikr-tq3sxhre"
// },
// "type": "bid",
// "amount": {
// "v": "641013461",
// "e": 8,
// "f": 6.41013461
// },
// "price": {
// "v": "411846",
// "e": 6,
// "f": 0.411846
// },
// "date": {
// "unix": 1731505789,
// "us": 911642,
// "iso": "2024-11-13 13:49:49.911642",
// "tz": "UTC",
// "full": "1731505789911642",
// "unixms": "1731505789911"
// }
// }
// ],
// "access": {
// "mkt-xrkg5l-akjz-cxxl-3a2e-mul5gfo4": {
// "required": "r",
// "available": "?"
// },
// "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4": {
// "required": "R",
// "available": "O"
// }
// },
// "paging": {
// "page_no": 1,
// "count": "5",
// "page_max": 1,
// "results_per_page": 20
// }
// }
var data interface{} = this.SafeList(response, "data")
ch <- this.ParseTrades(data, market, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchDepositAddress
* @description fetches a crypto deposit address for a specific currency
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.k7qe5aricayh
* @param {string} code unified currency code (e.g. "BTC", "ETH", "USDT")
* @param {object} [params] extra parameters specific to the EllipX API endpoint
* @returns {object} an address structure {
* 'currency': string, // unified currency code
* 'address': string, // the address for deposits
* 'tag': string|undefined, // tag/memo for deposits if needed
* 'network': object, // network object from currency info
* 'info': object // raw response from exchange
* }
* @throws {ExchangeError} if currency does not support deposits
*/
func (this *ellipx) FetchDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes16618 := (<-this.LoadMarkets())
PanicOnError(retRes16618)
var currency interface{} = this.Currency(code)
var network interface{} = this.SafeValue(GetValue(currency, "info"), "Crypto_Chain", nil)
var request interface{} = map[string]interface{} {
"Crypto_Token__": this.SafeString(network, "Crypto_Token__"),
"Crypto_Chain__": this.SafeString(network, "Crypto_Chain__"),
}
response:= (<-this.PrivatePostCryptoAddressFetch(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeValue(response, "data", map[string]interface{} {})
var address interface{} = this.SafeString(data, "Address")
var tag interface{} = this.SafeString(data, "memo")
this.CheckAddress(address)
ch <- map[string]interface{} {
"currency": code,
"address": address,
"tag": tag,
"network": network,
"info": response,
}
return nil
}()
return ch
}
/**
* @method
* @name ellipx#fetchTradingFee
* @description Fetches the current trading fees (maker and taker) applicable to the user.
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.kki5jay2c8it
* @param {string} [symbol] Not used by EllipX as fees are not symbol-specific.
* @param {object} [params] Extra parameters specific to the EllipX API endpoint.
* @returns {Promise<object>} A promise resolving to a unified trading fee structure:
* {
* 'info': object, // the raw response from the exchange
* 'symbol': undefined, // symbol is not used for this exchange
* 'maker': number, // maker fee rate in decimal form
* 'taker': number, // taker fee rate in decimal form
* 'percentage': true, // indicates fees are in percentage
* 'tierBased': false, // indicates fees do not vary by volume tiers
* }
*/
func (this *ellipx) FetchTradingFee(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes17008 := (<-this.LoadMarkets())
PanicOnError(retRes17008)
response:= (<-this.PrivateGetMarketTradeFeeQuery(params))
PanicOnError(response)
//
// Example response:
// {
// "result": "success",
// "data": {
// "maker": 15.0, // in basis points
// "taker": 25.0, // in basis points
// "volume": 123456.78,
// "promo": {
// // promotional discounts if any
// }
// }
// }
//
var data interface{} = this.SafeValue(response, "data", map[string]interface{} {})
var maker interface{} = this.SafeNumber(data, "maker") // in basis points
var taker interface{} = this.SafeNumber(data, "taker") // in basis points
var makerFee interface{} = Ternary(IsTrue((!IsEqual(maker, nil))), Divide(maker, 10000), nil)
var takerFee interface{} = Ternary(IsTrue((!IsEqual(taker, nil))), Divide(taker, 10000), nil)
ch <- map[string]interface{} {
"info": response,
"symbol": nil,
"maker": makerFee,
"taker": takerFee,
"percentage": true,
"tierBased": true,
}
return nil
}()
return ch
}
/**
* @method
* @name ellipx#withdraw
* @description Make a withdrawal request
* @see https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.zegupoa8g4t9
* @param {string} code Currency code
* @param {number} amount Amount to withdraw
* @param {string} address Destination wallet address
* @param {string} [tag] Additional tag/memo for currencies that require it
* @param {object} params Extra parameters specific to the EllipX API endpoint (Crypto_Chain__, Unit__)
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
*/
func (this *ellipx) 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
this.CheckAddress(address)
retRes17458 := (<-this.LoadMarkets())
PanicOnError(retRes17458)
var currency interface{} = this.Currency(code)
var networks interface{} = this.SafeValue(currency, "networks")
if IsTrue(IsEqual(networks, nil)) {
panic(NotSupported(Add(Add(Add(this.Id, " withdraw() for "), code), " is not supported")))
}
chainsResponse:= (<-this.PrivateGetUnitCurrency(map[string]interface{} {
"currency": GetValue(currency, "code"),
}))
PanicOnError(chainsResponse) // fetch Unit__ params for currency
var chainsData interface{} = this.SafeValue(chainsResponse, "data", []interface{}{})
var unit interface{} = this.SafeString(chainsData, "Unit__")
// check params again and omit params
this.Omit(params, "Unit__")
this.Omit(params, "Crypto_Chain__")
var amountString interface{} = ToString(amount)
var request interface{} = map[string]interface{} {
"Unit__": unit,
"amount": amountString,
"address": address,
"Crypto_Chain__": GetValue(networks, "id"),
}
if IsTrue(!IsEqual(tag, nil)) {
AddElementToObject(request, "memo", tag)
}
response:= (<-this.PrivatePostCryptoDisbursementWithdraw(this.Extend(request, params)))
PanicOnError(response)
// {
// Crypto_Disbursement__: "crdsb-4pw3kg-ipn5-amvb-da4n-6xncy4r4",
// Crypto_Token__: "crtok-dnehz4-wbgv-bunf-iyd3-m7gtsz2q",
// Crypto_Chain__: "chain-kjfvwn-l2xn-eclc-ul5d-mb6fu5hm",
// User__: "usr-5oint6-ozpr-alfp-2wxi-zgbm4osy",
// Value: {
// v: "1000000000",
// e: "8",
// f: "10",
// },
// Value_USD: "4.08723",
// Address: "D6z62LUwyNBi3QbPkzW8C4m7VDAgu9wb2Z",
// Status: "pending",
// Transaction: null,
// Requested: {
// unix: "1731570982",
// us: "203569",
// iso: "2024-11-14 07:56:22.203569",
// tz: "UTC",
// full: "1731570982203569",
// unixms: "1731570982203",
// },
// Scheduled: null,
// Processed: null,
// Amount: {
// value: "10.00000000",
// value_int: "1000000000",
// value_disp: "10.00000000",
// value_xint: {
// v: "1000000000",
// e: "8",
// f: "10",
// },
// display: "10.00000000DOGE",
// display_short: "10.00000000DOGE",
// currency: "DOGE",
// unit: "DOGE",
// has_vat: false,
// tax_profile: null,
// raw: {
// value: "10.00000000",
// value_int: "1000000000",
// value_disp: "10.00000000",
// value_xint: {
// v: "1000000000",
// e: "8",
// f: "10",
// },
// display: "10.00000000DOGE",
// display_short: "10.00000000DOGE",
// currency: "DOGE",
// unit: "DOGE",
// has_vat: false,
// tax_profile: null,
// },
// tax: {
// value: "10.00000000",
// value_int: "1000000000",
// value_disp: "10.00000000",
// value_xint: {
// v: "1000000000",
// e: "8",
// f: "10",
// },
// display: "10.00000000DOGE",
// display_short: "10.00000000DOGE",
// currency: "DOGE",
// unit: "DOGE",
// has_vat: true,
// tax_profile: null,
// },
// tax_only: {
// value: "0.000",
// value_int: "0",
// value_disp: "0",
// value_xint: {
// v: "0",
// e: "3",
// f: "0",
// },
// display: "¥0",
// display_short: "¥0",
// currency: "JPY",
// unit: "JPY",
// has_vat: false,
// tax_profile: null,
// },
// tax_rate: "0",
// },
// }
var data interface{} = this.SafeDict(response, "data")
var amountResponse interface{} = this.SafeDict(data, "Amount")
var requested interface{} = this.SafeDict(data, "Requested")
var processed interface{} = this.SafeDict(data, "Processed")
var withdrawId interface{} = this.SafeString(data, "Crypto_Disbursement__")
var timestamp interface{} = this.SafeInteger(requested, "unixms")
ch <- map[string]interface{} {
"info": response,
"id": withdrawId,
"txid": nil,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"network": this.SafeString(data, "Crypto_Chain__"),
"address": this.SafeString(data, "Address"),
"addressTo": this.SafeString(data, "Address"),
"addressFrom": nil,
"tag": tag,
"tagTo": tag,
"tagFrom": nil,
"type": "withdrawal",
"amount": this.SafeNumber(amountResponse, "value"),
"currency": code,
"status": this.ParseTransactionStatus(this.SafeString(data, "Status")),
"updated": this.SafeTimestamp(processed, "unix"),
"internal": false,
"comment": nil,
"fee": map[string]interface{} {
"currency": code,
"cost": nil,
"rate": nil,
},
}
return nil
}()
return ch
}
func (this *ellipx) ParseTransactionStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"pending": "pending",
"completed": "ok",
"failed": "failed",
"cancelled": "canceled",
}
return this.SafeString(statuses, status, status)
}
func (this *ellipx) ParseOrderStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"pending": "open",
"running": "open",
"post-pending": "open",
"open": "open",
"stop": "open",
"invalid": "rejected",
"done": "closed",
"cancel": "canceled",
"canceled": "canceled",
}
return this.SafeString(statuses, status, status)
}
func (this *ellipx) ParseAmount(amount interface{}) interface{} {
var v interface{} = this.SafeString(amount, "v", nil)
var e interface{} = this.SafeInteger(amount, "e", nil)
if IsTrue(IsTrue(IsEqual(v, nil)) || IsTrue(IsEqual(e, nil))) {
return nil
}
precise := NewPrecise(v)
precise.Decimals = e
precise.Reduce()
var amountString interface{} = precise.ToString()
return amountString
}
func (this *ellipx) ToAmount(amount interface{}, precision interface{}) interface{} {
var v interface{} = ToString(amount)
var e interface{} = precision
return map[string]interface{} {
"v": v,
"e": e,
}
}
func (this *ellipx) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
// {
// "code": 404,
// "error": "Not Found: Crypto\\Token(US)",
// "exception": "Exception\\NotFound",
// "message": "[I18N:error_not_found]",
// "request": "cc83738a-2438-4f53-ae44-f15306c07f32",
// "result": "error",
// "time": 0.0089569091796875,
// "token": "error_not_found"
// }
var errorCode interface{} = this.SafeString(response, "code")
var message interface{} = this.SafeString(response, "message")
if IsTrue(!IsEqual(errorCode, nil)) {
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), errorCode, message)
panic(ExchangeError(Add(Add(this.Id, " "), message)))
}
return nil
}
func (this *ellipx) Init(userConfig map[string]interface{}) {
this.Exchange = Exchange{}
this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
this.Exchange.DerivedExchange = this
}
Reference in New Issue Copy Permalink