ccxt 4.1.74 → 4.1.75

package/js/src/kraken.d.ts

@@ -79,11 +79,13 @@ export default class kraken extends Exchange {
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     parseTransactionStatus(status: any): string;
+    parseNetwork(network: any): string;
     parseTransaction(transaction: any, currency?: Currency): Transaction;
     parseTransactionsByType(type: any, transactions: any, code?: Str, since?: Int, limit?: Int): any;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     fetchTime(params?: {}): Promise<number>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    addPaginationCursorToResult(result: any): any;
     createDepositAddress(code: string, params?: {}): Promise<{
         currency: string;
         address: string;

package/js/src/kraken.js

@@ -328,6 +328,91 @@ export default class kraken extends Exchange {
                     'ZEC': 'Zcash (Transparent)',
                     'ZRX': '0x (ZRX)',
                 },
+                'withdrawMethods': {
+                    'Lightning': 'Lightning',
+                    'Bitcoin': 'BTC',
+                    'Ripple': 'XRP',
+                    'Litecoin': 'LTC',
+                    'Dogecoin': 'DOGE',
+                    'Stellar': 'XLM',
+                    'Ethereum': 'ERC20',
+                    'Arbitrum One': 'Arbitrum',
+                    'Polygon': 'MATIC',
+                    'Arbitrum Nova': 'Arbitrum',
+                    'Optimism': 'Optimism',
+                    'zkSync Era': 'zkSync',
+                    'Ethereum Classic': 'ETC',
+                    'Zcash': 'ZEC',
+                    'Monero': 'XMR',
+                    'Tron': 'TRC20',
+                    'Solana': 'SOL',
+                    'EOS': 'EOS',
+                    'Bitcoin Cash': 'BCH',
+                    'Cardano': 'ADA',
+                    'Qtum': 'QTUM',
+                    'Tezos': 'XTZ',
+                    'Cosmos': 'ATOM',
+                    'Nano': 'NANO',
+                    'Siacoin': 'SC',
+                    'Lisk': 'LSK',
+                    'Waves': 'WAVES',
+                    'ICON': 'ICX',
+                    'Algorand': 'ALGO',
+                    'Polygon - USDC.e': 'MATIC',
+                    'Arbitrum One - USDC.e': 'Arbitrum',
+                    'Polkadot': 'DOT',
+                    'Kava': 'KAVA',
+                    'Filecoin': 'FIL',
+                    'Kusama': 'KSM',
+                    'Flow': 'FLOW',
+                    'Energy Web': 'EW',
+                    'Mina': 'MINA',
+                    'Centrifuge': 'CFG',
+                    'Karura': 'KAR',
+                    'Moonriver': 'MOVR',
+                    'Shiden': 'SDN',
+                    'Khala': 'PHA',
+                    'Bifrost Kusama': 'BNC',
+                    'Songbird': 'SGB',
+                    'Terra classic': 'LUNC',
+                    'KILT': 'KILT',
+                    'Basilisk': 'BSX',
+                    'Flare': 'FLR',
+                    'Avalanche C-Chain': 'AVAX',
+                    'Kintsugi': 'KINT',
+                    'Altair': 'AIR',
+                    'Moonbeam': 'GLMR',
+                    'Acala': 'ACA',
+                    'Astar': 'ASTR',
+                    'Akash': 'AKT',
+                    'Robonomics': 'XRT',
+                    'Fantom': 'FTM',
+                    'Elrond': 'EGLD',
+                    'THORchain': 'RUNE',
+                    'Secret': 'SCRT',
+                    'Near': 'NEAR',
+                    'Internet Computer Protocol': 'ICP',
+                    'Picasso': 'PICA',
+                    'Crust Shadow': 'CSM',
+                    'Integritee': 'TEER',
+                    'Parallel Finance': 'PARA',
+                    'HydraDX': 'HDX',
+                    'Interlay': 'INTR',
+                    'Fetch.ai': 'FET',
+                    'NYM': 'NYM',
+                    'Terra 2.0': 'LUNA2',
+                    'Juno': 'JUNO',
+                    'Nodle': 'NODL',
+                    'Stacks': 'STX',
+                    'Ethereum PoW': 'ETHW',
+                    'Aptos': 'APT',
+                    'Sui': 'SUI',
+                    'Genshiro': 'GENS',
+                    'Aventus': 'AVT',
+                    'Sei': 'SEI',
+                    'OriginTrail': 'OTP',
+                    'Celestia': 'TIA',
+                },
             },
             'precisionMode': TICK_SIZE,
             'exceptions': {
@@ -2074,6 +2159,10 @@ export default class kraken extends Exchange {
         };
         return this.safeString(statuses, status, status);
     }
+    parseNetwork(network) {
+        const withdrawMethods = this.safeValue(this.options, 'withdrawMethods', {});
+        return this.safeString(withdrawMethods, network, network);
+    }
     parseTransaction(transaction, currency = undefined) {
         //
         // fetchDeposits
@@ -2124,6 +2213,8 @@ export default class kraken extends Exchange {
         //         "fee": "0.0050000000",
         //         "time":  1530481750,
         //         "status": "Success"
+        //         "key":"Huobi wallet",
+        //         "network":"Tron"
         //         status-prop: 'on-hold' // this field might not be present in some cases
         //     }
         //
@@ -2160,7 +2251,7 @@ export default class kraken extends Exchange {
             'id': id,
             'currency': code,
             'amount': amount,
-            'network': undefined,
+            'network': this.parseNetwork(this.safeString(transaction, 'network')),
             'address': address,
             'addressTo': undefined,
             'addressFrom': undefined,
@@ -2264,19 +2355,28 @@ export default class kraken extends Exchange {
          * @param {int} [since] the earliest time in ms to fetch withdrawals for
          * @param {int} [limit] the maximum number of withdrawals structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {object} [params.end] End timestamp, withdrawals created strictly after will be not be included in the response
+         * @param {boolean} [params.paginate]  default false, when true will automatically paginate by calling this endpoint multiple times
          * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
-         */
-        // https://www.kraken.com/en-us/help/api#withdraw-status
-        if (code === undefined) {
-            throw new ArgumentsRequired(this.id + ' fetchWithdrawals() requires a currency code argument');
-        }
+        */
         await this.loadMarkets();
-        const currency = this.currency(code);
-        const request = {
-            'asset': currency['id'],
-        };
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchWithdrawals', 'paginate');
+        if (paginate) {
+            params['cursor'] = true;
+            return await this.fetchPaginatedCallCursor('fetchWithdrawals', code, since, limit, params, 'next_cursor', 'cursor');
+        }
+        const request = {};
+        if (code !== undefined) {
+            const currency = this.currency(code);
+            request['asset'] = currency['id'];
+        }
+        if (since !== undefined) {
+            request['since'] = since.toString();
+        }
         const response = await this.privatePostWithdrawStatus(this.extend(request, params));
         //
+        // with no pagination
         //     {  error: [],
         //       "result": [ { "method": "Ether",
         //                     "aclass": "currency",
@@ -2288,8 +2388,51 @@ export default class kraken extends Exchange {
         //                        "fee": "0.0050000000",
         //                       "time":  1530481750,
         //                     "status": "Success"                                                             } ] }
+        // with pagination
+        //    {
+        //        "error":[],
+        //        "result":{
+        //           "withdrawals":[
+        //              {
+        //                 "method":"Tether USD (TRC20)",
+        //                 "aclass":"currency",
+        //                 "asset":"USDT",
+        //                 "refid":"BSNFZU2-MEFN4G-J3NEZV",
+        //                 "txid":"1c7a642fb7387bbc2c6a2c509fd1ae146937f4cf793b4079a4f0715e3a02615a",
+        //                 "info":"TQmdxSuC16EhFg8FZWtYgrfFRosoRF7bCp",
+        //                 "amount":"1996.50000000",
+        //                 "fee":"2.50000000",
+        //                 "time":1669126657,
+        //                 "status":"Success",
+        //                 "key":"poloniex",
+        //                 "network":"Tron"
+        //              },
+        //             ...
+        //           ],
+        //           "next_cursor":"HgAAAAAAAABGVFRSd3k1LVF4Y0JQY05Gd0xRY0NxenFndHpybkwBAQH2AwEBAAAAAQAAAAAAAAABAAAAAAAZAAAAAAAAAA=="
+        //        }
+        //     }
         //
-        return this.parseTransactionsByType('withdrawal', response['result'], code, since, limit);
+        let rawWithdrawals = undefined;
+        const result = this.safeValue(response, 'result');
+        if (!Array.isArray(result)) {
+            rawWithdrawals = this.addPaginationCursorToResult(result);
+        }
+        else {
+            rawWithdrawals = result;
+        }
+        return this.parseTransactionsByType('withdrawal', rawWithdrawals, code, since, limit);
+    }
+    addPaginationCursorToResult(result) {
+        const cursor = this.safeString(result, 'next_cursor');
+        const data = this.safeValue(result, 'withdrawals');
+        const dataLength = data.length;
+        if (cursor !== undefined && dataLength > 0) {
+            const last = data[dataLength - 1];
+            last['next_cursor'] = cursor;
+            data[dataLength - 1] = last;
+        }
+        return data;
     }
     async createDepositAddress(code, params = {}) {
         /**

package/js/src/poloniex.js

@@ -755,32 +755,34 @@ export default class poloniex extends Exchange {
             let withdrawAvailable = this.safeValue(result[code], 'withdraw');
             withdrawAvailable = (withdrawEnabled) ? withdrawEnabled : withdrawAvailable;
             const networks = this.safeValue(result[code], 'networks', {});
-            networks[networkCode] = {
-                'info': currency,
-                'id': networkId,
-                'network': networkCode,
-                'currencyId': id,
-                'numericId': numericId,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'active': active,
-                'fee': this.parseNumber(feeString),
-                'precision': undefined,
-                'limits': {
-                    'amount': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'withdraw': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'deposit': {
-                        'min': undefined,
-                        'max': undefined,
+            if (networkCode !== undefined) {
+                networks[networkCode] = {
+                    'info': currency,
+                    'id': networkId,
+                    'network': networkCode,
+                    'currencyId': id,
+                    'numericId': numericId,
+                    'deposit': depositEnabled,
+                    'withdraw': withdrawEnabled,
+                    'active': active,
+                    'fee': this.parseNumber(feeString),
+                    'precision': undefined,
+                    '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', []);
             const rawInfo = {};

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

@@ -68,6 +68,7 @@ export default class binance extends binanceRest {
     fetchOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrdersForSymbols(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
     handleOrderUpdate(client: Client, message: any): void;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;

package/js/src/pro/binance.js

@@ -7,7 +7,7 @@
 // ----------------------------------------------------------------------------
 import binanceRest from '../binance.js';
 import { Precise } from '../base/Precise.js';
-import { ExchangeError, ArgumentsRequired, BadRequest } from '../base/errors.js';
+import { ExchangeError, ArgumentsRequired, BadRequest, NotSupported } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 import { rsa } from '../base/functions/rsa.js';
@@ -26,6 +26,7 @@ export default class binance extends binanceRest {
                 'watchOrderBook': true,
                 'watchOrderBookForSymbols': true,
                 'watchOrders': true,
+                'watchOrdersForSymbols': true,
                 'watchPositions': true,
                 'watchTicker': true,
                 'watchTickers': true,
@@ -2065,6 +2066,7 @@ export default class binance extends binanceRest {
         /**
          * @method
          * @name binance#watchOrders
+         * @see https://binance-docs.github.io/apidocs/spot/en/#payload-order-update
          * @description watches information on multiple orders made by the user
          * @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
@@ -2078,7 +2080,7 @@ export default class binance extends binanceRest {
         if (symbol !== undefined) {
             market = this.market(symbol);
             symbol = market['symbol'];
-            messageHash += ':' + symbol;
+            messageHash += '::' + symbol;
         }
         let type = undefined;
         [type, params] = this.handleMarketTypeAndParams('watchOrders', market, params);
@@ -2101,11 +2103,63 @@ export default class binance extends binanceRest {
         this.setBalanceCache(client, type);
         this.setPositionsCache(client, type);
         const message = undefined;
-        const orders = await this.watch(url, messageHash, message, type);
+        const newOrder = await this.watch(url, messageHash, message, type);
         if (this.newUpdates) {
-            limit = orders.getLimit(symbol, limit);
+            return newOrder;
         }
-        return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
+        return this.filterBySymbolSinceLimit(this.orders, symbol, since, limit, true);
+    }
+    async watchOrdersForSymbols(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name binance#watchOrdersForSymbols
+         * @see https://binance-docs.github.io/apidocs/spot/en/#payload-order-update
+         * @description watches information on multiple orders made by the user
+         * @param {string[]} symbols unified symbol of the market to fetch orders for
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of trade structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('authenticate', params);
+        const isIsolatedMargin = (marginMode === 'isolated');
+        if (isIsolatedMargin) {
+            throw new NotSupported(this.id + ' watchOrdersForSymbols does not support isolated margin markets, use watchOrders instead');
+        }
+        await this.loadMarkets();
+        let type = undefined;
+        const market = this.getMarketFromSymbols(symbols);
+        [type, params] = this.handleMarketTypeAndParams('watchOrdersForSymbols', market, params);
+        symbols = this.marketSymbols(symbols, type, true, true, true);
+        let messageHash = 'orders';
+        if (symbols !== undefined) {
+            messageHash = messageHash + '::' + symbols.join(',');
+        }
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('watchOrdersForSymbols', market, params);
+        if (this.isLinear(type, subType)) {
+            type = 'future';
+        }
+        else if (this.isInverse(type, subType)) {
+            type = 'delivery';
+        }
+        params = this.extend(params, { 'type': type });
+        await this.authenticate(params);
+        let urlType = type;
+        if (type === 'margin') {
+            urlType = 'spot'; // spot-margin shares the same stream as regular spot
+        }
+        const url = this.urls['api']['ws'][urlType] + '/' + this.options[type]['listenKey'];
+        const client = this.client(url);
+        this.setBalanceCache(client, type);
+        this.setPositionsCache(client, type);
+        const message = undefined;
+        const newOrders = await this.watch(url, messageHash, message, type);
+        if (this.newUpdates) {
+            return newOrders;
+        }
+        return this.filterBySymbolsSinceLimit(this.orders, symbols, since, limit, true);
     }
     parseWsOrder(order, market = undefined) {
         //
@@ -2736,7 +2790,6 @@ export default class binance extends binanceRest {
         }
     }
     handleOrder(client, message) {
-        const messageHash = 'orders';
         const parsed = this.parseWsOrder(message);
         const symbol = this.safeString(parsed, 'symbol');
         const orderId = this.safeString(parsed, 'id');
@@ -2765,9 +2818,8 @@ export default class binance extends binanceRest {
                 }
             }
             cachedOrders.append(parsed);
-            client.resolve(this.orders, messageHash);
-            const messageHashSymbol = messageHash + ':' + symbol;
-            client.resolve(this.orders, messageHashSymbol);
+            this.resolvePromiseIfMessagehashMatches(client, 'orders::', symbol, parsed);
+            client.resolve(parsed, 'orders');
         }
     }
     handleAcountUpdate(client, message) {

package/js/src/pro/coinbasepro.js

@@ -251,8 +251,8 @@ export default class coinbasepro extends coinbaseproRest {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
-        symbols = this.marketSymbols(symbols, undefined, false);
         await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
         const name = 'user';
         const messageHash = 'multipleOrders::';
         const authentication = this.authenticate();

package/package.json

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