ccxt 4.4.20 → 4.4.21

package/dist/cjs/src/static_dependencies/watchable/src/unpromise.js

@@ -0,0 +1,298 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable @typescript-eslint/unbound-method */
+/* eslint-disable @typescript-eslint/return-await */
+/* eslint-disable @typescript-eslint/promise-function-async */
+var _a;
+/** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
+ * which is retained for the lifetime of the original Promise.
+ */
+const subscribableCache = new WeakMap();
+/** A NOOP function allowing a consistent interface for settled
+ * SubscribedPromises (settled promises are not subscribed - they resolve
+ * immediately). */
+const NOOP = () => { };
+/**
+ * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
+ * created once, cached and reused throughout the lifetime of the Promise. Get a
+ * Promise's ProxyPromise using `Unpromise.proxy(promise)`.
+ *
+ * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
+ * `.then()` and `.catch()` just once. Promises derived from it use a
+ * subscription- (and unsubscription-) based mechanism that monitors these
+ * handlers.
+ *
+ * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
+ * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
+ * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
+ * from the original, potentially long-lived Promise, eliminating memory leaks.
+ *
+ * This approach can eliminate the memory leaks that otherwise come about from
+ * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
+ * times on the same long-lived native Promise (subscriptions which can never be
+ * cleaned up).
+ *
+ * `Unpromise.race(promises)` is a reference implementation of `Promise.race`
+ * avoiding memory leaks when using long-lived unsettled Promises.
+ *
+ * `Unpromise.any(promises)` is a reference implementation of `Promise.any`
+ * avoiding memory leaks when using long-lived unsettled Promises.
+ *
+ * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
+ * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
+ * the scenes, `resolve` is implemented simply as
+ * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
+ * to tidy up!
+ *
+ */
+class Unpromise {
+    constructor(arg) {
+        /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
+         * after the original promise settles - no further notifications will be issued. */
+        this.subscribers = [];
+        /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
+         * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
+         * can be returned, and therefore subscription can be bypassed. */
+        this.settlement = null;
+        /** TOSTRING SUPPORT */
+        this[_a] = "Unpromise";
+        // handle either a Promise or a Promise executor function
+        if (typeof arg === "function") {
+            this.promise = new Promise(arg);
+        }
+        else {
+            this.promise = arg;
+        }
+        // subscribe for eventual fulfilment and rejection
+        // handle PromiseLike objects (that at least have .then)
+        const thenReturn = this.promise.then((value) => {
+            // atomically record fulfilment and detach subscriber list
+            const { subscribers } = this;
+            this.subscribers = null;
+            this.settlement = {
+                status: "fulfilled",
+                value,
+            };
+            // notify fulfilment to subscriber list
+            subscribers?.forEach(({ resolve }) => {
+                resolve(value);
+            });
+        });
+        // handle Promise (that also have a .catch behaviour)
+        if ("catch" in thenReturn) {
+            thenReturn.catch((reason) => {
+                // atomically record rejection and detach subscriber list
+                const { subscribers } = this;
+                this.subscribers = null;
+                this.settlement = {
+                    status: "rejected",
+                    reason,
+                };
+                // notify rejection to subscriber list
+                subscribers?.forEach(({ reject }) => {
+                    reject(reason);
+                });
+            });
+        }
+    }
+    /** Create a promise that mitigates uncontrolled subscription to a long-lived
+     * Promise via .then() and .catch() - otherwise a source of memory leaks.
+     *
+     * The returned promise has an `unsubscribe()` method which can be called when
+     * the Promise is no longer being tracked by application logic, and which
+     * ensures that there is no reference chain from the original promise to the
+     * new one, and therefore no memory leak.
+     *
+     * If original promise has not yet settled, this adds a new unique promise
+     * that listens to then/catch events, along with an `unsubscribe()` method to
+     * detach it.
+     *
+     * If original promise has settled, then creates a new Promise.resolve() or
+     * Promise.reject() and provided unsubscribe is a noop.
+     *
+     * If you call `unsubscribe()` before the returned Promise has settled, it
+     * will never settle.
+     */
+    subscribe() {
+        // in all cases we will combine some promise with its unsubscribe function
+        let promise;
+        let unsubscribe;
+        const { settlement } = this;
+        if (settlement === null) {
+            // not yet settled - subscribe new promise. Expect eventual settlement
+            if (this.subscribers === null) {
+                // invariant - it is not settled, so it must have subscribers
+                throw new Error("Unpromise settled but still has subscribers");
+            }
+            const subscriber = withResolvers();
+            this.subscribers = listWithMember(this.subscribers, subscriber);
+            promise = subscriber.promise;
+            unsubscribe = () => {
+                if (this.subscribers !== null) {
+                    this.subscribers = listWithoutMember(this.subscribers, subscriber);
+                }
+            };
+        }
+        else {
+            // settled - don't create subscribed promise. Just resolve or reject
+            const { status } = settlement;
+            if (status === "fulfilled") {
+                promise = Promise.resolve(settlement.value);
+            }
+            else {
+                promise = Promise.reject(settlement.reason);
+            }
+            unsubscribe = NOOP;
+        }
+        // extend promise signature with the extra method
+        return Object.assign(promise, { unsubscribe });
+    }
+    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */
+    then(onfulfilled, onrejected) {
+        const subscribed = this.subscribe();
+        const { unsubscribe } = subscribed;
+        return Object.assign(subscribed.then(onfulfilled, onrejected), {
+            unsubscribe,
+        });
+    }
+    catch(onrejected) {
+        const subscribed = this.subscribe();
+        const { unsubscribe } = subscribed;
+        return Object.assign(subscribed.catch(onrejected), {
+            unsubscribe,
+        });
+    }
+    finally(onfinally) {
+        const subscribed = this.subscribe();
+        const { unsubscribe } = subscribed;
+        return Object.assign(subscribed.finally(onfinally), {
+            unsubscribe,
+        });
+    }
+    /** Unpromise STATIC METHODS */
+    /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
+     * of the provided Promise reference) */
+    static proxy(promise) {
+        const cached = Unpromise.getSubscribablePromise(promise);
+        return typeof cached !== "undefined"
+            ? cached
+            : Unpromise.createSubscribablePromise(promise);
+    }
+    /** Create and store an Unpromise keyed by an original Promise. */
+    static createSubscribablePromise(promise) {
+        const created = new Unpromise(promise);
+        subscribableCache.set(promise, created); // resolve promise to unpromise
+        subscribableCache.set(created, created); // resolve the unpromise to itself
+        return created;
+    }
+    /** Retrieve a previously-created Unpromise keyed by an original Promise. */
+    static getSubscribablePromise(promise) {
+        return subscribableCache.get(promise);
+    }
+    /** Promise STATIC METHODS */
+    /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
+     * it (that can be later unsubscribed to eliminate Memory leaks) */
+    static resolve(value) {
+        const promise = typeof value === "object" &&
+            value !== null &&
+            "then" in value &&
+            typeof value.then === "function"
+            ? value
+            : Promise.resolve(value);
+        return Unpromise.proxy(promise).subscribe();
+    }
+    static async any(values) {
+        const valuesArray = Array.isArray(values) ? values : [...values];
+        const subscribedPromises = valuesArray.map(Unpromise.resolve);
+        try {
+            return await Promise.any(subscribedPromises);
+        }
+        finally {
+            subscribedPromises.forEach(({ unsubscribe }) => {
+                unsubscribe();
+            });
+        }
+    }
+    static async race(values) {
+        const valuesArray = Array.isArray(values) ? values : [...values];
+        const subscribedPromises = valuesArray.map(Unpromise.resolve);
+        try {
+            return await Promise.race(subscribedPromises);
+        }
+        finally {
+            subscribedPromises.forEach(({ unsubscribe }) => {
+                unsubscribe();
+            });
+        }
+    }
+    /** Create a race of SubscribedPromises that will fulfil to a single winning
+     * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
+     * accumulating .then() and .catch() subscribers. Allows simple logic to
+     * consume the result, like...
+     * ```ts
+     * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
+     * if(winner === promiseB){
+     *   const result = await promiseB;
+     *   // do the thing
+     * }
+     * ```
+     * */
+    static async raceReferences(promises) {
+        // map each promise to an eventual 1-tuple containing itself
+        const selfPromises = promises.map(resolveSelfTuple);
+        // now race them. They will fulfil to a readonly [P] or reject.
+        try {
+            return await Promise.race(selfPromises);
+        }
+        finally {
+            for (const promise of selfPromises) {
+                // unsubscribe proxy promises when the race is over to mitigate memory leaks
+                promise.unsubscribe();
+            }
+        }
+    }
+}
+_a = Symbol.toStringTag;
+/** Promises a 1-tuple containing the original promise when it resolves. Allows
+ * awaiting the eventual Promise ***reference*** (easy to destructure and
+ * exactly compare with ===). Avoids resolving to the Promise ***value*** (which
+ * may be ambiguous and therefore hard to identify as the winner of a race).
+ * You can call unsubscribe on the Promise to mitigate memory leaks.
+ * */
+function resolveSelfTuple(promise) {
+    return Unpromise.proxy(promise).then(() => [promise]);
+}
+/** VENDORED (Future) PROMISE UTILITIES */
+/** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */
+function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+/** IMMUTABLE LIST OPERATIONS */
+function listWithMember(arr, member) {
+    return [...arr, member];
+}
+function listWithoutIndex(arr, index) {
+    return [...arr.slice(0, index), ...arr.slice(index + 1)];
+}
+function listWithoutMember(arr, member) {
+    const index = arr.indexOf(member);
+    if (index !== -1) {
+        return listWithoutIndex(arr, index);
+    }
+    return arr;
+}
+
+exports.Unpromise = Unpromise;
+exports.resolveSelfTuple = resolveSelfTuple;

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.19";
+declare const version = "4.4.20";
 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.20';
