ccxt 4.4.62 → 4.4.64

package/js/src/gate.js

@@ -8,7 +8,7 @@
 import Exchange from './abstract/gate.js';
 import { Precise } from './base/Precise.js';
 import { TICK_SIZE } from './base/functions/number.js';
-import { ExchangeError, BadRequest, ArgumentsRequired, AuthenticationError, PermissionDenied, AccountSuspended, InsufficientFunds, RateLimitExceeded, ExchangeNotAvailable, BadSymbol, InvalidOrder, OrderNotFound, NotSupported, AccountNotEnabled, OrderImmediatelyFillable, BadResponse } from './base/errors.js';
+import { ExchangeError, BadRequest, ArgumentsRequired, AuthenticationError, PermissionDenied, AccountSuspended, InsufficientFunds, RateLimitExceeded, ExchangeNotAvailable, BadSymbol, InvalidOrder, OrderNotFound, NotSupported, AccountNotEnabled, OrderImmediatelyFillable } from './base/errors.js';
 import { sha512 } from './static_dependencies/noble-hashes/sha512.js';
 /**
  * @class gate
@@ -1829,103 +1829,83 @@ export default class gate extends Exchange {
         }
         const response = await this.publicSpotGetCurrencies(params);
         //
-        //    {
-        //        "currency": "BCN",
-        //        "delisted": false,
-        //        "withdraw_disabled": true,
-        //        "withdraw_delayed": false,
-        //        "deposit_disabled": true,
-        //        "trade_disabled": false
-        //    }
-        //
-        //    {
-        //        "currency":"USDT_ETH",
-        //        "delisted":false,
-        //        "withdraw_disabled":false,
-        //        "withdraw_delayed":false,
-        //        "deposit_disabled":false,
-        //        "trade_disabled":false,
-        //        "chain":"ETH"
-        //    }
-        //
+        //  [
+        //   {
+        //       "currency": "USDT_ETH",
+        //       "name": "Tether",
+        //       "delisted": false,
+        //       "withdraw_disabled": false,
+        //       "withdraw_delayed": false,
+        //       "deposit_disabled": false,
+        //       "trade_disabled": true,
+        //       "chain": "ETH"
+        //    },
+        //  ]
+        //
+        const indexedCurrencies = this.indexBy(response, 'currency');
         const result = {};
         for (let i = 0; i < response.length; i++) {
             const entry = response[i];
             const currencyId = this.safeString(entry, 'currency');
-            const currencyIdLower = this.safeStringLower(entry, 'currency');
             const parts = currencyId.split('_');
-            const currency = parts[0];
-            const code = this.safeCurrencyCode(currency);
-            const networkId = this.safeString(entry, 'chain');
-            let networkCode = undefined;
-            if (networkId !== undefined) {
-                networkCode = this.networkIdToCode(networkId, code);
+            const partFirst = this.safeString(parts, 0);
+            // if there's an underscore then the second part is always the chain name (except the _OLD suffix)
+            const currencyName = currencyId.endsWith('_OLD') ? currencyId : partFirst;
+            const withdrawEnabled = !this.safeBool(entry, 'withdraw_disabled');
+            const depositEnabled = !this.safeBool(entry, 'deposit_disabled');
+            const tradeDisabled = !this.safeBool(entry, 'trade_disabled');
+            const precision = this.parseNumber('0.0001'); // temporary safe default, because no value provided from API
+            const code = this.safeCurrencyCode(currencyName);
+            // check leveraged tokens (e.g. BTC3S, ETH5L)
+            let isLeveragedToken = false;
+            if (currencyId.endsWith('3S') || currencyId.endsWith('3L') || currencyId.endsWith('5S') || currencyId.endsWith('5L')) {
+                const realCurrencyId = currencyId.slice(0, -2);
+                if (realCurrencyId in indexedCurrencies) {
+                    isLeveragedToken = true;
+                }
             }
-            const delisted = this.safeValue(entry, 'delisted');
-            const withdrawDisabled = this.safeBool(entry, 'withdraw_disabled', false);
-            const depositDisabled = this.safeBool(entry, 'deposit_disabled', false);
-            const tradeDisabled = this.safeBool(entry, 'trade_disabled', false);
-            const withdrawEnabled = !withdrawDisabled;
-            const depositEnabled = !depositDisabled;
-            const tradeEnabled = !tradeDisabled;
-            const listed = !delisted;
-            const active = listed && tradeEnabled && withdrawEnabled && depositEnabled;
-            if (this.safeValue(result, code) === undefined) {
+            const type = isLeveragedToken ? 'leveraged' : 'crypto';
+            // some networks are null, they are mostly obsolete & unsupported dead tokens, so we can default their networkId to their tokenname
+            const networkId = this.safeString(entry, 'chain', currencyId);
+            const networkCode = this.networkIdToCode(networkId, code);
+            const networkEntry = {
+                'info': entry,
+                'id': networkId,
+                'network': networkCode,
+                'limits': {
+                    'deposit': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'withdraw': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                },
+                'active': !tradeDisabled,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
+                'fee': undefined,
+                'precision': precision,
+            };
+            // check if first entry for the specific currency
+            if (!(code in result)) {
                 result[code] = {
-                    'id': currency,
+                    'id': currencyName,
+                    'lowerCaseId': currencyName.toLowerCase(),
                     'code': code,
-                    'info': undefined,
-                    'name': undefined,
-                    'active': active,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'fee': undefined,
-                    'fees': [],
-                    'precision': this.parseNumber('1e-4'),
+                    'type': type,
+                    'precision': precision,
                     'limits': this.limits,
                     'networks': {},
+                    'info': [], // will be filled below
                 };
             }
-            let depositAvailable = this.safeValue(result[code], 'deposit');
-            depositAvailable = (depositEnabled) ? depositEnabled : depositAvailable;
-            let withdrawAvailable = this.safeValue(result[code], 'withdraw');
-            withdrawAvailable = (withdrawEnabled) ? withdrawEnabled : withdrawAvailable;
-            const networks = this.safeValue(result[code], 'networks', {});
-            if (networkCode !== undefined) {
-                networks[networkCode] = {
-                    'info': entry,
-                    'id': networkId,
-                    'network': networkCode,
-                    'currencyId': currencyId,
-                    'lowerCaseCurrencyId': currencyIdLower,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'active': active,
-                    'fee': undefined,
-                    'precision': this.parseNumber('1e-4'),
-                    'limits': {
-                        'amount': {
-                            'min': undefined,
-                            'max': undefined,
-                        },
-                        'withdraw': {
-                            'min': undefined,
-                            'max': undefined,
-                        },
-                        'deposit': {
-                            'min': undefined,
-                            'max': undefined,
-                        },
-                    },
-                };
-            }
-            result[code]['networks'] = networks;
-            const info = this.safeValue(result[code], 'info', []);
+            result[code]['networks'][networkCode] = networkEntry;
+            const info = this.safeList(result[code], 'info', []);
             info.push(entry);
             result[code]['info'] = info;
-            result[code]['active'] = depositAvailable && withdrawAvailable;
-            result[code]['deposit'] = depositAvailable;
-            result[code]['withdraw'] = withdrawAvailable;
+            result[code] = this.safeCurrencyStructure(result[code]); // this is needed after adding network entry
         }
         return result;
     }
@@ -2174,6 +2154,29 @@ export default class gate extends Exchange {
         }
         return result;
     }
+    /**
+     * @method
+     * @name gate#fetchDepositAddressesByNetwork
+     * @description fetch a dictionary of addresses for a currency, indexed by network
+     * @param {string} code unified currency code of the currency for the deposit address
+     * @param {object} [params] extra parameters specific to the api endpoint
+     * @returns {object} a dictionary of [address structures]{@link https://docs.ccxt.com/#/?id=address-structure} indexed by the network
+     */
+    async fetchDepositAddressesByNetwork(code, params = {}) {
+        await this.loadMarkets();
+        let currency = this.currency(code);
+        const request = {
+            'currency': currency['id'],
+        };
+        const response = await this.privateWalletGetDepositAddress(this.extend(request, params));
+        const chains = this.safeValue(response, 'multichain_addresses', []);
+        const currencyId = this.safeString(response, 'currency');
+        currency = this.safeCurrency(currencyId, currency);
+        const parsed = this.parseDepositAddresses(chains, [currency['code']], false, {
+            'currency': currency['id'],
+        });
+        return this.indexBy(parsed, 'network');
+    }
     /**
      * @method
      * @name gate#fetchDepositAddress
@@ -2186,74 +2189,30 @@ export default class gate extends Exchange {
      */
     async fetchDepositAddress(code, params = {}) {
         await this.loadMarkets();
-        const currency = this.currency(code);
-        const rawNetwork = this.safeStringUpper(params, 'network');
-        params = this.omit(params, 'network');
-        const request = {
-            'currency': currency['id'], // todo: currencies have network-junctions
-        };
-        const response = await this.privateWalletGetDepositAddress(this.extend(request, params));
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
+        const chainsIndexedById = await this.fetchDepositAddressesByNetwork(code, params);
+        const selectedNetworkId = this.selectNetworkCodeFromUnifiedNetworks(code, networkCode, chainsIndexedById);
+        return chainsIndexedById[selectedNetworkId];
+    }
+    parseDepositAddress(depositAddress, currency = undefined) {
         //
-        //    {
-        //        "currency": "XRP",
-        //        "address": "rHcFoo6a9qT5NHiVn1THQRhsEGcxtYCV4d 391331007",
-        //        "multichain_addresses": [
-        //            {
-        //                "chain": "XRP",
-        //                "address": "rHcFoo6a9qT5NHiVn1THQRhsEGcxtYCV4d",
-        //                "payment_id": "391331007",
-        //                "payment_name": "Tag",
-        //                "obtain_failed": 0
-        //            }
-        //        ]
-        //    }
+        //     {
+        //         chain: "BTC",
+        //         address: "1Nxu.......Ys",
+        //         payment_id: "",
+        //         payment_name: "",
+        //         obtain_failed: "0",
+        //     }
         //
-        const currencyId = this.safeString(response, 'currency');
-        code = this.safeCurrencyCode(currencyId);
-        const networkId = this.networkCodeToId(rawNetwork, code);
-        let network = undefined;
-        let tag = undefined;
-        let address = undefined;
-        if (networkId !== undefined) {
-            const addresses = this.safeValue(response, 'multichain_addresses');
-            for (let i = 0; i < addresses.length; i++) {
-                const entry = addresses[i];
-                const entryNetwork = this.safeString(entry, 'chain');
-                if (networkId === entryNetwork) {
-                    const obtainFailed = this.safeInteger(entry, 'obtain_failed');
-                    if (obtainFailed) {
-                        break;
-                    }
-                    address = this.safeString(entry, 'address');
-                    tag = this.safeString(entry, 'payment_id');
-                    network = this.networkIdToCode(networkId, code);
-                    break;
-                }
-            }
-        }
-        else {
-            const addressField = this.safeString(response, 'address');
-            if (addressField !== undefined) {
-                if (addressField.indexOf('New address is being generated for you, please wait') >= 0) {
-                    throw new BadResponse(this.id + ' ' + 'New address is being generated for you, please wait a few seconds and try again to get the address.');
-                }
-                if (addressField.indexOf(' ') >= 0) {
-                    const splitted = addressField.split(' ');
-                    address = splitted[0];
-                    tag = splitted[1];
-                }
-                else {
-                    address = addressField;
-                }
-            }
-        }
+        const address = this.safeString(depositAddress, 'address');
         this.checkAddress(address);
         return {
-            'info': response,
-            'currency': code,
-            'network': network,
+            'info': depositAddress,
+            'currency': this.safeString(currency, 'code'),
             'address': address,
-            'tag': tag,
+            'tag': this.safeString(depositAddress, 'payment_id'),
+            'network': this.networkIdToCode(this.safeString(depositAddress, 'chain')),
         };
     }
     /**
@@ -3986,15 +3945,10 @@ export default class gate extends Exchange {
         if (tag !== undefined) {
             request['memo'] = tag;
         }
-        const networks = this.safeValue(this.options, 'networks', {});
-        let network = this.safeStringUpper(params, 'network'); // this line allows the user to specify either ERC20 or ETH
-        network = this.safeStringLower(networks, network, network); // handle ETH>ERC20 alias
-        if (network !== undefined) {
-            request['chain'] = network;
-            params = this.omit(params, 'network');
-        }
-        else {
-            request['chain'] = currency['id']; // todo: currencies have network-junctions
+        let networkCode = undefined;
+        [networkCode, params] = this.handleNetworkCodeAndParams(params);
+        if (networkCode !== undefined) {
+            request['chain'] = this.networkCodeToId(networkCode);
         }
         const response = await this.privateWithdrawalsPostWithdrawals(this.extend(request, params));
         //

package/js/src/phemex.js

@@ -673,7 +673,8 @@ export default class phemex extends Exchange {
         //     }
         //
         const id = this.safeString(market, 'symbol');
-        const baseId = this.safeString2(market, 'baseCurrency', 'contractUnderlyingAssets');
+        const contractUnderlyingAssets = this.safeString(market, 'contractUnderlyingAssets');
+        const baseId = this.safeString(market, 'baseCurrency', contractUnderlyingAssets);
         const quoteId = this.safeString(market, 'quoteCurrency');
         const settleId = this.safeString(market, 'settleCurrency');
         let base = this.safeCurrencyCode(baseId);
@@ -683,6 +684,10 @@ export default class phemex extends Exchange {
         let inverse = false;
         if (settleId !== quoteId) {
             inverse = true;
+            // some unhandled cases
+            if (!('baseCurrency' in market) && base === quote) {
+                base = settle;
+            }
         }
         const priceScale = this.safeInteger(market, 'priceScale');
         const ratioScale = this.safeInteger(market, 'ratioScale');
@@ -872,7 +877,7 @@ export default class phemex extends Exchange {
      * @returns {object[]} an array of objects representing market data
      */
     async fetchMarkets(params = {}) {
-        const v2Products = await this.v2GetPublicProducts(params);
+        const v2ProductsPromise = this.v2GetPublicProducts(params);
         //
         //     {
         //         "code":0,
@@ -1022,7 +1027,8 @@ export default class phemex extends Exchange {
         //         }
         //     }
         //
-        const v1Products = await this.v1GetExchangePublicProducts(params);
+        const v1ProductsPromise = this.v1GetExchangePublicProducts(params);
+        const [v2Products, v1Products] = await Promise.all([v2ProductsPromise, v1ProductsPromise]);
         const v1ProductsData = this.safeValue(v1Products, 'data', []);
         //
         //     {
@@ -1059,14 +1065,14 @@ export default class phemex extends Exchange {
         //         ]
         //     }
         //
-        const v2ProductsData = this.safeValue(v2Products, 'data', {});
-        let products = this.safeValue(v2ProductsData, 'products', []);
-        const perpetualProductsV2 = this.safeValue(v2ProductsData, 'perpProductsV2', []);
+        const v2ProductsData = this.safeDict(v2Products, 'data', {});
+        let products = this.safeList(v2ProductsData, 'products', []);
+        const perpetualProductsV2 = this.safeList(v2ProductsData, 'perpProductsV2', []);
         products = this.arrayConcat(products, perpetualProductsV2);
-        let riskLimits = this.safeValue(v2ProductsData, 'riskLimits', []);
-        const riskLimitsV2 = this.safeValue(v2ProductsData, 'riskLimitsV2', []);
+        let riskLimits = this.safeList(v2ProductsData, 'riskLimits', []);
+        const riskLimitsV2 = this.safeList(v2ProductsData, 'riskLimitsV2', []);
         riskLimits = this.arrayConcat(riskLimits, riskLimitsV2);
-        const currencies = this.safeValue(v2ProductsData, 'currencies', []);
+        const currencies = this.safeList(v2ProductsData, 'currencies', []);
         const riskLimitsById = this.indexBy(riskLimits, 'symbol');
         const v1ProductsById = this.indexBy(v1ProductsData, 'symbol');
         const currenciesByCode = this.indexBy(currencies, 'currency');
@@ -1076,15 +1082,15 @@ export default class phemex extends Exchange {
             const type = this.safeStringLower(market, 'type');
             if ((type === 'perpetual') || (type === 'perpetualv2') || (type === 'perpetualpilot')) {
                 const id = this.safeString(market, 'symbol');
-                const riskLimitValues = this.safeValue(riskLimitsById, id, {});
+                const riskLimitValues = this.safeDict(riskLimitsById, id, {});
                 market = this.extend(market, riskLimitValues);
-                const v1ProductsValues = this.safeValue(v1ProductsById, id, {});
+                const v1ProductsValues = this.safeDict(v1ProductsById, id, {});
                 market = this.extend(market, v1ProductsValues);
                 market = this.parseSwapMarket(market);
             }
             else {
                 const baseCurrency = this.safeString(market, 'baseCurrency');
-                const currencyValues = this.safeValue(currenciesByCode, baseCurrency, {});
+                const currencyValues = this.safeDict(currenciesByCode, baseCurrency, {});
                 const valueScale = this.safeString(currencyValues, 'valueScale', '8');
                 market = this.extend(market, { 'valueScale': valueScale });
                 market = this.parseSpotMarket(market);

package/js/src/pro/bitmart.js

@@ -121,7 +121,7 @@ export default class bitmart extends bitmartRest {
         const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
         const channelType = (type === 'spot') ? 'spot' : 'futures';
         const actionType = (type === 'spot') ? 'op' : 'action';
-        let rawSubscriptions = [];
+        const rawSubscriptions = [];
         const messageHashes = [];
         for (let i = 0; i < symbols.length; i++) {
             const market = this.market(symbols[i]);
@@ -130,9 +130,10 @@ export default class bitmart extends bitmartRest {
             messageHashes.push(channel + ':' + market['symbol']);
         }
         // as an exclusion, futures "tickers" need one generic request for all symbols
-        if ((type !== 'spot') && (channel === 'ticker')) {
-            rawSubscriptions = [channelType + '/' + channel];
-        }
+        // if ((type !== 'spot') && (channel === 'ticker')) {
+        //     rawSubscriptions = [ channelType + '/' + channel ];
+        // }
+        // Exchange update from 2025-02-11 supports subscription by trading pair for swap
         const request = {
             'args': rawSubscriptions,
         };
@@ -948,39 +949,44 @@ export default class bitmart extends bitmartRest {
     }
     parseWsTrade(trade, market = undefined) {
         // spot
-        //    {
-        //        "price": "52700.50",
-        //        "s_t": 1630982050,
-        //        "side": "buy",
-        //        "size": "0.00112",
-        //        "symbol": "BTC_USDT"
-        //    }
+        //     {
+        //         "ms_t": 1740320841473,
+        //         "price": "2806.54",
+        //         "s_t": 1740320841,
+        //         "side": "sell",
+        //         "size": "0.77598",
+        //         "symbol": "ETH_USDT"
+        //     }
+        //
         // swap
-        //    {
-        //       "trade_id":6798697637,
-        //       "contract_id":1,
-        //       "symbol":"BTCUSDT",
-        //       "deal_price":"39735.8",
-        //       "deal_vol":"2",
-        //       "type":0,
-        //       "way":1,
-        //       "create_time":1701618503,
-        //       "create_time_mill":1701618503517,
-        //       "created_at":"2023-12-03T15:48:23.517518538Z"
-        //    }
+        //     {
+        //         "trade_id": "3000000245258661",
+        //         "symbol": "ETHUSDT",
+        //         "deal_price": "2811.1",
+        //         "deal_vol": "1858",
+        //         "way": 2,
+        //         "m": true,
+        //         "created_at": "2025-02-23T13:59:59.646490751Z"
+        //     }
         //
-        const contractId = this.safeString(trade, 'contract_id');
-        const marketType = (contractId === undefined) ? 'spot' : 'swap';
-        const marketDelimiter = (marketType === 'spot') ? '_' : '';
-        const timestamp = this.safeInteger(trade, 'create_time_mill', this.safeTimestamp(trade, 's_t'));
         const marketId = this.safeString(trade, 'symbol');
+        market = this.safeMarket(marketId, market);
+        let timestamp = this.safeInteger(trade, 'ms_t');
+        let datetime = undefined;
+        if (timestamp === undefined) {
+            datetime = this.safeString(trade, 'created_at');
+            timestamp = this.parse8601(datetime);
+        }
+        else {
+            datetime = this.iso8601(timestamp);
+        }
         return this.safeTrade({
             'info': trade,
             'id': this.safeString(trade, 'trade_id'),
             'order': undefined,
             'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'symbol': this.safeSymbol(marketId, market, marketDelimiter, marketType),
+            'datetime': datetime,
+            'symbol': market['symbol'],
             'type': undefined,
             'side': this.safeString(trade, 'side'),
             'price': this.safeString2(trade, 'price', 'deal_price'),
@@ -1006,20 +1012,22 @@ export default class bitmart extends bitmartRest {
         //        ],
         //        "table": "spot/ticker"
         //    }
-        //    {
-        //        "group":"futures/ticker",
-        //        "data":{
-        //              "symbol":"BTCUSDT",
-        //              "volume_24":"117387.58",
-        //              "fair_price":"146.24",
-        //              "last_price":"146.24",
-        //              "range":"147.17",
-        //              "ask_price": "147.11",
-        //              "ask_vol": "1",
-        //              "bid_price": "142.11",
-        //              "bid_vol": "1"
-        //            }
-        //    }
+        //
+        //     {
+        //         "data": {
+        //             "symbol": "ETHUSDT",
+        //             "last_price": "2807.73",
+        //             "volume_24": "2227011952",
+        //             "range": "0.0273398194664491",
+        //             "mark_price": "2807.5",
+        //             "index_price": "2808.71047619",
+        //             "ask_price": "2808.04",
+        //             "ask_vol": "7371",
+        //             "bid_price": "2807.28",
+        //             "bid_vol": "3561"
+        //         },
+        //         "group": "futures/ticker:ETHUSDT@100ms"
+        //     }
         //
         this.handleBidAsk(client, message);
         const table = this.safeString(message, 'table');
@@ -1044,17 +1052,19 @@ export default class bitmart extends bitmartRest {
     }
     parseWsSwapTicker(ticker, market = undefined) {
         //
-        //    {
-        //        "symbol":"BTCUSDT",
-        //        "volume_24":"117387.58",
-        //        "fair_price":"146.24",
-        //        "last_price":"146.24",
-        //        "range":"147.17",
-        //        "ask_price": "147.11",
-        //        "ask_vol": "1",
-        //        "bid_price": "142.11",
-        //        "bid_vol": "1"
-        //    }
+        //     {
+        //         "symbol": "ETHUSDT",
+        //         "last_price": "2807.73",
+        //         "volume_24": "2227011952",
+        //         "range": "0.0273398194664491",
+        //         "mark_price": "2807.5",
+        //         "index_price": "2808.71047619",
+        //         "ask_price": "2808.04",
+        //         "ask_vol": "7371",
+        //         "bid_price": "2807.28",
+        //         "bid_vol": "3561"
+        //     }
+        //
         const marketId = this.safeString(ticker, 'symbol');
         return this.safeTicker({
             'symbol': this.safeSymbol(marketId, market, '', 'swap'),
@@ -1073,10 +1083,12 @@ export default class bitmart extends bitmartRest {
             'previousClose': undefined,
             'change': undefined,
             'percentage': undefined,
-            'average': this.safeString(ticker, 'fair_price'),
+            'average': undefined,
             'baseVolume': undefined,
             'quoteVolume': this.safeString(ticker, 'volume_24'),
             'info': ticker,
+            'markPrice': this.safeString(ticker, 'mark_price'),
+            'indexPrice': this.safeString(ticker, 'index_price'),
         }, market);
     }
     /**

package/js/src/pro/bitopro.js

@@ -77,7 +77,7 @@ export default class bitopro extends bitoproRest {
             endPart = market['id'];
         }
         else {
-            endPart = market['id'] + ':' + limit;
+            endPart = market['id'] + ':' + this.numberToString(limit);
         }
         const orderbook = await this.watchPublic('order-books', messageHash, endPart);
         return orderbook.limit();

package/js/src/pro/gate.js

@@ -2024,6 +2024,11 @@ export default class gate extends gateRest {
             'signature': signature,
             'req_param': reqParams,
         };
+        if ((channel === 'spot.order_place') || (channel === 'futures.order_place')) {
+            payload['req_header'] = {
+                'x-gate-channel-id': 'ccxt',
+            };
+        }
         const request = {
             'id': requestId,
             'time': time,

package/js/src/pro/vertex.js

@@ -50,6 +50,11 @@ export default class vertex extends vertexRest {
                 },
                 'ws': {
                     'inflate': true,
+                    'options': {
+                        'headers': {
+                            'Sec-WebSocket-Extensions': 'permessage-deflate', // requires permessage-deflate extension, maybe we can set this in client implementation when inflate is true
+                        },
+                    },
                 },
             },
             'streaming': {

package/js/src/tradeogre.js

@@ -518,12 +518,12 @@ export default class tradeogre extends Exchange {
             throw new BadRequest(this.id + ' createOrder does not support market orders');
         }
         if (price === undefined) {
-            throw new ArgumentsRequired(this.id + ' createOrder requires a limit parameter');
+            throw new ArgumentsRequired(this.id + ' createOrder requires a price parameter');
         }
         const request = {
             'market': market['id'],
-            'quantity': this.parseToNumeric(this.amountToPrecision(symbol, amount)),
-            'price': this.parseToNumeric(this.priceToPrecision(symbol, price)),
+            'quantity': this.amountToPrecision(symbol, amount),
+            'price': this.priceToPrecision(symbol, price),
         };
         let response = undefined;
         if (side === 'buy') {