ccxt 4.2.44 → 4.2.46

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/gemini.js

@@ -460,10 +460,11 @@ class gemini extends gemini$1 {
         const market = this.safeMarket(marketId.toLowerCase());
         const symbol = market['symbol'];
         const messageHash = 'orderbook:' + symbol;
-        let orderbook = this.safeDict(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook();
+        if (!(symbol in this.orderbooks)) {
+            const ob = this.orderBook();
+            this.orderbooks[symbol] = ob;
         }
+        const orderbook = this.orderbooks[symbol];
         const bids = orderbook['bids'];
         const asks = orderbook['asks'];
         for (let i = 0; i < rawOrderBookChanges.length; i++) {

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/dist/cjs/src/timex.js

@@ -41,6 +41,9 @@ class timex extends timex$1 {
                 'fetchCrossBorrowRates': false,
                 'fetchCurrencies': true,
                 'fetchDeposit': false,
+                'fetchDepositAddress': true,
+                'fetchDepositAddresses': false,
+                'fetchDepositAddressesByNetwork': false,
                 'fetchDeposits': true,
                 'fetchFundingHistory': false,
                 'fetchFundingRate': false,
@@ -1521,7 +1524,69 @@ class timex extends timex$1 {
             'trades': rawTrades,
         }, market);
     }
+    async fetchDepositAddress(code, params = {}) {
+        /**
+         * @method
+         * @name timex#fetchDepositAddress
+         * @description fetch the deposit address for a currency associated with this account, does not accept params["network"]
+         * @param {string} code unified currency code
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
+         */
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'symbol': currency['code'],
+        };
+        const response = await this.currenciesGetSSymbol(this.extend(request, params));
+        //
+        //    {
+        //        id: '1',
+        //        currency: {
+        //            symbol: 'BTC',
+        //            name: 'Bitcoin',
+        //            address: '0x8370fbc6ddec1e18b4e41e72ed943e238458487c',
+        //            decimals: '8',
+        //            tradeDecimals: '20',
+        //            fiatSymbol: 'BTC',
+        //            depositEnabled: true,
+        //            withdrawalEnabled: true,
+        //            transferEnabled: true,
+        //            active: true
+        //        }
+        //    }
+        //
+        const data = this.safeDict(response, 'currency', {});
+        return this.parseDepositAddress(data, currency);
+    }
+    parseDepositAddress(depositAddress, currency = undefined) {
+        //
+        //    {
+        //        symbol: 'BTC',
+        //        name: 'Bitcoin',
+        //        address: '0x8370fbc6ddec1e18b4e41e72ed943e238458487c',
+        //        decimals: '8',
+        //        tradeDecimals: '20',
+        //        fiatSymbol: 'BTC',
+        //        depositEnabled: true,
+        //        withdrawalEnabled: true,
+        //        transferEnabled: true,
+        //        active: true
+        //    }
+        //
+        const currencyId = this.safeString(depositAddress, 'symbol');
+        return {
+            'info': depositAddress,
+            'currency': this.safeCurrencyCode(currencyId, currency),
+            'address': this.safeString(depositAddress, 'address'),
+            'tag': undefined,
+            'network': undefined,
+        };
+    }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
+        const paramsToExtract = this.extractParams(path);
+        path = this.implodeParams(path, params);
+        params = this.omit(params, paramsToExtract);
         let url = this.urls['api']['rest'] + '/' + api + '/' + path;
         if (Object.keys(params).length) {
             url += '?' + this.urlencodeWithArrayRepeat(params);

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.43";
+declare const version = "4.2.45";
 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.44';
+const version = '4.2.46';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -17,6 +17,8 @@ interface hitbtc {
     publicGetPublicOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandles(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandlesSymbol(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandlesSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfo(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfoSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesHistoryFunding(params?: {}): Promise<implicitReturnType>;

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

@@ -17,6 +17,8 @@ interface fmfwio {
     publicGetPublicOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandles(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandlesSymbol(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandlesSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfo(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfoSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesHistoryFunding(params?: {}): Promise<implicitReturnType>;

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

@@ -6,6 +6,11 @@ interface Exchange {
     publicGetOrderbookALLQuoteId(params?: {}): Promise<implicitReturnType>;
     publicGetOrderbookBaseIdQuoteId(params?: {}): Promise<implicitReturnType>;
     publicGetTransactionHistoryBaseIdQuoteId(params?: {}): Promise<implicitReturnType>;
+    publicGetNetworkInfo(params?: {}): Promise<implicitReturnType>;
+    publicGetAssetsstatusMultichainALL(params?: {}): Promise<implicitReturnType>;
+    publicGetAssetsstatusMultichainCurrency(params?: {}): Promise<implicitReturnType>;
+    publicGetWithdrawMinimumALL(params?: {}): Promise<implicitReturnType>;
+    publicGetWithdrawMinimumCurrency(params?: {}): Promise<implicitReturnType>;
     publicGetAssetsstatusALL(params?: {}): Promise<implicitReturnType>;
     publicGetAssetsstatusBaseId(params?: {}): Promise<implicitReturnType>;
     publicGetCandlestickBaseIdQuoteIdInterval(params?: {}): Promise<implicitReturnType>;

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/abstract/coinmate.d.ts

@@ -3,6 +3,8 @@ import { Exchange as _Exchange } from '../base/Exchange.js';
 interface Exchange {
     publicGetOrderBook(params?: {}): Promise<implicitReturnType>;
     publicGetTicker(params?: {}): Promise<implicitReturnType>;
+    publicGetTickerAll(params?: {}): Promise<implicitReturnType>;
+    publicGetProducts(params?: {}): Promise<implicitReturnType>;
     publicGetTransactions(params?: {}): Promise<implicitReturnType>;
     publicGetTradingPairs(params?: {}): Promise<implicitReturnType>;
     privatePostBalances(params?: {}): Promise<implicitReturnType>;
@@ -47,6 +49,16 @@ interface Exchange {
     privatePostUnconfirmedEthereumDeposits(params?: {}): Promise<implicitReturnType>;
     privatePostUnconfirmedLitecoinDeposits(params?: {}): Promise<implicitReturnType>;
     privatePostUnconfirmedRippleDeposits(params?: {}): Promise<implicitReturnType>;
+    privatePostCancelAllOpenOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostWithdrawVirtualCurrency(params?: {}): Promise<implicitReturnType>;
+    privatePostVirtualCurrencyDepositAddresses(params?: {}): Promise<implicitReturnType>;
+    privatePostUnconfirmedVirtualCurrencyDeposits(params?: {}): Promise<implicitReturnType>;
+    privatePostAdaWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privatePostAdaDepositAddresses(params?: {}): Promise<implicitReturnType>;
+    privatePostUnconfirmedAdaDeposits(params?: {}): Promise<implicitReturnType>;
+    privatePostSolWithdrawal(params?: {}): Promise<implicitReturnType>;
+    privatePostSolDepositAddresses(params?: {}): Promise<implicitReturnType>;
+    privatePostUnconfirmedSolDeposits(params?: {}): Promise<implicitReturnType>;
 }
 declare abstract class Exchange extends _Exchange {
 }

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

@@ -17,6 +17,8 @@ interface hitbtc {
     publicGetPublicOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandles(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandlesSymbol(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandlesSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfo(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfoSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesHistoryFunding(params?: {}): Promise<implicitReturnType>;

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

@@ -17,6 +17,8 @@ interface Exchange {
     publicGetPublicOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandles(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandlesSymbol(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandlesSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfo(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfoSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesHistoryFunding(params?: {}): Promise<implicitReturnType>;

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

@@ -17,6 +17,8 @@ interface hitbtc {
     publicGetPublicOrderbookSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandles(params?: {}): Promise<implicitReturnType>;
     publicGetPublicCandlesSymbol(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandles(params?: {}): Promise<implicitReturnType>;
+    publicGetPublicConvertedCandlesSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfo(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesInfoSymbol(params?: {}): Promise<implicitReturnType>;
     publicGetPublicFuturesHistoryFunding(params?: {}): Promise<implicitReturnType>;

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

@@ -245,6 +245,7 @@ interface Exchange {
     privatePostAccountQuickMarginBorrowRepay(params?: {}): Promise<implicitReturnType>;
     privatePostAccountBorrowRepay(params?: {}): Promise<implicitReturnType>;
     privatePostAccountSimulatedMargin(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountPositionBuilder(params?: {}): Promise<implicitReturnType>;
     privatePostAccountSetRiskOffsetType(params?: {}): Promise<implicitReturnType>;
     privatePostAccountActivateOption(params?: {}): Promise<implicitReturnType>;
     privatePostAccountSetAutoLoan(params?: {}): Promise<implicitReturnType>;

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

@@ -5,6 +5,8 @@ import WsClient from './ws/WsClient.js';
 import { OrderBook as WsOrderBook, IndexedOrderBook, CountedOrderBook } from './ws/OrderBook.js';
 import type { Market, Trade, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, Balances, Dictionary, Transaction, DepositAddressResponse, Currency, MinMax, IndexType, Int, OrderType, OrderSide, Position, FundingRate, DepositWithdrawFeeNetwork, LedgerEntry, BorrowInterest, OpenInterest, LeverageTier, TransferEntry, FundingRateHistory, Liquidation, FundingHistory, OrderRequest, MarginMode, Tickers, Greeks, Str, Num, MarketInterface, CurrencyInterface, Account } from './types.js';
 export type { Market, Trade, Fee, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, Balances, Dictionary, Transaction, DepositAddressResponse, Currency, MinMax, IndexType, Int, OrderType, OrderSide, Position, FundingRateHistory, Liquidation, FundingHistory, Greeks } from './types.js';
+import { ArrayCache } from './ws/Cache.js';
+import { OrderBook as Ob } from './ws/OrderBook.js';
 /**
  * @class Exchange
  */
@@ -73,14 +75,15 @@ export default class Exchange {
     walletAddress: string;
     token: string;
     balance: {};
-    orderbooks: {};
-    tickers: {};
-    orders: any;
-    triggerOrders: any;
-    trades: any;
+    orderbooks: Dictionary<Ob>;
+    tickers: Dictionary<Ticker>;
+    bidsasks: Dictionary<Ticker>;
+    orders: ArrayCache;
+    triggerOrders: ArrayCache;
+    trades: Dictionary<ArrayCache>;
     transactions: {};
     ohlcvs: any;
-    myTrades: any;
+    myTrades: ArrayCache;
     positions: any;
     urls: {
         logo?: string;
@@ -744,7 +747,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 = {};
@@ -3426,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
@@ -4357,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/base/ws/Cache.d.ts

@@ -1,8 +1,12 @@
+interface CustomArray extends Array {
+    hashmap: object;
+}
 declare class BaseCache extends Array {
     constructor(maxSize?: any);
     clear(): void;
 }
-declare class ArrayCache extends BaseCache {
+declare class ArrayCache extends BaseCache implements CustomArray {
+    hashmap: object;
     constructor(maxSize?: any);
     getLimit(symbol: any, limit: any): any;
     append(item: any): void;

package/js/src/base/ws/Cache.js

@@ -22,6 +22,7 @@ class BaseCache extends Array {
 class ArrayCache extends BaseCache {
     constructor(maxSize = undefined) {
         super(maxSize);
+        this.hashmap = {};
         Object.defineProperty(this, 'nestedNewUpdatesBySymbol', {
             __proto__: null,
             value: false,
@@ -47,6 +48,12 @@ class ArrayCache extends BaseCache {
             value: false,
             writable: true,
         });
+        Object.defineProperty(this, 'hashmap', {
+            __proto__: null,
+            value: {},
+            writable: true,
+            enumerable: false,
+        });
     }
     getLimit(symbol, limit) {
         let newUpdatesValue = undefined;
@@ -126,6 +133,7 @@ class ArrayCacheByTimestamp extends BaseCache {
         if (item[0] in this.hashmap) {
             const reference = this.hashmap[item[0]];
             if (reference !== item) {
+                // eslint-disable-next-line
                 for (const prop in item) {
                     reference[prop] = item[prop];
                 }
@@ -151,11 +159,11 @@ class ArrayCacheBySymbolById extends ArrayCache {
     constructor(maxSize = undefined) {
         super(maxSize);
         this.nestedNewUpdatesBySymbol = true;
-        Object.defineProperty(this, 'hashmap', {
-            __proto__: null,
-            value: {},
-            writable: true,
-        });
+        // Object.defineProperty (this, 'hashmap', {
+        //     __proto__: null, // make it invisible
+        //     value: {},
+        //     writable: true,
+        // })
     }
     append(item) {
         const byId = this.hashmap[item.symbol] = this.hashmap[item.symbol] || {};

package/js/src/base/ws/OrderBook.d.ts

@@ -1,4 +1,8 @@
-declare class OrderBook {
+interface CustomOrderBookProp {
+    cache: any[];
+}
+declare class OrderBook implements CustomOrderBookProp {
+    cache: any[];
     constructor(snapshot?: {}, depth?: any);
     limit(): this;
     update(snapshot: any): this;

package/js/src/base/ws/OrderBook.js

@@ -5,7 +5,7 @@
 // EDIT THE CORRESPONDENT .ts FILE INSTEAD
 
 /* eslint-disable max-classes-per-file */
-// @ts-nocheck 
+// @ts-nocheck
 import { iso8601 } from '../../base/functions/time.js';
 import { extend } from '../../base/functions/generic.js';
 import { Asks, Bids, CountedAsks, CountedBids, IndexedAsks, IndexedBids,
@@ -14,14 +14,14 @@ import { Asks, Bids, CountedAsks, CountedBids, IndexedAsks, IndexedBids,
 // IncrementalIndexedAsks,
 // IncrementalIndexedBids, // check this
  } from './OrderBookSide.js';
-// ----------------------------------------------------------------------------
-// overwrites absolute volumes at price levels
 class OrderBook {
     constructor(snapshot = {}, depth = undefined) {
+        this.cache = []; // make prop visible so we use typed OrderBooks
         Object.defineProperty(this, 'cache', {
             __proto__: null,
             value: [],
             writable: true,
+            enumerable: false,
         });
         depth = depth || Number.MAX_SAFE_INTEGER;
         const defaults = {