@livo-build/runtime 0.2.5 → 0.2.12

package/dist/aes.d.ts

@@ -0,0 +1,4 @@
+/** Encrypt a string → "ivBase64:ciphertextBase64". */
+export declare function encrypt(plaintext: string, secret: string): Promise<string>;
+/** Decrypt a value produced by encrypt(). Throws if tampered / wrong secret. */
+export declare function decrypt(value: string, secret: string): Promise<string>;

package/dist/aes.js

@@ -0,0 +1,38 @@
+// AES-256-GCM encrypt/decrypt for protecting sensitive values at rest in D1/KV
+// (e.g. per-user data). The key is a passphrase/secret; output is base64 "iv:ct".
+// Web Crypto only (Worker-safe).
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+function b64(bytes) {
+    let bin = "";
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return btoa(bin);
+}
+function unb64(s) {
+    const bin = atob(s);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+async function deriveKey(secret) {
+    const hash = await crypto.subtle.digest("SHA-256", enc.encode(secret));
+    return crypto.subtle.importKey("raw", hash, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+/** Encrypt a string → "ivBase64:ciphertextBase64". */
+export async function encrypt(plaintext, secret) {
+    const key = await deriveKey(secret);
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const ct = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, enc.encode(plaintext)));
+    return `${b64(iv)}:${b64(ct)}`;
+}
+/** Decrypt a value produced by encrypt(). Throws if tampered / wrong secret. */
+export async function decrypt(value, secret) {
+    const [ivB64, ctB64] = value.split(":");
+    if (!ivB64 || !ctB64)
+        throw new Error("decrypt: malformed ciphertext");
+    const key = await deriveKey(secret);
+    const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv: unb64(ivB64) }, key, unb64(ctB64));
+    return dec.decode(pt);
+}

package/dist/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { privateKeyToAccount } from "viem/accounts";
+import { createSiweMessage, verifySiweMessage } from "./siwe.js";
+import { createSession, verifySession } from "./sessions.js";
+import { encrypt, decrypt } from "./aes.js";
+import { Router, json } from "./http.js";
+const PK = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
+const account = privateKeyToAccount(PK);
+const ADDR = account.address;
+describe("SIWE", () => {
+    it("builds a canonical message and verifies a real signature (cross-checked vs viem)", async () => {
+        const msg = createSiweMessage({ domain: "app.livo.build", address: ADDR, uri: "https://app.livo.build", chainId: 11155111, nonce: "abc123" });
+        expect(msg).toContain("app.livo.build wants you to sign in");
+        expect(msg).toContain("Nonce: abc123");
+        const signature = await account.signMessage({ message: msg });
+        const r = await verifySiweMessage(msg, signature, { nonce: "abc123", domain: "app.livo.build" });
+        expect(r.valid).toBe(true);
+        expect(r.address?.toLowerCase()).toBe(ADDR.toLowerCase());
+    });
+    it("rejects a wrong nonce and an expired message", async () => {
+        const good = createSiweMessage({ domain: "d", address: ADDR, uri: "u", chainId: 1, nonce: "n1" });
+        const sig = await account.signMessage({ message: good });
+        expect((await verifySiweMessage(good, sig, { nonce: "n2" })).valid).toBe(false);
+        const expired = createSiweMessage({ domain: "d", address: ADDR, uri: "u", chainId: 1, nonce: "n1", expirationTime: new Date(Date.now() - 1000).toISOString() });
+        const sig2 = await account.signMessage({ message: expired });
+        expect((await verifySiweMessage(expired, sig2)).valid).toBe(false);
+    });
+});
+describe("sessions", () => {
+    it("round-trips a payload and rejects tampering / expiry", async () => {
+        const token = await createSession({ sub: "0xabc", role: "member" }, "secret");
+        const p = await verifySession(token, "secret");
+        expect(p?.sub).toBe("0xabc");
+        expect(await verifySession(token, "wrong-secret")).toBeNull();
+        expect(await verifySession(token + "x", "secret")).toBeNull();
+        const expired = await createSession({ sub: "x" }, "s", { ttlSeconds: -1 });
+        expect(await verifySession(expired, "s")).toBeNull();
+    });
+});
+describe("aes", () => {
+    it("encrypts and decrypts; wrong secret throws", async () => {
+        const ct = await encrypt("hello world", "k1");
+        expect(ct).not.toContain("hello");
+        expect(await decrypt(ct, "k1")).toBe("hello world");
+        await expect(decrypt(ct, "k2")).rejects.toBeTruthy();
+    });
+});
+describe("Router", () => {
+    it("matches method + :params and 404s otherwise", async () => {
+        const r = new Router("/api").get("/u/:id", (_req, { params }) => json({ id: params.id }));
+        const res = await r.handle(new Request("https://x/api/u/42"), {});
+        expect(res.status).toBe(200);
+        expect(await res.json()).toEqual({ id: "42" });
+        const miss = await r.handle(new Request("https://x/api/nope"), {});
+        expect(miss.status).toBe(404);
+    });
+});

