@nktkas/hyperliquid 0.25.6 → 0.25.8

package/src/src/api/subscription/~client.ts

@@ -16,6 +16,7 @@ import { l2Book } from "./l2Book.js";
 import { notification } from "./notification.js";
 import { openOrders } from "./openOrders.js";
 import { orderUpdates } from "./orderUpdates.js";
+import { spotState } from "./spotState.js";
 import { trades } from "./trades.js";
 import { userEvents } from "./userEvents.js";
 import { userFills } from "./userFills.js";
@@ -25,6 +26,7 @@ import { userNonFundingLedgerUpdates } from "./userNonFundingLedgerUpdates.js";
 import { userTwapHistory } from "./userTwapHistory.js";
 import { userTwapSliceFills } from "./userTwapSliceFills.js";
 import { webData2 } from "./webData2.js";
+import { webData3 } from "./webData3.js";
 
 export type {
   ActiveAssetCtxEvent as WsActiveAssetCtxEvent,
@@ -67,6 +69,7 @@ export type {
   OrderUpdatesEvent as WsOrderUpdatesEvent,
   OrderUpdatesParameters as WsOrderUpdatesParameters,
 } from "./orderUpdates.js";
+export type { SpotStateEvent as WsSpotStateEvent, SpotStateParameters as WsSpotStateParameters } from "./spotState.js";
 export type { TradesEvent as WsTradesEvent, TradesParameters as WsTradesParameters } from "./trades.js";
 export type {
   UserEventsEvent as WsUserEventsEvent,
@@ -94,6 +97,7 @@ export type {
   UserTwapSliceFillsParameters as WsUserTwapSliceFillsParameters,
 } from "./userTwapSliceFills.js";
 export type { WebData2Event as WsWebData2Event, WebData2Parameters as WsWebData2Parameters } from "./webData2.js";
+export type { WebData3Event as WsWebData3Event, WebData3Parameters as WsWebData3Parameters } from "./webData3.js";
 
 export type { SubscriptionRequestConfig } from "./_types.js";
 
@@ -452,6 +456,29 @@ export class SubscriptionClient<
     return orderUpdates(this, ...args);
   }
 
+  /**
+   * Subscribe to spot state updates for a specific user.
+   * @param params - Parameters specific to the API subscription.
+   * @param listener - A callback function to be called when the event is received.
+   * @returns A request-promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
+   *
+   * @throws {TransportError} When the transport layer throws an error.
+   *
+   * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+   * @example
+   * ```ts
+   * import * as hl from "@nktkas/hyperliquid";
+   *
+   * const transport = new hl.WebSocketTransport();
+   *
+   * const client = new hl.SubscriptionClient({ transport });
+   * const sub = await client.spotState({ user: "0x..." }, (data) => console.log(data));
+   * ```
+   */
+  spotState(...args: OmitFirst<OverloadedParameters<typeof spotState>>) {
+    return spotState(this, ...args);
+  }
+
   /**
    * Subscribe to real-time trade updates for a specific asset.
    * @param params - Parameters specific to the API subscription.
@@ -660,4 +687,27 @@ export class SubscriptionClient<
   webData2(...args: OmitFirst<OverloadedParameters<typeof webData2>>) {
     return webData2(this, ...args);
   }
+
+  /**
+   * Subscribe to comprehensive user and market data updates.
+   * @param params - Parameters specific to the API subscription.
+   * @param listener - A callback function to be called when the event is received.
+   * @returns A request-promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
+   *
+   * @throws {TransportError} When the transport layer throws an error.
+   *
+   * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+   * @example
+   * ```ts
+   * import * as hl from "@nktkas/hyperliquid";
+   *
+   * const transport = new hl.WebSocketTransport();
+   *
+   * const client = new hl.SubscriptionClient({ transport });
+   * const sub = await client.webData3({ user: "0x..." }, (data) => console.log(data));
+   * ```
+   */
+  webData3(...args: OmitFirst<OverloadedParameters<typeof webData3>>) {
+    return webData3(this, ...args);
+  }
 }

package/src/src/api/subscription/~mod.ts

@@ -40,6 +40,7 @@ export * from "./l2Book.js";
 export * from "./notification.js";
 export * from "./openOrders.js";
 export * from "./orderUpdates.js";
+export * from "./spotState.js";
 export * from "./trades.js";
 export * from "./userEvents.js";
 export * from "./userFills.js";
