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

ccxt/pro/gate.py

@@ -6,23 +6,47 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Liquidation, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Balances, Bool, Int, Liquidation, Market, MarketType, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
-from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import NotSupported
+from ccxt.base.errors import ChecksumError
 from ccxt.base.precise import Precise
 
 
 class gate(ccxt.async_support.gate):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(gate, self).describe(), {
             'has': {
                 'ws': True,
+                'cancelAllOrdersWs': True,
+                'cancelOrderWs': True,
+                'createMarketBuyOrderWithCostWs': True,
+                'createMarketOrderWs': True,
+                'createMarketOrderWithCostWs': False,
+                'createMarketSellOrderWithCostWs': False,
+                'createOrderWs': True,
+                'createOrdersWs': True,
+                'createPostOnlyOrderWs': True,
+                'createReduceOnlyOrderWs': True,
+                'createStopLimitOrderWs': True,
+                'createStopLossOrderWs': True,
+                'createStopMarketOrderWs': False,
+                'createStopOrderWs': True,
+                'createTakeProfitOrderWs': True,
+                'createTriggerOrderWs': True,
+                'editOrderWs': True,
+                'fetchOrderWs': True,
+                'fetchOrdersWs': False,
+                'fetchOpenOrdersWs': True,
+                'fetchClosedOrdersWs': True,
                 'watchOrderBook': True,
+                'watchBidsAsks': True,
                 'watchTicker': True,
                 'watchTickers': True,
                 'watchTrades': True,
@@ -82,6 +106,7 @@ class gate(ccxt.async_support.gate):
                     'interval': '100ms',
                     'snapshotDelay': 10,  # how many deltas to cache before fetching a snapshot
                     'snapshotMaxRetries': 3,
+                    'checksum': True,
                 },
                 'watchBalance': {
                     'settle': 'usdt',  # or btc
@@ -95,18 +120,258 @@ class gate(ccxt.async_support.gate):
             'exceptions': {
                 'ws': {
                     'exact': {
+                        '1': BadRequest,
                         '2': BadRequest,
                         '4': AuthenticationError,
                         '6': AuthenticationError,
                         '11': AuthenticationError,
                     },
+                    'broad': {},
                 },
             },
         })
 
