ccxt-ir 4.9.32 → 4.11.0

package/js/src/src/static_dependencies/starknet/utils/shortString.js

@@ -0,0 +1,96 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+import { TEXT_TO_FELT_MAX_LEN } from '../constants.js';
+import { addHexPrefix, removeHexPrefix } from './encode.js';
+import { isHex, isStringWholeNumber } from './num.js';
+/**
+ * Test if string contains only ASCII characters (string can be ascii text)
+ */
+export function isASCII(str) {
+    // eslint-disable-next-line no-control-regex
+    return /^[\x00-\x7F]*$/.test(str);
+}
+/**
+ * Test if string is a Cairo short string (string has less or equal 31 characters)
+ */
+export function isShortString(str) {
+    return str.length <= TEXT_TO_FELT_MAX_LEN;
+}
+/**
+ * Test if string contains only numbers (string can be converted to decimal number)
+ */
+export function isDecimalString(str) {
+    return /^[0-9]*$/i.test(str);
+}
+/**
+ * Checks if a given value is a string.
+ *
+ * @param {unknown} value - The value to be checked.
+ * @return {boolean} - Returns true if the value is a string, false otherwise.
+ */
+export function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Test if value is a free-from string text, and not a hex string or number string
+ */
+export function isText(val) {
+    return isString(val) && !isHex(val) && !isStringWholeNumber(val);
+}
+/**
+ * Test if value is short text
+ */
+export const isShortText = (val) => isText(val) && isShortString(val);
+/**
+ * Test if value is long text
+ */
+export const isLongText = (val) => isText(val) && !isShortString(val);
+/**
+ * Split long text into short strings
+ */
+export function splitLongString(longStr) {
+    const regex = RegExp(`[^]{1,${TEXT_TO_FELT_MAX_LEN}}`, 'g');
+    return longStr.match(regex) || [];
+}
+/**
+ * Convert an ASCII string to a hexadecimal string.
+ * @param str short string (ASCII string, 31 characters max)
+ * @returns format: hex-string; 248 bits max
+ * @example
+ * ```typescript
+ * const myEncodedString: string = encodeShortString("uri/pict/t38.jpg");
+ * // return hex string (ex."0x7572692f706963742f7433382e6a7067")
+ * ```
+ */
+export function encodeShortString(str) {
+    if (!isASCII(str))
+        throw new Error(`${str} is not an ASCII string`);
+    if (!isShortString(str))
+        throw new Error(`${str} is too long`);
+    return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+}
+/**
+ * Convert a hexadecimal or decimal string to an ASCII string.
+ * @param str representing a 248 bit max number (ex. "0x1A4F64EA56" or "236942575435676423")
+ * @returns format: short string; 31 characters max
+ * @example
+ * ```typescript
+ * const myDecodedString: string = decodeShortString("0x7572692f706963742f7433382e6a7067");
+ * // return string (ex."uri/pict/t38.jpg")
+ * ```
+ */
+export function decodeShortString(str) {
+    if (!isASCII(str))
+        throw new Error(`${str} is not an ASCII string`);
+    if (isHex(str)) {
+        return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    if (isDecimalString(str)) {
+        return decodeShortString('0X'.concat(BigInt(str).toString(16)));
+    }
+    throw new Error(`${str} is not Hex or decimal`);
+}

package/js/src/src/static_dependencies/starknet/utils/typedData.d.ts

@@ -0,0 +1,54 @@
+import { BigNumberish, TypedDataRevision as Revision, StarknetMerkleType, StarknetType, TypedData } from '../types/index.js';
+/** @deprecated prefer importing from 'types' over 'typedData' */
+interface Context {
+    parent?: string;
+    key?: string;
+}
+/**
+ * Prepares the selector for use.
+ *
+ * @param {string} selector - The selector to be prepared.
+ * @returns {string} The prepared selector.
+ */
+export declare function prepareSelector(selector: string): string;
+/**
+ * Checks if the given Starknet type is a Merkle tree type.
+ *
+ * @param {StarknetType} type - The StarkNet type to check.
+ *
+ * @returns {boolean} - True if the type is a Merkle tree type, false otherwise.
+ */
+export declare function isMerkleTreeType(type: StarknetType): type is StarknetMerkleType;
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ */
+export declare function getDependencies(types: TypedData['types'], type: string, dependencies?: string[], contains?: string, revision?: Revision): string[];
+/**
+ * Encode a type to a string. All dependent types are alphabetically sorted.
+ */
+export declare function encodeType(types: TypedData['types'], type: string, revision?: Revision): string;
+/**
+ * Get a type string as hash.
+ */
+export declare function getTypeHash(types: TypedData['types'], type: string, revision?: Revision): string;
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ */
+export declare function encodeValue(types: TypedData['types'], type: string, data: unknown, ctx?: Context, revision?: Revision): [string, string];
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export declare function encodeData<T extends TypedData>(types: T['types'], type: string, data: T['message'], revision?: Revision): string[][];
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export declare function getStructHash<T extends TypedData>(types: T['types'], type: string, data: T['message'], revision?: Revision): string;
+/**
+ * Get the SNIP-12 encoded message to sign, from the typedData object.
+ */
+export declare function getMessageHash(typedData: TypedData, account: BigNumberish): string;
+export {};

package/js/src/src/static_dependencies/starknet/utils/typedData.js

@@ -0,0 +1,321 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/* eslint-disable no-param-reassign */
+import { PRIME, RANGE_FELT, RANGE_I128, RANGE_U128 } from '../constants.js';
+import { TypedDataRevision as Revision, } from '../types/index.js';
+import assert from './assert.js';
+import { byteArrayFromString } from './calldata/byteArray.js';
+import { computePedersenHash, computePedersenHashOnElements, computePoseidonHash, computePoseidonHashOnElements, getSelectorFromName, } from './hash/index.js';
+import { MerkleTree } from './merkle.js';
+import { isHex, toHex } from './num.js';
+import { encodeShortString, isString } from './shortString.js';
+const presetTypes = {
+    u256: JSON.parse('[{ "name": "low", "type": "u128" }, { "name": "high", "type": "u128" }]'),
+    TokenAmount: JSON.parse('[{ "name": "token_address", "type": "ContractAddress" }, { "name": "amount", "type": "u256" }]'),
+    NftId: JSON.parse('[{ "name": "collection_address", "type": "ContractAddress" }, { "name": "token_id", "type": "u256" }]'),
+};
+const revisionConfiguration = {
+    [Revision.Active]: {
+        domain: 'StarknetDomain',
+        hashMethod: computePoseidonHashOnElements,
+        hashMerkleMethod: computePoseidonHash,
+        escapeTypeString: (s) => `"${s}"`,
+        presetTypes,
+    },
+    [Revision.Legacy]: {
+        domain: 'StarkNetDomain',
+        hashMethod: computePedersenHashOnElements,
+        hashMerkleMethod: computePedersenHash,
+        escapeTypeString: (s) => s,
+        presetTypes: {},
+    },
+};
+function assertRange(data, type, { min, max }) {
+    const value = BigInt(data);
+    assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
+}
+function identifyRevision({ types, domain }) {
+    if (revisionConfiguration[Revision.Active].domain in types && domain.revision === Revision.Active)
+        return Revision.Active;
+    if (revisionConfiguration[Revision.Legacy].domain in types &&
+        (domain.revision ?? Revision.Legacy) === Revision.Legacy)
+        return Revision.Legacy;
+    return undefined;
+}
+function getHex(value) {
+    try {
+        return toHex(value);
+    }
+    catch (e) {
+        if (isString(value)) {
+            return toHex(encodeShortString(value));
+        }
+        throw new Error(`Invalid BigNumberish: ${value}`);
+    }
+}
+/**
+ * Validates that `data` matches the EIP-712 JSON schema.
+ */
+function validateTypedData(data) {
+    const typedData = data;
+    return Boolean(typedData.message && typedData.primaryType && typedData.types && identifyRevision(typedData));
+}
+/**
+ * Prepares the selector for use.
+ *
+ * @param {string} selector - The selector to be prepared.
+ * @returns {string} The prepared selector.
+ */
+export function prepareSelector(selector) {
+    return isHex(selector) ? selector : getSelectorFromName(selector);
+}
+/**
+ * Checks if the given Starknet type is a Merkle tree type.
+ *
+ * @param {StarknetType} type - The StarkNet type to check.
+ *
+ * @returns {boolean} - True if the type is a Merkle tree type, false otherwise.
+ */
+export function isMerkleTreeType(type) {
+    return type.type === 'merkletree';
+}
+/**
+ * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
+ * in the resulting array.
+ */
+export function getDependencies(types, type, dependencies = [], contains = '', revision = Revision.Legacy) {
+    // Include pointers (struct arrays)
+    if (type[type.length - 1] === '*') {
+        type = type.slice(0, -1);
+    }
+    else if (revision === Revision.Active) {
+        // enum base
+        if (type === 'enum') {
+            type = contains;
+        }
+        // enum element types
+        else if (type.match(/^\(.*\)$/)) {
+            type = type.slice(1, -1);
+        }
+    }
+    if (dependencies.includes(type) || !types[type]) {
+        return dependencies;
+    }
+    return [
+        type,
+        ...types[type].reduce((previous, t) => [
+            ...previous,
+            ...getDependencies(types, t.type, previous, t.contains, revision).filter((dependency) => !previous.includes(dependency)),
+        ], []),
+    ];
+}
+function getMerkleTreeType(types, ctx) {
+    if (ctx.parent && ctx.key) {
+        const parentType = types[ctx.parent];
+        const merkleType = parentType.find((t) => t.name === ctx.key);
+        const isMerkleTree = isMerkleTreeType(merkleType);
+        if (!isMerkleTree) {
+            throw new Error(`${ctx.key} is not a merkle tree`);
+        }
+        if (merkleType.contains.endsWith('*')) {
+            throw new Error(`Merkle tree contain property must not be an array but was given ${ctx.key}`);
+        }
+        return merkleType.contains;
+    }
+    return 'raw';
+}
+/**
+ * Encode a type to a string. All dependent types are alphabetically sorted.
+ */
+export function encodeType(types, type, revision = Revision.Legacy) {
+    const allTypes = revision === Revision.Active
+        ? { ...types, ...revisionConfiguration[revision].presetTypes }
+        : types;
+    const [primary, ...dependencies] = getDependencies(allTypes, type, undefined, undefined, revision);
+    const newTypes = !primary ? [] : [primary, ...dependencies.sort()];
+    const esc = revisionConfiguration[revision].escapeTypeString;
+    return newTypes
+        .map((dependency) => {
+        const dependencyElements = allTypes[dependency].map((t) => {
+            const targetType = t.type === 'enum' && revision === Revision.Active
+                ? t.contains
+                : t.type;
+            // parentheses handling for enum variant types
+            const typeString = targetType.match(/^\(.*\)$/)
+                ? `(${targetType
+                    .slice(1, -1)
+                    .split(',')
+                    .map((e) => (e ? esc(e) : e))
+                    .join(',')})`
+                : esc(targetType);
+            return `${esc(t.name)}:${typeString}`;
+        });
+        return `${esc(dependency)}(${dependencyElements})`;
+    })
+        .join('');
+}
+/**
+ * Get a type string as hash.
+ */
+export function getTypeHash(types, type, revision = Revision.Legacy) {
+    return getSelectorFromName(encodeType(types, type, revision));
+}
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ */
+export function encodeValue(types, type, data, ctx = {}, revision = Revision.Legacy) {
+    if (types[type]) {
+        return [type, getStructHash(types, type, data, revision)];
+    }
+    if (revisionConfiguration[revision].presetTypes[type]) {
+        return [
+            type,
+            getStructHash(revisionConfiguration[revision].presetTypes, type, data, revision),
+        ];
+    }
+    if (type.endsWith('*')) {
+        const hashes = data.map((entry) => encodeValue(types, type.slice(0, -1), entry, undefined, revision)[1]);
+        return [type, revisionConfiguration[revision].hashMethod(hashes)];
+    }
+    switch (type) {
+        case 'enum': {
+            if (revision === Revision.Active) {
+                const [variantKey, variantData] = Object.entries(data)[0];
+                const parentType = types[ctx.parent][0];
+                const enumType = types[parentType.contains];
+                const variantType = enumType.find((t) => t.name === variantKey);
+                const variantIndex = enumType.indexOf(variantType);
+                const encodedSubtypes = variantType.type
+                    .slice(1, -1)
+                    .split(',')
+                    .map((subtype, index) => {
+                    if (!subtype)
+                        return subtype;
+                    const subtypeData = variantData[index];
+                    return encodeValue(types, subtype, subtypeData, undefined, revision)[1];
+                });
+                return [
+                    type,
+                    revisionConfiguration[revision].hashMethod([variantIndex, ...encodedSubtypes]),
+                ];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'merkletree': {
+            const merkleTreeType = getMerkleTreeType(types, ctx);
+            const structHashes = data.map((struct) => {
+                return encodeValue(types, merkleTreeType, struct, undefined, revision)[1];
+            });
+            const { root } = new MerkleTree(structHashes, revisionConfiguration[revision].hashMerkleMethod);
+            return ['felt', root];
+        }
+        case 'selector': {
+            return ['felt', prepareSelector(data)];
+        }
+        case 'string': {
+            if (revision === Revision.Active) {
+                const byteArray = byteArrayFromString(data);
+                const elements = [
+                    byteArray.data.length,
+                    ...byteArray.data,
+                    byteArray.pending_word,
+                    byteArray.pending_word_len,
+                ];
+                return [type, revisionConfiguration[revision].hashMethod(elements)];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'i128': {
+            if (revision === Revision.Active) {
+                const value = BigInt(data);
+                assertRange(value, type, RANGE_I128);
+                return [type, getHex(value < 0n ? PRIME + value : value)];
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'timestamp':
+        case 'u128': {
+            if (revision === Revision.Active) {
+                assertRange(data, type, RANGE_U128);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'felt':
+        case 'shortstring': {
+            // TODO: should 'shortstring' diverge into directly using encodeShortString()?
+            if (revision === Revision.Active) {
+                assertRange(getHex(data), type, RANGE_FELT);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'ClassHash':
+        case 'ContractAddress': {
+            if (revision === Revision.Active) {
+                assertRange(data, type, RANGE_FELT);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        case 'bool': {
+            if (revision === Revision.Active) {
+                assert(typeof data === 'boolean', `Type mismatch for ${type} ${data}`);
+            } // else fall through to default
+            return [type, getHex(data)];
+        }
+        default: {
+            if (revision === Revision.Active) {
+                throw new Error(`Unsupported type: ${type}`);
+            }
+            return [type, getHex(data)];
+        }
+    }
+}
+/**
+ * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export function encodeData(types, type, data, revision = Revision.Legacy) {
+    const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
+    const [returnTypes, values] = targetType.reduce(([ts, vs], field) => {
+        if (data[field.name] === undefined ||
+            (data[field.name] === null && field.type !== 'enum')) {
+            throw new Error(`Cannot encode data: missing data for '${field.name}'`);
+        }
+        const value = data[field.name];
+        const ctx = { parent: type, key: field.name };
+        const [t, encodedValue] = encodeValue(types, field.type, value, ctx, revision);
+        return [
+            [...ts, t],
+            [...vs, encodedValue],
+        ];
+    }, [['felt'], [getTypeHash(types, type, revision)]]);
+    return [returnTypes, values];
+}
+/**
+ * Get encoded data as a hash. The data should be a key -> value object with all the required values.
+ * All dependent types are automatically encoded.
+ */
+export function getStructHash(types, type, data, revision = Revision.Legacy) {
+    return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
+}
+/**
+ * Get the SNIP-12 encoded message to sign, from the typedData object.
+ */
+export function getMessageHash(typedData, account) {
+    if (!validateTypedData(typedData)) {
+        throw new Error('Typed data does not match JSON schema');
+    }
+    const revision = identifyRevision(typedData);
+    const { domain, hashMethod } = revisionConfiguration[revision];
+    const message = [
+        encodeShortString('StarkNet Message'),
+        getStructHash(typedData.types, domain, typedData.domain, revision),
+        account,
+        getStructHash(typedData.types, typedData.primaryType, typedData.message, revision),
+    ];
+    return hashMethod(message);
+}

package/js/src/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/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/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]>;