ccxt 4.4.20 → 4.4.22

package/js/src/okx.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/okx.js';
-import type { TransferEntry, Int, OrderSide, OrderType, Trade, OHLCV, Order, FundingRateHistory, OrderRequest, FundingHistory, Str, Transaction, Ticker, OrderBook, Balances, Tickers, Market, Greeks, Strings, MarketInterface, Currency, Leverage, Num, Account, OptionChain, Option, MarginModification, TradingFeeInterface, Currencies, Conversion, CancellationRequest, Dict, Position, CrossBorrowRate, CrossBorrowRates, LeverageTier, int, LedgerEntry, FundingRate, DepositAddress } from './base/types.js';
+import type { TransferEntry, Int, OrderSide, OrderType, Trade, OHLCV, Order, FundingRateHistory, OrderRequest, FundingHistory, Str, Transaction, Ticker, OrderBook, Balances, Tickers, Market, Greeks, Strings, MarketInterface, Currency, Leverage, Num, Account, OptionChain, Option, MarginModification, TradingFeeInterface, Currencies, Conversion, CancellationRequest, Dict, Position, CrossBorrowRate, CrossBorrowRates, LeverageTier, int, LedgerEntry, FundingRate, DepositAddress, LongShortRatio } from './base/types.js';
 /**
  * @class okx
  * @augments Exchange
@@ -107,7 +107,6 @@ export default class okx extends Exchange {
         info: any;
     };
     parseBorrowRateHistories(response: any, codes: any, since: any, limit: any): Dict;
-    parseBorrowRateHistory(response: any, code: any, since: any, limit: any): any;
     fetchBorrowRateHistories(codes?: any, since?: Int, limit?: Int, params?: {}): Promise<Dict>;
     fetchBorrowRateHistory(code: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
     modifyMarginHelper(symbol: string, amount: any, type: any, params?: {}): Promise<MarginModification>;
@@ -186,4 +185,6 @@ export default class okx extends Exchange {
     handleErrors(httpCode: int, reason: string, url: string, method: string, headers: Dict, body: string, response: any, requestHeaders: any, requestBody: any): any;
     fetchMarginAdjustmentHistory(symbol?: Str, type?: Str, since?: Num, limit?: Num, params?: {}): Promise<MarginModification[]>;
     fetchPositionsHistory(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    fetchLongShortRatioHistory(symbol?: Str, timeframe?: Str, since?: Int, limit?: Int, params?: {}): Promise<LongShortRatio[]>;
+    parseLongShortRatio(info: Dict, market?: Market): LongShortRatio;
 }

package/js/src/okx.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/okx.js';
-import { ExchangeError, ExchangeNotAvailable, OnMaintenance, ArgumentsRequired, BadRequest, AccountSuspended, InvalidAddress, DDoSProtection, PermissionDenied, InsufficientFunds, InvalidNonce, InvalidOrder, OrderNotFound, AuthenticationError, RequestTimeout, BadSymbol, RateLimitExceeded, NetworkError, CancelPending, NotSupported, AccountNotEnabled, ContractUnavailable, ManualInteractionNeeded } from './base/errors.js';
+import { ExchangeError, ExchangeNotAvailable, OnMaintenance, ArgumentsRequired, BadRequest, AccountSuspended, InvalidAddress, DDoSProtection, PermissionDenied, InsufficientFunds, InvalidNonce, InvalidOrder, OrderNotFound, AuthenticationError, RequestTimeout, BadSymbol, RateLimitExceeded, NetworkError, CancelPending, NotSupported, AccountNotEnabled, ContractUnavailable, ManualInteractionNeeded, OperationRejected } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { TICK_SIZE } from './base/functions/number.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
@@ -96,6 +96,8 @@ export default class okx extends Exchange {
                 'fetchLedgerEntry': undefined,
                 'fetchLeverage': true,
                 'fetchLeverageTiers': false,
+                'fetchLongShortRatio': false,
+                'fetchLongShortRatioHistory': true,
                 'fetchMarginAdjustmentHistory': true,
                 'fetchMarketLeverageTiers': true,
                 'fetchMarkets': true,
@@ -238,6 +240,7 @@ export default class okx extends Exchange {
                         '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
@@ -356,6 +359,9 @@ export default class okx extends Exchange {
                         '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,
@@ -887,6 +893,11 @@ export default class okx extends Exchange {
                     '59301': ExchangeError,
                     '59313': ExchangeError,
                     '59401': ExchangeError,
+                    '59410': OperationRejected,
+                    '59411': InsufficientFunds,
+                    '59412': OperationRejected,
+                    '59413': OperationRejected,
+                    '59414': BadRequest,
                     '59500': ExchangeError,
                     '59501': ExchangeError,
                     '59502': ExchangeError,
@@ -6676,16 +6687,6 @@ export default class okx extends Exchange {
         }
         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
@@ -8502,4 +8503,75 @@ export default class okx extends Exchange {
         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'),
+        };
+    }
 }

package/js/src/paradex.js

@@ -5,7 +5,7 @@
 // EDIT THE CORRESPONDENT .ts FILE INSTEAD
 
 //  ---------------------------------------------------------------------------
-import { Precise } from '../ccxt.js';
+import { Precise } from './base/Precise.js';
 import Exchange from './abstract/paradex.js';
 import { ExchangeError, PermissionDenied, AuthenticationError, BadRequest, ArgumentsRequired, OperationRejected, InvalidOrder } from './base/errors.js';
 import { TICK_SIZE } from './base/functions/number.js';

package/js/src/static_dependencies/noble-hashes/_blake2.js

@@ -97,7 +97,7 @@ export class BLAKE2 extends Hash {
     }
     _cloneInto(to) {
         const { buffer, length, finished, destroyed, outputLen, pos } = this;
-        to || (to = new this.constructor({ dkLen: outputLen }));
+        to ||= new this.constructor({ dkLen: outputLen });
         to.set(...this.get());
         to.length = length;
         to.finished = finished;

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

@@ -105,7 +105,7 @@ export class SHA2 extends 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/js/src/static_dependencies/noble-hashes/hmac.js

@@ -55,7 +55,7 @@ class HMAC extends 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/js/src/static_dependencies/noble-hashes/sha3-addons.js

@@ -113,7 +113,7 @@ class TupleHash extends Keccak {
         super.finish();
     }
     _cloneInto(to) {
-        to || (to = new TupleHash(this.blockLen, this.outputLen, this.enableXOF));
+        to ||= new TupleHash(this.blockLen, this.outputLen, this.enableXOF);
         return super._cloneInto(to);
     }
     clone() {
@@ -142,7 +142,7 @@ class ParallelHash extends Keccak {
         this.chunksDone = 0; // How many chunks we already have
         cshakePers(this, { NISTfn: 'ParallelHash', personalization: opts.personalization });
         let { blockLen: B } = opts;
-        B || (B = 8);
+        B ||= 8;
         assertNumber(B);
         this.chunkLen = B;
         super.update(leftEncode(B));
@@ -179,7 +179,7 @@ class ParallelHash extends Keccak {
         super.finish();
     }
     _cloneInto(to) {
-        to || (to = new ParallelHash(this.blockLen, this.outputLen, this.leafCons, this.enableXOF));
+        to ||= new ParallelHash(this.blockLen, this.outputLen, this.leafCons, this.enableXOF);
         if (this.leafHash)
             to.leafHash = this.leafHash._cloneInto(to.leafHash);
         to.chunkPos = this.chunkPos;
@@ -273,7 +273,7 @@ class KangarooTwelve extends Keccak {
     }
     _cloneInto(to) {
         const { blockLen, leafLen, leafHash, outputLen, rounds } = this;
-        to || (to = new KangarooTwelve(blockLen, leafLen, outputLen, rounds, {}));
+        to ||= new KangarooTwelve(blockLen, leafLen, outputLen, rounds, {});
         super._cloneInto(to);
         if (leafHash)
             to.leafHash = leafHash._cloneInto(to.leafHash);
@@ -340,7 +340,7 @@ class KeccakPRG extends Keccak {
     }
     _cloneInto(to) {
         const { rate } = this;
-        to || (to = new KeccakPRG(1600 - rate));
+        to ||= new KeccakPRG(1600 - rate);
         super._cloneInto(to);
         to.rate = rate;
         return to;

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

@@ -175,7 +175,7 @@ export class Keccak extends 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/js/src/static_dependencies/watchable/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Unpromise } from "./unpromise";
+export type { ProxyPromise, SubscribedPromise, PromiseExecutor, PromiseWithResolvers, } from "./types";

package/js/src/static_dependencies/watchable/src/index.js

@@ -0,0 +1,7 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+export { Unpromise } from "./unpromise";

package/js/src/static_dependencies/watchable/src/types.d.ts

@@ -0,0 +1,28 @@
+/** TYPES */
+/** A promise that exploits a single, memory-safe upstream subscription
+ * to a single re-used Unpromise that persists for the VM lifetime of a
+ * Promise.
+ *
+ * Calling unsubscribe() removes the subscription, eliminating
+ * all references to the SubscribedPromise. */
+export interface SubscribedPromise<T> extends Promise<T> {
+    unsubscribe: () => void;
+}
+/** Duplicate of Promise interface, except each call returns SubscribedPromise */
+export interface ProxyPromise<T> extends Promise<T> {
+    subscribe: () => SubscribedPromise<T>;
+    then: <TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => SubscribedPromise<TResult1 | TResult2>;
+    catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => SubscribedPromise<T | TResult>;
+    finally: (onfinally?: (() => void) | null | undefined) => SubscribedPromise<T>;
+}
+export declare type PromiseExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
+/** A standard pattern for a resolvable, rejectable Promise, based
+ * on the emerging ES2023 standard. Type ported from
+ * https://github.com/microsoft/TypeScript/pull/56593 */
+export interface PromiseWithResolvers<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+/** Given an array, this is the union of its members' types. */
+export declare type MemberOf<Arr extends readonly unknown[]> = Arr[number];