+    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
+        """
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#order-place
+        https://www.gate.io/docs/developers/futures/ws/en/#order-place
+
+        Create an order on the exchange
+        :param str symbol: Unified CCXT market symbol
+        :param str type: 'limit' or 'market' *"market" is contract only*
+        :param str side: 'buy' or 'sell'
+        :param float amount: the amount of currency to trade
+        :param float [price]: *ignored in "market" orders* the price at which the order is to be fulfilled at in units of the quote currency
+        :param dict [params]:  extra parameters specific to the exchange API endpoint
+        :param float [params.stopPrice]: The price at which a trigger order is triggered at
+        :param str [params.timeInForce]: "GTC", "IOC", or "PO"
+        :param float [params.stopLossPrice]: The price at which a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: The price at which a take profit order is triggered at
+        :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for margin trading if not provided self.options['defaultMarginMode'] is used
+        :param int [params.iceberg]: Amount to display for the iceberg order, Null or 0 for normal orders, Set to -1 to hide the order completely
+        :param str [params.text]: User defined information
+        :param str [params.account]: *spot and margin only* "spot", "margin" or "cross_margin"
+        :param bool [params.auto_borrow]: *margin only* Used in margin or cross margin trading to allow automatic loan of insufficient amount if balance is not enough
+        :param str [params.settle]: *contract only* Unified Currency Code for settle currency
+        :param bool [params.reduceOnly]: *contract only* Indicates if self order is to reduce the size of a position
+        :param bool [params.close]: *contract only* Set to close the position, with size set to 0
+        :param bool [params.auto_size]: *contract only* Set side to close dual-mode position, close_long closes the long side, while close_short the short one, size also needs to be set to 0
+        :param int [params.price_type]: *contract only* 0 latest deal price, 1 mark price, 2 index price
+        :param float [params.cost]: *spot market buy only* the quote quantity that can be used alternative for the amount
+        :returns dict|None: `An order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_place'
+        url = self.get_url_by_market(market)
+        params['textIsRequired'] = True
+        request = self.create_order_request(symbol, type, side, amount, price, params)
+        await self.authenticate(url, messageType)
+        rawOrder = await self.request_private(url, request, channel)
+        order = self.parse_order(rawOrder, market)
+        return order
+
+    async def create_orders_ws(self, orders: List[OrderRequest], params={}):
+        """
+        create a list of trade orders
+
+        https://www.gate.io/docs/developers/futures/ws/en/#order-batch-place
+
+        :param Array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        request = self.createOrdersRequest(orders, params)
+        firstOrder = orders[0]
+        market = self.market(firstOrder['symbol'])
+        if market['swap'] is not True:
+            raise NotSupported(self.id + ' createOrdersWs is not supported for swap markets')
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_batch_place'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrders = await self.request_private(url, request, channel)
+        return self.parse_orders(rawOrders, market)
+
+    async def cancel_all_orders_ws(self, symbol: Str = None, params={}):
+        """
+        cancel all open orders
+
+        https://www.gate.io/docs/developers/futures/ws/en/#cancel-all-open-orders-matched
+        https://www.gate.io/docs/developers/apiv4/ws/en/#order-cancel-all-with-specified-currency-pair
+
+        :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to use, defaults to spot.order_cancel_cp or futures.order_cancel_cp
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_cancel_cp'
+        channel, params = self.handle_option_and_params(params, 'cancelAllOrdersWs', 'channel', channel)
+        url = self.get_url_by_market(market)
+        params = self.omit(params, ['stop', 'trigger'])
+        type, query = self.handle_market_type_and_params('cancelAllOrders', market, params)
+        request, requestParams = self.multiOrderSpotPrepareRequest(market, trigger, query) if (type == 'spot') else self.prepareRequest(market, type, query)
+        await self.authenticate(url, messageType)
+        rawOrders = await self.request_private(url, self.extend(request, requestParams), channel)
+        return self.parse_orders(rawOrders, market)
+
+    async def cancel_order_ws(self, id: str, symbol: Str = None, params={}):
+        """
+        Cancels an open order
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#order-cancel
+        https://www.gate.io/docs/developers/futures/ws/en/#order-cancel
+
+        :param str id: Order id
+        :param str symbol: Unified market symbol
+        :param dict [params]: Parameters specified by the exchange api
+        :param bool [params.trigger]: True if the order to be cancelled is a trigger order
+        :returns: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        trigger = self.safe_value_n(params, ['is_stop_order', 'stop', 'trigger'], False)
+        params = self.omit(params, ['is_stop_order', 'stop', 'trigger'])
+        type, query = self.handle_market_type_and_params('cancelOrder', market, params)
+        request, requestParams = self.spotOrderPrepareRequest(market, trigger, query) if (type == 'spot' or type == 'margin') else self.prepareRequest(market, type, query)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_cancel'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        request['order_id'] = str(id)
+        res = await self.request_private(url, self.extend(request, requestParams), channel)
+        return self.parse_order(res, market)
+
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
+        """
+        edit a trade order, gate currently only supports the modification of the price or amount fields
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#order-amend
+        https://www.gate.io/docs/developers/futures/ws/en/#order-amend
+
+        :param str id: order id
+        :param str symbol: unified symbol of the market to create an order in
+        :param str type: 'market' or 'limit'
+        :param str side: 'buy' or 'sell'
+        :param float amount: how much of the currency you want to trade in units of the 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 dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        extendedRequest = self.edit_order_request(id, symbol, type, side, amount, price, params)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_amend'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrder = await self.request_private(url, extendedRequest, channel)
+        return self.parse_order(rawOrder, market)
+
+    async def fetch_order_ws(self, id: str, symbol: Str = None, params={}):
+        """
+        Retrieves information on an order
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#order-status
+        https://www.gate.io/docs/developers/futures/ws/en/#order-status
+
+        :param str id: Order id
+        :param str symbol: Unified market symbol, *required for spot and margin*
+        :param dict [params]: Parameters specified by the exchange api
+        :param bool [params.trigger]: True if the order being fetched is a trigger order
+        :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for margin trading if not provided self.options['defaultMarginMode'] is used
+        :param str [params.type]: 'spot', 'swap', or 'future', if not provided self.options['defaultMarginMode'] is used
+        :param str [params.settle]: 'btc' or 'usdt' - settle currency for perpetual swap and future - market settle currency is used if symbol is not None, default="usdt" for swap and "btc" for future
+        :returns: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        request, requestParams = self.fetchOrderRequest(id, symbol, params)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_status'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrder = await self.request_private(url, self.extend(request, requestParams), channel)
+        return self.parse_order(rawOrder, market)
+
+    async def fetch_open_orders_ws(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        """
+        fetch all unfilled currently open orders
+
+        https://www.gate.io/docs/developers/futures/ws/en/#order-list
+
+        :param str 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 dict [params]: extra parameters specific to the exchange API endpoint
+        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        return await self.fetch_orders_by_status_ws('open', symbol, since, limit, params)
+
+    async def fetch_closed_orders_ws(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        """
+        fetches information on multiple closed orders made by the user
+
+        https://www.gate.io/docs/developers/futures/ws/en/#order-list
+
+        :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 Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        return await self.fetch_orders_by_status_ws('finished', symbol, since, limit, params)
+
+    async def fetch_orders_by_status_ws(self, status: str, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        """
+
+        https://www.gate.io/docs/developers/futures/ws/en/#order-list
+
+        fetches information on multiple orders made by the user by status
+        :param str status: requested order status
+        :param str symbol: unified market symbol of the market orders were made in
+        :param int|None [since]: the earliest time in ms to fetch orders for
+        :param int|None [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.orderId]: order id to begin at
+        :param int [params.limit]: the maximum number of order structures to retrieve
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+            symbol = market['symbol']
+            if market['swap'] is not True:
+                raise NotSupported(self.id + ' fetchOrdersByStatusWs is only supported by swap markets. Use rest API for other markets')
+        request, requestParams = self.prepareOrdersByStatusRequest(status, symbol, since, limit, params)
+        newRequest = self.omit(request, ['settle'])
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_list'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrders = await self.request_private(url, self.extend(newRequest, requestParams), channel)
+        orders = self.parse_orders(rawOrders, market)
+        return self.filter_by_symbol_since_limit(orders, symbol, since, limit)
+
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://www.gate.com/docs/developers/apiv4/ws/en/#order-book-channel
+        https://www.gate.com/docs/developers/apiv4/ws/en/#order-book-v2-api
+        https://www.gate.com/docs/developers/futures/ws/en/#order-book-api
+        https://www.gate.com/docs/developers/futures/ws/en/#order-book-v2-api
+        https://www.gate.com/docs/developers/delivery/ws/en/#order-book-api
+
         :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
@@ -123,7 +388,7 @@ class gate(ccxt.async_support.gate):
         url = self.get_url_by_market(market)
         payload = [marketId, interval]
         if limit is None:
-            limit = 100
+            limit = 100  # max 100 atm
         if market['contract']:
             stringLimit = str(limit)
             payload.append(stringLimit)
@@ -134,6 +399,31 @@ class gate(ccxt.async_support.gate):
         orderbook = await self.subscribe_public(url, messageHash, payload, channel, query, subscription)
         return orderbook.limit()
 
+    async def un_watch_order_book(self, symbol: str, params={}) -> Any:
+        """
+        unWatches 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 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()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        marketId = market['id']
+        interval = '100ms'
+        interval, params = self.handle_option_and_params(params, 'watchOrderBook', 'interval', interval)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_book_update'
+        subMessageHash = 'orderbook' + ':' + symbol
+        messageHash = 'unsubscribe:orderbook' + ':' + symbol
+        url = self.get_url_by_market(market)
+        payload = [marketId, interval]
+        limit = self.safe_integer(params, 'limit', 100)
+        if market['contract']:
+            stringLimit = str(limit)
+            payload.append(stringLimit)
+        return await self.un_subscribe_public_multiple(url, 'orderbook', [symbol], [messageHash], [subMessageHash], payload, channel, params)
+
     def handle_order_book_subscription(self, client: Client, message, subscription):
         symbol = self.safe_string(subscription, 'symbol')
         limit = self.safe_integer(subscription, 'limit')
@@ -224,10 +514,12 @@ class gate(ccxt.async_support.gate):
         elif nonce >= deltaStart - 1:
             self.handle_delta(storedOrderBook, delta)
         else:
-            error = InvalidNonce(self.id + ' orderbook update has a nonce bigger than u')
             del client.subscriptions[messageHash]
             del self.orderbooks[symbol]
-            client.reject(error, messageHash)
+            checksum = self.handle_option('watchOrderBook', 'checksum', True)
+            if checksum:
+                error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+                client.reject(error, messageHash)
         client.resolve(storedOrderBook, messageHash)
 
     def get_cache_index(self, orderBook, cache):
@@ -268,7 +560,9 @@ class gate(ccxt.async_support.gate):
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#tickers-channel
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#tickers-channel
+
         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
@@ -283,7 +577,9 @@ class gate(ccxt.async_support.gate):
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
-        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#tickers-channel
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#tickers-channel
+
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -314,8 +610,10 @@ class gate(ccxt.async_support.gate):
 
     async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
         """
-        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#best-bid-or-ask-price
-        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#order-book-channel
+
+        https://www.gate.io/docs/developers/apiv4/ws/en/#best-bid-or-ask-price
+        https://www.gate.io/docs/developers/apiv4/ws/en/#order-book-channel
+
         watches best bid & ask for symbols
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -408,7 +706,7 @@ class gate(ccxt.async_support.gate):
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :param str symbol: unified symbol of the market to fetch trades for
+        :param str[] symbols: 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 dict [params]: extra parameters specific to the exchange API endpoint
@@ -432,6 +730,37 @@ class gate(ccxt.async_support.gate):
             limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def un_watch_trades_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        get the list of most recent trades for a particular symbol
+        :param str[] symbols: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        market = self.market(symbols[0])
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.trades'
+        subMessageHashes = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            subMessageHashes.append('trades:' + symbol)
+            messageHashes.append('unsubscribe:trades:' + symbol)
+        url = self.get_url_by_market(market)
+        return await self.un_subscribe_public_multiple(url, 'trades', symbols, messageHashes, subMessageHashes, marketIds, channel, params)
+
+    async def un_watch_trades(self, symbol: str, params={}) -> Any:
+        """
+        get the list of most recent trades for a particular symbol
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        return await self.un_watch_trades_for_symbols([symbol], params)
+
     def handle_trades(self, client: Client, message):
         #
         # {
@@ -549,7 +878,7 @@ class gate(ccxt.async_support.gate):
         :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
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         await self.load_markets()
         subType = None
@@ -739,11 +1068,15 @@ class gate(ccxt.async_support.gate):
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
-        :see: https://www.gate.io/docs/developers/futures/ws/en/#positions-subscription
-        :see: https://www.gate.io/docs/developers/delivery/ws/en/#positions-subscription
-        :see: https://www.gate.io/docs/developers/options/ws/en/#positions-channel
+
+        https://www.gate.io/docs/developers/futures/ws/en/#positions-subscription
+        https://www.gate.io/docs/developers/delivery/ws/en/#positions-subscription
+        https://www.gate.io/docs/developers/options/ws/en/#positions-channel
+
         watch all open positions
-        :param str[]|None symbols: list of unified market symbols
+        :param str[] [symbols]: list of unified market symbols to watch positions for
+        :param int [since]: the earliest time in ms to fetch positions for
+        :param int [limit]: the maximum number of positions to retrieve
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """
@@ -774,7 +1107,7 @@ class gate(ccxt.async_support.gate):
         client = self.client(url)
         self.set_positions_cache(client, type, symbols)
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
-        awaitPositionsSnapshot = self.safe_bool('watchPositions', 'awaitPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.handle_option('watchPositions', 'awaitPositionsSnapshot', True)
         cache = self.safe_value(self.positions, type)
         if fetchPositionsSnapshot and awaitPositionsSnapshot and cache is None:
             return await client.future(type + ':fetchPositionsSnapshot')
@@ -803,7 +1136,9 @@ class gate(ccxt.async_support.gate):
         cache = self.positions[type]
         for i in range(0, len(positions)):
             position = positions[i]
-            cache.append(position)
+            contracts = self.safe_number(position, 'contracts', 0)
+            if contracts > 0:
+                cache.append(position)
         # don't remove the future from the .futures cache
         future = client.futures[messageHash]
         future.resolve(cache)
@@ -847,8 +1182,28 @@ class gate(ccxt.async_support.gate):
         for i in range(0, len(data)):
             rawPosition = data[i]
             position = self.parse_position(rawPosition)
-            newPositions.append(position)
-            cache.append(position)
+            symbol = self.safe_string(position, 'symbol')
+            side = self.safe_string(position, 'side')
+            # Control when position is closed no side is returned
+            if side is None:
+                prevLongPosition = self.safe_dict(cache, symbol + 'long')
+                if prevLongPosition is not None:
+                    position['side'] = prevLongPosition['side']
+                    newPositions.append(position)
+                    cache.append(position)
+                prevShortPosition = self.safe_dict(cache, symbol + 'short')
+                if prevShortPosition is not None:
+                    position['side'] = prevShortPosition['side']
+                    newPositions.append(position)
+                    cache.append(position)
+                # if no prev position is found, default to long
+                if prevLongPosition is None and prevShortPosition is None:
+                    position['side'] = 'long'
+                    newPositions.append(position)
+                    cache.append(position)
+            else:
+                newPositions.append(position)
+                cache.append(position)
         messageHashes = self.find_message_hashes(client, type + ':positions::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]
@@ -869,7 +1224,7 @@ class gate(ccxt.async_support.gate):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.type]: spot, margin, swap, future, or option. Required if listening to all symbols.
         :param boolean [params.isInverse]: if future, listen to inverse or linear contracts
-        :returns dict[]: a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
         market = None
@@ -956,7 +1311,7 @@ class gate(ccxt.async_support.gate):
             elif event == 'finish':
                 status = self.safe_string(parsed, 'status')
                 if status is None:
-                    left = self.safe_number(info, 'left')
+                    left = self.safe_integer(info, 'left')
                     parsed['status'] = 'closed' if (left == 0) else 'canceled'
             stored.append(parsed)
             symbol = parsed['symbol']
@@ -971,9 +1326,11 @@ class gate(ccxt.async_support.gate):
     async def watch_my_liquidations(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
         """
         watch the public liquidations of a trading pair
-        :see: https://www.gate.io/docs/developers/futures/ws/en/#liquidates-api
-        :see: https://www.gate.io/docs/developers/delivery/ws/en/#liquidates-api
-        :see: https://www.gate.io/docs/developers/options/ws/en/#liquidates-channel
+
+        https://www.gate.io/docs/developers/futures/ws/en/#liquidates-api
+        https://www.gate.io/docs/developers/delivery/ws/en/#liquidates-api
+        https://www.gate.io/docs/developers/options/ws/en/#liquidates-channel
+
         :param str symbol: unified CCXT market symbol
         :param int [since]: the earliest time in ms to fetch liquidations for
         :param int [limit]: the maximum number of liquidation structures to retrieve
@@ -982,13 +1339,15 @@ class gate(ccxt.async_support.gate):
         """
         return self.watch_my_liquidations_for_symbols([symbol], since, limit, params)
 
-    async def watch_my_liquidations_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+    async def watch_my_liquidations_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
         """
         watch the private liquidations of a trading pair
-        :see: https://www.gate.io/docs/developers/futures/ws/en/#liquidates-api
-        :see: https://www.gate.io/docs/developers/delivery/ws/en/#liquidates-api
-        :see: https://www.gate.io/docs/developers/options/ws/en/#liquidates-channel
-        :param str symbol: unified CCXT market symbol
+
+        https://www.gate.io/docs/developers/futures/ws/en/#liquidates-api
+        https://www.gate.io/docs/developers/delivery/ws/en/#liquidates-api
+        https://www.gate.io/docs/developers/options/ws/en/#liquidates-channel
+
+        :param str[] symbols: unified CCXT market symbols
         :param int [since]: the earliest time in ms to fetch liquidations for
         :param int [limit]: the maximum number of liquidation structures to retrieve
         :param dict [params]: exchange specific parameters for the gate api endpoint
@@ -1134,38 +1493,88 @@ class gate(ccxt.async_support.gate):
             'datetime': self.iso8601(timestamp),
         })
 
