ccxt 4.2.85 → 4.2.87

package/dist/cjs/src/okcoin.js

@@ -1133,8 +1133,10 @@ class okcoin extends okcoin$1 {
         const request = {
             'instId': market['id'],
             'bar': bar,
-            'limit': limit,
         };
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100, max 100
+        }
         let method = undefined;
         [method, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'method', 'publicGetMarketCandles');
         let response = undefined;

package/dist/cjs/src/okx.js

@@ -6460,26 +6460,40 @@ class okx extends okx$1 {
         //       "msg": ""
         //     }
         //
-        return this.parseMarginModification(response, market);
+        const data = this.safeList(response, 'data', []);
+        const errorCode = this.safeString(response, 'code');
+        const item = this.safeDict(data, 0, {});
+        return this.extend(this.parseMarginModification(item, market), {
+            'status': (errorCode === '0') ? 'ok' : 'failed',
+        });
     }
     parseMarginModification(data, market = undefined) {
-        const innerData = this.safeValue(data, 'data', []);
-        const entry = this.safeValue(innerData, 0, {});
-        const errorCode = this.safeString(data, 'code');
-        const status = (errorCode === '0') ? 'ok' : 'failed';
-        const amountRaw = this.safeNumber(entry, 'amt');
-        const typeRaw = this.safeString(entry, 'type');
+        //
+        // addMargin/reduceMargin
+        //
+        //    {
+        //        "amt": "0.01",
+        //        "instId": "ETH-USD-SWAP",
+        //        "posSide": "net",
+        //        "type": "reduce"
+        //    }
+        //
+        const amountRaw = this.safeNumber(data, 'amt');
+        const typeRaw = this.safeString(data, 'type');
         const type = (typeRaw === 'reduce') ? 'reduce' : 'add';
-        const marketId = this.safeString(entry, 'instId');
+        const marketId = this.safeString(data, 'instId');
         const responseMarket = this.safeMarket(marketId, market);
         const code = responseMarket['inverse'] ? responseMarket['base'] : responseMarket['quote'];
         return {
             'info': data,
+            'symbol': responseMarket['symbol'],
             'type': type,
             'amount': amountRaw,
+            'total': undefined,
             'code': code,
-            'symbol': responseMarket['symbol'],
-            'status': status,
+            'status': undefined,
+            'timestamp': undefined,
+            'datetime': undefined,
         };
     }
     async reduceMargin(symbol, amount, params = {}) {

package/dist/cjs/src/phemex.js

@@ -4060,12 +4060,14 @@ class phemex extends phemex$1 {
         const codeCurrency = inverse ? 'base' : 'quote';
         return {
             'info': data,
+            'symbol': this.safeSymbol(undefined, market),
             'type': 'set',
             'amount': undefined,
             'total': undefined,
             'code': market[codeCurrency],
-            'symbol': this.safeSymbol(undefined, market),
             'status': this.parseMarginStatus(this.safeString(data, 'code')),
+            'timestamp': undefined,
+            'datetime': undefined,
         };
     }
     async setMarginMode(marginMode, symbol = undefined, params = {}) {

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

@@ -83,6 +83,7 @@ class bitget extends bitget$1 {
                         '30015': errors.AuthenticationError,
                         '30016': errors.BadRequest, // { event: 'error', code: 30016, msg: 'Param error' }
                     },
+                    'broad': {},
                 },
             },
         });

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

