ccxt 4.2.43 → 4.2.45

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

@@ -272,6 +272,7 @@ class gate extends gate$1 {
         /**
          * @method
          * @name gate#watchTicker
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#tickers-channel
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
          * @param {string} symbol unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -280,45 +281,21 @@ class gate extends gate$1 {
         await this.loadMarkets();
         const market = this.market(symbol);
         symbol = market['symbol'];
-        const marketId = market['id'];
-        const url = this.getUrlByMarket(market);
-        const messageType = this.getTypeByMarket(market);
-        const [topic, query] = this.handleOptionAndParams(params, 'watchTicker', 'name', 'tickers');
-        const channel = messageType + '.' + topic;
-        const messageHash = 'ticker:' + symbol;
-        const payload = [marketId];
-        return await this.subscribePublic(url, messageHash, payload, channel, query);
+        params['callerMethodName'] = 'watchTicker';
+        const result = await this.watchTickers([symbol], params);
+        return this.safeValue(result, symbol);
     }
     async watchTickers(symbols = undefined, params = {}) {
         /**
          * @method
          * @name gate#watchTickers
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#tickers-channel
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
          * @param {string[]} symbols unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
-        await this.loadMarkets();
-        symbols = this.marketSymbols(symbols);
-        if (symbols === undefined) {
-            throw new errors.ArgumentsRequired(this.id + ' watchTickers requires symbols');
-        }
-        const market = this.market(symbols[0]);
-        const messageType = this.getTypeByMarket(market);
-        const marketIds = this.marketIds(symbols);
-        const [topic, query] = this.handleOptionAndParams(params, 'watchTicker', 'method', 'tickers');
-        const channel = messageType + '.' + topic;
-        const messageHash = 'tickers';
-        const url = this.getUrlByMarket(market);
-        const ticker = await this.subscribePublic(url, messageHash, marketIds, channel, query);
-        let result = {};
-        if (this.newUpdates) {
-            result[ticker['symbol']] = ticker;
-        }
-        else {
-            result = this.tickers;
-        }
-        return this.filterByArray(result, 'symbol', symbols, true);
+        return await this.subscribeWatchTickersAndBidsAsks(symbols, 'watchTickers', this.extend({ 'method': 'tickers' }, params));
     }
     handleTicker(client, message) {
         //
@@ -338,6 +315,24 @@ class gate extends gate$1 {
         //          "low_24h": "42721.03"
         //        }
         //    }
+        //
+        this.handleTickerAndBidAsk('ticker', client, message);
+    }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name gate#watchBidsAsks
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#best-bid-or-ask-price
+         * @see https://www.gate.io/docs/developers/apiv4/ws/en/#order-book-channel
+         * @description watches best bid & ask for symbols
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        return await this.subscribeWatchTickersAndBidsAsks(symbols, 'watchBidsAsks', this.extend({ 'method': 'book_ticker' }, params));
+    }
+    handleBidAsk(client, message) {
+        //
         //    {
         //        "time": 1671363004,
         //        "time_ms": 1671363004235,
@@ -354,24 +349,63 @@ class gate extends gate$1 {
         //        }
         //    }
         //
+        this.handleTickerAndBidAsk('bidask', client, message);
+    }
+    async subscribeWatchTickersAndBidsAsks(symbols = undefined, callerMethodName = undefined, params = {}) {
+        await this.loadMarkets();
+        [callerMethodName, params] = this.handleParamString(params, 'callerMethodName', callerMethodName);
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const market = this.market(symbols[0]);
+        const messageType = this.getTypeByMarket(market);
+        const marketIds = this.marketIds(symbols);
+        let channelName = undefined;
+        [channelName, params] = this.handleOptionAndParams(params, callerMethodName, 'method');
+        const url = this.getUrlByMarket(market);
+        const channel = messageType + '.' + channelName;
+        const isWatchTickers = callerMethodName.indexOf('watchTicker') >= 0;
+        const prefix = isWatchTickers ? 'ticker' : 'bidask';
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push(prefix + ':' + symbol);
+        }
+        const tickerOrBidAsk = await this.subscribePublicMultiple(url, messageHashes, marketIds, channel, params);
+        if (this.newUpdates) {
+            const items = {};
+            items[tickerOrBidAsk['symbol']] = tickerOrBidAsk;
+            return items;
+        }
+        const result = isWatchTickers ? this.tickers : this.bidsasks;
+        return this.filterByArray(result, 'symbol', symbols, true);
+    }
+    handleTickerAndBidAsk(objectName, client, message) {
         const channel = this.safeString(message, 'channel');
         const parts = channel.split('.');
         const rawMarketType = this.safeString(parts, 0);
         const marketType = (rawMarketType === 'futures') ? 'contract' : 'spot';
-        let result = this.safeValue(message, 'result');
-        if (!Array.isArray(result)) {
-            result = [result];
+        let results = [];
+        if (marketType === 'contract') {
+            results = this.safeList(message, 'result', []);
         }
-        for (let i = 0; i < result.length; i++) {
-            const ticker = result[i];
-            const marketId = this.safeString(ticker, 's');
+        else {
+            const rawTicker = this.safeDict(message, 'result', {});
+            results = [rawTicker];
+        }
+        const isTicker = (objectName === 'ticker'); // whether ticker or bid-ask
+        for (let i = 0; i < results.length; i++) {
+            const rawTicker = results[i];
+            const marketId = this.safeString(rawTicker, 's');
             const market = this.safeMarket(marketId, undefined, '_', marketType);
-            const parsed = this.parseTicker(ticker, market);
-            const symbol = parsed['symbol'];
-            this.tickers[symbol] = parsed;
-            const messageHash = 'ticker:' + symbol;
-            client.resolve(parsed, messageHash);
-            client.resolve(parsed, 'tickers');
+            const parsedItem = this.parseTicker(rawTicker, market);
+            const symbol = parsedItem['symbol'];
+            if (isTicker) {
+                this.tickers[symbol] = parsedItem;
+            }
+            else {
+                this.bidsasks[symbol] = parsedItem;
+            }
+            const messageHash = objectName + ':' + symbol;
+            client.resolve(parsedItem, messageHash);
         }
     }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
@@ -1172,7 +1206,7 @@ class gate extends gate$1 {
             'orders': this.handleOrder,
             'positions': this.handlePositions,
             'tickers': this.handleTicker,
-            'book_ticker': this.handleTicker,
+            'book_ticker': this.handleBidAsk,
             'trades': this.handleTrades,
             'order_book_update': this.handleOrderBook,
             'balances': this.handleBalance,

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

@@ -408,6 +408,7 @@ class hitbtc extends hitbtc$1 {
             const messageHash = channel + '::' + symbol;
             client.resolve(newTickers, messageHash);
         }
+        client.resolve(newTickers, 'tickers');
         const messageHashes = this.findMessageHashes(client, 'tickers::');
         for (let i = 0; i < messageHashes.length; i++) {
             const messageHash = messageHashes[i];

package/dist/cjs/src/probit.js

@@ -1589,12 +1589,12 @@ class probit extends probit$1 {
         const currencyId = this.safeString(transaction, 'currency_id');
         const code = this.safeCurrencyCode(currencyId);
         const status = this.parseTransactionStatus(this.safeString(transaction, 'status'));
-        const feeCost = this.safeNumber(transaction, 'fee');
+        const feeCostString = this.safeString(transaction, 'fee');
         let fee = undefined;
-        if (feeCost !== undefined && feeCost !== 0) {
+        if (feeCostString !== undefined && feeCostString !== '0') {
             fee = {
                 'currency': code,
-                'cost': feeCost,
+                'cost': this.parseNumber(feeCostString),
             };
         }
         return {

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 { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.2.42";
+declare const version = "4.2.44";
 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, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.2.43';
+const version = '4.2.45';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -2,6 +2,7 @@ import { implicitReturnType } from '../base/types.js';
 import { Exchange as _Exchange } from '../base/Exchange.js';
 interface Exchange {
     v2PublicGetCurrencies(params?: {}): Promise<implicitReturnType>;
+    v2PublicGetCurrenciesCrypto(params?: {}): Promise<implicitReturnType>;
     v2PublicGetTime(params?: {}): Promise<implicitReturnType>;
     v2PublicGetExchangeRates(params?: {}): Promise<implicitReturnType>;
     v2PublicGetUsersUserId(params?: {}): Promise<implicitReturnType>;

package/js/src/base/Exchange.d.ts

@@ -75,6 +75,7 @@ export default class Exchange {
     balance: {};
     orderbooks: {};
     tickers: {};
+    bidsasks: {};
     orders: any;
     triggerOrders: any;
     trades: any;
@@ -744,7 +745,10 @@ export default class Exchange {
     setHeaders(headers: any): any;
     marketId(symbol: string): string;
     symbol(symbol: string): string;
+    handleParamString(params: object, paramName: string, defaultValue?: any): [string, object];
     resolvePath(path: any, params: any): any[];
+    getListFromObjectValues(objects: any, key: IndexType): any[];
+    getSymbolsForMarketType(marketType?: string, subType?: string, symbolWithActiveStatus?: boolean, symbolWithUnknownStatus?: boolean): any[];
     filterByArray(objects: any, key: IndexType, values?: any, indexed?: boolean): any;
     fetch2(path: any, api?: any, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;
     request(path: any, api?: any, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;

package/js/src/base/Exchange.js

@@ -59,6 +59,7 @@ export default class Exchange {
         this.balance = {};
         this.orderbooks = {};
         this.tickers = {};
+        this.bidsasks = {};
         this.orders = undefined;
         this.triggerOrders = undefined;
         this.transactions = {};
@@ -3136,6 +3137,9 @@ export default class Exchange {
          * @param {string} currencyCode unified currency code, but this argument is not required by default, unless there is an exchange (like huobi) that needs an override of the method to be able to pass currencyCode argument additionally
          * @returns {string|undefined} exchange-specific network id
          */
+        if (networkCode === undefined) {
+            return undefined;
+        }
         const networkIdsByCodes = this.safeValue(this.options, 'networks', {});
         let networkId = this.safeString(networkIdsByCodes, networkCode);
         // for example, if 'ETH' is passed for networkCode, but 'ETH' key not defined in `options->networks` object
@@ -3179,6 +3183,9 @@ export default class Exchange {
          * @param {string|undefined} currencyCode unified currency code, but this argument is not required by default, unless there is an exchange (like huobi) that needs an override of the method to be able to pass currencyCode argument additionally
          * @returns {string|undefined} unified network code
          */
+        if (networkId === undefined) {
+            return undefined;
+        }
         const networkCodesByIds = this.safeDict(this.options, 'networksById', {});
         let networkCode = this.safeString(networkCodesByIds, networkId, networkId);
         // replace mainnet network-codes (i.e. ERC20->ETH)
@@ -3420,12 +3427,46 @@ export default class Exchange {
         const market = this.market(symbol);
         return this.safeString(market, 'symbol', symbol);
     }
+    handleParamString(params, paramName, defaultValue = undefined) {
+        const value = this.safeString(params, paramName, defaultValue);
+        if (value !== undefined) {
+            params = this.omit(params, paramName);
+        }
+        return [value, params];
+    }
     resolvePath(path, params) {
         return [
             this.implodeParams(path, params),
             this.omit(params, this.extractParams(path)),
         ];
     }
+    getListFromObjectValues(objects, key) {
+        const newArray = this.toArray(objects);
+        const results = [];
+        for (let i = 0; i < newArray.length; i++) {
+            results.push(newArray[i][key]);
+        }
+        return results;
+    }
+    getSymbolsForMarketType(marketType = undefined, subType = undefined, symbolWithActiveStatus = true, symbolWithUnknownStatus = true) {
+        let filteredMarkets = this.markets;
+        if (marketType !== undefined) {
+            filteredMarkets = this.filterBy(filteredMarkets, 'type', marketType);
+        }
+        if (subType !== undefined) {
+            this.checkRequiredArgument('getSymbolsForMarketType', subType, 'subType', ['linear', 'inverse', 'quanto']);
+            filteredMarkets = this.filterBy(filteredMarkets, 'subType', subType);
+        }
+        const activeStatuses = [];
+        if (symbolWithActiveStatus) {
+            activeStatuses.push(true);
+        }
+        if (symbolWithUnknownStatus) {
+            activeStatuses.push(undefined);
+        }
+        filteredMarkets = this.filterByArray(filteredMarkets, 'active', activeStatuses, false);
+        return this.getListFromObjectValues(filteredMarkets, 'symbol');
+    }
     filterByArray(objects, key, values = undefined, indexed = true) {
         objects = this.toArray(objects);
         // return all of them if no values were passed
@@ -4351,6 +4392,19 @@ export default class Exchange {
                 return depositAddress;
             }
         }
+        else if (this.has['fetchDepositAddressesByNetwork']) {
+            const network = this.safeString(params, 'network');
+            params = this.omit(params, 'network');
+            const addressStructures = await this.fetchDepositAddressesByNetwork(code, params);
+            if (network !== undefined) {
+                return this.safeDict(addressStructures, network);
+            }
+            else {
+                const keys = Object.keys(addressStructures);
+                const key = this.safeString(keys, 0);
+                return this.safeDict(addressStructures, key);
+            }
+        }
         else {
             throw new NotSupported(this.id + ' fetchDepositAddress() is not supported yet');
         }

package/js/src/binance.d.ts

@@ -63,6 +63,7 @@ export default class binance extends Exchange {
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOpenOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;