@nktkas/hyperliquid 0.25.0-beta.1 → 0.25.0-beta.3

package/src/src/transports/websocket/_websocket_async_request.ts

@@ -0,0 +1,229 @@
+import type { ReconnectingWebSocket } from "./_reconnecting_websocket.js";
+import type { HyperliquidEventMap, HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
+import { WebSocketRequestError } from "./websocket_transport.js";
+
+interface PostRequest {
+    method: "post";
+    id: number;
+    request: unknown;
+}
+
+interface SubscribeUnsubscribeRequest {
+    method: "subscribe" | "unsubscribe";
+    subscription: unknown;
+}
+
+interface PingRequest {
+    method: "ping";
+}
+
+/**
+ * Manages WebSocket requests to the Hyperliquid API.
+ * Handles request creation, sending, and mapping responses to their corresponding requests.
+ */
+export class WebSocketAsyncRequest {
+    protected lastId: number = 0;
+    protected queue: {
+        id: number | string;
+        // deno-lint-ignore no-explicit-any
+        resolve: (value?: any) => void;
+        // deno-lint-ignore no-explicit-any
+        reject: (reason?: any) => void;
+    }[] = [];
+    lastRequestTime: number = 0;
+
+    /**
+     * Creates a new WebSocket async request handler.
+     * @param socket - WebSocket connection instance for sending requests to the Hyperliquid WebSocket API
+     * @param hlEvents - Used to recognize Hyperliquid responses and match them with sent requests
+     */
+    constructor(protected socket: ReconnectingWebSocket, hlEvents: HyperliquidEventTarget) {
+        // Monitor responses and match the pending request
+        hlEvents.addEventListener("subscriptionResponse", (event) => {
+            const detail = (event as HyperliquidEventMap["subscriptionResponse"]).detail;
+
+            // Use a stringified request as an id
+            const id = WebSocketAsyncRequest.requestToId(detail);
+            this.queue.findLast((item) => item.id === id)?.resolve(detail);
+        });
+        hlEvents.addEventListener("post", (event) => {
+            const detail = (event as HyperliquidEventMap["post"]).detail;
+
+            const data = detail.response.type === "info" ? detail.response.payload.data : detail.response.payload;
+            this.queue.findLast((item) => item.id === detail.id)?.resolve(data);
+        });
+        hlEvents.addEventListener("pong", () => {
+            this.queue.findLast((item) => item.id === "ping")?.resolve();
+        });
+        hlEvents.addEventListener("error", (event) => {
+            const detail = (event as HyperliquidEventMap["error"]).detail;
+
+            try {
+                // Error event doesn't have an id, use original request to match
+                const request = detail.match(/{.*}/)?.[0];
+                if (!request) return;
+
+                const parsedRequest = JSON.parse(request) as Record<string, unknown>;
+
+                // For `post` requests
+                if ("id" in parsedRequest && typeof parsedRequest.id === "number") {
+                    this.queue.findLast((item) => item.id === parsedRequest.id)
+                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    return;
+                }
+
+                // For `subscribe` and `unsubscribe` requests
+                if (
+                    "subscription" in parsedRequest &&
+                    typeof parsedRequest.subscription === "object" && parsedRequest.subscription !== null
+                ) {
+                    const id = WebSocketAsyncRequest.requestToId(parsedRequest);
+                    this.queue.findLast((item) => item.id === id)
+                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    return;
+                }
+
+                // For `Already subscribed` and `Invalid subscription` requests
+                if (detail.startsWith("Already subscribed") || detail.startsWith("Invalid subscription")) {
+                    const id = WebSocketAsyncRequest.requestToId({
+                        method: "subscribe",
+                        subscription: parsedRequest,
+                    });
+                    this.queue.findLast((item) => item.id === id)
+                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    return;
+                }
+                // For `Already unsubscribed` requests
+                if (detail.startsWith("Already unsubscribed")) {
+                    const id = WebSocketAsyncRequest.requestToId({
+                        method: "unsubscribe",
+                        subscription: parsedRequest,
+                    });
+                    this.queue.findLast((item) => item.id === id)
+                        ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+                    return;
+                }
+
+                // For unknown requests
+                const id = WebSocketAsyncRequest.requestToId(parsedRequest);
+                this.queue.findLast((item) => item.id === id)
+                    ?.reject(new WebSocketRequestError(`Server error: ${detail}`, { cause: detail }));
+            } catch {
+                // Ignore JSON parsing errors
+            }
+        });
+
+        // Throws all pending requests if the connection is dropped
+        socket.addEventListener("close", () => {
+            this.queue.forEach(({ reject }) => {
+                reject(new WebSocketRequestError("WebSocket connection closed."));
+            });
+            this.queue = [];
+        });
+    }
+
+    /**
+     * Sends a request to the Hyperliquid API.
+     * @returns A promise that resolves with the parsed JSON response body.
+     */
+    async request(method: "ping", signal?: AbortSignal): Promise<void>;
+    async request<T>(method: "post" | "subscribe" | "unsubscribe", payload: unknown, signal?: AbortSignal): Promise<T>;
+    async request<T>(
+        method: "post" | "subscribe" | "unsubscribe" | "ping",
+        payload_or_signal?: unknown | AbortSignal,
+        maybeSignal?: AbortSignal,
+    ): Promise<T> {
+        const payload = payload_or_signal instanceof AbortSignal ? undefined : payload_or_signal;
+        const signal = payload_or_signal instanceof AbortSignal ? payload_or_signal : maybeSignal;
+
+        // Reject the request if the signal is aborted
+        if (signal?.aborted) return Promise.reject(signal.reason);
+        // or if the WebSocket connection is permanently closed
+        if (this.socket.reconnectAbortController.signal.aborted) {
+            return Promise.reject(this.socket.reconnectAbortController.signal.reason);
+        }
+
+        // Create a request
+        let id: string | number;
+        let request: SubscribeUnsubscribeRequest | PostRequest | PingRequest;
+        if (method === "post") {
+            id = ++this.lastId;
+            request = { method, id, request: payload };
+        } else if (method === "ping") {
+            id = "ping";
+            request = { method };
+        } else {
+            request = { method, subscription: payload };
+            id = WebSocketAsyncRequest.requestToId(request);
+        }
+
+        // Send the request
+        this.socket.send(JSON.stringify(request), signal);
+        this.lastRequestTime = Date.now();
+
+        // Wait for a response
+        const { promise, resolve, reject } = Promise.withResolvers<T>();
+        this.queue.push({ id, resolve, reject });
+
+        const onAbort = () => reject(signal?.reason);
+        signal?.addEventListener("abort", onAbort, { once: true });
+
+        return await promise.finally(() => {
+            const index = this.queue.findLastIndex((item) => item.id === id);
+            if (index !== -1) this.queue.splice(index, 1);
+
+            signal?.removeEventListener("abort", onAbort);
+        });
+    }
+
+    /** Normalizes an object and then converts it to a string. */
+    static requestToId(value: unknown): string {
+        const lowerHex = deepLowerHex(value);
+        const sorted = deepSortKeys(lowerHex);
+        return JSON.stringify(sorted); // Also removes undefined
+    }
+}
+
+/** Deeply converts hexadecimal strings in an object/array to lowercase. */
+function deepLowerHex(obj: unknown): unknown {
+    if (typeof obj === "string") {
+        return /^(0X[0-9a-fA-F]*|0x[0-9a-fA-F]*[A-F][0-9a-fA-F]*)$/.test(obj) ? obj.toLowerCase() : obj;
+    }
+
+    if (Array.isArray(obj)) {
+        return obj.map((value) => deepLowerHex(value));
+    }
+
+    if (typeof obj === "object" && obj !== null) {
+        const result: Record<string, unknown> = {};
+        const entries = Object.entries(obj);
+
+        for (const [key, value] of entries) {
+            result[key] = deepLowerHex(value);
+        }
+
+        return result;
+    }
+
+    return obj;
+}
+
+/** Deeply sort the keys of an object. */
+function deepSortKeys<T>(obj: T): T {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+
+    if (Array.isArray(obj)) {
+        return obj.map(deepSortKeys) as T;
+    }
+
+    const result: Record<string, unknown> = {};
+    const keys = Object.keys(obj).sort();
+
+    for (const key of keys) {
+        result[key] = deepSortKeys((obj as Record<string, unknown>)[key]);
+    }
+
+    return result as T;
+}

package/src/src/transports/websocket/websocket_transport.ts

@@ -0,0 +1,394 @@
+import { TransportError } from "../base.js";
+import type { IRequestTransport, ISubscriptionTransport, Subscription } from "../base.js";
+import {
+    type MessageBufferStrategy,
+    ReconnectingWebSocket,
+    ReconnectingWebSocketError,
+    type ReconnectingWebSocketOptions,
+} from "./_reconnecting_websocket.js";
+import { HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
+import { WebSocketAsyncRequest } from "./_websocket_async_request.js";
+
+export { type MessageBufferStrategy, ReconnectingWebSocketError, type ReconnectingWebSocketOptions };
+
+/** Configuration options for the WebSocket transport layer. */
+export interface WebSocketTransportOptions {
+    /**
+     * The WebSocket URL.
+     * - Mainnet:
+     *   - API: `wss://api.hyperliquid.xyz/ws`
+     *   - Explorer: `wss://rpc.hyperliquid.xyz/ws`
+     * - Testnet:
+     *   - API: `wss://api.hyperliquid-testnet.xyz/ws`
+     *   - Explorer: `wss://rpc.hyperliquid-testnet.xyz/ws`
+     * @defaultValue `wss://api.hyperliquid.xyz/ws`
+     */
+    url?: string | URL;
+
+    /**
+     * Indicates this transport uses testnet endpoint.
+     * @defaultValue `false`
+     */
+    isTestnet?: boolean;
+
+    /**
+     * Timeout for requests in ms.
+     * Set to `null` to disable.
+     * @defaultValue `10_000`
+     */
+    timeout?: number | null;
+
+    /** Keep-alive configuration. */
+    keepAlive?: {
+        /**
+         * Interval between sending ping messages in ms.
+         * Set to `null` to disable.
+         * @defaultValue `30_000`
+         */
+        interval?: number | null;
+
+        /**
+         * Timeout for the ping request in ms.
+         * Set to `null` to disable.
+         * @defaultValue same as {@link timeout} for requests.
+         */
+        timeout?: number | null;
+    };
+
+    /** Reconnection policy configuration for closed connections. */
+    reconnect?: ReconnectingWebSocketOptions;
+
+    /**
+     * Enable automatic event resubscription after reconnection.
+     * @defaultValue `true`
+     */
+    autoResubscribe?: boolean;
+}
+
+/** Error thrown when a WebSocket request fails. */
+export class WebSocketRequestError extends TransportError {
+    constructor(message?: string, options?: ErrorOptions) {
+        super(message, options);
+        this.name = "WebSocketRequestError";
+    }
+}
+
+/** WebSocket implementation of the REST and Subscription transport interfaces. */
+export class WebSocketTransport implements IRequestTransport, ISubscriptionTransport, AsyncDisposable {
+    protected _wsRequester: WebSocketAsyncRequest;
+    protected _hlEvents: HyperliquidEventTarget;
+    protected _keepAliveTimeout: ReturnType<typeof setTimeout> | null = null;
+    protected _subscriptions: Map<
+        string, // Unique identifier based on the payload
+        {
+            listeners: Map<
+                (data: CustomEvent) => void, // Event listener function
+                () => Promise<void> // Unsubscribe function
+            >;
+            promise: Promise<unknown>; // Subscription request promise
+            resubscribeAbortController?: AbortController; // To monitor reconnection errors
+        }
+    > = new Map();
+    protected _isReconnecting = false;
+
+    /** Indicates this transport uses testnet endpoint. */
+    isTestnet: boolean;
+
+    /**
+     * Request timeout in ms.
+     * Set to `null` to disable.
+     */
+    timeout: number | null;
+
+    /** Keep-alive configuration. */
+    keepAlive: {
+        /**
+         * Interval between sending ping messages in ms.
+         * Set to `null` to disable.
+         */
+        interval: number | null;
+
+        /**
+         * Timeout for the ping request in ms.
+         * Set to `null` to disable.
+         */
+        timeout?: number | null;
+    };
+
+    /** Enable automatic resubscription after reconnection. */
+    autoResubscribe: boolean;
+
+    /** The WebSocket that is used for communication. */
+    readonly socket: ReconnectingWebSocket;
+
+    /**
+     * Creates a new WebSocket transport instance.
+     * @param options - Configuration options for the WebSocket transport layer.
+     */
+    constructor(options?: WebSocketTransportOptions) {
+        this.socket = new ReconnectingWebSocket(
+            options?.url ?? "wss://api.hyperliquid.xyz/ws",
+            undefined,
+            options?.reconnect,
+        );
+        this._hlEvents = new HyperliquidEventTarget(this.socket);
+        this._wsRequester = new WebSocketAsyncRequest(this.socket, this._hlEvents);
+
+        this.isTestnet = options?.isTestnet ?? false;
+        this.timeout = options?.timeout === undefined ? 10_000 : options.timeout;
+        this.keepAlive = {
+            interval: options?.keepAlive?.interval === undefined ? 30_000 : options.keepAlive?.interval,
+            timeout: options?.keepAlive?.timeout === undefined ? this.timeout : options.keepAlive?.timeout,
+        };
+        this.autoResubscribe = options?.autoResubscribe ?? true;
+
+        // Initialize listeners
+        this.socket.addEventListener("open", () => {
+            this._keepAliveStart();
+            this._resubscribeStart();
+        });
+        this.socket.addEventListener("close", () => {
+            this._keepAliveStop();
+            this._resubscribeStop();
+            this._isReconnecting = true;
+        });
+    }
+
+    /**
+     * Sends a request to the Hyperliquid API via WebSocket.
+     *
+     * Note: Explorer requests are not supported in the Hyperliquid WebSocket API.
+     *
+     * @param endpoint - The API endpoint to send the request to (`explorer` requests are not supported).
+     * @param payload - The payload to send with the request.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns A promise that resolves with parsed JSON response body.
+     *
+     * @throws {WebSocketRequestError} - An error that occurs when a WebSocket request fails.
+     */
+    async request<T>(type: "info" | "exchange", payload: unknown, signal?: AbortSignal): Promise<T> {
+        try {
+            const timeoutSignal = this.timeout ? AbortSignal.timeout(this.timeout) : undefined;
+            const combinedSignal = signal && timeoutSignal
+                ? AbortSignal.any([signal, timeoutSignal])
+                : signal ?? timeoutSignal;
+
+            return await this._wsRequester.request(
+                "post",
+                {
+                    type: type === "exchange" ? "action" : type,
+                    payload,
+                },
+                combinedSignal,
+            );
+        } catch (error) {
+            if (error instanceof TransportError) throw error; // Re-throw known errors
+            throw new WebSocketRequestError(
+                `Unknown error while making a WebSocket request: ${error}`,
+                { cause: error },
+            );
+        }
+    }
+
+    /**
+     * Subscribes to a Hyperliquid event channel.
+     * Sends a subscription request to the server and listens for events.
+     *
+     * @param channel - The event channel to listen to.
+     * @param payload - A payload to send with the subscription request.
+     * @param listener - A function to call when the event is dispatched.
+     * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
+     *
+     * @throws {WebSocketRequestError} - An error that occurs when a WebSocket request fails.
+     */
+    async subscribe<T>(
+        channel: string,
+        payload: unknown,
+        listener: (data: CustomEvent<T>) => void,
+    ): Promise<Subscription> {
+        try {
+            // Create a unique identifier for the subscription
+            const id = WebSocketAsyncRequest.requestToId(payload);
+
+            // Initialize new subscription, if it doesn't exist
+            let subscription = this._subscriptions.get(id);
+            if (!subscription) {
+                // Send subscription request
+                const promise = this._wsRequester.request("subscribe", payload);
+
+                // Cache subscription info
+                subscription = {
+                    listeners: new Map(),
+                    promise,
+                    resubscribeAbortController: new AbortController(),
+                };
+                this._subscriptions.set(id, subscription);
+            }
+
+            // Initialize new listener, if it doesn't exist
+            let unsubscribe = subscription.listeners.get(listener);
+            if (!unsubscribe) {
+                // Create new unsubscribe function
+                unsubscribe = async () => {
+                    try {
+                        // Remove listener and cleanup
+                        this._hlEvents.removeEventListener(channel, listener as EventListener);
+                        const subscription = this._subscriptions.get(id);
+                        subscription?.listeners.delete(listener);
+
+                        // If no listeners remain, remove subscription entirely
+                        if (subscription?.listeners.size === 0) {
+                            // Cleanup subscription
+                            this._subscriptions.delete(id);
+
+                            // If the socket is open, send unsubscription request
+                            if (this.socket.readyState === ReconnectingWebSocket.OPEN) {
+                                await this._wsRequester.request("unsubscribe", payload);
+                            }
+                        }
+                    } catch (error) {
+                        if (error instanceof TransportError) throw error; // Re-throw known errors
+                        throw new WebSocketRequestError(
+                            `Unknown error while unsubscribing from a WebSocket channel: ${error}`,
+                            { cause: error },
+                        );
+                    }
+                };
+
+                // Add listener and cache unsubscribe function
+                this._hlEvents.addEventListener(channel, listener as EventListener);
+                subscription.listeners.set(listener, unsubscribe);
+            }
+
+            // Wait for the initial subscription request to complete
+            await subscription.promise;
+
+            // Return subscription control object
+            return {
+                unsubscribe,
+                resubscribeSignal: subscription.resubscribeAbortController?.signal,
+            };
+        } catch (error) {
+            if (error instanceof TransportError) throw error; // Re-throw known errors
+            throw new WebSocketRequestError(
+                `Unknown error while subscribing to a WebSocket channel: ${error}`,
+                { cause: error },
+            );
+        }
+    }
+
+    /**
+     * Waits until the WebSocket connection is ready.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the promise can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns A promise that resolves when the connection is ready.
+     */
+    ready(signal?: AbortSignal): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const combinedSignal = signal
+                ? AbortSignal.any([this.socket.reconnectAbortController.signal, signal])
+                : this.socket.reconnectAbortController.signal;
+
+            if (combinedSignal.aborted) return reject(combinedSignal.reason);
+            if (this.socket.readyState === ReconnectingWebSocket.OPEN) return resolve();
+
+            const handleOpen = () => {
+                combinedSignal.removeEventListener("abort", handleAbort);
+                resolve();
+            };
+            const handleAbort = () => {
+                this.socket.removeEventListener("open", handleOpen);
+                reject(combinedSignal.reason);
+            };
+
+            this.socket.addEventListener("open", handleOpen, { once: true });
+            combinedSignal.addEventListener("abort", handleAbort, { once: true });
+        });
+    }
+
+    /**
+     * Closes the WebSocket connection and waits until it is fully closed.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the promise can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns A promise that resolves when the connection is fully closed.
+     */
+    close(signal?: AbortSignal): Promise<void> {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) return reject(signal.reason);
+            if (this.socket.readyState === ReconnectingWebSocket.CLOSED) return resolve();
+
+            const handleClose = () => {
+                signal?.removeEventListener("abort", handleAbort);
+                resolve();
+            };
+            const handleAbort = () => {
+                this.socket.removeEventListener("close", handleClose);
+                reject(signal?.reason);
+            };
+
+            this.socket.addEventListener("close", handleClose, { once: true });
+            signal?.addEventListener("abort", handleAbort, { once: true });
+
+            this.socket.close();
+        });
+    }
+
+    /** Keep the connection alive. Sends ping only when necessary. */
+    protected _keepAliveStart(): void {
+        if (this.keepAlive.interval === null || this._keepAliveTimeout) return;
+
+        const tick = async () => {
+            if (
+                this.socket.readyState !== ReconnectingWebSocket.OPEN || !this._keepAliveTimeout ||
+                this.keepAlive.interval === null
+            ) return;
+
+            // Check if the last request was sent more than the keep-alive interval ago
+            if (Date.now() - this._wsRequester.lastRequestTime >= this.keepAlive.interval) {
+                const timeoutSignal = this.keepAlive.timeout ? AbortSignal.timeout(this.keepAlive.timeout) : undefined;
+                await this._wsRequester.request("ping", timeoutSignal)
+                    .catch(() => undefined); // Ignore errors
+            }
+
+            // Schedule the next ping
+            if (
+                this.socket.readyState === ReconnectingWebSocket.OPEN && this._keepAliveTimeout &&
+                this.keepAlive.interval !== null
+            ) {
+                const nextDelay = this.keepAlive.interval - (Date.now() - this._wsRequester.lastRequestTime);
+                this._keepAliveTimeout = setTimeout(tick, nextDelay);
+            }
+        };
+
+        this._keepAliveTimeout = setTimeout(tick, this.keepAlive.interval);
+    }
+    protected _keepAliveStop(): void {
+        if (this._keepAliveTimeout !== null) {
+            clearTimeout(this._keepAliveTimeout);
+            this._keepAliveTimeout = null;
+        }
+    }
+
+    /** Resubscribe to all existing subscriptions if auto-resubscribe is enabled. */
+    protected _resubscribeStart(): void {
+        if (this.autoResubscribe && this._isReconnecting) {
+            for (const [id, subscriptionInfo] of this._subscriptions.entries()) {
+                subscriptionInfo.promise = this._wsRequester.request("subscribe", JSON.parse(id))
+                    .catch((error) => {
+                        subscriptionInfo.resubscribeAbortController?.abort(error);
+                    });
+            }
+        }
+    }
+    protected _resubscribeStop(): void {
+        if (!this.autoResubscribe || this.socket.reconnectAbortController.signal.aborted) {
+            for (const subscriptionInfo of this._subscriptions.values()) {
+                for (const [_, unsubscribe] of subscriptionInfo.listeners) {
+                    unsubscribe(); // does not cause an error if used when the connection is closed
+                }
+            }
+        }
+    }
+
+    async [Symbol.asyncDispose](): Promise<void> {
+        await this.close();
+    }
+}

