coinbase-api 0.3.2 → 1.0.1

package/dist/mjs/lib/jwtNode.d.ts

@@ -0,0 +1,13 @@
+interface JWTSignParams {
+    algorithm: 'ES256';
+    timestampMs: number;
+    jwtExpiresSeconds: number;
+    apiPubKey: string;
+    apiPrivKey: string;
+}
+export declare function signJWT(params: {
+    url: string;
+    method: string;
+} & JWTSignParams): string;
+export declare function signWSJWT(params: JWTSignParams): string;
+export {};

package/dist/mjs/lib/jwtNode.js

@@ -0,0 +1,45 @@
+import jwt from 'jsonwebtoken';
+import { nanoid } from 'nanoid';
+export function signJWT(params) {
+    const { url, method, algorithm, timestampMs, jwtExpiresSeconds, apiPrivKey, apiPubKey, } = params;
+    // Remove https:// but keep the rest
+    const urlWithEndpoint = url.slice(8);
+    const uri = `${method} ${urlWithEndpoint}`;
+    const payload = {
+        iss: 'cdp',
+        nbf: Math.floor(timestampMs / 1000),
+        exp: Math.floor(timestampMs / 1000) + jwtExpiresSeconds,
+        sub: apiPubKey,
+        uri,
+    };
+    const header = {
+        alg: algorithm,
+        kid: apiPubKey,
+        nonce: nanoid(16),
+    };
+    const options = {
+        algorithm: algorithm,
+        header: header,
+    };
+    return jwt.sign(payload, apiPrivKey, options);
+}
+export function signWSJWT(params) {
+    const { algorithm, timestampMs, jwtExpiresSeconds, apiPrivKey, apiPubKey } = params;
+    const payload = {
+        iss: 'cdp',
+        nbf: Math.floor(timestampMs / 1000),
+        exp: Math.floor(timestampMs / 1000) + jwtExpiresSeconds,
+        sub: apiPubKey,
+    };
+    const header = {
+        alg: algorithm,
+        kid: apiPubKey,
+        nonce: nanoid(16),
+    };
+    const options = {
+        algorithm: algorithm,
+        header: header,
+    };
+    return jwt.sign(payload, apiPrivKey, options);
+}
+//# sourceMappingURL=jwtNode.js.map

package/dist/mjs/lib/jwtNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwtNode.js","sourceRoot":"","sources":["../../../src/lib/jwtNode.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAUhC,MAAM,UAAU,OAAO,CACrB,MAGiB;IAEjB,MAAM,EACJ,GAAG,EACH,MAAM,EACN,SAAS,EACT,WAAW,EACX,iBAAiB,EACjB,UAAU,EACV,SAAS,GACV,GAAG,MAAM,CAAC;IAEX,oCAAoC;IACpC,MAAM,eAAe,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACrC,MAAM,GAAG,GAAG,GAAG,MAAM,IAAI,eAAe,EAAE,CAAC;IAE3C,MAAM,OAAO,GAAG;QACd,GAAG,EAAE,KAAK;QACV,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC;QACnC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,iBAAiB;QACvD,GAAG,EAAE,SAAS;QACd,GAAG;KACJ,CAAC;IAEF,MAAM,MAAM,GAAG;QACb,GAAG,EAAE,SAAS;QACd,GAAG,EAAE,SAAS;QACd,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC;KAClB,CAAC;IAEF,MAAM,OAAO,GAAoB;QAC/B,SAAS,EAAE,SAA0B;QACrC,MAAM,EAAE,MAAM;KACf,CAAC;IAEF,OAAO,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,MAAqB;IAC7C,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,iBAAiB,EAAE,UAAU,EAAE,SAAS,EAAE,GACxE,MAAM,CAAC;IACT,MAAM,OAAO,GAAG;QACd,GAAG,EAAE,KAAK;QACV,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC;QACnC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,iBAAiB;QACvD,GAAG,EAAE,SAAS;KACf,CAAC;IAEF,MAAM,MAAM,GAAG;QACb,GAAG,EAAE,SAAS;QACd,GAAG,EAAE,SAAS;QACd,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC;KAClB,CAAC;IAEF,MAAM,OAAO,GAAoB;QAC/B,SAAS,EAAE,SAA0B;QACrC,MAAM,EAAE,MAAM;KACf,CAAC;IAEF,OAAO,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AAChD,CAAC"}