-    def handle_error_message(self, client: Client, message):
-        # {
-        #     "time": 1647274664,
-        #     "channel": "futures.orders",
-        #     "event": "subscribe",
-        #     "error": {code: 2, message: "unknown contract BTC_USDT_20220318"},
-        # }
-        # {
-        #     "time": 1647276473,
-        #     "channel": "futures.orders",
-        #     "event": "subscribe",
-        #     "error": {
-        #       "code": 4,
-        #       "message": "{"label":"INVALID_KEY","message":"Invalid key provided"}\n"
-        #     },
-        #     "result": null
-        #   }
-        error = self.safe_value(message, 'error')
-        code = self.safe_integer(error, 'code')
-        id = self.safe_string(message, 'id')
-        if id is None:
-            return False
-        if code is not None:
+    def handle_error_message(self, client: Client, message) -> Bool:
+        #
+        #    {
+        #        "time": 1647274664,
+        #        "channel": "futures.orders",
+        #        "event": "subscribe",
+        #        "error": {code: 2, message: "unknown contract BTC_USDT_20220318"},
+        #    }
+        #    {
+        #      "time": 1647276473,
+        #      "channel": "futures.orders",
+        #      "event": "subscribe",
+        #      "error": {
+        #        "code": 4,
+        #        "message": "{"label":"INVALID_KEY","message":"Invalid key provided"}\n"
+        #      },
+        #      "result": null
+        #    }
+        #    {
+        #       header: {
+        #         response_time: '1718551891329',
+        #         status: '400',
+        #         channel: 'spot.order_place',
+        #         event: 'api',
+        #         client_id: '81.34.68.6-0xc16375e2c0',
+        #         conn_id: '9539116e0e09678f'
+        #       },
+        #       data: {errs: {label: 'AUTHENTICATION_FAILED', message: 'Not login'}},
+        #       request_id: '10406147'
+        #     }
+        #     {
+        #         "time": 1739853211,
+        #         "time_ms": 1739853211201,
+        #         "id": 1,
+        #         "conn_id": "62f2c1dabbe186d7",
+        #         "trace_id": "cdb02a8c0b61086b2fe6f8fad2f98c54",
+        #         "channel": "spot.trades",
+        #         "event": "subscribe",
+        #         "payload": [
+        #             "LUNARLENS_USDT",
+        #             "ETH_USDT"
+        #         ],
+        #         "error": {
+        #             "code": 2,
+        #             "message": "unknown currency pair: LUNARLENS_USDT"
+        #         },
+        #         "result": {
+        #             "status": "fail"
+        #         },
+        #         "requestId": "cdb02a8c0b61086b2fe6f8fad2f98c54"
+        #     }
+        #
+        data = self.safe_dict(message, 'data')
+        errs = self.safe_dict(data, 'errs')
+        error = self.safe_dict(message, 'error', errs)
+        code = self.safe_string_2(error, 'code', 'label')
+        id = self.safe_string_n(message, ['id', 'requestId', 'request_id'])
+        if error is not None:
             messageHash = self.safe_string(client.subscriptions, id)
