@hfunlabs/hyperliquid 0.27.1-hfunlabs.1

package/src/deps/jsr.io/@std/msgpack/1.0.3/mod.ts

@@ -0,0 +1,47 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * This module provides functions to encode and decode MessagePack.
+ *
+ * MessagePack is an efficient binary serialization format that is language
+ * agnostic. It is like JSON, but generally produces much smaller payloads.
+ * {@link https://msgpack.org/ | Learn more about MessagePack}.
+ *
+ * ```ts
+ * import { decode, encode } from "@std/msgpack";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   str: "deno",
+ *   arr: [1, 2, 3],
+ *   bool: true,
+ *   nil: null,
+ *   map: {
+ *     foo: "bar"
+ *   }
+ * };
+ *
+ * const encoded = encode(obj);
+ * assertEquals(encoded.length, 42);
+ *
+ * const decoded = decode(encoded);
+ * assertEquals(decoded, obj);
+ * ```
+ *
+ * MessagePack supports encoding and decoding the following types:
+ *
+ * - `number`
+ * - `bigint`
+ * - `string`
+ * - `boolean`
+ * - `null`
+ * - `Uint8Array`
+ * - arrays of values of these types
+ * - objects with string or number keys, and values of these types
+ *
+ * @module
+ */
+
+export * from "./decode.js";
+export * from "./encode.js";

package/src/src/_base.ts

@@ -0,0 +1,7 @@
+/** 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/_base.ts

@@ -0,0 +1,163 @@
+// deno-lint-ignore-file no-explicit-any ban-types
+import * as v from "valibot";
+import { HyperliquidError } from "../_base.js";
+
+// ============================================================
+// Types
+// ============================================================
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type Prettify<T> =
+  & { [K in keyof T]: T[K] }
+  & {};
+
+export type DeepImmutable<T> = {
+  readonly [K in keyof T]: DeepImmutable<T[K]>;
+};
+
+export type OmitFirst<T extends readonly any[]> = T extends readonly [any, ...infer R] ? R : [];
+
+export type OverloadedParameters<T> = T extends {
+  (...args: infer A1): unknown;
+  (...args: infer A2): unknown;
+  (...args: infer A3): unknown;
+  (...args: infer A4): unknown;
+} ? A1 | A2 | A3 | A4
+  : T extends {
+    (...args: infer A1): unknown;
+    (...args: infer A2): unknown;
+    (...args: infer A3): unknown;
+  } ? A1 | A2 | A3
+  : T extends {
+    (...args: infer A1): unknown;
+    (...args: infer A2): unknown;
+  } ? A1 | A2
+  : T extends (...args: infer A) => unknown ? A
+  : never;
+
+// ============================================================
+// API Schemas
+// ============================================================
+
+export const UnsignedDecimal = /* @__PURE__ */ (() => {
+  return v.pipe(
+    v.union([v.string(), v.number()]),
+    v.transform(String),
+    v.string(),
+    v.trim(),
+    v.regex(/^[0-9]+(\.[0-9]+)?$/),
+    v.transform((value) => formatDecimal(value)),
+  );
+})();
+export type UnsignedDecimal = v.InferOutput<typeof UnsignedDecimal>;
+
+export const Decimal = /* @__PURE__ */ (() => {
+  return v.pipe(
+    v.union([v.string(), v.number()]),
+    v.transform(String),
+    v.string(),
+    v.trim(),
+    v.regex(/^-?[0-9]+(\.[0-9]+)?$/),
+    v.transform((value) => formatDecimal(value)),
+  );
+})();
+export type Decimal = v.InferOutput<typeof Decimal>;
+
+export const Integer = /* @__PURE__ */ (() => {
+  return v.pipe(
+    v.union([v.string(), v.number()]),
+    v.transform(Number),
+    v.number(),
+    v.integer(),
+    v.safeInteger(),
+  );
+})();
+export type Integer = v.InferOutput<typeof Integer>;
+
+export const UnsignedInteger = /* @__PURE__ */ (() => {
+  return v.pipe(
+    v.union([v.string(), v.number()]),
+    v.transform(Number),
+    v.number(),
+    v.integer(),
+    v.safeInteger(),
+    v.minValue(0),
+  );
+})();
+export type UnsignedInteger = v.InferOutput<typeof UnsignedInteger>;
+
+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 TokenId = /* @__PURE__ */ (() => {
+  return v.pipe(
+    v.string(),
+    v.regex(/^[^:]+:0x[0-9a-fA-F]+$/),
+    v.transform((value) => value as `${string}:${Hex}`),
+  );
+})();
+export type TokenId = v.InferOutput<typeof TokenId>;
+
+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>;
+
+/** Removes leading/trailing zeros from decimal string without precision loss. */
+function formatDecimal(numStr: string): string {
+  return numStr
+    .trim()
+    .replace(/^(-?)0+(?=\d)/, "$1") // Remove leading zeros, keep sign
+    .replace(/(\.\d*?)0+$/, "$1") // Remove trailing zeros after decimal
+    .replace(/\.$/, ""); // Remove lone decimal point
+}
+
+/** Thrown when validating invalid data.  */
+export class SchemaError extends HyperliquidError {
+  constructor(message: string) {
+    super(message);
+    this.name = "SchemaError";
+  }
+}
+
+/**
+ * Creates a valibot parser with summarized error messages.
+ * Used for validating, formatting, and sorting object keys for correct signature generation.
+ * @param schema - The valibot schema to validate against.
+ * @returns A parser function that validates input against the schema.
+ */
+export function parser<TSchema extends v.GenericSchema>(schema: TSchema): v.Parser<TSchema, undefined> {
+  const safeParser = v.safeParser(schema);
+  const parser = (input: unknown) => {
+    const result = safeParser(input);
+    if (result.issues) throw new SchemaError("\n" + v.summarize(result.issues));
+    return result.output;
+  };
+  parser.schema = schema;
+  parser.config = undefined;
+  return parser;
+}