package/dist/mjs/lib/misc-util.d.ts

@@ -0,0 +1 @@
+export declare function neverGuard(x: never, msg: string): Error;

package/dist/mjs/lib/misc-util.js

@@ -0,0 +1,4 @@
+export function neverGuard(x, msg) {
+    return new Error(`Unhandled value exception "${x}", ${msg}`);
+}
+//# sourceMappingURL=misc-util.js.map

package/dist/mjs/lib/misc-util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc-util.js","sourceRoot":"","sources":["../../../src/lib/misc-util.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,UAAU,CAAC,CAAQ,EAAE,GAAW;IAC9C,OAAO,IAAI,KAAK,CAAC,8BAA8B,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAC/D,CAAC"}

package/dist/mjs/lib/requestUtils.d.ts

@@ -0,0 +1,98 @@
+import { CustomOrderIdProperty } from '../types/shared.types.js';
+/**
+ * Used to switch how authentication/requests work under the hood
+ */
+export declare const REST_CLIENT_TYPE_ENUM: {
+    /** Coinbase Advanced Trade API */
+    readonly advancedTrade: "advancedTrade";
+    /** Coinbase App API */
+    readonly coinbaseApp: "coinbaseApp";
+    /** Coinbase Exchange API */
+    readonly exchange: "exchange";
+    /** Coinbase Prime API */
+    readonly prime: "prime";
+    /** Coinbase International API */
+    readonly international: "international";
+    /** Coinbase Commerce API */
+    readonly commerce: "commerce";
+};
+export type RestClientType = (typeof REST_CLIENT_TYPE_ENUM)[keyof typeof REST_CLIENT_TYPE_ENUM];
+export interface RestClientOptions {
+    /**
+     * Your API key name.
+     *
+     * - For the Advanced Trade or App APIs, this is your API Key Name.
+     */
+    apiKey?: string;
+    /**
+     * Your API key secret.
+     *
+     * - For the Advanced Trade or App APIs, this is your API private key (including the -----BEGIN EC PRIVATE KEY-----\n etc).
+     */
+    apiSecret?: string;
+    /**
+     * Your API passphrase (NOT your account password). Only used for the API groups that use an API passphrase:
+     * - Coinbase Exchange API
+     * - Coinbase International API
+     * - Coinbase Prime API
+     */
+    apiPassphrase?: string;
+    /**
+     * For the Advanced Trade or App APIs, instead of passing the key name and
+     * private key, you can also parse the exported "cdp_api_key.json" into an object and pass it here.
+     *
+     * It will automatically get parsed into the apiKey & apiSecret configuration parameters.
+     */
+    cdpApiKey?: {
+        name: string;
+        privateKey: string;
+    };
+    /**
+     * https://docs.cdp.coinbase.com/coinbase-app/docs/localization
+     *
+     * The Coinbase App API supports localization for error messages and other strings.
+     * Localization is defined in each request with Accept-Language header.
+     *
+     * Accepted values are currently as below. Note: this may not work for all coinbase product groups.
+     */
+    localisation?: 'de' | 'en' | 'es' | 'es-mx' | 'fr' | 'id' | 'it' | 'nl' | 'pt' | 'pt-br';
+    /**
+     * Connect to the sandbox for supported products
+     *
+     * - Coinbase Exchange: https://docs.cdp.coinbase.com/exchange/docs/sandbox
+     * - Coinbase International: https://docs.cdp.coinbase.com/intx/docs/sandbox
+     *
+     * - Coinbase App: No sandbox available.
+     * - Coinbase Advanced Trade: No sandbox available.
+     * - Coinbase Prime: No sandbox available.
+     */
+    useSandbox?: boolean;
+    /**
+     * Enable keep alive for REST API requests (via axios).
+     * See: https://github.com/tiagosiebler/bybit-api/issues/368
+     */
+    keepAlive?: boolean;
+    /**
+     * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
+     * Only relevant if keepAlive is set to true.
+     * Default: 1000 (defaults comes from https agent)
+     */
+    keepAliveMsecs?: number;
+    /**
+     * For JWT auth (adv trade & app API), seconds until jwt expires. Defaults to 120 seconds.
+     */
+    jwtExpiresSeconds?: number;
+    /** Default: false. If true, we'll throw errors if any params are undefined */
+    strictParamValidation?: boolean;
+    /**
+     * Optionally override API protocol + domain
+     * e.g baseUrl: 'https://api.differentUrl.com'
+     **/
+    baseUrl?: string;
+    /** Default: true. whether to try and post-process request exceptions (and throw them). */
+    parseExceptions?: boolean;
+}
+export declare function serializeParams<T extends Record<string, any> | undefined = {}>(params: T, strict_validation: boolean | undefined, encodeValues: boolean, prefixWith: string): string;
+export declare const APIIDPrefix = "cbnode";
+export declare function logInvalidOrderId(orderIdProperty: CustomOrderIdProperty, expectedOrderIdPrefix: string, params: unknown): void;
+export declare function getRestBaseUrl(restClientOptions: RestClientOptions, restClientType: RestClientType): string;