-            if messageHash is not None:
-                try:
-                    self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], code, self.json(message))
-                except Exception as e:
-                    client.reject(e, messageHash)
-                    if messageHash in client.subscriptions:
-                        del client.subscriptions[messageHash]
-            del client.subscriptions[id]
+            try:
+                self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], code, self.json(message))
+                self.throw_exactly_matched_exception(self.exceptions['exact'], code, self.json(errs))
+                errorMessage = self.safe_string(error, 'message', self.safe_string(errs, 'message'))
+                self.throw_broadly_matched_exception(self.exceptions['ws']['broad'], errorMessage, self.json(message))
+                raise ExchangeError(self.json(message))
+            except Exception as e:
+                client.reject(e, messageHash)
+                if (messageHash is not None) and (messageHash in client.subscriptions):
+                    del client.subscriptions[messageHash]
+                # remove subscriptions for watchSymbols
+                channel = self.safe_string(message, 'channel')
+                if (channel is not None) and (channel.find('.') > 0):
+                    parsedChannel = channel.split('.')
+                    payload = self.safe_list(message, 'payload', [])
+                    for i in range(0, len(payload)):
+                        marketType = parsedChannel[0] == 'swap' if 'futures' else parsedChannel[0]
+                        symbol = self.safe_symbol(payload[i], None, '_', marketType)
+                        messageHashSymbol = parsedChannel[1] + ':' + symbol
+                        if (messageHashSymbol is not None) and (messageHashSymbol in client.subscriptions):
+                            del client.subscriptions[messageHashSymbol]
+            if (id is not None) and (id in client.subscriptions):
+                del client.subscriptions[id]
             return True
         return False
 
