@hyperix/hooks 0.2.0 → 0.2.2

package/dist/config/hl.d.ts

@@ -7,3 +7,4 @@ export declare const wsTransport: WebSocketTransport;
 export declare const wsClient: SubscriptionClient<{
     transport: WebSocketTransport;
 }>;
+export declare const HYCORE_USDC_ADDRESS = "0x6d1e7cde53ba9467b783cb7c530ce054";

package/dist/config/hl.js

@@ -1,5 +1,6 @@
 import { HttpTransport, InfoClient, SubscriptionClient, WebSocketTransport, } from "@nktkas/hyperliquid";
 export const transport = new HttpTransport();
-export const infoClient = new InfoClient({ transport: transport });
+export const infoClient = new InfoClient({ transport });
 export const wsTransport = new WebSocketTransport();
 export const wsClient = new SubscriptionClient({ transport: wsTransport });
+export const HYCORE_USDC_ADDRESS = "0x6d1e7cde53ba9467b783cb7c530ce054";

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from "./use-l2-book.js";
 export * from "./use-max-builder-fee.js";
 export * from "./use-mid.js";
 export * from "./use-all-dexs-clearing-house-state.js";
+export * from "./use-balances.js";
 export * from "./use-historical-orders.js";
 export * from "./use-open-orders.js";
 export * from "./use-trade-history.js";
@@ -25,6 +26,7 @@ export * from "./use-subscribe-status.js";
 export * from "./lib/symbol-converter.js";
 export * from "./use-symbol-converter.js";
 export * from "./use-twap-states.js";
+export * from "./use-user-abstraction.js";
 export * from "./use-user-fundings.js";
 export * from "./use-user-fills.js";
 export * from "./use-user-non-funding-ledger-updates.js";

package/dist/index.js

@@ -6,6 +6,7 @@ export * from "./use-l2-book.js";
 export * from "./use-max-builder-fee.js";
 export * from "./use-mid.js";
 export * from "./use-all-dexs-clearing-house-state.js";
+export * from "./use-balances.js";
 export * from "./use-historical-orders.js";
 export * from "./use-open-orders.js";
 export * from "./use-trade-history.js";
@@ -25,6 +26,7 @@ export * from "./use-subscribe-status.js";
 export * from "./lib/symbol-converter.js";
 export * from "./use-symbol-converter.js";
 export * from "./use-twap-states.js";
+export * from "./use-user-abstraction.js";
 export * from "./use-user-fundings.js";
 export * from "./use-user-fills.js";
 export * from "./use-user-non-funding-ledger-updates.js";

package/dist/lib/balances.d.ts

@@ -0,0 +1,60 @@
+import type { ClearinghouseStateResponse } from "@nktkas/hyperliquid/api/info";
+import type { AllDexsClearingHouseStateData } from "../use-all-dexs-clearing-house-state.js";
+import type { PerpMarket } from "../use-perp-markets.js";
+import type { Position } from "../use-positions.js";
+import type { SpotMarket } from "../use-spot-markets.js";
+import type { SpotBalance } from "../use-spot-state.js";
+import type { UserDelegatorSummaryData } from "../use-user-delegator-summary.js";
+import type { UserVaultEquitiesData } from "../use-user-vault-equities.js";
+export type BalanceType = "spot" | "perp" | "all";
+export type Balance = {
+    coin: string;
+    type: BalanceType;
+    dex: string;
+    total: number;
+    available: number;
+    value: number;
+    entryNtl?: number;
+    pnl?: number;
+    contract: string;
+};
+export type StakingInfo = {
+    delegatedAmount: number;
+    hypePrice: number;
+    stakingEquity: number;
+};
+export type PerpsOverview = {
+    balance: number;
+    unrealizedPNL: number;
+    crossMarginRatio: number;
+    maintenanceMargin: number;
+    crossAccountLeverage: number;
+};
+export type BalancesData = {
+    balances: Balance[];
+    isUnifiedAccount: boolean;
+    tradingEquity: number;
+    spotEquity: number;
+    perpEquity: number;
+    vaultEquity: number;
+    stakingInfo: StakingInfo;
+    totalEquity: number;
+    perpsOverview: PerpsOverview;
+    crossMarginAvailable: number;
+};
+export type BuildBalancesDataInput = {
+    spotBalances: SpotBalance[];
+    spotMarkets: SpotMarket[];
+    clearinghouseState?: AllDexsClearingHouseStateData;
+    perpMarkets?: PerpMarket[];
+    isUnifiedAccount: boolean;
+    vaultEquities?: UserVaultEquitiesData;
+    delegatorSummary?: UserDelegatorSummaryData;
+    positions?: Position[];
+};
+export declare function groupByQuoteCoinMap(data: {
+    quoteCoin: string;
+    dexName: string;
+}[] | undefined): Map<string, string[]>;
+export declare function coverClearinghouseStates(data: AllDexsClearingHouseStateData["clearinghouseStates"] | undefined): Map<string, ClearinghouseStateResponse>;
+export declare function buildBalancesData(input: BuildBalancesDataInput): BalancesData;