package/esm/mod.d.ts

@@ -1,20 +0,0 @@
-export * from "./src/errors.js";
-export * from "./src/transports/base.js";
-export type { AbstractWallet } from "./src/signing/mod.js";
-export * from "./src/clients/exchange.js";
-export * from "./src/clients/info.js";
-export * from "./src/clients/multiSign.js";
-export * from "./src/clients/subscription.js";
-export * from "./src/transports/http/http_transport.js";
-export * from "./src/transports/websocket/websocket_transport.js";
-export type { OrderParams, Signature } from "./src/schemas/exchange/requests.js";
-export type * from "./src/schemas/exchange/responses.js";
-export type * from "./src/schemas/explorer/responses.js";
-export type * from "./src/schemas/info/accounts.js";
-export type * from "./src/schemas/info/assets.js";
-export type * from "./src/schemas/info/validators.js";
-export type * from "./src/schemas/info/markets.js";
-export type * from "./src/schemas/info/orders.js";
-export type * from "./src/schemas/info/vaults.js";
-export type * from "./src/schemas/subscriptions/responses.js";
-//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AAGzC,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,yCAAyC,CAAC;AACxD,cAAc,mDAAmD,CAAC;AAGlE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AACjF,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,kCAAkC,CAAC;AACtD,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,0CAA0C,CAAC"}