package/dist/cache.d.ts

@@ -0,0 +1,12 @@
+import type { KvLike } from "./ratelimit.js";
+export interface CacheOptions {
+    /** Time-to-live in seconds. */
+    ttlSeconds: number;
+    /** Optional key namespace (default "cache:"). */
+    prefix?: string;
+}
+/**
+ * Return the cached JSON value for `key`, or run `produce()`, store it with a TTL,
+ * and return it. A miss or a corrupt cached value falls through to `produce()`.
+ */
+export declare function cached<T>(kv: KvLike, key: string, produce: () => Promise<T>, opts: CacheOptions): Promise<T>;

package/dist/cache.js

@@ -0,0 +1,27 @@
+// KV-backed memoize — cache an expensive computation (an RPC read, an upstream API
+// call) under a key with a TTL, so repeat requests are cheap. Pairs with any
+// Workers-KV-shaped binding.
+/**
+ * Return the cached JSON value for `key`, or run `produce()`, store it with a TTL,
+ * and return it. A miss or a corrupt cached value falls through to `produce()`.
+ */
+export async function cached(kv, key, produce, opts) {
+    const k = (opts.prefix ?? "cache:") + key;
+    const hit = await kv.get(k);
+    if (hit != null) {
+        try {
+            return JSON.parse(hit);
+        }
+        catch {
+            /* corrupt entry — recompute */
+        }
+    }
+    const value = await produce();
+    try {
+        await kv.put(k, JSON.stringify(value), { expirationTtl: opts.ttlSeconds });
+    }
+    catch {
+        /* cache write best-effort */
+    }
+    return value;
+}

package/dist/gate.d.ts

@@ -0,0 +1,10 @@
+import type { Chain } from "./chain.js";
+export declare function tokenBalanceOf(chain: Chain, token: string, owner: string): Promise<bigint>;
+export interface TokenGate {
+    /** ERC-20 / ERC-721 token address. */
+    token: string;
+    /** Minimum balance (base units for ERC-20; token count for ERC-721). */
+    minBalance: bigint;
+}
+/** Whether an owner currently meets a token gate. */
+export declare function meetsGate(chain: Chain, owner: string, gate: TokenGate): Promise<boolean>;

package/dist/gate.js

@@ -0,0 +1,18 @@
+// Token-gating helpers — does a wallet hold enough of a token to enter / stay in a
+// gated room? Works for ERC-20 (balance) and ERC-721 (count) since both expose
+// balanceOf(address). Read-only — a bot/keeper Chain needs only an RPC_URL.
+// The balanceOf(address)→uint256 of a token for an owner. Returns 0n on a failed
+// read (treat as "doesn't hold") rather than throwing the whole keeper sweep.
+export async function tokenBalanceOf(chain, token, owner) {
+    try {
+        const r = await chain.call(token, "balanceOf(address)(uint256)", [owner]);
+        return BigInt(r);
+    }
+    catch {
+        return 0n;
+    }
+}
+/** Whether an owner currently meets a token gate. */
+export async function meetsGate(chain, owner, gate) {
+    return (await tokenBalanceOf(chain, gate.token, owner)) >= gate.minBalance;
+}

package/dist/http.d.ts

