ext/ccxt-go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ccxt-go/mexc.go
zhangkun9038@dingtalk.com 1a2ce7046a first add
2025-02-28 10:33:20 +08:00

6772 lines
297 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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 mexc struct {
Exchange
}
func NewMexcCore() mexc {
p := mexc{}
setDefaults(&p)
return p
}
func (this *mexc) Describe() interface{} {
return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
"id": "mexc",
"name": "MEXC Global",
"countries": []interface{}{"SC"},
"rateLimit": 50,
"version": "v3",
"certified": true,
"pro": true,
"has": map[string]interface{} {
"CORS": nil,
"spot": true,
"margin": true,
"swap": true,
"future": false,
"option": false,
"addMargin": true,
"borrowCrossMargin": false,
"borrowIsolatedMargin": false,
"borrowMargin": false,
"cancelAllOrders": true,
"cancelOrder": true,
"cancelOrders": nil,
"closeAllPositions": false,
"closePosition": false,
"createDepositAddress": true,
"createMarketBuyOrderWithCost": true,
"createMarketOrderWithCost": true,
"createMarketSellOrderWithCost": true,
"createOrder": true,
"createOrders": true,
"createPostOnlyOrder": true,
"createReduceOnlyOrder": true,
"createStopLimitOrder": true,
"createStopMarketOrder": true,
"createStopOrder": true,
"createTriggerOrder": true,
"deposit": nil,
"editOrder": nil,
"fetchAccounts": true,
"fetchBalance": true,
"fetchBidsAsks": true,
"fetchBorrowInterest": false,
"fetchBorrowRate": false,
"fetchBorrowRateHistories": false,
"fetchBorrowRateHistory": false,
"fetchBorrowRates": false,
"fetchBorrowRatesPerSymbol": false,
"fetchCanceledOrders": true,
"fetchClosedOrder": nil,
"fetchClosedOrders": true,
"fetchCrossBorrowRate": false,
"fetchCrossBorrowRates": false,
"fetchCurrencies": true,
"fetchDeposit": nil,
"fetchDepositAddress": true,
"fetchDepositAddresses": nil,
"fetchDepositAddressesByNetwork": true,
"fetchDeposits": true,
"fetchDepositWithdrawFee": "emulated",
"fetchDepositWithdrawFees": true,
"fetchFundingHistory": true,
"fetchFundingInterval": true,
"fetchFundingIntervals": false,
"fetchFundingRate": true,
"fetchFundingRateHistory": true,
"fetchFundingRates": false,
"fetchIndexOHLCV": true,
"fetchIsolatedBorrowRate": false,
"fetchIsolatedBorrowRates": false,
"fetchIsolatedPositions": false,
"fetchL2OrderBook": true,
"fetchLedger": nil,
"fetchLedgerEntry": nil,
"fetchLeverage": true,
"fetchLeverages": false,
"fetchLeverageTiers": true,
"fetchMarginAdjustmentHistory": false,
"fetchMarginMode": false,
"fetchMarketLeverageTiers": "emulated",
"fetchMarkets": true,
"fetchMarkOHLCV": true,
"fetchMyTrades": true,
"fetchOHLCV": true,
"fetchOpenInterest": false,
"fetchOpenInterestHistory": false,
"fetchOpenOrder": nil,
"fetchOpenOrders": true,
"fetchOrder": true,
"fetchOrderBook": true,
"fetchOrderBooks": nil,
"fetchOrders": true,
"fetchOrderTrades": true,
"fetchPosition": "emulated",
"fetchPositionHistory": "emulated",
"fetchPositionMode": true,
"fetchPositions": true,
"fetchPositionsHistory": true,
"fetchPositionsRisk": nil,
"fetchPremiumIndexOHLCV": false,
"fetchStatus": true,
"fetchTicker": true,
"fetchTickers": true,
"fetchTime": true,
"fetchTrades": true,
"fetchTradingFee": true,
"fetchTradingFees": false,
"fetchTradingLimits": nil,
"fetchTransactionFee": "emulated",
"fetchTransactionFees": true,
"fetchTransactions": nil,
"fetchTransfer": true,
"fetchTransfers": true,
"fetchWithdrawal": nil,
"fetchWithdrawals": true,
"reduceMargin": true,
"repayCrossMargin": false,
"repayIsolatedMargin": false,
"setLeverage": true,
"setMarginMode": true,
"setPositionMode": true,
"signIn": nil,
"transfer": nil,
"withdraw": true,
},
"urls": map[string]interface{} {
"logo": "https://user-images.githubusercontent.com/1294454/137283979-8b2a818d-8633-461b-bfca-de89e8c446b2.jpg",
"api": map[string]interface{} {
"spot": map[string]interface{} {
"public": "https://api.mexc.com",
"private": "https://api.mexc.com",
},
"spot2": map[string]interface{} {
"public": "https://www.mexc.com/open/api/v2",
"private": "https://www.mexc.com/open/api/v2",
},
"contract": map[string]interface{} {
"public": "https://contract.mexc.com/api/v1/contract",
"private": "https://contract.mexc.com/api/v1/private",
},
"broker": map[string]interface{} {
"private": "https://api.mexc.com/api/v3/broker",
},
},
"www": "https://www.mexc.com/",
"doc": []interface{}{"https://mexcdevelop.github.io/apidocs/"},
"fees": []interface{}{"https://www.mexc.com/fee"},
"referral": "https://www.mexc.com/register?inviteCode=mexc-1FQ1GNu1",
},
"api": map[string]interface{} {
"spot": map[string]interface{} {
"public": map[string]interface{} {
"get": map[string]interface{} {
"ping": 1,
"time": 1,
"exchangeInfo": 10,
"depth": 1,
"trades": 5,
"historicalTrades": 1,
"aggTrades": 1,
"klines": 1,
"avgPrice": 1,
"ticker/24hr": 1,
"ticker/price": 1,
"ticker/bookTicker": 1,
"etf/info": 1,
},
},
"private": map[string]interface{} {
"get": map[string]interface{} {
"order": 2,
"openOrders": 3,
"allOrders": 10,
"account": 10,
"myTrades": 10,
"tradeFee": 10,
"sub-account/list": 1,
"sub-account/apiKey": 1,
"capital/config/getall": 10,
"capital/deposit/hisrec": 1,
"capital/withdraw/history": 1,
"capital/withdraw/address": 10,
"capital/deposit/address": 10,
"capital/transfer": 1,
"capital/transfer/tranId": 1,
"capital/transfer/internal": 1,
"capital/sub-account/universalTransfer": 1,
"capital/convert": 1,
"capital/convert/list": 1,
"margin/loan": 1,
"margin/allOrders": 1,
"margin/myTrades": 1,
"margin/openOrders": 1,
"margin/maxTransferable": 1,
"margin/priceIndex": 1,
"margin/order": 1,
"margin/isolated/account": 1,
"margin/maxBorrowable": 1,
"margin/repay": 1,
"margin/isolated/pair": 1,
"margin/forceLiquidationRec": 1,
"margin/isolatedMarginData": 1,
"margin/isolatedMarginTier": 1,
"rebate/taxQuery": 1,
"rebate/detail": 1,
"rebate/detail/kickback": 1,
"rebate/referCode": 1,
"rebate/affiliate/commission": 1,
"rebate/affiliate/withdraw": 1,
"rebate/affiliate/commission/detail": 1,
"mxDeduct/enable": 1,
"userDataStream": 1,
"selfSymbols": 1,
},
"post": map[string]interface{} {
"order": 1,
"order/test": 1,
"sub-account/virtualSubAccount": 1,
"sub-account/apiKey": 1,
"sub-account/futures": 1,
"sub-account/margin": 1,
"batchOrders": 10,
"capital/withdraw/apply": 1,
"capital/withdraw": 1,
"capital/transfer": 1,
"capital/transfer/internal": 1,
"capital/deposit/address": 1,
"capital/sub-account/universalTransfer": 1,
"capital/convert": 10,
"mxDeduct/enable": 1,
"userDataStream": 1,
},
"put": map[string]interface{} {
"userDataStream": 1,
},
"delete": map[string]interface{} {
"order": 1,
"openOrders": 1,
"sub-account/apiKey": 1,
"margin/order": 1,
"margin/openOrders": 1,
"userDataStream": 1,
"capital/withdraw": 1,
},
},
},
"contract": map[string]interface{} {
"public": map[string]interface{} {
"get": map[string]interface{} {
"ping": 2,
"detail": 100,
"support_currencies": 2,
"depth/{symbol}": 2,
"depth_commits/{symbol}/{limit}": 2,
"index_price/{symbol}": 2,
"fair_price/{symbol}": 2,
"funding_rate/{symbol}": 2,
"kline/{symbol}": 2,
"kline/index_price/{symbol}": 2,
"kline/fair_price/{symbol}": 2,
"deals/{symbol}": 2,
"ticker": 2,
"risk_reverse": 2,
"risk_reverse/history": 2,
"funding_rate/history": 2,
},
},
"private": map[string]interface{} {
"get": map[string]interface{} {
"account/assets": 2,
"account/asset/{currency}": 2,
"account/transfer_record": 2,
"position/list/history_positions": 2,
"position/open_positions": 2,
"position/funding_records": 2,
"position/position_mode": 2,
"order/list/open_orders/{symbol}": 2,
"order/list/history_orders": 2,
"order/external/{symbol}/{external_oid}": 2,
"order/get/{order_id}": 2,
"order/batch_query": 8,
"order/deal_details/{order_id}": 2,
"order/list/order_deals": 2,
"planorder/list/orders": 2,
"stoporder/list/orders": 2,
"stoporder/order_details/{stop_order_id}": 2,
"account/risk_limit": 2,
"account/tiered_fee_rate": 2,
"position/leverage": 2,
},
"post": map[string]interface{} {
"position/change_margin": 2,
"position/change_leverage": 2,
"position/change_position_mode": 2,
"order/submit": 2,
"order/submit_batch": 40,
"order/cancel": 2,
"order/cancel_with_external": 2,
"order/cancel_all": 2,
"account/change_risk_level": 2,
"planorder/place": 2,
"planorder/cancel": 2,
"planorder/cancel_all": 2,
"stoporder/cancel": 2,
"stoporder/cancel_all": 2,
"stoporder/change_price": 2,
"stoporder/change_plan_price": 2,
},
},
},
"spot2": map[string]interface{} {
"public": map[string]interface{} {
"get": map[string]interface{} {
"market/symbols": 1,
"market/coin/list": 2,
"common/timestamp": 1,
"common/ping": 2,
"market/ticker": 1,
"market/depth": 1,
"market/deals": 1,
"market/kline": 1,
"market/api_default_symbols": 2,
},
},
"private": map[string]interface{} {
"get": map[string]interface{} {
"account/info": 1,
"order/open_orders": 1,
"order/list": 1,
"order/query": 1,
"order/deals": 1,
"order/deal_detail": 1,
"asset/deposit/address/list": 2,
"asset/deposit/list": 2,
"asset/address/list": 2,
"asset/withdraw/list": 2,
"asset/internal/transfer/record": 10,
"account/balance": 10,
"asset/internal/transfer/info": 10,
"market/api_symbols": 2,
},
"post": map[string]interface{} {
"order/place": 1,
"order/place_batch": 1,
"order/advanced/place_batch": 1,
"asset/withdraw": 2,
"asset/internal/transfer": 10,
},
"delete": map[string]interface{} {
"order/cancel": 1,
"order/cancel_by_symbol": 1,
"asset/withdraw": 2,
},
},
},
"broker": map[string]interface{} {
"private": map[string]interface{} {
"get": map[string]interface{} {
"sub-account/universalTransfer": 1,
"sub-account/list": 1,
"sub-account/apiKey": 1,
"capital/deposit/subAddress": 1,
"capital/deposit/subHisrec": 1,
"capital/deposit/subHisrec/getall": 1,
},
"post": map[string]interface{} {
"sub-account/virtualSubAccount": 1,
"sub-account/apiKey": 1,
"capital/deposit/subAddress": 1,
"capital/withdraw/apply": 1,
"sub-account/universalTransfer": 1,
"sub-account/futures": 1,
},
"delete": map[string]interface{} {
"sub-account/apiKey": 1,
},
},
},
},
"precisionMode": TICK_SIZE,
"timeframes": map[string]interface{} {
"1m": "1m",
"5m": "5m",
"15m": "15m",
"30m": "30m",
"1h": "1h",
"4h": "4h",
"8h": "8h",
"1d": "1d",
"1w": "1w",
"1M": "1M",
},
"fees": map[string]interface{} {
"trading": map[string]interface{} {
"tierBased": false,
"percentage": true,
"maker": this.ParseNumber("0.002"),
"taker": this.ParseNumber("0.002"),
},
},
"options": map[string]interface{} {
"adjustForTimeDifference": false,
"timeDifference": 0,
"unavailableContracts": map[string]interface{} {
"BTC/USDT:USDT": true,
"LTC/USDT:USDT": true,
"ETH/USDT:USDT": true,
},
"fetchMarkets": map[string]interface{} {
"types": map[string]interface{} {
"spot": true,
"swap": map[string]interface{} {
"linear": true,
"inverse": false,
},
},
},
"timeframes": map[string]interface{} {
"spot": map[string]interface{} {
"1m": "1m",
"5m": "5m",
"15m": "15m",
"30m": "30m",
"1h": "60m",
"4h": "4h",
"1d": "1d",
"1w": "1W",
"1M": "1M",
},
"swap": map[string]interface{} {
"1m": "Min1",
"5m": "Min5",
"15m": "Min15",
"30m": "Min30",
"1h": "Min60",
"4h": "Hour4",
"8h": "Hour8",
"1d": "Day1",
"1w": "Week1",
"1M": "Month1",
},
},
"defaultType": "spot",
"defaultNetwork": "ETH",
"defaultNetworks": map[string]interface{} {
"ETH": "ETH",
"USDT": "ERC20",
"USDC": "ERC20",
"BTC": "BTC",
"LTC": "LTC",
},
"networks": map[string]interface{} {
"ZKSYNC": "ZKSYNCERA",
"TRC20": "TRX",
"TON": "TONCOIN",
"AVAXC": "AVAX_CCHAIN",
"ERC20": "ETH",
"ACA": "ACALA",
"BEP20": "BSC",
"OPTIMISM": "OP",
"ASTR": "ASTAR",
"BTM": "BTM2",
"CRC20": "CRONOS",
"ETHF": "ETF",
"HRC20": "HECO",
"OASIS": "ROSE",
"OKC": "OKT",
"RSK": "RBTC",
},
"networksById": map[string]interface{} {
"BNB Smart Chain(BEP20-RACAV1)": "BSC",
"BNB Smart Chain(BEP20-RACAV2)": "BSC",
"BNB Smart Chain(BEP20)": "BSC",
},
"recvWindow": Multiply(5, 1000),
"maxTimeTillEnd": Subtract(Multiply(Multiply(90, 86400), 1000), 1),
"broker": "CCXT",
},
"features": map[string]interface{} {
"default": map[string]interface{} {
"sandbox": false,
"createOrder": map[string]interface{} {
"marginMode": true,
"triggerPrice": false,
"triggerDirection": false,
"triggerPriceType": map[string]interface{} {
"last": false,
"mark": false,
"index": false,
},
"stopLossPrice": false,
"takeProfitPrice": false,
"attachedStopLossTakeProfit": nil,
"timeInForce": map[string]interface{} {
"IOC": true,
"FOK": true,
"PO": true,
"GTD": false,
},
"hedged": true,
"trailing": false,
"leverage": true,
"marketBuyByCost": true,
"marketBuyRequiresPrice": false,
"selfTradePrevention": false,
"iceberg": false,
},
"createOrders": map[string]interface{} {
"max": 20,
},
"fetchMyTrades": map[string]interface{} {
"marginMode": false,
"limit": 100,
"daysBack": 30,
"untilDays": nil,
"symbolRequired": true,
},
"fetchOrder": map[string]interface{} {
"marginMode": false,
"trigger": false,
"trailing": false,
"symbolRequired": true,
},
"fetchOpenOrders": map[string]interface{} {
"marginMode": true,
"limit": nil,
"trigger": false,
"trailing": false,
"symbolRequired": true,
},
"fetchOrders": map[string]interface{} {
"marginMode": true,
"limit": 1000,
"daysBack": 7,
"untilDays": 7,
"trigger": false,
"trailing": false,
"symbolRequired": true,
},
"fetchClosedOrders": map[string]interface{} {
"marginMode": true,
"limit": 1000,
"daysBack": 7,
"daysBackCanceled": 7,
"untilDays": 7,
"trigger": false,
"trailing": false,
"symbolRequired": true,
},
"fetchOHLCV": map[string]interface{} {
"limit": 1000,
},
},
"spot": map[string]interface{} {
"extends": "default",
},
"forDerivs": map[string]interface{} {
"extends": "default",
"createOrder": map[string]interface{} {
"triggerPrice": true,
"triggerPriceType": map[string]interface{} {
"last": true,
"mark": true,
"index": true,
},
"triggerDirection": true,
"stopLossPrice": false,
"takeProfitPrice": false,
"hedged": true,
"leverage": true,
"marketBuyByCost": false,
},
"createOrders": nil,
"fetchMyTrades": map[string]interface{} {
"marginMode": false,
"limit": 100,
"daysBack": 90,
"untilDays": 90,
},
"fetchOrder": map[string]interface{} {
"marginMode": false,
},
"fetchOpenOrders": map[string]interface{} {
"marginMode": false,
"limit": 100,
"trigger": true,
"trailing": false,
},
"fetchOrders": map[string]interface{} {
"marginMode": false,
"limit": 100,
"daysBack": 90,
"untilDays": 90,
"trigger": true,
"trailing": false,
},
"fetchClosedOrders": map[string]interface{} {
"marginMode": false,
"limit": 100,
"daysBack": 90,
"daysBackCanceled": nil,
"untilDays": 90,
"trigger": true,
"trailing": false,
},
"fetchOHLCV": map[string]interface{} {
"limit": 2000,
},
},
"swap": map[string]interface{} {
"linear": map[string]interface{} {
"extends": "forDerivs",
},
"inverse": map[string]interface{} {
"extends": "forDerivs",
},
},
"future": map[string]interface{} {
"linear": nil,
"inverse": nil,
},
},
"commonCurrencies": map[string]interface{} {
"BEYONDPROTOCOL": "BEYOND",
"BIFI": "BIFIF",
"BYN": "BEYONDFI",
"COFI": "COFIX",
"DFI": "DFISTARTER",
"DFT": "DFUTURE",
"DRK": "DRK",
"EGC": "EGORASCREDIT",
"FLUX1": "FLUX",
"FLUX": "FLUX1",
"FREE": "FREEROSSDAO",
"GAS": "GASDAO",
"GASNEO": "GAS",
"GMT": "GMTTOKEN",
"STEPN": "GMT",
"HERO": "STEPHERO",
"MIMO": "MIMOSA",
"PROS": "PROSFINANCE",
"SIN": "SINCITYTOKEN",
"SOUL": "SOULSWAP",
},
"exceptions": map[string]interface{} {
"exact": map[string]interface{} {
"-1128": BadRequest,
"-2011": BadRequest,
"-1121": BadSymbol,
"10101": InsufficientFunds,
"2009": InvalidOrder,
"2011": BadRequest,
"30004": InsufficientFunds,
"33333": BadRequest,
"44444": BadRequest,
"1002": InvalidOrder,
"30019": BadRequest,
"30005": InvalidOrder,
"2003": InvalidOrder,
"2005": InsufficientFunds,
"400": BadRequest,
"600": BadRequest,
"70011": PermissionDenied,
"88004": InsufficientFunds,
"88009": ExchangeError,
"88013": InvalidOrder,
"88015": InsufficientFunds,
"700003": InvalidNonce,
"26": ExchangeError,
"602": AuthenticationError,
"10001": AuthenticationError,
"10007": BadSymbol,
"10015": BadRequest,
"10072": BadRequest,
"10073": BadRequest,
"10095": InvalidOrder,
"10096": InvalidOrder,
"10097": InvalidOrder,
"10098": InvalidOrder,
"10099": BadRequest,
"10100": BadRequest,
"10102": InvalidOrder,
"10103": ExchangeError,
"10200": BadRequest,
"10201": BadRequest,
"10202": BadRequest,
"10206": BadRequest,
"10211": BadRequest,
"10212": BadRequest,
"10216": ExchangeError,
"10219": ExchangeError,
"10222": BadRequest,
"10232": BadRequest,
"10259": ExchangeError,
"10265": ExchangeError,
"10268": BadRequest,
"20001": ExchangeError,
"20002": ExchangeError,
"22222": BadRequest,
"30000": ExchangeError,
"30001": InvalidOrder,
"30002": InvalidOrder,
"30003": InvalidOrder,
"30010": InvalidOrder,
"30014": InvalidOrder,
"30016": InvalidOrder,
"30018": AccountSuspended,
"30020": AuthenticationError,
"30021": BadRequest,
"30025": InvalidOrder,
"30026": BadRequest,
"30027": InvalidOrder,
"30028": InvalidOrder,
"30029": InvalidOrder,
"30032": InvalidOrder,
"30041": InvalidOrder,
"60005": ExchangeError,
"700001": AuthenticationError,
"700002": AuthenticationError,
"700004": BadRequest,
"700005": InvalidNonce,
"700006": BadRequest,
"700007": AuthenticationError,
"700008": BadRequest,
"700013": AuthenticationError,
"730001": BadRequest,
"730002": BadRequest,
"730000": ExchangeError,
"730003": ExchangeError,
"730100": ExchangeError,
"730600": BadRequest,
"730601": BadRequest,
"730602": BadRequest,
"730700": BadRequest,
"730701": BadRequest,
"730702": BadRequest,
"730703": BadRequest,
"730704": BadRequest,
"730705": BadRequest,
"730706": BadRequest,
"730707": BadRequest,
"730101": BadRequest,
"140001": BadRequest,
"140002": AuthenticationError,
},
"broad": map[string]interface{} {
"Order quantity error, please try to modify.": BadRequest,
"Combination of optional parameters invalid": BadRequest,
"api market order is disabled": BadRequest,
"Contract not allow place order!": InvalidOrder,
"Oversold": InsufficientFunds,
"Insufficient position": InsufficientFunds,
"Insufficient balance!": InsufficientFunds,
"Bid price is great than max allow price": InvalidOrder,
"Invalid symbol.": BadSymbol,
"Param error!": BadRequest,
"maintenance": OnMaintenance,
},
},
})
}
/**
* @method
* @name mexc#fetchStatus
* @description the latest known information on the availability of the exchange API
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#test-connectivity
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-server-time
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [status structure]{@link https://docs.ccxt.com/#/?id=exchange-status-structure}
*/
func (this *mexc) FetchStatus(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
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchStatus", nil, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
var response interface{} = nil
var status interface{} = nil
var updated interface{} = nil
if IsTrue(IsEqual(marketType, "spot")) {
response = (<-this.SpotPublicGetPing(query))
PanicOnError(response)
//
// {}
//
var keys interface{} = ObjectKeys(response)
var length interface{} = GetArrayLength(keys)
status = Ternary(IsTrue(length), this.Json(response), "ok")
} else if IsTrue(IsEqual(marketType, "swap")) {
response = (<-this.ContractPublicGetPing(query))
PanicOnError(response)
//
// {"success":true,"code":"0","data":"1648124374985"}
//
status = Ternary(IsTrue(this.SafeValue(response, "success")), "ok", this.Json(response))
updated = this.SafeInteger(response, "data")
}
ch <- map[string]interface{} {
"status": status,
"updated": updated,
"url": nil,
"eta": nil,
"info": response,
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchTime
* @description fetches the current integer timestamp in milliseconds from the exchange server
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#check-server-time
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-server-time
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {int} the current integer timestamp in milliseconds from the exchange server
*/
func (this *mexc) FetchTime(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchTime", nil, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
var response interface{} = nil
if IsTrue(IsEqual(marketType, "spot")) {
response = (<-this.SpotPublicGetTime(query))
PanicOnError(response)
//
// {"serverTime": "1647519277579"}
//
ch <- this.SafeInteger(response, "serverTime")
return nil
} else if IsTrue(IsEqual(marketType, "swap")) {
response = (<-this.ContractPublicGetPing(query))
PanicOnError(response)
//
// {"success":true,"code":"0","data":"1648124374985"}
//
ch <- this.SafeInteger(response, "data")
return nil
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchCurrencies
* @description fetches all available currencies on an exchange
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#query-the-currency-information
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} an associative dictionary of currencies
*/
func (this *mexc) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
// this endpoint requires authentication
// while fetchCurrencies is a public API method by design
// therefore we check the keys here
// and fallback to generating the currencies from the markets
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
if !IsTrue(this.CheckRequiredCredentials(false)) {
return nil
}
response:= (<-this.SpotPrivateGetCapitalConfigGetall(params))
PanicOnError(response)
//
// {
// "coin": "QANX",
// "name": "QANplatform",
// "networkList": [
// {
// "coin": "QANX",
// "depositDesc": null,
// "depositEnable": true,
// "minConfirm": "0",
// "name": "QANplatform",
// "network": "BEP20(BSC)",
// "withdrawEnable": false,
// "withdrawFee": "42.000000000000000000",
// "withdrawIntegerMultiple": null,
// "withdrawMax": "24000000.000000000000000000",
// "withdrawMin": "20.000000000000000000",
// "sameAddress": false,
// "contract": "0xAAA7A10a8ee237ea61E8AC46C50A8Db8bCC1baaa"
// },
// {
// "coin": "QANX",
// "depositDesc": null,
// "depositEnable": true,
// "minConfirm": "0",
// "name": "QANplatform",
// "network": "ERC20",
// "withdrawEnable": true,
// "withdrawFee": "2732.000000000000000000",
// "withdrawIntegerMultiple": null,
// "withdrawMax": "24000000.000000000000000000",
// "withdrawMin": "240.000000000000000000",
// "sameAddress": false,
// "contract": "0xAAA7A10a8ee237ea61E8AC46C50A8Db8bCC1baaa"
// }
// ]
// }
//
var result interface{} = map[string]interface{} {}
for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
var currency interface{} = GetValue(response, i)
var id interface{} = this.SafeString(currency, "coin")
var code interface{} = this.SafeCurrencyCode(id)
var name interface{} = this.SafeString(currency, "name")
var currencyActive interface{} = false
var currencyFee interface{} = nil
var currencyWithdrawMin interface{} = nil
var currencyWithdrawMax interface{} = nil
var depositEnabled interface{} = false
var withdrawEnabled interface{} = false
var networks interface{} = map[string]interface{} {}
var chains interface{} = this.SafeValue(currency, "networkList", []interface{}{})
for j := 0; IsLessThan(j, GetArrayLength(chains)); j++ {
var chain interface{} = GetValue(chains, j)
var networkId interface{} = this.SafeString2(chain, "netWork", "network")
var network interface{} = this.NetworkIdToCode(networkId)
var isDepositEnabled interface{} = this.SafeBool(chain, "depositEnable", false)
var isWithdrawEnabled interface{} = this.SafeBool(chain, "withdrawEnable", false)
var active interface{} = (IsTrue(isDepositEnabled) && IsTrue(isWithdrawEnabled))
currencyActive = IsTrue(active) || IsTrue(currencyActive)
var withdrawMin interface{} = this.SafeString(chain, "withdrawMin")
var withdrawMax interface{} = this.SafeString(chain, "withdrawMax")
currencyWithdrawMin = Ternary(IsTrue((IsEqual(currencyWithdrawMin, nil))), withdrawMin, currencyWithdrawMin)
currencyWithdrawMax = Ternary(IsTrue((IsEqual(currencyWithdrawMax, nil))), withdrawMax, currencyWithdrawMax)
var fee interface{} = this.SafeNumber(chain, "withdrawFee")
currencyFee = Ternary(IsTrue((IsEqual(currencyFee, nil))), fee, currencyFee)
if IsTrue(Precise.StringGt(currencyWithdrawMin, withdrawMin)) {
currencyWithdrawMin = withdrawMin
}
if IsTrue(Precise.StringLt(currencyWithdrawMax, withdrawMax)) {
currencyWithdrawMax = withdrawMax
}
if IsTrue(isDepositEnabled) {
depositEnabled = true
}
if IsTrue(isWithdrawEnabled) {
withdrawEnabled = true
}
AddElementToObject(networks, network, map[string]interface{} {
"info": chain,
"id": networkId,
"network": network,
"active": active,
"deposit": isDepositEnabled,
"withdraw": isWithdrawEnabled,
"fee": fee,
"precision": nil,
"limits": map[string]interface{} {
"withdraw": map[string]interface{} {
"min": withdrawMin,
"max": withdrawMax,
},
},
})
}
var networkKeys interface{} = ObjectKeys(networks)
var networkKeysLength interface{} = GetArrayLength(networkKeys)
if IsTrue(IsTrue((IsEqual(networkKeysLength, 1))) || IsTrue((InOp(networks, "NONE")))) {
var defaultNetwork interface{} = this.SafeValue2(networks, "NONE", Subtract(networkKeysLength, 1))
if IsTrue(!IsEqual(defaultNetwork, nil)) {
currencyFee = GetValue(defaultNetwork, "fee")
}
}
AddElementToObject(result, code, map[string]interface{} {
"info": currency,
"id": id,
"code": code,
"name": name,
"active": currencyActive,
"deposit": depositEnabled,
"withdraw": withdrawEnabled,
"fee": currencyFee,
"precision": nil,
"limits": map[string]interface{} {
"amount": map[string]interface{} {
"min": nil,
"max": nil,
},
"withdraw": map[string]interface{} {
"min": currencyWithdrawMin,
"max": currencyWithdrawMax,
},
},
"networks": networks,
})
}
ch <- result
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchMarkets
* @description retrieves data on all markets for mexc
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#exchange-information
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-contract-information
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} an array of objects representing market data
*/
func (this *mexc) 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
if IsTrue(GetValue(this.Options, "adjustForTimeDifference")) {
retRes118912 := (<-this.LoadTimeDifference())
PanicOnError(retRes118912)
}
var spotMarketPromise interface{} = this.FetchSpotMarkets(params)
var swapMarketPromise interface{} = this.FetchSwapMarkets(params)
spotMarketswapMarketVariable := (<-promiseAll([]interface{}{spotMarketPromise, swapMarketPromise}));
spotMarket := GetValue(spotMarketswapMarketVariable,0);
swapMarket := GetValue(spotMarketswapMarketVariable,1)
ch <- this.ArrayConcat(spotMarket, swapMarket)
return nil
}()
return ch
}
/**
* @ignore
* @method
* @name mexc#fetchMarkets
* @description retrieves data on all spot markets for mexc
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#exchange-information
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} an array of objects representing market data
*/
func (this *mexc) FetchSpotMarkets(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.SpotPublicGetExchangeInfo(params))
PanicOnError(response)
//
// {
// "timezone": "CST",
// "serverTime": 1647521860402,
// "rateLimits": [],
// "exchangeFilters": [],
// "symbols": [
// {
// "symbol": "OGNUSDT",
// "status": "1",
// "baseAsset": "OGN",
// "baseAssetPrecision": "2",
// "quoteAsset": "USDT",
// "quoteAssetPrecision": "4",
// "orderTypes": [
// "LIMIT",
// "LIMIT_MAKER"
// ],
// "baseCommissionPrecision": "2",
// "quoteCommissionPrecision": "4",
// "quoteOrderQtyMarketAllowed": false,
// "isSpotTradingAllowed": true,
// "isMarginTradingAllowed": true,
// "permissions": [
// "SPOT",
// "MARGIN"
// ],
// "filters": [],
// "baseSizePrecision": "0.01", // this turned out to be a minimum base amount for order
// "maxQuoteAmount": "5000000",
// "makerCommission": "0.002",
// "takerCommission": "0.002"
// "quoteAmountPrecision": "5", // this turned out to be a minimum cost amount for order
// "quotePrecision": "4", // deprecated in favor of 'quoteAssetPrecision' ( https://dev.binance.vision/t/what-is-the-difference-between-quoteprecision-and-quoteassetprecision/4333 )
// // note, "icebergAllowed" & "ocoAllowed" fields were recently removed
// },
// ]
// }
//
// Notes:
// - 'quoteAssetPrecision' & 'baseAssetPrecision' are not currency's real blockchain precision (to view currency's actual individual precision, refer to fetchCurrencies() method).
//
var data interface{} = this.SafeValue(response, "symbols", []interface{}{})
var result interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var market interface{} = GetValue(data, i)
var id interface{} = this.SafeString(market, "symbol")
var baseId interface{} = this.SafeString(market, "baseAsset")
var quoteId interface{} = this.SafeString(market, "quoteAsset")
var base interface{} = this.SafeCurrencyCode(baseId)
var quote interface{} = this.SafeCurrencyCode(quoteId)
var status interface{} = this.SafeString(market, "status")
var isSpotTradingAllowed interface{} = this.SafeValue(market, "isSpotTradingAllowed")
var active interface{} = false
if IsTrue(IsTrue((IsEqual(status, "1"))) && IsTrue((isSpotTradingAllowed))) {
active = true
}
var isMarginTradingAllowed interface{} = this.SafeValue(market, "isMarginTradingAllowed")
var makerCommission interface{} = this.SafeNumber(market, "makerCommission")
var takerCommission interface{} = this.SafeNumber(market, "takerCommission")
var maxQuoteAmount interface{} = this.SafeNumber(market, "maxQuoteAmount")
AppendToArray(&result,map[string]interface{} {
"id": id,
"symbol": Add(Add(base, "/"), quote),
"base": base,
"quote": quote,
"settle": nil,
"baseId": baseId,
"quoteId": quoteId,
"settleId": nil,
"type": "spot",
"spot": true,
"margin": isMarginTradingAllowed,
"swap": false,
"future": false,
"option": false,
"active": active,
"contract": false,
"linear": nil,
"inverse": nil,
"taker": takerCommission,
"maker": makerCommission,
"contractSize": nil,
"expiry": nil,
"expiryDatetime": nil,
"strike": nil,
"optionType": nil,
"precision": map[string]interface{} {
"amount": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "baseAssetPrecision"))),
"price": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "quoteAssetPrecision"))),
},
"limits": map[string]interface{} {
"leverage": map[string]interface{} {
"min": nil,
"max": nil,
},
"amount": map[string]interface{} {
"min": this.SafeNumber(market, "baseSizePrecision"),
"max": nil,
},
"price": map[string]interface{} {
"min": nil,
"max": nil,
},
"cost": map[string]interface{} {
"min": this.SafeNumber(market, "quoteAmountPrecision"),
"max": maxQuoteAmount,
},
},
"created": nil,
"info": market,
})
}
ch <- result
return nil
}()
return ch
}
/**
* @ignore
* @method
* @name mexc#fetchMarkets
* @description retrieves data on all swap markets for mexc
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-contract-information
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} an array of objects representing market data
*/
func (this *mexc) FetchSwapMarkets(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 currentRl interface{} = this.RateLimit
this.SetProperty(this, "rateLimit", 10) // see comment: https://github.com/ccxt/ccxt/pull/23698
response:= (<-this.ContractPublicGetDetail(params))
PanicOnError(response)
this.SetProperty(this, "rateLimit", currentRl)
//
// {
// "success":true,
// "code":0,
// "data":[
// {
// "symbol":"BTC_USDT",
// "displayName":"BTC_USDT永续",
// "displayNameEn":"BTC_USDT SWAP",
// "positionOpenType":3,
// "baseCoin":"BTC",
// "quoteCoin":"USDT",
// "settleCoin":"USDT",
// "contractSize":0.0001,
// "minLeverage":1,
// "maxLeverage":125,
// "priceScale":2, // seems useless atm, as it's just how UI shows the price, i.e. 29583.50 for BTC/USDT:USDT, while price ticksize is 0.5
// "volScale":0, // probably: contract amount precision
// "amountScale":4, // probably: quote currency precision
// "priceUnit":0.5, // price tick size
// "volUnit":1, // probably: contract tick size
// "minVol":1,
// "maxVol":1000000,
// "bidLimitPriceRate":0.1,
// "askLimitPriceRate":0.1,
// "takerFeeRate":0.0006,
// "makerFeeRate":0.0002,
// "maintenanceMarginRate":0.004,
// "initialMarginRate":0.008,
// "riskBaseVol":10000,
// "riskIncrVol":200000,
// "riskIncrMmr":0.004,
// "riskIncrImr":0.004,
// "riskLevelLimit":5,
// "priceCoefficientVariation":0.1,
// "indexOrigin":["BINANCE","GATEIO","HUOBI","MXC"],
// "state":0, // 0 enabled, 1 delivery, 2 completed, 3 offline, 4 pause
// "isNew":false,
// "isHot":true,
// "isHidden":false
// },
// ]
// }
//
var data interface{} = this.SafeValue(response, "data", []interface{}{})
var result interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var market interface{} = GetValue(data, i)
var id interface{} = this.SafeString(market, "symbol")
var baseId interface{} = this.SafeString(market, "baseCoin")
var quoteId interface{} = this.SafeString(market, "quoteCoin")
var settleId interface{} = this.SafeString(market, "settleCoin")
var base interface{} = this.SafeCurrencyCode(baseId)
var quote interface{} = this.SafeCurrencyCode(quoteId)
var settle interface{} = this.SafeCurrencyCode(settleId)
var state interface{} = this.SafeString(market, "state")
var isLinear interface{} = IsEqual(quote, settle)
AppendToArray(&result,map[string]interface{} {
"id": id,
"symbol": Add(Add(Add(Add(base, "/"), quote), ":"), settle),
"base": base,
"quote": quote,
"settle": settle,
"baseId": baseId,
"quoteId": quoteId,
"settleId": settleId,
"type": "swap",
"spot": false,
"margin": false,
"swap": true,
"future": false,
"option": false,
"active": (IsEqual(state, "0")),
"contract": true,
"linear": isLinear,
"inverse": !IsTrue(isLinear),
"taker": this.SafeNumber(market, "takerFeeRate"),
"maker": this.SafeNumber(market, "makerFeeRate"),
"contractSize": this.SafeNumber(market, "contractSize"),
"expiry": nil,
"expiryDatetime": nil,
"strike": nil,
"optionType": nil,
"precision": map[string]interface{} {
"amount": this.SafeNumber(market, "volUnit"),
"price": this.SafeNumber(market, "priceUnit"),
},
"limits": map[string]interface{} {
"leverage": map[string]interface{} {
"min": this.SafeNumber(market, "minLeverage"),
"max": this.SafeNumber(market, "maxLeverage"),
},
"amount": map[string]interface{} {
"min": this.SafeNumber(market, "minVol"),
"max": this.SafeNumber(market, "maxVol"),
},
"price": map[string]interface{} {
"min": nil,
"max": nil,
},
"cost": map[string]interface{} {
"min": nil,
"max": nil,
},
},
"created": nil,
"info": market,
})
}
ch <- result
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchOrderBook
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#order-book
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-contract-s-depth-information
* @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
* @param {string} symbol unified symbol of the market to fetch the order book for
* @param {int} [limit] the maximum amount of order book entries to return
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
*/
func (this *mexc) 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
retRes14628 := (<-this.LoadMarkets())
PanicOnError(retRes14628)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var orderbook interface{} = nil
if IsTrue(GetValue(market, "spot")) {
response:= (<-this.SpotPublicGetDepth(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "lastUpdateId": "744267132",
// "bids": [
// ["40838.50","0.387864"],
// ["40837.95","0.008400"],
// ],
// "asks": [
// ["40838.61","6.544908"],
// ["40838.88","0.498000"],
// ]
// }
//
var spotTimestamp interface{} = this.SafeInteger(response, "timestamp")
orderbook = this.ParseOrderBook(response, symbol, spotTimestamp)
AddElementToObject(orderbook, "nonce", this.SafeInteger(response, "lastUpdateId"))
} else if IsTrue(GetValue(market, "swap")) {
response:= (<-this.ContractPublicGetDepthSymbol(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success":true,
// "code":0,
// "data":{
// "asks":[
// [3445.72,48379,1],
// [3445.75,34994,1],
// ],
// "bids":[
// [3445.55,44081,1],
// [3445.51,24857,1],
// ],
// "version":2827730444,
// "timestamp":1634117846232
// }
// }
//
var data interface{} = this.SafeValue(response, "data")
var timestamp interface{} = this.SafeInteger(data, "timestamp")
orderbook = this.ParseOrderBook(data, symbol, timestamp)
AddElementToObject(orderbook, "nonce", this.SafeInteger(data, "version"))
}
ch <- orderbook
return nil
}()
return ch
}
func (this *mexc) ParseBidAsk(bidask interface{}, optionalArgs ...interface{}) interface{} {
priceKey := GetArg(optionalArgs, 0, 0)
_ = priceKey
amountKey := GetArg(optionalArgs, 1, 1)
_ = amountKey
countOrIdKey := GetArg(optionalArgs, 2, 2)
_ = countOrIdKey
var countKey interface{} = 2
var price interface{} = this.SafeNumber(bidask, priceKey)
var amount interface{} = this.SafeNumber(bidask, amountKey)
var count interface{} = this.SafeNumber(bidask, countKey)
if IsTrue(!IsEqual(count, nil)) {
return []interface{}{price, amount, count}
}
return []interface{}{price, amount}
}
/**
* @method
* @name mexc#fetchTrades
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#recent-trades-list
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#compressed-aggregate-trades-list
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-contract-transaction-data
* @description get the list of most recent trades for a particular symbol
* @param {string} symbol unified symbol of the market to fetch trades for
* @param {int} [since] timestamp in ms of the earliest trade to fetch
* @param {int} [limit] the maximum amount of trades to fetch
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] *spot only* *since must be defined* the latest time in ms to fetch entries for
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
*/
func (this *mexc) 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
retRes15438 := (<-this.LoadMarkets())
PanicOnError(retRes15438)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var trades interface{} = nil
if IsTrue(GetValue(market, "spot")) {
var until interface{} = this.SafeIntegerN(params, []interface{}{"endTime", "until"})
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since)
if IsTrue(IsEqual(until, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchTrades() requires an until parameter when since is provided")))
}
}
if IsTrue(!IsEqual(until, nil)) {
if IsTrue(IsEqual(since, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchTrades() requires a since parameter when until is provided")))
}
AddElementToObject(request, "endTime", until)
}
var method interface{} = this.SafeString(this.Options, "fetchTradesMethod", "spotPublicGetAggTrades")
method = this.SafeString(params, "method", method) // AggTrades, HistoricalTrades, Trades
params = this.Omit(params, []interface{}{"method"})
if IsTrue(IsEqual(method, "spotPublicGetAggTrades")) {
trades = (<-this.SpotPublicGetAggTrades(this.Extend(request, params)))
PanicOnError(trades)
} else if IsTrue(IsEqual(method, "spotPublicGetHistoricalTrades")) {
trades = (<-this.SpotPublicGetHistoricalTrades(this.Extend(request, params)))
PanicOnError(trades)
} else if IsTrue(IsEqual(method, "spotPublicGetTrades")) {
trades = (<-this.SpotPublicGetTrades(this.Extend(request, params)))
PanicOnError(trades)
} else {
panic(NotSupported(Add(this.Id, " fetchTrades() not support this method")))
}
} else if IsTrue(GetValue(market, "swap")) {
response:= (<-this.ContractPublicGetDealsSymbol(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0,
// "data": [
// {
// "p": 31199,
// "v": 18,
// "T": 1,
// "O": 3,
// "M": 2,
// "t": 1609831235985
// },
// ]
// }
//
trades = this.SafeValue(response, "data")
}
ch <- this.ParseTrades(trades, market, since, limit)
return nil
}()
return ch
}
func (this *mexc) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
var id interface{} = nil
var timestamp interface{} = nil
var orderId interface{} = nil
var symbol interface{} = nil
var fee interface{} = nil
var typeVar interface{} = nil
var side interface{} = nil
var takerOrMaker interface{} = nil
var priceString interface{} = nil
var amountString interface{} = nil
var costString interface{} = nil
// if swap
if IsTrue(InOp(trade, "v")) {
//
// swap: fetchTrades
//
// {
// "p": 31199,
// "v": 18,
// "T": 1,
// "O": 3,
// "M": 2,
// "t": 1609831235985
// }
//
timestamp = this.SafeInteger(trade, "t")
market = this.SafeMarket(nil, market)
symbol = GetValue(market, "symbol")
priceString = this.SafeString(trade, "p")
amountString = this.SafeString(trade, "v")
side = this.ParseOrderSide(this.SafeString(trade, "T"))
takerOrMaker = "taker"
} else {
//
// spot: fetchTrades (for aggTrades)
//
// {
// "a": null,
// "f": null,
// "l": null,
// "p": "40679",
// "q": "0.001309",
// "T": 1647551328000,
// "m": true,
// "M": true
// }
//
// spot: fetchMyTrades, fetchOrderTrades
//
// {
// "symbol": "BTCUSDT",
// "id": "133948532984922113",
// "orderId": "133948532531949568",
// "orderListId": "-1",
// "price": "41995.51",
// "qty": "0.0002",
// "quoteQty": "8.399102",
// "commission": "0.016798204",
// "commissionAsset": "USDT",
// "time": "1647718055000",
// "isBuyer": true,
// "isMaker": false,
// "isBestMatch": true
// }
//
// swap: fetchMyTrades, fetchOrderTrades
//
// {
// "id": "299444585",
// "symbol": "STEPN_USDT",
// "side": "1",
// "vol": "1",
// "price": "2.45455",
// "feeCurrency": "USDT",
// "fee": "0.00147273",
// "timestamp": "1648924557000",
// "profit": "0",
// "category": "1",
// "orderId": "265307163526610432",
// "positionMode": "1",
// "taker": true
// }
//
var marketId interface{} = this.SafeString(trade, "symbol")
market = this.SafeMarket(marketId, market)
symbol = GetValue(market, "symbol")
id = this.SafeString2(trade, "id", "a")
priceString = this.SafeString2(trade, "price", "p")
orderId = this.SafeString(trade, "orderId")
// if swap
if IsTrue(InOp(trade, "positionMode")) {
timestamp = this.SafeInteger(trade, "timestamp")
amountString = this.SafeString(trade, "vol")
side = this.ParseOrderSide(this.SafeString(trade, "side"))
fee = map[string]interface{} {
"cost": this.SafeString(trade, "fee"),
"currency": this.SafeCurrencyCode(this.SafeString(trade, "feeCurrency")),
}
takerOrMaker = Ternary(IsTrue(this.SafeValue(trade, "taker")), "taker", "maker")
} else {
timestamp = this.SafeInteger2(trade, "time", "T")
amountString = this.SafeString2(trade, "qty", "q")
costString = this.SafeString(trade, "quoteQty")
var isBuyer interface{} = this.SafeValue(trade, "isBuyer")
var isMaker interface{} = this.SafeValue(trade, "isMaker")
var buyerMaker interface{} = this.SafeValue2(trade, "isBuyerMaker", "m")
if IsTrue(!IsEqual(isMaker, nil)) {
takerOrMaker = Ternary(IsTrue(isMaker), "maker", "taker")
}
if IsTrue(!IsEqual(isBuyer, nil)) {
side = Ternary(IsTrue(isBuyer), "buy", "sell")
}
if IsTrue(!IsEqual(buyerMaker, nil)) {
side = Ternary(IsTrue(buyerMaker), "sell", "buy")
takerOrMaker = "taker"
}
var feeAsset interface{} = this.SafeString(trade, "commissionAsset")
if IsTrue(!IsEqual(feeAsset, nil)) {
fee = map[string]interface{} {
"cost": this.SafeString(trade, "commission"),
"currency": this.SafeCurrencyCode(feeAsset),
}
}
}
}
if IsTrue(IsEqual(id, nil)) {
id = this.SyntheticTradeId(market, timestamp, side, amountString, priceString, typeVar, takerOrMaker)
}
return this.SafeTrade(map[string]interface{} {
"id": id,
"order": orderId,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"symbol": symbol,
"type": typeVar,
"side": side,
"takerOrMaker": takerOrMaker,
"price": priceString,
"amount": amountString,
"cost": costString,
"fee": fee,
"info": trade,
}, market)
}
func (this *mexc) SyntheticTradeId(optionalArgs ...interface{}) interface{} {
// TODO: can be unified method? this approach is being used by multiple exchanges (mexc, woo-coinsbit, dydx, ...)
market := GetArg(optionalArgs, 0, nil)
_ = market
timestamp := GetArg(optionalArgs, 1, nil)
_ = timestamp
side := GetArg(optionalArgs, 2, nil)
_ = side
amount := GetArg(optionalArgs, 3, nil)
_ = amount
price := GetArg(optionalArgs, 4, nil)
_ = price
orderType := GetArg(optionalArgs, 5, nil)
_ = orderType
takerOrMaker := GetArg(optionalArgs, 6, nil)
_ = takerOrMaker
var id interface{} = ""
if IsTrue(!IsEqual(timestamp, nil)) {
id = Add(Add(this.NumberToString(timestamp), "-"), this.SafeString(market, "id", "_"))
if IsTrue(!IsEqual(side, nil)) {
id = Add(id, Add("-", side))
}
if IsTrue(!IsEqual(amount, nil)) {
id = Add(id, Add("-", this.NumberToString(amount)))
}
if IsTrue(!IsEqual(price, nil)) {
id = Add(id, Add("-", this.NumberToString(price)))
}
if IsTrue(!IsEqual(takerOrMaker, nil)) {
id = Add(id, Add("-", takerOrMaker))
}
if IsTrue(!IsEqual(orderType, nil)) {
id = Add(id, Add("-", orderType))
}
}
return id
}
/**
* @method
* @name mexc#fetchOHLCV
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#kline-candlestick-data
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#k-line-data
* @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
* @param {string} symbol unified symbol of the market to fetch OHLCV data for
* @param {string} timeframe the length of time each candle represents
* @param {int} [since] timestamp in ms of the earliest candle to fetch
* @param {int} [limit] the maximum amount of candles to fetch
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] timestamp in ms of the latest candle to fetch
* @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
* @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
*/
func (this *mexc) 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
retRes18178 := (<-this.LoadMarkets())
PanicOnError(retRes18178)
var market interface{} = this.Market(symbol)
var maxLimit interface{} = Ternary(IsTrue((GetValue(market, "spot"))), 1000, 2000)
var paginate interface{} = false
paginateparamsVariable := this.HandleOptionAndParams(params, "fetchOHLCV", "paginate", false);
paginate = GetValue(paginateparamsVariable,0);
params = GetValue(paginateparamsVariable,1)
if IsTrue(paginate) {
retRes182319 := (<-this.FetchPaginatedCallDeterministic("fetchOHLCV", symbol, since, limit, timeframe, params, maxLimit))
PanicOnError(retRes182319)
ch <- retRes182319
return nil
}
var options interface{} = this.SafeValue(this.Options, "timeframes", map[string]interface{} {})
var timeframes interface{} = this.SafeValue(options, GetValue(market, "type"), map[string]interface{} {})
var timeframeValue interface{} = this.SafeString(timeframes, timeframe)
var duration interface{} = Multiply(this.ParseTimeframe(timeframe), 1000)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
"interval": timeframeValue,
}
var candles interface{} = nil
if IsTrue(GetValue(market, "spot")) {
var until interface{} = this.SafeIntegerN(params, []interface{}{"until", "endTime"})
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since)
if IsTrue(IsEqual(until, nil)) {
// we have to calculate it assuming we can get at most 2000 entries per request
var end interface{} = this.Sum(since, Multiply(maxLimit, duration))
var now interface{} = this.Milliseconds()
AddElementToObject(request, "endTime", mathMin(end, now))
}
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
if IsTrue(!IsEqual(until, nil)) {
params = this.Omit(params, []interface{}{"until"})
AddElementToObject(request, "endTime", until)
}
response:= (<-this.SpotPublicGetKlines(this.Extend(request, params)))
PanicOnError(response)
//
// [
// [
// 1640804880000,
// "47482.36",
// "47482.36",
// "47416.57",
// "47436.1",
// "3.550717",
// 1640804940000,
// "168387.3"
// ],
// ]
//
candles = response
} else if IsTrue(GetValue(market, "swap")) {
var until interface{} = this.SafeIntegerProductN(params, []interface{}{"until", "endTime"}, 0.001)
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "start", this.ParseToInt(Divide(since, 1000)))
}
if IsTrue(!IsEqual(until, nil)) {
params = this.Omit(params, []interface{}{"until"})
AddElementToObject(request, "end", until)
}
var priceType interface{} = this.SafeString(params, "price", "default")
params = this.Omit(params, "price")
var response interface{} = nil
if IsTrue(IsEqual(priceType, "default")) {
response = (<-this.ContractPublicGetKlineSymbol(this.Extend(request, params)))
PanicOnError(response)
} else if IsTrue(IsEqual(priceType, "index")) {
response = (<-this.ContractPublicGetKlineIndexPriceSymbol(this.Extend(request, params)))
PanicOnError(response)
} else if IsTrue(IsEqual(priceType, "mark")) {
response = (<-this.ContractPublicGetKlineFairPriceSymbol(this.Extend(request, params)))
PanicOnError(response)
} else {
panic(NotSupported(Add(this.Id, " fetchOHLCV() not support this price type, [default, index, mark]")))
}
//
// {
// "success":true,
// "code":0,
// "data":{
// "time":[1634052300,1634052360,1634052420],
// "open":[3492.2,3491.3,3495.65],
// "close":[3491.3,3495.65,3495.2],
// "high":[3495.85,3496.55,3499.4],
// "low":[3491.15,3490.9,3494.2],
// "vol":[1740.0,351.0,314.0],
// "amount":[60793.623,12260.4885,10983.1375],
// }
// }
//
var data interface{} = this.SafeValue(response, "data")
candles = this.ConvertTradingViewToOHLCV(data, "time", "open", "high", "low", "close", "vol")
}
ch <- this.ParseOHLCVs(candles, market, timeframe, since, limit)
return nil
}()
return ch
}
func (this *mexc) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
return []interface{}{this.SafeInteger(ohlcv, 0), this.SafeNumber(ohlcv, 1), this.SafeNumber(ohlcv, 2), this.SafeNumber(ohlcv, 3), this.SafeNumber(ohlcv, 4), this.SafeNumber(ohlcv, 5)}
}
/**
* @method
* @name mexc#fetchTickers
* @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#24hr-ticker-price-change-statistics
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-contract-trend-data
* @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 *mexc) 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
retRes19328 := (<-this.LoadMarkets())
PanicOnError(retRes19328)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
var isSingularMarket interface{} = false
if IsTrue(!IsEqual(symbols, nil)) {
var length interface{} = GetArrayLength(symbols)
isSingularMarket = IsEqual(length, 1)
var firstSymbol interface{} = this.SafeString(symbols, 0)
market = this.Market(firstSymbol)
}
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchTickers", market, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
var tickers interface{} = nil
if IsTrue(isSingularMarket) {
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
if IsTrue(IsEqual(marketType, "spot")) {
tickers = (<-this.SpotPublicGetTicker24hr(this.Extend(request, query)))
PanicOnError(tickers)
} else if IsTrue(IsEqual(marketType, "swap")) {
response:= (<-this.ContractPublicGetTicker(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "success":true,
// "code":0,
// "data":[
// {
// "symbol":"ETH_USDT",
// "lastPrice":3581.3,
// "bid1":3581.25,
// "ask1":3581.5,
// "volume24":4045530,
// "amount24":141331823.5755,
// "holdVol":5832946,
// "lower24Price":3413.4,
// "high24Price":3588.7,
// "riseFallRate":0.0275,
// "riseFallValue":95.95,
// "indexPrice":3580.7852,
// "fairPrice":3581.08,
// "fundingRate":0.000063,
// "maxBidPrice":3938.85,
// "minAskPrice":3222.7,
// "timestamp":1634162885016
// },
// ]
// }
//
tickers = this.SafeValue(response, "data", []interface{}{})
}
// when it's single symbol request, the returned structure is different (singular object) for both spot & swap, thus we need to wrap inside array
if IsTrue(isSingularMarket) {
tickers = []interface{}{tickers}
}
ch <- this.ParseTickers(tickers, symbols)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchTicker
* @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#24hr-ticker-price-change-statistics
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-contract-trend-data
* @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 *mexc) 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
retRes20228 := (<-this.LoadMarkets())
PanicOnError(retRes20228)
var market interface{} = this.Market(symbol)
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchTicker", market, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
var ticker interface{} = nil
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
if IsTrue(IsEqual(marketType, "spot")) {
ticker = (<-this.SpotPublicGetTicker24hr(this.Extend(request, query)))
PanicOnError(ticker)
} else if IsTrue(IsEqual(marketType, "swap")) {
response:= (<-this.ContractPublicGetTicker(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "success":true,
// "code":0,
// "data":{
// "symbol":"ETH_USDT",
// "lastPrice":3581.3,
// "bid1":3581.25,
// "ask1":3581.5,
// "volume24":4045530,
// "amount24":141331823.5755,
// "holdVol":5832946,
// "lower24Price":3413.4,
// "high24Price":3588.7,
// "riseFallRate":0.0275,
// "riseFallValue":95.95,
// "indexPrice":3580.7852,
// "fairPrice":3581.08,
// "fundingRate":0.000063,
// "maxBidPrice":3938.85,
// "minAskPrice":3222.7,
// "timestamp":1634162885016
// }
// }
//
ticker = this.SafeValue(response, "data", map[string]interface{} {})
}
// when it's single symbol request, the returned structure is different (singular object) for both spot & swap, thus we need to wrap inside array
ch <- this.ParseTicker(ticker, market)
return nil
}()
return ch
}
func (this *mexc) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(ticker, "symbol")
market = this.SafeMarket(marketId, market)
var timestamp interface{} = nil
var bid interface{} = nil
var ask interface{} = nil
var bidVolume interface{} = nil
var askVolume interface{} = nil
var baseVolume interface{} = nil
var quoteVolume interface{} = nil
var open interface{} = nil
var high interface{} = nil
var low interface{} = nil
var changePcnt interface{} = nil
var changeValue interface{} = nil
var prevClose interface{} = nil
var isSwap interface{} = this.SafeValue(market, "swap")
// if swap
if IsTrue(IsTrue(isSwap) || IsTrue((InOp(ticker, "timestamp")))) {
//
// {
// "symbol": "ETH_USDT",
// "lastPrice": 3581.3,
// "bid1": 3581.25,
// "ask1": 3581.5,
// "volume24": 4045530,
// "amount24": 141331823.5755,
// "holdVol": 5832946,
// "lower24Price": 3413.4,
// "high24Price": 3588.7,
// "riseFallRate": 0.0275,
// "riseFallValue": 95.95,
// "indexPrice": 3580.7852,
// "fairPrice": 3581.08,
// "fundingRate": 0.000063,
// "maxBidPrice": 3938.85,
// "minAskPrice": 3222.7,
// "timestamp": 1634162885016
// }
//
timestamp = this.SafeInteger(ticker, "timestamp")
bid = this.SafeString(ticker, "bid1")
ask = this.SafeString(ticker, "ask1")
baseVolume = this.SafeString(ticker, "volume24")
quoteVolume = this.SafeString(ticker, "amount24")
high = this.SafeString(ticker, "high24Price")
low = this.SafeString(ticker, "lower24Price")
changeValue = this.SafeString(ticker, "riseFallValue")
changePcnt = this.SafeString(ticker, "riseFallRate")
changePcnt = Precise.StringMul(changePcnt, "100")
} else {
//
// {
// "symbol": "BTCUSDT",
// "priceChange": "184.34",
// "priceChangePercent": "0.00400048",
// "prevClosePrice": "46079.37",
// "lastPrice": "46263.71",
// "lastQty": "",
// "bidPrice": "46260.38",
// "bidQty": "",
// "askPrice": "46260.41",
// "askQty": "",
// "openPrice": "46079.37",
// "highPrice": "47550.01",
// "lowPrice": "45555.5",
// "volume": "1732.461487",
// "quoteVolume": null,
// "openTime": 1641349500000,
// "closeTime": 1641349582808,
// "count": null
// }
//
timestamp = this.SafeInteger(ticker, "closeTime")
bid = this.SafeString(ticker, "bidPrice")
ask = this.SafeString(ticker, "askPrice")
bidVolume = this.SafeString(ticker, "bidQty")
askVolume = this.SafeString(ticker, "askQty")
if IsTrue(Precise.StringEq(bidVolume, "0")) {
bidVolume = nil
}
if IsTrue(Precise.StringEq(askVolume, "0")) {
askVolume = nil
}
baseVolume = this.SafeString(ticker, "volume")
quoteVolume = this.SafeString(ticker, "quoteVolume")
open = this.SafeString(ticker, "openPrice")
high = this.SafeString(ticker, "highPrice")
low = this.SafeString(ticker, "lowPrice")
prevClose = this.SafeString(ticker, "prevClosePrice")
changeValue = this.SafeString(ticker, "priceChange")
changePcnt = this.SafeString(ticker, "priceChangePercent")
changePcnt = Precise.StringMul(changePcnt, "100")
}
return this.SafeTicker(map[string]interface{} {
"symbol": GetValue(market, "symbol"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"open": open,
"high": high,
"low": low,
"close": this.SafeString(ticker, "lastPrice"),
"bid": bid,
"bidVolume": bidVolume,
"ask": ask,
"askVolume": askVolume,
"vwap": nil,
"previousClose": prevClose,
"change": changeValue,
"percentage": changePcnt,
"average": nil,
"baseVolume": baseVolume,
"quoteVolume": quoteVolume,
"info": ticker,
}, market)
}
/**
* @method
* @name mexc#fetchBidsAsks
* @description fetches the bid and ask price and volume for multiple markets
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#symbol-order-book-ticker
* @param {string[]|undefined} symbols unified symbols of the markets to fetch the bids and asks for, all markets 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 *mexc) FetchBidsAsks(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
retRes22138 := (<-this.LoadMarkets())
PanicOnError(retRes22138)
var market interface{} = nil
var isSingularMarket interface{} = false
if IsTrue(!IsEqual(symbols, nil)) {
var length interface{} = GetArrayLength(symbols)
isSingularMarket = IsEqual(length, 1)
market = this.Market(GetValue(symbols, 0))
}
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchBidsAsks", market, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
var tickers interface{} = nil
if IsTrue(IsEqual(marketType, "spot")) {
tickers = (<-this.SpotPublicGetTickerBookTicker(query))
PanicOnError(tickers)
} else if IsTrue(IsEqual(marketType, "swap")) {
panic(NotSupported(Add(Add(Add(this.Id, " fetchBidsAsks() is not available for "), marketType), " markets")))
}
// when it's single symbol request, the returned structure is different (singular object) for both spot & swap, thus we need to wrap inside array
if IsTrue(isSingularMarket) {
tickers = []interface{}{tickers}
}
ch <- this.ParseTickers(tickers, symbols)
return nil
}()
return ch
}
/**
* @method
* @name mexc#createMarketBuyOrderWithCost
* @description create a market buy order by providing the symbol and cost
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#new-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 *mexc) 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
retRes22578 := (<-this.LoadMarkets())
PanicOnError(retRes22578)
var market interface{} = this.Market(symbol)
if !IsTrue(GetValue(market, "spot")) {
panic(NotSupported(Add(this.Id, " createMarketBuyOrderWithCost() supports spot orders only")))
}
AddElementToObject(params, "cost", cost)
retRes226315 := (<-this.CreateOrder(symbol, "market", "buy", 0, nil, params))
PanicOnError(retRes226315)
ch <- retRes226315
return nil
}()
return ch
}
/**
* @method
* @name mexc#createMarketSellOrderWithCost
* @description create a market sell order by providing the symbol and cost
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#new-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 *mexc) CreateMarketSellOrderWithCost(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
retRes22778 := (<-this.LoadMarkets())
PanicOnError(retRes22778)
var market interface{} = this.Market(symbol)
if !IsTrue(GetValue(market, "spot")) {
panic(NotSupported(Add(this.Id, " createMarketBuyOrderWithCost() supports spot orders only")))
}
AddElementToObject(params, "cost", cost)
retRes228315 := (<-this.CreateOrder(symbol, "market", "sell", 0, nil, params))
PanicOnError(retRes228315)
ch <- retRes228315
return nil
}()
return ch
}
/**
* @method
* @name mexc#createOrder
* @description create a trade order
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#new-order
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#order-under-maintenance
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#trigger-order-under-maintenance
* @param {string} symbol unified symbol of the market to create an order in
* @param {string} type 'market' or 'limit'
* @param {string} side 'buy' or 'sell'
* @param {float} amount how much of currency you want to trade in units of base currency
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.marginMode] only 'isolated' is supported for spot-margin trading
* @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
* @param {bool} [params.postOnly] if true, the order will only be posted if it will be a maker order
* @param {bool} [params.reduceOnly] *contract only* indicates if this order is to reduce the size of a position
* @param {bool} [params.hedged] *swap only* true for hedged mode, false for one way mode, default is false
* @param {string} [params.timeInForce] 'IOC' or 'FOK', default is 'GTC'
* EXCHANGE SPECIFIC PARAMETERS
* @param {int} [params.leverage] *contract only* leverage is necessary on isolated margin
* @param {long} [params.positionId] *contract only* it is recommended to fill in this parameter when closing a position
* @param {string} [params.externalOid] *contract only* external order ID
* @param {int} [params.positionMode] *contract only* 1:hedge, 2:one-way, default: the user's current config
* @param {boolean} [params.test] *spot only* whether to use the test endpoint or not, default is false
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) 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
retRes23148 := (<-this.LoadMarkets())
PanicOnError(retRes23148)
var market interface{} = this.Market(symbol)
marginModequeryVariable := this.HandleMarginModeAndParams("createOrder", params);
marginMode := GetValue(marginModequeryVariable,0);
query := GetValue(marginModequeryVariable,1)
if IsTrue(GetValue(market, "spot")) {
retRes231819 := (<-this.CreateSpotOrder(market, typeVar, side, amount, price, marginMode, query))
PanicOnError(retRes231819)
ch <- retRes231819
return nil
} else {
retRes232019 := (<-this.CreateSwapOrder(market, typeVar, side, amount, price, marginMode, query))
PanicOnError(retRes232019)
ch <- retRes232019
return nil
}
return nil
}()
return ch
}
func (this *mexc) CreateSpotOrderRequest(market interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) interface{} {
price := GetArg(optionalArgs, 0, nil)
_ = price
marginMode := GetArg(optionalArgs, 1, nil)
_ = marginMode
params := GetArg(optionalArgs, 2, map[string]interface{} {})
_ = params
var symbol interface{} = GetValue(market, "symbol")
var orderSide interface{} = ToUpper(side)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
"side": orderSide,
"type": ToUpper(typeVar),
}
if IsTrue(IsEqual(typeVar, "market")) {
var cost interface{} = this.SafeNumber2(params, "cost", "quoteOrderQty")
params = this.Omit(params, "cost")
if IsTrue(!IsEqual(cost, nil)) {
amount = cost
AddElementToObject(request, "quoteOrderQty", this.CostToPrecision(symbol, amount))
} else {
if IsTrue(IsEqual(price, nil)) {
AddElementToObject(request, "quantity", this.AmountToPrecision(symbol, amount))
} else {
var amountString interface{} = this.NumberToString(amount)
var priceString interface{} = this.NumberToString(price)
var quoteAmount interface{} = Precise.StringMul(amountString, priceString)
amount = quoteAmount
AddElementToObject(request, "quoteOrderQty", this.CostToPrecision(symbol, amount))
}
}
} else {
AddElementToObject(request, "quantity", this.AmountToPrecision(symbol, amount))
}
if IsTrue(!IsEqual(price, nil)) {
AddElementToObject(request, "price", this.PriceToPrecision(symbol, price))
}
var clientOrderId interface{} = this.SafeString(params, "clientOrderId")
if IsTrue(!IsEqual(clientOrderId, nil)) {
AddElementToObject(request, "newClientOrderId", clientOrderId)
params = this.Omit(params, []interface{}{"type", "clientOrderId"})
}
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(!IsEqual(marginMode, "isolated")) {
panic(BadRequest(Add(Add(Add(this.Id, " createOrder() does not support marginMode "), marginMode), " for spot-margin trading")))
}
}
var postOnly interface{} = nil
postOnlyparamsVariable := this.HandlePostOnly(IsEqual(typeVar, "market"), IsEqual(typeVar, "LIMIT_MAKER"), params);
postOnly = GetValue(postOnlyparamsVariable,0);
params = GetValue(postOnlyparamsVariable,1)
if IsTrue(postOnly) {
AddElementToObject(request, "type", "LIMIT_MAKER")
}
var tif interface{} = this.SafeString(params, "timeInForce")
if IsTrue(!IsEqual(tif, nil)) {
params = this.Omit(params, "timeInForce")
if IsTrue(IsEqual(tif, "IOC")) {
AddElementToObject(request, "type", "IMMEDIATE_OR_CANCEL")
} else if IsTrue(IsEqual(tif, "FOK")) {
AddElementToObject(request, "type", "FILL_OR_KILL")
}
}
return this.Extend(request, params)
}
/**
* @ignore
* @method
* @name mexc#createSpotOrder
* @description create a trade order
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#new-order
* @param {string} market unified symbol of the market to create an order in
* @param {string} type 'market' or 'limit'
* @param {string} side 'buy' or 'sell'
* @param {float} amount how much of currency you want to trade in units of base currency
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
* @param {string} [marginMode] only 'isolated' is supported for spot-margin trading
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {bool} [params.postOnly] if true, the order will only be posted if it will be a maker order
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) CreateSpotOrder(market 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
marginMode := GetArg(optionalArgs, 1, nil)
_ = marginMode
params := GetArg(optionalArgs, 2, map[string]interface{} {})
_ = params
retRes23998 := (<-this.LoadMarkets())
PanicOnError(retRes23998)
var test interface{} = this.SafeBool(params, "test", false)
params = this.Omit(params, "test")
var request interface{} = this.CreateSpotOrderRequest(market, typeVar, side, amount, price, marginMode, params)
var response interface{} = nil
if IsTrue(test) {
response = (<-this.SpotPrivatePostOrderTest(request))
PanicOnError(response)
} else {
response = (<-this.SpotPrivatePostOrder(request))
PanicOnError(response)
}
//
// spot
//
// {
// "symbol": "BTCUSDT",
// "orderId": "123738410679123456",
// "orderListId": -1
// }
//
// margin
//
// {
// "symbol": "BTCUSDT",
// "orderId": "762634301354414080",
// "clientOrderId": null,
// "isIsolated": true,
// "transactTime": 1661992652132
// }
//
var order interface{} = this.ParseOrder(response, market)
AddElementToObject(order, "side", side)
AddElementToObject(order, "type", typeVar)
if IsTrue(IsEqual(this.SafeString(order, "price"), nil)) {
AddElementToObject(order, "price", price)
}
if IsTrue(IsEqual(this.SafeString(order, "amount"), nil)) {
AddElementToObject(order, "amount", amount)
}
ch <- order
return nil
}()
return ch
}
/**
* @ignore
* @method
* @name mexc#createSwapOrder
* @description create a trade order
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#new-order
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#order-under-maintenance
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#trigger-order-under-maintenance
* @param {string} market unified symbol of the market to create an order in
* @param {string} type 'market' or 'limit'
* @param {string} side 'buy' or 'sell'
* @param {float} amount how much of currency you want to trade in units of base currency
* @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
* @param {string} [marginMode] only 'isolated' is supported for spot-margin trading
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
* @param {bool} [params.postOnly] if true, the order will only be posted if it will be a maker order
* @param {bool} [params.reduceOnly] indicates if this order is to reduce the size of a position
* @param {bool} [params.hedged] *swap only* true for hedged mode, false for one way mode, default is false
*
* EXCHANGE SPECIFIC PARAMETERS
* @param {int} [params.leverage] leverage is necessary on isolated margin
* @param {long} [params.positionId] it is recommended to fill in this parameter when closing a position
* @param {string} [params.externalOid] external order ID
* @param {int} [params.positionMode] 1:hedge, 2:one-way, default: the user's current config
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) CreateSwapOrder(market 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
marginMode := GetArg(optionalArgs, 1, nil)
_ = marginMode
params := GetArg(optionalArgs, 2, map[string]interface{} {})
_ = params
retRes24688 := (<-this.LoadMarkets())
PanicOnError(retRes24688)
var symbol interface{} = GetValue(market, "symbol")
var unavailableContracts interface{} = this.SafeValue(this.Options, "unavailableContracts", map[string]interface{} {})
var isContractUnavaiable interface{} = this.SafeBool(unavailableContracts, symbol, false)
if IsTrue(isContractUnavaiable) {
panic(NotSupported(Add(Add(this.Id, " createSwapOrder() does not support yet this symbol:"), symbol)))
}
var openType interface{} = nil
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(IsEqual(marginMode, "cross")) {
openType = 2
} else if IsTrue(IsEqual(marginMode, "isolated")) {
openType = 1
} else {
panic(ArgumentsRequired(Add(this.Id, " createSwapOrder() marginMode parameter should be either \"cross\" or \"isolated\"")))
}
} else {
openType = this.SafeInteger(params, "openType", 2) // defaulting to cross margin
}
if IsTrue(IsTrue(IsTrue(IsTrue(IsTrue(IsTrue(IsTrue(IsTrue((!IsEqual(typeVar, "limit"))) && IsTrue((!IsEqual(typeVar, "market")))) && IsTrue((!IsEqual(typeVar, 1)))) && IsTrue((!IsEqual(typeVar, 2)))) && IsTrue((!IsEqual(typeVar, 3)))) && IsTrue((!IsEqual(typeVar, 4)))) && IsTrue((!IsEqual(typeVar, 5)))) && IsTrue((!IsEqual(typeVar, 6)))) {
panic(InvalidOrder(Add(this.Id, " createSwapOrder() order type must either limit, market, or 1 for limit orders, 2 for post-only orders, 3 for IOC orders, 4 for FOK orders, 5 for market orders or 6 to convert market price to current price")))
}
var postOnly interface{} = nil
postOnlyparamsVariable := this.HandlePostOnly(IsEqual(typeVar, "market"), IsEqual(typeVar, 2), params);
postOnly = GetValue(postOnlyparamsVariable,0);
params = GetValue(postOnlyparamsVariable,1)
if IsTrue(postOnly) {
typeVar = 2
} else if IsTrue(IsEqual(typeVar, "limit")) {
typeVar = 1
} else if IsTrue(IsEqual(typeVar, "market")) {
typeVar = 6
}
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
"vol": ParseFloat(this.AmountToPrecision(symbol, amount)),
"type": typeVar,
"openType": openType,
}
if IsTrue(IsTrue(IsTrue((!IsEqual(typeVar, 5))) && IsTrue((!IsEqual(typeVar, 6)))) && IsTrue((!IsEqual(typeVar, "market")))) {
AddElementToObject(request, "price", ParseFloat(this.PriceToPrecision(symbol, price)))
}
if IsTrue(IsEqual(openType, 1)) {
var leverage interface{} = this.SafeInteger(params, "leverage")
if IsTrue(IsEqual(leverage, nil)) {
panic(ArgumentsRequired(Add(this.Id, " createSwapOrder() requires a leverage parameter for isolated margin orders")))
}
}
var reduceOnly interface{} = this.SafeBool(params, "reduceOnly", false)
var hedged interface{} = this.SafeBool(params, "hedged", false)
var sideInteger interface{} = nil
if IsTrue(hedged) {
if IsTrue(reduceOnly) {
params = this.Omit(params, "reduceOnly") // hedged mode does not accept this parameter
side = Ternary(IsTrue((IsEqual(side, "buy"))), "sell", "buy")
}
sideInteger = Ternary(IsTrue((IsEqual(side, "buy"))), 1, 3)
AddElementToObject(request, "positionMode", 1)
} else {
if IsTrue(reduceOnly) {
sideInteger = Ternary(IsTrue((IsEqual(side, "buy"))), 2, 4)
} else {
sideInteger = Ternary(IsTrue((IsEqual(side, "buy"))), 1, 3)
}
}
AddElementToObject(request, "side", sideInteger)
var clientOrderId interface{} = this.SafeString2(params, "clientOrderId", "externalOid")
if IsTrue(!IsEqual(clientOrderId, nil)) {
AddElementToObject(request, "externalOid", clientOrderId)
}
var triggerPrice interface{} = this.SafeNumber2(params, "triggerPrice", "stopPrice")
params = this.Omit(params, []interface{}{"clientOrderId", "externalOid", "postOnly", "stopPrice", "triggerPrice", "hedged"})
var response interface{} = nil
if IsTrue(triggerPrice) {
AddElementToObject(request, "triggerPrice", this.PriceToPrecision(symbol, triggerPrice))
AddElementToObject(request, "triggerType", this.SafeInteger(params, "triggerType", 1))
AddElementToObject(request, "executeCycle", this.SafeInteger(params, "executeCycle", 1))
AddElementToObject(request, "trend", this.SafeInteger(params, "trend", 1))
AddElementToObject(request, "orderType", this.SafeInteger(params, "orderType", 1))
response = (<-this.ContractPrivatePostPlanorderPlace(this.Extend(request, params)))
PanicOnError(response)
} else {
response = (<-this.ContractPrivatePostOrderSubmit(this.Extend(request, params)))
PanicOnError(response)
}
//
// Swap
// {"code":200,"data":"2ff3163e8617443cb9c6fc19d42b1ca4"}
//
// Trigger
// {"success":true,"code":0,"data":259208506303929856}
//
var data interface{} = this.SafeString(response, "data")
ch <- this.SafeOrder(map[string]interface{} {
"id": data,
}, market)
return nil
}()
return ch
}
/**
* @method
* @name mexc#createOrders
* @description *spot only* *all orders must have the same symbol* create a list of trade orders
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#batch-orders
* @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 api endpoint
* @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) 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
retRes25908 := (<-this.LoadMarkets())
PanicOnError(retRes25908)
var ordersRequests interface{} = []interface{}{}
var symbol interface{} = nil
for i := 0; IsLessThan(i, GetArrayLength(orders)); i++ {
var rawOrder interface{} = GetValue(orders, i)
var marketId interface{} = this.SafeString(rawOrder, "symbol")
var market interface{} = this.Market(marketId)
if !IsTrue(GetValue(market, "spot")) {
panic(NotSupported(Add(this.Id, " createOrders() is only supported for spot markets")))
}
if IsTrue(IsEqual(symbol, nil)) {
symbol = marketId
} else {
if IsTrue(!IsEqual(symbol, marketId)) {
panic(BadRequest(Add(this.Id, " createOrders() requires all orders to have the same symbol")))
}
}
var typeVar interface{} = this.SafeString(rawOrder, "type")
var side interface{} = this.SafeString(rawOrder, "side")
var amount interface{} = this.SafeValue(rawOrder, "amount")
var price interface{} = this.SafeValue(rawOrder, "price")
var orderParams interface{} = this.SafeValue(rawOrder, "params", map[string]interface{} {})
var marginMode interface{} = nil
marginModeparamsVariable := this.HandleMarginModeAndParams("createOrder", params);
marginMode = GetValue(marginModeparamsVariable,0);
params = GetValue(marginModeparamsVariable,1)
var orderRequest interface{} = this.CreateSpotOrderRequest(market, typeVar, side, amount, price, marginMode, orderParams)
AppendToArray(&ordersRequests,orderRequest)
}
var request interface{} = map[string]interface{} {
"batchOrders": this.Json(ordersRequests),
}
response:= (<-this.SpotPrivatePostBatchOrders(request))
PanicOnError(response)
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "1196315350023612316",
// "newClientOrderId": "hio8279hbdsds",
// "orderListId": -1
// },
// {
// "newClientOrderId": "123456",
// "msg": "The minimum transaction volume cannot be less than:0.5USDT",
// "code": 30002
// },
// {
// "symbol": "BTCUSDT",
// "orderId": "1196315350023612318",
// "orderListId": -1
// }
// ]
//
ch <- this.ParseOrders(response)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchOrder
* @description fetches information on an order made by the user
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#query-order
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#query-the-order-based-on-the-order-number
* @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 {string} [params.marginMode] only 'isolated' is supported, for spot-margin trading
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) FetchOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchOrder() requires a symbol argument")))
}
retRes26608 := (<-this.LoadMarkets())
PanicOnError(retRes26608)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
var data interface{} = nil
if IsTrue(GetValue(market, "spot")) {
var clientOrderId interface{} = this.SafeString(params, "clientOrderId")
if IsTrue(!IsEqual(clientOrderId, nil)) {
params = this.Omit(params, "clientOrderId")
AddElementToObject(request, "origClientOrderId", clientOrderId)
} else {
AddElementToObject(request, "orderId", id)
}
marginModequeryVariable := this.HandleMarginModeAndParams("fetchOrder", params);
marginMode := GetValue(marginModequeryVariable,0);
query := GetValue(marginModequeryVariable,1)
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(!IsEqual(marginMode, "isolated")) {
panic(BadRequest(Add(Add(Add(this.Id, " fetchOrder() does not support marginMode "), marginMode), " for spot-margin trading")))
}
data = (<-this.SpotPrivateGetMarginOrder(this.Extend(request, query)))
PanicOnError(data)
} else {
data = (<-this.SpotPrivateGetOrder(this.Extend(request, query)))
PanicOnError(data)
}
} else if IsTrue(GetValue(market, "swap")) {
AddElementToObject(request, "order_id", id)
response:= (<-this.ContractPrivateGetOrderGetOrderId(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": "0",
// "data": {
// "orderId": "264995729269765120",
// "symbol": "STEPN_USDT",
// "positionId": "0",
// "price": "2.2",
// "vol": "15",
// "leverage": "20",
// "side": "1",
// "category": "1",
// "orderType": "1",
// "dealAvgPrice": "0",
// "dealVol": "0",
// "orderMargin": "2.2528",
// "takerFee": "0",
// "makerFee": "0",
// "profit": "0",
// "feeCurrency": "USDT",
// "openType": "1",
// "state": "2",
// "externalOid": "_m_0e9520c256744d64b942985189026d20",
// "errorCode": "0",
// "usedMargin": "0",
// "createTime": "1648850305236",
// "updateTime": "1648850305245",
// "positionMode": "1"
// }
// }
//
data = this.SafeValue(response, "data")
}
ch <- this.ParseOrder(data, market)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchOrders
* @description fetches information on multiple orders made by the user
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#all-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-of-the-user-39-s-historical-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#gets-the-trigger-order-list
* @param {string} symbol unified market symbol of the market orders were made in
* @param {int} [since] the earliest time in ms to fetch orders for
* @param {int} [limit] the maximum number of order structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] the latest time in ms to fetch orders for
* @param {string} [params.marginMode] only 'isolated' is supported, for spot-margin trading
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) FetchOrders(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes27838 := (<-this.LoadMarkets())
PanicOnError(retRes27838)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
var until interface{} = this.SafeInteger(params, "until")
params = this.Omit(params, "until")
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchOrders", market, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
if IsTrue(IsEqual(marketType, "spot")) {
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchOrders() requires a symbol argument for spot market")))
}
marginModequeryInnerVariable := this.HandleMarginModeAndParams("fetchOrders", params);
marginMode := GetValue(marginModequeryInnerVariable,0);
queryInner := GetValue(marginModequeryInnerVariable,1)
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since)
}
if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "endTime", until)
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "limit", limit)
}
var response interface{} = nil
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(!IsEqual(marginMode, "isolated")) {
panic(BadRequest(Add(Add(Add(this.Id, " fetchOrders() does not support marginMode "), marginMode), " for spot-margin trading")))
}
response = (<-this.SpotPrivateGetMarginAllOrders(this.Extend(request, queryInner)))
PanicOnError(response)
} else {
response = (<-this.SpotPrivateGetAllOrders(this.Extend(request, queryInner)))
PanicOnError(response)
}
//
// spot
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "133949373632483328",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "45000",
// "origQty": "0.0002",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "timeInForce": null,
// "type": "LIMIT",
// "side": "SELL",
// "stopPrice": null,
// "icebergQty": null,
// "time": "1647718255000",
// "updateTime": "1647718255000",
// "isWorking": true,
// "origQuoteOrderQty": "9"
// },
// ]
//
// margin
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "763307297891028992",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "18000",
// "origQty": "0.0014",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "type": "LIMIT",
// "side": "BUY",
// "isIsolated": true,
// "isWorking": true,
// "time": 1662153107000,
// "updateTime": 1662153107000
// }
// ]
//
ch <- this.ParseOrders(response, market, since, limit)
return nil
} else {
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "start_time", since)
var end interface{} = this.SafeInteger(params, "end_time", until)
if IsTrue(IsEqual(end, nil)) {
AddElementToObject(request, "end_time", this.Sum(since, GetValue(this.Options, "maxTimeTillEnd")))
} else {
if IsTrue(IsGreaterThan((Subtract(end, since)), GetValue(this.Options, "maxTimeTillEnd"))) {
panic(BadRequest(Add(this.Id, " end is invalid, i.e. exceeds allowed 90 days.")))
} else {
AddElementToObject(request, "end_time", until)
}
}
} else if IsTrue(!IsEqual(until, nil)) {
AddElementToObject(request, "start_time", this.Sum(until, Multiply(GetValue(this.Options, "maxTimeTillEnd"), OpNeg(1))))
AddElementToObject(request, "end_time", until)
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "page_size", limit)
}
var method interface{} = this.SafeString(this.Options, "fetchOrders", "contractPrivateGetOrderListHistoryOrders")
method = this.SafeString(query, "method", method)
var ordersOfRegular interface{} = []interface{}{}
var ordersOfTrigger interface{} = []interface{}{}
if IsTrue(IsEqual(method, "contractPrivateGetOrderListHistoryOrders")) {
response:= (<-this.ContractPrivateGetOrderListHistoryOrders(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "orderId": "265230764677709315",
// "symbol": "STEPN_USDT",
// "positionId": "0",
// "price": "2.1",
// "vol": "102",
// "leverage": "20",
// "side": "1",
// "category": "1",
// "orderType": "1",
// "dealAvgPrice": "0",
// "dealVol": "0",
// "orderMargin": "10.96704",
// "takerFee": "0",
// "makerFee": "0",
// "profit": "0",
// "feeCurrency": "USDT",
// "openType": "1",
// "state": "2",
// "externalOid": "_m_7e42f8df6b324c869e4e200397e2b00f",
// "errorCode": "0",
// "usedMargin": "0",
// "createTime": "1648906342000",
// "updateTime": "1648906342000",
// "positionMode": "1"
// },
// ]
// }
//
ordersOfRegular = this.SafeValue(response, "data")
} else {
// the Planorder endpoints work not only for stop-market orders, but also for stop-limit orders that were supposed to have a separate endpoint
response:= (<-this.ContractPrivateGetPlanorderListOrders(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "symbol": "STEPN_USDT",
// "leverage": "20",
// "side": "1",
// "vol": "13",
// "openType": "1",
// "state": "1",
// "orderType": "1",
// "errorCode": "0",
// "createTime": "1648984276000",
// "updateTime": "1648984276000",
// "id": "265557643326564352",
// "triggerType": "1",
// "triggerPrice": "3",
// "price": "2.9", // not present in stop-market, but in stop-limit order
// "executeCycle": "87600",
// "trend": "1",
// },
// ]
// }
//
ordersOfTrigger = this.SafeValue(response, "data")
}
var merged interface{} = this.ArrayConcat(ordersOfTrigger, ordersOfRegular)
ch <- this.ParseOrders(merged, market, since, limit, params)
return nil
}
return nil
}()
return ch
}
func (this *mexc) FetchOrdersByIds(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
retRes29638 := (<-this.LoadMarkets())
PanicOnError(retRes29638)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchOrdersByIds", market, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
if IsTrue(IsEqual(marketType, "spot")) {
panic(BadRequest(Add(Add(this.Id, " fetchOrdersByIds() is not supported for "), marketType)))
} else {
AddElementToObject(request, "order_ids", Join(ids, ","))
response:= (<-this.ContractPrivateGetOrderBatchQuery(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "orderId": "265230764677709315",
// "symbol": "STEPN_USDT",
// "positionId": "0",
// "price": "2.1",
// "vol": "102",
// "leverage": "20",
// "side": "1",
// "category": "1",
// "orderType": "1",
// "dealAvgPrice": "0",
// "dealVol": "0",
// "orderMargin": "10.96704",
// "takerFee": "0",
// "makerFee": "0",
// "profit": "0",
// "feeCurrency": "USDT",
// "openType": "1",
// "state": "2",
// "externalOid": "_m_7e42f8df6b324c869e4e200397e2b00f",
// "errorCode": "0",
// "usedMargin": "0",
// "createTime": "1648906342000",
// "updateTime": "1648906342000",
// "positionMode": "1"
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data")
ch <- this.ParseOrders(data, market)
return nil
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchOpenOrders
* @description fetch all unfilled currently open orders
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#current-open-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-of-the-user-39-s-historical-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#gets-the-trigger-order-list
* @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 {string} [params.marginMode] only 'isolated' is supported, for spot-margin trading
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) 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
retRes30308 := (<-this.LoadMarkets())
PanicOnError(retRes30308)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
var marketType interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
}
marketTypeparamsVariable := this.HandleMarketTypeAndParams("fetchOpenOrders", market, params);
marketType = GetValue(marketTypeparamsVariable,0);
params = GetValue(marketTypeparamsVariable,1)
if IsTrue(IsEqual(marketType, "spot")) {
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchOpenOrders() requires a symbol argument for spot market")))
}
AddElementToObject(request, "symbol", GetValue(market, "id"))
marginModequeryVariable := this.HandleMarginModeAndParams("fetchOpenOrders", params);
marginMode := GetValue(marginModequeryVariable,0);
query := GetValue(marginModequeryVariable,1)
var response interface{} = nil
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(!IsEqual(marginMode, "isolated")) {
panic(BadRequest(Add(Add(Add(this.Id, " fetchOpenOrders() does not support marginMode "), marginMode), " for spot-margin trading")))
}
response = (<-this.SpotPrivateGetMarginOpenOrders(this.Extend(request, query)))
PanicOnError(response)
} else {
response = (<-this.SpotPrivateGetOpenOrders(this.Extend(request, query)))
PanicOnError(response)
}
//
// spot
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "133949373632483328",
// "orderListId": "-1",
// "clientOrderId": "",
// "price": "45000",
// "origQty": "0.0002",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "timeInForce": null,
// "type": "LIMIT",
// "side": "SELL",
// "stopPrice": null,
// "icebergQty": null,
// "time": "1647718255199",
// "updateTime": null,
// "isWorking": true,
// "origQuoteOrderQty": "9"
// }
// ]
//
// margin
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "764547676405633024",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "18000",
// "origQty": "0.0013",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "type": "LIMIT",
// "side": "BUY",
// "isIsolated": true,
// "isWorking": true,
// "time": 1662448836000,
// "updateTime": 1662448836000
// }
// ]
//
ch <- this.ParseOrders(response, market, since, limit)
return nil
} else {
retRes310419 := (<-this.FetchOrdersByState(2, symbol, since, limit, params))
PanicOnError(retRes310419)
// TO_DO: another possible way is through: open_orders/{symbol}, but as they have same ratelimits, and less granularity, i think historical orders are more convenient, as it supports more params (however, theoretically, open-orders endpoint might be sligthly fast)
ch <- retRes310419
return nil
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchClosedOrders
* @description fetches information on multiple closed orders made by the user
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#all-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-of-the-user-39-s-historical-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#gets-the-trigger-order-list
* @param {string} symbol unified market symbol of the market orders were made in
* @param {int} [since] the earliest time in ms to fetch orders for
* @param {int} [limit] the maximum number of order structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) FetchClosedOrders(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes312215 := (<-this.FetchOrdersByState(3, symbol, since, limit, params))
PanicOnError(retRes312215)
ch <- retRes312215
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchCanceledOrders
* @description fetches information on multiple canceled orders made by the user
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#all-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-of-the-user-39-s-historical-orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#gets-the-trigger-order-list
* @param {string} symbol unified market symbol of the market orders were made in
* @param {int} [since] timestamp in ms of the earliest order, default is undefined
* @param {int} [limit] max number of orders to return, default is undefined
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) FetchCanceledOrders(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
retRes313915 := (<-this.FetchOrdersByState(4, symbol, since, limit, params))
PanicOnError(retRes313915)
ch <- retRes313915
return nil
}()
return ch
}
func (this *mexc) FetchOrdersByState(state interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes31438 := (<-this.LoadMarkets())
PanicOnError(retRes31438)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
}
marketTypeVariable := this.HandleMarketTypeAndParams("fetchOrdersByState", market, params);
marketType := GetValue(marketTypeVariable,0)
if IsTrue(IsEqual(marketType, "spot")) {
panic(NotSupported(Add(Add(this.Id, " fetchOrdersByState() is not supported for "), marketType)))
} else {
AddElementToObject(request, "states", state)
retRes315419 := (<-this.FetchOrders(symbol, since, limit, this.Extend(request, params)))
PanicOnError(retRes315419)
ch <- retRes315419
return nil
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#cancelOrder
* @description cancels an open order
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#cancel-order
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#cancel-the-order-under-maintenance
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#cancel-the-stop-limit-trigger-order-under-maintenance
* @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 {string} [params.marginMode] only 'isolated' is supported for spot-margin trading
* @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) 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
retRes31728 := (<-this.LoadMarkets())
PanicOnError(retRes31728)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
var marketType interface{} = nil
marketTypeparamsVariable := this.HandleMarketTypeAndParams("cancelOrder", market, params);
marketType = GetValue(marketTypeparamsVariable,0);
params = GetValue(marketTypeparamsVariable,1)
marginModequeryVariable := this.HandleMarginModeAndParams("cancelOrder", params);
marginMode := GetValue(marginModequeryVariable,0);
query := GetValue(marginModequeryVariable,1)
var data interface{} = nil
if IsTrue(IsEqual(marketType, "spot")) {
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument")))
}
var requestInner interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
var clientOrderId interface{} = this.SafeString(params, "clientOrderId")
if IsTrue(!IsEqual(clientOrderId, nil)) {
params = this.Omit(query, "clientOrderId")
AddElementToObject(requestInner, "origClientOrderId", clientOrderId)
} else {
AddElementToObject(requestInner, "orderId", id)
}
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(!IsEqual(marginMode, "isolated")) {
panic(BadRequest(Add(Add(Add(this.Id, " cancelOrder() does not support marginMode "), marginMode), " for spot-margin trading")))
}
data = (<-this.SpotPrivateDeleteMarginOrder(this.Extend(requestInner, query)))
PanicOnError(data)
} else {
data = (<-this.SpotPrivateDeleteOrder(this.Extend(requestInner, query)))
PanicOnError(data)
}
} else {
// TODO: PlanorderCancel endpoint has bug atm. waiting for fix.
var method interface{} = this.SafeString(this.Options, "cancelOrder", "contractPrivatePostOrderCancel") // contractPrivatePostOrderCancel, contractPrivatePostPlanorderCancel
method = this.SafeString(query, "method", method)
var response interface{} = nil
if IsTrue(IsEqual(method, "contractPrivatePostOrderCancel")) {
response = (<-this.ContractPrivatePostOrderCancel([]interface{}{id}))
PanicOnError(response) // the request cannot be changed or extended. This is the only way to send.
} else if IsTrue(IsEqual(method, "contractPrivatePostPlanorderCancel")) {
response = (<-this.ContractPrivatePostPlanorderCancel([]interface{}{id}))
PanicOnError(response) // the request cannot be changed or extended. This is the only way to send.
} else {
panic(NotSupported(Add(this.Id, " cancelOrder() not support this method")))
}
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "orderId": "264995729269765120",
// "errorCode": "0", // if already canceled: "2041"; if doesn't exist: "2040"
// "errorMsg": "success", // if already canceled: "order state cannot be cancelled"; if doesn't exist: "order not exist"
// }
// ]
// }
//
data = this.SafeValue(response, "data")
var order interface{} = this.SafeValue(data, 0)
var errorMsg interface{} = this.SafeValue(order, "errorMsg", "")
if IsTrue(!IsEqual(errorMsg, "success")) {
panic(InvalidOrder(Add(Add(Add(Add(this.Id, " cancelOrder() the order with id "), id), " cannot be cancelled: "), errorMsg)))
}
}
ch <- this.ParseOrder(data, market)
return nil
}()
return ch
}
/**
* @method
* @name mexc#cancelOrders
* @description cancel multiple orders
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#cancel-the-order-under-maintenance
* @param {string[]} ids order ids
* @param {string} symbol unified market symbol, default is undefined
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) 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
retRes32858 := (<-this.LoadMarkets())
PanicOnError(retRes32858)
var market interface{} = Ternary(IsTrue((!IsEqual(symbol, nil))), this.Market(symbol), nil)
marketTypeVariable := this.HandleMarketTypeAndParams("cancelOrders", market, params);
marketType := GetValue(marketTypeVariable,0)
if IsTrue(IsEqual(marketType, "spot")) {
panic(BadRequest(Add(Add(this.Id, " cancelOrders() is not supported for "), marketType)))
} else {
response:= (<-this.ContractPrivatePostOrderCancel(ids))
PanicOnError(response) // the request cannot be changed or extended. The only way to send.
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "orderId": "264995729269765120",
// "errorCode": "0", // if already canceled: "2041"
// "errorMsg": "success", // if already canceled: "order state cannot be cancelled"
// },
// ]
// }
//
var data interface{} = this.SafeList(response, "data")
ch <- this.ParseOrders(data, market)
return nil
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#cancelAllOrders
* @description cancel all open orders
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#cancel-all-open-orders-on-a-symbol
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#cancel-all-orders-under-a-contract-under-maintenance
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#cancel-all-trigger-orders-under-maintenance
* @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
* @param {string} [params.marginMode] only 'isolated' is supported for spot-margin trading
* @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
*/
func (this *mexc) 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
retRes33238 := (<-this.LoadMarkets())
PanicOnError(retRes33238)
var market interface{} = Ternary(IsTrue((!IsEqual(symbol, nil))), this.Market(symbol), nil)
var request interface{} = map[string]interface{} {}
var marketType interface{} = nil
marketTypeparamsVariable := this.HandleMarketTypeAndParams("cancelAllOrders", market, params);
marketType = GetValue(marketTypeparamsVariable,0);
params = GetValue(marketTypeparamsVariable,1)
marginModequeryVariable := this.HandleMarginModeAndParams("cancelAllOrders", params);
marginMode := GetValue(marginModequeryVariable,0);
query := GetValue(marginModequeryVariable,1)
if IsTrue(IsEqual(marketType, "spot")) {
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " cancelAllOrders() requires a symbol argument on spot")))
}
AddElementToObject(request, "symbol", GetValue(market, "id"))
var response interface{} = nil
if IsTrue(!IsEqual(marginMode, nil)) {
if IsTrue(!IsEqual(marginMode, "isolated")) {
panic(BadRequest(Add(Add(Add(this.Id, " cancelAllOrders() does not support marginMode "), marginMode), " for spot-margin trading")))
}
response = (<-this.SpotPrivateDeleteMarginOpenOrders(this.Extend(request, query)))
PanicOnError(response)
} else {
response = (<-this.SpotPrivateDeleteOpenOrders(this.Extend(request, query)))
PanicOnError(response)
}
//
// spot
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "133926492139692032",
// "price": "30000",
// "origQty": "0.0002",
// "type": "LIMIT",
// "side": "BUY"
// },
// ]
//
// margin
//
// [
// {
// "symbol": "BTCUSDT",
// "orderId": "762640232574226432",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "18000",
// "origQty": "0.00147",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "type": "LIMIT",
// "side": "BUY",
// "isIsolated": true,
// "isWorking": true,
// "time": 1661994066000,
// "updateTime": 1661994066000
// }
// ]
//
ch <- this.ParseOrders(response, market)
return nil
} else {
if IsTrue(!IsEqual(symbol, nil)) {
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
// method can be either: contractPrivatePostOrderCancelAll or contractPrivatePostPlanorderCancelAll
// the Planorder endpoints work not only for stop-market orders but also for stop-limit orders that are supposed to have separate endpoint
var method interface{} = this.SafeString(this.Options, "cancelAllOrders", "contractPrivatePostOrderCancelAll")
method = this.SafeString(query, "method", method)
var response interface{} = nil
if IsTrue(IsEqual(method, "contractPrivatePostOrderCancelAll")) {
response = (<-this.ContractPrivatePostOrderCancelAll(this.Extend(request, query)))
PanicOnError(response)
} else if IsTrue(IsEqual(method, "contractPrivatePostPlanorderCancelAll")) {
response = (<-this.ContractPrivatePostPlanorderCancelAll(this.Extend(request, query)))
PanicOnError(response)
}
//
// {
// "success": true,
// "code": "0"
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseOrders(data, market)
return nil
}
return nil
}()
return ch
}
func (this *mexc) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} {
//
// spot: createOrder
//
// {
// "symbol": "BTCUSDT",
// "orderId": "123738410679123456",
// "orderListId": -1
// }
//
// margin: createOrder
//
// {
// "symbol": "BTCUSDT",
// "orderId": "762634301354414080",
// "clientOrderId": null,
// "isIsolated": true,
// "transactTime": 1661992652132
// }
//
// spot: cancelOrder, cancelAllOrders
//
// {
// "symbol": "BTCUSDT",
// "orderId": "133926441921286144",
// "price": "30000",
// "origQty": "0.0002",
// "type": "LIMIT",
// "side": "BUY"
// }
//
// margin: cancelOrder, cancelAllOrders
//
// {
// "symbol": "BTCUSDT",
// "orderId": "762640232574226432",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "18000",
// "origQty": "0.00147",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "type": "LIMIT",
// "side": "BUY",
// "isIsolated": true,
// "isWorking": true,
// "time": 1661994066000,
// "updateTime": 1661994066000
// }
//
// spot: fetchOrder, fetchOpenOrders, fetchOrders
//
// {
// "symbol": "BTCUSDT",
// "orderId": "133734823834147272",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "30000",
// "origQty": "0.0002",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "CANCELED",
// "timeInForce": null,
// "type": "LIMIT",
// "side": "BUY",
// "stopPrice": null,
// "icebergQty": null,
// "time": "1647667102000",
// "updateTime": "1647708567000",
// "isWorking": true,
// "origQuoteOrderQty": "6"
// }
//
// margin: fetchOrder, fetchOrders
//
// {
// "symbol": "BTCUSDT",
// "orderId": "763307297891028992",
// "orderListId": "-1",
// "clientOrderId": null,
// "price": "18000",
// "origQty": "0.0014",
// "executedQty": "0",
// "cummulativeQuoteQty": "0",
// "status": "NEW",
// "type": "LIMIT",
// "side": "BUY",
// "isIsolated": true,
// "isWorking": true,
// "time": 1662153107000,
// "updateTime": 1662153107000
// }
//
// swap: createOrder
//
// 2ff3163e8617443cb9c6fc19d42b1ca4
//
// swap: fetchOrder, fetchOrders
//
// regular
// {
// "orderId": "264995729269765120",
// "symbol": "STEPN_USDT",
// "positionId": "0",
// "price": "2.2",
// "vol": "15",
// "leverage": "20",
// "side": "1", // TODO: not unified
// "category": "1",
// "orderType": "1", // TODO: not unified
// "dealAvgPrice": "0",
// "dealVol": "0",
// "orderMargin": "2.2528",
// "takerFee": "0",
// "makerFee": "0",
// "profit": "0",
// "feeCurrency": "USDT",
// "openType": "1",
// "state": "2", // TODO
// "externalOid": "_m_0e9520c256744d64b942985189026d20",
// "errorCode": "0",
// "usedMargin": "0",
// "createTime": "1648850305236",
// "updateTime": "1648850305245",
// "positionMode": "1"
// }
//
// stop
// {
// "id": "265557643326564352",
// "triggerType": "1",
// "triggerPrice": "3",
// "price": "2.9", // not present in stop-market, but in stop-limit order
// "executeCycle": "87600",
// "trend": "1",
// // below keys are same as in regular order structure
// "symbol": "STEPN_USDT",
// "leverage": "20",
// "side": "1",
// "vol": "13",
// "openType": "1",
// "state": "1",
// "orderType": "1",
// "errorCode": "0",
// "createTime": "1648984276000",
// "updateTime": "1648984276000",
// }
//
// createOrders error
//
// {
// "newClientOrderId": "123456",
// "msg": "The minimum transaction volume cannot be less than:0.5USDT",
// "code": 30002
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var code interface{} = this.SafeInteger(order, "code")
if IsTrue(!IsEqual(code, nil)) {
// error upon placing multiple orders
return this.SafeOrder(map[string]interface{} {
"info": order,
"status": "rejected",
"clientOrderId": this.SafeString(order, "newClientOrderId"),
})
}
var id interface{} = nil
if IsTrue(IsString(order)) {
id = order
} else {
id = this.SafeString2(order, "orderId", "id")
}
var marketId interface{} = this.SafeString(order, "symbol")
market = this.SafeMarket(marketId, market)
var timestamp interface{} = this.SafeIntegerN(order, []interface{}{"time", "createTime", "transactTime"})
var fee interface{} = nil
var feeCurrency interface{} = this.SafeString(order, "feeCurrency")
if IsTrue(!IsEqual(feeCurrency, nil)) {
var takerFee interface{} = this.SafeString(order, "takerFee")
var makerFee interface{} = this.SafeString(order, "makerFee")
var feeSum interface{} = Precise.StringAdd(takerFee, makerFee)
fee = map[string]interface{} {
"currency": feeCurrency,
"cost": this.ParseNumber(feeSum),
}
}
return this.SafeOrder(map[string]interface{} {
"id": id,
"clientOrderId": this.SafeString(order, "clientOrderId"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"lastTradeTimestamp": nil,
"status": this.ParseOrderStatus(this.SafeString2(order, "status", "state")),
"symbol": GetValue(market, "symbol"),
"type": this.ParseOrderType(this.SafeString(order, "type")),
"timeInForce": this.ParseOrderTimeInForce(this.SafeString(order, "timeInForce")),
"side": this.ParseOrderSide(this.SafeString(order, "side")),
"price": this.SafeNumber(order, "price"),
"triggerPrice": this.SafeNumber2(order, "stopPrice", "triggerPrice"),
"average": this.SafeNumber(order, "dealAvgPrice"),
"amount": this.SafeNumber2(order, "origQty", "vol"),
"cost": this.SafeNumber(order, "cummulativeQuoteQty"),
"filled": this.SafeNumber2(order, "executedQty", "dealVol"),
"remaining": nil,
"fee": fee,
"trades": nil,
"info": order,
}, market)
}
func (this *mexc) ParseOrderSide(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"BUY": "buy",
"SELL": "sell",
"1": "buy",
"2": "sell",
}
return this.SafeString(statuses, status, status)
}
func (this *mexc) ParseOrderType(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"MARKET": "market",
"LIMIT": "limit",
"LIMIT_MAKER": "limit",
}
return this.SafeString(statuses, status, status)
}
func (this *mexc) ParseOrderStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"NEW": "open",
"FILLED": "closed",
"CANCELED": "canceled",
"PARTIALLY_FILLED": "open",
"PARTIALLY_CANCELED": "canceled",
"2": "open",
"3": "closed",
"4": "canceled",
}
return this.SafeString(statuses, status, status)
}
func (this *mexc) ParseOrderTimeInForce(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"GTC": "GTC",
"FOK": "FOK",
"IOC": "IOC",
}
return this.SafeString(statuses, status, status)
}
func (this *mexc) FetchAccountHelper(typeVar interface{}, params interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
if IsTrue(IsEqual(typeVar, "spot")) {
retRes366319 := (<-this.SpotPrivateGetAccount(params))
PanicOnError(retRes366319)
ch <- retRes366319
return nil
} else if IsTrue(IsEqual(typeVar, "swap")) {
response:= (<-this.ContractPrivateGetAccountAssets(params))
PanicOnError(response)
//
// {
// "success":true,
// "code":0,
// "data":[
// {
// "currency":"BSV",
// "positionMargin":0,
// "availableBalance":0,
// "cashBalance":0,
// "frozenBalance":0,
// "equity":0,
// "unrealized":0,
// "bonus":0
// },
// ]
// }
//
ch <- this.SafeValue(response, "data")
return nil
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchAccounts
* @description fetch all the accounts associated with a profile
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#account-information
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-informations-of-user-39-s-asset
* @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 *mexc) FetchAccounts(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
// TODO: is the below endpoints suitable for fetchAccounts?
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchAccounts", nil, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
retRes37298 := (<-this.LoadMarkets())
PanicOnError(retRes37298)
response:= (<-this.FetchAccountHelper(marketType, query))
PanicOnError(response)
var data interface{} = this.SafeValue(response, "balances", []interface{}{})
var result interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(data)); i++ {
var account interface{} = GetValue(data, i)
var currencyId interface{} = this.SafeString2(account, "asset", "currency")
var code interface{} = this.SafeCurrencyCode(currencyId)
AppendToArray(&result,map[string]interface{} {
"id": this.SafeString(account, "id"),
"type": this.SafeString(account, "type"),
"code": code,
"info": account,
})
}
ch <- result
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchTradingFee
* @description fetch the trading fees for a market
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#query-mx-deduct-status
* @param {string} symbol unified market symbol
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [fee structure]{@link https://docs.ccxt.com/#/?id=fee-structure}
*/
func (this *mexc) FetchTradingFee(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes37578 := (<-this.LoadMarkets())
PanicOnError(retRes37578)
var market interface{} = this.Market(symbol)
if !IsTrue(GetValue(market, "spot")) {
panic(BadRequest(Add(this.Id, " fetchTradingFee() supports spot markets only")))
}
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
response:= (<-this.SpotPrivateGetTradeFee(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "data":{
// "makerCommission":0.003000000000000000,
// "takerCommission":0.003000000000000000
// },
// "code":0,
// "msg":"success",
// "timestamp":1669109672717
// }
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- map[string]interface{} {
"info": data,
"symbol": symbol,
"maker": this.SafeNumber(data, "makerCommission"),
"taker": this.SafeNumber(data, "takerCommission"),
"percentage": nil,
"tierBased": nil,
}
return nil
}()
return ch
}
func (this *mexc) CustomParseBalance(response interface{}, marketType interface{}) interface{} {
//
// spot
//
// {
// "asset": "USDT",
// "free": "0.000000000674",
// "locked": "0"
// }
//
// swap
//
// {
// "currency": "BSV",
// "positionMargin": 0,
// "availableBalance": 0,
// "cashBalance": 0,
// "frozenBalance": 0,
// "equity": 0,
// "unrealized": 0,
// "bonus": 0
// }
//
// margin
//
// {
// "baseAsset": {
// "asset": "BTC",
// "borrowEnabled": true,
// "borrowed": "0",
// "free": "0",
// "interest": "0",
// "locked": "0",
// "netAsset": "0",
// "netAssetOfBtc": "0",
// "repayEnabled": true,
// "totalAsset": "0"
// }
// "quoteAsset": {
// "asset": "USDT",
// "borrowEnabled": true,
// "borrowed": "0",
// "free": "10",
// "interest": "0",
// "locked": "0",
// "netAsset": "10",
// "netAssetOfBtc": "0",
// "repayEnabled": true,
// "totalAsset": "10"
// }
// "symbol": "BTCUSDT",
// "isolatedCreated": true,
// "enabled": true,
// "marginLevel": "999",
// "marginRatio": "9",
// "indexPrice": "16741.137068965517241379",
// "liquidatePrice": "--",
// "liquidateRate": "--",
// "tradeEnabled": true
// }
//
var wallet interface{} = nil
if IsTrue(IsEqual(marketType, "margin")) {
wallet = this.SafeValue(response, "assets", []interface{}{})
} else if IsTrue(IsEqual(marketType, "swap")) {
wallet = this.SafeValue(response, "data", []interface{}{})
} else {
wallet = this.SafeValue(response, "balances", []interface{}{})
}
var result interface{} = map[string]interface{} {
"info": response,
}
if IsTrue(IsEqual(marketType, "margin")) {
for i := 0; IsLessThan(i, GetArrayLength(wallet)); i++ {
var entry interface{} = GetValue(wallet, i)
var marketId interface{} = this.SafeString(entry, "symbol")
var symbol interface{} = this.SafeSymbol(marketId, nil)
var base interface{} = this.SafeValue(entry, "baseAsset", map[string]interface{} {})
var quote interface{} = this.SafeValue(entry, "quoteAsset", map[string]interface{} {})
var baseCode interface{} = this.SafeCurrencyCode(this.SafeString(base, "asset"))
var quoteCode interface{} = this.SafeCurrencyCode(this.SafeString(quote, "asset"))
var subResult interface{} = map[string]interface{} {}
AddElementToObject(subResult, baseCode, this.ParseBalanceHelper(base))
AddElementToObject(subResult, quoteCode, this.ParseBalanceHelper(quote))
AddElementToObject(result, symbol, this.SafeBalance(subResult))
}
return result
} else if IsTrue(IsEqual(marketType, "swap")) {
for i := 0; IsLessThan(i, GetArrayLength(wallet)); i++ {
var entry interface{} = GetValue(wallet, i)
var currencyId interface{} = this.SafeString(entry, "currency")
var code interface{} = this.SafeCurrencyCode(currencyId)
var account interface{} = this.Account()
AddElementToObject(account, "free", this.SafeString(entry, "availableBalance"))
AddElementToObject(account, "used", this.SafeString(entry, "frozenBalance"))
AddElementToObject(result, code, account)
}
return this.SafeBalance(result)
} else {
for i := 0; IsLessThan(i, GetArrayLength(wallet)); i++ {
var entry interface{} = GetValue(wallet, i)
var currencyId interface{} = this.SafeString(entry, "asset")
var code interface{} = this.SafeCurrencyCode(currencyId)
var account interface{} = this.Account()
AddElementToObject(account, "free", this.SafeString(entry, "free"))
AddElementToObject(account, "used", this.SafeString(entry, "locked"))
AddElementToObject(result, code, account)
}
return this.SafeBalance(result)
}
}
func (this *mexc) ParseBalanceHelper(entry interface{}) interface{} {
var account interface{} = this.Account()
AddElementToObject(account, "used", this.SafeString(entry, "locked"))
AddElementToObject(account, "free", this.SafeString(entry, "free"))
AddElementToObject(account, "total", this.SafeString(entry, "totalAsset"))
var debt interface{} = this.SafeString(entry, "borrowed")
var interest interface{} = this.SafeString(entry, "interest")
AddElementToObject(account, "debt", Precise.StringAdd(debt, interest))
return account
}
/**
* @method
* @name mexc#fetchBalance
* @description query for balance and get the amount of funds available for trading or funds locked in orders
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#account-information
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-informations-of-user-39-s-asset
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#isolated-account
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.symbols] // required for margin, market id's separated by commas
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
*/
func (this *mexc) 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
retRes39218 := (<-this.LoadMarkets())
PanicOnError(retRes39218)
var marketType interface{} = nil
var request interface{} = map[string]interface{} {}
marketTypeparamsVariable := this.HandleMarketTypeAndParams("fetchBalance", nil, params);
marketType = GetValue(marketTypeparamsVariable,0);
params = GetValue(marketTypeparamsVariable,1)
var marginMode interface{} = this.SafeString(params, "marginMode")
var isMargin interface{} = this.SafeBool(params, "margin", false)
params = this.Omit(params, []interface{}{"margin", "marginMode"})
var response interface{} = nil
if IsTrue(IsTrue(IsTrue((!IsEqual(marginMode, nil))) || IsTrue((isMargin))) || IsTrue((IsEqual(marketType, "margin")))) {
var parsedSymbols interface{} = nil
var symbol interface{} = this.SafeString(params, "symbol")
if IsTrue(IsEqual(symbol, nil)) {
var symbols interface{} = this.SafeValue(params, "symbols")
if IsTrue(!IsEqual(symbols, nil)) {
parsedSymbols = Join(this.MarketIds(symbols), ",")
}
} else {
var market interface{} = this.Market(symbol)
parsedSymbols = GetValue(market, "id")
}
this.CheckRequiredArgument("fetchBalance", parsedSymbols, "symbol or symbols")
marketType = "margin"
AddElementToObject(request, "symbols", parsedSymbols)
params = this.Omit(params, []interface{}{"symbol", "symbols"})
response = (<-this.SpotPrivateGetMarginIsolatedAccount(this.Extend(request, params)))
PanicOnError(response)
} else if IsTrue(IsEqual(marketType, "spot")) {
response = (<-this.SpotPrivateGetAccount(this.Extend(request, params)))
PanicOnError(response)
} else if IsTrue(IsEqual(marketType, "swap")) {
response = (<-this.ContractPrivateGetAccountAssets(this.Extend(request, params)))
PanicOnError(response)
} else {
panic(NotSupported(Add(this.Id, " fetchBalance() not support this method")))
}
//
// spot
//
// {
// "makerCommission": 0,
// "takerCommission": 20,
// "buyerCommission": 0,
// "sellerCommission": 0,
// "canTrade": true,
// "canWithdraw": true,
// "canDeposit": true,
// "updateTime": null,
// "accountType": "SPOT",
// "balances": [
// {
// "asset": "USDT",
// "free": "0.000000000674",
// "locked": "0"
// },
// ],
// "permissions": ["SPOT"]
// }
//
// swap
//
// {
// "success": true,
// "code": 0,
// "data": [
// {
// "currency": "BSV",
// "positionMargin": 0,
// "availableBalance": 0,
// "cashBalance": 0,
// "frozenBalance": 0,
// "equity": 0,
// "unrealized": 0,
// "bonus": 0
// },
// ]
// }
//
// margin
//
// {
// "assets": [
// {
// "baseAsset": {
// "asset": "BTC",
// "borrowEnabled": true,
// "borrowed": "0",
// "free": "0",
// "interest": "0",
// "locked": "0",
// "netAsset": "0",
// "netAssetOfBtc": "0",
// "repayEnabled": true,
// "totalAsset": "0"
// },
// "quoteAsset": {
// "asset": "USDT",
// "borrowEnabled": true,
// "borrowed": "0",
// "free": "10",
// "interest": "0",
// "locked": "0",
// "netAsset": "10",
// "netAssetOfBtc": "0",
// "repayEnabled": true,
// "totalAsset": "10"
// },
// "symbol": "BTCUSDT",
// "isolatedCreated": true,
// "enabled": true,
// "marginLevel": "999",
// "marginRatio": "9",
// "indexPrice": "16741.137068965517241379",
// "liquidatePrice": "--",
// "liquidateRate": "--",
// "tradeEnabled": true
// }
// ]
// }
//
ch <- this.CustomParseBalance(response, marketType)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchMyTrades
* @description fetch all trades made by the user
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#account-trade-list
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-all-transaction-details-of-the-user-s-order
* @param {string} symbol unified market symbol
* @param {int} [since] the earliest time in ms to fetch trades for
* @param {int} [limit] the maximum number of trades structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.until] the latest time in ms to fetch trades for
* @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
*/
func (this *mexc) 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
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchMyTrades() requires a symbol argument")))
}
retRes40578 := (<-this.LoadMarkets())
PanicOnError(retRes40578)
var market interface{} = this.Market(symbol)
var marketType interface{} = nil
marketTypeparamsVariable := this.HandleMarketTypeAndParams("fetchMyTrades", market, params);
marketType = GetValue(marketTypeparamsVariable,0);
params = GetValue(marketTypeparamsVariable,1)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
var trades interface{} = nil
if IsTrue(IsEqual(marketType, "spot")) {
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)) {
params = this.Omit(params, "until")
AddElementToObject(request, "endTime", until)
}
trades = (<-this.SpotPrivateGetMyTrades(this.Extend(request, params)))
PanicOnError(trades)
} else {
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "start_time", since)
var end interface{} = this.SafeInteger(params, "end_time")
if IsTrue(IsEqual(end, nil)) {
AddElementToObject(request, "end_time", this.Sum(since, GetValue(this.Options, "maxTimeTillEnd")))
}
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "page_size", limit)
}
response:= (<-this.ContractPrivateGetOrderListOrderDeals(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "id": "299444585",
// "symbol": "STEPN_USDT",
// "side": "1",
// "vol": "1",
// "price": "2.45455",
// "feeCurrency": "USDT",
// "fee": "0.00147273",
// "timestamp": "1648924557000",
// "profit": "0",
// "category": "1",
// "orderId": "265307163526610432",
// "positionMode": "1",
// "taker": true
// }
// ]
// }
//
trades = this.SafeValue(response, "data")
}
ch <- this.ParseTrades(trades, market, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchOrderTrades
* @description fetch all the trades made from a single order
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#account-trade-list
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#query-the-order-based-on-the-order-number
* @param {string} id order id
* @param {string} symbol unified market symbol
* @param {int} [since] the earliest time in ms to fetch trades for
* @param {int} [limit] the maximum number of trades to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
*/
func (this *mexc) FetchOrderTrades(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes41538 := (<-this.LoadMarkets())
PanicOnError(retRes41538)
var request interface{} = map[string]interface{} {}
var market interface{} = nil
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
}
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchOrderTrades", market, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
var trades interface{} = nil
if IsTrue(IsEqual(marketType, "spot")) {
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchOrderTrades() requires a symbol argument")))
}
AddElementToObject(request, "symbol", GetValue(market, "id"))
AddElementToObject(request, "orderId", id)
trades = (<-this.SpotPrivateGetMyTrades(this.Extend(request, query)))
PanicOnError(trades)
} else {
AddElementToObject(request, "order_id", id)
response:= (<-this.ContractPrivateGetOrderDealDetailsOrderId(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "success": true,
// "code": "0",
// "data": [
// {
// "id": "299444585",
// "symbol": "STEPN_USDT",
// "side": "1",
// "vol": "1",
// "price": "2.45455",
// "feeCurrency": "USDT",
// "fee": "0.00147273",
// "timestamp": "1648924557000",
// "profit": "0",
// "category": "1",
// "orderId": "265307163526610432",
// "positionMode": "1",
// "taker": true
// }
// ]
// }
//
trades = this.SafeValue(response, "data")
}
ch <- this.ParseTrades(trades, market, since, limit, query)
return nil
}()
return ch
}
func (this *mexc) ModifyMarginHelper(symbol interface{}, amount interface{}, addOrReduce 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 positionId interface{} = this.SafeInteger(params, "positionId")
if IsTrue(IsEqual(positionId, nil)) {
panic(ArgumentsRequired(Add(this.Id, " modifyMarginHelper() requires a positionId parameter")))
}
retRes42258 := (<-this.LoadMarkets())
PanicOnError(retRes42258)
var request interface{} = map[string]interface{} {
"positionId": positionId,
"amount": amount,
"type": addOrReduce,
}
response:= (<-this.ContractPrivatePostPositionChangeMargin(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0
// }
ch <- response
return nil
}()
return ch
}
/**
* @method
* @name mexc#reduceMargin
* @description remove margin from a position
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#increase-or-decrease-margin
* @param {string} symbol unified market symbol
* @param {float} amount the amount of margin to remove
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [margin structure]{@link https://docs.ccxt.com/#/?id=reduce-margin-structure}
*/
func (this *mexc) ReduceMargin(symbol interface{}, amount 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
retRes425115 := (<-this.ModifyMarginHelper(symbol, amount, "SUB", params))
PanicOnError(retRes425115)
ch <- retRes425115
return nil
}()
return ch
}
/**
* @method
* @name mexc#addMargin
* @description add margin
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#increase-or-decrease-margin
* @param {string} symbol unified market symbol
* @param {float} amount amount of margin to add
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [margin structure]{@link https://docs.ccxt.com/#/?id=add-margin-structure}
*/
func (this *mexc) AddMargin(symbol interface{}, amount 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
retRes426515 := (<-this.ModifyMarginHelper(symbol, amount, "ADD", params))
PanicOnError(retRes426515)
ch <- retRes426515
return nil
}()
return ch
}
/**
* @method
* @name mexc#setLeverage
* @description set the level of leverage for a market
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#switch-leverage
* @param {float} leverage the rate of leverage
* @param {string} symbol unified market symbol
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} response from the exchange
*/
func (this *mexc) SetLeverage(leverage 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
retRes42798 := (<-this.LoadMarkets())
PanicOnError(retRes42798)
var request interface{} = map[string]interface{} {
"leverage": leverage,
}
var positionId interface{} = this.SafeInteger(params, "positionId")
if IsTrue(IsEqual(positionId, nil)) {
var openType interface{} = this.SafeNumber(params, "openType") // 1 or 2
var positionType interface{} = this.SafeNumber(params, "positionType") // 1 or 2
var market interface{} = Ternary(IsTrue((!IsEqual(symbol, nil))), this.Market(symbol), nil)
if IsTrue(IsTrue(IsTrue((IsEqual(openType, nil))) || IsTrue((IsEqual(positionType, nil)))) || IsTrue((IsEqual(market, nil)))) {
panic(ArgumentsRequired(Add(this.Id, " setLeverage() requires a positionId parameter or a symbol argument with openType and positionType parameters, use openType 1 or 2 for isolated or cross margin respectively, use positionType 1 or 2 for long or short positions")))
} else {
AddElementToObject(request, "openType", openType)
AddElementToObject(request, "symbol", GetValue(market, "id"))
AddElementToObject(request, "positionType", positionType)
}
} else {
AddElementToObject(request, "positionId", positionId)
}
retRes429815 := (<-this.ContractPrivatePostPositionChangeLeverage(this.Extend(request, params)))
PanicOnError(retRes429815)
ch <- retRes429815
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchFundingHistory
* @description fetch the history of funding payments paid and received on this account
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-details-of-user-s-funding-rate
* @param {string} symbol unified market symbol
* @param {int} [since] the earliest time in ms to fetch funding history for
* @param {int} [limit] the maximum number of funding history structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [funding history structure]{@link https://docs.ccxt.com/#/?id=funding-history-structure}
*/
func (this *mexc) 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
retRes43138 := (<-this.LoadMarkets())
PanicOnError(retRes43138)
var market interface{} = nil
var request interface{} = map[string]interface{} {}
if IsTrue(!IsEqual(symbol, nil)) {
market = this.Market(symbol)
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "page_size", limit)
}
response:= (<-this.ContractPrivateGetPositionFundingRecords(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0,
// "data": {
// "pageSize": 20,
// "totalCount": 2,
// "totalPage": 1,
// "currentPage": 1,
// "resultList": [
// {
// "id": 7423910,
// "symbol": "BTC_USDT",
// "positionType": 1,
// "positionValue": 29.30024,
// "funding": 0.00076180624,
// "rate": -0.000026,
// "settleTime": 1643299200000
// },
// {
// "id": 7416473,
// "symbol": "BTC_USDT",
// "positionType": 1,
// "positionValue": 28.9188,
// "funding": 0.0014748588,
// "rate": -0.000051,
// "settleTime": 1643270400000
// }
// ]
// }
// }
//
var data interface{} = this.SafeValue(response, "data", map[string]interface{} {})
var resultList interface{} = this.SafeValue(data, "resultList", []interface{}{})
var result interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(resultList)); i++ {
var entry interface{} = GetValue(resultList, i)
var timestamp interface{} = this.SafeInteger(entry, "settleTime")
AppendToArray(&result,map[string]interface{} {
"info": entry,
"symbol": symbol,
"code": nil,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"id": this.SafeNumber(entry, "id"),
"amount": this.SafeNumber(entry, "funding"),
})
}
ch <- result
return nil
}()
return ch
}
func (this *mexc) ParseFundingRate(contract interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "symbol": "BTC_USDT",
// "fundingRate": 0.000014,
// "maxFundingRate": 0.003,
// "minFundingRate": -0.003,
// "collectCycle": 8,
// "nextSettleTime": 1643241600000,
// "timestamp": 1643240373359
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var nextFundingRate interface{} = this.SafeNumber(contract, "fundingRate")
var nextFundingTimestamp interface{} = this.SafeInteger(contract, "nextSettleTime")
var marketId interface{} = this.SafeString(contract, "symbol")
var symbol interface{} = this.SafeSymbol(marketId, market, nil, "contract")
var timestamp interface{} = this.SafeInteger(contract, "timestamp")
var interval interface{} = this.SafeString(contract, "collectCycle")
var intervalString interface{} = nil
if IsTrue(!IsEqual(interval, nil)) {
intervalString = Add(interval, "h")
}
return map[string]interface{} {
"info": contract,
"symbol": symbol,
"markPrice": nil,
"indexPrice": nil,
"interestRate": nil,
"estimatedSettlePrice": nil,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"fundingRate": nextFundingRate,
"fundingTimestamp": nextFundingTimestamp,
"fundingDatetime": this.Iso8601(nextFundingTimestamp),
"nextFundingRate": nil,
"nextFundingTimestamp": nil,
"nextFundingDatetime": nil,
"previousFundingRate": nil,
"previousFundingTimestamp": nil,
"previousFundingDatetime": nil,
"interval": intervalString,
}
}
/**
* @method
* @name mexc#fetchFundingInterval
* @description fetch the current funding rate interval
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-contract-funding-rate
* @param {string} symbol unified market symbol
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
*/
func (this *mexc) FetchFundingInterval(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
retRes443415 := (<-this.FetchFundingRate(symbol, params))
PanicOnError(retRes443415)
ch <- retRes443415
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchFundingRate
* @description fetch the current funding rate
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-contract-funding-rate
* @param {string} symbol unified market symbol
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
*/
func (this *mexc) FetchFundingRate(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
retRes44478 := (<-this.LoadMarkets())
PanicOnError(retRes44478)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
response:= (<-this.ContractPublicGetFundingRateSymbol(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0,
// "data": {
// "symbol": "BTC_USDT",
// "fundingRate": 0.000014,
// "maxFundingRate": 0.003,
// "minFundingRate": -0.003,
// "collectCycle": 8,
// "nextSettleTime": 1643241600000,
// "timestamp": 1643240373359
// }
// }
//
var result interface{} = this.SafeValue(response, "data", map[string]interface{} {})
ch <- this.ParseFundingRate(result, market)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchFundingRateHistory
* @description fetches historical funding rate prices
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-contract-funding-rate-history
* @param {string} symbol unified symbol of the market to fetch the funding rate history for
* @param {int} [since] not used by mexc, but filtered internally by ccxt
* @param {int} [limit] mexc limit is page_size default 20, maximum is 100
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure}
*/
func (this *mexc) 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
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " fetchFundingRateHistory() requires a symbol argument")))
}
retRes44878 := (<-this.LoadMarkets())
PanicOnError(retRes44878)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "page_size", limit)
}
response:= (<-this.ContractPublicGetFundingRateHistory(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0,
// "data": {
// "pageSize": 2,
// "totalCount": 21,
// "totalPage": 11,
// "currentPage": 1,
// "resultList": [
// {
// "symbol": "BTC_USDT",
// "fundingRate": 0.000266,
// "settleTime": 1609804800000
// },
// {
// "symbol": "BTC_USDT",
// "fundingRate": 0.00029,
// "settleTime": 1609776000000
// }
// ]
// }
// }
//
var data interface{} = this.SafeValue(response, "data")
var result interface{} = this.SafeValue(data, "resultList", []interface{}{})
var rates interface{} = []interface{}{}
for i := 0; IsLessThan(i, GetArrayLength(result)); i++ {
var entry interface{} = GetValue(result, i)
var marketId interface{} = this.SafeString(entry, "symbol")
var symbolInner interface{} = this.SafeSymbol(marketId)
var timestamp interface{} = this.SafeInteger(entry, "settleTime")
AppendToArray(&rates,map[string]interface{} {
"info": entry,
"symbol": symbolInner,
"fundingRate": this.SafeNumber(entry, "fundingRate"),
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
})
}
var sorted interface{} = this.SortBy(rates, "timestamp")
ch <- this.FilterBySymbolSinceLimit(sorted, GetValue(market, "symbol"), since, limit)
return nil
}()
return ch
}
/**
* @method
* @name mexc#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://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-contract-information
* @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 *mexc) 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
retRes45528 := (<-this.LoadMarkets())
PanicOnError(retRes45528)
symbols = this.MarketSymbols(symbols, "swap", true, true)
response:= (<-this.ContractPublicGetDetail(params))
PanicOnError(response)
//
// {
// "success":true,
// "code":0,
// "data":[
// {
// "symbol": "BTC_USDT",
// "displayName": "BTC_USDT永续",
// "displayNameEn": "BTC_USDT SWAP",
// "positionOpenType": 3,
// "baseCoin": "BTC",
// "quoteCoin": "USDT",
// "settleCoin": "USDT",
// "contractSize": 0.0001,
// "minLeverage": 1,
// "maxLeverage": 125,
// "priceScale": 2,
// "volScale": 0,
// "amountScale": 4,
// "priceUnit": 0.5,
// "volUnit": 1,
// "minVol": 1,
// "maxVol": 1000000,
// "bidLimitPriceRate": 0.1,
// "askLimitPriceRate": 0.1,
// "takerFeeRate": 0.0006,
// "makerFeeRate": 0.0002,
// "maintenanceMarginRate": 0.004,
// "initialMarginRate": 0.008,
// "riskBaseVol": 10000,
// "riskIncrVol": 200000,
// "riskIncrMmr": 0.004,
// "riskIncrImr": 0.004,
// "riskLevelLimit": 5,
// "priceCoefficientVariation": 0.1,
// "indexOrigin": ["BINANCE","GATEIO","HUOBI","MXC"],
// "state": 0, // 0 enabled, 1 delivery, 2 completed, 3 offline, 4 pause
// "isNew": false,
// "isHot": true,
// "isHidden": false
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data")
ch <- this.ParseLeverageTiers(data, symbols, "symbol")
return nil
}()
return ch
}
func (this *mexc) ParseMarketLeverageTiers(info interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "symbol": "BTC_USDT",
// "displayName": "BTC_USDT永续",
// "displayNameEn": "BTC_USDT SWAP",
// "positionOpenType": 3,
// "baseCoin": "BTC",
// "quoteCoin": "USDT",
// "settleCoin": "USDT",
// "contractSize": 0.0001,
// "minLeverage": 1,
// "maxLeverage": 125,
// "priceScale": 2,
// "volScale": 0,
// "amountScale": 4,
// "priceUnit": 0.5,
// "volUnit": 1,
// "minVol": 1,
// "maxVol": 1000000,
// "bidLimitPriceRate": 0.1,
// "askLimitPriceRate": 0.1,
// "takerFeeRate": 0.0006,
// "makerFeeRate": 0.0002,
// "maintenanceMarginRate": 0.004,
// "initialMarginRate": 0.008,
// "riskBaseVol": 10000,
// "riskIncrVol": 200000,
// "riskIncrMmr": 0.004,
// "riskIncrImr": 0.004,
// "riskLevelLimit": 5,
// "priceCoefficientVariation": 0.1,
// "indexOrigin": ["BINANCE","GATEIO","HUOBI","MXC"],
// "state": 0, // 0 enabled, 1 delivery, 2 completed, 3 offline, 4 pause
// "isNew": false,
// "isHot": true,
// "isHidden": false
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
var marketId interface{} = this.SafeString(info, "symbol")
var maintenanceMarginRate interface{} = this.SafeString(info, "maintenanceMarginRate")
var initialMarginRate interface{} = this.SafeString(info, "initialMarginRate")
var maxVol interface{} = this.SafeString(info, "maxVol")
var riskIncrVol interface{} = this.SafeString(info, "riskIncrVol")
var riskIncrMmr interface{} = this.SafeString(info, "riskIncrMmr")
var riskIncrImr interface{} = this.SafeString(info, "riskIncrImr")
var floor interface{} = "0"
var tiers interface{} = []interface{}{}
var quoteId interface{} = this.SafeString(info, "quoteCoin")
if IsTrue(IsEqual(riskIncrVol, "0")) {
return []interface{}{map[string]interface{} {
"tier": 0,
"symbol": this.SafeSymbol(marketId, market, nil, "contract"),
"currency": this.SafeCurrencyCode(quoteId),
"minNotional": nil,
"maxNotional": nil,
"maintenanceMarginRate": nil,
"maxLeverage": this.SafeNumber(info, "maxLeverage"),
"info": info,
}}
}
for Precise.StringLt(floor, maxVol) {
var cap interface{} = Precise.StringAdd(floor, riskIncrVol)
AppendToArray(&tiers,map[string]interface{} {
"tier": this.ParseNumber(Precise.StringDiv(cap, riskIncrVol)),
"symbol": this.SafeSymbol(marketId, market, nil, "contract"),
"currency": this.SafeCurrencyCode(quoteId),
"minNotional": this.ParseNumber(floor),
"maxNotional": this.ParseNumber(cap),
"maintenanceMarginRate": this.ParseNumber(maintenanceMarginRate),
"maxLeverage": this.ParseNumber(Precise.StringDiv("1", initialMarginRate)),
"info": info,
})
initialMarginRate = Precise.StringAdd(initialMarginRate, riskIncrImr)
maintenanceMarginRate = Precise.StringAdd(maintenanceMarginRate, riskIncrMmr)
floor = cap
}
return tiers
}
func (this *mexc) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// coin: "USDT",
// network: "BNB Smart Chain(BEP20)",
// address: "0x0d48003e0c27c5de62b97c9b4cdb31fdd29da619",
// memo: null
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var address interface{} = this.SafeString(depositAddress, "address")
var currencyId interface{} = this.SafeString(depositAddress, "coin")
var networkId interface{} = this.SafeString(depositAddress, "netWork")
this.CheckAddress(address)
return map[string]interface{} {
"info": depositAddress,
"currency": this.SafeCurrencyCode(currencyId, currency),
"network": this.NetworkIdToCode(networkId, currencyId),
"address": address,
"tag": this.SafeString(depositAddress, "memo"),
}
}
/**
* @method
* @name mexc#fetchDepositAddressesByNetwork
* @description fetch a dictionary of addresses for a currency, indexed by network
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#deposit-address-supporting-network
* @param {string} code unified currency code of the currency for the deposit address
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a dictionary of [address structures]{@link https://docs.ccxt.com/#/?id=address-structure} indexed by the network
*/
func (this *mexc) FetchDepositAddressesByNetwork(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
retRes47188 := (<-this.LoadMarkets())
PanicOnError(retRes47188)
var currency interface{} = this.Currency(code)
var request interface{} = map[string]interface{} {
"coin": GetValue(currency, "id"),
}
var networkCode interface{} = this.SafeString(params, "network")
var networkId interface{} = nil
if IsTrue(!IsEqual(networkCode, nil)) {
// createDepositAddress and fetchDepositAddress use a different network-id compared to withdraw
var networkUnified interface{} = this.NetworkIdToCode(networkCode, code)
var networks interface{} = this.SafeDict(currency, "networks", map[string]interface{} {})
if IsTrue(InOp(networks, networkUnified)) {
var network interface{} = this.SafeDict(networks, networkUnified, map[string]interface{} {})
var networkInfo interface{} = this.SafeValue(network, "info", map[string]interface{} {})
networkId = this.SafeString(networkInfo, "network")
} else {
networkId = this.NetworkCodeToId(networkCode, code)
}
}
if IsTrue(!IsEqual(networkId, nil)) {
AddElementToObject(request, "network", networkId)
}
params = this.Omit(params, "network")
response:= (<-this.SpotPrivateGetCapitalDepositAddress(this.Extend(request, params)))
PanicOnError(response)
//
// [
// {
// coin: "USDT",
// network: "BNB Smart Chain(BEP20)",
// address: "0x0d48003e0c27c5de62b97c9b4cdb31fdd29da619",
// memo: null
// }
// ...
// ]
//
var addressStructures interface{} = this.ParseDepositAddresses(response, nil, false)
ch <- this.IndexBy(addressStructures, "network")
return nil
}()
return ch
}
/**
* @method
* @name mexc#createDepositAddress
* @description create a currency deposit address
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#generate-deposit-address-supporting-network
* @param {string} code unified currency code of the currency for the deposit address
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.network] the blockchain network name
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
*/
func (this *mexc) CreateDepositAddress(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
retRes47688 := (<-this.LoadMarkets())
PanicOnError(retRes47688)
var currency interface{} = this.Currency(code)
var request interface{} = map[string]interface{} {
"coin": GetValue(currency, "id"),
}
var networkCode interface{} = this.SafeString(params, "network")
if IsTrue(IsEqual(networkCode, nil)) {
panic(ArgumentsRequired(Add(this.Id, " createDepositAddress requires a `network` parameter")))
}
// createDepositAddress and fetchDepositAddress use a different network-id compared to withdraw
var networkId interface{} = nil
var networkUnified interface{} = this.NetworkIdToCode(networkCode, code)
var networks interface{} = this.SafeDict(currency, "networks", map[string]interface{} {})
if IsTrue(InOp(networks, networkUnified)) {
var network interface{} = this.SafeDict(networks, networkUnified, map[string]interface{} {})
var networkInfo interface{} = this.SafeValue(network, "info", map[string]interface{} {})
networkId = this.SafeString(networkInfo, "network")
} else {
networkId = this.NetworkCodeToId(networkCode, code)
}
if IsTrue(!IsEqual(networkId, nil)) {
AddElementToObject(request, "network", networkId)
}
params = this.Omit(params, "network")
response:= (<-this.SpotPrivatePostCapitalDepositAddress(this.Extend(request, params)))
PanicOnError(response)
// {
// "coin": "EOS",
// "network": "EOS",
// "address": "zzqqqqqqqqqq",
// "memo": "MX10068"
// }
ch <- this.ParseDepositAddress(response, currency)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchDepositAddress
* @description fetch the deposit address for a currency associated with this account
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#deposit-address-supporting-network
* @param {string} code unified currency code
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.network] the chain of currency, this only apply for multi-chain currency, and there is no need for single chain currency
* @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
*/
func (this *mexc) 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 network interface{} = this.SafeString(params, "network")
var addressStructures interface{} = (<-this.FetchDepositAddressesByNetwork(code, params))
var result interface{} = nil
if IsTrue(!IsEqual(network, nil)) {
result = this.SafeDict(addressStructures, this.NetworkIdToCode(network, code))
} else {
var options interface{} = this.SafeDict(this.Options, "defaultNetworks")
var defaultNetworkForCurrency interface{} = this.SafeString(options, code)
if IsTrue(!IsEqual(defaultNetworkForCurrency, nil)) {
result = this.SafeDict(addressStructures, defaultNetworkForCurrency)
} else {
var keys interface{} = ObjectKeys(addressStructures)
var key interface{} = this.SafeString(keys, 0)
result = this.SafeDict(addressStructures, key)
}
}
if IsTrue(IsEqual(result, nil)) {
panic(InvalidAddress(Add(Add(Add(Add(Add(this.Id, " fetchDepositAddress() cannot find a deposit address for "), code), ", and network"), network), "consider creating one using .createDepositAddress() method or in MEXC website")))
}
ch <- result
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchDeposits
* @description fetch all deposits made to an account
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#deposit-history-supporting-network
* @param {string} code unified currency code
* @param {int} [since] the earliest time in ms to fetch deposits for
* @param {int} [limit] the maximum number of deposits structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
*/
func (this *mexc) 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
retRes48478 := (<-this.LoadMarkets())
PanicOnError(retRes48478)
var request interface{} = map[string]interface{} {}
var currency interface{} = nil
if IsTrue(!IsEqual(code, nil)) {
currency = this.Currency(code)
AddElementToObject(request, "coin", GetValue(currency, "id"))
// currently mexc does not have network names unified so for certain things we might need TRX or TRC-20
// due to that I'm applying the network parameter directly so the user can control it on its side
var rawNetwork interface{} = this.SafeString(params, "network")
if IsTrue(!IsEqual(rawNetwork, nil)) {
params = this.Omit(params, "network")
AddElementToObject(request, "coin", Add(Add(GetValue(request, "coin"), "-"), rawNetwork))
}
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since)
}
if IsTrue(!IsEqual(limit, nil)) {
if IsTrue(IsGreaterThan(limit, 1000)) {
panic(ExchangeError("This exchange supports a maximum limit of 1000"))
}
AddElementToObject(request, "limit", limit)
}
response:= (<-this.SpotPrivateGetCapitalDepositHisrec(this.Extend(request, params)))
PanicOnError(response)
//
// [
// {
// "amount": "10",
// "coin": "USDC-TRX",
// "network": "TRX",
// "status": "5",
// "address": "TSMcEDDvkqY9dz8RkFnrS86U59GwEZjfvh",
// "txId": "51a8f49e6f03f2c056e71fe3291aa65e1032880be855b65cecd0595a1b8af95b",
// "insertTime": "1664805021000",
// "unlockConfirm": "200",
// "confirmTimes": "203",
// "memo": "xxyy1122"
// }
// ]
//
ch <- this.ParseTransactions(response, currency, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchWithdrawals
* @description fetch all withdrawals made from an account
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#withdraw-history-supporting-network
* @param {string} code unified currency code
* @param {int} [since] the earliest time in ms to fetch withdrawals for
* @param {int} [limit] the maximum number of withdrawals structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
*/
func (this *mexc) 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
retRes49088 := (<-this.LoadMarkets())
PanicOnError(retRes49088)
var request interface{} = map[string]interface{} {}
var currency interface{} = nil
if IsTrue(!IsEqual(code, nil)) {
currency = this.Currency(code)
AddElementToObject(request, "coin", GetValue(currency, "id"))
}
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "startTime", since)
}
if IsTrue(!IsEqual(limit, nil)) {
if IsTrue(IsGreaterThan(limit, 1000)) {
panic(ExchangeError("This exchange supports a maximum limit of 1000"))
}
AddElementToObject(request, "limit", limit)
}
response:= (<-this.SpotPrivateGetCapitalWithdrawHistory(this.Extend(request, params)))
PanicOnError(response)
//
// [
// {
// "id": "adcd1c8322154de691b815eedcd10c42",
// "txId": "0xc8c918cd69b2246db493ef6225a72ffdc664f15b08da3e25c6879b271d05e9d0",
// "coin": "USDC-MATIC",
// "network": "MATIC",
// "address": "0xeE6C7a415995312ED52c53a0f8f03e165e0A5D62",
// "amount": "2",
// "transferType": "0",
// "status": "7",
// "transactionFee": "1",
// "confirmNo": null,
// "applyTime": "1664882739000",
// "remark": '',
// "memo": null
// }
// ]
//
ch <- this.ParseTransactions(response, currency, since, limit)
return nil
}()
return ch
}
func (this *mexc) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} {
//
// fetchDeposits
//
// {
// "amount": "10",
// "coin": "USDC-TRX",
// "network": "TRX",
// "status": "5",
// "address": "TSMcEDDvkqY9dz8RkFnrS86U59GwEZjfvh",
// "txId": "51a8f49e6f03f2c056e71fe3291aa65e1032880be855b65cecd0595a1b8af95b",
// "insertTime": "1664805021000",
// "unlockConfirm": "200",
// "confirmTimes": "203",
// "memo": "xxyy1122"
// }
//
// fetchWithdrawals
//
// {
// "id": "adcd1c8322154de691b815eedcd10c42",
// "txId": "0xc8c918cd69b2246db493ef6225a72ffdc664f15b08da3e25c6879b271d05e9d0",
// "coin": "USDC-MATIC",
// "network": "MATIC",
// "address": "0xeE6C7a415995312ED52c53a0f8f03e165e0A5D62",
// "amount": "2",
// "transferType": "0",
// "status": "7",
// "transactionFee": "1",
// "confirmNo": null,
// "applyTime": "1664882739000",
// "remark": '',
// "memo": null
// }
//
// withdraw
//
// {
// "id":"25fb2831fb6d4fc7aa4094612a26c81d"
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var id interface{} = this.SafeString(transaction, "id")
var typeVar interface{} = Ternary(IsTrue((IsEqual(id, nil))), "deposit", "withdrawal")
var timestamp interface{} = this.SafeInteger2(transaction, "insertTime", "applyTime")
var currencyId interface{} = nil
var currencyWithNetwork interface{} = this.SafeString(transaction, "coin")
if IsTrue(!IsEqual(currencyWithNetwork, nil)) {
currencyId = GetValue(Split(currencyWithNetwork, "-"), 0)
}
var network interface{} = nil
var rawNetwork interface{} = this.SafeString(transaction, "network")
if IsTrue(!IsEqual(rawNetwork, nil)) {
network = this.NetworkIdToCode(rawNetwork)
}
var code interface{} = this.SafeCurrencyCode(currencyId, currency)
var status interface{} = this.ParseTransactionStatusByType(this.SafeString(transaction, "status"), typeVar)
var amountString interface{} = this.SafeString(transaction, "amount")
var address interface{} = this.SafeString(transaction, "address")
var txid interface{} = this.SafeString(transaction, "txId")
var fee interface{} = nil
var feeCostString interface{} = this.SafeString(transaction, "transactionFee")
if IsTrue(!IsEqual(feeCostString, nil)) {
fee = map[string]interface{} {
"cost": this.ParseNumber(feeCostString),
"currency": code,
}
}
if IsTrue(IsEqual(typeVar, "withdrawal")) {
// mexc withdrawal amount includes the fee
amountString = Precise.StringSub(amountString, feeCostString)
}
return map[string]interface{} {
"info": transaction,
"id": id,
"txid": txid,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"network": network,
"address": address,
"addressTo": address,
"addressFrom": nil,
"tag": this.SafeString(transaction, "memo"),
"tagTo": nil,
"tagFrom": nil,
"type": typeVar,
"amount": this.ParseNumber(amountString),
"currency": code,
"status": status,
"updated": nil,
"comment": nil,
"internal": nil,
"fee": fee,
}
}
func (this *mexc) ParseTransactionStatusByType(status interface{}, optionalArgs ...interface{}) interface{} {
typeVar := GetArg(optionalArgs, 0, nil)
_ = typeVar
var statusesByType interface{} = map[string]interface{} {
"deposit": map[string]interface{} {
"1": "failed",
"2": "pending",
"3": "pending",
"4": "pending",
"5": "ok",
"6": "pending",
"7": "failed",
},
"withdrawal": map[string]interface{} {
"1": "pending",
"2": "pending",
"3": "pending",
"4": "pending",
"5": "pending",
"6": "pending",
"7": "ok",
"8": "failed",
"9": "canceled",
"10": "pending",
},
}
var statuses interface{} = this.SafeValue(statusesByType, typeVar, map[string]interface{} {})
return this.SafeString(statuses, status, status)
}
/**
* @method
* @name mexc#fetchPosition
* @description fetch data on a single open contract trade position
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-user-s-history-position-information
* @param {string} symbol unified market symbol of the market the position is held in, default is undefined
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
*/
func (this *mexc) FetchPosition(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
retRes50868 := (<-this.LoadMarkets())
PanicOnError(retRes50868)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
response:= (<-this.FetchPositions(nil, this.Extend(request, params)))
PanicOnError(response)
ch <- this.SafeValue(response, 0)
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchPositions
* @description fetch all open positions
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-user-s-history-position-information
* @param {string[]|undefined} symbols list of unified market symbols
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
*/
func (this *mexc) FetchPositions(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
retRes51058 := (<-this.LoadMarkets())
PanicOnError(retRes51058)
response:= (<-this.ContractPrivateGetPositionOpenPositions(params))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0,
// "data": [
// {
// "positionId": 1394650,
// "symbol": "ETH_USDT",
// "positionType": 1,
// "openType": 1,
// "state": 1,
// "holdVol": 1,
// "frozenVol": 0,
// "closeVol": 0,
// "holdAvgPrice": 1217.3,
// "openAvgPrice": 1217.3,
// "closeAvgPrice": 0,
// "liquidatePrice": 1211.2,
// "oim": 0.1290338,
// "im": 0.1290338,
// "holdFee": 0,
// "realised": -0.0073,
// "leverage": 100,
// "createTime": 1609991676000,
// "updateTime": 1609991676000,
// "autoAddIm": false
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParsePositions(data, symbols)
return nil
}()
return ch
}
func (this *mexc) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{} {
//
// fetchPositions
//
// {
// "positionId": 1394650,
// "symbol": "ETH_USDT",
// "positionType": 1,
// "openType": 1,
// "state": 1,
// "holdVol": 1,
// "frozenVol": 0,
// "closeVol": 0,
// "holdAvgPrice": 1217.3,
// "openAvgPrice": 1217.3,
// "closeAvgPrice": 0,
// "liquidatePrice": 1211.2,
// "oim": 0.1290338,
// "im": 0.1290338,
// "holdFee": 0,
// "realised": -0.0073,
// "leverage": 100,
// "createTime": 1609991676000,
// "updateTime": 1609991676000,
// "autoAddIm": false
// }
//
// fetchPositionsHistory
//
// {
// positionId: '390281084',
// symbol: 'RVN_USDT',
// positionType: '1',
// openType: '2',
// state: '3',
// holdVol: '0',
// frozenVol: '0',
// closeVol: '1141',
// holdAvgPrice: '0.03491',
// holdAvgPriceFullyScale: '0.03491',
// openAvgPrice: '0.03491',
// openAvgPriceFullyScale: '0.03491',
// closeAvgPrice: '0.03494',
// liquidatePrice: '0.03433',
// oim: '0',
// im: '0',
// holdFee: '0',
// realised: '0.1829',
// leverage: '50',
// createTime: '1711512408000',
// updateTime: '1711512553000',
// autoAddIm: false,
// version: '4',
// profitRatio: '0.0227',
// newOpenAvgPrice: '0.03491',
// newCloseAvgPrice: '0.03494',
// closeProfitLoss: '0.3423',
// fee: '0.1593977',
// positionShowStatus: 'CLOSED'
// }
//
market := GetArg(optionalArgs, 0, nil)
_ = market
market = this.SafeMarket(this.SafeString(position, "symbol"), market)
var symbol interface{} = GetValue(market, "symbol")
var contracts interface{} = this.SafeString(position, "holdVol")
var entryPrice interface{} = this.SafeNumber(position, "openAvgPrice")
var initialMargin interface{} = this.SafeString(position, "im")
var rawSide interface{} = this.SafeString(position, "positionType")
var side interface{} = Ternary(IsTrue((IsEqual(rawSide, "1"))), "long", "short")
var openType interface{} = this.SafeString(position, "margin_mode")
var marginType interface{} = Ternary(IsTrue((IsEqual(openType, "1"))), "isolated", "cross")
var leverage interface{} = this.SafeNumber(position, "leverage")
var liquidationPrice interface{} = this.SafeNumber(position, "liquidatePrice")
var timestamp interface{} = this.SafeInteger(position, "updateTime")
return this.SafePosition(map[string]interface{} {
"info": position,
"id": nil,
"symbol": symbol,
"contracts": this.ParseNumber(contracts),
"contractSize": nil,
"entryPrice": entryPrice,
"collateral": nil,
"side": side,
"unrealizedPnl": nil,
"leverage": this.ParseNumber(leverage),
"percentage": nil,
"marginMode": marginType,
"notional": nil,
"markPrice": nil,
"lastPrice": nil,
"liquidationPrice": liquidationPrice,
"initialMargin": this.ParseNumber(initialMargin),
"initialMarginPercentage": nil,
"maintenanceMargin": nil,
"maintenanceMarginPercentage": nil,
"marginRatio": nil,
"timestamp": timestamp,
"datetime": this.Iso8601(timestamp),
"hedged": nil,
"stopLossPrice": nil,
"takeProfitPrice": nil,
"lastUpdateTimestamp": nil,
})
}
/**
* @method
* @name mexc#fetchTransfer
* @description fetches a transfer
* @see https://mexcdevelop.github.io/apidocs/spot_v2_en/#internal-assets-transfer-order-inquiry
* @param {string} id transfer id
* @param {string} [code] not used by mexc fetchTransfer
* @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 *mexc) FetchTransfer(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
code := GetArg(optionalArgs, 0, nil)
_ = code
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchTransfer", nil, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
retRes52578 := (<-this.LoadMarkets())
PanicOnError(retRes52578)
if IsTrue(IsEqual(marketType, "spot")) {
var request interface{} = map[string]interface{} {
"transact_id": id,
}
response:= (<-this.Spot2PrivateGetAssetInternalTransferInfo(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "code": "200",
// "data": {
// "currency": "USDT",
// "amount": "1",
// "transact_id": "954877a2ef54499db9b28a7cf9ebcf41",
// "from": "MAIN",
// "to": "CONTRACT",
// "transact_state": "SUCCESS"
// }
// }
//
var data interface{} = this.SafeDict(response, "data", map[string]interface{} {})
ch <- this.ParseTransfer(data)
return nil
} else if IsTrue(IsEqual(marketType, "swap")) {
panic(BadRequest(Add(Add(this.Id, " fetchTransfer() is not supported for "), marketType)))
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchTransfers
* @description fetch a history of internal transfers made on an account
* @see https://mexcdevelop.github.io/apidocs/spot_v2_en/#get-internal-assets-transfer-records
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-user-39-s-asset-transfer-records
* @param {string} code unified currency code of the currency transferred
* @param {int} [since] the earliest time in ms to fetch transfers for
* @param {int} [limit] the maximum number of transfers structures to retrieve
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [transfer structures]{@link https://docs.ccxt.com/#/?id=transfer-structure}
*/
func (this *mexc) FetchTransfers(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
marketTypequeryVariable := this.HandleMarketTypeAndParams("fetchTransfers", nil, params);
marketType := GetValue(marketTypequeryVariable,0);
query := GetValue(marketTypequeryVariable,1)
retRes52988 := (<-this.LoadMarkets())
PanicOnError(retRes52988)
var request interface{} = map[string]interface{} {}
var currency interface{} = nil
var resultList interface{} = nil
if IsTrue(!IsEqual(code, nil)) {
currency = this.Currency(code)
AddElementToObject(request, "currency", GetValue(currency, "id"))
}
if IsTrue(IsEqual(marketType, "spot")) {
if IsTrue(!IsEqual(since, nil)) {
AddElementToObject(request, "start_time", since)
}
if IsTrue(!IsEqual(limit, nil)) {
if IsTrue(IsGreaterThan(limit, 50)) {
panic(ExchangeError("This exchange supports a maximum limit of 50"))
}
AddElementToObject(request, "page-size", limit)
}
response:= (<-this.Spot2PrivateGetAssetInternalTransferRecord(this.Extend(request, query)))
PanicOnError(response)
//
// {
// "code": "200",
// "data": {
// "total_page": "1",
// "total_size": "5",
// "result_list": [{
// "currency": "USDT",
// "amount": "1",
// "transact_id": "954877a2ef54499db9b28a7cf9ebcf41",
// "from": "MAIN",
// "to": "CONTRACT",
// "transact_state": "SUCCESS"
// },
// ...
// ]
// }
// }
//
var data interface{} = this.SafeValue(response, "data", map[string]interface{} {})
resultList = this.SafeValue(data, "result_list", []interface{}{})
} else if IsTrue(IsEqual(marketType, "swap")) {
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "page_size", limit)
}
response:= (<-this.ContractPrivateGetAccountTransferRecord(this.Extend(request, query)))
PanicOnError(response)
var data interface{} = this.SafeValue(response, "data")
resultList = this.SafeValue(data, "resultList")
}
ch <- this.ParseTransfers(resultList, currency, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name mexc#transfer
* @description transfer currency internally between wallets on the same account
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#user-universal-transfer
* @param {string} code unified currency code
* @param {float} amount amount to transfer
* @param {string} fromAccount account to transfer from
* @param {string} toAccount account to transfer to
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.symbol] market symbol required for margin account transfers eg:BTCUSDT
* @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
*/
func (this *mexc) 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)
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
retRes53878 := (<-this.LoadMarkets())
PanicOnError(retRes53878)
var currency interface{} = this.Currency(code)
var accounts interface{} = map[string]interface{} {
"spot": "SPOT",
"swap": "FUTURES",
"margin": "ISOLATED_MARGIN",
}
var fromId interface{} = this.SafeString(accounts, fromAccount)
var toId interface{} = this.SafeString(accounts, toAccount)
if IsTrue(IsEqual(fromId, nil)) {
var keys interface{} = ObjectKeys(accounts)
panic(ExchangeError(Add(Add(this.Id, " fromAccount must be one of "), Join(keys, ", "))))
}
if IsTrue(IsEqual(toId, nil)) {
var keys interface{} = ObjectKeys(accounts)
panic(ExchangeError(Add(Add(this.Id, " toAccount must be one of "), Join(keys, ", "))))
}
var request interface{} = map[string]interface{} {
"asset": GetValue(currency, "id"),
"amount": amount,
"fromAccountType": fromId,
"toAccountType": toId,
}
if IsTrue(IsTrue((IsEqual(fromId, "ISOLATED_MARGIN"))) || IsTrue((IsEqual(toId, "ISOLATED_MARGIN")))) {
var symbol interface{} = this.SafeString(params, "symbol")
params = this.Omit(params, "symbol")
if IsTrue(IsEqual(symbol, nil)) {
panic(ArgumentsRequired(Add(this.Id, " transfer() requires a symbol argument for isolated margin")))
}
var market interface{} = this.Market(symbol)
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
response:= (<-this.SpotPrivatePostCapitalTransfer(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "tranId": "ebb06123e6a64f4ab234b396c548d57e"
// }
//
var transaction interface{} = this.ParseTransfer(response, currency)
ch <- this.Extend(transaction, map[string]interface{} {
"amount": amount,
"fromAccount": fromAccount,
"toAccount": toAccount,
})
return nil
}()
return ch
}
func (this *mexc) ParseTransfer(transfer interface{}, optionalArgs ...interface{}) interface{} {
//
// spot: fetchTransfer
//
// {
// "currency": "USDT",
// "amount": "1",
// "transact_id": "b60c1df8e7b24b268858003f374ecb75",
// "from": "MAIN",
// "to": "CONTRACT",
// "transact_state": "WAIT"
// }
//
// swap: fetchTransfer
//
// {
// "currency": "USDT",
// "amount": "22.90213135",
// "txid": "fa8a1e7bf05940a3b7025856dc48d025",
// "id": "2980812",
// "type": "IN",
// "state": "SUCCESS",
// "createTime": "1648849076000",
// "updateTime": "1648849076000"
// }
//
// transfer
//
// {
// "tranId": "ebb06123e6a64f4ab234b396c548d57e"
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var currencyId interface{} = this.SafeString(transfer, "currency")
var id interface{} = this.SafeStringN(transfer, []interface{}{"transact_id", "txid", "tranId"})
var timestamp interface{} = this.SafeInteger(transfer, "createTime")
var datetime interface{} = Ternary(IsTrue((!IsEqual(timestamp, nil))), this.Iso8601(timestamp), nil)
var direction interface{} = this.SafeString(transfer, "type")
var accountFrom interface{} = nil
var accountTo interface{} = nil
if IsTrue(!IsEqual(direction, nil)) {
accountFrom = Ternary(IsTrue((IsEqual(direction, "IN"))), "MAIN", "CONTRACT")
accountTo = Ternary(IsTrue((IsEqual(direction, "IN"))), "CONTRACT", "MAIN")
} else {
accountFrom = this.SafeString(transfer, "from")
accountTo = this.SafeString(transfer, "to")
}
return map[string]interface{} {
"info": transfer,
"id": id,
"timestamp": timestamp,
"datetime": datetime,
"currency": this.SafeCurrencyCode(currencyId, currency),
"amount": this.SafeNumber(transfer, "amount"),
"fromAccount": this.ParseAccountId(accountFrom),
"toAccount": this.ParseAccountId(accountTo),
"status": this.ParseTransferStatus(this.SafeString2(transfer, "transact_state", "state")),
}
}
func (this *mexc) ParseAccountId(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"MAIN": "spot",
"CONTRACT": "swap",
}
return this.SafeString(statuses, status, status)
}
func (this *mexc) ParseTransferStatus(status interface{}) interface{} {
var statuses interface{} = map[string]interface{} {
"SUCCESS": "ok",
"FAILED": "failed",
"WAIT": "pending",
}
return this.SafeString(statuses, status, status)
}
/**
* @method
* @name mexc#withdraw
* @description make a withdrawal
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#withdraw-new
* @param {string} code unified currency code
* @param {float} amount the amount to withdraw
* @param {string} address the address to withdraw to
* @param {string} tag
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
*/
func (this *mexc) 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
retRes55228 := (<-this.LoadMarkets())
PanicOnError(retRes55228)
var currency interface{} = this.Currency(code)
tagparamsVariable := this.HandleWithdrawTagAndParams(tag, params);
tag = GetValue(tagparamsVariable,0);
params = GetValue(tagparamsVariable,1)
var networks interface{} = this.SafeDict(this.Options, "networks", map[string]interface{} {})
var network interface{} = this.SafeString2(params, "network", "netWork") // this line allows the user to specify either ERC20 or ETH
network = this.SafeString(networks, network, network) // handle ETH > ERC-20 alias
network = this.NetworkCodeToId(network, GetValue(currency, "code"))
this.CheckAddress(address)
var request interface{} = map[string]interface{} {
"coin": GetValue(currency, "id"),
"address": address,
"amount": amount,
}
if IsTrue(!IsEqual(tag, nil)) {
AddElementToObject(request, "memo", tag)
}
if IsTrue(!IsEqual(network, nil)) {
AddElementToObject(request, "netWork", network)
params = this.Omit(params, []interface{}{"network", "netWork"})
}
response:= (<-this.SpotPrivatePostCapitalWithdraw(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "id":"7213fea8e94b4a5593d507237e5a555b"
// }
//
ch <- this.ParseTransaction(response, currency)
return nil
}()
return ch
}
/**
* @method
* @name mexc#setPositionMode
* @description set hedged to true or false for a market
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#change-position-mode
* @param {bool} hedged set to true to use dualSidePosition
* @param {string} symbol not used by mexc setPositionMode ()
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} response from the exchange
*/
func (this *mexc) SetPositionMode(hedged interface{}, optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbol := GetArg(optionalArgs, 0, nil)
_ = symbol
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
var request interface{} = map[string]interface{} {
"positionMode": Ternary(IsTrue(hedged), 1, 2),
}
response:= (<-this.ContractPrivatePostPositionChangePositionMode(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success":true,
// "code":0
// }
//
ch <- response
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchPositionMode
* @description fetchs the position mode, hedged or one way, hedged for binance is set identically for all linear markets or all inverse markets
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-position-mode
* @param {string} symbol not used by mexc fetchPositionMode
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} an object detailing whether the market is in hedged or one-way mode
*/
func (this *mexc) FetchPositionMode(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
response:= (<-this.ContractPrivateGetPositionPositionMode(params))
PanicOnError(response)
//
// {
// "success":true,
// "code":0,
// "data":2
// }
//
var positionMode interface{} = this.SafeInteger(response, "data")
ch <- map[string]interface{} {
"info": response,
"hedged": (IsEqual(positionMode, 1)),
}
return nil
}()
return ch
}
/**
* @method
* @name mexc#fetchTransactionFees
* @description fetch deposit and withdrawal fees
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#query-the-currency-information
* @param {string[]|undefined} codes returns fees for all currencies if undefined
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure}
*/
func (this *mexc) FetchTransactionFees(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
codes := GetArg(optionalArgs, 0, nil)
_ = codes
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
retRes56108 := (<-this.LoadMarkets())
PanicOnError(retRes56108)
response:= (<-this.SpotPrivateGetCapitalConfigGetall(params))
PanicOnError(response)
//
// [
// {
// "coin": "AGLD",
// "name": "Adventure Gold",
// "networkList": [
// {
// "coin": "AGLD",
// "depositDesc": null,
// "depositEnable": true,
// "minConfirm": "0",
// "name": "Adventure Gold",
// "network": "ERC20",
// "withdrawEnable": true,
// "withdrawFee": "10.000000000000000000",
// "withdrawIntegerMultiple": null,
// "withdrawMax": "1200000.000000000000000000",
// "withdrawMin": "20.000000000000000000",
// "sameAddress": false,
// "contract": "0x32353a6c91143bfd6c7d363b546e62a9a2489a20",
// "withdrawTips": null,
// "depositTips": null
// }
// ...
// ]
// },
// ...
// ]
//
ch <- this.ParseTransactionFees(response, codes)
return nil
}()
return ch
}
func (this *mexc) ParseTransactionFees(response interface{}, optionalArgs ...interface{}) interface{} {
codes := GetArg(optionalArgs, 0, nil)
_ = codes
var withdrawFees interface{} = map[string]interface{} {}
for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
var entry interface{} = GetValue(response, i)
var currencyId interface{} = this.SafeString(entry, "coin")
var currency interface{} = this.SafeCurrency(currencyId)
var code interface{} = this.SafeString(currency, "code")
if IsTrue(IsTrue((IsEqual(codes, nil))) || IsTrue((this.InArray(code, codes)))) {
AddElementToObject(withdrawFees, code, this.ParseTransactionFee(entry, currency))
}
}
return map[string]interface{} {
"withdraw": withdrawFees,
"deposit": map[string]interface{} {},
"info": response,
}
}
func (this *mexc) ParseTransactionFee(transaction interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "coin": "AGLD",
// "name": "Adventure Gold",
// "networkList": [
// {
// "coin": "AGLD",
// "depositDesc": null,
// "depositEnable": true,
// "minConfirm": "0",
// "name": "Adventure Gold",
// "network": "ERC20",
// "withdrawEnable": true,
// "withdrawFee": "10.000000000000000000",
// "withdrawIntegerMultiple": null,
// "withdrawMax": "1200000.000000000000000000",
// "withdrawMin": "20.000000000000000000",
// "sameAddress": false,
// "contract": "0x32353a6c91143bfd6c7d363b546e62a9a2489a20",
// "withdrawTips": null,
// "depositTips": null
// }
// ...
// ]
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var networkList interface{} = this.SafeValue(transaction, "networkList", []interface{}{})
var result interface{} = map[string]interface{} {}
for j := 0; IsLessThan(j, GetArrayLength(networkList)); j++ {
var networkEntry interface{} = GetValue(networkList, j)
var networkId interface{} = this.SafeString(networkEntry, "network")
var networkCode interface{} = this.SafeString(GetValue(this.Options, "networks"), networkId, networkId)
var fee interface{} = this.SafeNumber(networkEntry, "withdrawFee")
AddElementToObject(result, networkCode, fee)
}
return result
}
/**
* @method
* @name mexc#fetchDepositWithdrawFees
* @description fetch deposit and withdrawal fees
* @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#query-the-currency-information
* @param {string[]|undefined} codes returns fees for all currencies if undefined
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object[]} a list of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure}
*/
func (this *mexc) FetchDepositWithdrawFees(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
codes := GetArg(optionalArgs, 0, nil)
_ = codes
params := GetArg(optionalArgs, 1, map[string]interface{} {})
_ = params
retRes57118 := (<-this.LoadMarkets())
PanicOnError(retRes57118)
response:= (<-this.SpotPrivateGetCapitalConfigGetall(params))
PanicOnError(response)
//
// [
// {
// "coin": "AGLD",
// "name": "Adventure Gold",
// "networkList": [
// {
// "coin": "AGLD",
// "depositDesc": null,
// "depositEnable": true,
// "minConfirm": "0",
// "name": "Adventure Gold",
// "network": "ERC20",
// "withdrawEnable": true,
// "withdrawFee": "10.000000000000000000",
// "withdrawIntegerMultiple": null,
// "withdrawMax": "1200000.000000000000000000",
// "withdrawMin": "20.000000000000000000",
// "sameAddress": false,
// "contract": "0x32353a6c91143bfd6c7d363b546e62a9a2489a20",
// "withdrawTips": null,
// "depositTips": null
// }
// ...
// ]
// },
// ...
// ]
//
ch <- this.ParseDepositWithdrawFees(response, codes, "coin")
return nil
}()
return ch
}
func (this *mexc) ParseDepositWithdrawFee(fee interface{}, optionalArgs ...interface{}) interface{} {
//
// {
// "coin": "AGLD",
// "name": "Adventure Gold",
// "networkList": [
// {
// "coin": "AGLD",
// "depositDesc": null,
// "depositEnable": true,
// "minConfirm": "0",
// "name": "Adventure Gold",
// "network": "ERC20",
// "withdrawEnable": true,
// "withdrawFee": "10.000000000000000000",
// "withdrawIntegerMultiple": null,
// "withdrawMax": "1200000.000000000000000000",
// "withdrawMin": "20.000000000000000000",
// "sameAddress": false,
// "contract": "0x32353a6c91143bfd6c7d363b546e62a9a2489a20",
// "withdrawTips": null,
// "depositTips": null
// }
// ...
// ]
// }
//
currency := GetArg(optionalArgs, 0, nil)
_ = currency
var networkList interface{} = this.SafeValue(fee, "networkList", []interface{}{})
var result interface{} = this.DepositWithdrawFee(fee)
for j := 0; IsLessThan(j, GetArrayLength(networkList)); j++ {
var networkEntry interface{} = GetValue(networkList, j)
var networkId interface{} = this.SafeString(networkEntry, "network")
var networkCode interface{} = this.NetworkIdToCode(networkId, this.SafeString(currency, "code"))
AddElementToObject(GetValue(result, "networks"), networkCode, map[string]interface{} {
"withdraw": map[string]interface{} {
"fee": this.SafeNumber(networkEntry, "withdrawFee"),
"percentage": nil,
},
"deposit": map[string]interface{} {
"fee": nil,
"percentage": nil,
},
})
}
return this.AssignDefaultDepositWithdrawFees(result)
}
/**
* @method
* @name mexc#fetchLeverage
* @description fetch the set leverage for a market
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-leverage
* @param {string} symbol unified market symbol
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
*/
func (this *mexc) FetchLeverage(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
retRes58028 := (<-this.LoadMarkets())
PanicOnError(retRes58028)
var market interface{} = this.Market(symbol)
var request interface{} = map[string]interface{} {
"symbol": GetValue(market, "id"),
}
response:= (<-this.ContractPrivateGetPositionLeverage(this.Extend(request, params)))
PanicOnError(response)
//
// {
// "success": true,
// "code": 0,
// "data": [
// {
// "level": 1,
// "maxVol": 463300,
// "mmr": 0.004,
// "imr": 0.005,
// "positionType": 1,
// "openType": 1,
// "leverage": 20,
// "limitBySys": false,
// "currentMmr": 0.004
// },
// {
// "level": 1,
// "maxVol": 463300,
// "mmr": 0.004,
// "imr": 0.005,
// "positionType": 2,
// "openType": 1,
// "leverage": 20,
// "limitBySys": false,
// "currentMmr": 0.004
// }
// ]
// }
//
var data interface{} = this.SafeList(response, "data", []interface{}{})
ch <- this.ParseLeverage(data, market)
return nil
}()
return ch
}
func (this *mexc) ParseLeverage(leverage interface{}, optionalArgs ...interface{}) interface{} {
market := GetArg(optionalArgs, 0, nil)
_ = market
var marginMode interface{} = nil
var longLeverage interface{} = nil
var shortLeverage interface{} = nil
for i := 0; IsLessThan(i, GetArrayLength(leverage)); i++ {
var entry interface{} = GetValue(leverage, i)
var openType interface{} = this.SafeInteger(entry, "openType")
var positionType interface{} = this.SafeInteger(entry, "positionType")
if IsTrue(IsEqual(positionType, 1)) {
longLeverage = this.SafeInteger(entry, "leverage")
} else if IsTrue(IsEqual(positionType, 2)) {
shortLeverage = this.SafeInteger(entry, "leverage")
}
marginMode = Ternary(IsTrue((IsEqual(openType, 1))), "isolated", "cross")
}
return map[string]interface{} {
"info": leverage,
"symbol": GetValue(market, "symbol"),
"marginMode": marginMode,
"longLeverage": longLeverage,
"shortLeverage": shortLeverage,
}
}
func (this *mexc) HandleMarginModeAndParams(methodName interface{}, optionalArgs ...interface{}) interface{} {
/**
* @ignore
* @method
* @description marginMode specified by params["marginMode"], this.options["marginMode"], this.options["defaultMarginMode"], params["margin"] = true or this.options["defaultType"] = 'margin'
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {bool} [params.margin] true for trading spot-margin
* @returns {Array} the marginMode in lowercase
*/
params := GetArg(optionalArgs, 0, map[string]interface{} {})
_ = params
defaultValue := GetArg(optionalArgs, 1, nil)
_ = defaultValue
var defaultType interface{} = this.SafeString(this.Options, "defaultType")
var isMargin interface{} = this.SafeBool(params, "margin", false)
var marginMode interface{} = nil
marginModeparamsVariable := this.Exchange.HandleMarginModeAndParams(methodName, params, defaultValue);
marginMode = GetValue(marginModeparamsVariable,0);
params = GetValue(marginModeparamsVariable,1)
if IsTrue(IsTrue((IsEqual(defaultType, "margin"))) || IsTrue((IsEqual(isMargin, true)))) {
marginMode = "isolated"
}
return []interface{}{marginMode, params}
}
/**
* @method
* @name mexc#fetchPositionsHistory
* @description fetches historical positions
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-user-s-history-position-information
* @param {string[]} [symbols] unified contract symbols
* @param {int} [since] not used by mexc fetchPositionsHistory
* @param {int} [limit] the maximum amount of candles to fetch, default=1000
* @param {object} [params] extra parameters specific to the exchange api endpoint
*
* EXCHANGE SPECIFIC PARAMETERS
* @param {int} [params.type] position type，1: long, 2: short
* @param {int} [params.page_num] current page number, default is 1
* @returns {object[]} a list of [position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
*/
func (this *mexc) FetchPositionsHistory(optionalArgs ...interface{}) <- chan interface{} {
ch := make(chan interface{})
go func() interface{} {
defer close(ch)
defer ReturnPanicError(ch)
symbols := GetArg(optionalArgs, 0, nil)
_ = symbols
since := GetArg(optionalArgs, 1, nil)
_ = since
limit := GetArg(optionalArgs, 2, nil)
_ = limit
params := GetArg(optionalArgs, 3, map[string]interface{} {})
_ = params
retRes59018 := (<-this.LoadMarkets())
PanicOnError(retRes59018)
var request interface{} = map[string]interface{} {}
if IsTrue(!IsEqual(symbols, nil)) {
var symbolsLength interface{} = GetArrayLength(symbols)
if IsTrue(IsEqual(symbolsLength, 1)) {
var market interface{} = this.Market(GetValue(symbols, 0))
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
}
if IsTrue(!IsEqual(limit, nil)) {
AddElementToObject(request, "page_size", limit)
}
response:= (<-this.ContractPrivateGetPositionListHistoryPositions(this.Extend(request, params)))
PanicOnError(response)
//
// {
// success: true,
// code: '0',
// data: [
// {
// positionId: '390281084',
// symbol: 'RVN_USDT',
// positionType: '1',
// openType: '2',
// state: '3',
// holdVol: '0',
// frozenVol: '0',
// closeVol: '1141',
// holdAvgPrice: '0.03491',
// holdAvgPriceFullyScale: '0.03491',
// openAvgPrice: '0.03491',
// openAvgPriceFullyScale: '0.03491',
// closeAvgPrice: '0.03494',
// liquidatePrice: '0.03433',
// oim: '0',
// im: '0',
// holdFee: '0',
// realised: '0.1829',
// leverage: '50',
// createTime: '1711512408000',
// updateTime: '1711512553000',
// autoAddIm: false,
// version: '4',
// profitRatio: '0.0227',
// newOpenAvgPrice: '0.03491',
// newCloseAvgPrice: '0.03494',
// closeProfitLoss: '0.3423',
// fee: '0.1593977',
// positionShowStatus: 'CLOSED'
// },
// ...
// ]
// }
//
var data interface{} = this.SafeList(response, "data")
var positions interface{} = this.ParsePositions(data, symbols, params)
ch <- this.FilterBySinceLimit(positions, since, limit)
return nil
}()
return ch
}
/**
* @method
* @name mexc#setMarginMode
* @description set margin mode to 'cross' or 'isolated'
* @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#switch-leverage
* @param {string} marginMode 'cross' or 'isolated'
* @param {string} [symbol] required when there is no position, else provide params["positionId"]
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.positionId] required when a position is set
* @param {string} [params.direction] "long" or "short" required when there is no position
* @returns {object} response from the exchange
*/
func (this *mexc) SetMarginMode(marginMode 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
retRes59728 := (<-this.LoadMarkets())
PanicOnError(retRes59728)
var market interface{} = this.Market(symbol)
if IsTrue(GetValue(market, "spot")) {
panic(BadSymbol(Add(this.Id, " setMarginMode() supports contract markets only")))
}
marginMode = ToLower(marginMode)
if IsTrue(IsTrue(!IsEqual(marginMode, "isolated")) && IsTrue(!IsEqual(marginMode, "cross"))) {
panic(BadRequest(Add(this.Id, " setMarginMode() marginMode argument should be isolated or cross")))
}
var leverage interface{} = this.SafeInteger(params, "leverage")
if IsTrue(IsEqual(leverage, nil)) {
panic(ArgumentsRequired(Add(this.Id, " setMarginMode() requires a leverage parameter")))
}
var direction interface{} = this.SafeStringLower2(params, "direction", "positionId")
var request interface{} = map[string]interface{} {
"leverage": leverage,
"openType": Ternary(IsTrue((IsEqual(marginMode, "isolated"))), 1, 2),
}
if IsTrue(!IsEqual(symbol, nil)) {
AddElementToObject(request, "symbol", GetValue(market, "id"))
}
if IsTrue(!IsEqual(direction, nil)) {
AddElementToObject(request, "positionType", Ternary(IsTrue((IsEqual(direction, "short"))), 2, 1))
}
params = this.Omit(params, "direction")
response:= (<-this.ContractPrivatePostPositionChangeLeverage(this.Extend(request, params)))
PanicOnError(response)
//
// { success: true, code: '0' }
//
ch <- this.ParseLeverage(response, market)
return nil
}()
return ch
}
func (this *mexc) Nonce() interface{} {
return Subtract(this.Milliseconds(), this.SafeInteger(this.Options, "timeDifference", 0))
}
func (this *mexc) 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 section interface{} = this.SafeString(api, 0)
var access interface{} = this.SafeString(api, 1)
pathparamsVariable := this.ResolvePath(path, params);
path = GetValue(pathparamsVariable,0);
params = GetValue(pathparamsVariable,1)
var url interface{} = nil
if IsTrue(IsTrue(IsEqual(section, "spot")) || IsTrue(IsEqual(section, "broker"))) {
if IsTrue(IsEqual(section, "broker")) {
url = Add(Add(GetValue(GetValue(GetValue(this.Urls, "api"), section), access), "/"), path)
} else {
url = Add(Add(Add(Add(GetValue(GetValue(GetValue(this.Urls, "api"), section), access), "/api/"), this.Version), "/"), path)
}
var urlParams interface{} = params
if IsTrue(IsEqual(access, "private")) {
if IsTrue(IsTrue(IsEqual(section, "broker")) && IsTrue((IsTrue(IsTrue((IsEqual(method, "POST"))) || IsTrue((IsEqual(method, "PUT")))) || IsTrue((IsEqual(method, "DELETE")))))) {
urlParams = map[string]interface{} {
"timestamp": this.Nonce(),
"recvWindow": this.SafeInteger(this.Options, "recvWindow", 5000),
}
body = this.Json(params)
} else {
AddElementToObject(urlParams, "timestamp", this.Nonce())
AddElementToObject(urlParams, "recvWindow", this.SafeInteger(this.Options, "recvWindow", 5000))
}
}
var paramsEncoded interface{} = ""
if IsTrue(GetArrayLength(ObjectKeys(urlParams))) {
paramsEncoded = this.Urlencode(urlParams)
url = Add(url, Add("?", paramsEncoded))
}
if IsTrue(IsEqual(access, "private")) {
this.CheckRequiredCredentials()
var signature interface{} = this.Hmac(this.Encode(paramsEncoded), this.Encode(this.Secret), sha256)
url = Add(url, Add(Add("&", "signature="), signature))
headers = map[string]interface{} {
"X-MEXC-APIKEY": this.ApiKey,
"source": this.SafeString(this.Options, "broker", "CCXT"),
}
}
if IsTrue(IsTrue(IsTrue((IsEqual(method, "POST"))) || IsTrue((IsEqual(method, "PUT")))) || IsTrue((IsEqual(method, "DELETE")))) {
AddElementToObject(headers, "Content-Type", "application/json")
}
} else if IsTrue(IsTrue(IsEqual(section, "contract")) || IsTrue(IsEqual(section, "spot2"))) {
url = Add(Add(GetValue(GetValue(GetValue(this.Urls, "api"), section), access), "/"), this.ImplodeParams(path, params))
params = this.Omit(params, this.ExtractParams(path))
if IsTrue(IsEqual(access, "public")) {
if IsTrue(GetArrayLength(ObjectKeys(params))) {
url = Add(url, Add("?", this.Urlencode(params)))
}
} else {
this.CheckRequiredCredentials()
var timestamp interface{} = ToString(this.Nonce())
var auth interface{} = ""
headers = map[string]interface{} {
"ApiKey": this.ApiKey,
"Request-Time": timestamp,
"Content-Type": "application/json",
"source": this.SafeString(this.Options, "broker", "CCXT"),
}
if IsTrue(IsEqual(method, "POST")) {
auth = this.Json(params)
body = auth
} else {
params = this.Keysort(params)
if IsTrue(GetArrayLength(ObjectKeys(params))) {
auth = Add(auth, this.Urlencode(params))
url = Add(url, Add("?", auth))
}
}
auth = Add(Add(this.ApiKey, timestamp), auth)
var signature interface{} = this.Hmac(this.Encode(auth), this.Encode(this.Secret), sha256)
AddElementToObject(headers, "Signature", signature)
}
}
return map[string]interface{} {
"url": url,
"method": method,
"body": body,
"headers": headers,
}
}
func (this *mexc) 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
}
// spot
// {"code":-1128,"msg":"Combination of optional parameters invalid.","_extend":null}
// {"success":false,"code":123456,"message":"Order quantity error...."}
//
// contract
//
// {"code":10232,"msg":"The currency not exist"}
// {"code":10216,"msg":"No available deposit address"}
// {"success":true, "code":0, "data":1634095541710}
//
var success interface{} = this.SafeBool(response, "success", false) // v1
if IsTrue(IsEqual(success, true)) {
return nil
}
var responseCode interface{} = this.SafeString(response, "code", nil)
if IsTrue(IsTrue(IsTrue((!IsEqual(responseCode, nil))) && IsTrue((!IsEqual(responseCode, "200")))) && IsTrue((!IsEqual(responseCode, "0")))) {
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 *mexc) 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 View Git Blame Copy Permalink