@@ -1188,6 +1597,73 @@ class gate(ccxt.async_support.gate):
         if id in client.subscriptions:
             del client.subscriptions[id]
 
+    def handle_un_subscribe(self, client: Client, message):
+        #
+        # {
+        #     "time":1725534679,
+        #     "time_ms":1725534679786,
+        #     "id":2,
+        #     "conn_id":"fac539b443fd7002",
+        #     "trace_id":"efe1d282b630b4aa266b84bee177791a",
+        #     "channel":"spot.trades",
+        #     "event":"unsubscribe",
+        #     "payload":[
+        #        "LTC_USDT"
+        #     ],
+        #     "result":{
+        #        "status":"success"
+        #     },
+        #     "requestId":"efe1d282b630b4aa266b84bee177791a"
+        # }
+        #
+        id = self.safe_string(message, 'id')
+        keys = list(client.subscriptions.keys())
+        for i in range(0, len(keys)):
+            messageHash = keys[i]
+            if not (messageHash in client.subscriptions):
+                continue
+                # the previous iteration can have deleted the messageHash from the subscriptions
+            if messageHash.startswith('unsubscribe'):
+                subscription = client.subscriptions[messageHash]
+                subId = self.safe_string(subscription, 'id')
+                if id != subId:
+                    continue
+                messageHashes = self.safe_list(subscription, 'messageHashes', [])
+                subMessageHashes = self.safe_list(subscription, 'subMessageHashes', [])
+                for j in range(0, len(messageHashes)):
+                    unsubHash = messageHashes[j]
+                    subHash = subMessageHashes[j]
+                    self.clean_unsubscription(client, subHash, unsubHash)
+                self.clean_cache(subscription)
+
+    def clean_cache(self, subscription: dict):
+        topic = self.safe_string(subscription, 'topic', '')
+        symbols = self.safe_list(subscription, 'symbols', [])
+        symbolsLength = len(symbols)
+        if topic == 'ohlcv':
+            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
+            for i in range(0, len(symbolsAndTimeFrames)):
+                symbolAndTimeFrame = symbolsAndTimeFrames[i]
+                symbol = self.safe_string(symbolAndTimeFrame, 0)
+                timeframe = self.safe_string(symbolAndTimeFrame, 1)
+                del self.ohlcvs[symbol][timeframe]
+        elif symbolsLength > 0:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                if topic.endswith('trades'):
+                    del self.trades[symbol]
+                elif topic == 'orderbook':
+                    del self.orderbooks[symbol]
+                elif topic == 'ticker':
+                    del self.tickers[symbol]
+        else:
+            if topic.endswith('trades'):
+                # don't reset self.myTrades directly here
+                # because in c# we need to use a different object
+                keys = list(self.trades.keys())
+                for i in range(0, len(keys)):
+                    del self.trades[keys[i]]
+
     def handle_message(self, client: Client, message):
         #
         # subscribe
