ccxt-ir 4.3.46.0.3__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/vertex.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.vertex import ImplicitAPI
-from ccxt.base.types import Balances, Currencies, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction
+from ccxt.base.types import Any, Balances, Currencies, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -22,7 +22,7 @@ from ccxt.base.precise import Precise
 
 class vertex(Exchange, ImplicitAPI):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(vertex, self).describe(), {
             'id': 'vertex',
             'name': 'Vertex',
@@ -55,6 +55,8 @@ class vertex(Exchange, ImplicitAPI):
                 'createOrder': True,
                 'createOrders': True,
                 'createReduceOnlyOrder': True,
+                'createStopOrder': True,
+                'createTriggerOrder': True,
                 'editOrder': False,
                 'fetchAccounts': False,
                 'fetchBalance': True,
@@ -91,6 +93,7 @@ class vertex(Exchange, ImplicitAPI):
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
                 'fetchOpenInterestHistory': False,
+                'fetchOpenInterests': True,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
@@ -327,6 +330,72 @@ class vertex(Exchange, ImplicitAPI):
                 'timeDifference': 0,  # the difference between system clock and exchange server clock
                 'brokerId': 5930043274845996,
             },
+            'features': {
+                'default': {
+                    'sandbox': True,
+                    'createOrder': {
+                        'marginMode': False,
+                        'triggerPrice': True,  # todo
+                        'triggerDirection': False,
+                        'triggerPriceType': None,
+                        'stopLossPrice': True,  # todo
+                        'takeProfitPrice': True,  # todo
+                        'attachedStopLossTakeProfit': None,
+                        'timeInForce': {
+                            'IOC': False,
+                            'FOK': False,
+                            'PO': True,
+                            'GTD': True,
+                        },
+                        'hedged': False,
+                        'trailing': False,
+                        'leverage': False,
+                        'marketBuyByCost': True,  # todo
+                        'marketBuyRequiresPrice': True,  # todo fix implementation
+                        'selfTradePrevention': False,
+                        'iceberg': False,
+                    },
+                    'createOrders': None,
+                    'fetchMyTrades': {
+                        'marginMode': False,
+                        'limit': 500,
+                        'daysBack': 100000,  # todo
+                        'untilDays': None,
+                        'symbolRequired': False,
+                    },
+                    'fetchOrder': {
+                        'marginMode': False,
+                        'trigger': False,
+                        'trailing': False,
+                        'symbolRequired': True,
+                    },
+                    'fetchOpenOrders': {
+                        'marginMode': False,
+                        'limit': 500,
+                        'trigger': True,
+                        'trailing': False,
+                        'symbolRequired': False,
+                    },
+                    'fetchOrders': None,  # todo, only for trigger
+                    'fetchClosedOrders': None,  # todo through fetchOrders
+                    'fetchOHLCV': {
+                        'limit': 1000,
+                    },
+                },
+                'spot': {
+                    'extends': 'default',
+                },
+                'swap': {
+                    'linear': {
+                        'extends': 'default',
+                    },
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
         })
 
     def set_sandbox_mode(self, enabled):
@@ -388,11 +457,10 @@ class vertex(Exchange, ImplicitAPI):
             tickerId = self.safe_string(data, 'ticker_id')
             if (tickerId is not None) and (tickerId.find('PERP') > 0):
                 continue
-            id = self.safe_string(data, 'product_id')
             name = self.safe_string(data, 'symbol')
             code = self.safe_currency_code(name)
-            result[code] = {
-                'id': id,
+            result[code] = self.safe_currency_structure({
+                'id': self.safe_string(data, 'product_id'),
                 'name': name,
                 'code': code,
                 'precision': None,
@@ -412,7 +480,7 @@ class vertex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-            }
+            })
         return result
 
     def parse_market(self, market) -> Market:
@@ -553,7 +621,7 @@ class vertex(Exchange, ImplicitAPI):
             result.append(self.parse_market(rawMarket))
         return result
 
-    def fetch_time(self, params={}):
+    def fetch_time(self, params={}) -> Int:
         """
         fetches the current integer timestamp in milliseconds from the exchange server
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -561,7 +629,7 @@ class vertex(Exchange, ImplicitAPI):
         """
         response = self.v1GatewayGetTime(params)
         # 1717481623452