package/dist/lib/balances.js

@@ -0,0 +1,208 @@
+import Decimal from "decimal.js";
+import { HYCORE_USDC_ADDRESS } from "../config/hl.js";
+export function groupByQuoteCoinMap(data) {
+    const map = new Map();
+    if (!data)
+        return map;
+    for (const item of data) {
+        const dexNames = map.get(item.quoteCoin) ?? [];
+        dexNames.push(item.dexName);
+        map.set(item.quoteCoin, dexNames);
+    }
+    return map;
+}
+export function coverClearinghouseStates(data) {
+    const map = new Map();
+    for (const state of data ?? []) {
+        const dexName = normalizeDexName(state[0]);
+        map.set(dexName, state[1]);
+    }
+    return map;
+}
+function normalizeDexName(dex) {
+    return dex === "" ? "core" : dex;
+}
+function sumBy(items, getValue) {
+    return items.reduce((acc, item) => acc + getValue(item), 0);
+}
+function buildPerpDexInfos(perpMarkets) {
+    const dexInfos = new Map();
+    for (const market of perpMarkets ?? []) {
+        const dexName = normalizeDexName(market.dex);
+        if (dexInfos.has(dexName))
+            continue;
+        dexInfos.set(dexName, {
+            dexName,
+            quoteCoin: market.collateralToken,
+        });
+    }
+    return [...dexInfos.values()];
+}
+function buildSpotBalances(spotBalances, spotMarkets, isUnifiedAccount) {
+    return spotBalances.map((spot) => {
+        const tokenInfo = spotMarkets.find((market) => market.baseToken === spot.coin);
+        const total = new Decimal(spot.total);
+        const hold = new Decimal(spot.hold ?? 0);
+        const price = new Decimal(tokenInfo?.markPrice ?? 1);
+        const value = total.mul(price);
+        const entryNtl = new Decimal(spot.entryNtl ?? 0);
+        const pnl = value.minus(entryNtl);
+        return {
+            coin: spot.coin,
+            type: isUnifiedAccount ? "all" : "spot",
+            dex: "",
+            total: total.toNumber(),
+            available: total.minus(hold).toNumber(),
+            value: value.toNumber(),
+            entryNtl: entryNtl.toNumber(),
+            pnl: pnl.toNumber(),
+            contract: tokenInfo?.tokenId ?? HYCORE_USDC_ADDRESS,
+        };
+    });
+}
+function buildPerpBalances(clearinghouseState, perpMarkets) {
+    const perpBalances = [];
+    const clearinghouseStatesMap = coverClearinghouseStates(clearinghouseState?.clearinghouseStates);
+    for (const dexInfo of buildPerpDexInfos(perpMarkets)) {
+        const dexState = clearinghouseStatesMap.get(dexInfo.dexName);
+        if (!dexState)
+            continue;
+        const totalAccountValue = new Decimal(dexState.marginSummary.accountValue);
+        if (totalAccountValue.lte(0))
+            continue;
+        perpBalances.push({
+            coin: dexInfo.quoteCoin,
+            type: "perp",
+            dex: dexInfo.dexName,
+            total: totalAccountValue.toNumber(),
+            available: new Decimal(dexState.withdrawable).toNumber(),
+            value: totalAccountValue.toNumber(),
+            contract: "",
+        });
+    }
+    return perpBalances;
+}
+function buildPerpsOverviewInfo(clearinghouseState, spotBalances, perpMarkets, isUnifiedAccount) {
+    if (!clearinghouseState) {
+        return undefined;
+    }
+    let totalCrossMaintenanceMarginUsed = new Decimal(0);
+    let totalCrossMarginSummaryValue = new Decimal(0);
+    let totalCrossPositionValue = new Decimal(0);
+    let totalCrossMarginAvailableValue = new Decimal(0);
+    let unifiedAccountRatio = new Decimal(0);
+    let unifiedTotalCollateralBalance = new Decimal(0);
+    const clearinghouseStatesMap = coverClearinghouseStates(clearinghouseState.clearinghouseStates);
+    const spotBalanceByCoin = new Map(spotBalances.map((spot) => [spot.coin, Number(spot.total)]));
+    const isolatedMarginByCoin = new Map();
+    const collateralCoins = new Set();
+    const dexInfos = buildPerpDexInfos(perpMarkets);
+    if (isUnifiedAccount) {
+        for (const [dexName, state] of clearinghouseStatesMap) {
+            const quoteCoin = dexInfos.find((info) => info.dexName === dexName)?.quoteCoin;
+            if (!quoteCoin)
+                continue;
+            collateralCoins.add(quoteCoin);
+            for (const assetPosition of state.assetPositions) {
+                if (assetPosition.position.leverage.type !== "isolated")
+                    continue;
+                const isolatedMargin = isolatedMarginByCoin.get(quoteCoin) ?? new Decimal(0);
+                isolatedMarginByCoin.set(quoteCoin, isolatedMargin.plus(assetPosition.position.marginUsed));
+            }
+        }
+    }
+    for (const [dexName, state] of clearinghouseStatesMap) {
+        totalCrossMaintenanceMarginUsed = totalCrossMaintenanceMarginUsed.plus(state.crossMaintenanceMarginUsed);
+        totalCrossMarginSummaryValue = totalCrossMarginSummaryValue.plus(state.crossMarginSummary.accountValue);
+        totalCrossPositionValue = totalCrossPositionValue.plus(state.crossMarginSummary.totalNtlPos);
+        if (isUnifiedAccount) {
+            const quoteCoin = dexInfos.find((info) => info.dexName === dexName)?.quoteCoin;
+            if (quoteCoin) {
+                const available = new Decimal(spotBalanceByCoin.get(quoteCoin) ?? 0).minus(isolatedMarginByCoin.get(quoteCoin) ?? 0);
+                if (available.gt(0)) {
+                    const ratio = new Decimal(state.crossMaintenanceMarginUsed).div(available);
+                    if (ratio.gt(unifiedAccountRatio)) {
+                        unifiedAccountRatio = ratio;
+                    }
+                }
+            }
+        }
+        if (dexName === "core") {
+            totalCrossMarginAvailableValue = totalCrossMarginAvailableValue.plus(new Decimal(state.crossMarginSummary.accountValue).minus(state.crossMaintenanceMarginUsed));
+        }
+    }
+    if (isUnifiedAccount) {
+        for (const quoteCoin of collateralCoins) {
+            const totalCollateral = new Decimal(spotBalanceByCoin.get(quoteCoin) ?? 0);
+            if (totalCollateral.gt(0)) {
+                unifiedTotalCollateralBalance =
+                    unifiedTotalCollateralBalance.plus(totalCollateral);
+            }
+        }
+    }
+    return {
+        totalCrossMaintenanceMarginUsed,
+        totalCrossMarginSummaryValue,
+        totalCrossPositionValue,
+        totalCrossMarginAvailableValue,
+        unifiedAccountRatio,
+        unifiedTotalCollateralBalance,
+    };
+}
+export function buildBalancesData(input) {
+    const spotBalances = buildSpotBalances(input.spotBalances, input.spotMarkets, input.isUnifiedAccount);
+    const perpBalances = input.isUnifiedAccount
+        ? []
+        : buildPerpBalances(input.clearinghouseState, input.perpMarkets);
+    const balances = [...perpBalances, ...spotBalances];
+    const rawSpotEquity = sumBy(balances.filter((balance) => balance.type === "spot"), (balance) => balance.value);
+    const rawPerpEquity = sumBy(balances.filter((balance) => balance.type === "perp"), (balance) => balance.value);
+    const tradingEquity = input.isUnifiedAccount
+        ? sumBy(balances.filter((balance) => balance.type === "all"), (balance) => balance.value)
+        : rawSpotEquity + rawPerpEquity;
+    const spotEquity = input.isUnifiedAccount ? tradingEquity : rawSpotEquity;
+    const perpEquity = input.isUnifiedAccount ? tradingEquity : rawPerpEquity;
+    const vaultEquity = sumBy(input.vaultEquities ?? [], (vault) => Number(vault.equity));
+    const delegatedAmount = Number(input.delegatorSummary?.delegated ?? 0);
+    const hypePrice = input.spotMarkets.find((market) => market.baseToken === "HYPE")
+        ?.markPrice ?? 0;
+    const stakingEquity = new Decimal(hypePrice).mul(delegatedAmount).toNumber();
+    const totalEquity = tradingEquity + vaultEquity + stakingEquity;
+    const totalUnrealizedPNL = sumBy(input.positions ?? [], (position) => Number(position.position.unrealizedPnl));
+    const perpsOverviewInfo = buildPerpsOverviewInfo(input.clearinghouseState, input.spotBalances, input.perpMarkets, input.isUnifiedAccount);
+    const perpsOverview = {
+        balance: new Decimal(perpEquity).minus(totalUnrealizedPNL).toNumber(),
+        unrealizedPNL: totalUnrealizedPNL,
+        crossMarginRatio: input.isUnifiedAccount
+            ? (perpsOverviewInfo?.unifiedAccountRatio.toNumber() ?? 0)
+            : perpEquity
+                ? (perpsOverviewInfo?.totalCrossMaintenanceMarginUsed
+                    .div(perpEquity)
+                    .toNumber() ?? 0)
+                : 0,
+        maintenanceMargin: perpsOverviewInfo?.totalCrossMaintenanceMarginUsed.toNumber() ?? 0,
+        crossAccountLeverage: input.isUnifiedAccount
+            ? perpsOverviewInfo?.unifiedTotalCollateralBalance.gt(0)
+                ? (perpsOverviewInfo?.totalCrossPositionValue
+                    .div(perpsOverviewInfo.unifiedTotalCollateralBalance)
+                    .toNumber() ?? 0)
+                : 0
+            : perpEquity
+                ? (perpsOverviewInfo?.totalCrossPositionValue
+                    .div(perpEquity)
+                    .toNumber() ?? 0)
+                : 0,
+    };
+    return {
+        balances,
+        isUnifiedAccount: input.isUnifiedAccount,
+        tradingEquity,
+        spotEquity,
+        perpEquity,
+        vaultEquity,
+        stakingInfo: { delegatedAmount, hypePrice, stakingEquity },
+        totalEquity,
+        perpsOverview,
+        crossMarginAvailable: perpsOverviewInfo?.totalCrossMarginAvailableValue.toNumber() ?? 0,
+    };
+}