package/dist/mjs/lib/requestUtils.js

@@ -0,0 +1,69 @@
+/**
+ * Used to switch how authentication/requests work under the hood
+ */
+export const REST_CLIENT_TYPE_ENUM = {
+    /** Coinbase Advanced Trade API */
+    advancedTrade: 'advancedTrade',
+    /** Coinbase App API */
+    coinbaseApp: 'coinbaseApp',
+    /** Coinbase Exchange API */
+    exchange: 'exchange',
+    /** Coinbase Prime API */
+    prime: 'prime',
+    /** Coinbase International API */
+    international: 'international',
+    /** Coinbase Commerce API */
+    commerce: 'commerce',
+};
+const exchangeBaseURLMap = {
+    [REST_CLIENT_TYPE_ENUM.advancedTrade]: 'https://api.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.coinbaseApp]: 'https://api.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.exchange]: 'https://api.exchange.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.prime]: 'https://api.prime.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.international]: 'https://api.international.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.commerce]: 'https://api.commerce.coinbase.com',
+};
+const exchangeSandboxURLMap = {
+    [REST_CLIENT_TYPE_ENUM.exchange]: 'https://api-public.sandbox.exchange.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.international]: 'https://api-n5e1.coinbase.com',
+    [REST_CLIENT_TYPE_ENUM.advancedTrade]: 'NoSandboxAvailable',
+    [REST_CLIENT_TYPE_ENUM.coinbaseApp]: 'NoSandboxAvailable',
+    [REST_CLIENT_TYPE_ENUM.prime]: 'NoSandboxAvailable',
+    [REST_CLIENT_TYPE_ENUM.commerce]: 'NoSandboxAvailable',
+};
+export function serializeParams(params, strict_validation, encodeValues, prefixWith) {
+    if (!params) {
+        return '';
+    }
+    const queryString = Object.keys(params)
+        .sort()
+        .map((key) => {
+        const value = params[key];
+        if (strict_validation === true && typeof value === 'undefined') {
+            throw new Error('Failed to sign API request due to undefined parameter');
+        }
+        const encodedValue = encodeValues ? encodeURIComponent(value) : value;
+        return `${key}=${encodedValue}`;
+    })
+        .join('&');
+    // Only prefix if there's a value
+    return queryString ? prefixWith + queryString : queryString;
+}
+export const APIIDPrefix = 'cbnode';
+export function logInvalidOrderId(orderIdProperty, expectedOrderIdPrefix, params) {
+    console.error(`'${orderIdProperty}' must be prefixed with ${expectedOrderIdPrefix}. Use the 'client.generateNewOrderId()' REST client utility method to generate a fresh order ID on demand. Original request: ${JSON.stringify(params)}`);
+}
+export function getRestBaseUrl(restClientOptions, restClientType) {
+    const exchangeBaseUrls = {
+        livenet: exchangeBaseURLMap[restClientType],
+        testnet: exchangeSandboxURLMap[restClientType],
+    };
+    if (restClientOptions.baseUrl) {
+        return restClientOptions.baseUrl;
+    }
+    if (restClientOptions.useSandbox === true) {
+        return exchangeBaseUrls.testnet;
+    }
+    return exchangeBaseUrls.livenet;
+}
+//# sourceMappingURL=requestUtils.js.map

package/dist/mjs/lib/requestUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestUtils.js","sourceRoot":"","sources":["../../../src/lib/requestUtils.ts"],"names":[],"mappings":"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"}

package/dist/mjs/lib/webCryptoAPI.d.ts