@@ -0,0 +1,48 @@
+export declare function json(body: unknown, status?: number, headers?: Record<string, string>): Response;
+export declare function error(message: string, status?: number): Response;
+export declare const CORS_HEADERS: Record<string, string>;
+/** Add permissive CORS headers to a response. (Same-origin api/ usually doesn't need this.) */
+export declare function withCors(res: Response): Response;
+export interface SseConnection {
+    /** Push an event. Non-string `data` is JSON-stringified. */
+    send(data: unknown, opts?: {
+        event?: string;
+        id?: string;
+    }): void;
+    /** Send a comment line to keep the connection alive (heartbeat). */
+    ping(): void;
+    /** End the stream. */
+    close(): void;
+    /** True once the stream has been closed or cancelled by the client. */
+    readonly closed: boolean;
+    /** The Response to return from your fetch handler. */
+    readonly response: Response;
+}
+/**
+ * Open a Server-Sent Events stream from an api/ Worker — push realtime updates to a
+ * browser (e.g. live prices feeding a chart/dashboard) with no WebSocket plumbing.
+ * Return `conn.response` from your handler, then `conn.send(...)` as data arrives.
+ * Pass `{ signal: req.signal }` so it tears down when the client disconnects.
+ */
+export declare function sse(init?: {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}): SseConnection;
+export interface RouteContext<Env = unknown> {
+    params: Record<string, string>;
+    url: URL;
+    env: Env;
+}
+export type RouteHandler<Env = unknown> = (req: Request, ctx: RouteContext<Env>) => Response | Promise<Response>;
+export declare class Router<Env = unknown> {
+    private readonly basePath;
+    private routes;
+    constructor(basePath?: string);
+    private add;
+    get(path: string, h: RouteHandler<Env>): this;
+    post(path: string, h: RouteHandler<Env>): this;
+    put(path: string, h: RouteHandler<Env>): this;
+    delete(path: string, h: RouteHandler<Env>): this;
+    /** Match + dispatch a request. Returns the handler's response, or a 404. */
+    handle(req: Request, env: Env): Promise<Response>;
+}

package/dist/http.js

@@ -0,0 +1,133 @@
+// Tiny HTTP helpers for api/ Workers, bots, and servers — stop hand-rolling JSON
+// responses and request routing.
+export function json(body, status = 200, headers = {}) {
+    return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json", ...headers } });
+}
+export function error(message, status = 400) {
+    return json({ error: message }, status);
+}
+export const CORS_HEADERS = {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,PUT,DELETE,OPTIONS",
+    "access-control-allow-headers": "content-type,authorization",
+};
+/** Add permissive CORS headers to a response. (Same-origin api/ usually doesn't need this.) */
+export function withCors(res) {
+    const h = new Headers(res.headers);
+    for (const [k, v] of Object.entries(CORS_HEADERS))
+        h.set(k, v);
+    return new Response(res.body, { status: res.status, headers: h });
+}
+/**
+ * Open a Server-Sent Events stream from an api/ Worker — push realtime updates to a
+ * browser (e.g. live prices feeding a chart/dashboard) with no WebSocket plumbing.
+ * Return `conn.response` from your handler, then `conn.send(...)` as data arrives.
+ * Pass `{ signal: req.signal }` so it tears down when the client disconnects.
+ */
+export function sse(init = {}) {
+    const encoder = new TextEncoder();
+    let controller = null;
+    let isClosed = false;
+    const stream = new ReadableStream({
+        start(c) {
+            controller = c;
+        },
+        cancel() {
+            isClosed = true;
+        },
+    });
+    const write = (s) => {
+        if (isClosed || !controller)
+            return;
+        try {
+            controller.enqueue(encoder.encode(s));
+        }
+        catch {
+            isClosed = true;
+        }
+    };
+    const conn = {
+        send(data, opts) {
+            const payload = typeof data === "string" ? data : JSON.stringify(data);
+            let frame = "";
+            if (opts?.event)
+                frame += `event: ${opts.event}\n`;
+            if (opts?.id)
+                frame += `id: ${opts.id}\n`;
+            for (const line of payload.split("\n"))
+                frame += `data: ${line}\n`; // SSE: one data: line per \n
+            write(frame + "\n");
+        },
+        ping() {
+            write(": ping\n\n");
+        },
+        close() {
+            if (isClosed)
+                return;
+            isClosed = true;
+            try {
+                controller?.close();
+            }
+            catch {
+                /* already closed */
+            }
+        },
+        get closed() {
+            return isClosed;
+        },
+        response: new Response(stream, {
+            headers: {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache",
+                connection: "keep-alive",
+                ...(init.headers ?? {}),
+            },
+        }),
+    };
+    init.signal?.addEventListener("abort", () => conn.close());
+    return conn;
+}
+// A minimal method + path router with `:param` segments. `basePath` is stripped
+// first (e.g. "/api/telegram"). Returns 404 when nothing matches.
+export class Router {
+    basePath;
+    routes = [];
+    constructor(basePath = "") {
+        this.basePath = basePath;
+    }
+    add(method, path, handler) {
+        const keys = [];
+        const pattern = new RegExp("^" +
+            path.replace(/:[A-Za-z0-9_]+/g, (m) => {
+                keys.push(m.slice(1));
+                return "([^/]+)";
+            }) +
+            "/?$");
+        this.routes.push({ method, keys, pattern, handler });
+        return this;
+    }
+    get(path, h) { return this.add("GET", path, h); }
+    post(path, h) { return this.add("POST", path, h); }
+    put(path, h) { return this.add("PUT", path, h); }
+    delete(path, h) { return this.add("DELETE", path, h); }
+    /** Match + dispatch a request. Returns the handler's response, or a 404. */
+    async handle(req, env) {
+        const url = new URL(req.url);
+        let path = url.pathname;
+        if (this.basePath && path.startsWith(this.basePath))
+            path = path.slice(this.basePath.length) || "/";
+        if (req.method === "OPTIONS")
+            return withCors(new Response(null, { status: 204 }));
+        for (const r of this.routes) {
+            if (r.method !== req.method)
+                continue;
+            const m = r.pattern.exec(path);
+            if (!m)
+                continue;
+            const params = {};
+            r.keys.forEach((k, i) => (params[k] = decodeURIComponent(m[i + 1])));
+            return r.handler(req, { params, url, env });
+        }
+        return error("not_found", 404);
+    }
+}