package/dist/use-balances.d.ts

@@ -0,0 +1,7 @@
+import type { UseSubscribeState } from "@outofgas/react-stream";
+import { type Balance, type BalanceType, type BalancesData, type PerpsOverview, type StakingInfo } from "./lib/balances.js";
+export type { Balance, BalancesData, BalanceType, PerpsOverview, StakingInfo };
+export type UseBalancesOptions = {
+    enabled?: boolean;
+};
+export declare function useBalances(user: `0x${string}`, options?: UseBalancesOptions): UseSubscribeState<BalancesData>;

package/dist/use-balances.js

@@ -0,0 +1,69 @@
+import { useMemo } from "react";
+import { buildBalancesData, } from "./lib/balances.js";
+import { useAllDexsClearingHouseState } from "./use-all-dexs-clearing-house-state.js";
+import { usePerpMarkets } from "./use-perp-markets.js";
+import { usePositions } from "./use-positions.js";
+import { useSpotMarkets } from "./use-spot-markets.js";
+import { useSpotState } from "./use-spot-state.js";
+import { useUserAbstraction } from "./use-user-abstraction.js";
+import { useUserDelegatorSummary } from "./use-user-delegator-summary.js";
+import { useUserVaultEquities } from "./use-user-vault-equities.js";
+function firstError(...errors) {
+    const error = errors.find(Boolean);
+    if (!error)
+        return undefined;
+    return error instanceof Error ? error.message : error;
+}
+export function useBalances(user, options = {}) {
+    const enabled = options.enabled ?? true;
+    const spotMarketsState = useSpotMarkets({ enabled });
+    const clearinghouseState = useAllDexsClearingHouseState(user, { enabled });
+    const spotState = useSpotState(user, { enabled });
+    const perpMarketsState = usePerpMarkets({ enabled });
+    const vaultEquitiesState = useUserVaultEquities(user, { enabled });
+    const delegatorSummaryState = useUserDelegatorSummary(user, { enabled });
+    const userAbstractionState = useUserAbstraction(user, { enabled });
+    const positionsState = usePositions(user, { enabled });
+    const data = useMemo(() => {
+        if (!enabled ||
+            !spotState.data ||
+            !spotMarketsState.data ||
+            !userAbstractionState.data) {
+            return undefined;
+        }
+        return buildBalancesData({
+            spotBalances: spotState.data.balances,
+            spotMarkets: spotMarketsState.data,
+            clearinghouseState: clearinghouseState.data,
+            perpMarkets: perpMarketsState.data,
+            isUnifiedAccount: userAbstractionState.data === "unifiedAccount",
+            vaultEquities: vaultEquitiesState.data,
+            delegatorSummary: delegatorSummaryState.data,
+            positions: positionsState.data,
+        });
+    }, [
+        clearinghouseState.data,
+        delegatorSummaryState.data,
+        enabled,
+        perpMarketsState.data,
+        positionsState.data,
+        spotState.data,
+        spotMarketsState.data,
+        userAbstractionState.data,
+        vaultEquitiesState.data,
+    ]);
+    return {
+        data,
+        ready: Boolean(data),
+        loading: enabled &&
+            (spotMarketsState.loading ||
+                clearinghouseState.loading ||
+                spotState.loading ||
+                perpMarketsState.loading ||
+                vaultEquitiesState.isLoading ||
+                delegatorSummaryState.isLoading ||
+                userAbstractionState.isLoading ||
+                positionsState.loading),
+        error: firstError(spotMarketsState.error, clearinghouseState.error, spotState.error, perpMarketsState.error, vaultEquitiesState.error, delegatorSummaryState.error, userAbstractionState.error, positionsState.error),
+    };
+}

