@hfunlabs/hyperliquid 0.30.2-hfunlabs.2 → 0.32.2-hfunlabs.3

package/src/deps/jsr.io/@std/async/1.0.16/unstable_semaphore.ts

@@ -1,146 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-
-/** Internal node for the FIFO waiting queue. */
-interface Node {
-  res: () => void;
-  next: Node | undefined;
-}
-
-/**
- * A counting semaphore for limiting concurrent access to a resource.
- *
- * @experimental **UNSTABLE**: New API, yet to be vetted.
- *
- * @example Usage
- * ```ts
- * import { Semaphore } from "@std/async/unstable-semaphore";
- *
- * const sem = new Semaphore(2);
- * {
- *   using _permit = await sem.acquire();
- *   // critical section
- * } // permit is automatically released when exiting the block
- * ```
- */
-export class Semaphore {
-  #max: number;
-  /** Current number of available permits. */
-  #count: number;
-  /** Head of the waiting queue. */
-  #head: Node | undefined;
-  /** Tail of the waiting queue. */
-  #tail: Node | undefined;
-
-  /**
-   * Creates a new semaphore with the specified number of permits.
-   *
-   * @param max Maximum concurrent permits. Defaults to 1 (mutex).
-   */
-  constructor(max: number = 1) {
-    if (max < 1) {
-      throw new TypeError(
-        `Cannot create semaphore as 'max' must be at least 1: current value is ${max}`,
-      );
-    }
-    this.#count = this.#max = max;
-  }
-
-  /**
-   * Acquires a permit, waiting if none are available.
-   *
-   * @example Usage
-   * ```ts no-assert
-   * import { Semaphore } from "@std/async/unstable-semaphore";
-   *
-   * const sem = new Semaphore(1);
-   * await sem.acquire();
-   * try {
-   *   // critical section
-   * } finally {
-   *   sem.release();
-   * }
-   * ```
-   *
-   * @example Using `using` statement
-   * ```ts no-assert
-   * import { Semaphore } from "@std/async/unstable-semaphore";
-   *
-   * const sem = new Semaphore(1);
-   * {
-   *   using _permit = await sem.acquire();
-   *   // critical section
-   * } // permit is automatically released when exiting the block
-   * ```
-   *
-   * @returns A promise that resolves to a {@linkcode Disposable} when a permit is acquired.
-   */
-  acquire(): Promise<Disposable> {
-    const disposable: Disposable = { [Symbol.dispose]: () => this.release() };
-    if (this.#count > 0) {
-      this.#count--;
-      return Promise.resolve(disposable);
-    }
-    return new Promise((res) => {
-      const node: Node = { res: () => res(disposable), next: undefined };
-      if (this.#tail) {
-        this.#tail = this.#tail.next = node;
-      } else {
-        this.#head = this.#tail = node;
-      }
-    });
-  }
-
-  /**
-   * Tries to acquire a permit without waiting.
-   *
-   * @example Usage
-   * ```ts no-assert
-   * import { Semaphore } from "@std/async/unstable-semaphore";
-   *
-   * const sem = new Semaphore(1);
-   * const permit = sem.tryAcquire();
-   * if (permit) {
-   *   using _ = permit;
-   *   // critical section
-   * } else {
-   *   // resource is busy
-   * }
-   * ```
-   *
-   * @returns A {@linkcode Disposable} if a permit was acquired, `undefined` otherwise.
-   */
-  tryAcquire(): Disposable | undefined {
-    if (this.#count > 0) {
-      this.#count--;
-      return { [Symbol.dispose]: () => this.release() };
-    }
-    return undefined;
-  }
-
-  /**
-   * Releases a permit, allowing the next waiter to proceed.
-   *
-   * @example Usage
-   * ```ts no-assert
-   * import { Semaphore } from "@std/async/unstable-semaphore";
-   *
-   * const sem = new Semaphore(1);
-   * await sem.acquire();
-   * try {
-   *   // critical section
-   * } finally {
-   *   sem.release();
-   * }
-   * ```
-   */
-  release(): void {
-    if (this.#head) {
-      this.#head.res();
-      this.#head = this.#head.next;
-      if (!this.#head) this.#tail = undefined;
-    } else if (this.#count < this.#max) {
-      this.#count++;
-    }
-  }
-}

package/src/src/_base.ts

@@ -1,7 +0,0 @@
-/** Base error class for all SDK errors. */
-export class HyperliquidError extends Error {
-  constructor(message?: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = "HyperliquidError";
-  }
-}

package/src/src/api/_schemas.ts

@@ -1,110 +0,0 @@
-// deno-lint-ignore-file valibot-project/require-name-suffix valibot-project/require-jsdoc valibot-project/require-description
-
-import * as v from "valibot";
-
-// ============================================================
-// Number
-// ============================================================
-
-export const UnsignedDecimal = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.union([v.string(), v.number()]),
-    v.toString(),
-    v.string(), // HACK: for correct JSONSchema generation
-    v.transform((value) => formatDecimalString(value)),
-    v.regex(/^[0-9]+(\.[0-9]+)?$/),
-  );
-})();
-export type UnsignedDecimal = v.InferOutput<typeof UnsignedDecimal>;
-
-export const Decimal = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.union([v.string(), v.number()]),
-    v.toString(),
-    v.string(), // HACK: for correct JSONSchema generation
-    v.transform((value) => formatDecimalString(value)),
-    v.regex(/^-?[0-9]+(\.[0-9]+)?$/),
-  );
-})();
-export type Decimal = v.InferOutput<typeof Decimal>;
-
-export const Integer = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.union([v.string(), v.number()]),
-    v.toNumber(),
-    v.number(), // HACK: for correct JSONSchema generation
-    v.safeInteger(),
-  );
-})();
-export type Integer = v.InferOutput<typeof Integer>;
-
-export const UnsignedInteger = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.union([v.string(), v.number()]),
-    v.toNumber(),
-    v.number(), // HACK: for correct JSONSchema generation
-    v.safeInteger(),
-    v.minValue(0),
-  );
-})();
-export type UnsignedInteger = v.InferOutput<typeof UnsignedInteger>;
-
-function formatDecimalString(value: string): string {
-  return value
-    // remove leading/trailing whitespace
-    .trim() // "  123.45  " → "123.45"
-    // 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"
-}
-
-// ============================================================
-// Hex
-// ============================================================
-
-export const Hex = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.string(),
-    v.regex(/^0[xX][0-9a-fA-F]+$/),
-    v.transform((value) => value.toLowerCase() as `0x${string}`),
-  );
-})();
-export type Hex = v.InferOutput<typeof Hex>;
-
-export const Address = /* @__PURE__ */ (() => {
-  return v.pipe(Hex, v.length(42));
-})();
-export type Address = v.InferOutput<typeof Address>;
-
-export const Cloid = /* @__PURE__ */ (() => {
-  return v.pipe(Hex, v.length(34));
-})();
-export type Cloid = v.InferOutput<typeof Cloid>;
-
-// ============================================================
-// Other
-// ============================================================
-
-export const Percent = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.string(),
-    v.regex(/^[0-9]+(\.[0-9]+)?%$/),
-    v.transform((value) => value as `${string}%`),
-  );
-})();
-export type Percent = v.InferOutput<typeof Percent>;
-
-export const ISO8601WithoutTimezone = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.string(),
-    v.regex(/^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])[T ](?:0\d|1\d|2[0-3])(?::[0-5]\d){2}(?:\.\d{1,9})?$/),
-  );
-})();
-export type ISO8601WithoutTimezone = v.InferOutput<typeof ISO8601WithoutTimezone>;