@@ -1284,6 +1760,9 @@ class gate(ccxt.async_support.gate):
         if event == 'subscribe':
             self.handle_subscription_status(client, message)
             return
+        if event == 'unsubscribe':
+            self.handle_un_subscribe(client, message)
+            return
         channel = self.safe_string(message, 'channel', '')
         channelParts = channel.split('.')
         channelType = self.safe_value(channelParts, 1)
@@ -1302,6 +1781,17 @@ class gate(ccxt.async_support.gate):
         method = self.safe_value(v4Methods, channelType)
         if method is not None:
             method(client, message)
+        requestId = self.safe_string(message, 'request_id')
+        if requestId == 'authenticated':
+            self.handle_authentication_message(client, message)
+            return
+        if requestId is not None:
+            data = self.safe_dict(message, 'data')
+            # use safeValue may be Array or an Object
+            result = self.safe_value(data, 'result')
+            ack = self.safe_bool(message, 'ack')
+            if ack is not True:
+                client.resolve(result, requestId)
 
     def get_url_by_market(self, market):
         baseUrl = self.urls['api'][market['type']]
@@ -1310,7 +1800,7 @@ class gate(ccxt.async_support.gate):
         else:
             return baseUrl
 
-    def get_type_by_market(self, market):
+    def get_type_by_market(self, market: Market):
         if market['spot']:
             return 'spot'
         elif market['option']:
@@ -1318,7 +1808,7 @@ class gate(ccxt.async_support.gate):
         else:
             return 'futures'
 
-    def get_url_by_market_type(self, type, isInverse=False):
+    def get_url_by_market_type(self, type: MarketType, isInverse=False):
         api = self.urls['api']
         url = api[type]
         if (type == 'swap') or (type == 'future'):
@@ -1377,6 +1867,74 @@ class gate(ccxt.async_support.gate):
         message = self.extend(request, params)
         return await self.watch_multiple(url, messageHashes, message, messageHashes)
 
+    async def un_subscribe_public_multiple(self, url, topic, symbols, messageHashes, subMessageHashes, payload, channel, params={}):
+        requestId = self.request_id()
+        time = self.seconds()
+        request: dict = {
+            'id': requestId,
+            'time': time,
+            'channel': channel,
+            'event': 'unsubscribe',
+            'payload': payload,
+        }
+        sub = {
+            'id': str(requestId),
+            'topic': topic,
+            'unsubscribe': True,
+            'messageHashes': messageHashes,
+            'subMessageHashes': subMessageHashes,
+            'symbols': symbols,
+        }
+        message = self.extend(request, params)
+        return await self.watch_multiple(url, messageHashes, message, messageHashes, sub)
+
+    async def authenticate(self, url, messageType):
+        channel = messageType + '.login'
+        client = self.client(url)
+        messageHash = 'authenticated'
+        future = client.future(messageHash)
+        authenticated = self.safe_value(client.subscriptions, messageHash)
+        if authenticated is None:
+            return await self.request_private(url, {}, channel, messageHash)
+        return future
+
+    def handle_authentication_message(self, client: Client, message):
+        messageHash = 'authenticated'
+        future = self.safe_value(client.futures, messageHash)
+        future.resolve(True)
+
+    async def request_private(self, url, reqParams, channel, requestId: Str = None):
+        self.check_required_credentials()
+        # uid is required for some subscriptions only so it's not a part of required credentials
+        event = 'api'
+        if requestId is None:
+            reqId = self.request_id()
+            requestId = str(reqId)
+        messageHash = requestId
+        time = self.seconds()
+        # unfortunately, PHP demands double quotes for the escaped newline symbol
+        signatureString = "\n".join([event, channel, self.json(reqParams), str(time)])  # eslint-disable-line quotes
+        signature = self.hmac(self.encode(signatureString), self.encode(self.secret), hashlib.sha512, 'hex')
+        payload: dict = {
+            'req_id': requestId,
+            'timestamp': str(time),
+            'api_key': self.apiKey,
+            'signature': signature,
+            'req_param': reqParams,
+        }
+        if (channel == 'spot.order_place') or (channel == 'futures.order_place'):
+            payload['req_header'] = {
+                'X-Gate-Channel-Id': 'ccxt',
+            }
+        request: dict = {
+            'id': requestId,
+            'time': time,
+            'channel': channel,
+            'event': event,
+            'payload': payload,
+        }
+        return await self.watch(url, messageHash, request, messageHash, requestId)
+
     async def subscribe_private(self, url, messageHash, payload, channel, params, requiresUid=False):
         self.check_required_credentials()
         # uid is required for some subscriptions only so it's not a part of required credentials
@@ -1402,7 +1960,7 @@ class gate(ccxt.async_support.gate):
             'id': requestId,
             'time': time,
             'channel': channel,
-            'event': 'subscribe',
+            'event': event,
             'auth': auth,
         }
         if payload is not None:
@@ -1413,4 +1971,4 @@ class gate(ccxt.async_support.gate):
             # in case of authenticationError we will throw
             client.subscriptions[tempSubscriptionHash] = messageHash
         message = self.extend(request, params)
-        return await self.watch(url, messageHash, message, messageHash)
+        return await self.watch(url, messageHash, message, messageHash, messageHash)