package/esm/mod.js

@@ -1,11 +0,0 @@
-// Base interfaces
-export * from "./src/errors.js";
-export * from "./src/transports/base.js";
-// Clients
-export * from "./src/clients/exchange.js";
-export * from "./src/clients/info.js";
-export * from "./src/clients/multiSign.js";
-export * from "./src/clients/subscription.js";
-// Transports
-export * from "./src/transports/http/http_transport.js";
-export * from "./src/transports/websocket/websocket_transport.js";

package/esm/src/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/src/errors.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,qBAAa,gBAAiB,SAAQ,KAAK;gBAC3B,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIvD"}

package/esm/src/signing/_signTypedData/ethers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ethers.d.ts","sourceRoot":"","sources":["../../../../src/src/signing/_signTypedData/ethers.ts"],"names":[],"mappings":"AAAA,6GAA6G;AAC7G,MAAM,WAAW,sBAAsB;IACnC,aAAa,CACT,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,EAAE,MAAM,CAAC;KAC7B,EACD,KAAK,EAAE;QACH,CAAC,GAAG,EAAE,MAAM,GAAG;YACX,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;SAChB,EAAE,CAAC;KACP,EACD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,UAAU,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,QAAQ,CAAC,EACH;QAAE,UAAU,IAAI,OAAO,CAAC;YAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GACvD,IAAI,CAAC;CACd;AAED,sGAAsG;AACtG,MAAM,WAAW,sBAAsB;IACnC,cAAc,CACV,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,EAAE,MAAM,CAAC;KAC7B,EACD,KAAK,EAAE;QACH,CAAC,GAAG,EAAE,MAAM,GAAG;YACX,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;SAChB,EAAE,CAAC;KACP,EACD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,UAAU,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/B,QAAQ,CAAC,EACH;QAAE,UAAU,IAAI,OAAO,CAAC;YAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,GACvD,IAAI,CAAC;CACd;AAED,8DAA8D;AAC9D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,sBAAsB,CAI1F;AAED,iEAAiE;AACjE,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,sBAAsB,CAI1F"}