package/dist/use-l2-book.d.ts

@@ -13,7 +13,7 @@ export type L2Book = {
 };
 export type UseL2BookOptions = {
     depth?: number;
-    nSigFigs?: number;
+    nSigFigs?: 2 | 3 | 4 | 5 | null;
 };
 export declare const EMPTY_L2_BOOK: L2Book;
 export declare function calcOrderbookLevels(price: number): {

package/dist/use-positions.d.ts

@@ -1,4 +1,13 @@
 import type { UseSubscribeState } from "@outofgas/react-stream";
 import { type AllDexsClearingHouseStateData, type UseAllDexsClearingHouseStateOptions } from "./use-all-dexs-clearing-house-state.js";
-export type Position = AllDexsClearingHouseStateData["clearinghouseStates"][number][1]["assetPositions"][number];
+import type { OpenOrder } from "./use-open-orders.js";
+export type RawPosition = AllDexsClearingHouseStateData["clearinghouseStates"][number][1]["assetPositions"][number];
+export type Position = RawPosition & {
+    markPrice: number | undefined;
+    fundingSinceOpen: number;
+    side: "Long" | "Short" | "Flat";
+    takeProfitTriggerPx: string | undefined;
+    stopLossTriggerPx: string | undefined;
+    triggerOrders: OpenOrder[];
+};
 export declare function usePositions(user: `0x${string}`, options?: UseAllDexsClearingHouseStateOptions): UseSubscribeState<Position[]>;

package/dist/use-positions.js

@@ -1,17 +1,96 @@
 import { useMemo } from "react";
+import { useAllDexsAssetCtxs } from "./use-all-dexs-asset-ctxs.js";
 import { useAllDexsClearingHouseState, } from "./use-all-dexs-clearing-house-state.js";
+import { useOpenOrders } from "./use-open-orders.js";
+import { useSymbolConverter } from "./use-symbol-converter.js";
+function getSide(size) {
+    const numericSize = Number(size);
+    if (numericSize > 0) {
+        return "Long";
+    }
+    if (numericSize < 0) {
+        return "Short";
+    }
+    return "Flat";
+}
+function getPerpMarkPrice(coin, assetCtxs, symbolConverter) {
+    if (!assetCtxs || !symbolConverter) {
+        return undefined;
+    }
+    const assetId = symbolConverter.getAssetId(coin);
+    if (assetId === undefined) {
+        return undefined;
+    }
+    const dex = coin.includes(":") ? (coin.split(":")[0] ?? "") : "";
+    const index = assetId % 10_000;
+    const ctxs = assetCtxs.ctxs.find(([ctxDex]) => ctxDex === dex)?.[1];
+    return ctxs?.[index] ? Number(ctxs[index].markPx) : undefined;
+}
+function getTriggerOrdersByCoin(orders) {
+    return orders.reduce((map, order) => {
+        if (!order.isTrigger || !order.triggerCondition) {
+            return map;
+        }
+        const current = map.get(order.coin) ?? [];
+        current.push(order);
+        map.set(order.coin, current);
+        return map;
+    }, new Map());
+}
+function getTpSl(orders) {
+    let takeProfitTriggerPx;
+    let stopLossTriggerPx;
+    for (const order of orders ?? []) {
+        if (order.orderType.includes("Take Profit")) {
+            takeProfitTriggerPx = order.triggerPx;
+            continue;
+        }
+        stopLossTriggerPx = order.triggerPx;
+    }
+    return {
+        takeProfitTriggerPx,
+        stopLossTriggerPx,
+        triggerOrders: orders ?? [],
+    };
+}
 export function usePositions(user, options = {}) {
+    const symbolConverter = useSymbolConverter();
     const positionsState = useAllDexsClearingHouseState(user, options);
+    const assetCtxsState = useAllDexsAssetCtxs({ enabled: options.enabled });
+    const openOrdersState = useOpenOrders(user, { enabled: options.enabled });
     const data = useMemo(() => {
-        return positionsState.data?.clearinghouseStates
+        const rawPositions = positionsState.data?.clearinghouseStates
             .flatMap(([, state]) => state.assetPositions)
             .sort((left, right) => Number(left.position.positionValue) <
             Number(right.position.positionValue)
             ? 1
             : -1);
-    }, [positionsState.data]);
+        const triggerOrdersByCoin = getTriggerOrdersByCoin(openOrdersState.data?.orders ?? []);
+        return rawPositions?.map((positionRecord) => {
+            const position = positionRecord.position;
+            const tpSl = getTpSl(triggerOrdersByCoin.get(position.coin));
+            return {
+                ...positionRecord,
+                markPrice: getPerpMarkPrice(position.coin, assetCtxsState.data, symbolConverter),
+                fundingSinceOpen: -Number(position.cumFunding.sinceOpen),
+                side: getSide(position.szi),
+                ...tpSl,
+            };
+        });
+    }, [
+        positionsState.data,
+        openOrdersState.data,
+        assetCtxsState.data,
+        symbolConverter,
+    ]);
     return {
         ...positionsState,
+        loading: positionsState.loading || assetCtxsState.loading || openOrdersState.loading,
+        ready: positionsState.ready &&
+            assetCtxsState.ready &&
+            openOrdersState.ready &&
+            symbolConverter !== null,
+        error: positionsState.error ?? assetCtxsState.error ?? openOrdersState.error,
         data,
     };
 }