package/dist/hyperliquid.d.ts

@@ -49,6 +49,51 @@ export interface AccountBalance {
     totalMarginUsed: number;
     totalNtlPos: number;
 }
+/** A parsed open perp position. */
+export interface PositionInfo {
+    coin: string;
+    /** Absolute size (always ≥ 0; see `side`). */
+    size: number;
+    side: "long" | "short" | "flat";
+    entryPx: number;
+    positionValue: number;
+    unrealizedPnl: number;
+    /** Return on equity as a fraction (0.12 = +12%). */
+    returnOnEquity: number;
+    leverage: number;
+    liquidationPx: number | null;
+    marginUsed: number;
+}
+/** Best bid / offer snapshot. */
+export interface Bbo {
+    bid: number | null;
+    ask: number | null;
+    mid: number | null;
+    spread: number | null;
+}
+interface RawPosition {
+    coin: string;
+    szi: string;
+    entryPx?: string | null;
+    positionValue?: string;
+    unrealizedPnl?: string;
+    returnOnEquity?: string;
+    leverage?: {
+        value?: number;
+    };
+    liquidationPx?: string | null;
+    marginUsed?: string;
+}
+/** Parse a Hyperliquid clearinghouse position into a clean PositionInfo. */
+export declare function parseHlPosition(p: RawPosition): PositionInfo;
+/** Parse an L2 book into a best bid/offer + mid + spread. */
+export declare function parseBbo(book: {
+    levels?: [Array<{
+        px: string;
+    }>, Array<{
+        px: string;
+    }>];
+}): Bbo;
 export interface PlaceOrderOptions {
     /** Reduce-only (close, never flip). Default false. */
     reduceOnly?: boolean;
@@ -133,6 +178,32 @@ export declare class Hyperliquid {
     assetCtx(coin: string): Promise<AssetContext>;
     /** OHLCV candles for charting. `interval` default "1h"; window defaults to the last 24h. */
     candles(coin: string, interval?: CandleInterval, opts?: CandlesOptions): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").CandleSnapshotResponse>;
+    /** Recent public trades for a coin. */
+    recentTrades(coin: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").RecentTradesResponse>;
+    /** Best bid/offer + mid + spread for a coin (parsed from the L2 book). */
+    bbo(coin: string): Promise<Bbo>;
+    /** All open positions as clean PositionInfo[] (default: the signer's account). */
+    positionsList(user?: string): Promise<PositionInfo[]>;
+    /** A single open position for a coin, or null if flat. */
+    position(coin: string, user?: string): Promise<PositionInfo | null>;
+    /** Current hourly funding rate for a coin (fraction, e.g. 0.0000125). */
+    fundingRate(coin: string): Promise<number>;
+    /** Historical funding rates for a coin (default: the last 7 days). */
+    fundingHistory(coin: string, opts?: {
+        startTime?: number;
+        endTime?: number;
+        lookbackMs?: number;
+    }): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").FundingHistoryResponse>;
+    /** Funding payments paid/received by an account (default signer; last 7 days). */
+    userFunding(opts?: {
+        startTime?: number;
+        endTime?: number;
+        lookbackMs?: number;
+    }, user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").UserFundingResponse>;
+    /** Predicted next funding rates across venues (no key). */
+    predictedFundings(): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").PredictedFundingsResponse>;
+    /** Portfolio history (PnL/account-value time series) for an account (default: the signer). */
+    portfolio(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").PortfolioResponse>;
     /** Raw order passthrough (the @nktkas `order` shape) for full control. */
     order(params: Parameters<ExchangeClient["order"]>[0]): Promise<{
         status: "ok";
@@ -333,6 +404,130 @@ export declare class Hyperliquid {
             };
         };
     }>;
+    /** Cancel a resting order by its client order id (cloid). */
+    cancelByCloid(coin: string, cloid: Hex): Promise<{
+        status: "ok";
+        response: {
+            type: "cancel";
+            data: {
+                statuses: "success"[];
+            };
+        };
+    }>;
+    /** Cancel ALL resting orders (optionally only for one coin). Returns the count cancelled. */
+    cancelAll(coin?: string): Promise<{
+        cancelled: number;
+    }>;
+    /** Modify a resting limit order in place (new size/price/side). */
+    modifyOrder(oid: number, coin: string, isBuy: boolean, size: number, price: number, opts?: PlaceOrderOptions): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Place a trigger order (stop / take-profit). `triggerPx` is the activation price;
+     * `tpsl` is "sl" (stop) or "tp". Market trigger by default (fills at market once
+     * armed); reduce-only by default (closing). `isBuy` is the side that executes —
+     * to protect a LONG use isBuy=false (sell), for a SHORT use isBuy=true (buy).
+     */
+    trigger(coin: string, isBuy: boolean, size: number, triggerPx: number, opts: {
+        tpsl: "tp" | "sl";
+        isMarket?: boolean;
+        reduceOnly?: boolean;
+        price?: number;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | "waitingForFill" | "waitingForTrigger")[];
+            };
+        };
+    }>;
+    /** Stop-loss trigger (reduce-only market by default). See `trigger` for `isBuy`. */
+    stopLoss(coin: string, isBuy: boolean, size: number, triggerPx: number, opts?: {
+        isMarket?: boolean;
+        price?: number;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | "waitingForFill" | "waitingForTrigger")[];
+            };
+        };
+    }>;
+    /** Take-profit trigger (reduce-only market by default). See `trigger` for `isBuy`. */
+    takeProfit(coin: string, isBuy: boolean, size: number, triggerPx: number, opts?: {
+        isMarket?: boolean;
+        price?: number;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | "waitingForFill" | "waitingForTrigger")[];
+            };
+        };
+    }>;
+    /** Dead-man's switch: auto-cancel all orders at `timeMs` (epoch) unless re-armed. Omit to clear. */
+    scheduleCancel(timeMs?: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Move USDC from spot into the perp wallet (margin top-up; not a withdrawal). */
+    transferToPerp(usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Move USDC from the perp wallet back to spot. */
+    transferToSpot(usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
     /** Set leverage for a coin (cross by default). */
     updateLeverage(coin: string, leverage: number, opts?: {
         cross?: boolean;
@@ -342,6 +537,80 @@ export declare class Hyperliquid {
             type: "default";
         };
     }>;
+    /**
+     * Place a TWAP order — slice `size` evenly over `minutes` (5–1440) to reduce impact.
+     * `randomize` jitters slice timing. Returns the @nktkas response (incl. the TWAP id).
+     */
+    twap(coin: string, isBuy: boolean, size: number, minutes: number, opts?: {
+        reduceOnly?: boolean;
+        randomize?: boolean;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "twapOrder";
+            data: {
+                status: {
+                    running: {
+                        twapId: number;
+                    };
+                };
+            };
+        };
+    }>;
+    /** Cancel a running TWAP by its id (from the `twap()` response). */
+    cancelTwap(coin: string, twapId: number): Promise<{
+        status: "ok";
+        response: {
+            type: "twapCancel";
+            data: {
+                status: "success";
+            };
+        };
+    }>;
+    /** Create a named sub-account (1–16 chars). Returns its address. */
+    createSubAccount(name: string): Promise<{
+        status: "ok";
+        response: {
+            type: "createSubAccount";
+            data: `0x${string}`;
+        };
+    }>;
+    /** List sub-accounts for an address (default: the signer). */
+    subAccounts(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").SubAccountsResponse>;
+    /** Move USDC from the master into a sub-account (`usd` in dollars). */
+    transferToSubAccount(subAccount: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Move USDC from a sub-account back to the master (`usd` in dollars). */
+    transferFromSubAccount(subAccount: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Deposit USDC into a vault (`usd` in dollars). */
+    vaultDeposit(vault: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Withdraw USDC from a vault (`usd` in dollars). */
+    vaultWithdraw(vault: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Vault details + your equity in it (public read; pass a user or use the signer). */
+    vaultDetails(vault: string, user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").VaultDetailsResponse>;
+    /** Your fee schedule + 14-day volume (default: the signer). */
+    userFees(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").UserFeesResponse>;
+    /** Status of a single order by its oid (resting/filled/canceled). */
+    orderStatus(oid: number, user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").OrderStatusResponse>;
     private symbols;
     private lookup;
     private requireUser;