@livo-build/runtime 0.2.4 → 0.2.5

package/dist/eip712.d.ts

@@ -0,0 +1,45 @@
+import { type Bytes, type Hex } from "./hex.js";
+export interface TypedDataField {
+    name: string;
+    type: string;
+}
+export interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: number | bigint;
+    verifyingContract?: string;
+    salt?: string;
+}
+export type TypedDataTypes = Record<string, readonly TypedDataField[]>;
+export interface TypedDataDefinition {
+    domain: TypedDataDomain;
+    types: TypedDataTypes;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+/** The 32-byte EIP-712 digest (`keccak256(0x1901 ‖ domainSeparator ‖ hashStruct)`). */
+export declare function hashTypedData(def: TypedDataDefinition): Bytes;
+/**
+ * Sign EIP-712 typed data with a raw private key. Returns the 65-byte
+ * `r ‖ s ‖ v` signature (v = 27/28), the form Ethereum verifiers expect.
+ */
+export declare function signTypedData(def: TypedDataDefinition & {
+    privateKey: string;
+}): Hex;
+/** Viem-style typed-data params (what a viem local account's signTypedData receives). */
+export interface ViemTypedDataParams {
+    domain: TypedDataDomain;
+    types: TypedDataTypes;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+export interface LocalAccount {
+    address: Hex;
+    signTypedData(params: ViemTypedDataParams): Promise<Hex>;
+}
+/**
+ * A viem-"local account"-shaped signer backed by a raw private key — `{ address,
+ * signTypedData }`. Drops into SDKs that accept a viem account (e.g.
+ * @nktkas/hyperliquid's ExchangeClient) without depending on viem itself.
+ */
+export declare function localAccount(privateKey: string): LocalAccount;

package/dist/eip712.js

@@ -0,0 +1,160 @@
+// EIP-712 typed-data hashing + signing — the missing primitive both the
+// Hyperliquid and Polymarket helpers need (their auth/order signatures are all
+// EIP-712). Implemented on the same audited @noble crypto as tx.ts/sig.ts and
+// validated byte-for-byte against viem in the test suite. Worker-safe, no deps
+// beyond noble.
+//
+// `localAccount(privateKey)` returns a viem-"local account"-shaped object
+// ({ address, signTypedData(params) }) so it drops straight into SDKs that accept
+// a viem account (e.g. @nktkas/hyperliquid's ExchangeClient) without pulling viem.
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesToHex, concatBytes, hexToBytes, toBytes, toBytesSigned, } from "./hex.js";
+import { toChecksumAddress } from "./tx.js";
+// The canonical field order for the EIP712Domain struct — only the present fields
+// are included, matching what viem/ethers produce.
+const DOMAIN_FIELDS = [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+    { name: "salt", type: "bytes32" },
+];
+function domainTypes(domain) {
+    return DOMAIN_FIELDS.filter((f) => domain[f.name] !== undefined && domain[f.name] !== null).map((f) => ({ name: f.name, type: f.type }));
+}
+// Collect the struct types `primaryType` depends on (transitively), excluding the
+// well-known EIP712Domain. Used to build the canonical `encodeType` string.
+function dependencies(primaryType, types, found = new Set()) {
+    const base = primaryType.replace(/\[.*\]$/, "");
+    if (found.has(base) || !types[base] || base === "EIP712Domain")
+        return [...found];
+    found.add(base);
+    for (const field of types[base]) {
+        for (const dep of dependencies(field.type, types, found))
+            found.add(dep);
+    }
+    return [...found];
+}
+function encodeType(primaryType, types) {
+    const deps = dependencies(primaryType, types).filter((d) => d !== primaryType);
+    deps.sort();
+    const ordered = [primaryType, ...deps];
+    return ordered
+        .map((t) => `${t}(${(types[t] ?? []).map((f) => `${f.type} ${f.name}`).join(",")})`)
+        .join("");
+}
+function typeHash(primaryType, types) {
+    return keccak_256(new TextEncoder().encode(encodeType(primaryType, types)));
+}
+function isArrayType(type) {
+    return type.endsWith("]");
+}
+// Encode one field to its 32-byte (or, for arrays/structs, hashed-to-32) chunk.
+function encodeField(types, type, value) {
+    if (types[type]) {
+        // nested struct → hash of its encodeData
+        return keccak_256(encodeData(type, value, types));
+    }
+    if (isArrayType(type)) {
+        const baseType = type.slice(0, type.lastIndexOf("["));
+        const arr = value;
+        return keccak_256(concatBytes(...arr.map((item) => encodeField(types, baseType, item))));
+    }
+    if (type === "string") {
+        return keccak_256(new TextEncoder().encode(String(value)));
+    }
+    if (type === "bytes") {
+        return keccak_256(hexToBytes(String(value)));
+    }
+    if (type === "bool") {
+        return toBytes(value ? 1n : 0n, 32);
+    }
+    if (type === "address") {
+        const addr = hexToBytes(String(value));
+        if (addr.length !== 20)
+            throw new Error(`address must be 20 bytes: ${String(value)}`);
+        return concatBytes(new Uint8Array(12), addr);
+    }
+    const bytesN = type.match(/^bytes(\d+)$/);
+    if (bytesN) {
+        const raw = hexToBytes(String(value));
+        const out = new Uint8Array(32);
+        out.set(raw.slice(0, Number(bytesN[1])), 0); // right-padded
+        return out;
+    }
+    const uint = type.match(/^uint(\d+)?$/);
+    if (uint)
+        return toBytes(toBigIntValue(value), 32);
+    const int = type.match(/^int(\d+)?$/);
+    if (int)
+        return toBytesSigned(toBigIntValue(value), 32);
+    throw new Error(`unsupported EIP-712 type: ${type}`);
+}
+function toBigIntValue(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number")
+        return BigInt(value);
+    return BigInt(String(value)); // decimal or 0x-hex string
+}
+function encodeData(primaryType, data, types) {
+    const parts = [typeHash(primaryType, types)];
+    for (const field of types[primaryType]) {
+        parts.push(encodeField(types, field.type, data[field.name]));
+    }
+    return concatBytes(...parts);
+}
+function hashStruct(primaryType, data, types) {
+    return keccak_256(encodeData(primaryType, data, types));
+}
+function domainSeparator(domain) {
+    const types = { EIP712Domain: domainTypes(domain) };
+    const data = {};
+    for (const f of domainTypes(domain)) {
+        const key = f.name;
+        data[f.name] = f.type === "uint256" ? toBigIntValue(domain[key]) : domain[key];
+    }
+    return hashStruct("EIP712Domain", data, types);
+}
+/** The 32-byte EIP-712 digest (`keccak256(0x1901 ‖ domainSeparator ‖ hashStruct)`). */
+export function hashTypedData(def) {
+    // `types` may carry an EIP712Domain entry (viem-style) — ignore it; the domain
+    // separator is derived from the present domain fields.
+    const sep = domainSeparator(def.domain);
+    const struct = hashStruct(def.primaryType, def.message, def.types);
+    return keccak_256(concatBytes(new Uint8Array([0x19, 0x01]), sep, struct));
+}
+function normalizeKey(privateKey) {
+    const k = privateKey.trim().replace(/^0x/, "");
+    if (!/^[0-9a-fA-F]{64}$/.test(k))
+        throw new Error("private key must be 32 bytes (64 hex chars)");
+    return hexToBytes(k);
+}
+/**
+ * Sign EIP-712 typed data with a raw private key. Returns the 65-byte
+ * `r ‖ s ‖ v` signature (v = 27/28), the form Ethereum verifiers expect.
+ */
+export function signTypedData(def) {
+    const digest = hashTypedData(def);
+    const sig = secp256k1.sign(digest, normalizeKey(def.privateKey), { lowS: true });
+    const r = toBytes(sig.r, 32);
+    const s = toBytes(sig.s, 32);
+    const v = new Uint8Array([27 + sig.recovery]);
+    return bytesToHex(concatBytes(r, s, v));
+}
+/**
+ * A viem-"local account"-shaped signer backed by a raw private key — `{ address,
+ * signTypedData }`. Drops into SDKs that accept a viem account (e.g.
+ * @nktkas/hyperliquid's ExchangeClient) without depending on viem itself.
+ */
+export function localAccount(privateKey) {
+    const pub = secp256k1.getPublicKey(normalizeKey(privateKey), false).slice(1);
+    const address = toChecksumAddress(bytesToHex(keccak_256(pub).slice(-20)));
+    return {
+        address,
+        async signTypedData(params) {
+            return signTypedData({ ...params, privateKey });
+        },
+    };
+}

package/dist/eip712.test.d.ts

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

package/dist/eip712.test.js

@@ -0,0 +1,106 @@
+// EIP-712 correctness: our hashTypedData/signTypedData must match viem byte-for-byte
+// (these signatures move real money on Hyperliquid/Polymarket). viem is the oracle.
+import { describe, expect, it } from "vitest";
+import { hashTypedData as _viemHash } from "viem";
+import { privateKeyToAccount as _pkToAccount } from "viem/accounts";
+import { hashTypedData, signTypedData, localAccount } from "./eip712.js";
+import { bytesToHex } from "./hex.js";
+const PK = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
+// A representative spread: domain with all fields, nested struct, array, bytes,
+// uint, address, bool, string.
+const PERSON_DEF = {
+    domain: {
+        name: "Ether Mail",
+        version: "1",
+        chainId: 1,
+        verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
+    },
+    types: {
+        Person: [
+            { name: "name", type: "string" },
+            { name: "wallet", type: "address" },
+        ],
+        Mail: [
+            { name: "from", type: "Person" },
+            { name: "to", type: "Person" },
+            { name: "contents", type: "string" },
+        ],
+    },
+    primaryType: "Mail",
+    message: {
+        from: { name: "Cow", wallet: "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826" },
+        to: { name: "Bob", wallet: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB" },
+        contents: "Hello, Bob!",
+    },
+};
+// Hyperliquid's Agent typed data (chainId 1337, the "Exchange" domain).
+const HL_AGENT_DEF = {
+    domain: { name: "Exchange", version: "1", chainId: 1337, verifyingContract: "0x0000000000000000000000000000000000000000" },
+    types: { Agent: [{ name: "source", type: "string" }, { name: "connectionId", type: "bytes32" }] },
+    primaryType: "Agent",
+    message: { source: "a", connectionId: "0x" + "ab".repeat(32) },
+};
+// Polymarket CTF Exchange Order — the exact struct we post.
+const PM_ORDER_DEF = {
+    domain: { name: "Polymarket CTF Exchange", version: "1", chainId: 137, verifyingContract: "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E" },
+    types: {
+        Order: [
+            { name: "salt", type: "uint256" },
+            { name: "maker", type: "address" },
+            { name: "signer", type: "address" },
+            { name: "taker", type: "address" },
+            { name: "tokenId", type: "uint256" },
+            { name: "makerAmount", type: "uint256" },
+            { name: "takerAmount", type: "uint256" },
+            { name: "expiration", type: "uint256" },
+            { name: "nonce", type: "uint256" },
+            { name: "feeRateBps", type: "uint256" },
+            { name: "side", type: "uint8" },
+            { name: "signatureType", type: "uint8" },
+        ],
+    },
+    primaryType: "Order",
+    message: {
+        salt: "123456789",
+        maker: "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
+        signer: "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
+        taker: "0x0000000000000000000000000000000000000000",
+        tokenId: "71321045679252212594626385532706912750332728571942532289631379312455583992563",
+        makerAmount: "1000000",
+        takerAmount: "2000000",
+        expiration: "0",
+        nonce: "0",
+        feeRateBps: "0",
+        side: 0,
+        signatureType: 0,
+    },
+};
+describe("hashTypedData matches viem", () => {
+    for (const [label, def] of [
+        ["EIP-712 example (nested structs)", PERSON_DEF],
+        ["Hyperliquid Agent", HL_AGENT_DEF],
+        ["Polymarket Order", PM_ORDER_DEF],
+    ]) {
+        it(label, () => {
+            const ours = bytesToHex(hashTypedData(def));
+            const theirs = _viemHash(def);
+            expect(ours).toBe(theirs);
+        });
+    }
+});
+describe("signTypedData matches viem", () => {
+    it("produces the same 65-byte signature as a viem local account", async () => {
+        const ours = signTypedData({ ...PM_ORDER_DEF, privateKey: PK });
+        const account = _pkToAccount(PK);
+        const theirs = await account.signTypedData(PM_ORDER_DEF);
+        expect(ours).toBe(theirs);
+    });
+    it("localAccount address + signature match viem", async () => {
+        const acct = localAccount(PK);
+        const viemAcct = _pkToAccount(PK);
+        expect(acct.address.toLowerCase()).toBe(viemAcct.address.toLowerCase());
+        const ours = await acct.signTypedData(HL_AGENT_DEF);
+        const theirs = await viemAcct.signTypedData(HL_AGENT_DEF);
+        expect(ours).toBe(theirs);
+    });
+});

package/dist/hyperliquid.d.ts

@@ -0,0 +1,360 @@
+import { ExchangeClient, InfoClient } from "@nktkas/hyperliquid";
+import { type Hex } from "./hex.js";
+export interface HyperliquidOptions {
+    /** Signing key. Default: env.HYPERLIQUID_PRIVATE_KEY, then env.RELAYER_PRIVATE_KEY. */
+    privateKey?: string;
+    /** Env var name to read the key from. Default: "HYPERLIQUID_PRIVATE_KEY". */
+    privateKeySecret?: string;
+    /** Use testnet endpoints. Default: truthy env.HYPERLIQUID_TESTNET. */
+    testnet?: boolean;
+    /**
+     * Which HIP-3 builder dexes to resolve symbols for: an array of dex names, or
+     * true for all of them. Default true — so "xyz:TSLA" & friends just work.
+     */
+    dexs?: string[] | boolean;
+    /**
+     * Master secret for deriving per-user AGENT keys (see `forUser`/`agentAddress`).
+     * Default: env.HL_AGENT_SECRET, then env.RELAYER_PRIVATE_KEY. Keep it stable —
+     * changing it changes every user's agent address (they'd have to re-approve).
+     */
+    agentSecret?: string;
+}
+export type Tif = "Gtc" | "Ioc" | "Alo";
+export type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d" | "3d" | "1w" | "1M";
+export interface CandlesOptions {
+    /** Window start (ms epoch). Default: endTime − lookbackMs. */
+    startTime?: number;
+    /** Window end (ms epoch). Default: now. */
+    endTime?: number;
+    /** How far back from endTime to start. Default: 24h. */
+    lookbackMs?: number;
+}
+/** Live per-coin context: prices, funding, and open interest. */
+export interface AssetContext {
+    coin: string;
+    markPx: number;
+    midPx: number | null;
+    oraclePx: number;
+    /** Current hourly funding rate (fraction, e.g. 0.0000125). */
+    funding: number;
+    openInterest: number;
+    prevDayPx: number;
+    /** 24h notional volume (USDC). */
+    dayNtlVlm: number;
+}
+/** Perp account summary. */
+export interface AccountBalance {
+    accountValue: number;
+    withdrawable: number;
+    totalMarginUsed: number;
+    totalNtlPos: number;
+}
+export interface PlaceOrderOptions {
+    /** Reduce-only (close, never flip). Default false. */
+    reduceOnly?: boolean;
+    /** Time-in-force for limit orders. Default "Gtc". */
+    tif?: Tif;
+}
+export interface MarketOrderOptions {
+    /** Reduce-only (close, never flip). Default false. */
+    reduceOnly?: boolean;
+    /** Max slippage from mid for the protective limit price (0.05 = 5%). Default 0.05. */
+    slippage?: number;
+}
+interface MinimalEnv {
+    [key: string]: unknown;
+}
+export declare class Hyperliquid {
+    /** True when pointed at testnet. */
+    readonly testnet: boolean;
+    /** The signer's address (null when no key is configured → read-only). */
+    readonly address: Hex | null;
+    private readonly env;
+    private readonly transport;
+    private readonly _info;
+    private readonly privateKey?;
+    private readonly dexOption;
+    private readonly agentSecret?;
+    private readAddressOverride?;
+    private _exchange?;
+    private _converter?;
+    private _meta?;
+    constructor(env: MinimalEnv | undefined, options?: HyperliquidOptions);
+    /** Raw @nktkas InfoClient (all read endpoints). */
+    get info(): InfoClient;
+    /** Raw @nktkas ExchangeClient (all signed endpoints). Throws if no key is set. */
+    get exchange(): ExchangeClient;
+    /**
+     * All mid prices for a dex, keyed by coin. With no arg → the main perp dex
+     * (e.g. { BTC: "95000.0" }). Pass a builder-dex name for equities/commodities
+     * (e.g. mids("xyz") → { "xyz:TSLA": "399.8", "xyz:GOLD": "4160.3", … }).
+     */
+    mids(dex?: string): Promise<Record<string, string>>;
+    /**
+     * Mid price of one coin as a number. Accepts a main-dex perp ("BTC") or a
+     * builder-dex asset ("xyz:TSLA") — the right dex is queried automatically.
+     * Throws if the coin isn't listed (try `findAsset` to resolve a bare ticker).
+     */
+    mid(coin: string): Promise<number>;
+    /** L2 order book for a coin (main-dex "BTC" or builder-dex "xyz:TSLA"). */
+    book(coin: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").L2BookResponse>;
+    /** Perp account state (positions, margin, withdrawable) for an address (default: the signer). */
+    positions(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").ClearinghouseStateResponse>;
+    /** Resting open orders for an address (default: the signer). */
+    openOrders(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").OpenOrdersResponse>;
+    /** Main perp-dex metadata (universe of coins + szDecimals + maxLeverage). Cached. */
+    meta(): Promise<{
+        universe: Array<{
+            name: string;
+            szDecimals: number;
+            maxLeverage: number;
+        }>;
+    }>;
+    /** The HIP-3 builder-deployed perp dexes (name + fullName + deployer). */
+    dexs(): Promise<{
+        name: string;
+        fullName?: string;
+    }[]>;
+    /**
+     * Resolve a bare ticker to its full Hyperliquid coin name. "BTC" → "BTC" (main
+     * dex); "TSLA" → "xyz:TSLA" (a builder dex). Returns null if nothing matches.
+     * Use the result with mid/book/limit/market/etc.
+     */
+    findAsset(symbol: string): Promise<string | null>;
+    /** The integer asset id Hyperliquid uses in orders for a coin (main, spot, or builder dex). */
+    assetId(coin: string): Promise<number>;
+    /** Perp account summary (value, withdrawable, margin) for an address (default: the signer). */
+    balance(user?: string): Promise<AccountBalance>;
+    /** Spot token balances for an address (default: the signer). */
+    spotBalances(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").SpotClearinghouseStateResponse>;
+    /** Recent fills (trade history) for an address (default: the signer). */
+    fills(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").UserFillsResponse>;
+    /** Live context for a coin — mark/mid/oracle price, funding rate, open interest, 24h volume. */
+    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>;
+    /** Raw order passthrough (the @nktkas `order` shape) for full control. */
+    order(params: Parameters<ExchangeClient["order"]>[0]): 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")[];
+            };
+        };
+    }>;
+    /** Place a limit order. `price`/`size` are numbers; we format to HL's precision. */
+    limit(coin: string, isBuy: boolean, size: number, price: number, opts?: PlaceOrderOptions): 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")[];
+            };
+        };
+    }>;
+    limitBuy(coin: string, size: number, price: number, opts?: PlaceOrderOptions): 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")[];
+            };
+        };
+    }>;
+    limitSell(coin: string, size: number, price: number, opts?: PlaceOrderOptions): 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")[];
+            };
+        };
+    }>;
+    /**
+     * Market order — an IOC limit priced `slippage` past the current mid so it
+     * crosses immediately. Returns the @nktkas order response.
+     */
+    market(coin: string, isBuy: boolean, size: number, opts?: MarketOrderOptions): 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")[];
+            };
+        };
+    }>;
+    marketBuy(coin: string, size: number, opts?: MarketOrderOptions): 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")[];
+            };
+        };
+    }>;
+    marketSell(coin: string, size: number, opts?: MarketOrderOptions): 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")[];
+            };
+        };
+    }>;
+    /**
+     * Market-close the entire open position in `coin` (reduce-only). Reads the
+     * current size and crosses the opposite side. No-op (returns closed:false) if flat.
+     */
+    closePosition(coin: string, opts?: {
+        slippage?: number;
+    }): Promise<{
+        closed: false;
+        side?: undefined;
+        size?: undefined;
+        result?: undefined;
+    } | {
+        closed: true;
+        side: string;
+        size: number;
+        result: {
+            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")[];
+                };
+            };
+        };
+    }>;
+    /** Cancel a resting order by its order id (oid). */
+    cancel(coin: string, oid: number): Promise<{
+        status: "ok";
+        response: {
+            type: "cancel";
+            data: {
+                statuses: "success"[];
+            };
+        };
+    }>;
+    /** Set leverage for a coin (cross by default). */
+    updateLeverage(coin: string, leverage: number, opts?: {
+        cross?: boolean;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    private symbols;
+    private lookup;
+    private requireUser;
+    /** The per-user agent PRIVATE key (deterministic from the agent secret + userId; never stored). */
+    agentKey(userId: string): Hex;
+    /** The agent ADDRESS the user must approve (show this in your connect/approve UI). */
+    agentAddress(userId: string): Hex;
+    /**
+     * A Hyperliquid bound to one end-user: it SIGNS orders with that user's agent key
+     * and READS/attributes to their `master` account. Use after the user has approved
+     * `agentAddress(userId)`. Trading methods (marketBuy/limit/closePosition/cancel/…)
+     * then act on the user's account; positions()/balance() default to `master`.
+     */
+    forUser(userId: string, master: string): Hyperliquid;
+}
+export {};