ccxt 4.4.20 → 4.4.21

package/js/src/hyperliquid.js

@@ -645,9 +645,9 @@ export default class hyperliquid extends Exchange {
                 const code = this.safeCurrencyCode(this.safeString(balance, 'coin'));
                 const account = this.account();
                 const total = this.safeString(balance, 'total');
-                const free = this.safeString(balance, 'hold');
+                const used = this.safeString(balance, 'hold');
                 account['total'] = total;
-                account['used'] = free;
+                account['used'] = used;
                 spotBalances[code] = account;
             }
             return this.safeBalance(spotBalances);
@@ -656,8 +656,8 @@ export default class hyperliquid extends Exchange {
         const result = {
             'info': response,
             'USDC': {
-                'total': this.safeFloat(data, 'accountValue'),
-                'used': this.safeFloat(data, 'totalMarginUsed'),
+                'total': this.safeNumber(data, 'accountValue'),
+                'free': this.safeNumber(response, 'withdrawable'),
             },
         };
         const timestamp = this.safeInteger(response, 'time');
@@ -2230,10 +2230,11 @@ export default class hyperliquid extends Exchange {
         const leverage = this.safeDict(entry, 'leverage', {});
         const marginMode = this.safeString(leverage, 'type');
         const isIsolated = (marginMode === 'isolated');
-        const size = this.safeNumber(entry, 'szi');
+        let size = this.safeString(entry, 'szi');
         let side = undefined;
         if (size !== undefined) {
-            side = (size > 0) ? 'long' : 'short';
+            side = Precise.stringGt(size, '0') ? 'long' : 'short';
+            size = Precise.stringAbs(size);
         }
         const unrealizedPnl = this.safeNumber(entry, 'unrealizedPnl');
         const initialMargin = this.safeNumber(entry, 'marginUsed');

package/js/src/kucoin.d.ts

@@ -76,7 +76,6 @@ export default class kucoin extends Exchange {
     parseLedgerEntry(item: Dict, currency?: Currency): LedgerEntry;
     fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
-    parseBorrowRateHistory(response: any, code: any, since: any, limit: any): any;
     parseBorrowRate(info: any, currency?: Currency): {
         currency: string;
         rate: number;

package/js/src/kucoin.js

@@ -166,7 +166,8 @@ export default class kucoin extends Exchange {
                         // margin trading
                         'mark-price/{symbol}/current': 3,
                         'mark-price/all-symbols': 3,
-                        'margin/config': 25, // 25SW
+                        'margin/config': 25,
+                        'announcements': 20, // 20W
                     },
                     'post': {
                         // ws
@@ -456,6 +457,7 @@ export default class kucoin extends Exchange {
             'precisionMode': TICK_SIZE,
             'exceptions': {
                 'exact': {
+                    'The order does not exist.': OrderNotFound,
                     'order not exist': OrderNotFound,
                     'order not exist.': OrderNotFound,
                     'order_not_exist': OrderNotFound,
@@ -656,6 +658,7 @@ export default class kucoin extends Exchange {
                             'currencies/{currency}': 'v3',
                             'symbols': 'v2',
                             'mark-price/all-symbols': 'v3',
+                            'announcements': 'v3',
                         },
                     },
                     'private': {
@@ -1544,41 +1547,28 @@ export default class kucoin extends Exchange {
         //        "chain": "ERC20"
         //    }
         //
+        const minWithdrawFee = this.safeNumber(fee, 'withdrawMinFee');
         const result = {
             'info': fee,
             'withdraw': {
+                'fee': minWithdrawFee,
+                'percentage': false,
+            },
+            'deposit': {
                 'fee': undefined,
                 'percentage': undefined,
             },
+            'networks': {},
+        };
+        const networkId = this.safeString(fee, 'chain');
+        const networkCode = this.networkIdToCode(networkId, this.safeString(currency, 'code'));
+        result['networks'][networkCode] = {
+            'withdraw': minWithdrawFee,
             'deposit': {
                 'fee': undefined,
                 'percentage': undefined,
             },
-            'networks': {},
         };
-        const isWithdrawEnabled = this.safeBool(fee, 'isWithdrawEnabled', true);
-        let minFee = undefined;
-        if (isWithdrawEnabled) {
-            result['withdraw']['percentage'] = false;
-            const chains = this.safeList(fee, 'chains', []);
-            for (let i = 0; i < chains.length; i++) {
-                const chain = chains[i];
-                const networkId = this.safeString(chain, 'chainId');
-                const networkCode = this.networkIdToCode(networkId, this.safeString(currency, 'code'));
-                const withdrawFee = this.safeString(chain, 'withdrawalMinFee');
-                if (minFee === undefined || (Precise.stringLt(withdrawFee, minFee))) {
-                    minFee = withdrawFee;
-                }
-                result['networks'][networkCode] = {
-                    'withdraw': this.parseNumber(withdrawFee),
-                    'deposit': {
-                        'fee': undefined,
-                        'percentage': undefined,
-                    },
-                };
-            }
-            result['withdraw']['fee'] = this.parseNumber(minFee);
-        }
         return result;
     }
     isFuturesMethod(methodName, params) {
@@ -3094,7 +3084,7 @@ export default class kucoin extends Exchange {
             },
             'status': status,
             'lastTradeTimestamp': undefined,
-            'average': undefined,
+            'average': this.safeString(order, 'avgDealPrice'),
             'trades': undefined,
         }, market);
     }
@@ -4429,16 +4419,6 @@ export default class kucoin extends Exchange {
         }
         return this.safeValue(config, 'cost', 1);
     }
-    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/kucoinfutures.js

@@ -2220,8 +2220,8 @@ export default class kucoinfutures extends kucoin {
         const amount = this.safeString(order, 'size');
         const filled = this.safeString(order, 'filledSize');
         const cost = this.safeString(order, 'filledValue');
-        let average = undefined;
-        if (Precise.stringGt(filled, '0')) {
+        let average = this.safeString(order, 'avgDealPrice');
+        if ((average === undefined) && Precise.stringGt(filled, '0')) {
             const contractSize = this.safeString(market, 'contractSize');
             if (market['linear']) {
                 average = Precise.stringDiv(cost, Precise.stringMul(contractSize, filled));

package/js/src/okx.d.ts

@@ -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>;

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';
@@ -356,6 +356,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 +890,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 +6684,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

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]>;