@@ -0,0 +1,10 @@
+export type SignEncodeMethod = 'hex' | 'base64';
+export type SignAlgorithm = 'SHA-256' | 'SHA-512';
+/**
+ * Similar to node crypto's `createHash()` function
+ */
+export declare function hashMessage(message: string, method: SignEncodeMethod, algorithm: SignAlgorithm): Promise<string>;
+/**
+ * Sign a message, with a secret, using the Web Crypto API
+ */
+export declare function signMessage(message: string, secret: string, method: SignEncodeMethod, algorithm: SignAlgorithm, secretEncodeMethod: 'base64:web' | 'utf'): Promise<string>;

package/dist/mjs/lib/webCryptoAPI.js

@@ -0,0 +1,79 @@
+import { neverGuard } from './misc-util.js';
+function bufferToB64(buffer) {
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return globalThis.btoa(binary);
+}
+function b64StringToBuffer(input) {
+    const binaryString = atob(input); // Decode base64 string
+    const buffer = new Uint8Array(binaryString.length);
+    // Convert binary string to a Uint8Array
+    for (let i = 0; i < binaryString.length; i++) {
+        buffer[i] = binaryString.charCodeAt(i);
+    }
+    return buffer;
+}
+/**
+ * Similar to node crypto's `createHash()` function
+ */
+export async function hashMessage(message, method, algorithm) {
+    const encoder = new TextEncoder();
+    const buffer = await globalThis.crypto.subtle.digest(algorithm, encoder.encode(message));
+    switch (method) {
+        case 'hex': {
+            return Array.from(new Uint8Array(buffer))
+                .map((byte) => byte.toString(16).padStart(2, '0'))
+                .join('');
+        }
+        case 'base64': {
+            return bufferToB64(buffer);
+        }
+        default: {
+            throw neverGuard(method, `Unhandled sign method: "${method}"`);
+        }
+    }
+}
+/**
+ * Sign a message, with a secret, using the Web Crypto API
+ */
+export async function signMessage(message, secret, method, algorithm, secretEncodeMethod) {
+    const encoder = new TextEncoder();
+    let encodedSecret;
+    switch (secretEncodeMethod) {
+        // case 'base64:node': {
+        //   encodedSecret = Buffer.from(secret, 'base64');
+        //   break;
+        // }
+        case 'base64:web': {
+            encodedSecret = b64StringToBuffer(secret);
+            break;
+        }
+        case 'utf': {
+            encodedSecret = encoder.encode(secret);
+            break;
+        }
+        default: {
+            throw new Error(`Unhandled encoding: "${secretEncodeMethod}"`);
+        }
+    }
+    const key = await globalThis.crypto.subtle.importKey('raw', encodedSecret, { name: 'HMAC', hash: algorithm }, false, ['sign']);
+    const buffer = await globalThis.crypto.subtle.sign('HMAC', key, encoder.encode(message));
+    switch (method) {
+        case 'hex': {
+            return Array.from(new Uint8Array(buffer))
+                .map((byte) => byte.toString(16).padStart(2, '0'))
+                .join('');
+        }
+        case 'base64': {
+            return bufferToB64(buffer);
+        }
+        default: {
+            throw neverGuard(method, `Unhandled sign method: "${method}"`);
+        }
+    }
+}
+//# sourceMappingURL=webCryptoAPI.js.map

package/dist/mjs/lib/webCryptoAPI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webCryptoAPI.js","sourceRoot":"","sources":["../../../src/lib/webCryptoAPI.ts"],"names":[],"mappings":"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"}

package/dist/mjs/lib/websocket/WsStore.d.ts

