@tria-sdk/hyperliquid-core 0.1.0

package/dist/api.js

@@ -0,0 +1,914 @@
+/**
+ * Hyperliquid API functions
+ * Platform-agnostic data fetching - no web or React Native specific code
+ */
+import { SymbolConverter } from "@nktkas/hyperliquid/utils";
+import { getHyperliquidInfoClient, getHyperliquidTransport } from "./client";
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_SPOT_QUOTE = "USDC";
+const CANDLE_LOOKBACK = 200;
+// ============================================================================
+// Helper Functions
+// ============================================================================
+const ensureSpotSymbol = (symbol) => {
+    const trimmed = symbol?.trim();
+    if (!trimmed) {
+        throw new Error("Token name is required");
+    }
+    return trimmed.includes("/") ? trimmed : `${trimmed}/${DEFAULT_SPOT_QUOTE}`;
+};
+const parseSymbolForBook = (symbol) => {
+    const trimmed = symbol?.trim();
+    if (!trimmed) {
+        throw new Error("Symbol is required");
+    }
+    if (trimmed.includes("/")) {
+        return { coin: trimmed, market: "spot" };
+    }
+    if (/-PERP$/i.test(trimmed)) {
+        return { coin: trimmed.replace(/-PERP$/i, ""), market: "perp" };
+    }
+    return { coin: trimmed, market: "perp" };
+};
+const intervalToMs = (interval) => {
+    const unit = interval.slice(-1);
+    const value = parseInt(interval.slice(0, -1), 10);
+    if (Number.isNaN(value)) {
+        return 60000;
+    }
+    switch (unit) {
+        case "m":
+            return value * 60 * 1000;
+        case "h":
+            return value * 60 * 60 * 1000;
+        case "d":
+            return value * 24 * 60 * 60 * 1000;
+        case "w":
+            return value * 7 * 24 * 60 * 60 * 1000;
+        case "M":
+            return value * 30 * 24 * 60 * 60 * 1000;
+        default:
+            return 60 * 1000;
+    }
+};
+const toNumeric = (value) => {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string") {
+        const parsed = parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+};
+const getLevelPrice = (level) => {
+    if (!level) {
+        return null;
+    }
+    if (Array.isArray(level)) {
+        return toNumeric(level[0]);
+    }
+    return toNumeric(level.px);
+};
+const getLevelSize = (level) => {
+    if (!level) {
+        return null;
+    }
+    if (Array.isArray(level)) {
+        return toNumeric(level[1]);
+    }
+    return toNumeric(level.sz);
+};
+const getLevelCount = (level) => {
+    if (!level) {
+        return null;
+    }
+    if (Array.isArray(level)) {
+        return typeof level[2] === "number" ? level[2] : null;
+    }
+    return typeof level.n === "number" ? level.n : null;
+};
+const normalizeOrderBookLevels = (levels, depth) => {
+    const normalized = [];
+    let runningTotal = 0;
+    for (const level of levels) {
+        if (normalized.length >= depth) {
+            break;
+        }
+        const price = getLevelPrice(level);
+        const size = getLevelSize(level);
+        if (price === null || size === null || size <= 0) {
+            continue;
+        }
+        runningTotal += size;
+        normalized.push({
+            price,
+            size,
+            total: runningTotal,
+            count: getLevelCount(level),
+        });
+    }
+    return normalized;
+};
+const pickValidPrice = (...values) => {
+    for (const value of values) {
+        if (value == null) {
+            continue;
+        }
+        const numeric = parseFloat(value);
+        if (Number.isFinite(numeric) && numeric > 0) {
+            return value;
+        }
+    }
+    return "0";
+};
+// ============================================================================
+// Public API Functions
+// ============================================================================
+/**
+ * Retrieves raw spot metadata from Hyperliquid public API
+ */
+export async function fetchSpotMeta(network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        return await client.spotMeta();
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches token details for a specific token
+ */
+export async function fetchTokenDetails(tokenId, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const details = await client.tokenDetails({ tokenId });
+        return {
+            name: details.name,
+            maxSupply: details.maxSupply,
+            totalSupply: details.totalSupply,
+            circulatingSupply: details.circulatingSupply,
+            szDecimals: details.szDecimals,
+            weiDecimals: details.weiDecimals,
+            genesis: details.genesis,
+            deployer: details.deployer || undefined,
+            deployGas: details.deployGas || undefined,
+            deployTime: details.deployTime || undefined,
+            seededUsdc: details.seededUsdc,
+            futureEmissions: details.futureEmissions,
+        };
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches all mid prices
+ */
+export async function fetchAllMids(network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        return await client.allMids();
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches spot metadata and asset contexts
+ */
+export async function fetchSpotMetaAndAssetCtxs(network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        return await client.spotMetaAndAssetCtxs();
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches spot tokens with market data
+ */
+export async function fetchSpotTokensWithMarketData(network = "testnet") {
+    try {
+        const [[spotMeta, spotCtxs], allMids] = await Promise.all([
+            fetchSpotMetaAndAssetCtxs(network),
+            fetchAllMids(network),
+        ]);
+        if (!spotMeta?.tokens || !Array.isArray(spotCtxs)) {
+            return [];
+        }
+        return spotMeta.tokens
+            .map((token, index) => {
+            const assetCtx = spotCtxs[index];
+            const currentPrice = pickValidPrice(allMids[token.name], assetCtx?.midPx, assetCtx?.markPx);
+            const lastPrice = pickValidPrice(assetCtx?.markPx, assetCtx?.midPx, assetCtx?.prevDayPx, allMids[token.name]);
+            let change24h = "0.00";
+            if (assetCtx?.prevDayPx) {
+                const prevPx = parseFloat(assetCtx.prevDayPx);
+                const nowPx = parseFloat(currentPrice);
+                if (prevPx > 0 && Number.isFinite(nowPx)) {
+                    change24h = (((nowPx - prevPx) / prevPx) * 100).toFixed(2);
+                }
+            }
+            return {
+                name: token.name,
+                szDecimals: token.szDecimals,
+                fullName: token.fullName || undefined,
+                price: currentPrice,
+                lastPrice,
+                midPrice: assetCtx?.midPx,
+                markPrice: assetCtx?.markPx,
+                change24h,
+                volume24h: assetCtx?.dayBaseVlm || "0",
+                circulatingSupply: assetCtx?.circulatingSupply || "0",
+            };
+        })
+            .filter((token) => {
+            const price = parseFloat(token.price || "0");
+            const volume = parseFloat(token.volume24h || "0");
+            return Number.isFinite(price) && price > 0 && volume > 0;
+        });
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches spot order book for a token
+ */
+export async function fetchSpotOrderBook(tokenName, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const coin = ensureSpotSymbol(tokenName);
+        return await client.l2Book({ coin });
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches order book snapshot with normalized levels
+ */
+export async function fetchOrderBook(symbol, depth = 25, network = "testnet") {
+    const { coin, market } = parseSymbolForBook(symbol);
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const response = (await client.l2Book({ coin }));
+        const levels = Array.isArray(response?.levels)
+            ? response.levels
+            : [];
+        const [rawBids = [], rawAsks = []] = levels;
+        const bids = normalizeOrderBookLevels(rawBids, depth);
+        const asks = normalizeOrderBookLevels(rawAsks, depth);
+        const bestBid = bids[0]?.price ?? null;
+        const bestAsk = asks[0]?.price ?? null;
+        const midPrice = bestBid !== null && bestAsk !== null
+            ? (bestBid + bestAsk) / 2
+            : bestBid ?? bestAsk ?? null;
+        const spread = bestBid !== null && bestAsk !== null
+            ? Math.max(bestAsk - bestBid, 0)
+            : null;
+        return {
+            symbol,
+            coin,
+            market,
+            bids,
+            asks,
+            bestBid,
+            bestAsk,
+            midPrice,
+            spread,
+            lastUpdated: typeof response?.time === "number" ? response.time : Date.now(),
+        };
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches recent trades for a coin
+ */
+export async function fetchRecentTrades(coin, limit = 20, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const anyClient = client;
+        let trades = [];
+        if (typeof anyClient.tradesSnapshot === "function") {
+            trades = await anyClient.tradesSnapshot({ coin, limit });
+        }
+        else if (typeof anyClient.trades === "function") {
+            trades = await anyClient.trades({ coin, limit });
+        }
+        else if (typeof anyClient.tradeHistory === "function") {
+            trades = await anyClient.tradeHistory({ coin, limit });
+        }
+        else if (typeof anyClient.recentTrades === "function") {
+            trades = await anyClient.recentTrades({ coin, limit });
+        }
+        return trades.map((trade) => {
+            const price = trade.p ?? trade.px ?? "0";
+            const size = trade.s ?? trade.sz ?? "0";
+            const timestamp = trade.time ?? Date.now();
+            return {
+                price: String(price),
+                size: String(size),
+                side: typeof trade.side === "string" ? trade.side : undefined,
+                time: typeof timestamp === "number"
+                    ? timestamp
+                    : Number(timestamp) || Date.now(),
+            };
+        });
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Fetches perp metadata
+ */
+export async function fetchPerpMeta(network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        return await client.meta();
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches perp metadata and asset contexts
+ */
+export async function fetchPerpMetaAndAssetCtxs(network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        return await client.metaAndAssetCtxs();
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches funding history for a coin
+ */
+export async function fetchFundingHistory(coin, startTime, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        return await client.fundingHistory({ coin, startTime });
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches user fills (trade history)
+ */
+export async function fetchUserFills(params) {
+    const { user, aggregateByTime = false, limit = 100, network = "testnet", } = params;
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const payload = { user, aggregateByTime };
+        let fills = [];
+        if (typeof client.userFills === "function") {
+            fills = await client.userFills(payload);
+        }
+        else if (typeof client.userFillsByTime === "function") {
+            const now = Date.now();
+            fills = await client.userFillsByTime({
+                ...payload,
+                startTime: now - 30 * 24 * 60 * 60 * 1000,
+                endTime: now,
+            });
+        }
+        return Array.isArray(fills)
+            ? fills.slice(0, limit).map((fill) => ({
+                coin: String(fill.coin ?? ""),
+                px: String(fill.px ?? fill.price ?? "0"),
+                sz: String(fill.sz ?? fill.size ?? "0"),
+                side: fill.side ?? "",
+                time: Number(fill.time ?? Date.now()),
+                fee: fill.fee ? String(fill.fee) : undefined,
+                feeToken: fill.feeToken ? String(fill.feeToken) : undefined,
+                hash: fill.hash ? String(fill.hash) : undefined,
+                oid: typeof fill.oid === "number" ? fill.oid : undefined,
+                tid: typeof fill.tid === "number" ? fill.tid : undefined,
+                cloid: fill.cloid ? String(fill.cloid) : undefined,
+                startPosition: fill.startPosition
+                    ? String(fill.startPosition)
+                    : undefined,
+                dir: fill.dir ? String(fill.dir) : undefined,
+                closedPnl: fill.closedPnl ? String(fill.closedPnl) : undefined,
+                crossed: typeof fill.crossed === "boolean" ? fill.crossed : undefined,
+                liquidation: fill.liquidation,
+                twapId: typeof fill.twapId === "number" ? fill.twapId : undefined,
+            }))
+            : [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Fetches user fills within a time window (order history)
+ */
+export async function fetchUserFillsByTime(params) {
+    const { user, startTime, endTime = Date.now(), aggregateByTime = true, limit = 200, network = "testnet", } = params;
+    try {
+        const client = getHyperliquidInfoClient(network);
+        let fills = [];
+        if (typeof client.userFillsByTime === "function") {
+            fills = await client.userFillsByTime({
+                user,
+                startTime,
+                endTime,
+                aggregateByTime,
+            });
+        }
+        else if (typeof client.userFills === "function") {
+            fills = await client.userFills({ user, aggregateByTime });
+        }
+        return Array.isArray(fills)
+            ? fills
+                .filter((fill) => {
+                const t = Number(fill.time ?? 0);
+                return t >= startTime && t <= endTime;
+            })
+                .slice(0, limit)
+                .map((fill) => ({
+                coin: String(fill.coin ?? ""),
+                px: String(fill.px ?? fill.price ?? "0"),
+                sz: String(fill.sz ?? fill.size ?? "0"),
+                side: fill.side ?? "",
+                time: Number(fill.time ?? Date.now()),
+                fee: fill.fee ? String(fill.fee) : undefined,
+                feeToken: fill.feeToken ? String(fill.feeToken) : undefined,
+                hash: fill.hash ? String(fill.hash) : undefined,
+                oid: typeof fill.oid === "number" ? fill.oid : undefined,
+                tid: typeof fill.tid === "number" ? fill.tid : undefined,
+                cloid: fill.cloid ? String(fill.cloid) : undefined,
+                startPosition: fill.startPosition
+                    ? String(fill.startPosition)
+                    : undefined,
+                dir: fill.dir ? String(fill.dir) : undefined,
+                closedPnl: fill.closedPnl ? String(fill.closedPnl) : undefined,
+                crossed: typeof fill.crossed === "boolean" ? fill.crossed : undefined,
+                liquidation: fill.liquidation,
+                twapId: typeof fill.twapId === "number" ? fill.twapId : undefined,
+            }))
+            : [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Fetches user funding ledger updates
+ */
+export async function fetchUserFunding(params) {
+    const { user, startTime, endTime = null, limit = 200, network = "testnet", } = params;
+    try {
+        const client = getHyperliquidInfoClient(network);
+        let updates = [];
+        if (typeof client.userFunding === "function") {
+            updates = await client.userFunding({ user, startTime, endTime });
+        }
+        return Array.isArray(updates)
+            ? updates.slice(0, limit).map((update) => ({
+                time: Number(update.time ?? Date.now()),
+                hash: update.hash ? String(update.hash) : undefined,
+                delta: update.delta,
+            }))
+            : [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Fetches user non-funding ledger updates (deposits, withdrawals, transfers)
+ */
+export async function fetchUserNonFundingLedgerUpdates(params) {
+    const { user, startTime, endTime = null, limit = 200, network = "testnet", } = params;
+    try {
+        const client = getHyperliquidInfoClient(network);
+        let updates = [];
+        if (typeof client.userNonFundingLedgerUpdates === "function") {
+            updates = await client.userNonFundingLedgerUpdates({
+                user,
+                startTime,
+                endTime,
+            });
+        }
+        return Array.isArray(updates)
+            ? updates.slice(0, limit).map((update) => ({
+                time: Number(update.time ?? Date.now()),
+                hash: update.hash ? String(update.hash) : undefined,
+                delta: update.delta,
+            }))
+            : [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Fetches perps with market data
+ */
+export async function fetchPerpsWithMarketData(network = "testnet") {
+    try {
+        const [[perpMeta, perpCtxs], allMids] = await Promise.all([
+            fetchPerpMetaAndAssetCtxs(network),
+            fetchAllMids(network),
+        ]);
+        if (!perpMeta?.universe || !Array.isArray(perpCtxs)) {
+            return [];
+        }
+        return perpMeta.universe.map((asset, index) => {
+            const assetCtx = perpCtxs[index];
+            const midPrice = allMids[asset.name] || "0";
+            let change24h = "0.00";
+            if (assetCtx?.prevDayPx && assetCtx?.midPx) {
+                const prev = parseFloat(assetCtx.prevDayPx);
+                const current = parseFloat(assetCtx.midPx);
+                if (prev > 0) {
+                    change24h = (((current - prev) / prev) * 100).toFixed(2);
+                }
+            }
+            const fundingRate = assetCtx?.funding
+                ? (parseFloat(assetCtx.funding) * 8 * 100).toFixed(4)
+                : "0.0000";
+            const now = Date.now();
+            const eightHours = 8 * 60 * 60 * 1000;
+            const nextFunding = Math.ceil(now / eightHours) * eightHours;
+            const hoursUntil = Math.max(0, Math.round((nextFunding - now) / (60 * 60 * 1000)));
+            const anyAsset = asset;
+            const anyCtx = assetCtx;
+            const levFromMeta = typeof anyAsset?.maxLeverage === "number"
+                ? anyAsset.maxLeverage
+                : typeof anyAsset?.maxLev === "number"
+                    ? anyAsset.maxLev
+                    : undefined;
+            const levFromCtx = typeof anyCtx?.risk?.maxLev === "number"
+                ? anyCtx.risk.maxLev
+                : typeof anyCtx?.maxLeverage === "number"
+                    ? anyCtx.maxLeverage
+                    : undefined;
+            const maxLeverage = levFromMeta ?? levFromCtx ?? 10;
+            const rawOi = parseFloat(assetCtx?.openInterest || "0");
+            const markPx = assetCtx?.markPx ?? assetCtx?.midPx ?? midPrice;
+            const markValue = parseFloat(String(markPx) || "0");
+            const openInterest = Number.isFinite(rawOi) && Number.isFinite(markValue)
+                ? (rawOi * markValue).toString()
+                : assetCtx?.openInterest || "0";
+            return {
+                name: asset.name,
+                price: midPrice,
+                change24h,
+                volume24h: assetCtx?.dayNtlVlm || "0",
+                openInterest,
+                fundingRate: `${fundingRate}%`,
+                nextFunding: `${hoursUntil}h`,
+                maxLeverage,
+            };
+        });
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches candlestick data
+ */
+export async function fetchCandlesticks(params) {
+    const { coin, interval, startTime, endTime, network = "testnet" } = params;
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const now = Date.now();
+        const fromTime = startTime ?? now - CANDLE_LOOKBACK * intervalToMs(interval);
+        const toTime = endTime ?? now;
+        const candles = await client.candleSnapshot({
+            coin,
+            interval,
+            startTime: fromTime,
+            endTime: toTime,
+        });
+        if (!Array.isArray(candles) || candles.length === 0) {
+            throw new Error(`No candlestick data for ${coin}`);
+        }
+        return candles
+            .sort((a, b) => a.t - b.t)
+            .map((candle) => ({
+            time: Math.floor(candle.t / 1000),
+            open: parseFloat(candle.o),
+            high: parseFloat(candle.h),
+            low: parseFloat(candle.l),
+            close: parseFloat(candle.c),
+            volume: parseFloat(candle.v || "0"),
+        }))
+            .filter((candle, index, arr) => index === 0 ? true : candle.time > arr[index - 1].time);
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches spot candles for a token
+ */
+export async function fetchSpotCandles(params) {
+    const { tokenName, interval, startTime, endTime, network } = params;
+    const coin = ensureSpotSymbol(tokenName);
+    return fetchCandlesticks({
+        coin,
+        interval,
+        startTime,
+        endTime,
+        network,
+    });
+}
+/**
+ * Fetches latest price for a coin
+ */
+export async function fetchLatestPrice(coin, network = "testnet") {
+    try {
+        const [[perpMeta, perpCtxs], allMids] = await Promise.all([
+            fetchPerpMetaAndAssetCtxs(network),
+            fetchAllMids(network),
+        ]);
+        const perpIndex = perpMeta?.universe?.findIndex((asset) => asset.name === coin);
+        if (perpIndex !== undefined && perpIndex > -1) {
+            const assetCtx = perpCtxs[perpIndex];
+            const currentPrice = allMids[coin] || assetCtx?.midPx || assetCtx?.markPx || "0";
+            let change24h = "0.00";
+            if (assetCtx?.prevDayPx && assetCtx?.midPx) {
+                const prev = parseFloat(assetCtx.prevDayPx);
+                const current = parseFloat(assetCtx.midPx);
+                if (prev > 0) {
+                    change24h = (((current - prev) / prev) * 100).toFixed(2);
+                }
+            }
+            return {
+                price: currentPrice,
+                change24h,
+                high24h: currentPrice,
+                low24h: currentPrice,
+                volume24h: assetCtx?.dayNtlVlm || "0",
+            };
+        }
+        const [[spotMeta, spotCtxs]] = await Promise.all([
+            fetchSpotMetaAndAssetCtxs(network),
+        ]);
+        const spotIndex = spotMeta?.tokens?.findIndex((token) => token.name === coin);
+        if (spotIndex === undefined || spotIndex === -1) {
+            throw new Error(`Coin ${coin} not found in Hyperliquid markets`);
+        }
+        const spotCtx = spotCtxs[spotIndex];
+        const currentPrice = allMids[coin] || spotCtx?.midPx || spotCtx?.markPx || "0";
+        let change24h = "0.00";
+        if (spotCtx?.prevDayPx && spotCtx?.midPx) {
+            const prev = parseFloat(spotCtx.prevDayPx);
+            const current = parseFloat(spotCtx.midPx);
+            if (prev > 0) {
+                change24h = (((current - prev) / prev) * 100).toFixed(2);
+            }
+        }
+        return {
+            price: currentPrice,
+            change24h,
+            high24h: currentPrice,
+            low24h: currentPrice,
+            volume24h: spotCtx?.dayBaseVlm || "0",
+        };
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches user leverage mode for a specific coin
+ */
+export async function fetchUserLeverageMode(userAddress, coin, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const state = await client.clearinghouseState({
+            user: userAddress,
+        });
+        if (!state?.assetPositions) {
+            return null;
+        }
+        for (const entry of state.assetPositions) {
+            const pos = entry?.position;
+            if (pos?.coin !== coin) {
+                continue;
+            }
+            const isCross = pos?.isCross ?? entry?.isCross ?? true;
+            let leverage;
+            if (pos?.leverage != null) {
+                leverage = Number(pos.leverage);
+            }
+            else if (pos?.szi &&
+                pos?.entryPx &&
+                state?.marginSummary?.accountValue) {
+                const notional = Math.abs(Number(pos.szi)) * Number(pos.entryPx);
+                const accountValue = Number(state.marginSummary.accountValue || 0);
+                if (accountValue > 0 && notional > 0) {
+                    leverage = Math.max(1, notional / (accountValue / 10));
+                }
+            }
+            return { mode: isCross ? "cross" : "isolated", leverage };
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Fetches top of book (best bid/ask) for a symbol
+ */
+export async function fetchTopOfBook(symbol, network = "testnet") {
+    const { coin } = parseSymbolForBook(symbol);
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const book = (await client.l2Book({ coin }));
+        const levels = Array.isArray(book?.levels)
+            ? book.levels
+            : [];
+        const [bids = [], asks = []] = levels;
+        const bestBid = getLevelPrice(bids[0]);
+        const bestAsk = getLevelPrice(asks[0]);
+        const midPrice = bestBid !== null && bestAsk !== null
+            ? (bestBid + bestAsk) / 2
+            : bestBid ?? bestAsk ?? null;
+        return {
+            bestBid,
+            bestAsk,
+            midPrice,
+            lastUpdated: Date.now(),
+        };
+    }
+    catch (error) {
+        throw error;
+    }
+}
+// ============================================================================
+// User-Specific API Functions
+// ============================================================================
+/**
+ * Fetches user positions from clearinghouse state
+ */
+export async function fetchUserPositions(userAddress, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const state = await client.clearinghouseState({
+            user: userAddress,
+        });
+        if (!state?.assetPositions || !Array.isArray(state.assetPositions)) {
+            return [];
+        }
+        return state.assetPositions
+            .filter((entry) => {
+            const pos = entry?.position;
+            if (!pos)
+                return false;
+            const size = parseFloat(pos.szi || "0");
+            return size !== 0;
+        })
+            .map((entry) => {
+            const pos = entry.position;
+            return {
+                coin: pos.coin,
+                szi: pos.szi,
+                entryPx: pos.entryPx || "0",
+                positionValue: pos.positionValue || "0",
+                unrealizedPnl: pos.unrealizedPnl || "0",
+                returnOnEquity: pos.returnOnEquity || "0",
+                liquidationPx: pos.liquidationPx || null,
+                marginUsed: pos.marginUsed || "0",
+                leverage: entry.leverage?.value || pos.leverage?.value || 1,
+                isCross: pos.isCross ?? entry.isCross ?? true,
+            };
+        });
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches user's clearinghouse state (positions + margin summary)
+ */
+export async function fetchUserState(userAddress, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const state = await client.clearinghouseState({
+            user: userAddress,
+        });
+        if (!state) {
+            return null;
+        }
+        const positions = (state.assetPositions || [])
+            .filter((entry) => {
+            const pos = entry?.position;
+            if (!pos)
+                return false;
+            const size = parseFloat(pos.szi || "0");
+            return size !== 0;
+        })
+            .map((entry) => {
+            const pos = entry.position;
+            return {
+                coin: pos.coin,
+                szi: pos.szi,
+                entryPx: pos.entryPx || "0",
+                positionValue: pos.positionValue || "0",
+                unrealizedPnl: pos.unrealizedPnl || "0",
+                returnOnEquity: pos.returnOnEquity || "0",
+                liquidationPx: pos.liquidationPx || null,
+                marginUsed: pos.marginUsed || "0",
+                leverage: entry.leverage?.value || pos.leverage?.value || 1,
+                isCross: pos.isCross ?? entry.isCross ?? true,
+            };
+        });
+        const marginSummary = state.marginSummary || {};
+        const crossMarginSummary = state.crossMarginSummary;
+        return {
+            assetPositions: positions,
+            marginSummary: {
+                accountValue: marginSummary.accountValue || "0",
+                totalNtlPos: marginSummary.totalNtlPos || "0",
+                totalRawUsd: marginSummary.totalRawUsd || "0",
+                totalMarginUsed: marginSummary.totalMarginUsed || "0",
+                withdrawable: marginSummary.withdrawable || "0",
+            },
+            crossMarginSummary: crossMarginSummary
+                ? {
+                    accountValue: crossMarginSummary.accountValue || "0",
+                    totalNtlPos: crossMarginSummary.totalNtlPos || "0",
+                    totalRawUsd: crossMarginSummary.totalRawUsd || "0",
+                    totalMarginUsed: crossMarginSummary.totalMarginUsed || "0",
+                    withdrawable: crossMarginSummary.withdrawable || "0",
+                }
+                : undefined,
+        };
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Fetches user's open orders
+ */
+export async function fetchOpenOrders(userAddress, network = "testnet") {
+    try {
+        const client = getHyperliquidInfoClient(network);
+        const orders = await client.openOrders({
+            user: userAddress,
+        });
+        if (!Array.isArray(orders)) {
+            return [];
+        }
+        return orders.map((order) => ({
+            coin: order.coin,
+            oid: order.oid,
+            side: order.side,
+            limitPx: order.limitPx,
+            sz: order.sz,
+            origSz: order.origSz,
+            timestamp: order.timestamp,
+            reduceOnly: order.reduceOnly ?? false,
+            orderType: order.orderType || "limit",
+            triggerPx: order.triggerPx || undefined,
+            isPositionTpsl: order.isPositionTpsl || false,
+            cloid: order.cloid || undefined,
+        }));
+    }
+    catch (error) {
+        throw error;
+    }
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Resolves asset index for a coin
+ */
+export async function resolveAssetIndex(coin, network = "testnet") {
+    const normalizedCoin = (coin || "")
+        .trim()
+        .replace(/-PERP$/i, "")
+        .toUpperCase();
+    if (!normalizedCoin) {
+        throw new Error("Coin is required to resolve asset index");
+    }
+    const converter = await SymbolConverter.create({
+        transport: getHyperliquidTransport(network),
+    });
+    const assetId = converter.getAssetId(normalizedCoin);
+    if (assetId === undefined) {
+        throw new Error(`Unable to resolve Hyperliquid asset index for ${coin}`);
+    }
+    return assetId;
+}
+//# sourceMappingURL=api.js.map