ccxt 4.3.46 → 4.3.48

package/dist/cjs/src/pro/gate.js

@@ -13,6 +13,27 @@ class gate extends gate$1 {
         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,
@@ -86,15 +107,249 @@ class gate extends gate$1 {
             'exceptions': {
                 'ws': {
                     'exact': {
+                        '1': errors.BadRequest,
                         '2': errors.BadRequest,
                         '4': errors.AuthenticationError,
                         '6': errors.AuthenticationError,
                         '11': errors.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 errors.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 errors.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
@@ -1221,42 +1476,59 @@ class gate extends gate$1 {
         });
     }
     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 errors.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;
@@ -1399,6 +1671,20 @@ class gate extends gate$1 {
         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']];
@@ -1485,6 +1771,51 @@ class gate extends gate$1 {
         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.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
@@ -1514,7 +1845,7 @@ class gate extends gate$1 {
             'id': requestId,
             'time': time,
             'channel': channel,
-            'event': 'subscribe',
+            'event': event,
             'auth': auth,
         };
         if (payload !== undefined) {

package/dist/cjs/src/woo.js

@@ -2534,6 +2534,12 @@ class woo extends woo$1 {
                 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/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, TransferEntries, LeverageTiers } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
-declare const version = "4.3.45";
+declare const version = "4.3.47";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.46';
+const version = '4.3.48';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/krakenfutures.d.ts

@@ -17,6 +17,8 @@ interface Exchange {
     privateGetTransfers(params?: {}): Promise<implicitReturnType>;
     privateGetLeveragepreferences(params?: {}): Promise<implicitReturnType>;
     privateGetPnlpreferences(params?: {}): Promise<implicitReturnType>;
+    privateGetAssignmentprogramCurrent(params?: {}): Promise<implicitReturnType>;
+    privateGetAssignmentprogramHistory(params?: {}): Promise<implicitReturnType>;
     privatePostSendorder(params?: {}): Promise<implicitReturnType>;
     privatePostEditorder(params?: {}): Promise<implicitReturnType>;
     privatePostCancelorder(params?: {}): Promise<implicitReturnType>;
@@ -25,6 +27,8 @@ interface Exchange {
     privatePostCancelallorders(params?: {}): Promise<implicitReturnType>;
     privatePostCancelallordersafter(params?: {}): Promise<implicitReturnType>;
     privatePostWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privatePostAssignmentprogramAdd(params?: {}): Promise<implicitReturnType>;
+    privatePostAssignmentprogramDelete(params?: {}): Promise<implicitReturnType>;
     privatePutLeveragepreferences(params?: {}): Promise<implicitReturnType>;
     privatePutPnlpreferences(params?: {}): Promise<implicitReturnType>;
     chartsGetPriceTypeSymbolInterval(params?: {}): Promise<implicitReturnType>;

package/js/src/base/functions/number.js

@@ -84,8 +84,8 @@ const truncate_to_string = (num, precision = 0) => {
 const truncate = (num, precision = 0) => parseFloat(truncate_to_string(num, precision));
 function precisionFromString(str) {
     // support string formats like '1e-4'
-    if (str.indexOf('e') > -1) {
-        const numStr = str.replace(/\de/, '');
+    if (str.indexOf('e') > -1 || str.indexOf('E') > -1) {
+        const numStr = str.replace(/\d\.?\d*[eE]/, '');
         return parseInt(numStr) * -1;
     }
     // support integer formats (without dot) like '1', '10' etc [Note: bug in decimalToPrecision, so this should not be used atm]

package/js/src/binance.d.ts

@@ -93,7 +93,7 @@ export default class binance extends Exchange {
     };
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
-    parseTransactionStatusByType(status: any, type?: any): string;
+    parseTransactionStatusByType(status: any, type?: any): any;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     parseTransferStatus(status: Str): Str;
     parseTransfer(transfer: Dict, currency?: Currency): TransferEntry;

package/js/src/binance.js

@@ -6169,7 +6169,7 @@ export default class binance extends Exchange {
         if (!market['spot']) {
             throw new NotSupported(this.id + ' createMarketOrderWithCost() supports spot orders only');
         }
-        params['quoteOrderQty'] = cost;
+        params['cost'] = cost;
         return await this.createOrder(symbol, 'market', side, cost, undefined, params);
     }
     async createMarketBuyOrderWithCost(symbol, cost, params = {}) {
@@ -6188,7 +6188,7 @@ export default class binance extends Exchange {
         if (!market['spot']) {
             throw new NotSupported(this.id + ' createMarketBuyOrderWithCost() supports spot orders only');
         }
-        params['quoteOrderQty'] = cost;
+        params['cost'] = cost;
         return await this.createOrder(symbol, 'market', 'buy', cost, undefined, params);
     }
     async createMarketSellOrderWithCost(symbol, cost, params = {}) {
@@ -7923,6 +7923,9 @@ export default class binance extends Exchange {
         return this.parseTransactions(response, currency, since, limit);
     }
     parseTransactionStatusByType(status, type = undefined) {
+        if (type === undefined) {
+            return status;
+        }
         const statusesByType = {
             'deposit': {
                 '0': 'pending',
@@ -8809,7 +8812,7 @@ export default class binance extends Exchange {
         const request = {
             'coin': currency['id'],
             'address': address,
-            'amount': amount,
+            'amount': this.currencyToPrecision(code, amount),
             // https://binance-docs.github.io/apidocs/spot/en/#withdraw-sapi
             // issue sapiGetCapitalConfigGetall () to get networks for withdrawing USDT ERC20 vs USDT Omni
             // 'network': 'ETH', // 'BTC', 'TRX', etc, optional

package/js/src/bitget.js

@@ -4414,7 +4414,7 @@ export default class bitget extends Exchange {
             }
             if (marginMode !== undefined) {
                 request['loanType'] = 'normal';
-                if (createMarketBuyOrderRequiresPrice && isMarketOrder && (side === 'buy')) {
+                if (isMarketOrder && (side === 'buy')) {
                     request['quoteSize'] = quantity;
                 }
                 else {

package/js/src/bitmart.js

@@ -2333,7 +2333,7 @@ export default class bitmart extends Exchange {
         const trailingActivationPrice = this.safeNumber(order, 'activation_price');
         return this.safeOrder({
             'id': id,
-            'clientOrderId': this.safeString(order, 'client_order_id'),
+            'clientOrderId': this.safeString2(order, 'client_order_id', 'clientOrderId'),
             'info': order,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),

package/js/src/gate.d.ts

@@ -165,15 +165,19 @@ export default class gate extends Exchange {
     parseTransactionType(type: any): string;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createOrdersRequest(orders: OrderRequest[], params?: {}): any[];
     createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
     createOrderRequest(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): any;
     createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
+    editOrderRequest(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): any;
     editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
     parseOrderStatus(status: Str): string;
     parseOrder(order: Dict, market?: Market): Order;
+    fetchOrderRequest(id: string, symbol?: Str, params?: {}): any[];
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOrdersByStatusRequest(status: any, symbol?: Str, since?: Int, limit?: Int, params?: {}): any[];
     fetchOrdersByStatus(status: any, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     cancelAllOrders(symbol?: Str, params?: {}): Promise<Order[]>;