ccxt 4.4.7 → 4.4.8

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

@@ -23,6 +23,7 @@ class bitmart extends bitmart$1 {
                 'watchBalance': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchOrderBook': true,
                 'watchOrderBookForSymbols': true,
                 'watchOrders': true,
@@ -334,6 +335,7 @@ class bitmart extends bitmart$1 {
         /**
          * @method
          * @name bitmart#watchTickers
+         * @see https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
          * @see https://developer-pro.bitmart.com/en/futuresv2/#public-ticker-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
@@ -352,6 +354,84 @@ class bitmart extends bitmart$1 {
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitmart#watchBidsAsks
+         * @see https://developer-pro.bitmart.com/en/spot/#public-ticker-channel
+         * @see https://developer-pro.bitmart.com/en/futuresv2/#public-ticker-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}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const firstMarket = this.getMarketFromSymbols(symbols);
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('watchBidsAsks', firstMarket, params);
+        const url = this.implodeHostname(this.urls['api']['ws'][marketType]['public']);
+        const channelType = (marketType === 'spot') ? 'spot' : 'futures';
+        const actionType = (marketType === 'spot') ? 'op' : 'action';
+        let rawSubscriptions = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            rawSubscriptions.push(channelType + '/ticker:' + market['id']);
+            messageHashes.push('bidask:' + symbols[i]);
+        }
+        if (marketType !== 'spot') {
+            rawSubscriptions = [channelType + '/ticker'];
+        }
+        const request = {
+            'args': rawSubscriptions,
+        };
+        request[actionType] = 'subscribe';
+        const newTickers = await this.watchMultiple(url, messageHashes, request, rawSubscriptions);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[newTickers['symbol']] = newTickers;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        const table = this.safeString(message, 'table');
+        const isSpot = (table !== undefined);
+        let rawTickers = [];
+        if (isSpot) {
+            rawTickers = this.safeList(message, 'data', []);
+        }
+        else {
+            rawTickers = [this.safeValue(message, 'data', {})];
+        }
+        if (!rawTickers.length) {
+            return;
+        }
+        for (let i = 0; i < rawTickers.length; i++) {
+            const ticker = this.parseWsBidAsk(rawTickers[i]);
+            const symbol = ticker['symbol'];
+            this.bidsasks[symbol] = ticker;
+            const messageHash = 'bidask:' + symbol;
+            client.resolve(ticker, messageHash);
+        }
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'ms_t');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeString2(ticker, 'ask_px', 'ask_price'),
+            'askVolume': this.safeString2(ticker, 'ask_sz', 'ask_vol'),
+            'bid': this.safeString2(ticker, 'bid_px', 'bid_price'),
+            'bidVolume': this.safeString2(ticker, 'bid_sz', 'bid_vol'),
+            'info': ticker,
+        }, market);
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -931,6 +1011,7 @@ class bitmart extends bitmart$1 {
         //            }
         //    }
         //
+        this.handleBidAsk(client, message);
         const table = this.safeString(message, 'table');
         const isSpot = (table !== undefined);
         let rawTickers = [];

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

@@ -17,6 +17,8 @@ class bitvavo extends bitvavo$1 {
                 'watchOrderBook': true,
                 'watchTrades': true,
                 'watchTicker': true,
+                'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchOHLCV': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
@@ -77,17 +79,56 @@ class bitvavo extends bitvavo$1 {
         const message = this.extend(request, params);
         return await this.watch(url, messageHash, message, messageHash);
     }
+    async watchPublicMultiple(methodName, channelName, symbols, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const messageHashes = [methodName];
+        const args = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            args.push(market['id']);
+        }
+        const url = this.urls['api']['ws'];
+        const request = {
+            'action': 'subscribe',
+            'channels': [
+                {
+                    'name': channelName,
+                    'markets': args,
+                },
+            ],
+        };
+        const message = this.extend(request, params);
+        return await this.watchMultiple(url, messageHashes, message, messageHashes);
+    }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
          * @name bitvavo#watchTicker
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://docs.bitvavo.com/#tag/Market-data-subscription-WebSocket/paths/~1subscribeTicker24h/post
          * @param {string} symbol 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.watchPublic('ticker24h', symbol, params);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitvavo#watchTickers
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @see https://docs.bitvavo.com/#tag/Market-data-subscription-WebSocket/paths/~1subscribeTicker24h/post
+         * @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, undefined, false);
+        const channel = 'ticker24h';
+        const tickers = await this.watchPublicMultiple(channel, channel, symbols, params);
+        return this.filterByArray(tickers, 'symbol', symbols);
+    }
     handleTicker(client, message) {
         //
         //     {
@@ -110,8 +151,10 @@ class bitvavo extends bitvavo$1 {
         //         ]
         //     }
         //
+        this.handleBidAsk(client, message);
         const event = this.safeString(message, 'event');
         const tickers = this.safeValue(message, 'data', []);
+        const result = [];
         for (let i = 0; i < tickers.length; i++) {
             const data = tickers[i];
             const marketId = this.safeString(data, 'market');
@@ -120,9 +163,57 @@ class bitvavo extends bitvavo$1 {
             const ticker = this.parseTicker(data, market);
             const symbol = ticker['symbol'];
             this.tickers[symbol] = ticker;
+            result.push(ticker);
             client.resolve(ticker, messageHash);
         }
-        return message;
+        client.resolve(result, event);
+    }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name mexc#watchBidsAsks
+         * @description watches best bid & ask for symbols
+         * @see https://docs.bitvavo.com/#tag/Market-data-subscription-WebSocket/paths/~1subscribeTicker24h/post
+         * @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, undefined, false);
+        const channel = 'ticker24h';
+        const tickers = await this.watchPublicMultiple('bidask', channel, symbols, params);
+        return this.filterByArray(tickers, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        const event = 'bidask';
+        const tickers = this.safeValue(message, 'data', []);
+        const result = [];
+        for (let i = 0; i < tickers.length; i++) {
+            const data = tickers[i];
+            const ticker = this.parseWsBidAsk(data);
+            const symbol = ticker['symbol'];
+            this.bidsasks[symbol] = ticker;
+            result.push(ticker);
+            const messageHash = event + ':' + symbol;
+            client.resolve(ticker, messageHash);
+        }
+        client.resolve(result, event);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'market');
+        market = this.safeMarket(marketId, undefined, '-');
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'timestamp');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeNumber(ticker, 'ask'),
+            'askVolume': this.safeNumber(ticker, 'askSize'),
+            'bid': this.safeNumber(ticker, 'bid'),
+            'bidVolume': this.safeNumber(ticker, 'bidSize'),
+            'info': ticker,
+        }, market);
     }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**

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

@@ -18,6 +18,7 @@ class blofin extends blofin$1 {
                 'watchOrderBookForSymbols': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchOHLCV': true,
                 'watchOHLCVForSymbols': true,
                 'watchOrders': true,
@@ -270,6 +271,7 @@ class blofin extends blofin$1 {
         //         ],
         //     }
         //
+        this.handleBidAsk(client, message);
         const arg = this.safeDict(message, 'arg');
         const channelName = this.safeString(arg, 'channel');
         const data = this.safeList(message, 'data');
@@ -284,6 +286,68 @@ class blofin extends blofin$1 {
     parseWsTicker(ticker, market = undefined) {
         return this.parseTicker(ticker, market);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#watchBidsAsks
+         * @description watches best bid & ask for symbols
+         * @see https://docs.blofin.com/index.html#ws-tickers-channel
+         * @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, undefined, false);
+        const firstMarket = this.market(symbols[0]);
+        const channel = 'tickers';
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('watchBidsAsks', firstMarket, params);
+        const url = this.implodeHostname(this.urls['api']['ws'][marketType]['public']);
+        const messageHashes = [];
+        const args = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            messageHashes.push('bidask:' + market['symbol']);
+            args.push({
+                'channel': channel,
+                'instId': market['id'],
+            });
+        }
+        const request = this.getSubscriptionRequest(args);
+        const ticker = await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), messageHashes);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[ticker['symbol']] = ticker;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        const data = this.safeList(message, 'data');
+        for (let i = 0; i < data.length; i++) {
+            const ticker = this.parseWsBidAsk(data[i]);
+            const symbol = ticker['symbol'];
+            const messageHash = 'bidask:' + symbol;
+            this.bidsasks[symbol] = ticker;
+            client.resolve(ticker, messageHash);
+        }
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'instId');
+        market = this.safeMarket(marketId, market, '-');
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'ts');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeString(ticker, 'askPrice'),
+            'askVolume': this.safeString(ticker, 'askSize'),
+            'bid': this.safeString(ticker, 'bidPrice'),
+            'bidVolume': this.safeString(ticker, 'bidSize'),
+            'info': ticker,
+        }, market);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method

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 { Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarketMarginModes, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError } from './src/base/errors.js';
-declare const version = "4.4.6";
+declare const version = "4.4.7";
 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, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.4.7';
+const version = '4.4.8';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -701,6 +701,7 @@ interface Exchange {
     papiPostRepayFuturesNegativeBalance(params?: {}): Promise<implicitReturnType>;
     papiPostListenKey(params?: {}): Promise<implicitReturnType>;
     papiPostAssetCollection(params?: {}): Promise<implicitReturnType>;
+    papiPostMarginRepayDebt(params?: {}): Promise<implicitReturnType>;
     papiPutListenKey(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmOrder(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmConditionalOrder(params?: {}): Promise<implicitReturnType>;

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

@@ -701,6 +701,7 @@ interface binance {
     papiPostRepayFuturesNegativeBalance(params?: {}): Promise<implicitReturnType>;
     papiPostListenKey(params?: {}): Promise<implicitReturnType>;
     papiPostAssetCollection(params?: {}): Promise<implicitReturnType>;
+    papiPostMarginRepayDebt(params?: {}): Promise<implicitReturnType>;
     papiPutListenKey(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmOrder(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmConditionalOrder(params?: {}): Promise<implicitReturnType>;

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

@@ -753,6 +753,7 @@ interface binance {
     papiPostRepayFuturesNegativeBalance(params?: {}): Promise<implicitReturnType>;
     papiPostListenKey(params?: {}): Promise<implicitReturnType>;
     papiPostAssetCollection(params?: {}): Promise<implicitReturnType>;
+    papiPostMarginRepayDebt(params?: {}): Promise<implicitReturnType>;
     papiPutListenKey(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmOrder(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmConditionalOrder(params?: {}): Promise<implicitReturnType>;

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

@@ -701,6 +701,7 @@ interface binance {
     papiPostRepayFuturesNegativeBalance(params?: {}): Promise<implicitReturnType>;
     papiPostListenKey(params?: {}): Promise<implicitReturnType>;
     papiPostAssetCollection(params?: {}): Promise<implicitReturnType>;
+    papiPostMarginRepayDebt(params?: {}): Promise<implicitReturnType>;
     papiPutListenKey(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmOrder(params?: {}): Promise<implicitReturnType>;
     papiDeleteUmConditionalOrder(params?: {}): Promise<implicitReturnType>;

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

@@ -131,6 +131,9 @@ interface Exchange {
     privateGetV5AccountContractTransactionLog(params?: {}): Promise<implicitReturnType>;
     privateGetV5AccountSmpGroup(params?: {}): Promise<implicitReturnType>;
     privateGetV5AccountMmpState(params?: {}): Promise<implicitReturnType>;
+    privateGetV5AssetExchangeQueryCoinList(params?: {}): Promise<implicitReturnType>;
+    privateGetV5AssetExchangeConvertResultQuery(params?: {}): Promise<implicitReturnType>;
+    privateGetV5AssetExchangeQueryConvertHistory(params?: {}): Promise<implicitReturnType>;
     privateGetV5AssetExchangeOrderRecord(params?: {}): Promise<implicitReturnType>;
     privateGetV5AssetDeliveryRecord(params?: {}): Promise<implicitReturnType>;
     privateGetV5AssetSettlementRecord(params?: {}): Promise<implicitReturnType>;
@@ -269,6 +272,8 @@ interface Exchange {
     privatePostV5AccountSetHedgingMode(params?: {}): Promise<implicitReturnType>;
     privatePostV5AccountMmpModify(params?: {}): Promise<implicitReturnType>;
     privatePostV5AccountMmpReset(params?: {}): Promise<implicitReturnType>;
+    privatePostV5AssetExchangeQuoteApply(params?: {}): Promise<implicitReturnType>;
+    privatePostV5AssetExchangeConvertExecute(params?: {}): Promise<implicitReturnType>;
     privatePostV5AssetTransferInterTransfer(params?: {}): Promise<implicitReturnType>;
     privatePostV5AssetTransferSaveTransferSubMember(params?: {}): Promise<implicitReturnType>;
     privatePostV5AssetTransferUniversalTransfer(params?: {}): Promise<implicitReturnType>;

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

@@ -78,6 +78,7 @@ interface Exchange {
     publicGetCopytradingPublicPreferenceCurrency(params?: {}): Promise<implicitReturnType>;
     publicGetCopytradingPublicCurrentSubpositions(params?: {}): Promise<implicitReturnType>;
     publicGetCopytradingPublicSubpositionsHistory(params?: {}): Promise<implicitReturnType>;
+    publicGetSupportAnnouncementsTypes(params?: {}): Promise<implicitReturnType>;
     privateGetRfqCounterparties(params?: {}): Promise<implicitReturnType>;
     privateGetRfqMakerInstrumentSettings(params?: {}): Promise<implicitReturnType>;
     privateGetRfqMmpConfig(params?: {}): Promise<implicitReturnType>;
@@ -207,6 +208,7 @@ interface Exchange {
     privateGetBrokerFdIfRebate(params?: {}): Promise<implicitReturnType>;
     privateGetAffiliateInviteeDetail(params?: {}): Promise<implicitReturnType>;
     privateGetUsersPartnerIfRebate(params?: {}): Promise<implicitReturnType>;
+    privateGetSupportAnnouncements(params?: {}): Promise<implicitReturnType>;
     privatePostRfqCreateRfq(params?: {}): Promise<implicitReturnType>;
     privatePostRfqCancelRfq(params?: {}): Promise<implicitReturnType>;
     privatePostRfqCancelBatchRfqs(params?: {}): Promise<implicitReturnType>;

package/js/src/binance.d.ts

@@ -303,46 +303,46 @@ export default class binance extends Exchange {
     repayCrossMargin(code: string, amount: any, params?: {}): Promise<{
         id: number;
         currency: string;
-        amount: any;
+        amount: number;
         symbol: any;
-        timestamp: any;
-        datetime: any;
+        timestamp: number;
+        datetime: string;
         info: any;
     }>;
     repayIsolatedMargin(symbol: string, code: string, amount: any, params?: {}): Promise<{
         id: number;
         currency: string;
-        amount: any;
+        amount: number;
         symbol: any;
-        timestamp: any;
-        datetime: any;
+        timestamp: number;
+        datetime: string;
         info: any;
     }>;
     borrowCrossMargin(code: string, amount: number, params?: {}): Promise<{
         id: number;
         currency: string;
-        amount: any;
+        amount: number;
         symbol: any;
-        timestamp: any;
-        datetime: any;
+        timestamp: number;
+        datetime: string;
         info: any;
     }>;
     borrowIsolatedMargin(symbol: string, code: string, amount: number, params?: {}): Promise<{
         id: number;
         currency: string;
-        amount: any;
+        amount: number;
         symbol: any;
-        timestamp: any;
-        datetime: any;
+        timestamp: number;
+        datetime: string;
         info: any;
     }>;
     parseMarginLoan(info: any, currency?: Currency): {
         id: number;
         currency: string;
-        amount: any;
+        amount: number;
         symbol: any;
-        timestamp: any;
-        datetime: any;
+        timestamp: number;
+        datetime: string;
         info: any;
     };
     fetchOpenInterestHistory(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OpenInterest[]>;

package/js/src/binance.js

@@ -1094,6 +1094,7 @@ export default class binance extends Exchange {
                         'repay-futures-negative-balance': 150,
                         'listenKey': 1,
                         'asset-collection': 3,
+                        'margin/repay-debt': 0.4, // Weight(Order): 0.4 => (1000 / (50 * 0.4)) * 60 = 3000
                     },
                     'put': {
                         'listenKey': 1, // 1
@@ -1211,6 +1212,7 @@ export default class binance extends Exchange {
                 ],
                 'fetchCurrencies': true,
                 // 'fetchTradesMethod': 'publicGetAggTrades', // publicGetTrades, publicGetHistoricalTrades, eapiPublicGetTrades
+                // 'repayCrossMarginMethod': 'papiPostRepayLoan', // papiPostMarginRepayDebt
                 'defaultTimeInForce': 'GTC',
                 'defaultType': 'spot',
                 'defaultSubType': undefined,
@@ -2907,7 +2909,7 @@ export default class binance extends Exchange {
             const res = this.safeValue(results, i);
             if (fetchMargins && Array.isArray(res)) {
                 const keysList = Object.keys(this.indexBy(res, 'symbol'));
-                const length = (Object.keys(this.options['crossMarginPairsData'])).length;
+                const length = this.options['crossMarginPairsData'].length;
                 // first one is the cross-margin promise
                 if (length === 0) {
                     this.options['crossMarginPairsData'] = keysList;
@@ -12220,10 +12222,13 @@ export default class binance extends Exchange {
          * @description repay borrowed margin and interest
          * @see https://developers.binance.com/docs/derivatives/portfolio-margin/trade/Margin-Account-Repay
          * @see https://developers.binance.com/docs/margin_trading/borrow-and-repay/Margin-Account-Borrow-Repay
+         * @see https://developers.binance.com/docs/derivatives/portfolio-margin/trade/Margin-Account-Repay-Debt
          * @param {string} code unified currency code of the currency to repay
          * @param {float} amount the amount to repay
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {boolean} [params.portfolioMargin] set to true if you would like to repay margin in a portfolio margin account
+         * @param {string} [params.repayCrossMarginMethod] *portfolio margin only* 'papiPostRepayLoan' (default), 'papiPostMarginRepayDebt' (alternative)
+         * @param {string} [params.specifyRepayAssets] *portfolio margin papiPostMarginRepayDebt only* specific asset list to repay debt
          * @returns {object} a [margin loan structure]{@link https://docs.ccxt.com/#/?id=margin-loan-structure}
          */
         await this.loadMarkets();
@@ -12236,19 +12241,41 @@ export default class binance extends Exchange {
         let isPortfolioMargin = undefined;
         [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'repayCrossMargin', 'papi', 'portfolioMargin', false);
         if (isPortfolioMargin) {
-            response = await this.papiPostRepayLoan(this.extend(request, params));
+            let method = undefined;
+            [method, params] = this.handleOptionAndParams2(params, 'repayCrossMargin', 'repayCrossMarginMethod', 'method');
+            if (method === 'papiPostMarginRepayDebt') {
+                response = await this.papiPostMarginRepayDebt(this.extend(request, params));
+                //
+                //     {
+                //         "asset": "USDC",
+                //         "amount": 10,
+                //         "specifyRepayAssets": null,
+                //         "updateTime": 1727170761267,
+                //         "success": true
+                //     }
+                //
+            }
+            else {
+                response = await this.papiPostRepayLoan(this.extend(request, params));
+                //
+                //     {
+                //         "tranId": 108988250265,
+                //         "clientTag":""
+                //     }
+                //
+            }
         }
         else {
             request['isIsolated'] = 'FALSE';
             request['type'] = 'REPAY';
             response = await this.sapiPostMarginBorrowRepay(this.extend(request, params));
+            //
+            //     {
+            //         "tranId": 108988250265,
+            //         "clientTag":""
+            //     }
+            //
         }
-        //
-        //     {
-        //         "tranId": 108988250265,
-        //         "clientTag":""
-        //     }
-        //
         return this.parseMarginLoan(response, currency);
     }
     async repayIsolatedMargin(symbol, code, amount, params = {}) {
@@ -12358,13 +12385,25 @@ export default class binance extends Exchange {
         //         "clientTag":""
         //     }
         //
+        // repayCrossMargin alternative endpoint
+        //
+        //     {
+        //         "asset": "USDC",
+        //         "amount": 10,
+        //         "specifyRepayAssets": null,
+        //         "updateTime": 1727170761267,
+        //         "success": true
+        //     }
+        //
+        const currencyId = this.safeString(info, 'asset');
+        const timestamp = this.safeInteger(info, 'updateTime');
         return {
             'id': this.safeInteger(info, 'tranId'),
-            'currency': this.safeCurrencyCode(undefined, currency),
-            'amount': undefined,
+            'currency': this.safeCurrencyCode(currencyId, currency),
+            'amount': this.safeNumber(info, 'amount'),
             'symbol': undefined,
-            'timestamp': undefined,
-            'datetime': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
             'info': info,
         };
     }

package/js/src/bybit.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/bybit.js';
-import type { Int, OrderSide, OrderType, Trade, Order, OHLCV, FundingRateHistory, OpenInterest, OrderRequest, Balances, Str, Transaction, Ticker, OrderBook, Tickers, Greeks, Strings, Market, Currency, MarketInterface, TransferEntry, Liquidation, Leverage, Num, FundingHistory, Option, OptionChain, TradingFeeInterface, Currencies, TradingFees, CancellationRequest, Position, CrossBorrowRate, Dict, LeverageTier, LeverageTiers, int, LedgerEntry } from './base/types.js';
+import type { Int, OrderSide, OrderType, Trade, Order, OHLCV, FundingRateHistory, OpenInterest, OrderRequest, Balances, Str, Transaction, Ticker, OrderBook, Tickers, Greeks, Strings, Market, Currency, MarketInterface, TransferEntry, Liquidation, Leverage, Num, FundingHistory, Option, OptionChain, TradingFeeInterface, Currencies, TradingFees, CancellationRequest, Position, CrossBorrowRate, Dict, LeverageTier, LeverageTiers, int, LedgerEntry, Conversion } from './base/types.js';
 /**
  * @class bybit
  * @augments Exchange
@@ -204,6 +204,12 @@ export default class bybit extends Exchange {
     fetchOptionChain(code: string, params?: {}): Promise<OptionChain>;
     parseOption(chain: Dict, currency?: Currency, market?: Market): Option;
     fetchPositionsHistory(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    fetchConvertCurrencies(params?: {}): Promise<Currencies>;
+    fetchConvertQuote(fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;
+    createConvertTrade(id: string, fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;
+    fetchConvertTrade(id: string, code?: Str, params?: {}): Promise<Conversion>;
+    fetchConvertTradeHistory(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Conversion[]>;
+    parseConversion(conversion: Dict, fromCurrency?: Currency, toCurrency?: Currency): Conversion;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
         url: string;
         method: string;