package/dist/use-user-abstraction.d.ts

@@ -0,0 +1,8 @@
+import type { UserAbstractionResponse } from "@nktkas/hyperliquid/api/info";
+import { type UseQueryOptions, type UseQueryResult } from "@tanstack/react-query";
+export type UserAbstractionData = UserAbstractionResponse;
+export type UseUserAbstractionOptions = Omit<UseQueryOptions<UserAbstractionData, Error, UserAbstractionData, [
+    "userAbstraction",
+    `0x${string}`
+]>, "queryKey" | "queryFn">;
+export declare function useUserAbstraction(user: `0x${string}`, options?: UseUserAbstractionOptions): UseQueryResult<UserAbstractionData, Error>;

package/dist/use-user-abstraction.js

@@ -0,0 +1,11 @@
+import { useQuery, } from "@tanstack/react-query";
+import { infoClient } from "./config/hl.js";
+export function useUserAbstraction(user, options = {}) {
+    const enabled = options.enabled ?? Boolean(user);
+    return useQuery({
+        queryKey: ["userAbstraction", user],
+        queryFn: () => infoClient.userAbstraction({ user }),
+        ...options,
+        enabled,
+    });
+}

package/dist/use-user-account-activity.js

@@ -91,6 +91,7 @@ function getAction(entry) {
         case "activateDexAbstraction":
             return "Activate";
     }
