ccxt 4.3.47 → 4.3.49

package/js/src/pro/gate.d.ts

@@ -1,8 +1,17 @@
 import gateRest from '../gate.js';
-import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Position, Balances, Liquidation } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Position, Balances, Liquidation, OrderType, OrderSide, Num, Market, MarketType, OrderRequest } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class gate extends gateRest {
     describe(): any;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createOrdersWs(orders: OrderRequest[], params?: {}): Promise<Order[]>;
+    cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<Order[]>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
+    fetchOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchClosedOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOrdersByStatusWs(status: string, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
     handleOrderBook(client: Client, message: any): void;
@@ -40,11 +49,14 @@ export default class gate extends gateRest {
     handleSubscriptionStatus(client: Client, message: any): void;
     handleMessage(client: Client, message: any): void;
     getUrlByMarket(market: any): any;
-    getTypeByMarket(market: any): "spot" | "futures" | "options";
-    getUrlByMarketType(type: any, isInverse?: boolean): any;
+    getTypeByMarket(market: Market): "spot" | "futures" | "options";
+    getUrlByMarketType(type: MarketType, isInverse?: boolean): any;
     getMarketTypeByUrl(url: string): any;
     requestId(): any;
     subscribePublic(url: any, messageHash: any, payload: any, channel: any, params?: {}, subscription?: any): Promise<any>;
     subscribePublicMultiple(url: any, messageHashes: any, payload: any, channel: any, params?: {}): Promise<any>;
+    authenticate(url: any, messageType: any): Promise<any>;
+    handleAuthenticationMessage(client: Client, message: any): void;
+    requestPrivate(url: any, reqParams: any, channel: any, requestId?: Str): Promise<any>;
     subscribePrivate(url: any, messageHash: any, payload: any, channel: any, params: any, requiresUid?: boolean): Promise<any>;
 }

package/js/src/pro/gate.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import gateRest from '../gate.js';
-import { AuthenticationError, BadRequest, ArgumentsRequired, InvalidNonce } from '../base/errors.js';
+import { AuthenticationError, BadRequest, ArgumentsRequired, InvalidNonce, ExchangeError, NotSupported } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha512 } from '../static_dependencies/noble-hashes/sha512.js';
 import Precise from '../base/Precise.js';
@@ -16,6 +16,27 @@ export default class gate extends gateRest {
         return this.deepExtend(super.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,
                 'watchTicker': true,
                 'watchTickers': true,
@@ -89,15 +110,249 @@ export default class gate extends gateRest {
             'exceptions': {
                 'ws': {
                     'exact': {
+                        '1': BadRequest,
                         '2': BadRequest,
                         '4': AuthenticationError,
                         '6': AuthenticationError,
                         '11': AuthenticationError,
                     },
+                    'broad': {},
                 },
             },
         });
     }
+    async createOrderWs(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#createOrderWs
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#order-place
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-place
+         * @description Create an order on the exchange
+         * @param {string} symbol Unified CCXT market symbol
+         * @param {string} type 'limit' or 'market' *"market" is contract only*
+         * @param {string} 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 fullfilled at in units of the quote currency
+         * @param {object} [params]  extra parameters specific to the exchange API endpoint
+         * @param {float} [params.stopPrice] The price at which a trigger order is triggered at
+         * @param {string} [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 {string} [params.marginMode] 'cross' or 'isolated' - marginMode for margin trading if not provided this.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 {string} [params.text] User defined information
+         * @param {string} [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 {string} [params.settle] *contract only* Unified Currency Code for settle currency
+         * @param {bool} [params.reduceOnly] *contract only* Indicates if this order is to reduce the size of a position
+         * @param {bool} [params.close] *contract only* Set as true 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 as an alternative for the amount
+         * @returns {object|undefined} [An order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const messageType = this.getTypeByMarket(market);
+        const channel = messageType + '.order_place';
+        const url = this.getUrlByMarket(market);
+        params['textIsRequired'] = true;
+        const request = this.createOrderRequest(symbol, type, side, amount, price, params);
+        await this.authenticate(url, messageType);
+        const rawOrder = await this.requestPrivate(url, request, channel);
+        const order = this.parseOrder(rawOrder, market);
+        return order;
+    }
+    async createOrdersWs(orders, params = {}) {
+        /**
+         * @method
+         * @name gate#createOrdersWs
+         * @description create a list of trade orders
+         * @see 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
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const request = this.createOrdersRequest(orders, params);
+        const firstOrder = orders[0];
+        const market = this.market(firstOrder['symbol']);
+        if (market['swap'] !== true) {
+            throw new NotSupported(this.id + ' createOrdersWs is not supported for swap markets');
+        }
+        const messageType = this.getTypeByMarket(market);
+        const channel = messageType + '.order_batch_place';
+        const url = this.getUrlByMarket(market);
+        await this.authenticate(url, messageType);
+        const rawOrders = await this.requestPrivate(url, request, channel);
+        return this.parseOrders(rawOrders, market);
+    }
+    async cancelAllOrdersWs(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#cancelAllOrdersWs
+         * @description cancel all open orders
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#cancel-all-open-orders-matched
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#order-cancel-all-with-specified-currency-pair
+         * @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.channel] the channel to use, defaults to spot.order_cancel_cp or futures.order_cancel_cp
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = (symbol === undefined) ? undefined : this.market(symbol);
+        const stop = this.safeBool2(params, 'stop', 'trigger');
+        const messageType = this.getTypeByMarket(market);
+        let channel = messageType + '.order_cancel_cp';
+        [channel, params] = this.handleOptionAndParams(params, 'cancelAllOrdersWs', 'channel', channel);
+        const url = this.getUrlByMarket(market);
+        params = this.omit(params, ['stop', 'trigger']);
+        const [type, query] = this.handleMarketTypeAndParams('cancelAllOrders', market, params);
+        const [request, requestParams] = (type === 'spot') ? this.multiOrderSpotPrepareRequest(market, stop, query) : this.prepareRequest(market, type, query);
+        await this.authenticate(url, messageType);
+        const rawOrders = await this.requestPrivate(url, this.extend(request, requestParams), channel);
+        return this.parseOrders(rawOrders, market);
+    }
+    async cancelOrderWs(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#cancelOrderWs
+         * @description Cancels an open order
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#order-cancel
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-cancel
+         * @param {string} id Order id
+         * @param {string} symbol Unified market symbol
+         * @param {object} [params] Parameters specified by the exchange api
+         * @param {bool} [params.stop] True if the order to be cancelled is a trigger order
+         * @returns An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = (symbol === undefined) ? undefined : this.market(symbol);
+        const stop = this.safeValue2(params, 'is_stop_order', 'stop', false);
+        params = this.omit(params, ['is_stop_order', 'stop']);
+        const [type, query] = this.handleMarketTypeAndParams('cancelOrder', market, params);
+        const [request, requestParams] = (type === 'spot' || type === 'margin') ? this.spotOrderPrepareRequest(market, stop, query) : this.prepareRequest(market, type, query);
+        const messageType = this.getTypeByMarket(market);
+        const channel = messageType + '.order_cancel';
+        const url = this.getUrlByMarket(market);
+        await this.authenticate(url, messageType);
+        request['order_id'] = id.toString();
+        const res = await this.requestPrivate(url, this.extend(request, requestParams), channel);
+        return this.parseOrder(res, market);
+    }
+    async editOrderWs(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#editOrderWs
+         * @description edit a trade order, gate currently only supports the modification of the price or amount fields
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#order-amend
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-amend
+         * @param {string} id order id
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much of the currency you want to trade in units of the base currency
+         * @param {float} [price] the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const extendedRequest = this.editOrderRequest(id, symbol, type, side, amount, price, params);
+        const messageType = this.getTypeByMarket(market);
+        const channel = messageType + '.order_amend';
+        const url = this.getUrlByMarket(market);
+        await this.authenticate(url, messageType);
+        const rawOrder = await this.requestPrivate(url, extendedRequest, channel);
+        return this.parseOrder(rawOrder, market);
+    }
+    async fetchOrderWs(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#fetchOrderWs
+         * @description Retrieves information on an order
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#order-status
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-status
+         * @param {string} id Order id
+         * @param {string} symbol Unified market symbol, *required for spot and margin*
+         * @param {object} [params] Parameters specified by the exchange api
+         * @param {bool} [params.stop] True if the order being fetched is a trigger order
+         * @param {string} [params.marginMode] 'cross' or 'isolated' - marginMode for margin trading if not provided this.options['defaultMarginMode'] is used
+         * @param {string} [params.type] 'spot', 'swap', or 'future', if not provided this.options['defaultMarginMode'] is used
+         * @param {string} [params.settle] 'btc' or 'usdt' - settle currency for perpetual swap and future - market settle currency is used if symbol !== undefined, default="usdt" for swap and "btc" for future
+         * @returns An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = (symbol === undefined) ? undefined : this.market(symbol);
+        const [request, requestParams] = this.fetchOrderRequest(id, symbol, params);
+        const messageType = this.getTypeByMarket(market);
+        const channel = messageType + '.order_status';
+        const url = this.getUrlByMarket(market);
+        await this.authenticate(url, messageType);
+        const rawOrder = await this.requestPrivate(url, this.extend(request, requestParams), channel);
+        return this.parseOrder(rawOrder, market);
+    }
+    async fetchOpenOrdersWs(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#fetchOpenOrdersWs
+         * @description fetch all unfilled currently open orders
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-list
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch open orders for
+         * @param {int} [limit] the maximum number of  open orders structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        return await this.fetchOrdersByStatusWs('open', symbol, since, limit, params);
+    }
+    async fetchClosedOrdersWs(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#fetchClosedOrdersWs
+         * @description fetches information on multiple closed orders made by the user
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-list
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        return await this.fetchOrdersByStatusWs('finished', symbol, since, limit, params);
+    }
+    async fetchOrdersByStatusWs(status, symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#fetchOrdersWs
+         * @see https://www.gate.io/docs/developers/futures/ws/en/#order-list
+         * @description fetches information on multiple orders made by the user by status
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int|undefined} [since] the earliest time in ms to fetch orders for
+         * @param {int|undefined} [limit] the maximum number of order structures to retrieve
+         * @param {object} [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 {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            symbol = market['symbol'];
+            if (market['swap'] !== true) {
+                throw new NotSupported(this.id + ' fetchOrdersByStatusWs is only supported by swap markets. Use rest API for other markets');
+            }
+        }
+        const [request, requestParams] = this.fetchOrdersByStatusRequest(status, symbol, since, limit, params);
+        const newRequest = this.omit(request, ['settle']);
+        const messageType = this.getTypeByMarket(market);
+        const channel = messageType + '.order_list';
+        const url = this.getUrlByMarket(market);
+        await this.authenticate(url, messageType);
+        const rawOrders = await this.requestPrivate(url, this.extend(newRequest, requestParams), channel);
+        const orders = this.parseOrders(rawOrders, market);
+        return this.filterBySymbolSinceLimit(orders, symbol, since, limit);
+    }
     async watchOrderBook(symbol, limit = undefined, params = {}) {
         /**
          * @method
@@ -1224,42 +1479,59 @@ export default class gate extends gateRest {
         });
     }
     handleErrorMessage(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
-        //   }
-        const error = this.safeValue(message, 'error');
-        const code = this.safeInteger(error, 'code');
-        const id = this.safeString(message, 'id');
-        if (id === undefined) {
-            return false;
-        }
-        if (code !== undefined) {
+        //
+        //    {
+        //        "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'
+        //     }
+        //
+        const data = this.safeDict(message, 'data');
+        const errs = this.safeDict(data, 'errs');
+        const error = this.safeDict(message, 'error', errs);
+        const code = this.safeString2(error, 'code', 'label');
+        const id = this.safeString2(message, 'id', 'requestId');
+        if (error !== undefined) {
             const messageHash = this.safeString(client.subscriptions, id);
-            if (messageHash !== undefined) {
-                try {
-                    this.throwExactlyMatchedException(this.exceptions['ws']['exact'], code, this.json(message));
-                }
-                catch (e) {
-                    client.reject(e, messageHash);
-                    if (messageHash in client.subscriptions) {
-                        delete client.subscriptions[messageHash];
-                    }
+            try {
+                this.throwExactlyMatchedException(this.exceptions['ws']['exact'], code, this.json(message));
+                this.throwExactlyMatchedException(this.exceptions['exact'], code, this.json(errs));
+                const errorMessage = this.safeString(error, 'message', this.safeString(errs, 'message'));
+                this.throwBroadlyMatchedException(this.exceptions['ws']['broad'], errorMessage, this.json(message));
+                throw new ExchangeError(this.json(message));
+            }
+            catch (e) {
+                client.reject(e, messageHash);
+                if ((messageHash !== undefined) && (messageHash in client.subscriptions)) {
+                    delete client.subscriptions[messageHash];
                 }
             }
-            delete client.subscriptions[id];
+            if (id !== undefined) {
+                delete client.subscriptions[id];
+            }
             return true;
         }
         return false;
@@ -1402,6 +1674,20 @@ export default class gate extends gateRest {
         if (method !== undefined) {
             method.call(this, client, message);
         }
+        const requestId = this.safeString(message, 'request_id');
+        if (requestId === 'authenticated') {
+            this.handleAuthenticationMessage(client, message);
+            return;
+        }
+        if (requestId !== undefined) {
+            const data = this.safeDict(message, 'data');
+            // use safeValue as result may be Array or an Object
+            const result = this.safeValue(data, 'result');
+            const ack = this.safeBool(message, 'ack');
+            if (ack !== true) {
+                client.resolve(result, requestId);
+            }
+        }
     }
     getUrlByMarket(market) {
         const baseUrl = this.urls['api'][market['type']];
@@ -1488,6 +1774,51 @@ export default class gate extends gateRest {
         const message = this.extend(request, params);
         return await this.watchMultiple(url, messageHashes, message, messageHashes);
     }
+    async authenticate(url, messageType) {
+        const channel = messageType + '.login';
+        const client = this.client(url);
+        const messageHash = 'authenticated';
+        const future = client.future(messageHash);
+        const authenticated = this.safeValue(client.subscriptions, messageHash);
+        if (authenticated === undefined) {
+            return await this.requestPrivate(url, {}, channel, messageHash);
+        }
+        return future;
+    }
+    handleAuthenticationMessage(client, message) {
+        const messageHash = 'authenticated';
+        const future = this.safeValue(client.futures, messageHash);
+        future.resolve(true);
+    }
+    async requestPrivate(url, reqParams, channel, requestId = undefined) {
+        this.checkRequiredCredentials();
+        // uid is required for some subscriptions only so it's not a part of required credentials
+        const event = 'api';
+        if (requestId === undefined) {
+            const reqId = this.requestId();
+            requestId = reqId.toString();
+        }
+        const messageHash = requestId;
+        const time = this.seconds();
+        // unfortunately, PHP demands double quotes for the escaped newline symbol
+        const signatureString = [event, channel, this.json(reqParams), time.toString()].join("\n"); // eslint-disable-line quotes
+        const signature = this.hmac(this.encode(signatureString), this.encode(this.secret), sha512, 'hex');
+        const payload = {
+            'req_id': requestId,
+            'timestamp': time.toString(),
+            'api_key': this.apiKey,
+            'signature': signature,
+            'req_param': reqParams,
+        };
+        const request = {
+            'id': requestId,
+            'time': time,
+            'channel': channel,
+            'event': event,
+            'payload': payload,
+        };
+        return await this.watch(url, messageHash, request, messageHash);
+    }
     async subscribePrivate(url, messageHash, payload, channel, params, requiresUid = false) {
         this.checkRequiredCredentials();
         // uid is required for some subscriptions only so it's not a part of required credentials
@@ -1517,7 +1848,7 @@ export default class gate extends gateRest {
             'id': requestId,
             'time': time,
             'channel': channel,
-            'event': 'subscribe',
+            'event': event,
             'auth': auth,
         };
         if (payload !== undefined) {

package/js/src/woo.js

@@ -2537,6 +2537,12 @@ export default class woo extends Exchange {
                 url += '?' + this.urlencode(params);
             }
         }
+        else if (access === 'pub') {
+            url += pathWithParams;
+            if (Object.keys(params).length) {
+                url += '?' + this.urlencode(params);
+            }
+        }
         else {
             this.checkRequiredCredentials();
             if (method === 'POST' && (path === 'algo/order' || path === 'order')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.3.47",
+  "version": "4.3.49",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",