@@ -0,0 +1,63 @@
+import WebSocket from 'isomorphic-ws';
+import { DefaultLogger } from './logger.js';
+import { DeferredPromise, WSConnectedResult, WsConnectionStateEnum, WsStoredState } from './WsStore.types.js';
+/**
+ * Simple comparison of two objects, only checks 1-level deep (nested objects won't match)
+ */
+export declare function isDeepObjectMatch(object1: unknown, object2: unknown): boolean;
+declare const DEFERRED_PROMISE_REF: {
+    readonly CONNECTION_IN_PROGRESS: "CONNECTION_IN_PROGRESS";
+};
+type DeferredPromiseRef = (typeof DEFERRED_PROMISE_REF)[keyof typeof DEFERRED_PROMISE_REF];
+export declare class WsStore<WsKey extends string, TWSTopicSubscribeEventArgs extends string | object> {
+    private wsState;
+    private logger;
+    constructor(logger: typeof DefaultLogger);
+    /** Get WS stored state for key, optionally create if missing */
+    get(key: WsKey, createIfMissing?: true): WsStoredState<TWSTopicSubscribeEventArgs>;
+    get(key: WsKey, createIfMissing?: false): WsStoredState<TWSTopicSubscribeEventArgs> | undefined;
+    getKeys(): WsKey[];
+    create(key: WsKey): WsStoredState<TWSTopicSubscribeEventArgs> | undefined;
+    delete(key: WsKey): void;
+    hasExistingActiveConnection(key: WsKey): boolean;
+    getWs(key: WsKey): WebSocket | undefined;
+    setWs(key: WsKey, wsConnection: WebSocket): WebSocket;
+    getDeferredPromise<TSuccessResult = any>(wsKey: WsKey, promiseRef: string | DeferredPromiseRef): DeferredPromise<TSuccessResult> | undefined;
+    createDeferredPromise<TSuccessResult = any>(wsKey: WsKey, promiseRef: string | DeferredPromiseRef, throwIfExists: boolean): DeferredPromise<TSuccessResult>;
+    resolveDeferredPromise(wsKey: WsKey, promiseRef: string | DeferredPromiseRef, value: unknown, removeAfter: boolean): void;
+    rejectDeferredPromise(wsKey: WsKey, promiseRef: string | DeferredPromiseRef, value: unknown, removeAfter: boolean): void;
+    removeDeferredPromise(wsKey: WsKey, promiseRef: string | DeferredPromiseRef): void;
+    rejectAllDeferredPromises(wsKey: WsKey, reason: string): void;
+    /** Get promise designed to track a connection attempt in progress. Resolves once connected. */
+    getConnectionInProgressPromise(wsKey: WsKey): DeferredPromise<WSConnectedResult> | undefined;
+    /**
+     * Create a deferred promise designed to track a connection attempt in progress.
+     *
+     * Will throw if existing promise is found.
+     */
+    createConnectionInProgressPromise(wsKey: WsKey, throwIfExists: boolean): DeferredPromise<WSConnectedResult>;
+    /** Remove promise designed to track a connection attempt in progress */
+    removeConnectingInProgressPromise(wsKey: WsKey): void;
+    isWsOpen(key: WsKey): boolean;
+    getConnectionState(key: WsKey): WsConnectionStateEnum;
+    setConnectionState(key: WsKey, state: WsConnectionStateEnum): void;
+    isConnectionState(key: WsKey, state: WsConnectionStateEnum): boolean;
+    /**
+     * Check if we're currently in the process of opening a connection for any reason. Safer than only checking "CONNECTING" as the state
+     * @param key
+     * @returns
+     */
+    isConnectionAttemptInProgress(key: WsKey): boolean;
+    getTopics(key: WsKey): Set<TWSTopicSubscribeEventArgs>;
+    getTopicsByKey(): Record<string, Set<TWSTopicSubscribeEventArgs>>;
+    /**
+     * Find matching "topic" request from the store
+     * @param key
+     * @param topic
+     * @returns
+     */
+    getMatchingTopic(key: WsKey, topic: TWSTopicSubscribeEventArgs): TWSTopicSubscribeEventArgs | undefined;
+    addTopic(key: WsKey, topic: TWSTopicSubscribeEventArgs): Set<TWSTopicSubscribeEventArgs>;
+    deleteTopic(key: WsKey, topic: TWSTopicSubscribeEventArgs): Set<TWSTopicSubscribeEventArgs>;
+}
+export {};

package/dist/mjs/lib/websocket/WsStore.js