+    return "Unknown";
 }
 function formatDexLabel(dex) {
     if (dex === "spot")
@@ -140,6 +141,7 @@ function getSource(entry) {
         case "activateDexAbstraction":
             return "Wallet";
     }
+    return "--";
 }
 function getDestination(entry) {
     switch (entry.delta.type) {
@@ -182,6 +184,16 @@ function getDestination(entry) {
         case "activateDexAbstraction":
             return entry.delta.dex;
     }
+    return "--";
+}
+function getUnknownAmount() {
+    return {
+        value: null,
+        numericValue: null,
+        token: null,
+        direction: "neutral",
+        displayValue: "--",
+    };
 }
 function getAmount(entry, user) {
     switch (entry.delta.type) {
@@ -365,6 +377,7 @@ function getAmount(entry, user) {
                 displayValue: formatDisplayValue(entry.delta.amount, entry.delta.token, "out"),
             };
     }
+    return getUnknownAmount();
 }
 function getFee(entry) {
     switch (entry.delta.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperix/hooks",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,7 @@
     "@tanstack/react-query": "^5.90.2",
     "@nktkas/hyperliquid": "^0.32.1",
     "@outofgas/react-stream": "^0.1.4",
+    "decimal.js": "^10.6.0",
     "react": "^19.1.1"
   },
   "devDependencies": {