@@ -49,3 +50,4 @@ export * from "./userNonFundingLedgerUpdates.js";
 export * from "./userTwapHistory.js";
 export * from "./userTwapSliceFills.js";
 export * from "./webData2.js";
+export * from "./webData3.js";

package/src/src/signing/_signTypedData.ts

@@ -218,7 +218,7 @@ export async function getWalletChainId(wallet: AbstractWallet): Promise<`0x${str
   }
 }
 
-/** Get the wallet address from various wallet types. */
+/** Get the lowercase wallet address from various wallet types. */
 export async function getWalletAddress(wallet: AbstractWallet): Promise<`0x${string}`> {
   if (isAbstractViemWallet(wallet)) {
     if ("address" in wallet && wallet.address) {

package/src/src/utils/{_minimalEIP712Signer.ts → _eip712.ts}

@@ -1,5 +1,3 @@
-// -------------------- EIP-712 --------------------
-
 import { keccak_256 } from "@noble/hashes/sha3.js";
 import * as secp from "@noble/secp256k1";
 
@@ -19,7 +17,7 @@ export interface Domain {
 }
 
 /** Signs typed data with a private key. */
-async function signTypedData(args: {
+export async function signTypedData(args: {
   privateKey: string | Uint8Array;
   domain?: Domain;
   types: Types;
@@ -36,20 +34,18 @@ async function signTypedData(args: {
 
   const hash = hashTypedData({ domain, types, primaryType, message });
 
-  const signature = await secp.signAsync(
-    hash,
-    privateKey instanceof Uint8Array ? privateKey : secp.etc.hexToBytes(cleanHex(privateKey)),
-    { prehash: false, format: "recovered" },
-  );
+  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(signature.slice(1, 33));
-  const s = secp.etc.bytesToHex(signature.slice(33, 65));
-  const v = (signature[0] + 27).toString(16).padStart(2, "0");
+  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}`;
 }
 