@@ -570,17 +570,22 @@ class kucoin extends kucoin$1 {
         const marketId = this.safeString(data, 'symbol', topicSymbol);
         const symbol = this.safeSymbol(marketId, undefined, '-');
         const messageHash = 'orderbook:' + symbol;
-        let orderbook = this.safeDict(this.orderbooks, symbol);
+        // let orderbook = this.safeDict (this.orderbooks, symbol);
         if (subject === 'level2') {
-            if (orderbook === undefined) {
-                orderbook = this.orderBook();
+            if (!(symbol in this.orderbooks)) {
+                this.orderbooks[symbol] = this.orderBook();
             }
             else {
+                const orderbook = this.orderbooks[symbol];
                 orderbook.reset();
             }
-            orderbook['symbol'] = symbol;
+            this.orderbooks[symbol]['symbol'] = symbol;
         }
         else {
+            if (!(symbol in this.orderbooks)) {
+                this.orderbooks[symbol] = this.orderBook();
+            }
+            const orderbook = this.orderbooks[symbol];
             const nonce = this.safeInteger(orderbook, 'nonce');
             const deltaEnd = this.safeInteger2(data, 'sequenceEnd', 'timestamp');
             if (nonce === undefined) {
@@ -606,8 +611,8 @@ class kucoin extends kucoin$1 {
                 return;
             }
         }
-        this.handleDelta(orderbook, data);
-        client.resolve(orderbook, messageHash);
+        this.handleDelta(this.orderbooks[symbol], data);
+        client.resolve(this.orderbooks[symbol], messageHash);
     }
     getCacheIndex(orderbook, cache) {
         const firstDelta = this.safeValue(cache, 0);

package/dist/cjs/src/wazirx.js

@@ -319,7 +319,7 @@ class wazirx extends wazirx$1 {
             'interval': this.safeString(this.timeframes, timeframe, timeframe),
         };
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 2000);
         }
         const until = this.safeInteger(params, 'until');
         params = this.omit(params, ['until']);

package/dist/cjs/src/zonda.js

@@ -1201,6 +1201,9 @@ class zonda extends zonda$1 {
         if (limit === undefined) {
             limit = 100;
         }
+        else {
+            limit = Math.min(limit, 11000); // supports up to 11k candles diapason
+        }
         const duration = this.parseTimeframe(timeframe);
         const timerange = limit * duration * 1000;
         if (since === undefined) {

package/examples/js/benchmark.js

@@ -0,0 +1,104 @@
+import { spawn } from 'child_process';
+import asTable from 'as-table';
+import ccxt, { version } from '../../js/ccxt.js';
+const stats = (times) => {
+    // calculate statistics
+    const sum = times.reduce((a, b) => a + b, 0);
+    const avg = Math.round(sum / times.length);
+    const min = Math.min(...times);
+    const max = Math.max(...times);
+    times.sort((a, b) => a - b);
+    const median = times.length % 2 === 0 ? (times[times.length / 2 - 1] + times[times.length / 2]) / 2 : times[Math.floor(times.length / 2)];
+    return { min, 'average': avg, max, median, 'iterations': times.length };
+};
+async function benchmark(exchangeId, method, args, verbose = false, minIterations = 10, argsv = '') {
+    const exchange = new ccxt.pro[exchangeId]({});
+    const languages = ['js', 'py', 'php', 'cs'];
+    const commands = languages.map((language) => ({
+        'language': language,
+        'method': method,
+        'command': `npm run cli.${language} ${exchangeId} ${method} ${args.join(' ')} -- ${argsv} --poll`,
+    }));
+    const wsMethod = method + 'Ws';
+    if (exchange.has[wsMethod]) {
+        const wsCommands = languages.map((language) => ({
+            'language': language,
+            'method': wsMethod,
+            'command': `npm run cli.${language} ${exchangeId} ${wsMethod} ${args.join(' ')} -- ${argsv} --poll`,
+        }));
+        commands.push(...wsCommands);
+    }
+    const regex = /iteration (\d+) passed in (\d+) ms/g;
+    async function runCommand(command) {
+        if (verbose) {
+            console.log(exchange.iso8601(new Date().getTime()), ' running command:', command);
+        }
+        return new Promise((resolve, reject) => {
+            const [cmd, ...args] = command.split(' ');
+            const child = spawn(cmd, args);
+            const matches = [];
+            const language = command.slice(8, 15);
+            child.stdout.on('data', (data) => {
+                const message = data.toString();
+                matches.push(...Array.from(message.matchAll(regex)));
+                const match = matches[matches.length - 1];
+                if (match && match[1] && match[2]) {
+                    const iteration = parseInt(match[1]);
+                    const time = parseInt(match[2]);
+                    if (iteration <= minIterations) {
+                        if (verbose) {
+                            console.log(exchange.iso8601(new Date().getTime()), `${language} iteration ${iteration} passed in ${time} ms`);
+                        }
+                    }
+                    else {
+                        const times = matches.map((m) => parseInt(m[2]));
+                        child.kill();
+                        if (verbose) {
+                            console.log(exchange.iso8601(new Date().getTime()), `killed process - ${language} iteration ${iteration} passed in ${time} ms`);
+                        }
+                        resolve({ times });
+                    }
+                }
+            });
+            child.stderr.on('data', (data) => {
+                const message = data.toString();
+                console.error(exchange.iso8601(new Date().getTime()), `command ${command} failed. stderr: ${message}`);
+                const times = matches.map((m) => parseInt(m[2]));
+                resolve({ times });
+            });
+            child.on('close', (code) => {
+                const times = matches.map((m) => parseInt(m[2]));
+                resolve({ times });
+                console.log(exchange.iso8601(new Date().getTime()), `${language} child process exited with code ${code}`);
+            });
+            child.on('error', (err) => {
+                console.error(exchange.iso8601(new Date().getTime()), `command ${command} failed. error: ${err}`);
+                reject(err);
+            });
+        });
+    }
+    const benchmarks = [];
+    const results = await Promise.all(commands.map((c) => runCommand(c.command)));
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        benchmarks.push({ 'language': commands[i].language, 'method': commands[i].method, ...stats(result.times) });
+    }
+    if (verbose) {
+        const rawResults = results.map((r, i) => ({ 'language': commands[i].language, 'method': commands[i].method, ...stats(r.times), 'times': r.times }));
+        console.log(rawResults);
+    }
+    console.log(asTable(benchmarks));
+}
+const [_, , exchangeId, methodName, ...params] = process.argv.filter((x) => !x.startsWith('--'));
+const verbose = process.argv.includes('--verbose');
+const minIterationsString = process.argv.find((x) => x.startsWith('--min-iterations='))?.slice(18);
+const minIterations = minIterationsString ? parseInt(minIterationsString) : 10;
+const argsv = process.argv.filter((x) => x.startsWith('--') && !x.startsWith('--min-iterations')).join(' ');
+console.log((new Date()).toISOString());
+console.log('Node.js:', process.version);
+console.log('CCXT v' + version);
+const start = new Date().getTime();
+await benchmark(exchangeId, methodName, params, verbose, minIterations, argsv);
+const end = new Date().getTime();
+console.log((new Date().toISOString()), 'Total time:', end - start, 'ms');
+process.exit(0);

package/examples/ts/benchmark.ts

@@ -0,0 +1,134 @@
+import { spawn } from 'child_process';
+import asTable from 'as-table';
+import ccxt, { version } from '../../js/ccxt.js';
+
+interface Stats {
+    min: number;
+    average: number;
+    max: number;
+    median: number;
+    iterations: number;
+}
+
+interface Test {
+    language: string;
+    method: string;
+    command: string;
+}
+
+interface Benchmark extends Omit<Test, 'command'>, Stats { }
+
+const stats = (times: number[]): Stats => {
+    // calculate statistics
+    const sum = times.reduce ((a, b) => a + b, 0);
+    const avg = Math.round (sum / times.length);
+    const min = Math.min (...times);
+    const max = Math.max (...times);
+    times.sort ((a, b) => a - b);
+    const median = times.length % 2 === 0 ? (times[times.length / 2 - 1] + times[times.length / 2]) / 2 : times[Math.floor (times.length / 2)];
+    return { min, 'average': avg, max, median, 'iterations': times.length };
+};
+
+async function benchmark (exchangeId, method, args, verbose = false, minIterations = 10, argsv = '') {
+    const exchange = new ccxt.pro[exchangeId] ({});
+    const languages = [ 'js', 'py', 'php', 'cs' ];
+    const commands: Test[] = languages.map ((language) => ({
+        'language': language,
+        'method': method,
+        'command': `npm run cli.${language} ${exchangeId} ${method} ${args.join (' ')} -- ${argsv} --poll`,
+    }));
+    const wsMethod = method + 'Ws';
+    if (exchange.has[wsMethod]) {
+        const wsCommands: Test[] = languages.map ((language) => ({
+            'language': language,
+            'method': wsMethod,
+            'command': `npm run cli.${language} ${exchangeId} ${wsMethod} ${args.join (' ')} -- ${argsv} --poll`,
+        }));
+        commands.push (...wsCommands);
+    }
+    const regex = /iteration (\d+) passed in (\d+) ms/g;
+
+    async function runCommand (command: string) {
+        if (verbose) {
+            console.log (exchange.iso8601 (new Date ().getTime ()), ' running command:', command);
+        }
+        return new Promise<{ times: number[] }> ((resolve, reject) => {
+            const [ cmd, ...args ] = command.split (' ');
+
+            const child = spawn (cmd, args);
+            const matches = [];
+            const language = command.slice (8, 15);
+            child.stdout.on ('data', (data: Buffer) => {
+                const message = data.toString ();
+                matches.push (...Array.from (message.matchAll (regex)));
+                const match = matches[matches.length - 1];
+
+                if (match && match[1] && match[2]) {
+                    const iteration = parseInt (match[1]);
+                    const time = parseInt (match[2]);
+
+                    if (iteration <= minIterations) {
+                        if (verbose) {
+                            console.log (exchange.iso8601 (new Date ().getTime ()), `${language} iteration ${iteration} passed in ${time} ms`);
+                        }
+                    } else {
+                        const times = matches.map ((m) => parseInt (m[2]));
+                        child.kill ();
+                        if (verbose) {
+                            console.log (exchange.iso8601 (new Date ().getTime ()), `killed process - ${language} iteration ${iteration} passed in ${time} ms`);
+                        }
+                        resolve ({ times });
+                    }
+                }
+            });
+
+            child.stderr.on ('data', (data: Buffer) => {
+                const message = data.toString ();
+                console.error (exchange.iso8601 (new Date ().getTime ()), `command ${command} failed. stderr: ${message}`);
+                const times = matches.map ((m) => parseInt (m[2]));
+                resolve ({ times });
+            });
+
+            child.on ('close', (code: number) => {
+                const times = matches.map ((m) => parseInt (m[2]));
+                resolve ({ times });
+                console.log (exchange.iso8601 (new Date ().getTime ()), `${language} child process exited with code ${code}`);
+            });
+
+            child.on ('error', (err) => {
+                console.error (exchange.iso8601 (new Date ().getTime ()), `command ${command} failed. error: ${err}`);
+                reject (err);
+            });
+        });
+    }
+
+    const benchmarks: Benchmark[] = [];
+    const results = await Promise.all (commands.map ((c) => runCommand (c.command)));
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        benchmarks.push ({ 'language': commands[i].language, 'method': commands[i].method, ...stats (result.times) });
+    }
+    if (verbose) {
+        const rawResults = results.map ((r, i) => ({ 'language': commands[i].language, 'method': commands[i].method, ...stats (r.times), 'times': r.times }));
+        console.log (rawResults);
+    }
+    console.log (asTable (benchmarks));
+}
+
+const [ _, , exchangeId, methodName, ...params ] = process.argv.filter ((x) => !x.startsWith ('--'));
+const verbose = process.argv.includes ('--verbose');
+const minIterationsString = process.argv.find ((x) => x.startsWith ('--min-iterations='))?.slice (18);
+const minIterations = minIterationsString ? parseInt (minIterationsString) : 10;
+const argsv = process.argv.filter ((x) => x.startsWith ('--') && !x.startsWith ('--min-iterations')).join (' ');
+
+
+console.log ((new Date ()).toISOString ());
+console.log ('Node.js:', process.version);
+console.log ('CCXT v' + version);
+
+const start = new Date ().getTime ();
+await benchmark (exchangeId, methodName, params, verbose, minIterations, argsv);
+const end = new Date ().getTime ();
+
+console.log ((new Date ().toISOString ()), 'Total time:', end - start, 'ms');
+process.exit (0);

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, Leverage, Leverages, Option, OptionChain } 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.84";
+declare const version = "4.2.86";
 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.85';
+const version = '4.2.87';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';