package/src/src/api/exchange/_methods/_base/_nonce.ts

@@ -1,29 +0,0 @@
-/**
- * Nonce manager for generating unique nonces per wallet address and network.
- *
- * Uses lazy cleanup: removes entries when Date.now() > lastNonce.
- */
-class NonceManager {
-  #map = new Map<string, number>();
-
-  getNonce(key: string): number {
-    const now = Date.now();
-    this.#cleanup(now);
-
-    const lastNonce = this.#map.get(key) ?? 0;
-    const nonce = now > lastNonce ? now : lastNonce + 1;
-    this.#map.set(key, nonce);
-    return nonce;
-  }
-
-  #cleanup(now: number): void {
-    for (const [key, lastNonce] of this.#map) {
-      if (now > lastNonce) {
-        this.#map.delete(key);
-      }
-    }
-  }
-}
-
-/** Global nonce manager instance. */
-export const globalNonceManager = /* @__PURE__ */ new NonceManager();

package/src/src/api/exchange/_methods/_base/_semaphore.ts

@@ -1,74 +0,0 @@
-import { Semaphore } from "../../../../../deps/jsr.io/@std/async/1.0.16/unstable_semaphore.js";
-
-/**
- * A reference-counted registry for lazily creating and reusing per-key values.
- *
- * @template K - Map key type.
- * @template V - Stored value type.
- */
-class RefCountedRegistry<K, V> {
-  #map = new Map<K, { value: V; refs: number }>();
-  #factory: () => V;
-
-  /**
-   * Creates a new registry instance.
-   *
-   * @param factory - Factory function used to create a new value when a key is first referenced.
-   */
-  constructor(factory: () => V) {
-    this.#factory = factory;
-  }
-
-  /**
-   * Increments the reference count for a key and returns its value.
-   *
-   * If the key is not present, a new value is created via the factory.
-   *
-   * @param key - Registry key.
-   * @returns The value associated with the key.
-   */
-  ref(key: K): V {
-    let entry = this.#map.get(key);
-    if (!entry) {
-      entry = { value: this.#factory(), refs: 0 };
-      this.#map.set(key, entry);
-    }
-    entry.refs++;
-    return entry.value;
-  }
-
-  /**
-   * Decrements the reference count for a key.
-   *
-   * When the count reaches zero, the entry is removed.
-   *
-   * @param key - Registry key.
-   */
-  unref(key: K): void {
-    const entry = this.#map.get(key);
-    if (!entry) return;
-    if (--entry.refs === 0) {
-      this.#map.delete(key);
-    }
-  }
-}
-
-const semaphores = new RefCountedRegistry(() => new Semaphore(1));
-
-/**
- * Acquires a lock for the given key, executes the provided async function, and releases the lock.
- *
- * @param key The key to lock on.
- * @param fn The async function to execute while holding the lock.
- * @returns The result of the async function.
- */
-export async function withLock<K, T>(key: K, fn: () => Promise<T>): Promise<T> {
-  const semaphore = semaphores.ref(key);
-  await semaphore.acquire();
-  try {
-    return await fn();
-  } finally {
-    semaphore.release();
-    semaphores.unref(key);
-  }
-}

package/src/src/api/exchange/_methods/_base/commonSchemas.ts

@@ -1,84 +0,0 @@
-import * as v from "valibot";
-import { Hex } from "../../../_schemas.js";
-
-/** Error response for failed operations. */
-export const ErrorResponse = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.object({
-      /** Error status. */
-      status: v.pipe(
-        v.literal("err"),
-        v.description("Error status."),
-      ),
-      /** Error message. */
-      response: v.pipe(
-        v.string(),
-        v.description("Error message."),
-      ),
-    }),
-    v.description("Error response for failed operations."),
-  );
-})();
-export type ErrorResponse = v.InferOutput<typeof ErrorResponse>;
-
-/** Successful response without specific data. */
-export const SuccessResponse = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.object({
-      /** Successful status. */
-      status: v.pipe(
-        v.literal("ok"),
-        v.description("Successful status."),
-      ),
-      /** Response details. */
-      response: v.pipe(
-        v.object({
-          /** Type of response. */
-          type: v.pipe(
-            v.literal("default"),
-            v.description("Type of response."),
-          ),
-        }),
-        v.description("Response details."),
-      ),
-    }),
-    v.description("Successful response without specific data."),
-  );
-})();
-export type SuccessResponse = v.InferOutput<typeof SuccessResponse>;
-
-/** ECDSA signature components. */
-export const SignatureSchema = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.object({
-      /** First 32-byte component. */
-      r: v.pipe(
-        Hex,
-        v.length(66),
-        v.description("First 32-byte component."),
-      ),
-      /** Second 32-byte component. */
-      s: v.pipe(
-        Hex,
-        v.length(66),
-        v.description("Second 32-byte component."),
-      ),
-      /** Recovery identifier. */
-      v: v.pipe(
-        v.picklist([27, 28]),
-        v.description("Recovery identifier."),
-      ),
-    }),
-    v.description("ECDSA signature components."),
-  );
-})();
-export type SignatureSchema = v.InferOutput<typeof SignatureSchema>;
-
-/** HyperLiquid network type. */
-export const HyperliquidChainSchema = /* @__PURE__ */ (() => {
-  return v.pipe(
-    v.picklist(["Mainnet", "Testnet"]),
-    v.description("HyperLiquid network type."),
-  );
-})();
-export type HyperliquidChainSchema = v.InferOutput<typeof HyperliquidChainSchema>;

