ccxt 4.3.51__py2.py3-none-any.whl → 4.3.53__py2.py3-none-any.whl

ccxt/pro/vertex.py

@@ -0,0 +1,916 @@
+# -*- coding: utf-8 -*-
+
+# 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
+
+import ccxt.async_support
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide
+from ccxt.base.types import Int, Market, Order, OrderBook, Position, Str, Strings, Ticker, Trade
+from ccxt.async_support.base.ws.client import Client
+from typing import List
+from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ArgumentsRequired
+from ccxt.base.errors import NotSupported
+from ccxt.base.precise import Precise
+
+
+class vertex(ccxt.async_support.vertex):
+
+    def describe(self):
+        return self.deep_extend(super(vertex, self).describe(), {
+            'has': {
+                'ws': True,
+                'watchBalance': False,
+                'watchMyTrades': True,
+                'watchOHLCV': False,
+                'watchOrderBook': True,
+                'watchOrders': True,
+                'watchTicker': True,
+                'watchTickers': False,
+                'watchTrades': True,
+                'watchPositions': True,
+            },
+            'urls': {
+                'api': {
+                    'ws': 'wss://gateway.prod.vertexprotocol.com/v1/subscribe',
+                },
+                'test': {
+                    'ws': 'wss://gateway.sepolia-test.vertexprotocol.com/v1/subscribe',
+                },
+            },
+            'requiredCredentials': {
+                'apiKey': False,
+                'secret': False,
+                'walletAddress': True,
+                'privateKey': True,
+            },
+            'options': {
+                'tradesLimit': 1000,
+                'ordersLimit': 1000,
+                'requestId': {},
+                'watchPositions': {
+                    'fetchPositionsSnapshot': True,  # or False
+                    'awaitPositionsSnapshot': True,  # whether to wait for the positions snapshot before providing updates
+                },
+            },
+            'streaming': {
+                # 'ping': self.ping,
+                'keepAlive': 30000,
+            },
+            'exceptions': {
+                'ws': {
+                    'exact': {
+                        'Auth is needed.': AuthenticationError,
+                    },
+                },
+            },
+        })
+
+    def request_id(self, url):
+        options = self.safe_dict(self.options, 'requestId', {})
+        previousValue = self.safe_integer(options, url, 0)
+        newValue = self.sum(previousValue, 1)
+        self.options['requestId'][url] = newValue
+        return newValue
+
+    async def watch_public(self, messageHash, message):
+        url = self.urls['api']['ws']
+        requestId = self.request_id(url)
+        subscribe = {
+            'id': requestId,
+        }
+        request = self.extend(subscribe, message)
+        return await self.watch(url, messageHash, request, messageHash, subscribe)
+
+    async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        watches information on multiple trades made in a market
+        :see: https://docs.vertexprotocol.com/developer-resources/api/subscriptions/streams
+        :param str symbol: unified market symbol of the market trades were made in
+        :param int [since]: the earliest time in ms to fetch trades for
+        :param int [limit]: the maximum number of trade structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        name = 'trade'
+        topic = market['id'] + '@' + name
+        request = {
+            'method': 'subscribe',
+            'stream': {
+                'type': name,
+                'product_id': self.parse_to_numeric(market['id']),
+            },
+        }
+        message = self.extend(request, params)
+        trades = await self.watch_public(topic, message)
+        if self.newUpdates:
+            limit = trades.getLimit(market['symbol'], limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
+
+    def handle_trade(self, client: Client, message):
+        #
+        # {
+        #     "type": "trade",
+        #     "timestamp": "1676151190656903000",  # timestamp of the event in nanoseconds
+        #     "product_id": 1,
+        #     "price": "1000",  # price the trade happened at, multiplied by 1e18
+        #     # both taker_qty and maker_qty have the same value
+        #     # set to filled amount(min amount of taker and maker) when matching against book
+        #     # set to matched amm base amount when matching against amm
+        #     "taker_qty": "1000",
+        #     "maker_qty": "1000",
+        #     "is_taker_buyer": True,
+        #     "is_maker_amm": True  # True when maker is amm
+        # }
+        #
+        topic = self.safe_string(message, 'type')
+        marketId = self.safe_string(message, 'product_id')
+        trade = self.parse_ws_trade(message)
+        symbol = trade['symbol']
+        if not (symbol in self.trades):
+            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            stored = ArrayCache(limit)
+            self.trades[symbol] = stored
+        trades = self.trades[symbol]
+        trades.append(trade)
+        self.trades[symbol] = trades
+        client.resolve(trades, marketId + '@' + topic)
+
+    async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        watches information on multiple trades made by the user
+        :see: https://docs.vertexprotocol.com/developer-resources/api/subscriptions/streams
+        :param str symbol: unified market symbol of the market orders were made in
+        :param int [since]: the earliest time in ms to fetch orders for
+        :param int [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.user]: user address, will default to self.walletAddress if not provided
+        :returns dict[]: a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
+        """
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' watchMyTrades requires a symbol.')
+        await self.load_markets()
+        userAddress = None
+        userAddress, params = self.handlePublicAddress('watchMyTrades', params)
+        market = self.market(symbol)
+        name = 'fill'
+        topic = market['id'] + '@' + name
+        request = {
+            'method': 'subscribe',
+            'stream': {
+                'type': name,
+                'product_id': self.parse_to_numeric(market['id']),
+                'subaccount': self.convertAddressToSender(userAddress),
+            },
+        }
+        message = self.extend(request, params)
+        trades = await self.watch_public(topic, message)
+        if self.newUpdates:
+            limit = trades.getLimit(symbol, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
+
+    def handle_my_trades(self, client: Client, message):
+        #
+        # {
+        #     "type": "fill",
+        #     "timestamp": "1676151190656903000",  # timestamp of the event in nanoseconds
+        #     "product_id": 1,
+        #     # the subaccount that placed self order
+        #     "subaccount": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43746573743000000000000000",
+        #     # hash of the order that uniquely identifies it
+        #     "order_digest": "0xf4f7a8767faf0c7f72251a1f9e5da590f708fd9842bf8fcdeacbaa0237958fff",
+        #     # the amount filled, multiplied by 1e18
+        #     "filled_qty": "1000",
+        #     # the amount outstanding unfilled, multiplied by 1e18
+        #     "remaining_qty": "2000",
+        #     # the original order amount, multiplied by 1e18
+        #     "original_qty": "3000",
+        #     # fill price
+        #     "price": "24991000000000000000000",
+        #     # True for `taker`, False for `maker`
+        #     "is_taker": True,
+        #     "is_bid": True,
+        #     # True when matching against amm
+        #     "is_against_amm": True,
+        #     # an optional `order id` that can be provided when placing an order
+        #     "id": 100
+        # }
+        #
+        topic = self.safe_string(message, 'type')
+        marketId = self.safe_string(message, 'product_id')
+        if self.myTrades is None:
+            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            self.myTrades = ArrayCacheBySymbolById(limit)
+        trades = self.myTrades
+        parsed = self.parse_ws_trade(message)
+        trades.append(parsed)
+        client.resolve(trades, marketId + '@' + topic)
+
+    def parse_ws_trade(self, trade, market=None):
+        #
+        # watchTrades
+        # {
+        #     "type": "trade",
+        #     "timestamp": "1676151190656903000",  # timestamp of the event in nanoseconds
+        #     "product_id": 1,
+        #     "price": "1000",  # price the trade happened at, multiplied by 1e18
+        #     # both taker_qty and maker_qty have the same value
+        #     # set to filled amount(min amount of taker and maker) when matching against book
+        #     # set to matched amm base amount when matching against amm
+        #     "taker_qty": "1000",
+        #     "maker_qty": "1000",
+        #     "is_taker_buyer": True,
+        #     "is_maker_amm": True  # True when maker is amm
+        # }
+        # watchMyTrades
+        # {
+        #     "type": "fill",
+        #     "timestamp": "1676151190656903000",  # timestamp of the event in nanoseconds
+        #     "product_id": 1,
+        #     # the subaccount that placed self order
+        #     "subaccount": "0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43746573743000000000000000",
+        #     # hash of the order that uniquely identifies it
+        #     "order_digest": "0xf4f7a8767faf0c7f72251a1f9e5da590f708fd9842bf8fcdeacbaa0237958fff",
+        #     # the amount filled, multiplied by 1e18
+        #     "filled_qty": "1000",
+        #     # the amount outstanding unfilled, multiplied by 1e18
+        #     "remaining_qty": "2000",
+        #     # the original order amount, multiplied by 1e18
+        #     "original_qty": "3000",
+        #     # fill price
+        #     "price": "24991000000000000000000",
+        #     # True for `taker`, False for `maker`
+        #     "is_taker": True,
+        #     "is_bid": True,
+        #     # True when matching against amm
+        #     "is_against_amm": True,
+        #     # an optional `order id` that can be provided when placing an order
+        #     "id": 100
+        # }
+        #
+        marketId = self.safe_string(trade, 'product_id')
+        market = self.safe_market(marketId, market)
+        symbol = market['symbol']
+        price = self.convertFromX18(self.safe_string(trade, 'price'))
+        amount = self.convertFromX18(self.safe_string_2(trade, 'taker_qty', 'filled_qty'))
+        cost = Precise.string_mul(price, amount)
+        timestamp = Precise.string_div(self.safe_string(trade, 'timestamp'), '1000000')
+        takerOrMaker = None
+        isTaker = self.safe_bool(trade, 'is_taker')
+        if isTaker is not None:
+            takerOrMaker = 'taker' if (isTaker) else 'maker'
+        side = None
+        isBid = self.safe_bool(trade, 'is_bid')
+        if isBid is not None:
+            side = 'buy' if (isBid) else 'sell'
+        return self.safe_trade({
+            'id': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'symbol': symbol,
+            'side': side,
+            'price': price,
+            'amount': amount,
+            'cost': cost,
+            'order': self.safe_string_2(trade, 'digest', 'id'),
+            'takerOrMaker': takerOrMaker,
+            'type': None,
+            'fee': None,
+            'info': trade,
+        }, market)
+
+    async def watch_ticker(self, symbol: str, params={}) -> Ticker:
+        """
+        :see: https://docs.vertexprotocol.com/developer-resources/api/subscriptions/streams
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :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>`
+        """
+        await self.load_markets()
+        name = 'best_bid_offer'
+        market = self.market(symbol)
+        topic = market['id'] + '@' + name
+        request = {
+            'method': 'subscribe',
+            'stream': {
+                'type': name,
+                'product_id': self.parse_to_numeric(market['id']),
+            },
+        }
+        message = self.extend(request, params)
+        return await self.watch_public(topic, message)
+
+    def parse_ws_ticker(self, ticker, market=None):
+        #
+        # {
+        #     "type": "best_bid_offer",
+        #     "timestamp": "1676151190656903000",  # timestamp of the event in nanoseconds
+        #     "product_id": 1,
+        #     "bid_price": "1000",  # the highest bid price, multiplied by 1e18
+        #     "bid_qty": "1000",  # quantity at the huighest bid, multiplied by 1e18.
+        #                        # i.e. if self is USDC with 6 decimals, one USDC
+        #                        # would be 1e12
+        #     "ask_price": "1000",  # lowest ask price
+        #     "ask_qty": "1000"  # quantity at the lowest ask
+        # }
+        #
+        timestamp = Precise.string_div(self.safe_string(ticker, 'timestamp'), '1000000')
+        return self.safe_ticker({
+            'symbol': self.safe_symbol(None, market),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'high': self.safe_string(ticker, 'high'),
+            'low': self.safe_string(ticker, 'low'),
+            'bid': self.convertFromX18(self.safe_string(ticker, 'bid_price')),
+            'bidVolume': self.convertFromX18(self.safe_string(ticker, 'bid_qty')),
+            'ask': self.convertFromX18(self.safe_string(ticker, 'ask_price')),
+            'askVolume': self.convertFromX18(self.safe_string(ticker, 'ask_qty')),
+            'vwap': None,
+            'open': None,
+            'close': None,
+            'last': None,
+            'previousClose': None,
+            'change': None,
+            'percentage': None,
+            'average': None,
+            'baseVolume': None,
+            'quoteVolume': None,
+            'info': ticker,
+        }, market)
+
+    def handle_ticker(self, client: Client, message):
+        #
+        # {
+        #     "type": "best_bid_offer",
+        #     "timestamp": "1676151190656903000",  # timestamp of the event in nanoseconds
+        #     "product_id": 1,
+        #     "bid_price": "1000",  # the highest bid price, multiplied by 1e18
+        #     "bid_qty": "1000",  # quantity at the huighest bid, multiplied by 1e18.
+        #                        # i.e. if self is USDC with 6 decimals, one USDC
+        #                        # would be 1e12
+        #     "ask_price": "1000",  # lowest ask price
+        #     "ask_qty": "1000"  # quantity at the lowest ask
+        # }
+        #
+        marketId = self.safe_string(message, 'product_id')
+        market = self.safe_market(marketId)
+        ticker = self.parse_ws_ticker(message, market)
+        ticker['symbol'] = market['symbol']
+        self.tickers[market['symbol']] = ticker
+        client.resolve(ticker, marketId + '@best_bid_offer')
+        return message
+
+    async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
+        """
+        :see: https://docs.vertexprotocol.com/developer-resources/api/subscriptions/streams
+        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :param str 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 dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        name = 'book_depth'
+        market = self.market(symbol)
+        messageHash = market['id'] + '@' + name
+        url = self.urls['api']['ws']
+        requestId = self.request_id(url)
+        request: dict = {
+            'id': requestId,
+            'method': 'subscribe',
+            'stream': {
+                'type': name,
+                'product_id': self.parse_to_numeric(market['id']),
+            },
+        }
+        subscription: dict = {
+            'id': str(requestId),
+            'name': name,
+            'symbol': symbol,
+            'method': self.handle_order_book_subscription,
+            'limit': limit,
+            'params': params,
+        }
+        message = self.extend(request, params)
+        orderbook = await self.watch(url, messageHash, message, messageHash, subscription)
+        return orderbook.limit()
+
+    def handle_order_book_subscription(self, client: Client, message, subscription):
+        defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+        limit = self.safe_integer(subscription, 'limit', defaultLimit)
+        symbol = self.safe_string(subscription, 'symbol')  # watchOrderBook
+        if symbol in self.orderbooks:
+            del self.orderbooks[symbol]
+        self.orderbooks[symbol] = self.order_book({}, limit)
+        self.spawn(self.fetch_order_book_snapshot, client, message, subscription)
+
+    async def fetch_order_book_snapshot(self, client, message, subscription):
+        symbol = self.safe_string(subscription, 'symbol')
+        market = self.market(symbol)
+        messageHash = market['id'] + '@book_depth'
+        try:
+            defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+            limit = self.safe_integer(subscription, 'limit', defaultLimit)
+            params = self.safe_value(subscription, 'params')
+            snapshot = await self.fetch_rest_order_book_safe(symbol, limit, params)
+            if self.safe_value(self.orderbooks, symbol) is None:
+                # if the orderbook is dropped before the snapshot is received
+                return
+            orderbook = self.orderbooks[symbol]
+            orderbook.reset(snapshot)
+            messages = orderbook.cache
+            for i in range(0, len(messages)):
+                messageItem = messages[i]
+                lastTimestamp = self.parse_to_int(Precise.string_div(self.safe_string(messageItem, 'last_max_timestamp'), '1000000'))
+                if lastTimestamp < orderbook['timestamp']:
+                    continue
+                else:
+                    self.handle_order_book_message(client, messageItem, orderbook)
+            self.orderbooks[symbol] = orderbook
+            client.resolve(orderbook, messageHash)
+        except Exception as e:
+            del client.subscriptions[messageHash]
+            client.reject(e, messageHash)
+
+    def handle_order_book(self, client: Client, message):
+        #
+        #
+        # the feed does not include a snapshot, just the deltas
+        #
+        # {
+        #     "type":"book_depth",
+        #     # book depth aggregates a number of events once every 50ms
+        #     # these are the minimum and maximum timestamps from
+        #     # events that contributed to self response
+        #     "min_timestamp": "1683805381879572835",
+        #     "max_timestamp": "1683805381879572835",
+        #     # the max_timestamp of the last book_depth event for self product
+        #     "last_max_timestamp": "1683805381771464799",
+        #     "product_id":1,
+        #     # changes to the bid side of the book in the form of [[price, new_qty]]
+        #     "bids":[["21594490000000000000000","51007390115411548"]],
+        #     # changes to the ask side of the book in the form of [[price, new_qty]]
+        #     "asks":[["21694490000000000000000","0"],["21695050000000000000000","0"]]
+        # }
+        #
+        marketId = self.safe_string(message, 'product_id')
+        market = self.safe_market(marketId)
+        symbol = market['symbol']
+        if not (symbol in self.orderbooks):
+            self.orderbooks[symbol] = self.order_book()
+        orderbook = self.orderbooks[symbol]
+        timestamp = self.safe_integer(orderbook, 'timestamp')
+        if timestamp is None:
+            # Buffer the events you receive from the stream.
+            orderbook.cache.append(message)
+        else:
+            lastTimestamp = self.parse_to_int(Precise.string_div(self.safe_string(message, 'last_max_timestamp'), '1000000'))
+            if lastTimestamp > timestamp:
+                self.handle_order_book_message(client, message, orderbook)
+                client.resolve(orderbook, marketId + '@book_depth')
+
+    def handle_order_book_message(self, client: Client, message, orderbook):
+        timestamp = self.parse_to_int(Precise.string_div(self.safe_string(message, 'last_max_timestamp'), '1000000'))
+        # convert from X18
+        data = {
+            'bids': [],
+            'asks': [],
+        }
+        bids = self.safe_list(message, 'bids', [])
+        for i in range(0, len(bids)):
+            bid = bids[i]
+            data['bids'].append([
+                self.convertFromX18(bid[0]),
+                self.convertFromX18(bid[1]),
+            ])
+        asks = self.safe_list(message, 'asks', [])
+        for i in range(0, len(asks)):
+            ask = asks[i]
+            data['asks'].append([
+                self.convertFromX18(ask[0]),
+                self.convertFromX18(ask[1]),
+            ])
+        self.handle_deltas(orderbook['asks'], self.safe_list(data, 'asks', []))
+        self.handle_deltas(orderbook['bids'], self.safe_list(data, 'bids', []))
+        orderbook['timestamp'] = timestamp
+        orderbook['datetime'] = self.iso8601(timestamp)
+        return orderbook
+
+    def handle_delta(self, bookside, delta):
+        price = self.safe_float(delta, 0)
+        amount = self.safe_float(delta, 1)
+        bookside.store(price, amount)
+
+    def handle_deltas(self, bookside, deltas):
+        for i in range(0, len(deltas)):
+            self.handle_delta(bookside, deltas[i])
+
+    def handle_subscription_status(self, client: Client, message):
+        #
+        #     {
+        #         "result": null,
+        #         "id": 1574649734450
+        #     }
+        #
+        id = self.safe_string(message, 'id')
+        subscriptionsById = self.index_by(client.subscriptions, 'id')
+        subscription = self.safe_value(subscriptionsById, id, {})
+        method = self.safe_value(subscription, 'method')
+        if method is not None:
+            method(client, message, subscription)
+        return message
+
+    async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
+        """
+        :see: https://docs.vertexprotocol.com/developer-resources/api/subscriptions/streams
+        watch all open positions
+        :param str[]|None symbols: list of unified market symbols
+        :param dict params: extra parameters specific to the exchange API endpoint
+        :param str [params.user]: user address, will default to self.walletAddress if not provided
+        :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        if not self.is_empty(symbols):
+            if len(symbols) > 1:
+                raise NotSupported(self.id + ' watchPositions require only one symbol.')
+        else:
+            raise ArgumentsRequired(self.id + ' watchPositions require one symbol.')
+        userAddress = None
+        userAddress, params = self.handlePublicAddress('watchPositions', params)
+        url = self.urls['api']['ws']
+        client = self.client(url)
+        self.set_positions_cache(client, symbols, params)
+        fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.safe_bool('watchPositions', 'awaitPositionsSnapshot', True)
+        if fetchPositionsSnapshot and awaitPositionsSnapshot and self.positions is None:
+            snapshot = await client.future('fetchPositionsSnapshot')
+            return self.filter_by_symbols_since_limit(snapshot, symbols, since, limit, True)
+        name = 'position_change'
+        market = self.market(symbols[0])
+        topic = market['id'] + '@' + name
+        request = {
+            'method': 'subscribe',
+            'stream': {
+                'type': name,
+                'product_id': self.parse_to_numeric(market['id']),
+                'subaccount': self.convertAddressToSender(userAddress),
+            },
+        }
+        message = self.extend(request, params)
+        newPositions = await self.watch_public(topic, message)
+        if self.newUpdates:
+            limit = newPositions.getLimit(symbols[0], limit)
+        return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit, True)
+
+    def set_positions_cache(self, client: Client, symbols: Strings = None, params={}):
+        fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', False)
+        if fetchPositionsSnapshot:
+            messageHash = 'fetchPositionsSnapshot'
+            if not (messageHash in client.futures):
+                client.future(messageHash)
+                self.spawn(self.load_positions_snapshot, client, messageHash, symbols, params)
+        else:
+            self.positions = ArrayCacheBySymbolBySide()
+
+    async def load_positions_snapshot(self, client, messageHash, symbols, params):
+        positions = await self.fetch_positions(symbols, params)
+        self.positions = ArrayCacheBySymbolBySide()
+        cache = self.positions
+        for i in range(0, len(positions)):
+            position = positions[i]
+            cache.append(position)
+        # don't remove the future from the .futures cache
+        future = client.futures[messageHash]
+        future.resolve(cache)
+        client.resolve(cache, 'positions')
+
+    def handle_positions(self, client, message):
+        #
+        # {
+        #     "type":"position_change",
+        #     "timestamp": "1676151190656903000",  # timestamp of event in nanoseconds
+        #     "product_id":1,
+        #      # whether self is a position change for the LP token for self product
+        #     "is_lp":false,
+        #     # subaccount who's position changed
+        #     "subaccount":"0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43706d00000000000000000000",
+        #     # new amount for self product
+        #     "amount":"51007390115411548",
+        #     # new quote balance for self product; zero for everything except non lp perps
+        #     # the negative of the entry cost of the perp
+        #     "v_quote_amount":"0"
+        # }
+        #
+        if self.positions is None:
+            self.positions = ArrayCacheBySymbolBySide()
+        cache = self.positions
+        topic = self.safe_string(message, 'type')
+        marketId = self.safe_string(message, 'product_id')
+        market = self.safe_market(marketId)
+        position = self.parse_ws_position(message, market)
+        cache.append(position)
+        client.resolve(position, marketId + '@' + topic)
+
+    def parse_ws_position(self, position, market=None):
+        #
+        # {
+        #     "type":"position_change",
+        #     "timestamp": "1676151190656903000",  # timestamp of event in nanoseconds
+        #     "product_id":1,
+        #      # whether self is a position change for the LP token for self product
+        #     "is_lp":false,
+        #     # subaccount who's position changed
+        #     "subaccount":"0x7a5ec2748e9065794491a8d29dcf3f9edb8d7c43706d00000000000000000000",
+        #     # new amount for self product
+        #     "amount":"51007390115411548",
+        #     # new quote balance for self product; zero for everything except non lp perps
+        #     # the negative of the entry cost of the perp
+        #     "v_quote_amount":"0"
+        # }
+        #
+        marketId = self.safe_string(position, 'product_id')
+        market = self.safe_market(marketId)
+        contractSize = self.convertFromX18(self.safe_string(position, 'amount'))
+        side = 'buy'
+        if Precise.string_lt(contractSize, '1'):
+            side = 'sell'
+        timestamp = self.parse_to_int(Precise.string_div(self.safe_string(position, 'timestamp'), '1000000'))
+        return self.safe_position({
+            'info': position,
+            'id': None,
+            'symbol': self.safe_string(market, 'symbol'),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'lastUpdateTimestamp': None,
+            'initialMargin': None,
+            'initialMarginPercentage': None,
+            'maintenanceMargin': None,
+            'maintenanceMarginPercentage': None,
+            'entryPrice': None,
+            'notional': None,
+            'leverage': None,
+            'unrealizedPnl': None,
+            'contracts': None,
+            'contractSize': self.parse_number(contractSize),
+            'marginRatio': None,
+            'liquidationPrice': None,
+            'markPrice': None,
+            'lastPrice': None,
+            'collateral': None,
+            'marginMode': 'cross',
+            'marginType': None,
+            'side': side,
+            'percentage': None,
+            'hedged': None,
+            'stopLossPrice': None,
+            'takeProfitPrice': None,
+        })
+
+    def handle_auth(self, client: Client, message):
+        #
+        # {result: null, id: 1}
+        #
+        messageHash = 'authenticated'
+        error = self.safe_string(message, 'error')
+        if error is None:
+            # client.resolve(message, messageHash)
+            future = self.safe_value(client.futures, 'authenticated')
+            future.resolve(True)
+        else:
+            authError = AuthenticationError(self.json(message))
+            client.reject(authError, messageHash)
+            # allows further authentication attempts
+            if messageHash in client.subscriptions:
+                del client.subscriptions['authenticated']
+
+    def build_ws_authentication_sig(self, message, chainId, verifyingContractAddress):
+        messageTypes = {
+            'StreamAuthentication': [
+                {'name': 'sender', 'type': 'bytes32'},
+                {'name': 'expiration', 'type': 'uint64'},
+            ],
+        }
+        return self.buildSig(chainId, messageTypes, message, verifyingContractAddress)
+
+    async def authenticate(self, params={}):
+        self.check_required_credentials()
+        url = self.urls['api']['ws']
+        client = self.client(url)
+        messageHash = 'authenticated'
+        future = client.future(messageHash)
+        authenticated = self.safe_value(client.subscriptions, messageHash)
+        if authenticated is None:
+            requestId = self.request_id(url)
+            contracts = await self.queryContracts()
+            chainId = self.safe_string(contracts, 'chain_id')
+            verifyingContractAddress = self.safe_string(contracts, 'endpoint_addr')
+            now = self.nonce()
+            nonce = now + 90000
+            authentication = {
+                'sender': self.convertAddressToSender(self.walletAddress),
+                'expiration': nonce,
+            }
+            request = {
+                'id': requestId,
+                'method': 'authenticate',
+                'tx': {
+                    'sender': authentication['sender'],
+                    'expiration': self.number_to_string(authentication['expiration']),
+                },
+                'signature': self.build_ws_authentication_sig(authentication, chainId, verifyingContractAddress),
+            }
+            message = self.extend(request, params)
+            self.watch(url, messageHash, message, messageHash)
+        return await future
+
+    async def watch_private(self, messageHash, message, params={}):
+        await self.authenticate(params)
+        url = self.urls['api']['ws']
+        requestId = self.request_id(url)
+        subscribe = {
+            'id': requestId,
+        }
+        request = self.extend(subscribe, message)
+        return await self.watch(url, messageHash, request, messageHash, subscribe)
+
+    async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        """
+        watches information on multiple orders made by the user
+        :see: https://docs.vertexprotocol.com/developer-resources/api/subscriptions/streams
+        :param str symbol: unified market symbol of the market orders were made in
+        :param int [since]: the earliest time in ms to fetch orders for
+        :param int [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' watchOrders requires a symbol.')
+        self.check_required_credentials()
+        await self.load_markets()
+        name = 'order_update'
+        market = self.market(symbol)
+        topic = market['id'] + '@' + name
+        request = {
+            'method': 'subscribe',
+            'stream': {
+                'type': name,
+                'subaccount': self.convertAddressToSender(self.walletAddress),
+                'product_id': self.parse_to_numeric(market['id']),
+            },
+        }
+        message = self.extend(request, params)
+        orders = await self.watch_private(topic, message)
+        if self.newUpdates:
+            limit = orders.getLimit(symbol, limit)
+        return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
+
+    def parse_ws_order_status(self, status):
+        if status is not None:
+            statuses = {
+                'filled': 'open',
+                'placed': 'open',
+                'cancelled': 'canceled',
+            }
+            return self.safe_string(statuses, status, status)
+        return status
+
+    def parse_ws_order(self, order, market: Market = None) -> Order:
+        #
+        # {
+        #     "type": "order_update",
+        #     # timestamp of the event in nanoseconds
+        #     "timestamp": "1695081920633151000",
+        #     "product_id": 1,
+        #     # order digest
+        #     "digest": "0xf7712b63ccf70358db8f201e9bf33977423e7a63f6a16f6dab180bdd580f7c6c",
+        #     # remaining amount to be filled.
+        #     # will be `0` if the order is either fully filled or cancelled.
+        #     "amount": "82000000000000000",
+        #     # any of: "filled", "cancelled", "placed"
+        #     "reason": "filled"
+        #     # an optional `order id` that can be provided when placing an order
+        #     "id": 100
+        # }
+        #
+        marketId = self.safe_string(order, 'product_id')
+        timestamp = self.parse_to_int(Precise.string_div(self.safe_string(order, 'timestamp'), '1000000'))
+        remaining = self.parse_to_numeric(self.convertFromX18(self.safe_string(order, 'amount')))
+        status = self.parse_ws_order_status(self.safe_string(order, 'reason'))
+        if remaining == 0 and status == 'open':
+            status = 'closed'
+        market = self.safe_market(marketId, market)
+        symbol = market['symbol']
+        return self.safe_order({
+            'info': order,
+            'id': self.safe_string_2(order, 'digest', 'id'),
+            'clientOrderId': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'lastTradeTimestamp': None,
+            'lastUpdateTimestamp': None,
+            'symbol': symbol,
+            'type': None,
+            'timeInForce': None,
+            'postOnly': None,
+            'reduceOnly': None,
+            'side': None,
+            'price': None,
+            'triggerPrice': None,
+            'amount': None,
+            'cost': None,
+            'average': None,
+            'filled': None,
+            'remaining': remaining,
+            'status': status,
+            'fee': None,
+            'trades': None,
+        }, market)
+
+    def handle_order_update(self, client: Client, message):
+        #
+        # {
+        #     "type": "order_update",
+        #     # timestamp of the event in nanoseconds
+        #     "timestamp": "1695081920633151000",
+        #     "product_id": 1,
+        #     # order digest
+        #     "digest": "0xf7712b63ccf70358db8f201e9bf33977423e7a63f6a16f6dab180bdd580f7c6c",
+        #     # remaining amount to be filled.
+        #     # will be `0` if the order is either fully filled or cancelled.
+        #     "amount": "82000000000000000",
+        #     # any of: "filled", "cancelled", "placed"
+        #     "reason": "filled"
+        #     # an optional `order id` that can be provided when placing an order
+        #     "id": 100
+        # }
+        #
+        topic = self.safe_string(message, 'type')
+        marketId = self.safe_string(message, 'product_id')
+        parsed = self.parse_ws_order(message)
+        symbol = self.safe_string(parsed, 'symbol')
+        orderId = self.safe_string(parsed, 'id')
+        if symbol is not None:
+            if self.orders is None:
+                limit = self.safe_integer(self.options, 'ordersLimit', 1000)
+                self.orders = ArrayCacheBySymbolById(limit)
+            cachedOrders = self.orders
+            orders = self.safe_dict(cachedOrders.hashmap, symbol, {})
+            order = self.safe_dict(orders, orderId)
+            if order is not None:
+                parsed['timestamp'] = self.safe_integer(order, 'timestamp')
+                parsed['datetime'] = self.safe_string(order, 'datetime')
+            cachedOrders.append(parsed)
+            client.resolve(self.orders, marketId + '@' + topic)
+
+    def handle_error_message(self, client: Client, message):
+        #
+        # {
+        #     result: null,
+        #     error: 'error parsing request: missing field `expiration`',
+        #     id: 0
+        # }
+        #
+        errorMessage = self.safe_string(message, 'error')
+        try:
+            if errorMessage is not None:
+                feedback = self.id + ' ' + self.json(message)
+                self.throw_exactly_matched_exception(self.exceptions['exact'], errorMessage, feedback)
+            return False
+        except Exception as error:
+            if isinstance(error, AuthenticationError):
+                messageHash = 'authenticated'
+                client.reject(error, messageHash)
+                if messageHash in client.subscriptions:
+                    del client.subscriptions[messageHash]
+            else:
+                client.reject(error)
+            return True
+
+    def handle_message(self, client: Client, message):
+        if self.handle_error_message(client, message):
+            return
+        methods = {
+            'trade': self.handle_trade,
+            'best_bid_offer': self.handle_ticker,
+            'book_depth': self.handle_order_book,
+            'fill': self.handle_my_trades,
+            'position_change': self.handle_positions,
+            'order_update': self.handle_order_update,
+        }
+        event = self.safe_string(message, 'type')
+        method = self.safe_value(methods, event)
+        if method is not None:
+            method(client, message)
+            return
+        requestId = self.safe_string(message, 'id')
+        if requestId is not None:
+            self.handle_subscription_status(client, message)
+            return
+        # check whether it's authentication
+        auth = self.safe_value(client.futures, 'authenticated')
+        if auth is not None:
+            self.handle_auth(client, message)