-        return self.parse_number(response)
+        return self.parse_to_int(response)
 
     def fetch_status(self, params={}):
         """
@@ -1327,16 +1395,74 @@ class vertex(Exchange, ImplicitAPI):
         #     }
         # }
         #
-        value = self.safe_number(interest, 'open_interest_usd')
+        marketId = self.safe_string(interest, 'ticker_id')
         return self.safe_open_interest({
-            'symbol': market['symbol'],
-            'openInterestAmount': None,
-            'openInterestValue': value,
+            'symbol': self.safe_symbol(marketId, market),
+            'openInterestAmount': self.safe_number(interest, 'open_interest'),
+            'openInterestValue': self.safe_number(interest, 'open_interest_usd'),
             'timestamp': None,
             'datetime': None,
             'info': interest,
         }, market)
 
+    def fetch_open_interests(self, symbols: Strings = None, params={}):
+        """
+        Retrieves the open interest for a list of symbols
+
+        https://docs.vertexprotocol.com/developer-resources/api/v2/contracts
+
+        :param str[] [symbols]: a list of unified CCXT market symbols
+        :param dict [params]: exchange specific parameters
+        :returns dict[]: a list of `open interest structures <https://docs.ccxt.com/#/?id=open-interest-structure>`
+        """
+        self.load_markets()
+        symbols = self.market_symbols(symbols)
+        response = self.v2ArchiveGetContracts(params)
+        #
+        #     {
+        #         "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
+        #         },
+        #     }
+        #
+        parsedSymbols = []
+        results = []
+        markets = list(response.keys())
+        if symbols is None:
+            symbols = []
+            for y in range(0, len(markets)):
+                tickerId = markets[y]
+                parsedTickerId = tickerId.split('-')
+                currentSymbol = parsedTickerId[0] + '/USDC:USDC'
+                if not self.in_array(currentSymbol, symbols):
+                    symbols.append(currentSymbol)
+        for i in range(0, len(markets)):
+            marketId = markets[i]
+            marketInner = self.safe_market(marketId)
+            openInterest = self.safe_dict(response, marketId, {})
+            for j in range(0, len(symbols)):
+                market = self.market(symbols[j])
+                tickerId = market['base'] + '_USDC'
+                if marketInner['marketId'] == tickerId:
+                    parsedSymbols.append(market['symbol'])
+                    results.append(self.parse_open_interest(openInterest, market))
+        return self.filter_by_array(results, 'symbol', parsedSymbols)
+
     def fetch_open_interest(self, symbol: str, params={}):
         """
         Retrieves the open interest of a derivative trading pair
@@ -1396,7 +1522,7 @@ class vertex(Exchange, ImplicitAPI):
         marketId = base + '/' + quote
         if base.find('PERP') > 0:
             marketId = marketId.replace('-PERP', '') + ':USDC'
-        market = self.market(marketId)
+        market = self.safe_market(marketId, market)
         last = self.safe_string(ticker, 'last_price')
         return self.safe_ticker({
             'symbol': market['symbol'],
@@ -1962,7 +2088,7 @@ class vertex(Exchange, ImplicitAPI):
         :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 dict [params]: extra parameters specific to the exchange API endpoint
-        :param boolean [params.stop]: whether the order is a stop/algo order
+        :param boolean [params.trigger]: whether the order is a trigger/algo order
         :param str [params.user]: user address, will default to self.walletAddress if not provided
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
@@ -1972,13 +2098,13 @@ class vertex(Exchange, ImplicitAPI):
         userAddress, params = self.handle_public_address('fetchOpenOrders', params)
         request = {}
         market: Market = None
-        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
         if symbol is not None:
             market = self.market(symbol)
             request['product_id'] = self.parse_to_numeric(market['id'])
         response = None
-        if stop:
+        if trigger:
             contracts = self.query_contracts()
             chainId = self.safe_string(contracts, 'chain_id')
             verifyingContractAddress = self.safe_string(contracts, 'endpoint_addr')
@@ -2043,7 +2169,7 @@ class vertex(Exchange, ImplicitAPI):
             #       "product_id": 1,
             #       "orders": [
             #         {
-            #           "product_id": 1,
+            #           "product_id": 2,
             #           "sender": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43000000000000000000000000",
             #           "price_x18": "1000000000000000000",
             #           "amount": "1000000000000000000",
@@ -2052,7 +2178,7 @@ class vertex(Exchange, ImplicitAPI):
             #           "order_type": "default",
             #           "unfilled_amount": "1000000000000000000",
             #           "digest": "0x0000000000000000000000000000000000000000000000000000000000000000",
-            #           "placed_at": 1682437739,
+            #           "placed_at": 1682437737,
             #           "order_type": "ioc"
             #         }
             #       ]
@@ -2074,14 +2200,14 @@ class vertex(Exchange, ImplicitAPI):
         :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 dict [params]: extra parameters specific to the exchange API endpoint
-        :param boolean [params.stop]: whether the order is a stop/algo order
+        :param boolean [params.trigger]: whether the order is a trigger/algo order
         :param str [params.user]: user address, will default to self.walletAddress if not provided
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.check_required_credentials()
-        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
-        if not stop:
+        if not trigger:
             raise NotSupported(self.id + ' fetchOrders only support trigger orders')
         userAddress = None
         userAddress, params = self.handle_public_address('fetchOrders', params)
@@ -2156,7 +2282,7 @@ class vertex(Exchange, ImplicitAPI):
         cancel all open orders in a market
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param boolean [params.stop]: whether the order is a stop/algo order
+        :param boolean [params.trigger]: whether the order is a trigger/algo order
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.check_required_credentials()
@@ -2187,10 +2313,10 @@ class vertex(Exchange, ImplicitAPI):
                 'signature': self.build_cancel_all_orders_sig(cancels, chainId, verifyingContractAddress),
             },
         }