package/js/src/static_dependencies/watchable/src/types.js

@@ -0,0 +1,8 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/** TYPES */
+export {};

package/js/src/static_dependencies/watchable/src/unpromise.d.ts

@@ -0,0 +1,120 @@
+import type { PromiseExecutor, PromiseWithResolvers, ProxyPromise, SubscribedPromise } from "./types";
+/**
+ * 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!
+ *
+ */
+export declare class Unpromise<T> implements ProxyPromise<T> {
+    /** INSTANCE IMPLEMENTATION */
+    /** The promise shadowed by this Unpromise<T>  */
+    protected readonly promise: Promise<T> | PromiseLike<T>;
+    /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
+     * after the original promise settles - no further notifications will be issued. */
+    protected subscribers: ReadonlyArray<PromiseWithResolvers<T>> | null;
+    /** 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. */
+    protected settlement: PromiseSettledResult<T> | null;
+    /** Constructor accepts a normal Promise executor function like `new
+     * Unpromise((resolve, reject) => {...})` or accepts a pre-existing Promise
+     * like `new Unpromise(existingPromise)`. Adds `.then()` and `.catch()`
+     * handlers to the Promise. These handlers pass fulfilment and rejection
+     * notifications to downstream subscribers and maintains records of value
+     * or error if the Promise ever settles. */
+    protected constructor(promise: Promise<T>);
+    protected constructor(promise: PromiseLike<T>);
+    protected constructor(executor: PromiseExecutor<T>);
+    /** 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(): SubscribedPromise<T>;
+    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): SubscribedPromise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): SubscribedPromise<T | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): SubscribedPromise<T>;
+    /** TOSTRING SUPPORT */
+    readonly [Symbol.toStringTag] = "Unpromise";
+    /** Unpromise STATIC METHODS */
+    /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
+     * of the provided Promise reference) */
+    static proxy<T>(promise: PromiseLike<T>): ProxyPromise<T>;
+    /** Create and store an Unpromise keyed by an original Promise. */
+    protected static createSubscribablePromise<T>(promise: PromiseLike<T>): Unpromise<T>;
+    /** Retrieve a previously-created Unpromise keyed by an original Promise. */
+    protected static getSubscribablePromise<T>(promise: PromiseLike<T>): ProxyPromise<T>;
+    /** 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<T>(value: T | PromiseLike<T>): SubscribedPromise<Awaited<T>>;
+    /** Perform Promise.any() via SubscribedPromises, then unsubscribe them.
+     * Equivalent to Promise.any but eliminates memory leaks from long-lived
+     * promises accumulating .then() and .catch() subscribers. */
+    static any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+    /** Perform Promise.race via SubscribedPromises, then unsubscribe them.
+     * Equivalent to Promise.race but eliminates memory leaks from long-lived
+     * promises accumulating .then() and .catch() subscribers. */
+    static race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+    /** 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 raceReferences<P extends Promise<unknown>>(promises: readonly P[]): Promise<readonly [P]>;
+}
+/** 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.
+ * */
+export declare function resolveSelfTuple<P extends Promise<unknown>>(promise: P): SubscribedPromise<readonly [P]>;