package/src/src/api/exchange/_methods/_base/errors.ts

@@ -1,108 +0,0 @@
-import { HyperliquidError } from "../../../../_base.js";
-
-// =============================================================
-// Error Detection (Duck Typing)
-// =============================================================
-
-/** Check if value has an error property. */
-function hasError(value: unknown): value is { error: string } {
-  return typeof value === "object" && value !== null &&
-    "error" in value && typeof value.error === "string";
-}
-
-/** Check if response has error status. */
-function hasErrorStatus(response: unknown): response is { status: "err"; response: string } {
-  return typeof response === "object" && response !== null &&
-    "status" in response && response.status === "err";
-}
-
-/** Check if response has statuses array with errors. */
-function hasStatusesWithErrors(response: unknown): boolean {
-  if (typeof response !== "object" || response === null) return false;
-  const r = response as { response?: { data?: { statuses?: unknown[] } } };
-  const statuses = r.response?.data?.statuses;
-  return Array.isArray(statuses) && statuses.some(hasError);
-}
-
-/** Check if response has single status with error. */
-function hasSingleStatusWithError(response: unknown): boolean {
-  if (typeof response !== "object" || response === null) return false;
-  const r = response as { response?: { data?: { status?: unknown } } };
-  return hasError(r.response?.data?.status);
-}
-
-/** Extract error message from response using duck typing. */
-function extractErrorMessage(response: unknown): string | undefined {
-  if (hasErrorStatus(response)) {
-    return response.response;
-  }
-
-  const r = response as { response?: { data?: { statuses?: unknown[]; status?: unknown } } };
-
-  if (Array.isArray(r.response?.data?.statuses)) {
-    const errors = r.response.data.statuses.reduce<string[]>((acc, status, index) => {
-      if (hasError(status)) acc.push(`Order ${index}: ${status.error}`);
-      return acc;
-    }, []);
-    if (errors.length > 0) return errors.join(", ");
-  }
-
-  if (hasError(r.response?.data?.status)) {
-    return r.response.data.status.error;
-  }
-
-  return undefined;
-}
-
-// =============================================================
-// Error Classes
-// =============================================================
-
-/** Thrown when Exchange API returns an error response. */
-export class ApiRequestError extends HyperliquidError {
-  readonly response: unknown;
-
-  constructor(response: unknown) {
-    const message = extractErrorMessage(response) ||
-      "An unknown error occurred while processing an API request. See `response` for more details.";
-    super(message);
-    this.name = "ApiRequestError";
-    this.response = response;
-  }
-}
-
-// =============================================================
-// Assertions
-// =============================================================
-
-/** Assert that response is successful, throw ApiRequestError otherwise. */
-export function assertSuccessResponse(response: unknown): void {
-  if (hasErrorStatus(response) || hasStatusesWithErrors(response) || hasSingleStatusWithError(response)) {
-    throw new ApiRequestError(response);
-  }
-}
-
-// =============================================================
-// Type Utilities
-// =============================================================
-
-// deno-lint-ignore ban-types
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-
-/** Exclude error variants from response type. */
-export type ExcludeErrorResponse<T> = T extends { status: "err" } ? never // with error status
-  : T extends { response: { data: { statuses: ReadonlyArray<infer S> } } } // with multiple statuses
-    ? Exclude<S, { error: unknown }> extends never ? never
-    : Prettify<
-      Omit<T, "response"> & {
-        response: Prettify<Omit<T["response"], "data"> & { data: { statuses: Array<Exclude<S, { error: unknown }>> } }>;
-      }
-    >
-  : T extends { response: { data: { status: infer S } } } // with single status
-    ? S extends { error: unknown } ? never
-    : Prettify<
-      Omit<T, "response"> & {
-        response: Prettify<Omit<T["response"], "data"> & { data: { status: Exclude<S, { error: unknown }> } }>;
-      }
-    >
-  : T;