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

3510 lines
151 KiB
Go
Raw Permalink 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 oxfun struct {
Exchange
}
func NewOxfunCore() oxfun {
p := oxfun{}
setDefaults(&p)
return p
}
func (this *oxfun) Describe() interface{} {
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
"id": "oxfun",
"name": "OXFUN",
"countries": []interface{}{"PA"},
"version": "v3",
"rateLimit": 120,
"pro": true,
"has": map[string]interface{} {
"CORS": nil,
"spot": true,
"margin": false,
"swap": true,
"future": false,
"option": false,
"addMargin": false,
"cancelAllOrders": true,
"cancelOrder": true,
"cancelOrders": true,
"closeAllPositions": false,
"closePosition": false,
"createDepositAddress": false,
"createMarketBuyOrderWithCost": true,
"createMarketOrderWithCost": false,
"createMarketSellOrderWithCost": false,
"createOrder": true,
"createOrders": true,
"createPostOnlyOrder": true,
"createReduceOnlyOrder": false,
"createStopLimitOrder": true,
"createStopMarketOrder": true,
"createStopOrder": true,
"deposit": false,
"editOrder": false,
"fetchAccounts": true,
"fetchBalance": true,
"fetchBidsAsks": false,
"fetchBorrowInterest": false,
"fetchBorrowRateHistories": false,
"fetchBorrowRateHistory": false,
"fetchCanceledOrders": false,
"fetchClosedOrder": false,
"fetchClosedOrders": false,
"fetchCrossBorrowRate": false,
"fetchCrossBorrowRates": false,
"fetchCurrencies": true,
"fetchDeposit": false,
"fetchDepositAddress": true,
"fetchDepositAddresses": false,
"fetchDepositAddressesByNetwork": false,
"fetchDeposits": true,
"fetchDepositWithdrawFee": false,
"fetchDepositWithdrawFees": false,
"fetchFundingHistory": true,
"fetchFundingRate": "emulated",
"fetchFundingRateHistory": true,
"fetchFundingRates": true,
"fetchIndexOHLCV": false,
"fetchIsolatedBorrowRate": false,
"fetchIsolatedBorrowRates": false,
"fetchL3OrderBook": false,
"fetchLedger": false,
"fetchLeverage": false,
"fetchLeverageTiers": true,
"fetchMarketLeverageTiers": "emulated",
"fetchMarkets": true,
"fetchMarkOHLCV": false,
"fetchMyTrades": true,
"fetchOHLCV": true,
"fetchOpenInterestHistory": false,
"fetchOpenOrder": false,
"fetchOpenOrders": true,
"fetchOrder": true,
"fetchOrderBook": true,
"fetchOrderBooks": false,
"fetchOrders": false,
"fetchOrderTrades": false,
"fetchPosition": false,
"fetchPositionHistory": false,
"fetchPositionMode": false,
"fetchPositions": true,
"fetchPositionsForSymbol": false,
"fetchPositionsHistory": false,
"fetchPositionsRisk": false,
"fetchPremiumIndexOHLCV": false,
"fetchStatus": false,
"fetchTicker": true,
"fetchTickers": true,
"fetchTime": false,
"fetchTrades": true,
"fetchTradingFee": false,
"fetchTradingFees": false,
"fetchTradingLimits": false,
"fetchTransactionFee": false,
"fetchTransactionFees": false,
"fetchTransactions": false,
"fetchTransfers": true,
"fetchWithdrawal": false,
"fetchWithdrawals": true,
"fetchWithdrawalWhitelist": false,
"reduceMargin": false,
"repayCrossMargin": false,
"repayIsolatedMargin": false,
"sandbox": true,
"setLeverage": false,
"setMargin": false,
"setMarginMode": false,
"setPositionMode": false,
"signIn": false,
"transfer": true,
"withdraw": true,
"ws": true,
},
"timeframes": map[string]interface{} {
"1m": "60s",
"5m": "300s",
"15m": "900s",
"30m": "1800s",
"1h": "3600s",
"2h": "7200s",
"4h": "14400s",
"1d": "86400s",
},
"urls": map[string]interface{} {
"logo": "https://github.com/ccxt/ccxt/assets/43336371/6a196124-c1ee-4fae-8573-962071b61a85",
"referral": "https://ox.fun/register?shareAccountId=5ZUD4a7G",
"api": map[string]interface{} {
"public": "https://api.ox.fun",
"private": "https://api.ox.fun",
},
"test": map[string]interface{} {
"public": "https://stgapi.ox.fun",
"private": "https://stgapi.ox.fun",
},
"www": "https://ox.fun/",
"doc": "https://docs.ox.fun/",
"fees": "https://support.ox.fun/en/articles/8819866-trading-fees",
},
"api": map[string]interface{} {
"public": map[string]interface{} {
"get": map[string]interface{} {
"v3/markets": 1,
"v3/assets": 1,
"v3/tickers": 1,
"v3/funding/estimates": 1,
"v3/candles": 1,
"v3/depth": 1,
"v3/markets/operational": 1,
"v3/exchange-trades": 1,
"v3/funding/rates": 1,
"v3/leverage/tiers": 1,
},
},
"private": map[string]interface{} {
"get": map[string]interface{} {
"v3/account": 1,
"v3/account/names": 1,
"v3/wallet": 1,
"v3/transfer": 1,
"v3/balances": 1,
"v3/positions": 1,
"v3/funding": 1,
"v3/deposit-addresses": 1,
"v3/deposit": 1,
"v3/withdrawal-addresses": 1,
"v3/withdrawal": 1,
"v3/withdrawal-fees": 1,
"v3/orders/status": 1,
"v3/orders/working": 1,
"v3/trades": 1,
},
"post": map[string]interface{} {
"v3/transfer": 1,
"v3/withdrawal": 1,
"v3/orders/place": 1,
},
"delete": map[string]interface{} {
"v3/orders/cancel": 1,
"v3/orders/cancel-all": 1,
},
},
},
"fees": map[string]interface{} {
"trading": map[string]interface{} {
"tierBased": true,
"percentage": true,
"maker": this.ParseNumber("0.00020"),
"taker": this.ParseNumber("0.00070"),
"tiers": map[string]interface{} {
"maker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.00020")}, []interface{}{this.ParseNumber("2500000"), this.ParseNumber("0.00010")}, []interface{}{this.ParseNumber("25000000"), this.ParseNumber("0")}},
"taker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.00070")}, []interface{}{this.ParseNumber("2500000"), this.ParseNumber("0.00050")}, []interface{}{this.ParseNumber("25000000"), this.ParseNumber("0.00040")}},
},
},
},
"precisionMode": TICK_SIZE,
"options": map[string]interface{} {
"sandboxMode": false,
"networks": map[string]interface{} {
"BTC": "Bitcoin",
"ERC20": "Ethereum",
"AVAX": "Avalanche",
"SOL": "Solana",
"ARB": "Arbitrum",
"MATIC": "Polygon",
"FTM": "Fantom",
"BNB": "BNBSmartChain",
"OPTIMISM": "Optimism",
},
"networksById": map[string]interface{} {
"Bitcoin": "BTC",
"Ethereum": "ERC20",
"Avalanche": "AVAX",
"Solana": "SOL",
"Arbitrum": "ARB",
"Polygon": "MATIC",
"Fantom": "FTM",
"Base": "BASE",
"BNBSmartChain": "BNB",
"Optimism": "OPTIMISM",
},
},
"features": map[string]interface{} {
"default": map[string]interface{} {
"sandbox": true,
"createOrder": map[string]interface{} {
"marginMode": false,
"triggerPrice": true,
"triggerDirection": false,
"triggerPriceType": nil,
"stopLossPrice": false,
"takeProfitPrice": false,
"attachedStopLossTakeProfit": nil,
"timeInForce": map[string]interface{} {
"IOC": true,
"FOK": true,
"PO": true,
"GTD": false,
},
"hedged": false,
"trailing": false,
"leverage": false,
"marketBuyByCost": true,
"marketBuyRequiresPrice": false,
"selfTradePrevention": true,
"iceberg": true,
},
"createOrders": map[string]interface{} {
"max": 10,
},
"fetchMyTrades": map[string]interface{} {
"marginMode": false,
"limit": 500,
"daysBack": 100000,
"untilDays": 7,
"symbolRequired": false,
},
"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": false,
},
"fetchOrders": nil,
"fetchClosedOrders": nil,
"fetchOHLCV": map[string]interface{} {
"limit": 500,
},
},
"spot": map[string]interface{} {
"extends": "default",
},
"swap": map[string]interface{} {
"linear": map[string]interface{} {
"extends": "default",
},
"inverse": nil,
},
"future": map[string]interface{} {
"linear": nil,
"inverse": nil,
},
},
"exceptions": map[string]interface{} {
"exact": map[string]interface{} {
"-0010": OperationFailed,
"-429": RateLimitExceeded,
"-05001": AuthenticationError,
"-10001": ExchangeError,
"-20000": BadRequest,
"-20001": BadRequest,
"-20002": BadRequest,
"-20003": NotSupported,
"-20005": AuthenticationError,
"-20006": BadRequest,
"-20007": AuthenticationError,
"-20008": BadRequest,
"-20009": BadRequest,
"-20010": ArgumentsRequired,
"-20011": ArgumentsRequired,
"-20012": ArgumentsRequired,
"-20013": ArgumentsRequired,
"-20014": BadRequest,
"-20015": BadSymbol,
"-20016": BadRequest,
"-20017": BadRequest,
"-20018": BadRequest,
"-20019": BadRequest,
"-20020": BadRequest,
"-20021": BadRequest,
"-20022": ArgumentsRequired,
"-20023": ArgumentsRequired,
"-20024": ExchangeError,
"-20025": AuthenticationError,
"-20026": BadRequest,
"-20027": BadRequest,
"-20028": BadRequest,
"-20029": BadRequest,
"-20030": BadRequest,
"-20031": MarketClosed,
"-20032": NetworkError,
"-20033": BadRequest,
"-20034": BadRequest,
"-20050": ExchangeError,
"-30001": BadRequest,
"-35034": AuthenticationError,
"-35046": AuthenticationError,
"-40001": ExchangeError,
"-50001": ExchangeError,
"-300001": AccountNotEnabled,
"-300011": InvalidOrder,
"-300012": InvalidOrder,
"-100005": OrderNotFound,
"-100006": InvalidOrder,
"-100008": BadRequest,
"-100015": NetworkError,
"-710001": ExchangeError,
"-710002": BadRequest,
"-710003": BadRequest,
"-710004": BadRequest,
"-710005": InsufficientFunds,
"-710006": InsufficientFunds,
"-710007": InsufficientFunds,
"-000101": NetworkError,
"-000201": NetworkError,
},
"broad": map[string]interface{} {
"-20001": OperationFailed,
"-200050": RequestTimeout,
},
},
})
}
/**
* @method
* @name oxfun#fetchMarkets
* @description retrieves data on all markets for bitmex
* @see https://docs.ox.fun/?json#get-v3-markets
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} an array of objects representing market data
*/
func (this *oxfun) 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
responseFromMarketsresponseFromTickersVariable := (<-promiseAll([]interface{}{this.PublicGetV3Markets(params), this.PublicGetV3Tickers(params)}));
responseFromMarkets := GetValue(responseFromMarketsresponseFromTickersVariable,0);
responseFromTickers := GetValue(responseFromMarketsresponseFromTickersVariable,1)
var marketsFromMarkets interface{} = this.SafeList(responseFromMarkets, "data", []interface{}{})
//
// {
// success: true,
// data: [
// {
// marketCode: 'OX-USD-SWAP-LIN',
// name: 'OX/USD Perp',
// referencePair: 'OX/USDT',
// base: 'OX',
// counter: 'USD',
// type: 'FUTURE',
// tickSize: '0.00001',
// minSize: '1',
// listedAt: '1704766320000',
// upperPriceBound: '0.02122',
// lowerPriceBound: '0.01142',
// markPrice: '0.01632',
// indexPrice: '0.01564',
// lastUpdatedAt: '1714762235569'
// },
// {
// marketCode: 'BTC-USD-SWAP-LIN',
// name: 'BTC/USD Perp',
// referencePair: 'BTC/USDT',
// base: 'BTC',
// counter: 'USD',
// type: 'FUTURE',
// tickSize: '1',
// minSize: '0.0001',
// listedAt: '1704686640000',
// upperPriceBound: '67983',
// lowerPriceBound: '55621',
// markPrice: '61802',
// indexPrice: '61813',
// lastUpdatedAt: '1714762234765'
// },
// {
// "marketCode": "MILK-OX",
// "name": "MILK/OX",
// "referencePair": "MILK/OX",
// "base": "MILK",
// "counter": "OX",
// "type": "SPOT",
// "tickSize": "0.0001",
// "minSize": "1",
// "listedAt": "1706608500000",
// "upperPriceBound": "1.0000",
// "lowerPriceBound": "-1.0000",
// "markPrice": "0.0269",
// "indexPrice": "0.0269",
// "lastUpdatedAt": "1714757402185"
// },
// ...
// ]
// }
//
var marketsFromTickers interface{} = this.SafeList(responseFromTickers, "data", []interface{}{})
//
// {
// "success": true,
// "data": [
// {
// "marketCode": "DYM-USD-SWAP-LIN",
// "markPrice": "3.321",
// "open24h": "3.315",
// "high24h": "3.356",
// "low24h": "3.255",
// "volume24h": "0",
// "currencyVolume24h": "0",
// "openInterest": "1768.1",
// "lastTradedPrice": "3.543",
// "lastTradedQuantity": "1.0",
// "lastUpdatedAt": "1714853388102"
// },
// ...
// ]
// }
//
var markets interface{} = this.ArrayConcat(marketsFromMarkets, marketsFromTickers)
ch <- this.ParseMarkets(markets)
return nil
}()
return ch
}
func (this *oxfun) ParseMarkets(markets interface{}) interface{} {
var marketIds interface{} = []interface{}{}
var result interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(markets)); i++ {
var market interface{} = GetValue(markets, i)
var marketId interface{} = this.SafeString(market, "marketCode")
if !IsTrue((this.InArray(marketId, marketIds))) {
AppendToArray(&marketIds,marketId)
AppendToArray(&result,this.ParseMarket(market))
}
}
return result
}
func (this *oxfun) ParseMarket(market interface{}) interface{} {
var id interface{} = this.SafeString(market, "marketCode", "")
var parts interface{} = Split(id, "-")
var baseId interface{} = this.SafeString(parts, 0)
var quoteId interface{} = this.SafeString(parts, 1)
var base interface{} = this.SafeCurrencyCode(baseId)
var quote interface{} = this.SafeCurrencyCode(quoteId)
var symbol interface{} = Add(Add(base, "/"), quote)
var typeVar interface{} = this.SafeStringLower(market, "type", "spot") // markets from v3/tickers are spot and have no type
var settleId interface{} = nil
var settle interface{} = nil
var isFuture interface{} = (IsEqual(typeVar, "future")) // the exchange has only perpetual futures
if IsTrue(isFuture) {
typeVar = "swap"
settleId = "OX"
settle = this.SafeCurrencyCode("OX")
symbol = Add(Add(symbol, ":"), settle)
}
var isSpot interface{} = IsEqual(typeVar, "spot")
return this.SafeMarketStructure(map[string]interface{} {
"id": id,
"numericId": nil,
"symbol": symbol,
"base": base,
"quote": quote,
"settle": settle,
"baseId": baseId,
"quoteId": quoteId,
"settleId": settleId,
"type": typeVar,
"spot": isSpot,
"margin": false,
"swap": isFuture,
"future": false,
"option": false,
"active": true,
"contract": isFuture,
"linear": Ternary(IsTrue(isFuture), true, nil),
"inverse": Ternary(IsTrue(isFuture), false, nil),
"taker": GetValue(GetValue(this.Fees, "trading"), "taker"),
"maker": GetValue(GetValue(this.Fees, "trading"), "maker"),
"contractSize": Ternary(IsTrue(isFuture), 1, nil),
"expiry": nil,
"expiryDatetime": nil,
"strike": nil,
"optionType": nil,
"precision": map[string]interface{} {
"amount": nil,
"price": this.SafeNumber(market, "tickSize"),
},
"limits": map[string]interface{} {
"leverage": map[string]interface{} {
"min": nil,
"max": nil,
},
"amount": map[string]interface{} {
"min": this.SafeNumber(market, "minSize"),
"max": nil,
},
"price": map[string]interface{} {
"min": nil,
"max": nil,
},
"cost": map[string]interface{} {
"min": nil,
"max": nil,
},
},
"created": this.SafeInteger(market, "listedAt"),
"index": nil,
"info": market,
})
}
/**
* @method
* @name oxfun#fetchCurrencies
* @description fetches all available currencies on an exchange
* @see https://docs.ox.fun/?json#get-v3-assets
* @param {dict} [params] extra parameters specific to the exchange API endpoint
* @returns {dict} an associative dictionary of currencies
*/
func (this *oxfun) 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.PublicGetV3Assets(params))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "asset": "OX",
// "isCollateral": true,
// "loanToValue": "1.000000000",
// "loanToValueFactor": "0.000000000",
// "networkList": [
// {
// "network": "BNBSmartChain",
// "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": false,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Polygon",
// "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": false,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Arbitrum",
// "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": true,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Ethereum",
// "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": true,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Arbitrum",
// "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": false,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Avalanche",
// "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": false,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Solana",
// "tokenId": "DV3845GEAVXfwpyVGGgWbqBVCtzHdCXNCGfcdboSEuZz",
// "transactionPrecision": "8",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": true,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// },
// {
// "network": "Ethereum",
// "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": false,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// }
// ]
// },
// {
// "asset": "BTC",
// "isCollateral": true,
// "loanToValue": "0.950000000",
// "loanToValueFactor": "0.000000000",
// "networkList": [
// {
// "network": "Bitcoin",
// "transactionPrecision": "8",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": true,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// }
// ]
// },
// {
// "asset": "USDT.ARB",
// "isCollateral": true,
// "loanToValue": "0.950000000",
// "loanToValueFactor": "0.000000000",
// "networkList": [
// {
// "network": "Arbitrum",
// "tokenId": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
// "transactionPrecision": "18",
// "isWithdrawalFeeChargedToUser": true,
// "canDeposit": true,
// "canWithdraw": true,
// "minDeposit": "0.00010",
// "minWithdrawal": "0.00010"
// }
// ]
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
var result interface{} = map[string]interface{} {}
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var currency interface{} = GetValue(data, i)
var fullId interface{} = this.SafeString(currency, "asset", "")
var parts interface{} = Split(fullId, ".")
var id interface{} = GetValue(parts, 0)
var code interface{} = this.SafeCurrencyCode(id)
var networks interface{} = map[string]interface{} {}
var chains interface{} = this.SafeList(currency, "networkList", []interface{}{})
var currencyMaxPrecision interface{} = nil
var currencyDepositEnabled interface{} = nil
var currencyWithdrawEnabled interface{} = nil
for j := 0; IsLessThan(j, GetArrayLength(chains)); j++ {
var chain interface{} = GetValue(chains, j)
var networkId interface{} = this.SafeString(chain, "network")
var networkCode interface{} = this.NetworkIdToCode(networkId)
var deposit interface{} = this.SafeBool(chain, "canDeposit")
var withdraw interface{} = this.SafeBool(chain, "canWithdraw")
var active interface{} = (IsTrue(deposit) && IsTrue(withdraw))
var minDeposit interface{} = this.SafeString(chain, "minDeposit")
var minWithdrawal interface{} = this.SafeString(chain, "minWithdrawal")
var precision interface{} = this.ParsePrecision(this.SafeString(chain, "transactionPrecision"))
AddElementToObject(networks, networkCode, map[string]interface{} {
"id": networkId,
"network": networkCode,
"margin": nil,
"deposit": deposit,
"withdraw": withdraw,
"active": active,
"fee": nil,
"precision": this.ParseNumber(precision),
"limits": map[string]interface{} {
"deposit": map[string]interface{} {
"min": minDeposit,
"max": nil,
},
"withdraw": map[string]interface{} {
"min": minWithdrawal,
"max": nil,
},
},
"info": chain,
})
if IsTrue(IsTrue((IsEqual(currencyDepositEnabled, nil))) || IsTrue(deposit)) {
currencyDepositEnabled = deposit
}
if IsTrue(IsTrue((IsEqual(currencyWithdrawEnabled, nil))) || IsTrue(withdraw)) {
currencyWithdrawEnabled = withdraw
}
if IsTrue(IsTrue((IsEqual(currencyMaxPrecision, nil))) || IsTrue(Precise.StringGt(currencyMaxPrecision, precision))) {
currencyMaxPrecision = precision
}
}
if IsTrue(InOp(result, code)) {
// checking for specific ids as USDC.ARB
networks = this.Extend(GetValue(GetValue(result, code), "networks"), networks)
}
AddElementToObject(result, code, map[string]interface{} {
"id": id,
"code": code,
"name": nil,
"type": nil,
"active": nil,
"deposit": currencyDepositEnabled,
"withdraw": currencyWithdrawEnabled,
"fee": nil,
"precision": this.ParseNumber(currencyMaxPrecision),
"limits": map[string]interface{} {
"amount": map[string]interface{} {
"min": nil,
"max": nil,
},
"withdraw": map[string]interface{} {
"min": nil,
"max": nil,
},
},
"networks": networks,
"info": currency,
})
}
ch <- result
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchTickers
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
* @see https://docs.ox.fun/?json#get-v3-tickers
* @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
*/
func (this *oxfun) FetchTickers(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbols := GetArg(optionalArgs, 0, nil)
_ = symbols
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
retRes8038 := (<-this.LoadMarkets())
PanicOnError(retRes8038)
symbols = this.MarketSymbols(symbols)
response:= (<-this.PublicGetV3Tickers(params))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "marketCode": "NII-USDT",
// "markPrice": "0",
// "open24h": "0",
// "high24h": "0",
// "low24h": "0",
// "volume24h": "0",
// "currencyVolume24h": "0",
// "openInterest": "0",
// "lastTradedPrice": "0",
// "lastTradedQuantity": "0",
// "lastUpdatedAt": "1714853388621"
// },
// {
// "marketCode": "GEC-USDT",
// "markPrice": "0",
// "open24h": "0",
// "high24h": "0",
// "low24h": "0",
// "volume24h": "0",
// "currencyVolume24h": "0",
// "openInterest": "0",
// "lastTradedPrice": "0",
// "lastTradedQuantity": "0",
// "lastUpdatedAt": "1714853388621"
// },
// {
// "marketCode": "DYM-USD-SWAP-LIN",
// "markPrice": "3.321",
// "open24h": "3.315",
// "high24h": "3.356",
// "low24h": "3.255",
// "volume24h": "0",
// "currencyVolume24h": "0",
// "openInterest": "1768.1",
// "lastTradedPrice": "3.543",
// "lastTradedQuantity": "1.0",
// "lastUpdatedAt": "1714853388102"
// },
// ...
// ]
// }
//
var tickers interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseTickers(tickers, symbols)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#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.ox.fun/?json#get-v3-tickers
* @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 *oxfun) 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
retRes8678 := (<-this.LoadMarkets())
PanicOnError(retRes8678)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
}
response:= (<-this.PublicGetV3Tickers(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "marketCode": "BTC-USD-SWAP-LIN",
// "markPrice": "64276",
// "open24h": "63674",
// "high24h": "64607",
// "low24h": "62933",
// "volume24h": "306317655.80000",
// "currencyVolume24h": "48.06810",
// "openInterest": "72.39250",
// "lastTradedPrice": "64300.0",
// "lastTradedQuantity": "1.0",
// "lastUpdatedAt": "1714925196034"
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
var ticker interface{} = this.SafeDict(data, 0, map[string]interface{} {})
ch <- this.ParseTicker(ticker, market)
return nil
}()
return ch
}
func (this *oxfun) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "marketCode": "BTC-USD-SWAP-LIN",
// "markPrice": "64276",
// "open24h": "63674",
// "high24h": "64607",
// "low24h": "62933",
// "volume24h": "306317655.80000",
// "currencyVolume24h": "48.06810",
// "openInterest": "72.39250",
// "lastTradedPrice": "64300.0",
// "lastTradedQuantity": "1.0",
// "lastUpdatedAt": "1714925196034"
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var timestamp interface{} = this.SafeInteger(ticker, "lastUpdatedAt")
var marketId interface{} = this.SafeString(ticker, "marketCode")
market = this.SafeMarket(marketId, market)
var symbol interface{} = GetValue(market, "symbol")
var last interface{} = this.SafeString(ticker, "lastTradedPrice")
return this.SafeTicker(map[string]interface{} {
"symbol": symbol,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"high": this.SafeString(ticker, "high24h"),
"low": this.SafeString(ticker, "low24h"),
"bid": nil,
"bidVolume": nil,
"ask": nil,
"askVolume": nil,
"vwap": nil,
"open": this.SafeString(ticker, "open24h"),
"close": last,
"last": last,
"previousClose": nil,
"change": nil,
"percentage": nil,
"average": nil,
"baseVolume": this.SafeString(ticker, "currencyVolume24h"),
"quoteVolume": nil,
"markPrice": this.SafeString(ticker, "markPrice"),
"info": ticker,
}, market)
}
/**
* @method
* @name oxfun#fetchOHLCV
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
* @see https://docs.ox.fun/?json#get-v3-candles
* @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 (default 24 hours ago)
* @param {int} [limit] the maximum amount of candles to fetch (default 200, max 500)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] timestamp in ms of the latest candle to fetch (default now)
* @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
*/
func (this *oxfun) 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
retRes9588 := (<-this.LoadMarkets())
PanicOnError(retRes9588)
var market interface{} = this.Market(symbol)
timeframe = this.SafeString(this.Timeframes, timeframe, timeframe)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
"timeframe": timeframe,
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
} else if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "endTime", this.Sum(since, Multiply(Multiply(Multiply(Multiply(7, 24), 60), 60), 1000))) // for the exchange not to throw an exception if since is younger than 7 days
}
response:= (<-this.PublicGetV3Candles(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "timeframe": "3600s",
// "data": [
// {
// "open": "0.03240000",
// "high": "0.03240000",
// "low": "0.03240000",
// "close": "0.03240000",
// "volume": "0",
// "currencyVolume": "0",
// "openedAt": "1714906800000"
// },
// {
// "open": "0.03240000",
// "high": "0.03240000",
// "low": "0.03240000",
// "close": "0.03240000",
// "volume": "0",
// "currencyVolume": "0",
// "openedAt": "1714903200000"
// },
// ...
// ]
// }
//
var result interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseOHLCVs(result, market, timeframe, since, limit)
return nil
}()
return ch
}
func (this *oxfun) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "open": "0.03240000",
// "high": "0.03240000",
// "low": "0.03240000",
// "close": "0.03240000",
// "volume": "0",
// "currencyVolume": "0",
// "openedAt": "1714906800000"
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
return []interface{}{this.SafeInteger(ohlcv, "openedAt"), this.SafeNumber(ohlcv, "open"), this.SafeNumber(ohlcv, "high"), this.SafeNumber(ohlcv, "low"), this.SafeNumber(ohlcv, "close"), this.SafeNumber(ohlcv, "currencyVolume")}
}
/**
* @method
* @name oxfun#fetchOrderBook
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
* @see https://docs.ox.fun/?json#get-v3-depth
* @param {string} symbol unified symbol of the market to fetch the order book for
* @param {int} [limit] the maximum amount of order book entries to return (default 5, max 100)
* @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 *oxfun) 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
retRes10438 := (<-this.LoadMarkets())
PanicOnError(retRes10438)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "level", limit)
}
response:= (<-this.PublicGetV3Depth(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "level": "5",
// "data": {
// "marketCode": "BTC-USD-SWAP-LIN",
// "lastUpdatedAt": "1714933499266",
// "asks": [
// [ 64073.0, 8.4622 ],
// [ 64092.0, 8.1912 ],
// [ 64111.0, 8.0669 ],
// [ 64130.0, 11.7195 ],
// [ 64151.0, 10.1798 ]
// ],
// "bids": [
// [ 64022.0, 10.1292 ],
// [ 64003.0, 8.1619 ],
// [ 64000.0, 1.0 ],
// [ 63984.0, 12.7724 ],
// [ 63963.0, 11.0073 ]
// ]
// }
// }
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
var timestamp interface{} = this.SafeInteger(data, "lastUpdatedAt")
ch <- this.ParseOrderBook(data, GetValue(market, "symbol"), timestamp)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchFundingRates
* @description fetch the current funding rates for multiple markets
* @see https://docs.ox.fun/?json#get-v3-funding-estimates
* @param {string[]} symbols unified market symbols
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {Order[]} an array of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
*/
func (this *oxfun) FetchFundingRates(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbols := GetArg(optionalArgs, 0, nil)
_ = symbols
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
retRes10918 := (<-this.LoadMarkets())
PanicOnError(retRes10918)
symbols = this.MarketSymbols(symbols)
response:= (<-this.PublicGetV3FundingEstimates(params))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "marketCode": "OX-USD-SWAP-LIN",
// "fundingAt": "1715515200000",
// "estFundingRate": "0.000200000"
// },
// {
// "marketCode": "BTC-USD-SWAP-LIN",
// "fundingAt": "1715515200000",
// "estFundingRate": "0.000003"
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseFundingRates(data, symbols)
return nil
}()
return ch
}
func (this *oxfun) ParseFundingRate(fundingRate interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "marketCode": "OX-USD-SWAP-LIN",
// "fundingAt": "1715515200000",
// "estFundingRate": "0.000200000"
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var symbol interface{} = this.SafeString(fundingRate, "marketCode")
market = this.Market(symbol)
var estFundingRateTimestamp interface{} = this.SafeInteger(fundingRate, "fundingAt")
return map[string]interface{} {
"info": fundingRate,
"symbol": GetValue(market, "symbol"),
"markPrice": nil,
"indexPrice": nil,
"interestRate": this.ParseNumber("0"),
"estimatedSettlePrice": nil,
"timestamp": estFundingRateTimestamp,
"datetime": this.Iso8601(estFundingRateTimestamp),
"fundingRate": this.SafeNumber(fundingRate, "estFundingRate"),
"fundingTimestamp": nil,
"fundingDatetime": nil,
"nextFundingRate": nil,
"nextFundingTimestamp": nil,
"nextFundingDatetime": nil,
"previousFundingRate": nil,
"previousFundingTimestamp": nil,
"previousFundingDatetime": nil,
"interval": nil,
}
}
/**
* @method
* @name oxfun#fetchFundingRateHistory
* @description Fetches the history of funding rates
* @see https://docs.ox.fun/?json#get-v3-funding-rates
* @param {string} symbol unified symbol of the market to fetch trades for
* @param {int} [since] timestamp in ms of the earliest trade to fetch (default 24 hours ago)
* @param {int} [limit] the maximum amount of trades to fetch (default 200, max 500)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] timestamp in ms of the latest trade to fetch (default now)
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
*/
func (this *oxfun) FetchFundingRateHistory(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes11628 := (<-this.LoadMarkets())
PanicOnError(retRes11628)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
}
response:= (<-this.PublicGetV3FundingRates(this.Extend(request, params)))
PanicOnError(response)
//
// {
// success: true,
// data: [
// {
// marketCode: 'NEAR-USD-SWAP-LIN',
// fundingRate: '-0.000010000',
// createdAt: '1715428870755'
// },
// {
// marketCode: 'ENA-USD-SWAP-LIN',
// fundingRate: '0.000150000',
// createdAt: '1715428868616'
// },
// ...
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseFundingRateHistories(data, market, since, limit)
return nil
}()
return ch
}
func (this *oxfun) ParseFundingRateHistory(info interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// success: true,
// data: [
// {
// marketCode: 'NEAR-USD-SWAP-LIN',
// fundingRate: '-0.000010000',
// createdAt: '1715428870755'
// },
// {
// marketCode: 'ENA-USD-SWAP-LIN',
// fundingRate: '0.000150000',
// createdAt: '1715428868616'
// },
// ...
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(info, "marketCode")
market = this.SafeMarket(marketId, market)
var symbol interface{} = GetValue(market, "symbol")
var timestamp interface{} = this.SafeInteger(info, "createdAt")
return map[string]interface{} {
"info": info,
"symbol": symbol,
"fundingRate": this.SafeNumber(info, "fundingRate"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
}
}
/**
* @method
* @name oxfun#fetchFundingHistory
* @description fetches the history of funding payments
* @see https://docs.ox.fun/?json#get-v3-funding
* @param {string} symbol unified symbol of the market to fetch trades for
* @param {int} [since] timestamp in ms of the earliest trade to fetch (default 24 hours ago)
* @param {int} [limit] the maximum amount of trades to fetch (default 200, max 500)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] timestamp in ms of the latest trade to fetch (default now)
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
*/
func (this *oxfun) FetchFundingHistory(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes12448 := (<-this.LoadMarkets())
PanicOnError(retRes12448)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
}
response:= (<-this.PrivateGetV3Funding(this.Extend(request, params)))
PanicOnError(response)
//
// {
// success: true,
// data: [
// {
// id: '966709913041305605',
// marketCode: 'ETH-USD-SWAP-LIN',
// payment: '-0.00430822',
// fundingRate: '0.000014',
// position: '0.001',
// indexPrice: '3077.3',
// createdAt: '1715086852890'
// },
// {
// id: '966698111997509637',
// marketCode: 'ETH-USD-SWAP-LIN',
// payment: '-0.0067419',
// fundingRate: '0.000022',
// position: '0.001',
// indexPrice: '3064.5',
// createdAt: '1715083251516'
// },
// ...
// ]
// }
//
var result interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseIncomes(result, market, since, limit)
return nil
}()
return ch
}
func (this *oxfun) ParseIncome(income interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// id: '966709913041305605',
// marketCode: 'ETH-USD-SWAP-LIN',
// payment: '-0.00430822',
// fundingRate: '0.000014',
// position: '0.001',
// indexPrice: '3077.3',
// createdAt: '1715086852890'
// },
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(income, "marketCode")
var symbol interface{} = this.SafeSymbol(marketId, market)
var amount interface{} = this.SafeNumber(income, "payment")
var code interface{} = this.SafeCurrencyCode("OX")
var id interface{} = this.SafeString(income, "id")
var timestamp interface{} = this.SafeTimestamp(income, "createdAt")
var rate interface{} = this.SafeNumber(income, "fundingRate")
return map[string]interface{} {
"info": income,
"symbol": symbol,
"code": code,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"id": id,
"amount": amount,
"rate": rate,
}
}
/**
* @method
* @name oxfun#fetchLeverageTiers
* @description retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes, if a market has a leverage tier of 0, then the leverage tiers cannot be obtained for this market
* @see https://docs.ox.fun/?json#get-v3-leverage-tiers
* @param {string[]} [symbols] list of unified market symbols
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a dictionary of [leverage tiers structures]{@link https://docs.ccxt.com/#/?id=leverage-tiers-structure}, indexed by market symbols
*/
func (this *oxfun) FetchLeverageTiers(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbols := GetArg(optionalArgs, 0, nil)
_ = symbols
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
retRes13328 := (<-this.LoadMarkets())
PanicOnError(retRes13328)
response:= (<-this.PublicGetV3LeverageTiers(params))
PanicOnError(response)
//
// {
// success: true,
// data: [
// {
// marketCode: 'SOL-USD-SWAP-LIN',
// tiers: [
// {
// tier: '1',
// leverage: '10',
// positionFloor: '0',
// positionCap: '200000000',
// initialMargin: '0.1',
// maintenanceMargin: '0.05',
// maintenanceAmount: '0'
// },
// {
// tier: '2',
// leverage: '5',
// positionFloor: '200000000',
// positionCap: '280000000',
// initialMargin: '0.2',
// maintenanceMargin: '0.1',
// maintenanceAmount: '7000000'
// },
// {
// tier: '3',
// leverage: '4',
// positionFloor: '280000000',
// positionCap: '460000000',
// initialMargin: '0.25',
// maintenanceMargin: '0.125',
// maintenanceAmount: '14000000'
// },
// ...
// ]
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseLeverageTiers(data, symbols, "marketCode")
return nil
}()
return ch
}
func (this *oxfun) ParseMarketLeverageTiers(info interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// marketCode: 'SOL-USD-SWAP-LIN',
// tiers: [
// {
// tier: '1',
// leverage: '10',
// positionFloor: '0',
// positionCap: '200000000',
// initialMargin: '0.1',
// maintenanceMargin: '0.05',
// maintenanceAmount: '0'
// ...
// ]
// },
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(info, "marketCode")
market = this.SafeMarket(marketId, market)
var listOfTiers interface{} = this.SafeList(info, "tiers", []interface{}{})
var tiers interface{} = []interface{}{}
for j := 0; IsLessThan(j, GetArrayLength(listOfTiers)); j++ {
var tier interface{} = GetValue(listOfTiers, j)
AppendToArray(&tiers,map[string]interface{} {
"tier": this.SafeNumber(tier, "tier"),
"symbol": this.SafeSymbol(marketId, market),
"currency": GetValue(market, "settle"),
"minNotional": this.SafeNumber(tier, "positionFloor"),
"maxNotional": this.SafeNumber(tier, "positionCap"),
"maintenanceMarginRate": this.SafeNumber(tier, "maintenanceMargin"),
"maxLeverage": this.SafeNumber(tier, "leverage"),
"info": tier,
})
}
return tiers
}
/**
* @method
* @name oxfun#fetchTrades
* @description get the list of most recent trades for a particular symbol
* @see https://docs.ox.fun/?json#get-v3-exchange-trades
* @param {string} symbol unified symbol of the market to fetch trades for
* @param {int} [since] timestamp in ms of the earliest trade to fetch (default 24 hours ago)
* @param {int} [limit] the maximum amount of trades to fetch (default 200, max 500)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] timestamp in ms of the latest trade to fetch (default now)
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
*/
func (this *oxfun) 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
retRes14298 := (<-this.LoadMarkets())
PanicOnError(retRes14298)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
} else if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "endTime", this.Sum(since, Multiply(Multiply(Multiply(Multiply(7, 24), 60), 60), 1000))) // for the exchange not to throw an exception if since is younger than 7 days
}
response:= (<-this.PublicGetV3ExchangeTrades(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "marketCode": "BTC-USD-SWAP-LIN",
// "matchPrice": "63900",
// "matchQuantity": "1",
// "side": "SELL",
// "matchType": "TAKER",
// "matchedAt": "1714934112352"
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseTrades(data, market, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchMyTrades
* @description fetch all trades made by the user
* @see https://docs.ox.fun/?json#get-v3-trades
* @param {string} symbol unified market symbol
* @param {int} [since] the earliest time in ms to fetch trades for
* @param {int} [limit] the maximum amount of trades to fetch (default 200, max 500)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] timestamp in ms of the latest trade to fetch (default now)
* @returns {Trade[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure}
*/
func (this *oxfun) FetchMyTrades(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes14818 := (<-this.LoadMarkets())
PanicOnError(retRes14818)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
AddElementToObject(request, "marketCode", GetValue(market, "id"))
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since)
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
} else if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "endTime", this.Sum(since, Multiply(Multiply(Multiply(Multiply(7, 24), 60), 60), 1000))) // for the exchange not to throw an exception if since is younger than 7 days
}
response:= (<-this.PrivateGetV3Trades(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "orderId": "1000104903698",
// "clientOrderId": "1715000260094",
// "matchId": "400017129522773178",
// "marketCode": "ETH-USD-SWAP-LIN",
// "side": "BUY",
// "matchedQuantity": "0.001",
// "matchPrice": "3100.2",
// "total": "310.02",
// "orderMatchType": "MAKER",
// "feeAsset": "OX",
// "fee": "0.062004",
// "source": "0",
// "matchedAt": "1715000267420"
// }
// ]
// }
//
var result interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseTrades(result, market, since, limit)
return nil
}()
return ch
}
func (this *oxfun) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
//
// public fetchTrades
//
// {
// "marketCode": "BTC-USD-SWAP-LIN",
// "matchPrice": "63900",
// "matchQuantity": "1",
// "side": "SELL",
// "matchType": "TAKER",
// "matchedAt": "1714934112352"
// }
//
//
// private fetchMyTrades
//
// {
// "orderId": "1000104903698",
// "clientOrderId": "1715000260094",
// "matchId": "400017129522773178",
// "marketCode": "ETH-USD-SWAP-LIN",
// "side": "BUY",
// "matchedQuantity": "0.001",
// "matchPrice": "3100.2",
// "total": "310.02",
// "orderMatchType": "MAKER",
// "feeAsset": "OX",
// "fee": "0.062004",
// "source": "0",
// "matchedAt": "1715000267420"
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(trade, "marketCode")
market = this.SafeMarket(marketId, market)
var symbol interface{} = GetValue(market, "symbol")
var timestamp interface{} = this.SafeInteger(trade, "matchedAt")
var fee interface{} = map[string]interface{} {
"cost": this.SafeString(trade, "fee"),
"currency": this.SafeCurrencyCode(this.SafeString(trade, "feeAsset")),
}
return this.SafeTrade(map[string]interface{} {
"id": this.SafeString(trade, "matchId"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"symbol": symbol,
"type": nil,
"order": this.SafeString(trade, "orderId"),
"side": this.SafeStringLower(trade, "side"),
"takerOrMaker": this.SafeStringLower2(trade, "matchType", "orderMatchType"),
"price": this.SafeString(trade, "matchPrice"),
"amount": this.SafeString2(trade, "matchQuantity", "matchedQuantity"),
"cost": nil,
"fee": fee,
"info": trade,
}, market)
}
/**
* @method
* @name oxfun#fetchBalance
* @description query for balance and get the amount of funds available for trading or funds locked in orders
* @see https://docs.ox.fun/?json#get-v3-balances
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.asset] currency id, if empty the exchange returns info about all currencies
* @param {string} [params.subAcc] Name of sub account. If no subAcc is given, then the response contains only the account linked to the API-Key.
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
*/
func (this *oxfun) 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
retRes15968 := (<-this.LoadMarkets())
PanicOnError(retRes15968)
response:= (<-this.PrivateGetV3Balances(params))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "accountId": "106490",
// "name": "main",
// "balances": [
// {
// "asset": "OX",
// "total": "-7.55145065000",
// "available": "-71.16445065000",
// "reserved": "0",
// "lastUpdatedAt": "1715000448946"
// },
// {
// "asset": "ETH",
// "total": "0.01",
// "available": "0.01",
// "reserved": "0",
// "lastUpdatedAt": "1714914512750"
// },
// ...
// ]
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
var balance interface{} = GetValue(data, 0)
var subAcc interface{} = this.SafeString(params, "subAcc")
if IsTrue(!IsEqual(subAcc, nil)) {
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var b interface{} = GetValue(data, i)
var name interface{} = this.SafeString(b, "name")
if IsTrue(IsEqual(name, subAcc)) {
balance = b
break
}
}
}
ch <- this.ParseBalance(balance)
return nil
}()
return ch
}
func (this *oxfun) ParseBalance(balance interface{}) interface{} {
//
// {
// "accountId": "106490",
// "name": "main",
// "balances": [
// {
// "asset": "OX",
// "total": "-7.55145065000",
// "available": "-71.16445065000",
// "reserved": "0",
// "lastUpdatedAt": "1715000448946"
// },
// {
// "asset": "ETH",
// "total": "0.01",
// "available": "0.01",
// "reserved": "0",
// "lastUpdatedAt": "1714914512750"
// },
// ...
// ]
// }
//
var result interface{} = map[string]interface{} {
"info": balance,
}
var balances interface{} = this.SafeList(balance, "balances", []interface{}{})
for i := 0; IsLessThan(i, GetArrayLength(balances)); i++ {
var balanceEntry interface{} = GetValue(balances, i)
var currencyId interface{} = this.SafeString(balanceEntry, "asset")
var code interface{} = this.SafeCurrencyCode(currencyId)
var account interface{} = this.Account()
AddElementToObject(account, "total", this.SafeString(balanceEntry, "total"))
AddElementToObject(account, "free", this.SafeString(balanceEntry, "available"))
AddElementToObject(account, "used", this.SafeString(balanceEntry, "reserved"))
AddElementToObject(result, code, account)
}
return this.SafeBalance(result)
}
/**
* @method
* @name oxfun#fetchAccounts
* @description fetch subaccounts associated with a profile
* @see https://docs.ox.fun/?json#get-v3-account-names
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a dictionary of [account structures]{@link https://docs.ccxt.com/#/?id=account-structure} indexed by the account type
*/
func (this *oxfun) FetchAccounts(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes16938 := (<-this.LoadMarkets())
PanicOnError(retRes16938)
// this endpoint can only be called using API keys paired with the parent account! Returns all active subaccounts.
response:= (<-this.PrivateGetV3AccountNames(params))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "accountId": "106526",
// "name": "testSubAccount"
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseAccounts(data, params)
return nil
}()
return ch
}
func (this *oxfun) ParseAccount(account interface{}) interface{} {
//
// {
// "accountId": "106526",
// "name": "testSubAccount"
// },
//
return map[string]interface{} {
"id": this.SafeString(account, "accountId"),
"type": nil,
"code": nil,
"info": account,
}
}
/**
* @method
* @name oxfun#transfer
* @description transfer currency internally between wallets on the same account
* @see https://docs.ox.fun/?json#post-v3-transfer
* @param {string} code unified currency code
* @param {float} amount amount to transfer
* @param {string} fromAccount account id to transfer from
* @param {string} toAccount account id to transfer to
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
*/
func (this *oxfun) Transfer(code interface{}, amount interface{}, fromAccount interface{}, toAccount interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
// transferring funds between sub-accounts is restricted to API keys linked to the parent account.
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes17418 := (<-this.LoadMarkets())
PanicOnError(retRes17418)
var currency interface{} = this.Currency(code)
var request interface{} = map[string]interface{} {
"asset": GetValue(currency, "id"),
"quantity": this.CurrencyToPrecision(code, amount),
"fromAccount": fromAccount,
"toAccount": toAccount,
}
response:= (<-this.PrivatePostV3Transfer(this.Extend(request, params)))
PanicOnError(response)
//
// {
// timestamp: 1715430036267,
// datetime: '2024-05-11T12:20:36.267Z',
// currency: 'OX',
// amount: 10,
// fromAccount: '106464',
// toAccount: '106570',
// info: {
// asset: 'OX',
// quantity: '10',
// fromAccount: '106464',
// toAccount: '106570',
// transferredAt: '1715430036267'
// }
// }
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- this.ParseTransfer(data, currency)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchTransfers
* @description fetch a history of internal transfers made on an account
* @see https://docs.ox.fun/?json#get-v3-transfer
* @param {string} code unified currency code of the currency transferred
* @param {int} [since] the earliest time in ms to fetch transfers for (default 24 hours ago)
* @param {int} [limit] the maximum number of transfer structures to retrieve (default 50, max 200)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] the latest time in ms to fetch transfers for (default time now)
* @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure}
*/
func (this *oxfun) FetchTransfers(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
// API keys linked to the parent account can get all account transfers, while API keys linked to a sub-account can only see transfers where the sub-account is either the "fromAccount" or "toAccount"
code := GetArg(optionalArgs, 0, nil)
_ = code
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes17858 := (<-this.LoadMarkets())
PanicOnError(retRes17858)
var request interface{} = map[string]interface{} {}
var currency interface{} = nil
if IsTrue(!IsEqual(code, nil)) {
currency = this.Currency(code)
AddElementToObject(request, "asset", GetValue(currency, "id"))
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
} else if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "endTime", this.Sum(since, Multiply(Multiply(Multiply(Multiply(7, 24), 60), 60), 1000))) // for the exchange not to throw an exception if since is younger than 7 days
}
response:= (<-this.PrivateGetV3Transfer(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "asset": "USDT",
// "quantity": "5",
// "fromAccount": "106490",
// "toAccount": "106526",
// "id": "966706320886267905",
// "status": "COMPLETED",
// "transferredAt": "1715085756708"
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseTransfers(data, currency, since, limit)
return nil
}()
return ch
}
func (this *oxfun) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} {
//
// fetchTransfers
//
// {
// "asset": "USDT",
// "quantity": "5",
// "fromAccount": "106490",
// "toAccount": "106526",
// "id": "966706320886267905",
// "status": "COMPLETED",
// "transferredAt": "1715085756708"
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var timestamp interface{} = this.SafeInteger(transfer, "transferredAt")
var currencyId interface{} = this.SafeString(transfer, "asset")
return map[string]interface{} {
"id": this.SafeString(transfer, "id"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"currency": this.SafeCurrencyCode(currencyId, currency),
"amount": this.SafeNumber(transfer, "quantity"),
"fromAccount": this.SafeString(transfer, "fromAccount"),
"toAccount": this.SafeString(transfer, "toAccount"),
"status": this.ParseTransferStatus(this.SafeString(transfer, "status")),
"info": transfer,
}
}
func (this *oxfun) ParseTransferStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"COMPLETED": "ok",
}
return this.SafeString(statuses, status, status)
}
/**
* @method
* @name oxfun#fetchDepositAddress
* @description fetch the deposit address for a currency associated with this account
* @see https://docs.ox.fun/?json#get-v3-deposit-addresses
* @param {string} code unified currency code
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.network] network for fetch deposit address
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
*/
func (this *oxfun) 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
var networkCode interface{} = this.SafeString(params, "network")
var networkId interface{} = this.NetworkCodeToId(networkCode, code)
if IsTrue(IsEqual(networkId, nil)) {
panic(BadRequest(Add(this.Id, " fetchDepositAddress() require network parameter")))
}
retRes18798 := (<-this.LoadMarkets())
PanicOnError(retRes18798)
var currency interface{} = this.Currency(code)
var request interface{} = map[string]interface{} {
"asset": GetValue(currency, "id"),
"network": networkId,
}
params = this.Omit(params, "network")
response:= (<-this.PrivateGetV3DepositAddresses(this.Extend(request, params)))
PanicOnError(response)
//
// {"success":true,"data":{"address":"0x998dEc76151FB723963Bd8AFD517687b38D33dE8"}}
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- this.ParseDepositAddress(data, currency)
return nil
}()
return ch
}
func (this *oxfun) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{} {
//
// {"address":"0x998dEc76151FB723963Bd8AFD517687b38D33dE8"}
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var address interface{} = this.SafeString(depositAddress, "address")
this.CheckAddress(address)
return map[string]interface{} {
"info": depositAddress,
"currency": GetValue(currency, "code"),
"network": nil,
"address": address,
"tag": nil,
}
}
/**
* @method
* @name oxfun#fetchDeposits
* @description fetch all deposits made to an account
* @see https://docs.ox.fun/?json#get-v3-deposit
* @param {string} code unified currency code of the currency transferred
* @param {int} [since] the earliest time in ms to fetch transfers for (default 24 hours ago)
* @param {int} [limit] the maximum number of transfer structures to retrieve (default 50, max 200)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] the latest time in ms to fetch transfers for (default time now)
* @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure}
*/
func (this *oxfun) FetchDeposits(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
code := GetArg(optionalArgs, 0, nil)
_ = code
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes19228 := (<-this.LoadMarkets())
PanicOnError(retRes19228)
var request interface{} = map[string]interface{} {}
var currency interface{} = nil
if IsTrue(!IsEqual(code, nil)) {
currency = this.Currency(code)
AddElementToObject(request, "asset", GetValue(currency, "id"))
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
}
response:= (<-this.PrivateGetV3Deposit(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "asset":"USDC",
// "network":"Ethereum",
// "address": "0x998dEc76151FB723963Bd8AFD517687b38D33dE8",
// "quantity":"50",
// "id":"5914",
// "status": "COMPLETED",
// "txId":"0xf5e79663830a0c6f94d46638dcfbc134566c12facf1832396f81ecb55d3c75dc",
// "creditedAt":"1714821645154"
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
AddElementToObject(GetValue(data, i), "type", "deposit")
}
ch <- this.ParseTransactions(data, currency, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchWithdrawals
* @description fetch all withdrawals made from an account
* @see https://docs.ox.fun/?json#get-v3-withdrawal
* @param {string} code unified currency code of the currency transferred
* @param {int} [since] the earliest time in ms to fetch transfers for (default 24 hours ago)
* @param {int} [limit] the maximum number of transfer structures to retrieve (default 50, max 200)
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] the latest time in ms to fetch transfers for (default time now)
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
*/
func (this *oxfun) FetchWithdrawals(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
code := GetArg(optionalArgs, 0, nil)
_ = code
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes19788 := (<-this.LoadMarkets())
PanicOnError(retRes19788)
var request interface{} = map[string]interface{} {}
var currency interface{} = nil
if IsTrue(!IsEqual(code, nil)) {
currency = this.Currency(code)
AddElementToObject(request, "asset", GetValue(currency, "id"))
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since) // startTime and endTime must be within 7 days of each other
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var until interface{} = this.SafeInteger(params, "until")
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
params = this.Omit(params, "until")
}
response:= (<-this.PrivateGetV3Withdrawal(this.Extend(request, params)))
PanicOnError(response)
//
// {
// success: true,
// data: [
// {
// id: '968163212989431811',
// asset: 'OX',
// network: 'Arbitrum',
// address: '0x90fc1fB49a4ED8f485dd02A2a1Cf576897f6Bfc9',
// quantity: '11.7444',
// fee: '1.744400000',
// status: 'COMPLETED',
// txId: '0xe96b2d128b737fdbca927edf355cff42202e65b0fb960e64ffb9bd68c121f69f',
// requestedAt: '1715530365450',
// completedAt: '1715530527000'
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
AddElementToObject(GetValue(data, i), "type", "withdrawal")
}
ch <- this.ParseTransactions(data, currency, since, limit)
return nil
}()
return ch
}
func (this *oxfun) ParseTransactions(transactions interface{}, optionalArgs ...interface{}) interface{} {
currency := GetArg(optionalArgs, 0, nil)
_ = currency
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
var result interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(transactions)); i++ {
AddElementToObject(transactions, i, this.Extend(GetValue(transactions, i), params))
var transaction interface{} = this.ParseTransaction(GetValue(transactions, i), currency)
AppendToArray(&result,transaction)
}
result = this.SortBy(result, "timestamp")
var code interface{} = Ternary(IsTrue((!IsEqual(currency, nil))), GetValue(currency, "code"), nil)
return this.FilterByCurrencySinceLimit(result, code, since, limit)
}
func (this *oxfun) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
//
// fetchDeposits
// {
// "asset":"USDC",
// "network":"Ethereum",
// "address": "0x998dEc76151FB723963Bd8AFD517687b38D33dE8",
// "quantity":"50",
// "id":"5914",
// "status": "COMPLETED",
// "txId":"0xf5e79663830a0c6f94d46638dcfbc134566c12facf1832396f81ecb55d3c75dc",
// "creditedAt":"1714821645154"
// }
//
// fetchWithdrawals
// {
// id: '968163212989431811',
// asset: 'OX',
// network: 'Arbitrum',
// address: '0x90fc1fB49a4ED8f485dd02A2a1Cf576897f6Bfc9',
// quantity: '11.7444',
// fee: '1.744400000',
// status: 'COMPLETED',
// txId: '0xe96b2d128b737fdbca927edf355cff42202e65b0fb960e64ffb9bd68c121f69f',
// requestedAt: '1715530365450',
// completedAt: '1715530527000'
// }
//
// withdraw
// {
// "id": "968364664449302529",
// "asset": "OX",
// "network": "Arbitrum",
// "address": "0x90fc1fB49a4ED8f485dd02A2a1Cf576897f6Bfc9",
// "quantity": "10",
// "externalFee": false,
// "fee": "1.6728",
// "status": "PENDING",
// "requestedAt": "1715591843616"
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var id interface{} = this.SafeString(transaction, "id")
var typeVar interface{} = this.SafeString(transaction, "type")
transaction = this.Omit(transaction, "type")
var address interface{} = nil
var addressTo interface{} = nil
var status interface{} = nil
if IsTrue(IsEqual(typeVar, "deposit")) {
address = this.SafeString(transaction, "address")
status = this.ParseDepositStatus(this.SafeString(transaction, "status"))
} else if IsTrue(IsEqual(typeVar, "withdrawal")) {
addressTo = this.SafeString(transaction, "address")
status = this.ParseWithdrawalStatus(this.SafeString(transaction, "status"))
}
var txid interface{} = this.SafeString(transaction, "txId")
var currencyId interface{} = this.SafeString(transaction, "asset")
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
var network interface{} = this.SafeString(transaction, "network")
var networkCode interface{} = this.NetworkIdToCode(network)
var timestamp interface{} = this.SafeInteger2(transaction, "creditedAt", "requestedAt")
var amount interface{} = this.SafeNumber(transaction, "quantity")
var feeCost interface{} = this.SafeNumber(transaction, "fee")
var fee interface{} = nil
if IsTrue(!IsEqual(feeCost, nil)) {
fee = map[string]interface{} {
"cost": feeCost,
"currency": code,
}
}
return map[string]interface{} {
"info": transaction,
"id": id,
"txid": txid,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"network": networkCode,
"address": address,
"addressTo": addressTo,
"addressFrom": nil,
"tag": nil,
"tagTo": nil,
"tagFrom": nil,
"type": typeVar,
"amount": amount,
"currency": code,
"status": status,
"updated": nil,
"internal": nil,
"comment": nil,
"fee": fee,
}
}
func (this *oxfun) ParseDepositStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"COMPLETED": "ok",
}
return this.SafeString(statuses, status, status)
}
func (this *oxfun) ParseWithdrawalStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"COMPLETED": "ok",
"PROCESSING": "pending",
"IN SWEEPING": "pending",
"PENDING": "pending",
"ON HOLD": "pending",
"CANCELED": "canceled",
"FAILED": "failed",
}
return this.SafeString(statuses, status, status)
}
/**
* @method
* @name oxfun#withdraw
* @description make a withdrawal
* @see https://docs.ox.fun/?json#post-v3-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
* @param {string} [params.network] network for withdraw
* @param {bool} [params.externalFee] if false, then the fee is taken from the quantity, also with the burn fee for asset SOLO
*
* EXCHANGE SPECIFIC PARAMETERS
* @param {string} [params.tfaType] GOOGLE, or AUTHY_SECRET, or YUBIKEY, for 2FA
* @param {string} [params.code] 2FA code
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
*/
func (this *oxfun) 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)
retRes21688 := (<-this.LoadMarkets())
PanicOnError(retRes21688)
var currency interface{} = this.Currency(code)
var stringAmount interface{} = this.CurrencyToPrecision(code, amount)
var request interface{} = map[string]interface{} {
"asset": GetValue(currency, "id"),
"address": address,
"quantity": stringAmount,
}
if IsTrue(!IsEqual(tag, nil)) {
AddElementToObject(request, "memo", tag)
}
var networkCode interface{} = nil
networkCodeparamsVariable := this.HandleNetworkCodeAndParams(params);
networkCode = GetValue(networkCodeparamsVariable,0);
params = GetValue(networkCodeparamsVariable,1)
if IsTrue(!IsEqual(networkCode, nil)) {
AddElementToObject(request, "network", this.NetworkCodeToId(networkCode))
}
AddElementToObject(request, "externalFee", false)
response:= (<-this.PrivatePostV3Withdrawal(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": {
// "id": "968364664449302529",
// "asset": "OX",
// "network": "Arbitrum",
// "address": "0x90fc1fB49a4ED8f485dd02A2a1Cf576897f6Bfc9",
// "quantity": "10",
// "externalFee": false,
// "fee": "1.6728",
// "status": "PENDING",
// "requestedAt": "1715591843616"
// }
// }
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
AddElementToObject(data, "type", "withdrawal")
ch <- this.ParseTransaction(data, currency)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchPositions
* @description fetch all open positions
* @see https://docs.ox.fun/?json#get-v3-positions
* @param {string[]|undefined} symbols list of unified market symbols
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {boolean} [params.subAcc]
* @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
*/
func (this *oxfun) FetchPositions(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
// Calling this endpoint using an API key pair linked to the parent account with the parameter "subAcc"
// allows the caller to include positions of additional sub-accounts in the response.
// This feature does not work when using API key pairs linked to a sub-account
symbols := GetArg(optionalArgs, 0, nil)
_ = symbols
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
retRes22218 := (<-this.LoadMarkets())
PanicOnError(retRes22218)
symbols = this.MarketSymbols(symbols)
response:= (<-this.PrivateGetV3Positions(params))
PanicOnError(response)
//
// {
// "success": true,
// "data": [
// {
// "accountId": "106490",
// "name": "main",
// "positions": [
// {
// "marketCode": "BTC-USD-SWAP-LIN",
// "baseAsset": "BTC",
// "counterAsset": "USD",
// "position": "0.00010",
// "entryPrice": "64300.0",
// "markPrice": "63278",
// "positionPnl": "-10.1900",
// "estLiquidationPrice": "0",
// "lastUpdatedAt": "1714915841448"
// },
// ...
// ]
// },
// {
// "accountId": "106526",
// "name": "testSubAccount",
// "positions": [
// {
// "marketCode": "ETH-USD-SWAP-LIN",
// "baseAsset": "ETH",
// "counterAsset": "USD",
// "position": "0.001",
// "entryPrice": "3080.5",
// "markPrice": "3062.0",
// "positionPnl": "-1.8500",
// "estLiquidationPrice": "0",
// "lastUpdatedAt": "1715089678013"
// },
// ...
// ]
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
var allPositions interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var account interface{} = GetValue(data, i)
var positions interface{} = this.SafeList(account, "positions", []interface{}{})
allPositions = this.ArrayConcat(allPositions, positions)
}
ch <- this.ParsePositions(allPositions, symbols)
return nil
}()
return ch
}
func (this *oxfun) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "marketCode": "ETH-USD-SWAP-LIN",
// "baseAsset": "ETH",
// "counterAsset": "USD",
// "position": "0.001",
// "entryPrice": "3080.5",
// "markPrice": "3062.0",
// "positionPnl": "-1.8500",
// "estLiquidationPrice": "0",
// "lastUpdatedAt": "1715089678013"
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(position, "marketCode")
market = this.SafeMarket(marketId, market)
return this.SafePosition(map[string]interface{} {
"info": position,
"id": nil,
"symbol": GetValue(market, "symbol"),
"notional": nil,
"marginMode": "cross",
"liquidationPrice": this.SafeNumber(position, "estLiquidationPrice"),
"entryPrice": this.SafeNumber(position, "entryPrice"),
"unrealizedPnl": this.SafeNumber(position, "positionPnl"),
"realizedPnl": nil,
"percentage": nil,
"contracts": this.SafeNumber(position, "position"),
"contractSize": nil,
"markPrice": this.SafeNumber(position, "markPrice"),
"lastPrice": nil,
"side": nil,
"hedged": nil,
"timestamp": nil,
"datetime": nil,
"lastUpdateTimestamp": this.SafeInteger(position, "lastUpdatedAt"),
"maintenanceMargin": nil,
"maintenanceMarginPercentage": nil,
"collateral": nil,
"initialMargin": nil,
"initialMarginPercentage": nil,
"leverage": nil,
"marginRatio": nil,
"stopLossPrice": nil,
"takeProfitPrice": nil,
})
}
/**
* @method
* @name oxfun#createOrder
* @description create a trade order
* @see https://docs.ox.fun/?json#post-v3-orders-place
* @param {string} symbol unified symbol of the market to create an order in
* @param {string} type 'market', 'limit', 'STOP_LIMIT' or 'STOP_MARKET'
* @param {string} side 'buy' or 'sell'
* @param {float} amount how much of currency you want to trade in units of base currency
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.clientOrderId] a unique id for the order
* @param {int} [params.timestamp] in milliseconds. If an order reaches the matching engine and the current timestamp exceeds timestamp + recvWindow, then the order will be rejected.
* @param {int} [params.recvWindow] in milliseconds. If an order reaches the matching engine and the current timestamp exceeds timestamp + recvWindow, then the order will be rejected. If timestamp is provided without recvWindow, then a default recvWindow of 1000ms is used.
* @param {string} [params.responseType] FULL or ACK
* @param {float} [params.cost] the quote quantity that can be used as an alternative for the amount for market buy orders
* @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
* @param {float} [params.limitPrice] Limit price for the STOP_LIMIT order
* @param {bool} [params.postOnly] if true, the order will only be posted if it will be a maker order
* @param {string} [params.timeInForce] GTC (default), IOC, FOK, PO, MAKER_ONLY or MAKER_ONLY_REPRICE (reprices order to the best maker only price if the specified price were to lead to a taker trade)
* @param {string} [params.selfTradePreventionMode] NONE, EXPIRE_MAKER, EXPIRE_TAKER or EXPIRE_BOTH for more info check here {@link https://docs.ox.fun/?json#self-trade-prevention-modes}
* @param {string} [params.displayQuantity] for an iceberg order, pass both quantity and displayQuantity fields in the order request
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) 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
retRes23508 := (<-this.LoadMarkets())
PanicOnError(retRes23508)
var request interface{} = map[string]interface{} {
"responseType": this.SafeString(params, "responseType", "FULL"),
"timestamp": this.SafeInteger(params, "timestamp", this.Milliseconds()),
}
params = this.Omit(params, []interface{}{"responseType", "timestamp"})
var recvWindow interface{} = this.SafeInteger(params, "recvWindow")
if IsTrue(!IsEqual(recvWindow, nil)) {
AddElementToObject(request, "recvWindow", recvWindow)
params = this.Omit(params, "recvWindow")
}
var orderRequest interface{} = this.CreateOrderRequest(symbol, typeVar, side, amount, price, params)
AddElementToObject(request, "orders", []interface{}{orderRequest})
response:= (<-this.PrivatePostV3OrdersPlace(request))
PanicOnError(response)
//
// accepted market order responseType FULL
// {
// "success": true,
// "data": [
// {
// "notice": "OrderMatched",
// "accountId": "106490",
// "orderId": "1000109901865",
// "submitted": true,
// "clientOrderId": "0",
// "marketCode": "OX-USDT",
// "status": "FILLED",
// "side": "SELL",
// "isTriggered": false,
// "quantity": "150.0",
// "amount": "0.0",
// "remainQuantity": "0.0",
// "matchId": "100017047880451399",
// "matchPrice": "0.01465",
// "matchQuantity": "150.0",
// "feeInstrumentId": "USDT",
// "fees": "0.0015382500",
// "orderType": "MARKET",
// "createdAt": "1715592472236",
// "lastMatchedAt": "1715592472200",
// "displayQuantity": "150.0"
// }
// ]
// }
//
// accepted limit order responseType FULL
// {
// "success": true,
// "data": [
// {
// "notice": "OrderOpened",
// "accountId": "106490",
// "orderId": "1000111482406",
// "submitted": true,
// "clientOrderId": "0",
// "marketCode": "ETH-USD-SWAP-LIN",
// "status": "OPEN",
// "side": "SELL",
// "price": "4000.0",
// "isTriggered": false,
// "quantity": "0.01",
// "amount": "0.0",
// "orderType": "LIMIT",
// "timeInForce": "GTC",
// "createdAt": "1715763507682",
// "displayQuantity": "0.01"
// }
// ]
// }
//
// accepted order responseType ACK
// {
// "success": true,
// "data": [
// {
// "accountId": "106490",
// "orderId": "1000109892193",
// "submitted": true,
// "marketCode": "OX-USDT",
// "side": "BUY",
// "price": "0.01961",
// "isTriggered": false,
// "quantity": "100",
// "orderType": "MARKET",
// "timeInForce": "IOC",
// "createdAt": "1715591529057",
// "selfTradePreventionMode": "NONE"
// }
// ]
// }
//
// rejected order (balance insufficient)
// {
// "success": true,
// "data": [
// {
// "code": "710001",
// "message": "System failure, exception thrown -> null",
// "submitted": false,
// "marketCode": "OX-USDT",
// "side": "BUY",
// "price": "0.01961",
// "amount": "100",
// "orderType": "MARKET",
// "timeInForce": "IOC",
// "createdAt": "1715591678835",
// "source": 11,
// "selfTradePreventionMode": "NONE"
// }
// ]
// }
//
// rejected order (bad request)
// {
// "success": true,
// "data": [
// {
// "code": "20044",
// "message": "Amount is not supported for this order type",
// "submitted": false,
// "marketCode": "OX-USDT",
// "side": "SELL",
// "amount": "200",
// "orderType": "MARKET",
// "createdAt": "1715592079986",
// "source": 11
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
var order interface{} = this.SafeDict(data, 0, map[string]interface{} {})
ch <- this.ParseOrder(order)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#createOrders
* @description create a list of trade orders
* @see https://docs.ox.fun/?json#post-v3-orders-place
* @param {Array} orders list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.timestamp] *for all orders* in milliseconds. If orders reach the matching engine and the current timestamp exceeds timestamp + recvWindow, then all orders will be rejected.
* @param {int} [params.recvWindow] *for all orders* in milliseconds. If orders reach the matching engine and the current timestamp exceeds timestamp + recvWindow, then all orders will be rejected. If timestamp is provided without recvWindow, then a default recvWindow of 1000ms is used.
* @param {string} [params.responseType] *for all orders* FULL or ACK
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) CreateOrders(orders interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes24988 := (<-this.LoadMarkets())
PanicOnError(retRes24988)
var ordersRequests interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(orders)); i++ {
var rawOrder interface{} = GetValue(orders, i)
var symbol interface{} = this.SafeString(rawOrder, "symbol")
var typeVar interface{} = this.SafeString(rawOrder, "type")
var side interface{} = this.SafeString(rawOrder, "side")
var amount interface{} = this.SafeNumber(rawOrder, "amount")
var price interface{} = this.SafeNumber(rawOrder, "price")
var orderParams interface{} = this.SafeDict(rawOrder, "params", map[string]interface{} {})
var orderRequest interface{} = this.CreateOrderRequest(symbol, typeVar, side, amount, price, orderParams)
AppendToArray(&ordersRequests,orderRequest)
}
var request interface{} = map[string]interface{} {
"responseType": "FULL",
"timestamp": this.Milliseconds(),
"orders": ordersRequests,
}
response:= (<-this.PrivatePostV3OrdersPlace(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseOrders(data)
return nil
}()
return ch
}
func (this *oxfun) CreateOrderRequest(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) interface{} {
/**
* @param {string} symbol unified symbol of the market to create an order in
* @param {string} type 'market', 'limit', 'STOP_LIMIT' or 'STOP_MARKET'
* @param {string} side 'buy' or 'sell'
* @param {float} amount how much of currency you want to trade in units of base currency
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.clientOrderId] a unique id for the order
* @param {float} [params.cost] the quote quantity that can be used as an alternative for the amount for market buy orders
* @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
* @param {float} [params.limitPrice] Limit price for the STOP_LIMIT order
* @param {bool} [params.postOnly] if true, the order will only be posted if it will be a maker order
* @param {string} [params.timeInForce] GTC (default), IOC, FOK, PO, MAKER_ONLY or MAKER_ONLY_REPRICE (reprices order to the best maker only price if the specified price were to lead to a taker trade)
* @param {string} [params.selfTradePreventionMode] NONE, EXPIRE_MAKER, EXPIRE_TAKER or EXPIRE_BOTH for more info check here {@link https://docs.ox.fun/?json#self-trade-prevention-modes}
* @param {string} [params.displayQuantity] for an iceberg order, pass both quantity and displayQuantity fields in the order request
*/
price := GetArg(optionalArgs, 0, nil)
_ = price
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"marketCode": GetValue(market, "id"),
"side": ToUpper(side),
"source": 1000,
}
var cost interface{} = this.SafeString2(params, "cost", "amount")
if IsTrue(!IsEqual(cost, nil)) {
AddElementToObject(request, "amount", cost) // todo costToPrecision
params = this.Omit(params, []interface{}{"cost", "amount"})
} else {
AddElementToObject(request, "quantity", amount) // todo amountToPrecision
}
var triggerPrice interface{} = this.SafeString2(params, "triggerPrice", "stopPrice")
var orderType interface{} = ToUpper(typeVar)
if IsTrue(!IsEqual(triggerPrice, nil)) {
if IsTrue(IsEqual(orderType, "MARKET")) {
orderType = "STOP_MARKET"
} else if IsTrue(IsEqual(orderType, "LIMIT")) {
orderType = "STOP_LIMIT"
}
AddElementToObject(request, "stopPrice", triggerPrice) // todo priceToPrecision
params = this.Omit(params, []interface{}{"triggerPrice", "stopPrice"})
}
AddElementToObject(request, "orderType", orderType)
if IsTrue(IsEqual(orderType, "STOP_LIMIT")) {
AddElementToObject(request, "limitPrice", price) // todo priceToPrecision
} else if IsTrue(!IsEqual(price, nil)) {
AddElementToObject(request, "price", price) // todo priceToPrecision
}
var postOnly interface{} = nil
var isMarketOrder interface{} = IsTrue((IsEqual(orderType, "MARKET"))) || IsTrue((IsEqual(orderType, "STOP_MARKET")))
postOnlyparamsVariable := this.HandlePostOnly(isMarketOrder, false, params);
postOnly = GetValue(postOnlyparamsVariable,0);
params = GetValue(postOnlyparamsVariable,1)
var timeInForce interface{} = this.SafeStringUpper(params, "timeInForce")
if IsTrue(IsTrue(postOnly) && IsTrue((!IsEqual(timeInForce, "MAKER_ONLY_REPRICE")))) {
AddElementToObject(request, "timeInForce", "MAKER_ONLY")
}
return this.Extend(request, params)
}
/**
* @method
* @name oxfun#createMarketBuyOrderWithCost
* @description create a market buy order by providing the symbol and cost
* @see https://open.big.one/docs/spot_orders.html#create-order
* @param {string} symbol unified symbol of the market to create an order in
* @param {float} cost how much you want to trade in units of the quote currency
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) CreateMarketBuyOrderWithCost(symbol interface{}, cost 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
retRes25898 := (<-this.LoadMarkets())
PanicOnError(retRes25898)
var market interface{} = this.Market(symbol)
if !IsTrue(GetValue(market, "spot")) {
panic(NotSupported(Add(this.Id, " createMarketBuyOrderWithCost() supports spot orders only")))
}
var request interface{} = map[string]interface{} {
"cost": cost,
}
retRes259715 := (<-this.CreateOrder(symbol, "market", "buy", nil, nil, this.Extend(request, params)))
PanicOnError(retRes259715)
ch <- retRes259715
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchOrder
* @see https://docs.ox.fun/?json#get-v3-orders-status
* @description fetches information on an order made by the user
* @param {string} id a unique id for the order
* @param {string} [symbol] not used by oxfun fetchOrder
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.clientOrderId] the client order id of the order
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) 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
retRes26128 := (<-this.LoadMarkets())
PanicOnError(retRes26128)
var request interface{} = map[string]interface{} {
"orderId": id,
}
response:= (<-this.PrivateGetV3OrdersStatus(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "data": {
// "orderId": "1000111762980",
// "clientOrderId": "0",
// "marketCode": "ETH-USD-SWAP-LIN",
// "status": "OPEN",
// "side": "BUY",
// "price": "2700.0",
// "isTriggered": false,
// "remainQuantity": "0.01",
// "totalQuantity": "0.01",
// "amount": "0",
// "displayQuantity": "0.01",
// "cumulativeMatchedQuantity": "0",
// "orderType": "STOP_LIMIT",
// "timeInForce": "GTC",
// "source": "11",
// "createdAt": "1715794191277"
// }
// }
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- this.ParseOrder(data)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#fetchOpenOrders
* @description fetch all unfilled currently open orders
* @see https://docs.ox.fun/?json#get-v3-orders-working
* @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
* @param {int} [params.orderId] a unique id for the order
* @param {int} [params.clientOrderId] the client order id of the order
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) 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
retRes26588 := (<-this.LoadMarkets())
PanicOnError(retRes26588)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
}
response:= (<-this.PrivateGetV3OrdersWorking(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseOrders(data, market, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#cancelOrder
* @description cancels an open order
* @see https://docs.ox.fun/?json#delete-v3-orders-cancel
* @param {string} id order id
* @param {string} symbol unified symbol of the market the order was made in
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.clientOrderId] a unique id for the order
* @param {int} [params.timestamp] in milliseconds
* @param {int} [params.recvWindow] in milliseconds
* @param {string} [params.responseType] 'FULL' or 'ACK'
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) CancelOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument")))
}
var market interface{} = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
var request interface{} = map[string]interface{} {
"timestamp": this.Milliseconds(),
"responseType": "FULL",
}
var orderRequest interface{} = map[string]interface{} {
"marketCode": marketId,
"orderId": id,
}
var clientOrderId interface{} = this.SafeInteger(params, "clientOrderId")
if IsTrue(!IsEqual(clientOrderId, nil)) {
AddElementToObject(orderRequest, "clientOrderId", clientOrderId)
}
AddElementToObject(request, "orders", []interface{}{orderRequest})
response:= (<-this.PrivateDeleteV3OrdersCancel(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeList(response, "data", []interface{}{})
var order interface{} = this.SafeDict(data, 0, map[string]interface{} {})
ch <- this.ParseOrder(order)
return nil
}()
return ch
}
/**
* @method
* @name oxfun#cancelAllOrders
* @description cancel all open orders
* @see https://docs.ox.fun/?json#delete-v3-orders-cancel-all
* @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} response from exchange
*/
func (this *oxfun) CancelAllOrders(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
var request interface{} = map[string]interface{} {}
if IsTrue(!IsEqual(symbol, nil)) {
var market interface{} = this.Market(symbol)
AddElementToObject(request, "marketCode", GetValue(market, "id"))
}
retRes273415 := (<-this.PrivateDeleteV3OrdersCancelAll(this.Extend(request, params)))
PanicOnError(retRes273415)
//
// {
// "success": true,
// "data": { "notice": "Orders queued for cancelation" }
// }
//
// {
// "success": true,
// "data": { "notice": "No working orders found" }
// }
//
ch <- retRes273415
return nil
}()
return ch
}
/**
* @method
* @name oxfun#cancelOrders
* @description cancel multiple orders
* @see https://docs.ox.fun/?json#delete-v3-orders-cancel
* @param {string[]} ids order ids
* @param {string} [symbol] unified market symbol
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.timestamp] in milliseconds
* @param {int} [params.recvWindow] in milliseconds
* @param {string} [params.responseType] 'FULL' or 'ACK'
* @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *oxfun) CancelOrders(ids interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " cancelOrders() requires a symbol argument")))
}
retRes27548 := (<-this.LoadMarkets())
PanicOnError(retRes27548)
var market interface{} = this.Market(symbol)
var marketId interface{} = GetValue(market, "id")
var request interface{} = map[string]interface{} {
"timestamp": this.Milliseconds(),
"responseType": "FULL",
}
var orders interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(ids)); i++ {
var order interface{} = map[string]interface{} {
"marketCode": marketId,
"orderId": GetValue(ids, i),
}
AppendToArray(&orders,order)
}
AddElementToObject(request, "orders", orders)
response:= (<-this.PrivateDeleteV3OrdersCancel(this.Extend(request, params)))
PanicOnError(response)
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseOrders(data, market)
return nil
}()
return ch
}
func (this *oxfun) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
//
// accepted market order responseType FULL
// {
// "notice": "OrderMatched",
// "accountId": "106490",
// "orderId": "1000109901865",
// "submitted": true,
// "clientOrderId": "0",
// "marketCode": "OX-USDT",
// "status": "FILLED",
// "side": "SELL",
// "isTriggered": false,
// "quantity": "150.0",
// "amount": "0.0",
// "remainQuantity": "0.0",
// "matchId": "100017047880451399",
// "matchPrice": "0.01465",
// "matchQuantity": "150.0",
// "feeInstrumentId": "USDT",
// "fees": "0.0015382500",
// "orderType": "MARKET",
// "createdAt": "1715592472236",
// "lastMatchedAt": "1715592472200",
// "displayQuantity": "150.0"
// }
//
// accepted limit order responseType FULL
// {
// "notice": "OrderOpened",
// "accountId": "106490",
// "orderId": "1000111482406",
// "submitted": true,
// "clientOrderId": "0",
// "marketCode": "ETH-USD-SWAP-LIN",
// "status": "OPEN",
// "side": "SELL",
// "price": "4000.0",
// "isTriggered": false,
// "quantity": "0.01",
// "amount": "0.0",
// "orderType": "LIMIT",
// "timeInForce": "GTC",
// "createdAt": "1715763507682",
// "displayQuantity": "0.01"
// }
//
// accepted order responseType ACK
// {
// "accountId": "106490",
// "orderId": "1000109892193",
// "submitted": true,
// "marketCode": "OX-USDT",
// "side": "BUY",
// "price": "0.01961",
// "isTriggered": false,
// "quantity": "100",
// "orderType": "MARKET",
// "timeInForce": "IOC",
// "createdAt": "1715591529057",
// "selfTradePreventionMode": "NONE"
// }
//
// rejected order (balance insufficient)
// {
// "code": "710001",
// "message": "System failure, exception thrown -> null",
// "submitted": false,
// "marketCode": "OX-USDT",
// "side": "BUY",
// "price": "0.01961",
// "amount": "100",
// "orderType": "MARKET",
// "timeInForce": "IOC",
// "createdAt": "1715591678835",
// "source": 11,
// "selfTradePreventionMode": "NONE"
// }
//
// rejected order (bad request)
// {
// "code": "20044",
// "message": "Amount is not supported for this order type",
// "submitted": false,
// "marketCode": "OX-USDT",
// "side": "SELL",
// "amount": "200",
// "orderType": "MARKET",
// "createdAt": "1715592079986",
// "source": 11
// }
//
// fetchOrder
// {
// "orderId": "1000111762980",
// "clientOrderId": "0",
// "marketCode": "ETH-USD-SWAP-LIN",
// "status": "OPEN",
// "side": "BUY",
// "price": "2700.0",
// "isTriggered": false,
// "remainQuantity": "0.01",
// "totalQuantity": "0.01",
// "amount": "0",
// "displayQuantity": "0.01",
// "cumulativeMatchedQuantity": "0",
// "orderType": "STOP_LIMIT",
// "timeInForce": "GTC",
// "source": "11",
// "createdAt": "1715794191277"
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(order, "marketCode")
market = this.SafeMarket(marketId, market)
var timestamp interface{} = this.SafeInteger(order, "createdAt")
var fee interface{} = nil
var feeCurrency interface{} = this.SafeString(order, "feeInstrumentId")
if IsTrue(!IsEqual(feeCurrency, nil)) {
fee = map[string]interface{} {
"currency": this.SafeCurrencyCode(feeCurrency),
"cost": this.SafeNumber(order, "fees"),
}
}
var status interface{} = this.SafeString(order, "status")
var code interface{} = this.SafeInteger(order, "code") // rejected orders have code of the error
if IsTrue(!IsEqual(code, nil)) {
status = "rejected"
}
var triggerPrice interface{} = this.SafeString(order, "stopPrice")
return this.SafeOrder(map[string]interface{} {
"id": this.SafeString(order, "orderId"),
"clientOrderId": this.SafeString(order, "clientOrderId"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"lastTradeTimestamp": this.SafeInteger(order, "lastMatchedAt"),
"lastUpdateTimestamp": this.SafeInteger(order, "lastModifiedAt"),
"status": this.ParseOrderStatus(status),
"symbol": GetValue(market, "symbol"),
"type": this.ParseOrderType(this.SafeString(order, "orderType")),
"timeInForce": this.ParseOrderTimeInForce(this.SafeString(order, "timeInForce")),
"side": this.SafeStringLower(order, "side"),
"price": this.SafeStringN(order, []interface{}{"price", "matchPrice", "limitPrice"}),
"average": nil,
"amount": this.SafeString2(order, "totalQuantity", "quantity"),
"filled": this.SafeString2(order, "cumulativeMatchedQuantity", "matchQuantity"),
"remaining": this.SafeString(order, "remainQuantity"),
"triggerPrice": triggerPrice,
"stopLossPrice": triggerPrice,
"cost": this.OmitZero(this.SafeString(order, "amount")),
"trades": nil,
"fee": fee,
"info": order,
}, market)
}
func (this *oxfun) ParseOrderStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"OPEN": "open",
"PARTIALLY_FILLED": "open",
"PARTIAL_FILL": "open",
"FILLED": "closed",
"CANCELED": "canceled",
"CANCELED_BY_USER": "canceled",
"CANCELED_BY_MAKER_ONLY": "rejected",
"CANCELED_BY_FOK": "rejected",
"CANCELED_ALL_BY_IOC": "rejected",
"CANCELED_PARTIAL_BY_IOC": "canceled",
"CANCELED_BY_SELF_TRADE_PROTECTION": "rejected",
}
return this.SafeString(statuses, status, status)
}
func (this *oxfun) ParseOrderType(typeVar interface{}) interface{} {
var types interface{} = map[string]interface{} {
"LIMIT": "limit",
"STOP_LIMIT": "limit",
"MARKET": "market",
"STOP_MARKET": "market",
}
return this.SafeString(types, typeVar, typeVar)
}
func (this *oxfun) ParseOrderTimeInForce(typeVar interface{}) interface{} {
var types interface{} = map[string]interface{} {
"GTC": "GTC",
"IOC": "IOC",
"FOK": "FOK",
"MAKER_ONLY": "PO",
"MAKER_ONLY_REPRICE": "PO",
}
return this.SafeString(types, typeVar, typeVar)
}
func (this *oxfun) 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 baseUrl interface{} = GetValue(GetValue(this.Urls, "api"), api)
var url interface{} = Add(Add(baseUrl, "/"), path)
var queryString interface{} = ""
if IsTrue(IsEqual(method, "GET")) {
queryString = this.Urlencode(params)
if IsTrue(!IsEqual(GetLength(queryString), 0)) {
url = Add(url, Add("?", queryString))
}
}
if IsTrue(IsEqual(api, "private")) {
this.CheckRequiredCredentials()
var timestamp interface{} = this.Milliseconds()
var isoDatetime interface{} = this.Iso8601(timestamp)
var datetimeParts interface{} = Split(isoDatetime, ".")
var datetime interface{} = GetValue(datetimeParts, 0)
var nonce interface{} = this.Nonce()
var urlParts interface{} = Split(baseUrl, "//")
if IsTrue(IsTrue((IsEqual(method, "POST"))) || IsTrue((IsEqual(method, "DELETE")))) {
body = this.Json(params)
queryString = body
}
var msgString interface{} = Add(Add(Add(Add(Add(Add(Add(Add(Add(Add(datetime, "\n"), ToString(nonce)), "\n"), method), "\n"), GetValue(urlParts, 1)), "\n/"), path), "\n"), queryString)
var signature interface{} = this.Hmac(this.Encode(msgString), this.Encode(this.Secret), sha256, "base64")
headers = map[string]interface{} {
"Content-Type": "application/json",
"AccessKey": this.ApiKey,
"Timestamp": datetime,
"Signature": signature,
"Nonce": ToString(nonce),
}
}
return map[string]interface{} {
"url": url,
"method": method,
"body": body,
"headers": headers,
}
}
func (this *oxfun) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} {
if IsTrue(IsEqual(response, nil)) {
return nil
}
if IsTrue(!IsEqual(code, 200)) {
var responseCode interface{} = this.SafeString(response, "code", nil)
var feedback interface{} = Add(Add(this.Id, " "), body)
this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), body, feedback)
this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), responseCode, feedback)
panic(ExchangeError(feedback))
}
return nil
}
func (this *oxfun) 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