-        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
         response = None
-        if stop:
+        if trigger:
             response = self.v1TriggerPostExecute(self.extend(request, params))
             #
             # {
@@ -2225,7 +2351,7 @@ class vertex(Exchange, ImplicitAPI):
             #     "request_type": "execute_cancel_product_orders"
             # }
             #
-        return response
+        return [self.safe_order({'info': response})]
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
@@ -2239,7 +2365,8 @@ class vertex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        return self.cancel_orders([id], symbol, params)
+        order = self.cancel_orders([id], symbol, params)
+        return self.safe_order({'info': order})
 
     def cancel_orders(self, ids: List[str], symbol: Str = None, params={}):
         """
@@ -2270,24 +2397,25 @@ class vertex(Exchange, ImplicitAPI):
             'digests': ids,
             'nonce': nonce,
         }
+        productIds = cancels['productIds']
         marketIdNum = self.parse_to_numeric(marketId)
         for i in range(0, len(ids)):
-            cancels['productIds'].append(marketIdNum)
+            productIds.append(marketIdNum)
         request = {
             'cancel_orders': {
                 'tx': {
                     'sender': cancels['sender'],
-                    'productIds': cancels['productIds'],
+                    'productIds': productIds,
                     'digests': cancels['digests'],
                     'nonce': self.number_to_string(cancels['nonce']),
                 },
                 'signature': self.build_cancel_orders_sig(cancels, chainId, verifyingContractAddress),
             },
         }
-        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
         response = None
-        if stop:
+        if trigger:
             response = self.v1TriggerPostExecute(self.extend(request, params))
             #
             # {
@@ -2731,7 +2859,7 @@ class vertex(Exchange, ImplicitAPI):
             'takeProfitPrice': None,
         })
 
-    def fetch_positions(self, symbols: Strings = None, params={}):
+    def fetch_positions(self, symbols: Strings = None, params={}) -> List[Position]:
         """
         fetch all open positions
 
@@ -2779,7 +2907,7 @@ class vertex(Exchange, ImplicitAPI):
         #
         return self.safe_dict(response, 'data', {})
 
-    def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
+    def withdraw(self, code: str, amount: float, address: str, tag: Str = None, params={}) -> Transaction:
         """
         make a withdrawal
 

ccxt/wallex.py

@@ -5,17 +5,17 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.wallex import ImplicitAPI
-from ccxt.base.types import Int, Market, OrderBook, Strings, Ticker, Tickers
+from ccxt.base.types import Any, Int, Market, OrderBook, Strings, Ticker, Tickers
 from typing import List
 
 
 class wallex(Exchange, ImplicitAPI):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(wallex, self).describe(), {
             'id': 'wallex',
             'name': 'Wallex',
-            'country': ['IR'],
+            'countries': ['IR'],
             'rateLimit': 1000,
             'version': '1',
             'certified': False,
@@ -125,10 +125,10 @@ class wallex(Exchange, ImplicitAPI):
             },
         })
 
-    def fetch_markets(self, symbols: Strings = None, params={}) -> List[Market]:
+    def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for wallex
-        :see: https://api-docs.wallex.ir/#be8d9c51a2
+        https://api-docs.wallex.ir/#be8d9c51a2
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
@@ -251,7 +251,7 @@ class wallex(Exchange, ImplicitAPI):
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :see: https://api-docs.wallex.ir/#be8d9c51a2
+        https://api-docs.wallex.ir/#be8d9c51a2
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -274,7 +274,7 @@ class wallex(Exchange, ImplicitAPI):
     def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://api-docs.wallex.ir/#be8d9c51a2
+        https://api-docs.wallex.ir/#be8d9c51a2
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -372,7 +372,7 @@ class wallex(Exchange, ImplicitAPI):
     def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-        :see: https://api-docs.wallex.ir/#be8d9c51a2
+        https://api-docs.wallex.ir/#be8d9c51a2
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -418,7 +418,7 @@ class wallex(Exchange, ImplicitAPI):
     def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data for multiple markets
-        :see: https://api-docs.wallex.ir/#be8d9c51a2
+        https://api-docs.wallex.ir/#be8d9c51a2
         :param str[]|None symbols: list of unified market symbols, all symbols fetched if None, default is None
         :param int [limit]: max number of entries per orderbook to return, default is None
         :param dict [params]: extra parameters specific to the exchange API endpoint