ccxt 4.2.86 → 4.2.87

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/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.85";
+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.86';
+const version = '4.2.87';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/ascendex.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/ascendex.js';
-import type { TransferEntry, FundingHistory, Int, OHLCV, Order, OrderSide, OrderType, OrderRequest, Str, Trade, Balances, Transaction, Ticker, OrderBook, Tickers, Strings, Num, Currency, Market, Leverage, Leverages, Account, MarginModes, MarginMode } from './base/types.js';
+import type { TransferEntry, FundingHistory, Int, OHLCV, Order, OrderSide, OrderType, OrderRequest, Str, Trade, Balances, Transaction, Ticker, OrderBook, Tickers, Strings, Num, Currency, Market, Leverage, Leverages, Account, MarginModes, MarginMode, MarginModification } from './base/types.js';
 /**
  * @class ascendex
  * @augments Exchange
@@ -70,17 +70,10 @@ export default class ascendex extends Exchange {
         fundingDatetime: string;
     };
     fetchFundingRates(symbols?: Strings, params?: {}): Promise<any>;
-    modifyMarginHelper(symbol: string, amount: any, type: any, params?: {}): Promise<any>;
-    parseMarginModification(data: any, market?: Market): {
-        info: any;
-        type: any;
-        amount: any;
-        code: string;
-        symbol: string;
-        status: string;
-    };
-    reduceMargin(symbol: string, amount: any, params?: {}): Promise<any>;
-    addMargin(symbol: string, amount: any, params?: {}): Promise<any>;
+    modifyMarginHelper(symbol: string, amount: any, type: any, params?: {}): Promise<MarginModification>;
+    parseMarginModification(data: any, market?: Market): MarginModification;
+    reduceMargin(symbol: string, amount: any, params?: {}): Promise<MarginModification>;
+    addMargin(symbol: string, amount: any, params?: {}): Promise<MarginModification>;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
     setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<any>;
     fetchLeverageTiers(symbols?: Strings, params?: {}): Promise<{}>;

package/js/src/ascendex.js

@@ -2876,15 +2876,25 @@ export default class ascendex extends Exchange {
         });
     }
     parseMarginModification(data, market = undefined) {
+        //
+        // addMargin/reduceMargin
+        //
+        //     {
+        //          "code": 0
+        //     }
+        //
         const errorCode = this.safeString(data, 'code');
         const status = (errorCode === '0') ? 'ok' : 'failed';
         return {
             'info': data,
+            'symbol': market['symbol'],
             'type': undefined,
             'amount': undefined,
+            'total': undefined,
             'code': market['quote'],
-            'symbol': market['symbol'],
             'status': status,
+            'timestamp': undefined,
+            'datetime': undefined,
         };
     }
     async reduceMargin(symbol, amount, params = {}) {

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

@@ -3,7 +3,7 @@ import { // eslint-disable-line object-curly-newline
 ExchangeError, AuthenticationError, DDoSProtection, RequestTimeout, ExchangeNotAvailable, RateLimitExceeded } from "./errors.js";
 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, Option, OptionChain, Str, Num, MarketInterface, CurrencyInterface, BalanceAccount, MarginModes, MarketType, Leverage, Leverages, LastPrice, LastPrices, Account, Strings } from './types.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, Option, OptionChain, Str, Num, MarketInterface, CurrencyInterface, BalanceAccount, MarginModes, MarketType, Leverage, Leverages, LastPrice, LastPrices, Account, Strings, MarginModification } 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, LedgerEntry, BorrowInterest, OpenInterest, LeverageTier, TransferEntry, BorrowRate, FundingRateHistory, Liquidation, FundingHistory, OrderRequest, MarginMode, Tickers, Greeks, Option, OptionChain, Str, Num, MarketInterface, CurrencyInterface, BalanceAccount, MarginModes, MarketType, Leverage, Leverages, LastPrice, LastPrices, Account, Strings } from './types.js';
 import { ArrayCache, ArrayCacheByTimestamp } from './ws/Cache.js';
 import { OrderBook as Ob } from './ws/OrderBook.js';
@@ -678,7 +678,7 @@ export default class Exchange {
     fetchCrossBorrowRates(params?: {}): Promise<{}>;
     fetchIsolatedBorrowRates(params?: {}): Promise<{}>;
     parseMarketLeverageTiers(info: any, market?: Market): object;
-    fetchLeverageTiers(symbols?: string[], params?: {}): Promise<Dictionary<LeverageTier>>;
+    fetchLeverageTiers(symbols?: string[], params?: {}): Promise<Dictionary<LeverageTier[]>>;
     parsePosition(position: any, market?: Market): Position;
     parseFundingRateHistory(info: any, market?: Market): FundingRateHistory;
     parseBorrowInterest(info: any, market?: Market): BorrowInterest;
@@ -697,8 +697,8 @@ export default class Exchange {
     fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;
     fetchLeverages(symbols?: string[], params?: {}): Promise<Leverages>;
     setPositionMode(hedged: boolean, symbol?: Str, params?: {}): Promise<{}>;
-    addMargin(symbol: string, amount: number, params?: {}): Promise<{}>;
-    reduceMargin(symbol: string, amount: number, params?: {}): Promise<{}>;
+    addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
+    reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
     setMargin(symbol: string, amount: number, params?: {}): Promise<{}>;
     setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<{}>;
     fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;

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

@@ -432,6 +432,17 @@ export interface Leverage {
     longLeverage: number;
     shortLeverage: number;
 }
+export interface MarginModification {
+    'info': any;
+    'symbol': string;
+    'type': 'add' | 'reduce' | 'set' | undefined;
+    'amount': Num;
+    'total': Num;
+    'code': Str;
+    'status': Str;
+    'timestamp': Int;
+    'datetime': Str;
+}
 export interface Leverages extends Dictionary<Leverage> {
 }
 export interface LastPrices extends Dictionary<LastPrice> {

package/js/src/binance.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/binance.js';
-import type { TransferEntry, Int, OrderSide, Balances, OrderType, Trade, OHLCV, Order, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, Str, Transaction, Ticker, OrderBook, Tickers, Market, Greeks, Strings, Currency, MarketInterface, MarginMode, MarginModes, Leverage, Leverages, Num, Option } from './base/types.js';
+import type { TransferEntry, Int, OrderSide, Balances, OrderType, Trade, OHLCV, Order, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, Str, Transaction, Ticker, OrderBook, Tickers, Market, Greeks, Strings, Currency, MarketInterface, MarginMode, MarginModes, Leverage, Leverages, Num, Option, MarginModification } from './base/types.js';
 /**
  * @class binance
  * @augments Exchange
@@ -306,16 +306,9 @@ export default class binance extends Exchange {
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
     request(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;
     modifyMarginHelper(symbol: string, amount: any, addOrReduce: any, params?: {}): Promise<any>;
-    parseMarginModification(data: any, market?: Market): {
-        info: any;
-        type: string;
-        amount: number;
-        code: any;
-        symbol: string;
-        status: string;
-    };
-    reduceMargin(symbol: string, amount: any, params?: {}): Promise<any>;
-    addMargin(symbol: string, amount: any, params?: {}): Promise<any>;
+    parseMarginModification(data: any, market?: Market): MarginModification;
+    reduceMargin(symbol: string, amount: any, params?: {}): Promise<MarginModification>;
+    addMargin(symbol: string, amount: any, params?: {}): Promise<MarginModification>;
     fetchCrossBorrowRate(code: string, params?: {}): Promise<{
         currency: string;
         rate: number;

package/js/src/binance.js

@@ -11215,6 +11215,16 @@ export default class binance extends Exchange {
         });
     }
     parseMarginModification(data, market = undefined) {
+        //
+        // add/reduce margin
+        //
+        //     {
+        //         "code": 200,
+        //         "msg": "Successfully modify position margin.",
+        //         "amount": 0.001,
+        //         "type": 1
+        //     }
+        //
         const rawType = this.safeInteger(data, 'type');
         const resultType = (rawType === 1) ? 'add' : 'reduce';
         const resultAmount = this.safeNumber(data, 'amount');
@@ -11222,11 +11232,14 @@ export default class binance extends Exchange {
         const status = (errorCode === '200') ? 'ok' : 'failed';
         return {
             'info': data,
+            'symbol': market['symbol'],
             'type': resultType,
             'amount': resultAmount,
+            'total': undefined,
             'code': undefined,
-            'symbol': market['symbol'],
             'status': status,
+            'timestamp': undefined,
+            'datetime': undefined,
         };
     }
     async reduceMargin(symbol, amount, params = {}) {

package/js/src/bingx.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/bingx.js';
-import type { TransferEntry, Int, OrderSide, OHLCV, FundingRateHistory, Order, OrderType, OrderRequest, Str, Trade, Balances, Transaction, Ticker, OrderBook, Tickers, Market, Strings, Currency, Position, Dict, Leverage, MarginMode, Num } from './base/types.js';
+import type { TransferEntry, Int, OrderSide, OHLCV, FundingRateHistory, Order, OrderType, OrderRequest, Str, Trade, Balances, Transaction, Ticker, OrderBook, Tickers, Market, Strings, Currency, Position, Dict, Leverage, MarginMode, Num, MarginModification } from './base/types.js';
 /**
  * @class bingx
  * @augments Exchange
@@ -109,7 +109,10 @@ export default class bingx extends Exchange {
     parseTransaction(transaction: any, currency?: Currency): Transaction;
     parseTransactionStatus(status: string): string;
     setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<any>;
-    setMargin(symbol: string, amount: number, params?: {}): Promise<any>;
+    addMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
+    reduceMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
+    setMargin(symbol: string, amount: number, params?: {}): Promise<MarginModification>;
+    parseMarginModification(data: any, market?: Market): MarginModification;
     fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;
     parseLeverage(leverage: any, market?: any): Leverage;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;

package/js/src/bingx.js

@@ -33,6 +33,7 @@ export default class bingx extends Exchange {
                 'swap': true,
                 'future': false,
                 'option': false,
+                'addMargin': true,
                 'cancelAllOrders': true,
                 'cancelOrder': true,
                 'cancelOrders': true,
@@ -79,6 +80,7 @@ export default class bingx extends Exchange {
                 'fetchTrades': true,
                 'fetchTransfers': true,
                 'fetchWithdrawals': true,
+                'reduceMargin': true,
                 'setLeverage': true,
                 'setMargin': true,
                 'setMarginMode': true,
@@ -3467,6 +3469,18 @@ export default class bingx extends Exchange {
         };
         return await this.swapV2PrivatePostTradeMarginType(this.extend(request, params));
     }
+    async addMargin(symbol, amount, params = {}) {
+        const request = {
+            'type': 1,
+        };
+        return await this.setMargin(symbol, amount, this.extend(request, params));
+    }
+    async reduceMargin(symbol, amount, params = {}) {
+        const request = {
+            'type': 2,
+        };
+        return await this.setMargin(symbol, amount, this.extend(request, params));
+    }
     async setMargin(symbol, amount, params = {}) {
         /**
          * @method
@@ -3501,7 +3515,29 @@ export default class bingx extends Exchange {
         //        "type": 1
         //    }
         //
-        return response;
+        return this.parseMarginModification(response, market);
+    }
+    parseMarginModification(data, market = undefined) {
+        //
+        //    {
+        //        "code": 0,
+        //        "msg": "",
+        //        "amount": 1,
+        //        "type": 1
+        //    }
+        //
+        const type = this.safeString(data, 'type');
+        return {
+            'info': data,
+            'symbol': this.safeString(market, 'symbol'),
+            'type': (type === '1') ? 'add' : 'reduce',
+            'amount': this.safeNumber(data, 'amount'),
+            'total': this.safeNumber(data, 'margin'),
+            'code': this.safeString(market, 'settle'),
+            'status': undefined,
+            'timestamp': undefined,
+            'datetime': undefined,
+        };
     }
     async fetchLeverage(symbol, params = {}) {
         /**