+const version = '4.4.21';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -162,6 +162,7 @@ interface Exchange {
     privateGetV5UserDelSubmember(params?: {}): Promise<implicitReturnType>;
     privateGetV5UserSubmembers(params?: {}): Promise<implicitReturnType>;
     privateGetV5SpotLeverTokenOrderRecord(params?: {}): Promise<implicitReturnType>;
+    privateGetV5SpotMarginTradeInterestRateHistory(params?: {}): Promise<implicitReturnType>;
     privateGetV5SpotMarginTradeState(params?: {}): Promise<implicitReturnType>;
     privateGetV5SpotCrossMarginTradeLoanInfo(params?: {}): Promise<implicitReturnType>;
     privateGetV5SpotCrossMarginTradeAccount(params?: {}): Promise<implicitReturnType>;

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

@@ -19,6 +19,7 @@ interface Exchange {
     publicGetMarkPriceSymbolCurrent(params?: {}): Promise<implicitReturnType>;
     publicGetMarkPriceAllSymbols(params?: {}): Promise<implicitReturnType>;
     publicGetMarginConfig(params?: {}): Promise<implicitReturnType>;
+    publicGetAnnouncements(params?: {}): Promise<implicitReturnType>;
     publicPostBulletPublic(params?: {}): Promise<implicitReturnType>;
     privateGetUserInfo(params?: {}): Promise<implicitReturnType>;
     privateGetAccounts(params?: {}): Promise<implicitReturnType>;

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

@@ -19,6 +19,7 @@ interface kucoin {
     publicGetMarkPriceSymbolCurrent(params?: {}): Promise<implicitReturnType>;
     publicGetMarkPriceAllSymbols(params?: {}): Promise<implicitReturnType>;
     publicGetMarginConfig(params?: {}): Promise<implicitReturnType>;
+    publicGetAnnouncements(params?: {}): Promise<implicitReturnType>;
     publicPostBulletPublic(params?: {}): Promise<implicitReturnType>;
     privateGetUserInfo(params?: {}): Promise<implicitReturnType>;
     privateGetAccounts(params?: {}): Promise<implicitReturnType>;

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

@@ -152,6 +152,9 @@ interface Exchange {
     privateGetAccountFixedLoanBorrowingLimit(params?: {}): Promise<implicitReturnType>;
     privateGetAccountFixedLoanBorrowingQuote(params?: {}): Promise<implicitReturnType>;
     privateGetAccountFixedLoanBorrowingOrdersList(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSpotManualBorrowRepay(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSetAutoRepay(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountSpotBorrowRepayHistory(params?: {}): Promise<implicitReturnType>;
     privateGetUsersSubaccountList(params?: {}): Promise<implicitReturnType>;
     privateGetAccountSubaccountBalances(params?: {}): Promise<implicitReturnType>;
     privateGetAssetSubaccountBalances(params?: {}): Promise<implicitReturnType>;

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

@@ -366,7 +366,7 @@ export default class Exchange {
     getProperty(obj: any, property: any, defaultValue?: any): any;
     setProperty(obj: any, property: any, defaultValue?: any): void;
     axolotl(payload: any, hexKey: any, ed25519: any): string;
-    fixStringifiedJsonMembers(content: string): any;
+    fixStringifiedJsonMembers(content: string): string;
     ethAbiEncode(types: any, args: any): Uint8Array;
     ethEncodeStructuredData(domain: any, messageTypes: any, messageData: any): Uint8Array;
     retrieveStarkAccount(signature: any, accountClassHash: any, accountProxyClassHash: any): {
@@ -1094,6 +1094,8 @@ export default class Exchange {
     parseTickers(tickers: any, symbols?: Strings, params?: {}): Tickers;
     parseDepositAddresses(addresses: any, codes?: Strings, indexed?: boolean, params?: {}): DepositAddress[];
     parseBorrowInterests(response: any, market?: Market): any[];
+    parseBorrowRate(info: any, currency?: Currency): Dict;
+    parseBorrowRateHistory(response: any, code: Str, since: Int, limit: Int): any;
     parseIsolatedBorrowRates(info: any): IsolatedBorrowRates;
     parseFundingRateHistories(response: any, market?: any, since?: Int, limit?: Int): FundingRateHistory[];
     safeSymbol(marketId: Str, market?: Market, delimiter?: Str, marketType?: Str): string;

package/js/src/base/Exchange.js

@@ -5507,6 +5507,19 @@ export default class Exchange {
         }
         return interests;
     }
+    parseBorrowRate(info, currency = undefined) {
+        throw new NotSupported(this.id + ' parseBorrowRate() is not supported yet');
+    }
+    parseBorrowRateHistory(response, code, since, limit) {
+        const result = [];
+        for (let i = 0; i < response.length; i++) {
+            const item = response[i];
+            const borrowRate = this.parseBorrowRate(item);
+            result.push(borrowRate);
+        }
+        const sorted = this.sortBy(result, 'timestamp');
+        return this.filterByCurrencySinceLimit(sorted, code, since, limit);
+    }
     parseIsolatedBorrowRates(info) {
         const result = {};
         for (let i = 0; i < info.length; i++) {

package/js/src/base/ws/Future.js

@@ -5,6 +5,7 @@
 // EDIT THE CORRESPONDENT .ts FILE INSTEAD
 
 // @ts-nocheck
+import { Unpromise } from "../../static_dependencies/watchable/src/unpromise.js";
 export function Future() {
     let resolve = undefined, reject = undefined;
     const p = new Promise((resolve_, reject_) => {
@@ -31,4 +32,4 @@ function wrapFuture(aggregatePromise) {
     aggregatePromise.then(p.resolve, p.reject);
     return p;
 }
-Future.race = (futures) => wrapFuture(Promise.race(futures));
+Future.race = (futures) => wrapFuture(Unpromise.race(futures));

package/js/src/binance.d.ts

@@ -229,7 +229,6 @@ export default class binance extends Exchange {
     fetchIsolatedBorrowRate(symbol: string, params?: {}): Promise<IsolatedBorrowRate>;
     fetchIsolatedBorrowRates(params?: {}): Promise<IsolatedBorrowRates>;
     fetchBorrowRateHistory(code: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseBorrowRateHistory(response: any, code: any, since: any, limit: any): any;
     parseBorrowRate(info: any, currency?: Currency): {
         currency: string;
         rate: number;

package/js/src/binance.js

@@ -12118,16 +12118,6 @@ export default class binance extends Exchange {
         //
         return this.parseBorrowRateHistory(response, code, since, limit);
     }
-    parseBorrowRateHistory(response, code, since, limit) {
-        const result = [];
-        for (let i = 0; i < response.length; i++) {
-            const item = response[i];
-            const borrowRate = this.parseBorrowRate(item);
-            result.push(borrowRate);
-        }
-        const sorted = this.sortBy(result, 'timestamp');
-        return this.filterByCurrencySinceLimit(sorted, code, since, limit);
-    }
     parseBorrowRate(info, currency = undefined) {
         //
         //    {

package/js/src/bingx.js

@@ -5319,7 +5319,7 @@ export default class bingx extends Exchange {
          * @method
          * @name bingx#withdraw
          * @description make a withdrawal
-         * @see https://bingx-api.github.io/docs/#/common/account-api.html#Withdraw
+         * @see https://bingx-api.github.io/docs/#/en-us/spot/wallet-api.html#Withdraw
          * @param {string} code unified currency code
          * @param {float} amount the amount to withdraw
          * @param {string} address the address to withdraw to
@@ -5328,6 +5328,8 @@ export default class bingx extends Exchange {
          * @param {int} [params.walletType] 1 fund account, 2 standard account, 3 perpetual account
          * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/#/?id=transaction-structure}
          */
+        [tag, params] = this.handleWithdrawTagAndParams(tag, params);
+        this.checkAddress(address);
         await this.loadMarkets();
         const currency = this.currency(code);
         let walletType = this.safeInteger(params, 'walletType');
@@ -5347,6 +5349,9 @@ export default class bingx extends Exchange {
         if (network !== undefined) {
             request['network'] = this.networkCodeToId(network);
         }
+        if (tag !== undefined) {
+            request['addressTag'] = tag;
+        }
         params = this.omit(params, ['walletType', 'network']);
         const response = await this.walletsV1PrivatePostCapitalWithdrawApply(this.extend(request, params));
         const data = this.safeValue(response, 'data');

package/js/src/bybit.d.ts

@@ -106,6 +106,7 @@ export default class bybit extends Exchange {
         info: any;
     };
     fetchBorrowInterest(code?: Str, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchBorrowRateHistory(code: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseBorrowInterest(info: Dict, market?: Market): {
         symbol: any;
         marginMode: string;

package/js/src/bybit.js

@@ -371,6 +371,7 @@ export default class bybit extends Exchange {
                         // spot leverage token
                         'v5/spot-lever-token/order-record': 1,
                         // spot margin trade
+                        'v5/spot-margin-trade/interest-rate-history': 5,
                         'v5/spot-margin-trade/state': 5,
                         'v5/spot-cross-margin-trade/loan-info': 1,
                         'v5/spot-cross-margin-trade/account': 1,
@@ -7320,12 +7321,22 @@ export default class bybit extends Exchange {
         //         "timestamp": 1666734490778
         //     }
         //
+        // fetchBorrowRateHistory
+        //     {
+        //         "timestamp": 1721469600000,
+        //         "currency": "USDC",
+        //         "hourlyBorrowRate": "0.000014621596",
+        //         "vipLevel": "No VIP"
+        //     }
+        //
         const timestamp = this.safeInteger(info, 'timestamp');
-        const currencyId = this.safeString(info, 'coin');
+        const currencyId = this.safeString2(info, 'coin', 'currency');
+        const hourlyBorrowRate = this.safeNumber(info, 'hourlyBorrowRate');
+        const period = (hourlyBorrowRate !== undefined) ? 3600000 : 86400000; // 1h or 1d
         return {
             'currency': this.safeCurrencyCode(currencyId, currency),
-            'rate': this.safeNumber(info, 'interestRate'),
-            'period': 86400000,
+            'rate': this.safeNumber(info, 'interestRate', hourlyBorrowRate),
+            'period': period,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'info': info,
@@ -7377,6 +7388,57 @@ export default class bybit extends Exchange {
         const interest = this.parseBorrowInterests(rows, undefined);
         return this.filterByCurrencySinceLimit(interest, code, since, limit);
     }
+    async fetchBorrowRateHistory(code, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#fetchBorrowRateHistory
+         * @description retrieves a history of a currencies borrow interest rate at specific time slots
+         * @see https://bybit-exchange.github.io/docs/v5/spot-margin-uta/historical-interest
+         * @param {string} code unified currency code
+         * @param {int} [since] timestamp for the earliest borrow rate
+         * @param {int} [limit] the maximum number of [borrow rate structures]{@link https://docs.ccxt.com/#/?id=borrow-rate-structure} to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {object[]} an array of [borrow rate structures]{@link https://docs.ccxt.com/#/?id=borrow-rate-structure}
+         */
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'currency': currency['id'],
+        };
+        if (since === undefined) {
+            since = this.milliseconds() - 86400000 * 30; // last 30 days
+        }
+        request['startTime'] = since;
+        let endTime = this.safeInteger2(params, 'until', 'endTime');
+        params = this.omit(params, ['until']);
+        if (endTime === undefined) {
+            endTime = since + 86400000 * 30; // since + 30 days
+        }
+        request['endTime'] = endTime;
+        const response = await this.privateGetV5SpotMarginTradeInterestRateHistory(this.extend(request, params));
+        //
+        //   {
+        //       "retCode": 0,
+        //       "retMsg": "OK",
+        //       "result": {
+        //           "list": [
+        //               {
+        //                   "timestamp": 1721469600000,
+        //                   "currency": "USDC",
+        //                   "hourlyBorrowRate": "0.000014621596",
+        //                   "vipLevel": "No VIP"
+        //               }
+        //           ]
+        //       },
+        //       "retExtInfo": "{}",
+        //       "time": 1721899048991
+        //   }
+        //
+        const data = this.safeDict(response, 'result');
+        const rows = this.safeList(data, 'list', []);
+        return this.parseBorrowRateHistory(rows, code, since, limit);
+    }
     parseBorrowInterest(info, market = undefined) {
         //
         //     {

package/js/src/htx.d.ts

@@ -37,7 +37,7 @@ export default class htx extends Exchange {
     };
     costToPrecision(symbol: any, cost: any): string;
     fetchMarkets(params?: {}): Promise<Market[]>;
-    fetchMarketsByTypeAndSubType(type: any, subType: any, params?: {}): Promise<any[]>;
+    fetchMarketsByTypeAndSubType(type: Str, subType: Str, params?: {}): Promise<any[]>;
     tryGetSymbolFromFutureMarkets(symbolOrMarketId: string): any;
     parseTicker(ticker: Dict, market?: Market): Ticker;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
@@ -66,7 +66,7 @@ export default class htx extends Exchange {
         type: any;
         code: any;
     };
-    fetchAccountIdByType(type: any, marginMode?: any, symbol?: any, params?: {}): Promise<any>;
+    fetchAccountIdByType(type: string, marginMode?: Str, symbol?: Str, params?: {}): Promise<any>;
     fetchCurrencies(params?: {}): Promise<Currencies>;
     networkIdToCode(networkId?: Str, currencyCode?: Str): string;
     networkCodeToId(networkCode: string, currencyCode?: Str): any;

package/js/src/htx.js

@@ -1639,6 +1639,10 @@ export default class htx extends Exchange {
          * @method
          * @name htx#fetchMarkets
          * @description retrieves data on all markets for huobi
+         * @see https://huobiapi.github.io/docs/spot/v1/en/#get-all-supported-trading-symbol-v1-deprecated
+         * @see https://huobiapi.github.io/docs/dm/v1/en/#get-contract-info
+         * @see https://huobiapi.github.io/docs/coin_margined_swap/v1/en/#query-swap-info
+         * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#general-query-swap-info
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} an array of objects representing market data
          */
@@ -1669,6 +1673,20 @@ export default class htx extends Exchange {
         return allMarkets;
     }
     async fetchMarketsByTypeAndSubType(type, subType, params = {}) {
+        /**
+         * @ignore
+         * @method
+         * @name htx#fetchMarketsByTypeAndSubType
+         * @description retrieves data on all markets of a certain type and/or subtype
+         * @see https://huobiapi.github.io/docs/spot/v1/en/#get-all-supported-trading-symbol-v1-deprecated
+         * @see https://huobiapi.github.io/docs/dm/v1/en/#get-contract-info
+         * @see https://huobiapi.github.io/docs/coin_margined_swap/v1/en/#query-swap-info
+         * @see https://huobiapi.github.io/docs/usdt_swap/v1/en/#general-query-swap-info
+         * @param {string} [type] 'spot', 'swap' or 'future'
+         * @param {string} [subType] 'linear' or 'inverse'
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} an array of objects representing market data
+         */
         const isSpot = (type === 'spot');
         const request = {};
         let response = undefined;
@@ -3191,6 +3209,16 @@ export default class htx extends Exchange {
         };
     }
     async fetchAccountIdByType(type, marginMode = undefined, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name htx#fetchAccountIdByType
+         * @description fetch all the accounts by a type and marginModeassociated with a profile
+         * @see https://huobiapi.github.io/docs/spot/v1/en/#get-all-accounts-of-the-current-user
+         * @param {string} type 'spot', 'swap' or 'future
+         * @param {string} [marginMode] 'cross' or 'isolated'
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a dictionary of [account structures]{@link https://docs.ccxt.com/#/?id=account-structure} indexed by the account type
+         */
         const accounts = await this.loadAccounts();
         const accountId = this.safeValue2(params, 'accountId', 'account-id');
         if (accountId !== undefined) {