@@ -0,0 +1,249 @@
+import { DefaultLogger } from './logger.js';
+import { WsConnectionStateEnum, } from './WsStore.types.js';
+/**
+ * Simple comparison of two objects, only checks 1-level deep (nested objects won't match)
+ */
+export function isDeepObjectMatch(object1, object2) {
+    if (typeof object1 === 'string' && typeof object2 === 'string') {
+        return object1 === object2;
+    }
+    if (typeof object1 !== 'object' || typeof object2 !== 'object') {
+        return false;
+    }
+    for (const key in object1) {
+        const value1 = object1[key];
+        const value2 = object2[key];
+        if (value1 !== value2) {
+            return false;
+        }
+    }
+    return true;
+}
+const DEFERRED_PROMISE_REF = {
+    CONNECTION_IN_PROGRESS: 'CONNECTION_IN_PROGRESS',
+};
+export class WsStore {
+    wsState = {};
+    logger;
+    constructor(logger) {
+        this.logger = logger || DefaultLogger;
+    }
+    get(key, createIfMissing) {
+        if (this.wsState[key]) {
+            return this.wsState[key];
+        }
+        if (createIfMissing) {
+            return this.create(key);
+        }
+    }
+    getKeys() {
+        return Object.keys(this.wsState);
+    }
+    create(key) {
+        if (this.hasExistingActiveConnection(key)) {
+            this.logger.info('WsStore setConnection() overwriting existing open connection: ', this.getWs(key));
+        }
+        this.wsState[key] = {
+            subscribedTopics: new Set(),
+            connectionState: WsConnectionStateEnum.INITIAL,
+            deferredPromiseStore: {},
+        };
+        return this.get(key);
+    }
+    delete(key) {
+        // TODO: should we allow this at all? Perhaps block this from happening...
+        if (this.hasExistingActiveConnection(key)) {
+            const ws = this.getWs(key);
+            this.logger.info('WsStore deleting state for connection still open: ', ws);
+            ws?.close();
+        }
+        delete this.wsState[key];
+    }
+    /* connection websocket */
+    hasExistingActiveConnection(key) {
+        return this.get(key) && this.isWsOpen(key);
+    }
+    getWs(key) {
+        return this.get(key)?.ws;
+    }
+    setWs(key, wsConnection) {
+        if (this.isWsOpen(key)) {
+            this.logger.info('WsStore setConnection() overwriting existing open connection: ', this.getWs(key));
+        }
+        this.get(key, true).ws = wsConnection;
+        return wsConnection;
+    }
+    getDeferredPromise(wsKey, promiseRef) {
+        const storeForKey = this.get(wsKey);
+        if (!storeForKey) {
+            return;
+        }
+        const deferredPromiseStore = storeForKey.deferredPromiseStore;
+        return deferredPromiseStore[promiseRef];
+    }
+    createDeferredPromise(wsKey, promiseRef, throwIfExists) {
+        const existingPromise = this.getDeferredPromise(wsKey, promiseRef);
+        if (existingPromise) {
+            if (throwIfExists) {
+                throw new Error(`Promise exists for "${wsKey}"`);
+            }
+            else {
+                // console.log('existing promise');
+                return existingPromise;
+            }
+        }
+        // console.log('create promise');
+        const createIfMissing = true;
+        const storeForKey = this.get(wsKey, createIfMissing);
+        // TODO: Once stable, use Promise.withResolvers in future
+        const deferredPromise = {};
+        deferredPromise.promise = new Promise((resolve, reject) => {
+            deferredPromise.resolve = resolve;
+            deferredPromise.reject = reject;
+        });
+        const deferredPromiseStore = storeForKey.deferredPromiseStore;
+        deferredPromiseStore[promiseRef] = deferredPromise;
+        return deferredPromise;
+    }
+    resolveDeferredPromise(wsKey, promiseRef, value, removeAfter) {
+        const promise = this.getDeferredPromise(wsKey, promiseRef);
+        if (promise?.resolve) {
+            promise.resolve(value);
+        }
+        if (removeAfter) {
+            this.removeDeferredPromise(wsKey, promiseRef);
+        }
+    }
+    rejectDeferredPromise(wsKey, promiseRef, value, removeAfter) {
+        const promise = this.getDeferredPromise(wsKey, promiseRef);
+        if (promise?.reject) {
+            promise.reject(value);
+        }
+        if (removeAfter) {
+            this.removeDeferredPromise(wsKey, promiseRef);
+        }
+    }
+    removeDeferredPromise(wsKey, promiseRef) {
+        const storeForKey = this.get(wsKey);
+        if (!storeForKey) {
+            return;
+        }
+        const deferredPromise = storeForKey.deferredPromiseStore[promiseRef];
+        if (deferredPromise) {
+            // Just in case it's pending
+            if (deferredPromise.resolve) {
+                deferredPromise.resolve('promiseRemoved');
+            }
+            delete storeForKey.deferredPromiseStore[promiseRef];
+        }
+    }
+    rejectAllDeferredPromises(wsKey, reason) {
+        const storeForKey = this.get(wsKey);
+        const deferredPromiseStore = storeForKey.deferredPromiseStore;
+        if (!storeForKey || !deferredPromiseStore) {
+            return;
+        }
+        const reservedKeys = Object.values(DEFERRED_PROMISE_REF);
+        for (const promiseRef in deferredPromiseStore) {
+            // Skip reserved keys, such as the connection promise
+            if (reservedKeys.includes(promiseRef)) {
+                continue;
+            }
+            try {
+                this.rejectDeferredPromise(wsKey, promiseRef, reason, true);
+            }
+            catch (e) {
+                this.logger.error(`rejectAllDeferredPromises(): Exception rejecting deferred promise`, { wsKey: wsKey, reason, promiseRef, exception: e });
+            }
+        }
+    }
+    /** Get promise designed to track a connection attempt in progress. Resolves once connected. */
+    getConnectionInProgressPromise(wsKey) {
+        return this.getDeferredPromise(wsKey, DEFERRED_PROMISE_REF.CONNECTION_IN_PROGRESS);
+    }
+    /**
+     * Create a deferred promise designed to track a connection attempt in progress.
+     *
+     * Will throw if existing promise is found.
+     */
+    createConnectionInProgressPromise(wsKey, throwIfExists) {
+        return this.createDeferredPromise(wsKey, DEFERRED_PROMISE_REF.CONNECTION_IN_PROGRESS, throwIfExists);
+    }
+    /** Remove promise designed to track a connection attempt in progress */
+    removeConnectingInProgressPromise(wsKey) {
+        return this.removeDeferredPromise(wsKey, DEFERRED_PROMISE_REF.CONNECTION_IN_PROGRESS);
+    }
+    /* connection state */
+    isWsOpen(key) {
+        const existingConnection = this.getWs(key);
+        return (!!existingConnection &&
+            existingConnection.readyState === existingConnection.OPEN);
+    }
+    getConnectionState(key) {
+        return this.get(key, true).connectionState;
+    }
+    setConnectionState(key, state) {
+        // console.log(new Date(), `setConnectionState(${key}, ${state})`);
+        this.get(key, true).connectionState = state;
+    }
+    isConnectionState(key, state) {
+        return this.getConnectionState(key) === state;
+    }
+    /**
+     * Check if we're currently in the process of opening a connection for any reason. Safer than only checking "CONNECTING" as the state
+     * @param key
+     * @returns
+     */
+    isConnectionAttemptInProgress(key) {
+        const isConnectionInProgress = this.isConnectionState(key, WsConnectionStateEnum.CONNECTING) ||
+            this.isConnectionState(key, WsConnectionStateEnum.RECONNECTING);
+        return isConnectionInProgress;
+    }
+    /* subscribed topics */
+    getTopics(key) {
+        return this.get(key, true).subscribedTopics;
+    }
+    getTopicsByKey() {
+        const result = {};
+        for (const refKey in this.wsState) {
+            result[refKey] = this.getTopics(refKey);
+        }
+        return result;
+    }
+    // Since topics are objects we can't rely on the set to detect duplicates
+    /**
+     * Find matching "topic" request from the store
+     * @param key
+     * @param topic
+     * @returns
+     */
+    getMatchingTopic(key, topic) {
+        // if (typeof topic === 'string') {
+        //   return this.getMatchingTopic(key, { channel: topic });
+        // }
+        const allTopics = this.getTopics(key).values();
+        for (const storedTopic of allTopics) {
+            if (isDeepObjectMatch(topic, storedTopic)) {
+                return storedTopic;
+            }
+        }
+    }
+    addTopic(key, topic) {
+        // console.log(`wsStore.addTopic(${key}, ${topic})`);
+        // Check for duplicate topic. If already tracked, don't store this one
+        const existingTopic = this.getMatchingTopic(key, topic);
+        if (existingTopic) {
+            return this.getTopics(key);
+        }
+        return this.getTopics(key).add(topic);
+    }
+    deleteTopic(key, topic) {
+        // Check if we're subscribed to a topic like this
+        const storedTopic = this.getMatchingTopic(key, topic);
+        if (storedTopic) {
+            this.getTopics(key).delete(storedTopic);
+        }
+        return this.getTopics(key);
+    }
+}
+//# sourceMappingURL=WsStore.js.map