@hfunlabs/hyperliquid 0.27.1-hfunlabs.1

package/src/src/transport/websocket/mod.ts

@@ -0,0 +1,349 @@
+import { type IRequestTransport, type ISubscriptionTransport, type Subscription, TransportError } from "../base.js";
+import { AbortSignal_ } from "../_polyfills.js";
+import { ReconnectingWebSocket, ReconnectingWebSocketError, type ReconnectingWebSocketOptions } from "@nktkas/rews";
+import { HyperliquidEventTarget } from "./_hyperliquid_event_target.js";
+import { WebSocketAsyncRequest, WebSocketRequestError } from "./_websocket_async_request.js";
+
+export { ReconnectingWebSocketError, WebSocketRequestError };
+
+type MaybePromise<T> = T | Promise<T>;
+
+/** Configuration options for the WebSocket transport layer. */
+export interface WebSocketTransportOptions {
+  /**
+   * Indicates this transport uses testnet endpoint.
+   * @default false
+   */
+  isTestnet?: boolean;
+  /**
+   * Custom WebSocket endpoint for API and Subscription requests.
+   * - 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`
+   * @default `wss://api.hyperliquid.xyz/ws` for mainnet, `wss://api.hyperliquid-testnet.xyz/ws` for testnet
+   */
+  url?: string | URL;
+  /**
+   * Timeout for requests in ms.
+   * Set to `null` to disable.
+   * @default 10_000
+   */
+  timeout?: number | null;
+  /**
+   * Interval between sending ping messages in ms.
+   * Set to `null` to disable.
+   * @default 30_000
+   */
+  keepAliveInterval?: number | null;
+  /** Reconnection policy configuration for closed connections. */
+  reconnect?: ReconnectingWebSocketOptions;
+  /**
+   * Enable automatic re-subscription to Hyperliquid subscription after reconnection.
+   * @default true
+   */
+  resubscribe?: boolean;
+  onRequest?: (type: string, payload: unknown) => MaybePromise<unknown | void | null | undefined>;
+  onResponse?: (response: unknown) => MaybePromise<unknown | void | null | undefined>;
+  onError?: (error: unknown) => MaybePromise<Error | void | null | undefined>;
+}
+
+/** WebSocket implementation of the REST and Subscription transport interfaces. */
+export class WebSocketTransport implements IRequestTransport, ISubscriptionTransport {
+  protected _wsRequester: WebSocketAsyncRequest;
+  protected _hlEvents: HyperliquidEventTarget;
+  protected _keepAliveTimeout: ReturnType<typeof setTimeout> | undefined;
+  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
+      promiseFinished: boolean;
+      resubscribeAbortController: AbortController; // To monitor reconnection errors
+    }
+  > = new Map();
+
+  /** Indicates this transport uses testnet endpoint. */
+  readonly isTestnet: boolean;
+  /**
+   * Timeout for requests in ms.
+   * Set to `null` to disable.
+   */
+  timeout: number | null;
+  /**
+   * Interval between sending ping messages in ms.
+   * Set to `null` to disable.
+   */
+  keepAliveInterval: number | null;
+  /** Enable automatic re-subscription to Hyperliquid subscription after reconnection. */
+  resubscribe: 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.isTestnet = options?.isTestnet ?? false;
+    this.timeout = options?.timeout === undefined ? 10_000 : options.timeout;
+    this.keepAliveInterval = options?.keepAliveInterval ?? 30_000;
+    this.resubscribe = options?.resubscribe ?? true;
+
+    this.socket = new ReconnectingWebSocket(
+      options?.url ?? (this.isTestnet ? "wss://api.hyperliquid-testnet.xyz/ws" : "wss://api.hyperliquid.xyz/ws"),
+      options?.reconnect,
+    );
+
+    this._hlEvents = new HyperliquidEventTarget(this.socket);
+    this._wsRequester = new WebSocketAsyncRequest(this.socket, this._hlEvents);
+
+    // Initialize listeners
+    this.socket.addEventListener("open", () => {
+      this._keepAliveRun();
+      this._resubscribeRun();
+    });
+    const handleClose = () => {
+      this._keepAliveStop();
+      this._resubscribeStop();
+    };
+    this.socket.addEventListener("close", handleClose);
+    this.socket.addEventListener("error", handleClose);
+  }
+
+  /**
+   * Keep the connection alive.
+   * Sends ping only when no other requests were sent within the keep-alive interval.
+   */
+  protected _keepAliveRun(): void {
+    if (this.keepAliveInterval === null || this._keepAliveTimeout) return;
+
+    const tick = async () => {
+      if (
+        this.socket.readyState !== ReconnectingWebSocket.OPEN || !this._keepAliveTimeout ||
+        this.keepAliveInterval === null
+      ) return;
+
+      // Check if the last request was sent more than the keep-alive interval ago
+      if (Date.now() - this._wsRequester.lastRequestTime >= this.keepAliveInterval) {
+        const timeoutSignal = this.timeout ? AbortSignal_.timeout(this.keepAliveInterval) : undefined;
+        await this._wsRequester.request("ping", timeoutSignal)
+          .catch(() => undefined); // Ignore errors
+      }
+
+      // Schedule the next ping
+      if (
+        this.socket.readyState === ReconnectingWebSocket.OPEN && this._keepAliveTimeout &&
+        this.keepAliveInterval !== null
+      ) {
+        const nextDelay = this.keepAliveInterval - (Date.now() - this._wsRequester.lastRequestTime);
+        this._keepAliveTimeout = setTimeout(tick, nextDelay);
+      }
+    };
+
+    this._keepAliveTimeout = setTimeout(tick, this.keepAliveInterval);
+  }
+  protected _keepAliveStop(): void {
+    clearTimeout(this._keepAliveTimeout);
+    this._keepAliveTimeout = undefined;
+  }
+
+  /** Resubscribe to all existing subscriptions if auto-resubscribe is enabled. */
+  protected _resubscribeRun(): void {
+    if (this.resubscribe) {
+      for (const [id, subscription] of this._subscriptions.entries()) {
+        if (subscription.promiseFinished) { // reconnect only previously connected subscriptions to avoid double subscriptions due to message buffering.
+          subscription.promise = this._wsRequester.request("subscribe", JSON.parse(id))
+            .catch((error) => subscription.resubscribeAbortController.abort(error))
+            .finally(() => subscription.promiseFinished = true);
+          subscription.promiseFinished = false;
+        }
+      }
+    }
+  }
+  protected _resubscribeStop(): void {
+    if (!this.resubscribe || this.socket.terminationSignal.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
+        }
+      }
+    }
+  }
+
+  /**
+   * Sends a request to the Hyperliquid API via WebSocket.
+   * @param endpoint - The API endpoint to send the request to.
+   * @param payload - The payload to send with the request.
+   * @param signal - An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) can be used to cancel the request by calling [`abort()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort) on the corresponding [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/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)
+          .finally(() => subscription!.promiseFinished = true);
+
+        // Cache subscription info
+        subscription = {
+          listeners: new Map(),
+          promise,
+          promiseFinished: false,
+          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);
+            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);
+        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 [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) can be used to cancel the promise by calling [`abort()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort) on the corresponding [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/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.terminationSignal, signal])
+        : this.socket.terminationSignal;
+
+      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 [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) can be used to cancel the promise by calling [`abort()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort) on the corresponding [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/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 = () => {
+        reject(signal?.reason);
+      };
+
+      this.socket.addEventListener("close", handleClose, { once: true, signal });
+      this.socket.addEventListener("error", handleClose, { once: true, signal });
+      signal?.addEventListener("abort", handleAbort, { once: true });
+
+      this.socket.close();
+    });
+  }
+}

package/src/src/utils/_eip712.ts

@@ -0,0 +1,243 @@
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import * as secp from "@noble/secp256k1";
+
+export interface Types {
+  [type: string]: {
+    name: string;
+    type: string;
+  }[];
+}
+
+export interface Domain {
+  name?: string;
+  version?: string;
+  chainId?: number | string | bigint | `0x${string}`;
+  verifyingContract?: `0x${string}`;
+  salt?: `0x${string}`;
+}
+
+/** Signs typed data with a private key. */
+export async function signTypedData(args: {
+  privateKey: string | Uint8Array;
+  domain?: Domain;
+  types: Types;
+  primaryType: string;
+  message: Record<string, unknown>;
+}): Promise<`0x${string}`> {
+  const {
+    privateKey,
+    domain = {},
+    types,
+    primaryType,
+    message,
+  } = args;
+
+  const hash = hashTypedData({ domain, types, primaryType, message });
+
+  const pk = typeof privateKey === "string" ? secp.etc.hexToBytes(cleanHex(privateKey)) : privateKey;
+  const sigr = await secp.signAsync(hash, pk, { prehash: false, format: "recovered" });
+
+  const r = secp.etc.bytesToHex(sigr.slice(1, 33));
+  const s = secp.etc.bytesToHex(sigr.slice(33, 65));
+  const v = (sigr[0] + 27).toString(16).padStart(2, "0");
+
+  return `0x${r}${s}${v}`;
+}
+
+/** Hashes typed data according to EIP-712. */
+export function hashTypedData(args: {
+  domain: Domain;
+  types: Types;
+  primaryType: string;
+  message: Record<string, unknown>;
+}): Uint8Array {
+  const { domain, types: types_, primaryType, message } = args;
+
+  const domainFields = [];
+  if (domain.name !== undefined) {
+    domainFields.push({ name: "name", type: "string" });
+  }
+  if (domain.version !== undefined) {
+    domainFields.push({ name: "version", type: "string" });
+  }
+  if (domain.chainId !== undefined) {
+    domainFields.push({ name: "chainId", type: "uint256" });
+  }
+  if (domain.verifyingContract !== undefined) {
+    domainFields.push({ name: "verifyingContract", type: "address" });
+  }
+  if (domain.salt !== undefined) {
+    domainFields.push({ name: "salt", type: "bytes32" });
+  }
+
+  const types = {
+    EIP712Domain: domainFields,
+    ...types_,
+  };
+
+  const bytes: Uint8Array[] = [new Uint8Array([0x19, 0x01])];
+  bytes.push(hashStruct("EIP712Domain", domain as Record<string, unknown>, types));
+  if (primaryType !== "EIP712Domain") bytes.push(hashStruct(primaryType, message, types));
+
+  return keccak_256(secp.etc.concatBytes(...bytes));
+}
+
+function hashStruct(primaryType: string, data: Record<string, unknown>, types: Types): Uint8Array {
+  const typeHash = keccak_256(new TextEncoder().encode(encodeType(primaryType, types)));
+  const encodedValues = types[primaryType].map((field) => encodeValue(field.type, data[field.name], types));
+  return keccak_256(secp.etc.concatBytes(typeHash, ...encodedValues));
+}
+
+function encodeType(primaryType: string, types: Types): string {
+  const deps = findTypeDependencies(primaryType, types);
+  const sortedDeps = [primaryType, ...deps.filter((d) => d !== primaryType).sort()];
+  return sortedDeps
+    .map((type) => `${type}(${types[type].map((field) => `${resolveTypeAlias(field.type)} ${field.name}`).join(",")})`)
+    .join("");
+}
+
+function resolveTypeAlias(type: string): string {
+  if (type === "uint") return "uint256";
+  if (type === "int") return "int256";
+  return type;
+}
+
+function findTypeDependencies(primaryType: string, types: Types, _found = new Set<string>()): string[] {
+  if (_found.has(primaryType) || !types[primaryType]) return [];
+  _found.add(primaryType);
+
+  for (const field of types[primaryType]) {
+    const baseType = field.type.replace(/\[.*?\]/g, "");
+    if (types[baseType]) {
+      findTypeDependencies(baseType, types, _found);
+    }
+  }
+  return Array.from(_found);
+}
+
+function encodeValue(type: string, value: unknown, types: Types): Uint8Array {
+  const arrayMatch = type.match(/^(.*)\[(\d*)\]$/);
+  if (arrayMatch) {
+    // Extract type info: base type and optional length
+    const [, baseType, len] = arrayMatch;
+    if (!Array.isArray(value)) {
+      throw new Error(`Expected array for ${type}. Received: ${typeof value}`);
+    }
+    if (len && value.length !== +len) {
+      throw new Error(`Invalid length for ${type}: expected ${len}. Received: ${value.length}`);
+    }
+
+    // Encode each element in the array and hash them together
+    const encodedElements = value.map((v) => encodeValue(baseType, v, types));
+    return keccak_256(secp.etc.concatBytes(...encodedElements));
+  }
+
+  if (types[type]) {
+    if (value === undefined) return new Uint8Array(32);
+    return hashStruct(type, value as Record<string, unknown>, types);
+  }
+
+  if (type === "string") {
+    return keccak_256(new TextEncoder().encode(value as string));
+  }
+
+  if (type === "address") {
+    const bytes = secp.etc.hexToBytes(cleanHex(value as string));
+    if (bytes.length !== 20) {
+      throw new Error(`Address must be 20 bytes.`);
+    }
+    const padded = new Uint8Array(32);
+    padded.set(bytes, 12);
+    return padded;
+  }
+
+  if (type.startsWith("uint") || type.startsWith("int")) {
+    // Extract type info: uint/int and bit size
+    const isUint = type.startsWith("uint");
+    const bitsStr = type.slice(isUint ? 4 : 3);
+    const bits = parseInt(bitsStr || "256");
+    if (bits > 256 || bits % 8 !== 0) {
+      throw new Error(`Invalid ${isUint ? "uint" : "int"} size: ${bitsStr}. Must be 8-256 in steps of 8`);
+    }
+
+    // Apply Two's complement for specified bit size
+    const bigIntValue = BigInt(value as number | string | bigint | `0x${string}`);
+    const resizedValue = isUint ? BigInt.asUintN(bits, bigIntValue) : BigInt.asIntN(bits, bigIntValue);
+
+    // Convert to 32-byte big-endian
+    const hex = BigInt.asUintN(256, resizedValue).toString(16).padStart(64, "0");
+    return secp.etc.hexToBytes(hex);
+  }
+
+  if (type === "bool") {
+    const result = new Uint8Array(32);
+    result[31] = value ? 1 : 0;
+    return result;
+  }
+
+  if (type === "bytes") {
+    const bytes = typeof value === "string" ? secp.etc.hexToBytes(cleanHex(value)) : value as Uint8Array;
+    return keccak_256(bytes);
+  }
+
+  const bytesMatch = type.match(/^bytes(\d+)$/);
+  if (bytesMatch) {
+    // Extract type info: bytes size
+    const size = parseInt(bytesMatch[1]);
+    if (size === 0 || size > 32) {
+      throw new Error(`bytesN size must be 1-32. Received: ${size}`);
+    }
+
+    // Convert hex to bytes
+    const bytes = secp.etc.hexToBytes(cleanHex(value as string));
+    if (bytes.length !== size) {
+      throw new Error(`${type} requires exactly ${size} bytes. Received: ${bytes.length} from '${value}'`);
+    }
+
+    // Pad to 32 bytes
+    const padded = new Uint8Array(32);
+    padded.set(bytes, 0);
+    return padded;
+  }
+
+  throw new Error(`Unsupported type: '${type}'.`);
+}
+
+function cleanHex(hex: string): string {
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+
+// -------------------- For SDK --------------------
+
+import type { AbstractViemLocalAccount } from "../signing/mod.js";
+
+/** A minimalist EIP-712 signer using a raw private key. */
+export class PrivateKeyEIP712Signer implements AbstractViemLocalAccount {
+  #privateKey: string | Uint8Array;
+  address: `0x${string}`;
+  constructor(privateKey: string | Uint8Array) {
+    this.#privateKey = privateKey;
+    this.address = privateKeyToAddress(privateKey); // and validate the private key
+  }
+  signTypedData(params: {
+    domain: Domain;
+    types: Types;
+    primaryType: string;
+    message: Record<string, unknown>;
+  }): Promise<`0x${string}`> {
+    return signTypedData({ privateKey: this.#privateKey, ...params });
+  }
+}
+
+function privateKeyToAddress(privateKey: string | Uint8Array): `0x${string}` {
+  const pk = typeof privateKey === "string" ? secp.etc.hexToBytes(cleanHex(privateKey)) : privateKey;
+  const publicKey = secp.getPublicKey(pk, false);
+  return publicKeyToAddress(publicKey);
+}
+
+function publicKeyToAddress(publicKey: Uint8Array): `0x${string}` {
+  const publicKeyWithoutPrefix = publicKey.slice(1);
+  const hash = keccak_256(publicKeyWithoutPrefix);
+  const addressBytes = hash.slice(-20);
+  return `0x${secp.etc.bytesToHex(addressBytes)}`;
+}