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 vertex struct { Exchange } func NewVertexCore() vertex { p := vertex{} setDefaults(&p) return p } func (this *vertex) Describe() interface{} { return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} { "id": "vertex", "name": "Vertex", "countries": []interface{}{}, "version": "v1", "rateLimit": 50, "certified": false, "pro": true, "dex": true, "has": map[string]interface{} { "CORS": nil, "spot": true, "margin": false, "swap": true, "future": true, "option": false, "addMargin": false, "borrowCrossMargin": false, "borrowIsolatedMargin": false, "cancelAllOrders": true, "cancelAllOrdersAfter": false, "cancelOrder": true, "cancelOrders": true, "cancelOrdersForSymbols": false, "closeAllPositions": false, "closePosition": false, "createMarketBuyOrderWithCost": false, "createMarketOrderWithCost": false, "createMarketSellOrderWithCost": false, "createOrder": true, "createOrders": true, "createReduceOnlyOrder": true, "createStopOrder": true, "createTriggerOrder": true, "editOrder": false, "fetchAccounts": false, "fetchBalance": true, "fetchBorrowInterest": false, "fetchBorrowRateHistories": false, "fetchBorrowRateHistory": false, "fetchCanceledOrders": false, "fetchClosedOrders": false, "fetchCrossBorrowRate": false, "fetchCrossBorrowRates": false, "fetchCurrencies": true, "fetchDepositAddress": false, "fetchDepositAddresses": false, "fetchDeposits": false, "fetchDepositWithdrawFee": false, "fetchDepositWithdrawFees": false, "fetchFundingHistory": false, "fetchFundingRate": true, "fetchFundingRateHistory": false, "fetchFundingRates": true, "fetchIndexOHLCV": false, "fetchIsolatedBorrowRate": false, "fetchIsolatedBorrowRates": false, "fetchLedger": false, "fetchLeverage": false, "fetchLeverageTiers": false, "fetchLiquidations": false, "fetchMarginMode": nil, "fetchMarketLeverageTiers": false, "fetchMarkets": true, "fetchMarkOHLCV": false, "fetchMyLiquidations": false, "fetchMyTrades": true, "fetchOHLCV": true, "fetchOpenInterest": true, "fetchOpenInterestHistory": false, "fetchOpenInterests": true, "fetchOpenOrders": true, "fetchOrder": true, "fetchOrderBook": true, "fetchOrders": true, "fetchOrderTrades": false, "fetchPosition": false, "fetchPositionMode": false, "fetchPositions": true, "fetchPositionsRisk": false, "fetchPremiumIndexOHLCV": false, "fetchStatus": true, "fetchTicker": false, "fetchTickers": true, "fetchTime": true, "fetchTrades": true, "fetchTradingFee": false, "fetchTradingFees": true, "fetchTransfer": false, "fetchTransfers": false, "fetchWithdrawal": false, "fetchWithdrawals": false, "reduceMargin": false, "repayCrossMargin": false, "repayIsolatedMargin": false, "sandbox": true, "setLeverage": false, "setMarginMode": false, "setPositionMode": false, "transfer": false, "withdraw": true, }, "timeframes": map[string]interface{} { "1m": 60, "5m": 300, "15m": 900, "1h": 3600, "2h": 7200, "4h": 14400, "1d": 86400, "1w": 604800, "1M": 604800, }, "hostname": "vertexprotocol.com", "urls": map[string]interface{} { "logo": "https://github.com/ccxt/ccxt/assets/43336371/bd04a0fa-3b48-47b6-9d8b-124954d520a8", "api": map[string]interface{} { "v1": map[string]interface{} { "archive": "https://archive.prod.{hostname}/v1", "gateway": "https://gateway.prod.{hostname}/v1", "trigger": "https://trigger.prod.{hostname}/v1", }, "v2": map[string]interface{} { "archive": "https://archive.prod.{hostname}/v2", "gateway": "https://gateway.prod.{hostname}/v2", }, }, "test": map[string]interface{} { "v1": map[string]interface{} { "archive": "https://archive.sepolia-test.{hostname}/v1", "gateway": "https://gateway.sepolia-test.{hostname}/v1", "trigger": "https://trigger.sepolia-test.{hostname}/v1", }, "v2": map[string]interface{} { "archive": "https://archive.sepolia-test.{hostname}/v2", "gateway": "https://gateway.sepolia-test.{hostname}/v2", }, }, "www": "https://vertexprotocol.com/", "doc": "https://docs.vertexprotocol.com/", "fees": "https://docs.vertexprotocol.com/basics/fees", "referral": "https://app.vertexprotocol.com?referrer=0xCfC9BaB96a2eA3d3c3F031c005e82E1D9F295aC1", }, "api": map[string]interface{} { "v1": map[string]interface{} { "archive": map[string]interface{} { "post": map[string]interface{} { "": 1, }, }, "gateway": map[string]interface{} { "get": map[string]interface{} { "query": 1, "symbols": 1, "time": 1, }, "post": map[string]interface{} { "query": 1, "execute": 1, }, }, "trigger": map[string]interface{} { "post": map[string]interface{} { "execute": 1, "query": 1, }, }, }, "v2": map[string]interface{} { "archive": map[string]interface{} { "get": map[string]interface{} { "tickers": 1, "contracts": 1, "trades": 1, "vrtx": 1, }, }, "gateway": map[string]interface{} { "get": map[string]interface{} { "assets": 0.6667, "pairs": 1, "orderbook": 1, }, }, }, }, "fees": map[string]interface{} { "swap": map[string]interface{} { "taker": this.ParseNumber("0.0002"), "maker": this.ParseNumber("0.0002"), }, "spot": map[string]interface{} { "taker": this.ParseNumber("0.0002"), "maker": this.ParseNumber("0.0002"), }, }, "requiredCredentials": map[string]interface{} { "apiKey": false, "secret": false, "walletAddress": true, "privateKey": true, }, "exceptions": map[string]interface{} { "exact": map[string]interface{} { "1000": RateLimitExceeded, "1015": RateLimitExceeded, "1001": PermissionDenied, "1002": PermissionDenied, "1003": PermissionDenied, "2000": InvalidOrder, "2001": InvalidOrder, "2002": InvalidOrder, "2003": InvalidOrder, "2004": InvalidOrder, "2005": InvalidOrder, "2006": InvalidOrder, "2007": InvalidOrder, "2008": InvalidOrder, "2009": InvalidOrder, "2010": InvalidOrder, "2011": BadRequest, "2012": BadRequest, "2013": InvalidOrder, "2014": PermissionDenied, "2015": InvalidOrder, "2016": InvalidOrder, "2017": InvalidOrder, "2019": InvalidOrder, "2020": InvalidOrder, "2021": InvalidOrder, "2022": InvalidOrder, "2023": InvalidOrder, "2024": InsufficientFunds, "2025": InsufficientFunds, "2026": BadRequest, "2027": AuthenticationError, "2028": AuthenticationError, "2029": AuthenticationError, "2030": BadRequest, "2031": InvalidOrder, "2033": InvalidOrder, "2034": InvalidOrder, "2035": InvalidOrder, "2036": InvalidOrder, "2037": InvalidOrder, "2038": InvalidOrder, "2039": InvalidOrder, "2040": InvalidOrder, "2041": InvalidOrder, "2042": InvalidOrder, "2043": InvalidOrder, "2044": InvalidOrder, "2045": InvalidOrder, "2046": InvalidOrder, "2047": InvalidOrder, "2048": InvalidOrder, "2049": ExchangeError, "2050": PermissionDenied, "2051": InvalidOrder, "2052": InvalidOrder, "2053": InvalidOrder, "2054": InvalidOrder, "2055": InvalidOrder, "2056": InvalidOrder, "2057": InvalidOrder, "2058": InvalidOrder, "2059": InvalidOrder, "2060": InvalidOrder, "2061": InvalidOrder, "2062": InvalidOrder, "2063": InvalidOrder, "2064": InvalidOrder, "2065": InvalidOrder, "2066": InvalidOrder, "2067": InvalidOrder, "2068": InvalidOrder, "2069": InvalidOrder, "2070": InvalidOrder, "2071": InvalidOrder, "2072": InvalidOrder, "2073": InvalidOrder, "2074": InvalidOrder, "2075": InvalidOrder, "2076": InvalidOrder, "3000": BadRequest, "3001": BadRequest, "3002": BadRequest, "3003": BadRequest, "4000": BadRequest, "4001": ExchangeError, "4002": ExchangeError, "4003": ExchangeError, "4004": InvalidOrder, "5000": ExchangeError, }, "broad": map[string]interface{} {}, }, "precisionMode": TICK_SIZE, "commonCurrencies": map[string]interface{} {}, "options": map[string]interface{} { "defaultType": "swap", "sandboxMode": false, "timeDifference": 0, "brokerId": 5930043274845996, }, "features": map[string]interface{} { "default": map[string]interface{} { "sandbox": true, "createOrder": map[string]interface{} { "marginMode": false, "triggerPrice": true, "triggerDirection": false, "triggerPriceType": nil, "stopLossPrice": true, "takeProfitPrice": true, "attachedStopLossTakeProfit": nil, "timeInForce": map[string]interface{} { "IOC": false, "FOK": false, "PO": true, "GTD": true, }, "hedged": false, "trailing": false, "leverage": false, "marketBuyByCost": true, "marketBuyRequiresPrice": true, "selfTradePrevention": false, "iceberg": false, }, "createOrders": nil, "fetchMyTrades": map[string]interface{} { "marginMode": false, "limit": 500, "daysBack": 100000, "untilDays": nil, "symbolRequired": false, }, "fetchOrder": map[string]interface{} { "marginMode": false, "trigger": false, "trailing": false, "symbolRequired": true, }, "fetchOpenOrders": map[string]interface{} { "marginMode": false, "limit": 500, "trigger": true, "trailing": false, "symbolRequired": false, }, "fetchOrders": nil, "fetchClosedOrders": nil, "fetchOHLCV": map[string]interface{} { "limit": 1000, }, }, "spot": map[string]interface{} { "extends": "default", }, "swap": map[string]interface{} { "linear": map[string]interface{} { "extends": "default", }, "inverse": nil, }, "future": map[string]interface{} { "linear": nil, "inverse": nil, }, }, }) } func (this *vertex) SetSandboxMode(enabled interface{}) { this.Exchange.SetSandboxMode(enabled) AddElementToObject(this.Options, "sandboxMode", enabled) } func (this *vertex) ConvertToX18(num interface{}) interface{} { if IsTrue(IsString(num)) { return Precise.StringMul(num, "1000000000000000000") } var numStr interface{} = this.NumberToString(num) return Precise.StringMul(numStr, "1000000000000000000") } func (this *vertex) ConvertFromX18(num interface{}) interface{} { if IsTrue(IsString(num)) { return Precise.StringDiv(num, "1000000000000000000") } var numStr interface{} = this.NumberToString(num) return Precise.StringDiv(numStr, "1000000000000000000") } /** * @method * @name vertex#fetchCurrencies * @description fetches all available currencies on an exchange * @see https://docs.vertexprotocol.com/developer-resources/api/v2/assets * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} an associative dictionary of currencies */ func (this *vertex) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params var request interface{} = map[string]interface{} {} response:= (<-this.V2GatewayGetAssets(this.Extend(request, params))) PanicOnError(response) // // [ // { // "product_id": 2, // "ticker_id": "BTC-PERP_USDC", // "market_type": "perp", // "name": "Bitcoin Perp", // "symbol": "BTC-PERP", // "maker_fee": 0.0002, // "taker_fee": 0, // "can_withdraw": false, // "can_deposit": false // }, // { // "product_id": 1, // "ticker_id": "BTC_USDC", // "market_type": "spot", // "name": "Bitcoin", // "symbol": "BTC", // "taker_fee": 0.0003, // "maker_fee": 0, // "can_withdraw": true, // "can_deposit": true // } // ] // var result interface{} = map[string]interface{} {} for i := 0; IsLessThan(i, GetArrayLength(response)); i++ { var data interface{} = this.SafeDict(response, i, map[string]interface{} {}) var tickerId interface{} = this.SafeString(data, "ticker_id") if IsTrue(IsTrue((!IsEqual(tickerId, nil))) && IsTrue((IsGreaterThan(GetIndexOf(tickerId, "PERP"), 0)))) { continue } var id interface{} = this.SafeString(data, "product_id") var name interface{} = this.SafeString(data, "symbol") var code interface{} = this.SafeCurrencyCode(name) AddElementToObject(result, code, map[string]interface{} { "id": id, "name": name, "code": code, "precision": nil, "info": data, "active": nil, "deposit": this.SafeBool(data, "can_deposit"), "withdraw": this.SafeBool(data, "can_withdraw"), "networks": nil, "fee": nil, "limits": map[string]interface{} { "amount": map[string]interface{} { "min": nil, "max": nil, }, "withdraw": map[string]interface{} { "min": nil, "max": nil, }, }, }) } ch <- result return nil }() return ch } func (this *vertex) ParseMarket(market interface{}) interface{} { // // { // "type": "spot", // "product_id": 3, // "symbol": "WETH", // "price_increment_x18": "100000000000000000", // "size_increment": "10000000000000000", // "min_size": "100000000000000000", // "min_depth_x18": "5000000000000000000000", // "max_spread_rate_x18": "2000000000000000", // "maker_fee_rate_x18": "0", // "taker_fee_rate_x18": "300000000000000", // "long_weight_initial_x18": "900000000000000000", // "long_weight_maintenance_x18": "950000000000000000" // } // var marketType interface{} = this.SafeString(market, "type") var quoteId interface{} = "USDC" var quote interface{} = this.SafeCurrencyCode(quoteId) var baseId interface{} = this.SafeString(market, "symbol") var base interface{} = this.SafeCurrencyCode(baseId) var settleId interface{} = quoteId var settle interface{} = this.SafeCurrencyCode(settleId) var symbol interface{} = Add(Add(base, "/"), quote) var spot interface{} = IsEqual(marketType, "spot") var contract interface{} = !IsTrue(spot) var swap interface{} = !IsTrue(spot) if IsTrue(swap) { var splitSymbol interface{} = Split(base, "-") symbol = Add(Add(Add(Add(GetValue(splitSymbol, 0), "/"), quote), ":"), settle) } var priceIncrementX18 interface{} = this.SafeString(market, "price_increment_x18") var sizeIncrementX18 interface{} = this.SafeString(market, "size_increment") var minSizeX18 interface{} = this.SafeString(market, "min_size") var takerX18 interface{} = this.SafeNumber(market, "taker_fee_rate_x18") var makerX18 interface{} = this.SafeNumber(market, "maker_fee_rate_x18") var isInverse interface{} = Ternary(IsTrue((spot)), nil, false) var isLinear interface{} = Ternary(IsTrue((spot)), nil, true) var contractSize interface{} = Ternary(IsTrue((spot)), nil, this.ParseNumber("1")) return map[string]interface{} { "id": this.SafeString(market, "product_id"), "symbol": symbol, "base": base, "quote": quote, "settle": Ternary(IsTrue((spot)), nil, settle), "baseId": baseId, "quoteId": quoteId, "settleId": Ternary(IsTrue((spot)), nil, settleId), "type": Ternary(IsTrue((spot)), "spot", "swap"), "spot": spot, "margin": nil, "swap": swap, "future": false, "option": false, "active": true, "contract": contract, "linear": isLinear, "inverse": isInverse, "taker": this.ParseNumber(this.ConvertFromX18(takerX18)), "maker": this.ParseNumber(this.ConvertFromX18(makerX18)), "contractSize": contractSize, "expiry": nil, "expiryDatetime": nil, "strike": nil, "optionType": nil, "precision": map[string]interface{} { "amount": this.ParseNumber(this.ConvertFromX18(sizeIncrementX18)), "price": this.ParseNumber(this.ConvertFromX18(priceIncrementX18)), }, "limits": map[string]interface{} { "leverage": map[string]interface{} { "min": nil, "max": nil, }, "amount": map[string]interface{} { "min": this.ParseNumber(this.ConvertFromX18(minSizeX18)), "max": nil, }, "price": map[string]interface{} { "min": nil, "max": nil, }, "cost": map[string]interface{} { "min": nil, "max": nil, }, }, "created": nil, "info": market, } } /** * @method * @name vertex#fetchMarkets * @description retrieves data on all markets for vertex * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/symbols * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} an array of objects representing market data */ func (this *vertex) 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 var request interface{} = map[string]interface{} { "type": "symbols", } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "data": { // "symbols": { // "WETH": { // "type": "spot", // "product_id": 3, // "symbol": "WETH", // "price_increment_x18": "100000000000000000", // "size_increment": "10000000000000000", // "min_size": "100000000000000000", // "min_depth_x18": "5000000000000000000000", // "max_spread_rate_x18": "2000000000000000", // "maker_fee_rate_x18": "0", // "taker_fee_rate_x18": "300000000000000", // "long_weight_initial_x18": "900000000000000000", // "long_weight_maintenance_x18": "950000000000000000" // } // } // }, // "request_type": "query_symbols" // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var markets interface{} = this.SafeDict(data, "symbols", map[string]interface{} {}) var symbols interface{} = ObjectKeys(markets) var result interface{} = []interface{}{} for i := 0; IsLessThan(i, GetArrayLength(symbols)); i++ { var symbol interface{} = GetValue(symbols, i) var rawMarket interface{} = this.SafeDict(markets, symbol, map[string]interface{} {}) AppendToArray(&result,this.ParseMarket(rawMarket)) } ch <- result return nil }() return ch } /** * @method * @name vertex#fetchTime * @description fetches the current integer timestamp in milliseconds from the exchange server * @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 *vertex) FetchTime(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params response:= (<-this.V1GatewayGetTime(params)) PanicOnError(response) // 1717481623452 ch <- this.ParseToInt(response) return nil }() return ch } /** * @method * @name vertex#fetchStatus * @description the latest known information on the availability of the exchange API * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/status * @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 *vertex) 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 var request interface{} = map[string]interface{} { "type": "status", } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "data": "active", // "request_type": "query_status", // } // var status interface{} = this.SafeString(response, "data") if IsTrue(IsEqual(status, "active")) { status = "ok" } else { status = "error" } ch <- map[string]interface{} { "status": status, "updated": nil, "eta": nil, "url": nil, "info": response, } return nil }() return ch } func (this *vertex) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{} { // // { // "ticker_id": "ARB_USDC", // "trade_id": 999994, // "price": 1.1366122408151016, // "base_filled": 175, // "quote_filled": -198.90714214264278, // "timestamp": 1691068943, // "trade_type": "buy" // } // fetchMytrades // { // "digest": "0x80ce789702b670b7d33f2aa67e12c85f124395c3f9acdb422dde3b4973ccd50c", // "order": { // "sender": "0x12a0b4888021576eb10a67616dd3dd3d9ce206b664656661756c740000000000", // "priceX18": "27544000000000000000000", // "amount": "2000000000000000000", // "expiration": "4611686020107119633", // "nonce": "1761322608857448448" // }, // "base_filled": "736000000000000000", // "quote_filled": "-20276464287857571514302", // "fee": "4055287857571514302", // "sequencer_fee": "0" // "cumulative_fee": "4055287857571514302", // "cumulative_base_filled": "736000000000000000", // "cumulative_quote_filled": "-20276464287857571514302", // "submission_idx": "563012", // "pre_balance": { // "base": { // "perp": { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "1823351297710837" // }, // "balance": { // "amount": "2686684000000000000000", // "v_quote_balance": "-76348662407149297671587247", // "last_cumulative_funding_x18": "134999841911604906604576" // } // } // }, // "quote": null // }, // "post_balance": { // "base": { // "perp": { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "1823351297710837" // }, // "balance": { // "amount": "2686013000000000000000", // "v_quote_balance": "-76328351274188497671587247", // "last_cumulative_funding_x18": "134999841911604906604576" // } // } // }, // "quote": null // } // } market := GetArg(optionalArgs, 0, nil) _ = market var price interface{} = nil var amount interface{} = nil var side interface{} = nil var fee interface{} = nil var feeCost interface{} = this.ConvertFromX18(this.SafeString(trade, "fee")) if IsTrue(!IsEqual(feeCost, nil)) { fee = map[string]interface{} { "cost": feeCost, "currency": nil, } } var id interface{} = this.SafeString2(trade, "trade_id", "submission_idx") var order interface{} = this.SafeString(trade, "digest") var timestamp interface{} = this.SafeTimestamp(trade, "timestamp") if IsTrue(IsEqual(timestamp, nil)) { // fetchMyTrades var baseBalance interface{} = this.SafeDict(this.SafeDict(trade, "pre_balance", map[string]interface{} {}), "base", map[string]interface{} {}) var marketId interface{} = nil if IsTrue(InOp(baseBalance, "perp")) { marketId = this.SafeString(this.SafeDict(baseBalance, "perp", map[string]interface{} {}), "product_id") } else { marketId = this.SafeString(this.SafeDict(baseBalance, "spot", map[string]interface{} {}), "product_id") } market = this.SafeMarket(marketId) var subOrder interface{} = this.SafeDict(trade, "order", map[string]interface{} {}) price = this.ConvertFromX18(this.SafeString(subOrder, "priceX18")) amount = this.ConvertFromX18(this.SafeString(trade, "base_filled")) if IsTrue(Precise.StringLt(amount, "0")) { side = "sell" } else { side = "buy" } } else { var tickerId interface{} = this.SafeString(trade, "ticker_id") var splitTickerId interface{} = Split(tickerId, "_") var splitSymbol interface{} = Split(GetValue(splitTickerId, 0), "-") var marketId interface{} = Add(GetValue(splitSymbol, 0), GetValue(splitTickerId, 1)) market = this.SafeMarket(marketId, market) price = this.SafeString(trade, "price") amount = this.SafeString(trade, "base_filled") side = this.SafeStringLower(trade, "trade_type") } amount = Precise.StringAbs(amount) var symbol interface{} = GetValue(market, "symbol") return this.SafeTrade(map[string]interface{} { "id": id, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "symbol": symbol, "side": side, "price": price, "amount": amount, "cost": nil, "order": order, "takerOrMaker": nil, "type": nil, "fee": fee, "info": trade, }, market) } /** * @method * @name vertex#fetchTrades * @description get the list of most recent trades for a particular symbol * @see https://docs.vertexprotocol.com/developer-resources/api/v2/trades * @param {string} symbol unified symbol of the market to fetch trades for * @param {int} [since] timestamp in ms of the earliest trade to fetch * @param {int} [limit] the maximum amount of trades to fetch * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades} */ func (this *vertex) 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 retRes8178 := (<-this.LoadMarkets()) PanicOnError(retRes8178) var market interface{} = this.Market(symbol) var marketId interface{} = Add(GetValue(market, "baseId"), "_USDC") var request interface{} = map[string]interface{} { "ticker_id": marketId, } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) } response:= (<-this.V2ArchiveGetTrades(this.Extend(request, params))) PanicOnError(response) // // [ // { // "ticker_id": "ARB_USDC", // "trade_id": 999994, // "price": 1.1366122408151016, // "base_filled": 175, // "quote_filled": -198.90714214264278, // "timestamp": 1691068943, // "trade_type": "buy" // }, // { // "ticker_id": "ARB_USDC", // "trade_id": 999978, // "price": 1.136512210806099, // "base_filled": 175, // "quote_filled": -198.8896368910673, // "timestamp": 1691068882, // "trade_type": "buy" // } // ] // ch <- this.ParseTrades(response, market, since, limit) return nil }() return ch } /** * @method * @name vertex#fetchMyTrades * @description fetch all trades made by the user * @see https://docs.vertexprotocol.com/developer-resources/api/archive-indexer/matches * @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 {string} [params.user] user address, will default to this.walletAddress if not provided * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure} */ func (this *vertex) 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 retRes8658 := (<-this.LoadMarkets()) PanicOnError(retRes8658) var userAddress interface{} = nil userAddressparamsVariable := this.HandlePublicAddress("fetchMyTrades", params); userAddress = GetValue(userAddressparamsVariable,0); params = GetValue(userAddressparamsVariable,1) var market interface{} = nil var matchesRequest interface{} = map[string]interface{} { "subaccount": this.ConvertAddressToSender(userAddress), } if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(matchesRequest, "product_ids", []interface{}{this.ParseToNumeric(GetValue(market, "id"))}) } var until interface{} = this.SafeInteger(params, "until") if IsTrue(!IsEqual(until, nil)) { params = this.Omit(params, "until") AddElementToObject(matchesRequest, "max_time", until) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(matchesRequest, "limit", limit) } var request interface{} = map[string]interface{} { "matches": matchesRequest, } response:= (<-this.V1ArchivePost(this.Extend(request, params))) PanicOnError(response) // // { // "matches": [ // { // "digest": "0x80ce789702b670b7d33f2aa67e12c85f124395c3f9acdb422dde3b4973ccd50c", // "order": { // "sender": "0x12a0b4888021576eb10a67616dd3dd3d9ce206b664656661756c740000000000", // "priceX18": "27544000000000000000000", // "amount": "2000000000000000000", // "expiration": "4611686020107119633", // "nonce": "1761322608857448448" // }, // "base_filled": "736000000000000000", // "quote_filled": "-20276464287857571514302", // "fee": "4055287857571514302", // "sequencer_fee": "0" // "cumulative_fee": "4055287857571514302", // "cumulative_base_filled": "736000000000000000", // "cumulative_quote_filled": "-20276464287857571514302", // "submission_idx": "563012", // "pre_balance": { // "base": { // "perp": { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "1823351297710837" // }, // "balance": { // "amount": "2686684000000000000000", // "v_quote_balance": "-76348662407149297671587247", // "last_cumulative_funding_x18": "134999841911604906604576" // } // } // }, // "quote": null // }, // "post_balance": { // "base": { // "perp": { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "1823351297710837" // }, // "balance": { // "amount": "2686013000000000000000", // "v_quote_balance": "-76328351274188497671587247", // "last_cumulative_funding_x18": "134999841911604906604576" // } // } // }, // "quote": null // } // }, // { // "digest": "0x0f6e5a0434e36d8e6d4fed950d3624b0d8c91a8a84efd156bb25c1382561c0c2", // "order": { // "sender": "0x12a0b4888021576eb10a67616dd3dd3d9ce206b664656661756c740000000000", // "priceX18": "27540000000000000000000", // "amount": "2000000000000000000", // "expiration": "4611686020107119623", // "nonce": "1761322602510417920" // }, // "base_filled": "723999999999999999", // "quote_filled": "-19944943483044913474043", // "fee": "5983483044913474042", // "cumulative_fee": "11958484645393618085", // "cumulative_base_filled": "1446999999999999998", // "cumulative_quote_filled": "-39861640484645393618087", // "submission_idx": "563011", // "pre_balance": { // "base": { // "perp": { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "1823351297710837" // }, // "balance": { // "amount": "2686684000000000000000", // "v_quote_balance": "-76348662407149297671587247", // "last_cumulative_funding_x18": "134999841911604906604576" // } // } // }, // "quote": null // }, // "post_balance": { // "base": { // "perp": { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "1823351297710837" // }, // "balance": { // "amount": "2686013000000000000000", // "v_quote_balance": "-76328351274188497671587247", // "last_cumulative_funding_x18": "134999841911604906604576" // } // } // }, // "quote": null // } // } // ], // "txs": [ // { // "tx": { // "match_orders": { // "product_id": 2, // "amm": true, // "taker": { // "order": { // "sender": "0x12a0b4888021576eb10a67616dd3dd3d9ce206b664656661756c740000000000", // "price_x18": "27544000000000000000000", // "amount": "2000000000000000000", // "expiration": 4611686020107120000, // "nonce": 1761322608857448400 // }, // "signature": "0xe8fa7151bde348afa3b46dc52798046b7c8318f1b0a7f689710debbc094658cc1bf5a7e478ccc8278b625da0b9402c86b580d2e31e13831337dfd6153f4b37811b" // }, // "maker": { // "order": { // "sender": "0xebdbbcdbd2646c5f23a1e0806027eee5f71b074664656661756c740000000000", // "price_x18": "27544000000000000000000", // "amount": "-736000000000000000", // "expiration": 1679731669, // "nonce": 1761322585591644200 // }, // "signature": "0x47f9d47f0777f3ca0b13f07b7682dbeea098c0e377b87dcb025754fe34c900e336b8c7744e021fb9c46a4f8c6a1478bafa28bf0d023ae496aa3efa4d8e81df181c" // } // } // }, // "submission_idx": "563012", // "timestamp": "1679728133" // }, // { // "tx": { // "match_orders": { // "product_id": 1, // "amm": true, // "taker": { // "order": { // "sender": "0x12a0b4888021576eb10a67616dd3dd3d9ce206b664656661756c740000000000", // "price_x18": "27540000000000000000000", // "amount": "2000000000000000000", // "expiration": 4611686020107120000, // "nonce": 1761322602510418000 // }, // "signature": "0x826c68f1a3f76d9ffbe8041f8d45e969d31f1ab6f2ae2f6379d1493e479e56436091d6cf4c72e212dd2f1d2fa17c627c4c21bd6d281c77172b8af030488478b71c" // }, // "maker": { // "order": { // "sender": "0xf8d240d9514c9a4715d66268d7af3b53d619642564656661756c740000000000", // "price_x18": "27540000000000000000000", // "amount": "-724000000000000000", // "expiration": 1679731656, // "nonce": 1761322565506171000 // }, // "signature": "0xd8b6505b8d9b8c3cbfe793080976388035682c02a27893fb26b48a5b2bfe943f4162dea3a42e24e0dff5e2f74fbf77e33d83619140a2a581117c55e6cc236bdb1c" // } // } // }, // "submission_idx": "563011", // "timestamp": "1679728127" // } // ] // } // var trades interface{} = this.SafeList(response, "matches", []interface{}{}) ch <- this.ParseTrades(trades, market, since, limit, params) return nil }() return ch } /** * @method * @name vertex#fetchOrderBook * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data * @see https://docs.vertexprotocol.com/developer-resources/api/v2/orderbook * @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 *vertex) 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 retRes10748 := (<-this.LoadMarkets()) PanicOnError(retRes10748) var market interface{} = this.Market(symbol) var marketId interface{} = Add(GetValue(market, "baseId"), "_USDC") if IsTrue(IsEqual(limit, nil)) { limit = 100 } var request interface{} = map[string]interface{} { "ticker_id": marketId, "depth": limit, } response:= (<-this.V2GatewayGetOrderbook(this.Extend(request, params))) PanicOnError(response) // // { // "ticker_id": "ETH-PERP_USDC", // "bids": [ // [ // 1612.3, // 0.31 // ], // [ // 1612.0, // 0.93 // ], // [ // 1611.5, // 1.55 // ], // [ // 1610.8, // 2.17 // ] // ], // "asks": [ // [ // 1612.9, // 0.93 // ], // [ // 1613.4, // 1.55 // ], // [ // 1614.1, // 2.17 // ] // ], // "timestamp": 1694375362016 // } // var timestamp interface{} = this.SafeInteger(response, "timestamp") ch <- this.ParseOrderBook(response, symbol, timestamp, "bids", "asks") return nil }() return ch } /** * @method * @name vertex#fetchTradingFees * @description fetch the trading fees for multiple markets * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/fee-rates * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.user] user address, will default to this.walletAddress if not provided * @returns {object} a dictionary of [fee structures]{@link https://docs.ccxt.com/#/?id=fee-structure} indexed by market symbols */ func (this *vertex) FetchTradingFees(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 retRes11378 := (<-this.LoadMarkets()) PanicOnError(retRes11378) var userAddress interface{} = nil userAddressparamsVariable := this.HandlePublicAddress("fetchTradingFees", params); userAddress = GetValue(userAddressparamsVariable,0); params = GetValue(userAddressparamsVariable,1) var request interface{} = map[string]interface{} { "type": "fee_rates", "sender": this.ConvertAddressToSender(userAddress), } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "data": { // "taker_fee_rates_x18": [ // "0", // "300000000000000", // "200000000000000", // "300000000000000", // "200000000000000" // ], // "maker_fee_rates_x18": [ // "0", // "0", // "0", // "0", // "0" // ], // "liquidation_sequencer_fee": "250000000000000000", // "health_check_sequencer_fee": "100000000000000000", // "taker_sequencer_fee": "25000000000000000", // "withdraw_sequencer_fees": [ // "10000000000000000", // "40000000000000", // "0", // "600000000000000", // "0" // ] // }, // "request_type": "query_fee_rates", // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var maker interface{} = this.SafeList(data, "maker_fee_rates_x18", []interface{}{}) var taker interface{} = this.SafeList(data, "taker_fee_rates_x18", []interface{}{}) var result interface{} = map[string]interface{} {} for i := 0; IsLessThan(i, GetArrayLength(taker)); i++ { var market interface{} = this.SafeMarket(this.NumberToString(i)) if IsTrue(IsEqual(GetValue(market, "id"), nil)) { continue } var symbol interface{} = GetValue(market, "symbol") AddElementToObject(result, symbol, map[string]interface{} { "info": response, "symbol": symbol, "maker": this.ParseNumber(this.ConvertFromX18(GetValue(maker, i))), "taker": this.ParseNumber(this.ConvertFromX18(GetValue(taker, i))), "percentage": true, "tierBased": false, }) } ch <- result return nil }() return ch } func (this *vertex) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{} { // example response in fetchOHLCV market := GetArg(optionalArgs, 0, nil) _ = market return []interface{}{this.SafeTimestamp(ohlcv, "timestamp"), this.ParseNumber(this.ConvertFromX18(this.SafeString(ohlcv, "open_x18"))), this.ParseNumber(this.ConvertFromX18(this.SafeString(ohlcv, "high_x18"))), this.ParseNumber(this.ConvertFromX18(this.SafeString(ohlcv, "low_x18"))), this.ParseNumber(this.ConvertFromX18(this.SafeString(ohlcv, "close_x18"))), this.ParseNumber(this.ConvertFromX18(this.SafeString(ohlcv, "volume")))} } /** * @method * @name vertex#fetchOHLCV * @see https://docs.vertexprotocol.com/developer-resources/api/archive-indexer/candlesticks * @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] max=1000, max=100 when since is defined and is less than (now - (999 * (timeframe in ms))) * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume */ func (this *vertex) 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 retRes12248 := (<-this.LoadMarkets()) PanicOnError(retRes12248) var market interface{} = this.Market(symbol) var ohlcvRequest interface{} = map[string]interface{} { "product_id": this.ParseToInt(GetValue(market, "id")), "granularity": this.SafeInteger(this.Timeframes, timeframe), } var until interface{} = this.SafeInteger(params, "until") if IsTrue(!IsEqual(until, nil)) { params = this.Omit(params, "until") AddElementToObject(ohlcvRequest, "max_time", until) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(ohlcvRequest, "limit", mathMin(limit, 1000)) } var request interface{} = map[string]interface{} { "candlesticks": ohlcvRequest, } response:= (<-this.V1ArchivePost(this.Extend(request, params))) PanicOnError(response) // // { // "candlesticks": [ // { // "product_id": 1, // "granularity": 60, // "submission_idx": "627709", // "timestamp": "1680118140", // "open_x18": "27235000000000000000000", // "high_x18": "27298000000000000000000", // "low_x18": "27235000000000000000000", // "close_x18": "27298000000000000000000", // "volume": "1999999999999999998" // }, // { // "product_id": 1, // "granularity": 60, // "submission_idx": "627699", // "timestamp": "1680118080", // "open_x18": "27218000000000000000000", // "high_x18": "27245000000000000000000", // "low_x18": "27218000000000000000000", // "close_x18": "27245000000000000000000", // "volume": "11852999999999999995" // } // ] // } // var rows interface{} = this.SafeList(response, "candlesticks", []interface{}{}) ch <- this.ParseOHLCVs(rows, market, timeframe, since, limit) return nil }() return ch } func (this *vertex) ParseFundingRate(ticker interface{}, optionalArgs ...interface{}) interface{} { // // { // "product_id": 4, // "funding_rate_x18": "2447900598160952", // "update_time": "1680116326" // } // // { // "ETH-PERP_USDC": { // "ticker_id": "ETH-PERP_USDC", // "base_currency": "ETH-PERP", // "quote_currency": "USDC", // "last_price": 1620.3, // "base_volume": 1309.2, // "quote_volume": 2117828.093867611, // "product_type": "perpetual", // "contract_price": 1620.372642114429, // "contract_price_currency": "USD", // "open_interest": 1635.2, // "open_interest_usd": 2649633.3443855145, // "index_price": 1623.293496279935, // "mark_price": 1623.398589416731, // "funding_rate": 0.000068613217104332, // "next_funding_rate_timestamp": 1694379600, // "price_change_percent_24h": -0.6348599635253989 // } // } // market := GetArg(optionalArgs, 0, nil) _ = market var fundingRate interface{} = this.SafeNumber(ticker, "funding_rate") if IsTrue(IsEqual(fundingRate, nil)) { var fundingRateX18 interface{} = this.SafeString(ticker, "funding_rate_x18") fundingRate = this.ParseNumber(this.ConvertFromX18(fundingRateX18)) } var fundingTimestamp interface{} = this.SafeTimestamp2(ticker, "update_time", "next_funding_rate_timestamp") var markPrice interface{} = this.SafeNumber(ticker, "mark_price") var indexPrice interface{} = this.SafeNumber(ticker, "index_price") return map[string]interface{} { "info": ticker, "symbol": GetValue(market, "symbol"), "markPrice": markPrice, "indexPrice": indexPrice, "interestRate": nil, "estimatedSettlePrice": nil, "timestamp": nil, "datetime": nil, "fundingRate": fundingRate, "fundingTimestamp": fundingTimestamp, "fundingDatetime": this.Iso8601(fundingTimestamp), "nextFundingRate": nil, "nextFundingTimestamp": nil, "nextFundingDatetime": nil, "previousFundingRate": nil, "previousFundingTimestamp": nil, "previousFundingDatetime": nil, "interval": nil, } } /** * @method * @name vertex#fetchFundingRate * @description fetch the current funding rate * @see https://docs.vertexprotocol.com/developer-resources/api/archive-indexer/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 *vertex) 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 retRes13438 := (<-this.LoadMarkets()) PanicOnError(retRes13438) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "funding_rate": map[string]interface{} { "product_id": this.ParseToInt(GetValue(market, "id")), }, } response:= (<-this.V1ArchivePost(this.Extend(request, params))) PanicOnError(response) // // { // "product_id": 4, // "funding_rate_x18": "2447900598160952", // "update_time": "1680116326" // } // ch <- this.ParseFundingRate(response, market) return nil }() return ch } /** * @method * @name vertex#fetchFundingRates * @description fetches funding rates for multiple markets * @see https://docs.vertexprotocol.com/developer-resources/api/v2/contracts * @param {string[]} symbols unified symbols of the markets to fetch the funding rates for, all market funding rates are returned if not assigned * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object[]} an array of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure} */ func (this *vertex) FetchFundingRates(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) symbols := GetArg(optionalArgs, 0, nil) _ = symbols params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params retRes13718 := (<-this.LoadMarkets()) PanicOnError(retRes13718) var request interface{} = map[string]interface{} {} if IsTrue(!IsEqual(symbols, nil)) { symbols = this.MarketSymbols(symbols) } response:= (<-this.V2ArchiveGetContracts(this.Extend(request, params))) PanicOnError(response) // // { // "ETH-PERP_USDC": { // "ticker_id": "ETH-PERP_USDC", // "base_currency": "ETH-PERP", // "quote_currency": "USDC", // "last_price": 1620.3, // "base_volume": 1309.2, // "quote_volume": 2117828.093867611, // "product_type": "perpetual", // "contract_price": 1620.372642114429, // "contract_price_currency": "USD", // "open_interest": 1635.2, // "open_interest_usd": 2649633.3443855145, // "index_price": 1623.293496279935, // "mark_price": 1623.398589416731, // "funding_rate": 0.000068613217104332, // "next_funding_rate_timestamp": 1694379600, // "price_change_percent_24h": -0.6348599635253989 // } // } // var keys interface{} = ObjectKeys(response) var fundingRates interface{} = map[string]interface{} {} for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ { var tickerId interface{} = GetValue(keys, i) var parsedTickerId interface{} = Split(tickerId, "-") var data interface{} = GetValue(response, tickerId) var marketId interface{} = Add(GetValue(parsedTickerId, 0), "/USDC:USDC") var market interface{} = this.Market(marketId) var ticker interface{} = this.ParseFundingRate(data, market) var symbol interface{} = GetValue(ticker, "symbol") AddElementToObject(fundingRates, symbol, ticker) } ch <- this.FilterByArray(fundingRates, "symbol", symbols) return nil }() return ch } func (this *vertex) ParseOpenInterest(interest interface{}, optionalArgs ...interface{}) interface{} { // // { // "ETH-PERP_USDC": { // "ticker_id": "ETH-PERP_USDC", // "base_currency": "ETH-PERP", // "quote_currency": "USDC", // "last_price": 1620.3, // "base_volume": 1309.2, // "quote_volume": 2117828.093867611, // "product_type": "perpetual", // "contract_price": 1620.372642114429, // "contract_price_currency": "USD", // "open_interest": 1635.2, // "open_interest_usd": 2649633.3443855145, // "index_price": 1623.293496279935, // "mark_price": 1623.398589416731, // "funding_rate": 0.000068613217104332, // "next_funding_rate_timestamp": 1694379600, // "price_change_percent_24h": -0.6348599635253989 // } // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(interest, "ticker_id") return this.SafeOpenInterest(map[string]interface{} { "symbol": this.SafeSymbol(marketId, market), "openInterestAmount": this.SafeNumber(interest, "open_interest"), "openInterestValue": this.SafeNumber(interest, "open_interest_usd"), "timestamp": nil, "datetime": nil, "info": interest, }, market) } /** * @method * @name vertex#fetchOpenInterests * @description Retrieves the open interest for a list of symbols * @see https://docs.vertexprotocol.com/developer-resources/api/v2/contracts * @param {string[]} [symbols] a list of unified CCXT market symbols * @param {object} [params] exchange specific parameters * @returns {object[]} a list of [open interest structures]{@link https://docs.ccxt.com/#/?id=open-interest-structure} */ func (this *vertex) FetchOpenInterests(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 retRes14588 := (<-this.LoadMarkets()) PanicOnError(retRes14588) symbols = this.MarketSymbols(symbols) response:= (<-this.V2ArchiveGetContracts(params)) PanicOnError(response) // // { // "ADA-PERP_USDC": { // "ticker_id": "ADA-PERP_USDC", // "base_currency": "ADA-PERP", // "quote_currency": "USDC", // "last_price": 0.85506, // "base_volume": 1241320.0, // "quote_volume": 1122670.9080057142, // "product_type": "perpetual", // "contract_price": 0.8558601432685385, // "contract_price_currency": "USD", // "open_interest": 104040.0, // "open_interest_usd": 89043.68930565874, // "index_price": 0.8561952606869176, // "mark_price": 0.856293781088936, // "funding_rate": 0.000116153806226841, // "next_funding_rate_timestamp": 1734685200, // "price_change_percent_24h": -12.274325340321374 // }, // } // var parsedSymbols interface{} = []interface{}{} var results interface{} = []interface{}{} var markets interface{} = ObjectKeys(response) if IsTrue(IsEqual(symbols, nil)) { symbols = []interface{}{} for y := 0; IsLessThan(y, GetArrayLength(markets)); y++ { var tickerId interface{} = GetValue(markets, y) var parsedTickerId interface{} = Split(tickerId, "-") var currentSymbol interface{} = Add(GetValue(parsedTickerId, 0), "/USDC:USDC") if !IsTrue(this.InArray(currentSymbol, symbols)) { AppendToArray(&symbols,currentSymbol) } } } for i := 0; IsLessThan(i, GetArrayLength(markets)); i++ { var marketId interface{} = GetValue(markets, i) var marketInner interface{} = this.SafeMarket(marketId) var openInterest interface{} = this.SafeDict(response, marketId, map[string]interface{} {}) for j := 0; IsLessThan(j, GetArrayLength(symbols)); j++ { var market interface{} = this.Market(GetValue(symbols, j)) var tickerId interface{} = Add(GetValue(market, "base"), "_USDC") if IsTrue(IsEqual(GetValue(marketInner, "marketId"), tickerId)) { AppendToArray(&parsedSymbols,GetValue(market, "symbol")) AppendToArray(&results,this.ParseOpenInterest(openInterest, market)) } } } ch <- this.FilterByArray(results, "symbol", parsedSymbols) return nil }() return ch } /** * @method * @name vertex#fetchOpenInterest * @description Retrieves the open interest of a derivative trading pair * @see https://docs.vertexprotocol.com/developer-resources/api/v2/contracts * @param {string} symbol Unified CCXT market symbol * @param {object} [params] exchange specific parameters * @returns {object} an open interest structure{@link https://docs.ccxt.com/#/?id=open-interest-structure} */ func (this *vertex) FetchOpenInterest(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 retRes15238 := (<-this.LoadMarkets()) PanicOnError(retRes15238) var market interface{} = this.Market(symbol) if !IsTrue(GetValue(market, "contract")) { panic(BadRequest(Add(this.Id, " fetchOpenInterest() supports contract markets only"))) } var request interface{} = map[string]interface{} {} response:= (<-this.V2ArchiveGetContracts(this.Extend(request, params))) PanicOnError(response) // // { // "ETH-PERP_USDC": { // "ticker_id": "ETH-PERP_USDC", // "base_currency": "ETH-PERP", // "quote_currency": "USDC", // "last_price": 1620.3, // "base_volume": 1309.2, // "quote_volume": 2117828.093867611, // "product_type": "perpetual", // "contract_price": 1620.372642114429, // "contract_price_currency": "USD", // "open_interest": 1635.2, // "open_interest_usd": 2649633.3443855145, // "index_price": 1623.293496279935, // "mark_price": 1623.398589416731, // "funding_rate": 0.000068613217104332, // "next_funding_rate_timestamp": 1694379600, // "price_change_percent_24h": -0.6348599635253989 // } // } // var tickerId interface{} = Add(GetValue(market, "base"), "_USDC") var openInterest interface{} = this.SafeDict(response, tickerId, map[string]interface{} {}) ch <- this.ParseOpenInterest(openInterest, market) return nil }() return ch } func (this *vertex) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{} { // // { // "ticker_id": "BTC_USDC", // "base_currency": "BTC", // "quote_currency": "USDC", // "last_price": 25728.0, // "base_volume": 552.048, // "quote_volume": 14238632.207250029, // "price_change_percent_24h": -0.6348599635253989 // } // market := GetArg(optionalArgs, 0, nil) _ = market var base interface{} = this.SafeString(ticker, "base_currency") var quote interface{} = this.SafeString(ticker, "quote_currency") var marketId interface{} = Add(Add(base, "/"), quote) if IsTrue(IsGreaterThan(GetIndexOf(base, "PERP"), 0)) { marketId = Add(Replace(marketId, "-PERP", ""), ":USDC") } market = this.SafeMarket(marketId, market) var last interface{} = this.SafeString(ticker, "last_price") return this.SafeTicker(map[string]interface{} { "symbol": GetValue(market, "symbol"), "timestamp": nil, "datetime": nil, "high": nil, "low": nil, "bid": nil, "bidVolume": nil, "ask": nil, "askVolume": nil, "vwap": nil, "open": nil, "close": last, "last": last, "previousClose": nil, "change": nil, "percentage": this.SafeString(ticker, "price_change_percent_24h"), "average": nil, "baseVolume": this.SafeString(ticker, "base_volume"), "quoteVolume": this.SafeString(ticker, "quote_volume"), "info": ticker, }, market) } /** * @method * @name vertex#fetchTickers * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market * @see https://docs.vertexprotocol.com/developer-resources/api/v2/tickers * @param {string[]} [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 *vertex) 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 retRes16118 := (<-this.LoadMarkets()) PanicOnError(retRes16118) symbols = this.MarketSymbols(symbols, nil, true, true, true) var request interface{} = map[string]interface{} {} response:= (<-this.V2ArchiveGetTickers(this.Extend(request, params))) PanicOnError(response) // // { // "ETH_USDC": { // "ticker_id": "ETH_USDC", // "base_currency": "ETH", // "quote_currency": "USDC", // "last_price": 1619.1, // "base_volume": 1428.32, // "quote_volume": 2310648.316391866, // "price_change_percent_24h": -1.0509394462969588 // }, // "BTC_USDC": { // "ticker_id": "BTC_USDC", // "base_currency": "BTC", // "quote_currency": "USDC", // "last_price": 25728.0, // "base_volume": 552.048, // "quote_volume": 14238632.207250029, // "price_change_percent_24h": -0.6348599635253989 // } // } // var tickers interface{} = ObjectValues(response) ch <- this.ParseTickers(tickers, symbols) return nil }() return ch } func (this *vertex) QueryContracts(optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) // query contract addresses for sending order params := GetArg(optionalArgs, 0, map[string]interface{} {}) _ = params var cachedContracts interface{} = this.SafeDict(this.Options, "v1contracts") if IsTrue(!IsEqual(cachedContracts, nil)) { ch <- cachedContracts return nil } var request interface{} = map[string]interface{} { "type": "contracts", } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) AddElementToObject(this.Options, "v1contracts", data) ch <- data return nil }() return ch } func (this *vertex) Nonce() interface{} { return Subtract(this.Milliseconds(), GetValue(this.Options, "timeDifference")) } func (this *vertex) HashMessage(message interface{}) interface{} { return Add("0x", this.Hash(message, keccak, "hex")) } func (this *vertex) SignHash(hash interface{}, privateKey interface{}) interface{} { var signature interface{} = Ecdsa(Slice(hash, OpNeg(64), nil), Slice(privateKey, OpNeg(64), nil), secp256k1, nil) var r interface{} = GetValue(signature, "r") var s interface{} = GetValue(signature, "s") var v interface{} = this.IntToBase16(this.Sum(27, GetValue(signature, "v"))) return Add(Add(Add("0x", PadStart(r, 64, "0")), PadStart(s, 64, "0")), v) } func (this *vertex) SignMessage(message interface{}, privateKey interface{}) interface{} { return this.SignHash(this.HashMessage(message), Slice(privateKey, OpNeg(64), nil)) } func (this *vertex) BuildSig(chainId interface{}, messageTypes interface{}, message interface{}, optionalArgs ...interface{}) interface{} { verifyingContractAddress := GetArg(optionalArgs, 0, "") _ = verifyingContractAddress var domain interface{} = map[string]interface{} { "chainId": chainId, "name": "Vertex", "verifyingContract": verifyingContractAddress, "version": "0.0.1", } var msg interface{} = this.EthEncodeStructuredData(domain, messageTypes, message) var signature interface{} = this.SignMessage(msg, this.PrivateKey) return signature } func (this *vertex) BuildCreateOrderSig(message interface{}, chainId interface{}, verifyingContractAddress interface{}) interface{} { var messageTypes interface{} = map[string]interface{} { "Order": []interface{}{map[string]interface{} { "name": "sender", "type": "bytes32", }, map[string]interface{} { "name": "priceX18", "type": "int128", }, map[string]interface{} { "name": "amount", "type": "int128", }, map[string]interface{} { "name": "expiration", "type": "uint64", }, map[string]interface{} { "name": "nonce", "type": "uint64", }}, } return this.BuildSig(chainId, messageTypes, message, verifyingContractAddress) } func (this *vertex) BuildListTriggerTxSig(message interface{}, chainId interface{}, verifyingContractAddress interface{}) interface{} { var messageTypes interface{} = map[string]interface{} { "ListTriggerOrders": []interface{}{map[string]interface{} { "name": "sender", "type": "bytes32", }, map[string]interface{} { "name": "recvTime", "type": "uint64", }}, } return this.BuildSig(chainId, messageTypes, message, verifyingContractAddress) } func (this *vertex) BuildCancelAllOrdersSig(message interface{}, chainId interface{}, verifyingContractAddress interface{}) interface{} { var messageTypes interface{} = map[string]interface{} { "CancellationProducts": []interface{}{map[string]interface{} { "name": "sender", "type": "bytes32", }, map[string]interface{} { "name": "productIds", "type": "uint32[]", }, map[string]interface{} { "name": "nonce", "type": "uint64", }}, } return this.BuildSig(chainId, messageTypes, message, verifyingContractAddress) } func (this *vertex) BuildCancelOrdersSig(message interface{}, chainId interface{}, verifyingContractAddress interface{}) interface{} { var messageTypes interface{} = map[string]interface{} { "Cancellation": []interface{}{map[string]interface{} { "name": "sender", "type": "bytes32", }, map[string]interface{} { "name": "productIds", "type": "uint32[]", }, map[string]interface{} { "name": "digests", "type": "bytes32[]", }, map[string]interface{} { "name": "nonce", "type": "uint64", }}, } return this.BuildSig(chainId, messageTypes, message, verifyingContractAddress) } func (this *vertex) BuildWithdrawSig(message interface{}, chainId interface{}, verifyingContractAddress interface{}) interface{} { var messageTypes interface{} = map[string]interface{} { "WithdrawCollateral": []interface{}{map[string]interface{} { "name": "sender", "type": "bytes32", }, map[string]interface{} { "name": "productId", "type": "uint32", }, map[string]interface{} { "name": "amount", "type": "uint128", }, map[string]interface{} { "name": "nonce", "type": "uint64", }}, } return this.BuildSig(chainId, messageTypes, message, verifyingContractAddress) } func (this *vertex) ConvertAddressToSender(address interface{}) interface{} { var sender interface{} = Add(address, "64656661756c74") return PadEnd(sender, 66, "0") } func (this *vertex) GetNonce(now interface{}, expiration interface{}) interface{} { if IsTrue(IsEqual(now, nil)) { now = this.Nonce() } // nonce = ((now + expiration) << 20) + 1000 // 1 << 20 = 1048576 return Precise.StringAdd(Precise.StringMul(Precise.StringAdd(this.NumberToString(now), this.NumberToString(expiration)), "1048576"), "1000") } func (this *vertex) GetExpiration(now interface{}, timeInForce interface{}, postOnly interface{}, reduceOnly interface{}) interface{} { var expiration interface{} = Precise.StringAdd(this.NumberToString(now), "86400") if IsTrue(IsEqual(timeInForce, "ioc")) { // 1 << 62 = 4611686018427387904 expiration = Precise.StringOr(expiration, "4611686018427387904") } else if IsTrue(IsEqual(timeInForce, "fok")) { // 2 << 62 = 9223372036854775808 expiration = Precise.StringOr(expiration, "9223372036854775808") } else if IsTrue(postOnly) { // 3 << 62 = 13835058055282163712 expiration = Precise.StringOr(expiration, "13835058055282163712") } if IsTrue(reduceOnly) { // 1 << 61 = 2305843009213693952 expiration = Precise.StringOr(expiration, "2305843009213693952") } return expiration } func (this *vertex) GetAmount(amount interface{}, side interface{}) interface{} { var amountString interface{} = this.NumberToString(amount) if IsTrue(IsEqual(side, "sell")) { if IsTrue(IsGreaterThan(amount, 0)) { // amount *= -1; amountString = Precise.StringMul(amountString, "-1") } } else { if IsTrue(IsLessThan(amount, 0)) { // amount *= -1; amountString = Precise.StringMul(amountString, "-1") } } return amountString } /** * @method * @name vertex#createOrder * @description create a trade order * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/executes/place-order * @see https://docs.vertexprotocol.com/developer-resources/api/trigger/executes/place-order * @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.timeInForce] ioc, fok * @param {bool} [params.postOnly] true or false whether the order is post-only * @param {bool} [params.reduceOnly] true or false whether the order is reduce-only, only works for ioc and fok order * @param {float} [params.triggerPrice] The price at which a trigger order is triggered at * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) 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 this.CheckRequiredCredentials() var marketType interface{} = ToLower(typeVar) var isMarketOrder interface{} = IsEqual(marketType, "market") if IsTrue(IsTrue(isMarketOrder) && IsTrue(IsEqual(price, nil))) { panic(ArgumentsRequired(Add(this.Id, " createOrder() requires a price argument for market order"))) } retRes18208 := (<-this.LoadMarkets()) PanicOnError(retRes18208) var market interface{} = this.Market(symbol) var marketId interface{} = this.ParseToInt(GetValue(market, "id")) contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var bookAddresses interface{} = this.SafeList(contracts, "book_addrs", []interface{}{}) var verifyingContractAddress interface{} = this.SafeString(bookAddresses, marketId) var defaultTimeInForce interface{} = Ternary(IsTrue((isMarketOrder)), "fok", nil) var timeInForce interface{} = this.SafeStringLower(params, "timeInForce", defaultTimeInForce) var postOnly interface{} = this.SafeBool(params, "postOnly", false) var reduceOnly interface{} = this.SafeBool(params, "reduceOnly", false) var triggerPrice interface{} = this.SafeString2(params, "triggerPrice", "stopPrice") var stopLossPrice interface{} = this.SafeString(params, "stopLossPrice", triggerPrice) var takeProfitPrice interface{} = this.SafeString(params, "takeProfitPrice") var isTrigger interface{} = (IsTrue(stopLossPrice) || IsTrue(takeProfitPrice)) var now interface{} = this.Nonce() var nonce interface{} = this.GetNonce(now, 90000) if IsTrue(IsTrue(postOnly) && IsTrue(reduceOnly)) { panic(NotSupported(Add(this.Id, " reduceOnly not supported when postOnly is enabled"))) } var expiration interface{} = this.GetExpiration(now, timeInForce, postOnly, reduceOnly) if IsTrue(isTrigger) { // 1 << 63 = 9223372036854775808 nonce = Precise.StringOr(nonce, "9223372036854775808") } var amountString interface{} = this.GetAmount(amount, side) var order interface{} = map[string]interface{} { "sender": this.ConvertAddressToSender(this.WalletAddress), "priceX18": this.ConvertToX18(this.PriceToPrecision(symbol, price)), "amount": this.ConvertToX18(this.AmountToPrecision(symbol, amountString)), "expiration": expiration, "nonce": nonce, } var request interface{} = map[string]interface{} { "place_order": map[string]interface{} { "product_id": marketId, "order": map[string]interface{} { "sender": GetValue(order, "sender"), "priceX18": GetValue(order, "priceX18"), "amount": GetValue(order, "amount"), "expiration": this.NumberToString(GetValue(order, "expiration")), "nonce": GetValue(order, "nonce"), }, "signature": this.BuildCreateOrderSig(order, chainId, verifyingContractAddress), "id": this.SafeInteger(this.Options, "brokerId", 5930043274845996), }, } params = this.Omit(params, []interface{}{"timeInForce", "reduceOnly", "postOnly", "triggerPrice", "stopPrice", "stopLossPrice", "takeProfitPrice"}) var response interface{} = nil if IsTrue(isTrigger) { var trigger interface{} = map[string]interface{} {} if IsTrue(!IsEqual(stopLossPrice, nil)) { AddElementToObject(trigger, "last_price_below", this.ConvertToX18(stopLossPrice)) } else if IsTrue(!IsEqual(takeProfitPrice, nil)) { AddElementToObject(trigger, "last_price_above", this.ConvertToX18(takeProfitPrice)) } AddElementToObject(GetValue(request, "place_order"), "trigger", trigger) response = (<-this.V1TriggerPostExecute(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V1GatewayPostExecute(this.Extend(request, params))) PanicOnError(response) } // // { // "status": "success", // "signature": {signature}, // "data": { // "digest": {order digest} // }, // "request_type": "execute_place_order" // "id": 100 // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) ch <- this.SafeOrder(map[string]interface{} { "id": this.SafeString(data, "digest"), }) return nil }() return ch } /** * @method * @name vertex#editOrder * @description edit a trade order * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/executes/cancel-and-place * @param {string} id cancel order id * @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.timeInForce] ioc, fok * @param {bool} [params.postOnly] true or false whether the order is post-only * @param {bool} [params.reduceOnly] true or false whether the order is reduce-only, only works for ioc and fok order * @param {float} [params.triggerPrice] The price at which a trigger order is triggered at * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) EditOrder(id interface{}, symbol interface{}, typeVar interface{}, side interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) amount := GetArg(optionalArgs, 0, nil) _ = amount price := GetArg(optionalArgs, 1, nil) _ = price params := GetArg(optionalArgs, 2, map[string]interface{} {}) _ = params this.CheckRequiredCredentials() var marketType interface{} = ToLower(typeVar) var isMarketOrder interface{} = IsEqual(marketType, "market") if IsTrue(IsTrue(isMarketOrder) && IsTrue(IsEqual(price, nil))) { panic(ArgumentsRequired(Add(this.Id, " editOrder() requires a price argument for market order"))) } retRes19238 := (<-this.LoadMarkets()) PanicOnError(retRes19238) var market interface{} = this.Market(symbol) var marketId interface{} = this.ParseToInt(GetValue(market, "id")) var defaultTimeInForce interface{} = Ternary(IsTrue((isMarketOrder)), "fok", nil) var timeInForce interface{} = this.SafeStringLower(params, "timeInForce", defaultTimeInForce) var postOnly interface{} = this.SafeBool(params, "postOnly", false) var reduceOnly interface{} = this.SafeBool(params, "reduceOnly", false) var triggerPrice interface{} = this.SafeString2(params, "triggerPrice", "stopPrice") var stopLossPrice interface{} = this.SafeString(params, "stopLossPrice", triggerPrice) var takeProfitPrice interface{} = this.SafeString(params, "takeProfitPrice") var isTrigger interface{} = (IsTrue(stopLossPrice) || IsTrue(takeProfitPrice)) contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var bookAddresses interface{} = this.SafeList(contracts, "book_addrs", []interface{}{}) var verifyingContractAddressOrder interface{} = this.SafeString(bookAddresses, marketId) var verifyingContractAddressCancel interface{} = this.SafeString(contracts, "endpoint_addr") var now interface{} = this.Nonce() var nonce interface{} = this.GetNonce(now, 90000) var sender interface{} = this.ConvertAddressToSender(this.WalletAddress) if IsTrue(IsTrue(postOnly) && IsTrue(reduceOnly)) { panic(NotSupported(Add(this.Id, " reduceOnly not supported when postOnly is enabled"))) } if IsTrue(isTrigger) { panic(NotSupported(Add(this.Id, " editOrder() not supported for trigger order"))) } var expiration interface{} = this.GetExpiration(now, timeInForce, postOnly, reduceOnly) var amountString interface{} = this.GetAmount(amount, side) var order interface{} = map[string]interface{} { "sender": sender, "priceX18": this.ConvertToX18(this.PriceToPrecision(symbol, price)), "amount": this.ConvertToX18(this.AmountToPrecision(symbol, amountString)), "expiration": expiration, "nonce": nonce, } var cancels interface{} = map[string]interface{} { "sender": sender, "productIds": []interface{}{marketId}, "digests": []interface{}{id}, "nonce": nonce, } var request interface{} = map[string]interface{} { "cancel_and_place": map[string]interface{} { "cancel_tx": map[string]interface{} { "sender": GetValue(cancels, "sender"), "productIds": GetValue(cancels, "productIds"), "digests": GetValue(cancels, "digests"), "nonce": this.NumberToString(GetValue(cancels, "nonce")), }, "cancel_signature": this.BuildCancelOrdersSig(cancels, chainId, verifyingContractAddressCancel), "place_order": map[string]interface{} { "product_id": marketId, "order": map[string]interface{} { "sender": GetValue(order, "sender"), "priceX18": GetValue(order, "priceX18"), "amount": GetValue(order, "amount"), "expiration": this.NumberToString(GetValue(order, "expiration")), "nonce": GetValue(order, "nonce"), }, "signature": this.BuildCreateOrderSig(order, chainId, verifyingContractAddressOrder), "id": this.SafeInteger(this.Options, "brokerId", 5930043274845996), }, }, } params = this.Omit(params, []interface{}{"timeInForce", "reduceOnly", "postOnly", "triggerPrice", "stopPrice", "stopLossPrice", "takeProfitPrice"}) response:= (<-this.V1GatewayPostExecute(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "signature": {signature}, // "data": { // "digest": {order digest} // }, // "request_type": "execute_cancel_and_place" // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) ch <- this.SafeOrder(map[string]interface{} { "id": this.SafeString(data, "digest"), }) return nil }() return ch } func (this *vertex) ParseOrderStatus(status interface{}) interface{} { if IsTrue(!IsEqual(status, nil)) { var statuses interface{} = map[string]interface{} { "pending": "open", } if IsTrue(IsString(status)) { return this.SafeString(statuses, status, status) } var statusCancelled interface{} = this.SafeDict(status, "cancelled") if IsTrue(!IsEqual(statusCancelled, nil)) { return "canceled" } var statusTriggered interface{} = this.SafeDict(status, "triggered", map[string]interface{} {}) var triggeredStatus interface{} = this.SafeString(statusTriggered, "status", "failure") if IsTrue(IsEqual(triggeredStatus, "success")) { return "closed" } return "canceled" } return status } func (this *vertex) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{} { // // { // "product_id": 1, // "sender": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43000000000000000000000000", // "price_x18": "1000000000000000000", // "amount": "1000000000000000000", // "expiration": "2000000000", // "nonce": "1", // "unfilled_amount": "1000000000000000000", // "digest": "0x0000000000000000000000000000000000000000000000000000000000000000", // "placed_at": 1681951347, // "order_type": "ioc" // } // stop order // { // "order": { // "order": { // "sender": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43000000000000000000000000", // "priceX18": "1000000000000000000", // "amount": "1000000000000000000", // "expiration": "2000000000", // "nonce": "1", // }, // "signature": "0x...", // "product_id": 1, // "spot_leverage": true, // "trigger": { // "price_above": "1000000000000000000" // }, // "digest": "0x..." // }, // "status": "pending", // "updated_at": 1688768157050 // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(order, "product_id") var timestamp interface{} = this.SafeTimestamp(order, "placed_at") var amount interface{} = this.SafeString(order, "amount") var price interface{} = this.SafeString(order, "price_x18") var remaining interface{} = this.SafeString(order, "unfilled_amount") var triggerPriceNum interface{} = nil var status interface{} = this.SafeValue(order, "status") if IsTrue(!IsEqual(status, nil)) { // trigger order var outerOrder interface{} = this.SafeDict(order, "order", map[string]interface{} {}) var innerOrder interface{} = this.SafeDict(outerOrder, "order", map[string]interface{} {}) marketId = this.SafeString(outerOrder, "product_id") amount = this.SafeString(innerOrder, "amount") price = this.SafeString(innerOrder, "priceX18") timestamp = this.SafeTimestamp(order, "updated_at") var trigger interface{} = this.SafeDict(outerOrder, "trigger", map[string]interface{} {}) var triggerPrice interface{} = this.SafeStringN(trigger, []interface{}{"price_above", "price_below", "last_price_above", "last_price_below"}) if IsTrue(!IsEqual(triggerPrice, nil)) { triggerPriceNum = this.ParseToNumeric(this.ConvertFromX18(triggerPrice)) } } market = this.SafeMarket(marketId, market) var symbol interface{} = GetValue(market, "symbol") var priceNum interface{} = nil if IsTrue(!IsEqual(price, nil)) { priceNum = this.ParseToNumeric(this.ConvertFromX18(price)) } var amountNum interface{} = nil if IsTrue(!IsEqual(amount, nil)) { amountNum = this.ParseToNumeric(this.ConvertFromX18(amount)) } var remainingNum interface{} = nil if IsTrue(!IsEqual(remaining, nil)) { remainingNum = this.ParseToNumeric(this.ConvertFromX18(remaining)) } var side interface{} = nil if IsTrue(IsTrue(!IsEqual(amountNum, nil)) && IsTrue(!IsEqual(remainingNum, nil))) { side = Ternary(IsTrue((IsTrue(IsLessThan(amountNum, 0)) || IsTrue(IsLessThan(remainingNum, 0)))), "sell", "buy") } var tif interface{} = this.ParseTimeInForce(this.SafeString(order, "order_type")) var isPostOnly interface{} = (IsEqual(tif, "PO")) return this.SafeOrder(map[string]interface{} { "info": order, "id": this.SafeString(order, "digest"), "clientOrderId": nil, "timestamp": timestamp, "datetime": this.Iso8601(timestamp), "lastTradeTimestamp": nil, "lastUpdateTimestamp": nil, "symbol": symbol, "type": nil, "timeInForce": tif, "postOnly": isPostOnly, "reduceOnly": nil, "side": side, "price": priceNum, "triggerPrice": triggerPriceNum, "amount": amountNum, "cost": nil, "average": nil, "filled": nil, "remaining": remainingNum, "status": this.ParseOrderStatus(status), "fee": nil, "trades": nil, }, market) } func (this *vertex) ParseTimeInForce(timeInForce interface{}) interface{} { var timeInForces interface{} = map[string]interface{} { "POST_ONLY": "PO", } return this.SafeStringUpper(timeInForces, timeInForce, timeInForce) } /** * @method * @name vertex#fetchOrder * @description fetches information on an order made by the user * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/order * @param {string} id the order id * @param {string} symbol unified symbol of the market the order was made in * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) 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 retRes21488 := (<-this.LoadMarkets()) PanicOnError(retRes21488) var market interface{} = this.Market(symbol) var request interface{} = map[string]interface{} { "type": "order", "product_id": this.ParseToInt(GetValue(market, "id")), "digest": id, } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "data": { // "product_id": 1, // "sender": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43000000000000000000000000", // "price_x18": "1000000000000000000", // "amount": "1000000000000000000", // "expiration": "2000000000", // "nonce": "1", // "unfilled_amount": "1000000000000000000", // "digest": "0x0000000000000000000000000000000000000000000000000000000000000000", // "placed_at": 1681951347, // "order_type": "ioc" // }, // "request_type": "query_order", // } // var data interface{} = this.SafeDict(response, "data") ch <- this.ParseOrder(data, market) return nil }() return ch } /** * @method * @name vertex#fetchOpenOrders * @description fetch all unfilled currently open orders * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/orders * @see https://docs.vertexprotocol.com/developer-resources/api/trigger/queries/list-trigger-orders * @param {string} symbol unified market symbol * @param {int} [since] the earliest time in ms to fetch open orders for * @param {int} [limit] the maximum number of open orders structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @param {string} [params.user] user address, will default to this.walletAddress if not provided * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) 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 this.CheckRequiredCredentials() retRes21948 := (<-this.LoadMarkets()) PanicOnError(retRes21948) var userAddress interface{} = nil userAddressparamsVariable := this.HandlePublicAddress("fetchOpenOrders", params); userAddress = GetValue(userAddressparamsVariable,0); params = GetValue(userAddressparamsVariable,1) var request interface{} = map[string]interface{} {} var market interface{} = nil var trigger interface{} = this.SafeBool2(params, "stop", "trigger") params = this.Omit(params, []interface{}{"stop", "trigger"}) if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "product_id", this.ParseToNumeric(GetValue(market, "id"))) } var response interface{} = nil if IsTrue(trigger) { contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var verifyingContractAddress interface{} = this.SafeString(contracts, "endpoint_addr") var tx interface{} = map[string]interface{} { "sender": this.ConvertAddressToSender(userAddress), "recvTime": Add(this.Nonce(), 90000), } AddElementToObject(request, "signature", this.BuildListTriggerTxSig(tx, chainId, verifyingContractAddress)) AddElementToObject(request, "tx", map[string]interface{} { "sender": GetValue(tx, "sender"), "recvTime": this.NumberToString(GetValue(tx, "recvTime")), }) AddElementToObject(request, "type", "list_trigger_orders") AddElementToObject(request, "pending", true) var until interface{} = this.SafeInteger(params, "until") params = this.Omit(params, "until") if IsTrue(!IsEqual(until, nil)) { AddElementToObject(request, "max_update_time", until) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) } response = (<-this.V1TriggerPostQuery(this.Extend(request, params))) PanicOnError(response) } else { this.CheckRequiredArgument("fetchOpenOrders", symbol, "symbol") AddElementToObject(request, "type", "subaccount_orders") AddElementToObject(request, "sender", this.ConvertAddressToSender(userAddress)) response = (<-this.V1GatewayPostQuery(this.Extend(request, params))) PanicOnError(response) } var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var orders interface{} = this.SafeList(data, "orders") ch <- this.ParseOrders(orders, market, since, limit) return nil }() return ch } /** * @method * @name vertex#fetchOrders * @description fetches information on multiple orders made by the user * @see https://docs.vertexprotocol.com/developer-resources/api/trigger/queries/list-trigger-orders * @param {string} symbol unified market symbol * @param {int} [since] the earliest time in ms to fetch open orders for * @param {int} [limit] the maximum number of open orders structures to retrieve * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @param {string} [params.user] user address, will default to this.walletAddress if not provided * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) 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 this.CheckRequiredCredentials() var trigger interface{} = this.SafeBool2(params, "stop", "trigger") params = this.Omit(params, []interface{}{"stop", "trigger"}) if !IsTrue(trigger) { panic(NotSupported(Add(this.Id, " fetchOrders only support trigger orders"))) } var userAddress interface{} = nil userAddressparamsVariable := this.HandlePublicAddress("fetchOrders", params); userAddress = GetValue(userAddressparamsVariable,0); params = GetValue(userAddressparamsVariable,1) retRes23188 := (<-this.LoadMarkets()) PanicOnError(retRes23188) var market interface{} = nil var request interface{} = map[string]interface{} { "type": "list_trigger_orders", "pending": false, } if IsTrue(!IsEqual(symbol, nil)) { market = this.Market(symbol) AddElementToObject(request, "product_id", this.ParseToNumeric(GetValue(market, "id"))) } contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var verifyingContractAddress interface{} = this.SafeString(contracts, "endpoint_addr") var tx interface{} = map[string]interface{} { "sender": this.ConvertAddressToSender(userAddress), "recvTime": Add(this.Nonce(), 90000), } AddElementToObject(request, "signature", this.BuildListTriggerTxSig(tx, chainId, verifyingContractAddress)) AddElementToObject(request, "tx", map[string]interface{} { "sender": GetValue(tx, "sender"), "recvTime": this.NumberToString(GetValue(tx, "recvTime")), }) var until interface{} = this.SafeInteger(params, "until") params = this.Omit(params, "until") if IsTrue(!IsEqual(until, nil)) { AddElementToObject(request, "max_update_time", until) } if IsTrue(!IsEqual(limit, nil)) { AddElementToObject(request, "limit", limit) } response:= (<-this.V1TriggerPostQuery(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "data": { // "orders": [ // { // "order": { // "order": { // "sender": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43000000000000000000000000", // "priceX18": "1000000000000000000", // "amount": "1000000000000000000", // "expiration": "2000000000", // "nonce": "1", // }, // "signature": "0x...", // "product_id": 1, // "spot_leverage": true, // "trigger": { // "price_above": "1000000000000000000" // }, // "digest": "0x..." // }, // "status": "pending", // "updated_at": 1688768157050 // } // ] // }, // "request_type": "query_list_trigger_orders" // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var orders interface{} = this.SafeList(data, "orders") ch <- this.ParseOrders(orders, market, since, limit) return nil }() return ch } /** * @method * @name vertex#cancelAllOrders * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/executes/cancel-product-orders * @see https://docs.vertexprotocol.com/developer-resources/api/trigger/executes/cancel-product-orders * @description cancel all open orders in a market * @param {string} symbol unified market symbol * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {boolean} [params.trigger] whether the order is a trigger/algo order * @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) 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 this.CheckRequiredCredentials() retRes23978 := (<-this.LoadMarkets()) PanicOnError(retRes23978) if IsTrue(IsEqual(symbol, nil)) { panic(ArgumentsRequired(Add(this.Id, " cancelAllOrders() requires a symbol argument"))) } var market interface{} = this.Market(symbol) var marketId interface{} = GetValue(market, "id") contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var verifyingContractAddress interface{} = this.SafeString(contracts, "endpoint_addr") var now interface{} = this.Nonce() var nonce interface{} = this.GetNonce(now, 90000) var cancels interface{} = map[string]interface{} { "sender": this.ConvertAddressToSender(this.WalletAddress), "productIds": []interface{}{this.ParseToNumeric(marketId)}, "nonce": nonce, } var request interface{} = map[string]interface{} { "cancel_product_orders": map[string]interface{} { "tx": map[string]interface{} { "sender": GetValue(cancels, "sender"), "productIds": GetValue(cancels, "productIds"), "nonce": this.NumberToString(GetValue(cancels, "nonce")), }, "signature": this.BuildCancelAllOrdersSig(cancels, chainId, verifyingContractAddress), }, } var trigger interface{} = this.SafeBool2(params, "stop", "trigger") params = this.Omit(params, []interface{}{"stop", "trigger"}) var response interface{} = nil if IsTrue(trigger) { response = (<-this.V1TriggerPostExecute(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V1GatewayPostExecute(this.Extend(request, params))) PanicOnError(response) } ch <- response return nil }() return ch } /** * @method * @name vertex#cancelOrder * @description cancels an open order * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/executes/cancel-orders * @see https://docs.vertexprotocol.com/developer-resources/api/trigger/executes/cancel-orders * @param {string} id order id * @param {string} symbol unified symbol of the market the order was made in * @param {object} [params] extra parameters specific to the exchange API endpoint * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure} */ func (this *vertex) 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 retRes247915 := (<-this.CancelOrders([]interface{}{id}, symbol, params)) PanicOnError(retRes247915) ch <- retRes247915 return nil }() return ch } /** * @method * @name vertex#cancelOrders * @description cancel multiple orders * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/executes/cancel-orders * @see https://docs.vertexprotocol.com/developer-resources/api/trigger/executes/cancel-orders * @param {string[]} ids order ids * @param {string} [symbol] unified market symbol * @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 *vertex) 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 this.CheckRequiredCredentials() if IsTrue(IsEqual(symbol, nil)) { panic(ArgumentsRequired(Add(this.Id, " cancelOrders() requires a symbol argument"))) } retRes24988 := (<-this.LoadMarkets()) PanicOnError(retRes24988) var market interface{} = this.Market(symbol) var marketId interface{} = GetValue(market, "id") contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var verifyingContractAddress interface{} = this.SafeString(contracts, "endpoint_addr") var now interface{} = this.Nonce() var nonce interface{} = this.GetNonce(now, 90000) var cancels interface{} = map[string]interface{} { "sender": this.ConvertAddressToSender(this.WalletAddress), "productIds": []interface{}{}, "digests": ids, "nonce": nonce, } var productIds interface{} = GetValue(cancels, "productIds") var marketIdNum interface{} = this.ParseToNumeric(marketId) for i := 0; IsLessThan(i, GetArrayLength(ids)); i++ { AppendToArray(&productIds,marketIdNum) } var request interface{} = map[string]interface{} { "cancel_orders": map[string]interface{} { "tx": map[string]interface{} { "sender": GetValue(cancels, "sender"), "productIds": productIds, "digests": GetValue(cancels, "digests"), "nonce": this.NumberToString(GetValue(cancels, "nonce")), }, "signature": this.BuildCancelOrdersSig(cancels, chainId, verifyingContractAddress), }, } var trigger interface{} = this.SafeBool2(params, "stop", "trigger") params = this.Omit(params, []interface{}{"stop", "trigger"}) var response interface{} = nil if IsTrue(trigger) { response = (<-this.V1TriggerPostExecute(this.Extend(request, params))) PanicOnError(response) } else { response = (<-this.V1GatewayPostExecute(this.Extend(request, params))) PanicOnError(response) } ch <- response return nil }() return ch } /** * @method * @name vertex#fetchBalance * @description query for balance and get the amount of funds available for trading or funds locked in orders * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/subaccount-info * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.user] user address, will default to this.walletAddress if not provided * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure} */ func (this *vertex) 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 var userAddress interface{} = nil userAddressparamsVariable := this.HandlePublicAddress("fetchBalance", params); userAddress = GetValue(userAddressparamsVariable,0); params = GetValue(userAddressparamsVariable,1) var request interface{} = map[string]interface{} { "type": "subaccount_info", "subaccount": this.ConvertAddressToSender(userAddress), } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "data": { // "subaccount": "0x265167ddfac55365d6ff07fc5943276319aa6b9f64656661756c740000000000", // "exists": true, // "healths": [ // { // "assets": "75323297691833342306", // "liabilities": "46329556869051092241", // "health": "28993740822782250065" // }, // { // "assets": "75323297691833342306", // "liabilities": "35968911700887320741", // "health": "39354385990946021565" // }, // { // "assets": "80796966663601107565", // "liabilities": "0", // "health": "80796966663601107565" // } // ], // "health_contributions": [ // [ // "75323297691833340000", // "75323297691833340000", // "75323297691833340000" // ], // [ // "0", // "0", // "0" // ], // [ // "0", // "0", // "0" // ], // [ // "0", // "0", // "0" // ], // [ // "-46329556869051090000", // "-35968911700887323000", // "5473668971767765000" // ] // ], // "spot_count": 3, // "perp_count": 2, // "spot_balances": [ // { // "product_id": 1, // "lp_balance": { // "amount": "0" // }, // "balance": { // "amount": "0", // "last_cumulative_multiplier_x18": "1003419811982007193" // } // }, // { // "product_id": 3, // "lp_balance": { // "amount": "0" // }, // "balance": { // "amount": "0", // "last_cumulative_multiplier_x18": "1007584195035969404" // } // }, // { // "product_id": 0, // "lp_balance": { // "amount": "0" // }, // "balance": { // "amount": "75323297691833342306", // "last_cumulative_multiplier_x18": "1000000002391497578" // } // } // ], // "perp_balances": [ // { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "-284321955122859921" // }, // "balance": { // "amount": "0", // "v_quote_balance": "0", // "last_cumulative_funding_x18": "6363466629611946777168" // } // }, // { // "product_id": 4, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "-90979748449893411" // }, // "balance": { // "amount": "-200000000000000000", // "v_quote_balance": "419899475698318625259", // "last_cumulative_funding_x18": "141182516563970577208" // } // } // ], // "spot_products": [ // { // "product_id": 1, // "oracle_price_x18": "30217830336443750750000", // "risk": { // "long_weight_initial_x18": "750000000000000000", // "short_weight_initial_x18": "1250000000000000000", // "long_weight_maintenance_x18": "800000000000000000", // "short_weight_maintenance_x18": "1200000000000000000", // "large_position_penalty_x18": "0" // }, // "config": { // "token": "0x5cc7c91690b2cbaee19a513473d73403e13fb431", // "interest_inflection_util_x18": "800000000000000000", // "interest_floor_x18": "10000000000000000", // "interest_small_cap_x18": "40000000000000000", // "interest_large_cap_x18": "1000000000000000000" // }, // "state": { // "cumulative_deposits_multiplier_x18": "1001304691727847318", // "cumulative_borrows_multiplier_x18": "1003419811982007193", // "total_deposits_normalized": "213107447159798397806318", // "total_borrows_normalized": "4907820740150097483532" // }, // "lp_state": { // "supply": "1304981417419495030893348", // "quote": { // "amount": "2048495687410669565222259", // "last_cumulative_multiplier_x18": "1000000002391497578" // }, // "base": { // "amount": "67623029247538886515", // "last_cumulative_multiplier_x18": "1001304691727847318" // } // }, // "book_info": { // "size_increment": "1000000000000000", // "price_increment_x18": "1000000000000000000", // "min_size": "10000000000000000", // "collected_fees": "8865582805773573662738183", // "lp_spread_x18": "3000000000000000" // } // }, // { // "product_id": 3, // "oracle_price_x18": "2075217009708333333333", // "risk": { // "long_weight_initial_x18": "750000000000000000", // "short_weight_initial_x18": "1250000000000000000", // "long_weight_maintenance_x18": "800000000000000000", // "short_weight_maintenance_x18": "1200000000000000000", // "large_position_penalty_x18": "0" // }, // "config": { // "token": "0xcc59686e3a32fb104c8ff84dd895676265efb8a6", // "interest_inflection_util_x18": "800000000000000000", // "interest_floor_x18": "10000000000000000", // "interest_small_cap_x18": "40000000000000000", // "interest_large_cap_x18": "1000000000000000000" // }, // "state": { // "cumulative_deposits_multiplier_x18": "1003722507760089346", // "cumulative_borrows_multiplier_x18": "1007584195035969404", // "total_deposits_normalized": "232750303205807326418622", // "total_borrows_normalized": "110730726549469855171025" // }, // "lp_state": { // "supply": "902924999999999999774268", // "quote": { // "amount": "1165328092090344104989049", // "last_cumulative_multiplier_x18": "1000000002391497578" // }, // "base": { // "amount": "563265647183403990588", // "last_cumulative_multiplier_x18": "1003722507760089346" // } // }, // "book_info": { // "size_increment": "10000000000000000", // "price_increment_x18": "100000000000000000", // "min_size": "100000000000000000", // "collected_fees": "1801521329724633001446457", // "lp_spread_x18": "3000000000000000" // } // }, // { // "product_id": 0, // "oracle_price_x18": "1000000000000000000", // "risk": { // "long_weight_initial_x18": "1000000000000000000", // "short_weight_initial_x18": "1000000000000000000", // "long_weight_maintenance_x18": "1000000000000000000", // "short_weight_maintenance_x18": "1000000000000000000", // "large_position_penalty_x18": "0" // }, // "config": { // "token": "0x179522635726710dd7d2035a81d856de4aa7836c", // "interest_inflection_util_x18": "800000000000000000", // "interest_floor_x18": "10000000000000000", // "interest_small_cap_x18": "40000000000000000", // "interest_large_cap_x18": "1000000000000000000" // }, // "state": { // "cumulative_deposits_multiplier_x18": "1000000002391497578", // "cumulative_borrows_multiplier_x18": "1001593395547514024", // "total_deposits_normalized": "60000256267437588885818752247843", // "total_borrows_normalized": "391445043137305055810336885" // }, // "lp_state": { // "supply": "0", // "quote": { // "amount": "0", // "last_cumulative_multiplier_x18": "0" // }, // "base": { // "amount": "0", // "last_cumulative_multiplier_x18": "0" // } // }, // "book_info": { // "size_increment": "0", // "price_increment_x18": "0", // "min_size": "0", // "collected_fees": "0", // "lp_spread_x18": "0" // } // } // ], // "perp_products": [ // { // "product_id": 2, // "oracle_price_x18": "30219079716463070000000", // "risk": { // "long_weight_initial_x18": "875000000000000000", // "short_weight_initial_x18": "1125000000000000000", // "long_weight_maintenance_x18": "900000000000000000", // "short_weight_maintenance_x18": "1100000000000000000", // "large_position_penalty_x18": "0" // }, // "state": { // "cumulative_funding_long_x18": "6363466629611946777168", // "cumulative_funding_short_x18": "6363466629611946777168", // "available_settle": "100612314098927536086702448", // "open_interest": "57975708279961875623240" // }, // "lp_state": { // "supply": "783207415944433511804197", // "last_cumulative_funding_x18": "6363466629611946777168", // "cumulative_funding_per_lp_x18": "-284321955122859921", // "base": "37321000000000000000", // "quote": "1150991638943862165224593" // }, // "book_info": { // "size_increment": "1000000000000000", // "price_increment_x18": "1000000000000000000", // "min_size": "10000000000000000", // "collected_fees": "7738341933653651206856235", // "lp_spread_x18": "3000000000000000" // } // }, // { // "product_id": 4, // "oracle_price_x18": "2072129033632754300000", // "risk": { // "long_weight_initial_x18": "875000000000000000", // "short_weight_initial_x18": "1125000000000000000", // "long_weight_maintenance_x18": "900000000000000000", // "short_weight_maintenance_x18": "1100000000000000000", // "large_position_penalty_x18": "0" // }, // "state": { // "cumulative_funding_long_x18": "141182516563970577208", // "cumulative_funding_short_x18": "141182516563970577208", // "available_settle": "33807443862986950288685582", // "open_interest": "316343836992291503987611" // }, // "lp_state": { // "supply": "541756546038144467864559", // "last_cumulative_funding_x18": "141182516563970577208", // "cumulative_funding_per_lp_x18": "-90979748449893411", // "base": "362320000000000000000", // "quote": "750080187685127907834038" // }, // "book_info": { // "size_increment": "10000000000000000", // "price_increment_x18": "100000000000000000", // "min_size": "100000000000000000", // "collected_fees": "1893278317732551619694831", // "lp_spread_x18": "3000000000000000" // } // } // ] // }, // "request_type": "query_subaccount_info" // } // var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var balances interface{} = this.SafeList(data, "spot_balances", []interface{}{}) var result interface{} = map[string]interface{} { "info": response, } for i := 0; IsLessThan(i, GetArrayLength(balances)); i++ { var balance interface{} = GetValue(balances, i) var marketId interface{} = this.SafeString(balance, "product_id") var market interface{} = this.SafeMarket(marketId) var isUsdcMarketId interface{} = IsEqual(marketId, "0") if IsTrue(IsTrue(IsEqual(GetValue(market, "id"), nil)) && !IsTrue(isUsdcMarketId)) { continue } var baseId interface{} = Ternary(IsTrue((isUsdcMarketId)), "USDC", this.SafeString(market, "baseId")) var code interface{} = this.SafeCurrencyCode(baseId) var account interface{} = this.Account() var tokenBalance interface{} = this.SafeDict(balance, "balance", map[string]interface{} {}) var total interface{} = this.ConvertFromX18(this.SafeString(tokenBalance, "amount")) AddElementToObject(account, "total", total) AddElementToObject(result, code, account) } ch <- this.SafeBalance(result) return nil }() return ch } func (this *vertex) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{} { // // { // "product_id": 2, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "-284321955122859921" // }, // "balance": { // "amount": "0", // "v_quote_balance": "0", // "last_cumulative_funding_x18": "6363466629611946777168" // } // }, // { // "product_id": 4, // "lp_balance": { // "amount": "0", // "last_cumulative_funding_x18": "-90979748449893411" // }, // "balance": { // "amount": "-200000000000000000", // "v_quote_balance": "419899475698318625259", // "last_cumulative_funding_x18": "141182516563970577208" // } // } // market := GetArg(optionalArgs, 0, nil) _ = market var marketId interface{} = this.SafeString(position, "product_id") market = this.SafeMarket(marketId) var balance interface{} = this.SafeDict(position, "balance", map[string]interface{} {}) var contractSize interface{} = this.ConvertFromX18(this.SafeString(balance, "amount")) var side interface{} = "buy" if IsTrue(Precise.StringLt(contractSize, "1")) { side = "sell" } return this.SafePosition(map[string]interface{} { "info": position, "id": nil, "symbol": this.SafeString(market, "symbol"), "timestamp": nil, "datetime": nil, "lastUpdateTimestamp": nil, "initialMargin": nil, "initialMarginPercentage": nil, "maintenanceMargin": nil, "maintenanceMarginPercentage": nil, "entryPrice": nil, "notional": nil, "leverage": nil, "unrealizedPnl": nil, "contracts": nil, "contractSize": this.ParseToNumeric(contractSize), "marginRatio": nil, "liquidationPrice": nil, "markPrice": nil, "lastPrice": nil, "collateral": nil, "marginMode": "cross", "marginType": nil, "side": side, "percentage": nil, "hedged": nil, "stopLossPrice": nil, "takeProfitPrice": nil, }) } /** * @method * @name vertex#fetchPositions * @description fetch all open positions * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/subaccount-info * @param {string[]} [symbols] list of unified market symbols * @param {object} [params] extra parameters specific to the exchange API endpoint * @param {string} [params.user] user address, will default to this.walletAddress if not provided * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/#/?id=position-structure} */ func (this *vertex) 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 var userAddress interface{} = nil userAddressparamsVariable := this.HandlePublicAddress("fetchPositions", params); userAddress = GetValue(userAddressparamsVariable,0); params = GetValue(userAddressparamsVariable,1) var request interface{} = map[string]interface{} { "type": "subaccount_info", "subaccount": this.ConvertAddressToSender(userAddress), } response:= (<-this.V1GatewayGetQuery(this.Extend(request, params))) PanicOnError(response) // the response is the same as fetchBalance var data interface{} = this.SafeDict(response, "data", map[string]interface{} {}) var positions interface{} = this.SafeList(data, "perp_balances", []interface{}{}) symbols = this.MarketSymbols(symbols) var result interface{} = []interface{}{} for i := 0; IsLessThan(i, GetArrayLength(positions)); i++ { var position interface{} = this.Extend(this.ParsePosition(GetValue(positions, i), nil), params) if IsTrue(IsEqual(GetValue(position, "contractSize"), 0)) { continue } AppendToArray(&result,position) } ch <- this.FilterByArrayPositions(result, "symbol", symbols, false) return nil }() return ch } func (this *vertex) QueryNonces() <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) var request interface{} = map[string]interface{} { "type": "nonces", "address": this.WalletAddress, } response:= (<-this.V1GatewayGetQuery(request)) PanicOnError(response) // // { // "status":"success", // "data":{ // "tx_nonce": 0, // "order_nonce": 1753048133299863552 // }, // "request_type": "query_nonces", // } // ch <- this.SafeDict(response, "data", map[string]interface{} {}) return nil }() return ch } /** * @method * @name vertex#withdraw * @description make a withdrawal * @see https://docs.vertexprotocol.com/developer-resources/api/withdrawing-on-chain * @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 *vertex) Withdraw(code interface{}, amount interface{}, address interface{}, optionalArgs ...interface{}) <- chan interface{} { ch := make(chan interface{}) go func() interface{} { defer close(ch) defer ReturnPanicError(ch) tag := GetArg(optionalArgs, 0, nil) _ = tag params := GetArg(optionalArgs, 1, map[string]interface{} {}) _ = params this.CheckRequiredCredentials() retRes30488 := (<-this.LoadMarkets()) PanicOnError(retRes30488) var currency interface{} = this.Currency(code) contracts:= (<-this.QueryContracts()) PanicOnError(contracts) var chainId interface{} = this.SafeString(contracts, "chain_id") var verifyingContractAddress interface{} = this.SafeString(contracts, "endpoint_addr") nonces:= (<-this.QueryNonces()) PanicOnError(nonces) var nonce interface{} = this.SafeNumber(nonces, "tx_nonce") var withdraw interface{} = map[string]interface{} { "sender": this.ConvertAddressToSender(this.WalletAddress), "productId": this.ParseToNumeric(GetValue(currency, "id")), "amount": ToString(amount), "nonce": nonce, } var request interface{} = map[string]interface{} { "withdraw_collateral": map[string]interface{} { "tx": map[string]interface{} { "sender": GetValue(withdraw, "sender"), "productId": GetValue(withdraw, "productId"), "amount": GetValue(withdraw, "amount"), "nonce": this.NumberToString(GetValue(withdraw, "nonce")), }, "signature": this.BuildWithdrawSig(withdraw, chainId, verifyingContractAddress), }, } response:= (<-this.V1GatewayPostExecute(this.Extend(request, params))) PanicOnError(response) // // { // "status": "success", // "signature": {signature}, // "request_type": "execute_withdraw_collateral" // } // var transaction interface{} = this.ParseTransaction(response, currency) ch <- this.Extend(transaction, map[string]interface{} { "amount": amount, "address": address, }) return nil }() return ch } func (this *vertex) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{} { // // { // "status": "success", // "signature": {signature}, // "request_type": "execute_withdraw_collateral" // } // currency := GetArg(optionalArgs, 0, nil) _ = currency var code interface{} = nil if IsTrue(!IsEqual(currency, nil)) { code = GetValue(currency, "code") } return map[string]interface{} { "info": transaction, "id": nil, "txid": nil, "timestamp": nil, "datetime": nil, "addressFrom": nil, "address": nil, "addressTo": nil, "tagFrom": nil, "tag": nil, "tagTo": nil, "type": "withdrawal", "amount": nil, "currency": code, "status": this.ParseTransactionStatus(this.SafeString(transaction, "status")), "updated": nil, "network": nil, "comment": nil, "internal": nil, "fee": nil, } } func (this *vertex) ParseTransactionStatus(status interface{}) interface{} { var statuses interface{} = map[string]interface{} { "success": "ok", } return this.SafeString(statuses, status, status) } func (this *vertex) HandlePublicAddress(methodName interface{}, params interface{}) interface{} { var userAux interface{} = nil userAuxparamsVariable := this.HandleOptionAndParams(params, methodName, "user"); userAux = GetValue(userAuxparamsVariable,0); params = GetValue(userAuxparamsVariable,1) var user interface{} = userAux userparamsVariable := this.HandleOptionAndParams(params, methodName, "address", userAux); user = GetValue(userparamsVariable,0); params = GetValue(userparamsVariable,1) if IsTrue(IsTrue((!IsEqual(user, nil))) && IsTrue((!IsEqual(user, "")))) { return []interface{}{user, params} } if IsTrue(IsTrue((!IsEqual(this.WalletAddress, nil))) && IsTrue((!IsEqual(this.WalletAddress, "")))) { return []interface{}{this.WalletAddress, params} } panic(ArgumentsRequired(Add(Add(Add(this.Id, " "), methodName), "() requires a user parameter inside \\'params\\' or the wallet address set"))) } func (this *vertex) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{} { if !IsTrue(response) { return nil // fallback to default error handler } // // var status interface{} = this.SafeString(response, "status", "") if IsTrue(IsEqual(status, "failure")) { var message interface{} = this.SafeString(response, "error") var feedback interface{} = Add(Add(this.Id, " "), body) var errorCode interface{} = this.SafeString(response, "error_code") this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), errorCode, feedback) this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), message, feedback) panic(ExchangeError(feedback)) } return nil } func (this *vertex) 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 version interface{} = this.SafeString(api, 0) var typeVar interface{} = this.SafeString(api, 1) var url interface{} = this.ImplodeHostname(GetValue(GetValue(GetValue(this.Urls, "api"), version), typeVar)) if IsTrue(IsTrue(!IsEqual(version, "v1")) || IsTrue(!IsEqual(typeVar, "archive"))) { url = Add(Add(url, "/"), path) } if IsTrue(IsEqual(method, "POST")) { headers = map[string]interface{} { "Content-Type": "application/json", } body = this.Json(params) } else { if IsTrue(GetArrayLength(ObjectKeys(params))) { url = Add(url, Add("?", this.Urlencode(params))) } } if IsTrue(!IsEqual(path, "execute")) { // required encoding for public methods if IsTrue(!IsEqual(headers, nil)) { AddElementToObject(headers, "Accept-Encoding", "gzip") } else { headers = map[string]interface{} { "Accept-Encoding": "gzip", } } } return map[string]interface{} { "url": url, "method": method, "body": body, "headers": headers, } } func (this *vertex) Init(userConfig map[string]interface{}) { this.Exchange = Exchange{} this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this) this.Exchange.DerivedExchange = this }