-function hashTypedData(args: {
+/** Hashes typed data according to EIP-712. */
+export function hashTypedData(args: {
   domain: Domain;
   types: Types;
   primaryType: string;
@@ -211,7 +207,7 @@ function cleanHex(hex: string): string {
   return hex.startsWith("0x") ? hex.slice(2) : hex;
 }
 
-// -------------------- Interaction API --------------------
+// -------------------- For SDK --------------------
 
 import type { AbstractViemLocalAccount } from "../signing/mod.js";
 
@@ -221,30 +217,27 @@ export class PrivateKeyEIP712Signer implements AbstractViemLocalAccount {
   address: `0x${string}`;
   constructor(privateKey: string | Uint8Array) {
     this.#privateKey = privateKey;
-    this.address = privateKeyToAddress(privateKey); // and validate the key
-  }
-  signTypedData(
-    params: {
-      domain: Domain;
-      types: Types;
-      primaryType: string;
-      message: Record<string, unknown>;
-    },
-  ): Promise<`0x${string}`> {
+    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);
-  const publicKeyWithoutPrefix = publicKey.slice(1);
+  return publicKeyToAddress(publicKey);
+}
 
+function publicKeyToAddress(publicKey: Uint8Array): `0x${string}` {
+  const publicKeyWithoutPrefix = publicKey.slice(1);
   const hash = keccak_256(publicKeyWithoutPrefix);
-
   const addressBytes = hash.slice(-20);
-  const address = secp.etc.bytesToHex(addressBytes);
-
-  return `0x${address}`;
+  return `0x${secp.etc.bytesToHex(addressBytes)}`;
 }

package/src/src/utils/_format.ts

@@ -0,0 +1,173 @@
+/**
+ * Format price according to Hyperliquid {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/tick-and-lot-size | rules}:
+ * - Maximum 5 significant figures
+ * - Maximum 6 (for perp) or 8 (for spot) - `szDecimals` decimal places
+ * - Integer prices are always allowed regardless of significant figures
+ * @example
+ * ```ts
+ * import { formatPrice } from "@nktkas/hyperliquid/utils";
+ *
+ * //        `true` for perp (default), `false` for spot
+ * //                                              ⌄⌄⌄⌄⌄
+ * const price = formatPrice("0.0000123456789", 0, false); // → "0.00001234"
+ * ```
+ */
+export function formatPrice(price: string | number, szDecimals: number, isPerp: boolean = true): string {
+  price = price.toString().trim();
+  assertNumberString(price);
+
+  // Integer prices are always allowed
+  if (/^-?\d+$/.test(price)) return trimZeros(price);
+
+  // Apply decimal limit: max 6 (perp) or 8 (spot) - szDecimals
+  const maxDecimals = Math.max((isPerp ? 6 : 8) - szDecimals, 0);
+  price = StringMath.toFixedTruncate(price, maxDecimals);
+
+  // Apply sig figs limit: max 5 significant figures
+  price = StringMath.toPrecisionTruncate(price, 5);
+
+  return price;
+}
+
+/**
+ * Format size according to Hyperliquid {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/tick-and-lot-size | rules}:
+ * - Truncate decimal places to `szDecimals`
+ * @example
+ * ```ts
+ * import { formatSize } from "@nktkas/hyperliquid/utils";
+ *
+ * const size = formatSize("1.23456789", 5); // → "1.23456"
+ * ```
+ * @note May return 0 if the value is not suitable, but when closing a position, a size of 0 means the full size.
+ */
+export function formatSize(size: string | number, szDecimals: number): string {
+  size = size.toString().trim();
+  assertNumberString(size);
+
+  // Apply decimal limit: szDecimals
+  size = StringMath.toFixedTruncate(size, szDecimals);
+
+  return size;
+}
+
+/** String-based Math operations for arbitrary precision */
+const StringMath = {
+  /** Floor log10 (magnitude): position of most significant digit */
+  log10Floor(value: string): number {
+    const abs = value[0] === "-" ? value.slice(1) : value;
+
+    // Check if zero or invalid
+    const num = Number(abs);
+    if (num === 0 || isNaN(num)) return -Infinity;
+
+    const [int, dec] = abs.split(".");
+
+    // Number >= 1: magnitude = length of integer part - 1
+    if (Number(int) !== 0) {
+      const trimmed = int.replace(/^0+/, "");
+      return trimmed.length - 1;
+    }
+
+    // Number < 1: count leading zeros in decimal part
+    const leadingZeros = dec.match(/^0*/)?.[0].length ?? 0;
+    return -(leadingZeros + 1);
+  },
+
+  /** Multiply by 10^exp: shift decimal point left (negative) or right (positive) */
+  multiplyByPow10(value: string, exp: number): string {
+    if (!Number.isInteger(exp)) throw new RangeError("Exponent must be an integer");
+    if (exp === 0) return trimZeros(value);
+
+    const neg = value[0] === "-";
+    const abs = neg ? value.slice(1) : value;
+    const [intRaw, dec = ""] = abs.split(".");
+    // Normalize empty integer part to "0" (handles ".5" → "0.5")
+    const int = intRaw || "0";
+
+    let result: string;
+
+    if (exp > 0) {
+      // Shift right: move digits from decimal to integer
+      if (exp >= dec.length) {
+        result = int + dec + "0".repeat(exp - dec.length);
+      } else {
+        result = int + dec.slice(0, exp) + "." + dec.slice(exp);
+      }
+    } else {
+      // Shift left: move digits from integer to decimal
+      const absExp = -exp;
+      if (absExp >= int.length) {
+        result = "0." + "0".repeat(absExp - int.length) + int + dec;
+      } else {
+        result = int.slice(0, -absExp) + "." + int.slice(-absExp) + dec;
+      }
+    }
+
+    return trimZeros((neg ? "-" : "") + result);
+  },
+
+  /** Returns the integer part of a number by removing any fractional digits */
+  trunc(value: string): string {
+    const dotIndex = value.indexOf(".");
+    return dotIndex === -1 ? value : value.slice(0, dotIndex) || "0";
+  },
+
+  /** Truncate to a certain number of significant figures */
+  toPrecisionTruncate(value: string, precision: number): string {
+    if (!Number.isInteger(precision)) throw new RangeError("Precision must be an integer");
+    if (precision < 1) throw new RangeError("Precision must be positive");
+    if (/^-?0+(\.0*)?$/.test(value)) return "0"; // zero is special case (don't work with log10)
+
+    const neg = value[0] === "-";
+    const abs = neg ? value.slice(1) : value;
+
+    // Calculate how much to shift: align most significant digit to ones place + (maxSigFigs-1)
+    const magnitude = StringMath.log10Floor(abs);
+    const shiftAmount = precision - magnitude - 1;
+
+    // Shift right, truncate integer part, shift back
+    const shifted = StringMath.multiplyByPow10(abs, shiftAmount);
+    const truncated = StringMath.trunc(shifted);
+    const result = StringMath.multiplyByPow10(truncated, -shiftAmount);
+
+    // build final result and trim zeros
+    return trimZeros(neg ? "-" + result : result);
+  },
+
+  /** Truncate to a certain number of decimal places */
+  toFixedTruncate(value: string, decimals: number): string {
+    if (!Number.isInteger(decimals)) throw new RangeError("Decimals must be an integer");
+    if (decimals < 0) throw new RangeError("Decimals must be non-negative");
+
+    // Match number with up to `decimals` decimal places
+    const regex = new RegExp(`^-?(?:\\d+)?(?:\\.\\d{0,${decimals}})?`);
+    const result = value.match(regex)?.[0];
+
+    if (!result) {
+      throw new TypeError("Invalid number format");
+    }
+
+    // Trim zeros after truncation
+    return trimZeros(result);
+  },
+};
+
+function trimZeros(value: string): string {
+  return value
+    // remove leading zeros
+    .replace(/^(-?)0+(?=\d)/, "$1") // "00123" → "123", "-00.5" → "-0.5"
+    // remove trailing zeros
+    .replace(/\.0*$|(\.\d+?)0+$/, "$1") // "1.2000" → "1.2", "5.0" → "5"
+    // add leading zero if starts with decimal point
+    .replace(/^(-?)\./, "$10.") // ".5" → "0.5", "-.5" → "-0.5"
+    // add "0" if string is empty after trimming
+    .replace(/^-?$/, "0") // "" → "0", "-" → "0"
+    // normalize negative zero
+    .replace(/^-0$/, "0"); // "-0" → "0"
+}
+
+function assertNumberString(value: string): void {
+  if (!/^-?(\d+\.?\d*|\.\d*)$/.test(value)) {
+    throw new TypeError("Invalid number format");
+  }
+}

package/src/src/utils/_recover.ts

@@ -0,0 +1,178 @@
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import * as secp from "@noble/secp256k1";
+import { createL1ActionHash, type Signature } from "../signing/mod.js";
+import { hashTypedData } from "./_eip712.js";
+
+/**
+ * Recover the Ethereum address that signed an L1 action.
+ * @example
+ * ```ts
+ * import { recoverUserFromL1Action } from "@nktkas/hyperliquid/utils";
+ *
+ * const action = {
+ *   type: "cancel",
+ *   cancels: [{ a: 0, o: 12345 }],
+ * };
+ * const nonce = 1700000000000;
+ * const signature = {
+ *   r: "0x...",
+ *   s: "0x...",
+ *   v: 27,
+ * } as const;
+ *
+ * const address = await recoverUserFromL1Action({ action, nonce, signature });
+ * console.log(`Signer address: ${address}`);
+ * ```
+ */
+export async function recoverUserFromL1Action(params: {
+  /** The action that was signed (hash depends on key order). */
+  action: Record<string, unknown>;
+  /** The timestamp in ms used when signing. */
+  nonce: number;
+  /** The signature to recover the address from. */
+  signature: Signature;
+  /** Indicates if the action is for the testnet. (default: false) */
+  isTestnet?: boolean;
+  /** Optional vault address used in the action. */
+  vaultAddress?: `0x${string}`;
+  /** Optional expiration time in ms used in the action. */
+  expiresAfter?: number;
+}): Promise<`0x${string}`> {
+  const {
+    action,
+    signature,
+    nonce,
+    isTestnet = false,
+    vaultAddress,
+    expiresAfter,
+  } = params;
+
+  // 1. Create the action hash
+  const actionHash = createL1ActionHash({ action, nonce, vaultAddress, expiresAfter });
+
+  // 2. Hash the typed data according to EIP-712
+  const hash = hashTypedData({
+    domain: {
+      name: "Exchange",
+      version: "1",
+      chainId: 1337,
+      verifyingContract: "0x0000000000000000000000000000000000000000",
+    },
+    types: {
+      Agent: [
+        { name: "source", type: "string" },
+        { name: "connectionId", type: "bytes32" },
+      ],
+    },
+    primaryType: "Agent",
+    message: {
+      source: isTestnet ? "b" : "a",
+      connectionId: actionHash,
+    },
+  });
+
+  // 3. Convert signature to recovery format (v, r, s)
+  const sigr = secp.etc.concatBytes(
+    new Uint8Array([signature.v - 27]),
+    secp.etc.hexToBytes(signature.r.slice(2)),
+    secp.etc.hexToBytes(signature.s.slice(2)),
+  );
+
+  // 4. Recover the public key from the signature and hash
+  const compressedPubKey = await secp.recoverPublicKeyAsync(sigr, hash, { prehash: false });
+  const uncompressedPubKey = secp.Point.fromBytes(compressedPubKey).toBytes(false);
+
+  // 5. Convert the public key to an Ethereum address
+  return publicKeyToAddress(uncompressedPubKey);
+}
+
+/**
+ * Recover the Ethereum address that signed a user-signed action.
+ * @example
+ * ```ts
+ * import { recoverUserFromUserSigned } from "@nktkas/hyperliquid/utils";
+ *
+ * const action = {
+ *   type: "approveAgent",
+ *   signatureChainId: "0x66eee" as const,
+ *   hyperliquidChain: "Mainnet",
+ *   agentAddress: "0x...",
+ *   agentName: "Agent",
+ *   nonce: 1700000000000,
+ * };
+ * const types = {
+ *   HyperliquidTransaction: [
+ *     { name: "hyperliquidChain", type: "string" },
+ *     // ... other fields
+ *   ],
+ * };
+ * const signature = {
+ *   r: "0x...",
+ *   s: "0x...",
+ *   v: 27,
+ * } as const;
+ *
+ * const address = await recoverUserFromUserSigned({ action, types, signature });
+ * console.log(`Signer address: ${address}`);
+ * ```
+ */
+export async function recoverUserFromUserSigned(params: {
+  /** The action that was signed (hex strings must be in lower case). */
+  action:
+    & {
+      signatureChainId: `0x${string}`;
+      [key: string]: unknown;
+    }
+    & (
+      | { nonce: number; time?: undefined }
+      | { time: number; nonce?: undefined }
+    );
+  /** The types of the action (hash depends on key order). */
+  types: {
+    [key: string]: {
+      name: string;
+      type: string;
+    }[];
+  };
+  /** The signature to recover the address from. */
+  signature: Signature;
+}): Promise<`0x${string}`> {
+  const { action, types, signature } = params;
+
+  // 1. Hash the typed data according to EIP-712
+  const hash = hashTypedData({
+    domain: {
+      name: "HyperliquidSignTransaction",
+      version: "1",
+      chainId: parseInt(action.signatureChainId),
+      verifyingContract: "0x0000000000000000000000000000000000000000",
+    },
+    types,
+    primaryType: Object.keys(types)[0],
+    message: action,
+  });
+
+  // 2. Convert signature to recovery format (v, r, s)
+  const sigr = secp.etc.concatBytes(
+    new Uint8Array([signature.v - 27]),
+    secp.etc.hexToBytes(signature.r.slice(2)),
+    secp.etc.hexToBytes(signature.s.slice(2)),
+  );
+
+  // 3. Recover the public key from the signature and hash
+  const compressedPubKey = await secp.recoverPublicKeyAsync(sigr, hash, { prehash: false });
+  const uncompressedPubKey = secp.Point.fromBytes(compressedPubKey).toBytes(false);
+
+  // 4. Convert the public key to an Ethereum address
+  return publicKeyToAddress(uncompressedPubKey);
+}
+
+/** Convert a public key to an Ethereum address. */
+function publicKeyToAddress(publicKey: Uint8Array): `0x${string}` {
+  // Remove the 0x04 prefix from uncompressed public key
+  const publicKeyWithoutPrefix = publicKey.slice(1);
+  // Hash the public key and take the last 20 bytes as the address
+  const hash = keccak_256(publicKeyWithoutPrefix);
+  const addressBytes = hash.slice(-20);
+  return `0x${secp.etc.bytesToHex(addressBytes)}`;
+}

package/src/src/utils/_symbolConverter.ts

@@ -25,6 +25,9 @@ export interface SymbolConverterOptions {
  * const transport = new HttpTransport(); // or `WebSocketTransport`
  * const converter = await SymbolConverter.create({ transport });
  *
+ * // By default, dexs are not loaded; specify them when creating an instance
+ * // const converter = await SymbolConverter.create({ transport, dexs: ["test"] });
+ *
  * const btcId = converter.getAssetId("BTC"); // perpetual → 0
  * const hypeUsdcId = converter.getAssetId("HYPE/USDC"); // spot market → 10107
  * const dexAbcId = converter.getAssetId("test:ABC"); // builder dex (if enabled) → 110000
@@ -32,6 +35,8 @@ export interface SymbolConverterOptions {
  * const btcSzDecimals = converter.getSzDecimals("BTC"); // perpetual → 5
  * const hypeUsdcSzDecimals = converter.getSzDecimals("HYPE/USDC"); // spot market → 2
  * const dexAbcSzDecimals = converter.getSzDecimals("test:ABC"); // builder dex (if enabled) → 0
+ *
+ * const spotPairId = converter.getSpotPairId("HFUN/USDC"); // → "@2"
  * ```
  */
 export class SymbolConverter {
@@ -39,6 +44,7 @@ export class SymbolConverter {
   private readonly dexOption: DexOption;
   private readonly nameToAssetId = new Map<string, number>();
   private readonly nameToSzDecimals = new Map<string, number>();
+  private readonly nameToSpotPairId = new Map<string, string>();
 
   private constructor(options: SymbolConverterOptions) {
     this.transport = options.transport;
@@ -86,6 +92,7 @@ export class SymbolConverter {
 
     this.nameToAssetId.clear();
     this.nameToSzDecimals.clear();
+    this.nameToSpotPairId.clear();
 
     this.processDefaultPerps(perpMetaData);
     this.processSpotAssets(spotMetaData);
@@ -158,6 +165,7 @@ export class SymbolConverter {
       const baseQuoteKey = `${baseToken.name}/${quoteToken.name}`;
       this.nameToAssetId.set(baseQuoteKey, assetId);
       this.nameToSzDecimals.set(baseQuoteKey, baseToken.szDecimals);
+      this.nameToSpotPairId.set(baseQuoteKey, market.name);
     });
   }
 
@@ -182,4 +190,14 @@ export class SymbolConverter {
   getSzDecimals(name: string): number | undefined {
     return this.nameToSzDecimals.get(name);
   }
+
+  /**
+   * Get spot pair ID for info endpoints and subscriptions (e.g., l2book, trades).
+   *
+   * Accepts spot markets in the "BASE/QUOTE" format (e.g., "HFUN/USDC").
+   * @example "HFUN/USDC" → "@2", "PURR/USDC" → "PURR/USDC"
+   */
+  getSpotPairId(name: string): string | undefined {
+    return this.nameToSpotPairId.get(name);
+  }
 }

package/src/src/utils/mod.ts

@@ -1 +1,3 @@
 export * from "./_symbolConverter.js";
+export * from "./_format.js";
+export * from "./_recover.js";

package/esm/src/api/exchange/_base/_sequential.d.ts

@@ -1,30 +0,0 @@
-/**
- * Sequential request execution to prevent nonce race conditions.
- *
- * Problem: When multiple requests are sent rapidly, they may execute in different order
- * on the transport layer, causing nonce errors (e.g., server receives nonce 101 before 100).
- *
- * Solution: Queue ensures requests execute sequentially in order.
- */
-import type { ExchangeRequestConfig, MultiSignRequestConfig } from "./_types.js";
-/**
- * Request queue for sequential execution of requests.
- * Ensures that requests are executed in order, preventing them from arriving at the server out of sequence.
- */
-declare class RequestQueue {
-    private queue;
-    /**
-     * Enqueue a request to be executed sequentially.
-     * @param fn - The function to execute.
-     * @returns A promise that resolves with the result of the function.
-     */
-    enqueue<T>(fn: () => Promise<T>): Promise<T>;
-}
-/**
- * Get or create a request queue for the given config.
- * Uses a global Map keyed by wallet address to ensure the same wallet uses the same queue
- * regardless of whether called via client or direct function.
- */
-export declare function getRequestQueue(config: ExchangeRequestConfig | MultiSignRequestConfig): Promise<RequestQueue | undefined>;
-export {};
-//# sourceMappingURL=_sequential.d.ts.map

package/esm/src/api/exchange/_base/_sequential.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_sequential.d.ts","sourceRoot":"","sources":["../../../../../src/src/api/exchange/_base/_sequential.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAGjF;;;GAGG;AACH,cAAM,YAAY;IAChB,OAAO,CAAC,KAAK,CAAuC;IAEpD;;;;OAIG;IACH,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAK7C;AAmBD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAAG,sBAAsB,GACrD,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CA0BnC"}