package/esm/src/signing/_signTypedData/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/src/signing/_signTypedData/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAG9B,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,KAAK,0BAA0B,EAAE,KAAK,wBAAwB,EAAwB,MAAM,WAAW,CAAC;AAEjH,gEAAgE;AAChE,MAAM,MAAM,cAAc,GACpB,KAAK,MAAM,EAAE,GACb,0BAA0B,GAC1B,wBAAwB,GACxB,sBAAsB,GACtB,sBAAsB,CAAC;AAE7B,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACtB,iDAAiD;IACjD,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,kDAAkD;IAClD,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,0BAA0B;IAC1B,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC;CACd;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACtC,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,iBAAiB,EAAE,KAAK,MAAM,EAAE,CAAC;KACpC,CAAC;IACF,KAAK,EAAE;QACH,CAAC,GAAG,EAAE,MAAM,GAAG;YACX,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;SAChB,EAAE,CAAC;KACP,CAAC;IACF,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,GAAG,OAAO,CAAC,SAAS,CAAC,CA8BrB;AASD,sCAAsC;AACtC,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAkBrF;AAED,wDAAwD;AACxD,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAgBrF"}

package/esm/src/signing/_signTypedData/private_key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"private_key.d.ts","sourceRoot":"","sources":["../../../../src/src/signing/_signTypedData/private_key.ts"],"names":[],"mappings":"AAGA,UAAU,KAAK;IACX,CAAC,IAAI,EAAE,MAAM,GAAG;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KAChB,EAAE,CAAC;CACP;AAED,UAAU,MAAO,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,MAAM,EAAE,CAAC;IACnD,iBAAiB,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAClC,IAAI,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;CACxB;AAED,2CAA2C;AAC3C,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAkBzB;AAsKD,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,OAAO,GAAG,UAAU,IAAI,MAAM,CAG3E;AAED,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAYrE"}