ccxt 4.4.20 → 4.4.22

package/dist/cjs/src/okx.js

@@ -93,6 +93,8 @@ class okx extends okx$1 {
                 'fetchLedgerEntry': undefined,
                 'fetchLeverage': true,
                 'fetchLeverageTiers': false,
+                'fetchLongShortRatio': false,
+                'fetchLongShortRatioHistory': true,
                 'fetchMarginAdjustmentHistory': true,
                 'fetchMarketLeverageTiers': true,
                 'fetchMarkets': true,
@@ -235,6 +237,7 @@ class okx extends okx$1 {
                         'rubik/stat/margin/loan-ratio': 4,
                         // long/short
                         'rubik/stat/contracts/long-short-account-ratio': 4,
+                        'rubik/stat/contracts/long-short-account-ratio-contract': 4,
                         'rubik/stat/contracts/open-interest-volume': 4,
                         'rubik/stat/option/open-interest-volume': 4,
                         // put/call
@@ -353,6 +356,9 @@ class okx extends okx$1 {
                         'account/fixed-loan/borrowing-limit': 4,
                         'account/fixed-loan/borrowing-quote': 5,
                         'account/fixed-loan/borrowing-orders-list': 5,
+                        'account/spot-manual-borrow-repay': 10,
+                        'account/set-auto-repay': 4,
+                        'account/spot-borrow-repay-history': 4,
                         // subaccount
                         'users/subaccount/list': 10,
                         'account/subaccount/balances': 10 / 3,
@@ -884,6 +890,11 @@ class okx extends okx$1 {
                     '59301': errors.ExchangeError,
                     '59313': errors.ExchangeError,
                     '59401': errors.ExchangeError,
+                    '59410': errors.OperationRejected,
+                    '59411': errors.InsufficientFunds,
+                    '59412': errors.OperationRejected,
+                    '59413': errors.OperationRejected,
+                    '59414': errors.BadRequest,
                     '59500': errors.ExchangeError,
                     '59501': errors.ExchangeError,
                     '59502': errors.ExchangeError,
@@ -6673,16 +6684,6 @@ class okx extends okx$1 {
         }
         return borrowRateHistories;
     }
-    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);
-    }
     async fetchBorrowRateHistories(codes = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -8499,6 +8500,77 @@ class okx extends okx$1 {
         const positions = this.parsePositions(data, symbols, params);
         return this.filterBySinceLimit(positions, since, limit);
     }
+    async fetchLongShortRatioHistory(symbol = undefined, timeframe = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#fetchLongShortRatioHistory
+         * @description fetches the long short ratio history for a unified market symbol
+         * @see https://www.okx.com/docs-v5/en/#trading-statistics-rest-api-get-contract-long-short-ratio
+         * @param {string} symbol unified symbol of the market to fetch the long short ratio for
+         * @param {string} [timeframe] the period for the ratio
+         * @param {int} [since] the earliest time in ms to fetch ratios for
+         * @param {int} [limit] the maximum number of long short ratio structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] timestamp in ms of the latest ratio to fetch
+         * @returns {object[]} an array of [long short ratio structures]{@link https://docs.ccxt.com/#/?id=long-short-ratio-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        const until = this.safeString2(params, 'until', 'end');
+        params = this.omit(params, 'until');
+        if (until !== undefined) {
+            request['end'] = until;
+        }
+        if (timeframe !== undefined) {
+            request['period'] = timeframe;
+        }
+        if (since !== undefined) {
+            request['begin'] = since;
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        const response = await this.publicGetRubikStatContractsLongShortAccountRatioContract(this.extend(request, params));
+        //
+        //     {
+        //         "code": "0",
+        //         "data": [
+        //             ["1729323600000", "0.9398602814619824"],
+        //             ["1729323300000", "0.9398602814619824"],
+        //             ["1729323000000", "0.9398602814619824"],
+        //         ],
+        //         "msg": ""
+        //     }
+        //
+        const data = this.safeList(response, 'data', []);
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            const entry = data[i];
+            result.push({
+                'timestamp': this.safeString(entry, 0),
+                'longShortRatio': this.safeString(entry, 1),
+            });
+        }
+        return this.parseLongShortRatioHistory(result, market);
+    }
+    parseLongShortRatio(info, market = undefined) {
+        const timestamp = this.safeInteger(info, 'timestamp');
+        let symbol = undefined;
+        if (market !== undefined) {
+            symbol = market['symbol'];
+        }
+        return {
+            'info': info,
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'timeframe': undefined,
+            'longShortRatio': this.safeNumber(info, 'longShortRatio'),
+        };
+    }
 }
 
 module.exports = okx;

package/dist/cjs/src/paradex.js

@@ -1,13 +1,12 @@
 'use strict';
 
-require('../ccxt.js');
+var Precise = require('./base/Precise.js');
 var paradex$1 = require('./abstract/paradex.js');
 var errors = require('./base/errors.js');
 var number = require('./base/functions/number.js');
 var crypto = require('./base/functions/crypto.js');
 var sha3 = require('./static_dependencies/noble-hashes/sha3.js');
 var secp256k1 = require('./static_dependencies/noble-curves/secp256k1.js');
-var Precise = require('./base/Precise.js');
 
 //  ---------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------

package/dist/cjs/src/static_dependencies/noble-hashes/_sha2.js

@@ -104,7 +104,7 @@ class SHA2 extends utils.Hash {
         return res;
     }
     _cloneInto(to) {
-        to || (to = new this.constructor());
+        to ||= new this.constructor();
         to.set(...this.get());
         const { blockLen, buffer, length, finished, destroyed, pos } = this;
         to.length = length;

package/dist/cjs/src/static_dependencies/noble-hashes/hmac.js

@@ -54,7 +54,7 @@ class HMAC extends utils.Hash {
     }
     _cloneInto(to) {
         // Create new instance without calling constructor since key already in state and we don't know it.
-        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        to ||= Object.create(Object.getPrototypeOf(this), {});
         const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
         to = to;
         to.finished = finished;

package/dist/cjs/src/static_dependencies/noble-hashes/sha3.js

@@ -174,7 +174,7 @@ class Keccak extends utils.Hash {
     }
     _cloneInto(to) {
         const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to ||= new Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
         to.state32.set(this.state32);
         to.pos = this.pos;
         to.posOut = this.posOut;

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

@@ -2,9 +2,9 @@ import { Exchange } from './src/base/Exchange.js';
 import { Precise } from './src/base/Precise.js';
 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 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, LongShortRatio } 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.21";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';
@@ -558,5 +558,5 @@ declare const ccxt: {
     zaif: typeof zaif;
     zonda: typeof zonda;
 } & typeof functions & typeof errors;
-export { version, Exchange, exchanges, pro, Precise, functions, errors, 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, 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, MarketMarginModes, 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, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitteam, bitvavo, bl3p, blockchaincom, blofin, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbaseadvanced, coinbaseexchange, coinbaseinternational, coincheck, coinex, coinlist, coinmate, coinmetro, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hashkey, hitbtc, hollaex, htx, huobi, huobijp, hyperliquid, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, onetrading, oxfun, p2b, paradex, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, tradeogre, upbit, vertex, wavesexchange, wazirx, whitebit, woo, woofipro, xt, yobit, zaif, zonda, };
+export { version, Exchange, exchanges, pro, Precise, functions, errors, 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, 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, MarketMarginModes, 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, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, LongShortRatio, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers, ace, alpaca, ascendex, bequant, bigone, binance, binancecoinm, binanceus, binanceusdm, bingx, bit2c, bitbank, bitbns, bitcoincom, bitfinex, bitfinex2, bitflyer, bitget, bithumb, bitmart, bitmex, bitopro, bitpanda, bitrue, bitso, bitstamp, bitteam, bitvavo, bl3p, blockchaincom, blofin, btcalpha, btcbox, btcmarkets, btcturk, bybit, cex, coinbase, coinbaseadvanced, coinbaseexchange, coinbaseinternational, coincheck, coinex, coinlist, coinmate, coinmetro, coinone, coinsph, coinspot, cryptocom, currencycom, delta, deribit, digifinex, exmo, fmfwio, gate, gateio, gemini, hashkey, hitbtc, hollaex, htx, huobi, huobijp, hyperliquid, idex, independentreserve, indodax, kraken, krakenfutures, kucoin, kucoinfutures, kuna, latoken, lbank, luno, lykke, mercado, mexc, ndax, novadax, oceanex, okcoin, okx, onetrading, oxfun, p2b, paradex, paymium, phemex, poloniex, poloniexfutures, probit, timex, tokocrypto, tradeogre, upbit, vertex, wavesexchange, wazirx, whitebit, woo, woofipro, xt, yobit, zaif, zonda, };
 export default ccxt;

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.22';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -10,6 +10,7 @@ interface Exchange {
     publicGetGethealth(params?: {}): Promise<implicitReturnType>;
     publicGetGetboardstate(params?: {}): Promise<implicitReturnType>;
     publicGetGetchats(params?: {}): Promise<implicitReturnType>;
+    publicGetGetfundingrate(params?: {}): Promise<implicitReturnType>;
     privateGetGetpermissions(params?: {}): Promise<implicitReturnType>;
     privateGetGetbalance(params?: {}): Promise<implicitReturnType>;
     privateGetGetbalancehistory(params?: {}): Promise<implicitReturnType>;

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

@@ -67,12 +67,14 @@ interface Exchange {
     publicMixGetV2MixMarketCurrentFundRate(params?: {}): Promise<implicitReturnType>;
     publicMixGetV2MixMarketContracts(params?: {}): Promise<implicitReturnType>;
     publicMixGetV2MixMarketQueryPositionLever(params?: {}): Promise<implicitReturnType>;
+    publicMixGetV2MixMarketAccountLongShort(params?: {}): Promise<implicitReturnType>;
     publicMarginGetMarginV1CrossPublicInterestRateAndLimit(params?: {}): Promise<implicitReturnType>;
     publicMarginGetMarginV1IsolatedPublicInterestRateAndLimit(params?: {}): Promise<implicitReturnType>;
     publicMarginGetMarginV1CrossPublicTierData(params?: {}): Promise<implicitReturnType>;
     publicMarginGetMarginV1IsolatedPublicTierData(params?: {}): Promise<implicitReturnType>;
     publicMarginGetMarginV1PublicCurrencies(params?: {}): Promise<implicitReturnType>;
     publicMarginGetV2MarginCurrencies(params?: {}): Promise<implicitReturnType>;
+    publicMarginGetV2MarginMarketLongShortRatio(params?: {}): Promise<implicitReturnType>;
     publicEarnGetV2EarnLoanPublicCoinInfos(params?: {}): Promise<implicitReturnType>;
     publicEarnGetV2EarnLoanPublicHourInterest(params?: {}): Promise<implicitReturnType>;
     privateSpotGetSpotV1WalletDepositAddress(params?: {}): Promise<implicitReturnType>;
@@ -219,6 +221,7 @@ interface Exchange {
     privateMixGetV2MixOrderOrdersHistory(params?: {}): Promise<implicitReturnType>;
     privateMixGetV2MixOrderOrdersPlanPending(params?: {}): Promise<implicitReturnType>;
     privateMixGetV2MixOrderOrdersPlanHistory(params?: {}): Promise<implicitReturnType>;
+    privateMixGetV2MixMarketPositionLongShort(params?: {}): Promise<implicitReturnType>;
     privateMixPostMixV1AccountSubAccountContractAssets(params?: {}): Promise<implicitReturnType>;
     privateMixPostMixV1AccountOpenCount(params?: {}): Promise<implicitReturnType>;
     privateMixPostMixV1AccountSetLeverage(params?: {}): Promise<implicitReturnType>;

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/cex.d.ts

@@ -1,35 +1,34 @@
 import { implicitReturnType } from '../base/types.js';
 import { Exchange as _Exchange } from '../base/Exchange.js';
 interface Exchange {
-    publicGetCurrencyProfile(params?: {}): Promise<implicitReturnType>;
-    publicGetCurrencyLimits(params?: {}): Promise<implicitReturnType>;
-    publicGetLastPricePair(params?: {}): Promise<implicitReturnType>;
-    publicGetLastPricesCurrencies(params?: {}): Promise<implicitReturnType>;
-    publicGetOhlcvHdYyyymmddPair(params?: {}): Promise<implicitReturnType>;
-    publicGetOrderBookPair(params?: {}): Promise<implicitReturnType>;
-    publicGetTickerPair(params?: {}): Promise<implicitReturnType>;
-    publicGetTickersCurrencies(params?: {}): Promise<implicitReturnType>;
-    publicGetTradeHistoryPair(params?: {}): Promise<implicitReturnType>;
-    publicPostConvertPair(params?: {}): Promise<implicitReturnType>;
-    publicPostPriceStatsPair(params?: {}): Promise<implicitReturnType>;
-    privatePostActiveOrdersStatus(params?: {}): Promise<implicitReturnType>;
-    privatePostArchivedOrdersPair(params?: {}): Promise<implicitReturnType>;
-    privatePostBalance(params?: {}): Promise<implicitReturnType>;
-    privatePostCancelOrder(params?: {}): Promise<implicitReturnType>;
-    privatePostCancelOrdersPair(params?: {}): Promise<implicitReturnType>;
-    privatePostCancelReplaceOrderPair(params?: {}): Promise<implicitReturnType>;
-    privatePostClosePositionPair(params?: {}): Promise<implicitReturnType>;
-    privatePostGetAddress(params?: {}): Promise<implicitReturnType>;
-    privatePostGetCryptoAddress(params?: {}): Promise<implicitReturnType>;
-    privatePostGetMyfee(params?: {}): Promise<implicitReturnType>;
-    privatePostGetOrder(params?: {}): Promise<implicitReturnType>;
-    privatePostGetOrderTx(params?: {}): Promise<implicitReturnType>;
-    privatePostOpenOrdersPair(params?: {}): Promise<implicitReturnType>;
-    privatePostOpenOrders(params?: {}): Promise<implicitReturnType>;
-    privatePostOpenPositionPair(params?: {}): Promise<implicitReturnType>;
-    privatePostOpenPositionsPair(params?: {}): Promise<implicitReturnType>;
-    privatePostPlaceOrderPair(params?: {}): Promise<implicitReturnType>;
-    privatePostRawTxHistory(params?: {}): Promise<implicitReturnType>;
+    publicPostGetServerTime(params?: {}): Promise<implicitReturnType>;
+    publicPostGetPairsInfo(params?: {}): Promise<implicitReturnType>;
+    publicPostGetCurrenciesInfo(params?: {}): Promise<implicitReturnType>;
+    publicPostGetProcessingInfo(params?: {}): Promise<implicitReturnType>;
+    publicPostGetTicker(params?: {}): Promise<implicitReturnType>;
+    publicPostGetTradeHistory(params?: {}): Promise<implicitReturnType>;
+    publicPostGetOrderBook(params?: {}): Promise<implicitReturnType>;
+    publicPostGetCandles(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyCurrentFee(params?: {}): Promise<implicitReturnType>;
+    privatePostGetFeeStrategy(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyVolume(params?: {}): Promise<implicitReturnType>;
+    privatePostDoCreateAccount(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyAccountStatusV3(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyWalletBalance(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostDoMyNewOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostDoCancelMyOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostDoCancelAllOrders(params?: {}): Promise<implicitReturnType>;
+    privatePostGetOrderBook(params?: {}): Promise<implicitReturnType>;
+    privatePostGetCandles(params?: {}): Promise<implicitReturnType>;
+    privatePostGetTradeHistory(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyTransactionHistory(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMyFundingHistory(params?: {}): Promise<implicitReturnType>;
+    privatePostDoMyInternalTransfer(params?: {}): Promise<implicitReturnType>;
+    privatePostGetProcessingInfo(params?: {}): Promise<implicitReturnType>;
+    privatePostGetDepositAddress(params?: {}): Promise<implicitReturnType>;
+    privatePostDoDepositFundsFromWallet(params?: {}): Promise<implicitReturnType>;
+    privatePostDoWithdrawalFundsToWallet(params?: {}): Promise<implicitReturnType>;
 }
 declare abstract class Exchange extends _Exchange {
 }

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

@@ -91,8 +91,13 @@ interface Exchange {
     privateUnifiedGetInterestRecords(params?: {}): Promise<implicitReturnType>;
     privateUnifiedGetEstimateRate(params?: {}): Promise<implicitReturnType>;
     privateUnifiedGetCurrencyDiscountTiers(params?: {}): Promise<implicitReturnType>;
+    privateUnifiedGetRiskUnits(params?: {}): Promise<implicitReturnType>;
+    privateUnifiedGetUnifiedMode(params?: {}): Promise<implicitReturnType>;
+    privateUnifiedGetLoanMarginTiers(params?: {}): Promise<implicitReturnType>;
     privateUnifiedPostAccountMode(params?: {}): Promise<implicitReturnType>;
     privateUnifiedPostLoans(params?: {}): Promise<implicitReturnType>;
+    privateUnifiedPostPortfolioCalculator(params?: {}): Promise<implicitReturnType>;
+    privateUnifiedPutUnifiedMode(params?: {}): Promise<implicitReturnType>;
     privateSpotGetFee(params?: {}): Promise<implicitReturnType>;
     privateSpotGetBatchFee(params?: {}): Promise<implicitReturnType>;
     privateSpotGetAccounts(params?: {}): Promise<implicitReturnType>;