@hyperix/hooks 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export * from "./use-l2-book.js";
+export * from "./use-historical-orders.js";
 export * from "./use-trade-history.js";
 export * from "./use-trades.js";
+export * from "./use-order-history.js";
+export * from "./use-user-fundings.js";
 export * from "./use-user-fills.js";

package/dist/index.js

@@ -1,4 +1,7 @@
 export * from "./use-l2-book.js";
+export * from "./use-historical-orders.js";
 export * from "./use-trade-history.js";
 export * from "./use-trades.js";
+export * from "./use-order-history.js";
+export * from "./use-user-fundings.js";
 export * from "./use-user-fills.js";

package/dist/use-historical-orders.d.ts

@@ -0,0 +1,12 @@
+import { type UseSubscribeState } from "@outofgas/react-stream";
+import type { UserHistoricalOrdersEvent } from "@nktkas/hyperliquid/api/subscription";
+export type HistoricalOrder = UserHistoricalOrdersEvent["orderHistory"][number];
+export type HistoricalOrdersData = {
+    user: `0x${string}`;
+    orderHistory: HistoricalOrder[];
+};
+export type UseHistoricalOrdersOptions = {
+    enabled?: boolean;
+    onUpdate?: (event: UserHistoricalOrdersEvent) => void;
+};
+export declare function useHistoricalOrders(user: `0x${string}`, options?: UseHistoricalOrdersOptions): UseSubscribeState<HistoricalOrdersData>;

package/dist/use-historical-orders.js

@@ -0,0 +1,42 @@
+import { useSubscribe } from "@outofgas/react-stream";
+import { wsClient } from "./config/hl.js";
+function sortHistoricalOrders(orderHistory) {
+    return [...orderHistory].sort((a, b) => b.statusTimestamp - a.statusTimestamp);
+}
+function mergeHistoricalOrders(previousData, incomingEvent) {
+    const orderHistory = incomingEvent.isSnapshot
+        ? incomingEvent.orderHistory
+        : [...(previousData?.orderHistory ?? []), ...incomingEvent.orderHistory];
+    return {
+        user: incomingEvent.user,
+        orderHistory: sortHistoricalOrders(orderHistory),
+    };
+}
+export function useHistoricalOrders(user, options = {}) {
+    const { enabled: enabledOverride, onUpdate } = options;
+    const enabled = enabledOverride ?? Boolean(user);
+    return useSubscribe({
+        key: ["historical-orders", user],
+        enabled,
+        subscribe: async ({ onData, onError }) => {
+            let data;
+            const subscription = await wsClient.userHistoricalOrders({ user }, (event) => {
+                try {
+                    if (!event.isSnapshot) {
+                        onUpdate?.(event);
+                    }
+                    data = mergeHistoricalOrders(data, event);
+                    onData(data);
+                }
+                catch (error) {
+                    onError(error instanceof Error
+                        ? error
+                        : new Error("Failed to process user historical orders event"));
+                }
+            });
+            return {
+                unsubscribe: () => subscription.unsubscribe(),
+            };
+        },
+    });
+}

package/dist/use-order-history.d.ts

@@ -0,0 +1,16 @@
+import { type HistoricalOrder, type UseHistoricalOrdersOptions } from "./use-historical-orders.js";
+export type OrderHistoryDirection = "Buy" | "Sell" | "Long" | "Short" | "Close Long" | "Close Short";
+export type OrderHistory = HistoricalOrder & {
+    displayCoin: string;
+    direction: OrderHistoryDirection;
+};
+export type OrderHistoryData = {
+    user: `0x${string}`;
+    orderHistory: OrderHistory[];
+};
+export declare function useOrderHistory(user: `0x${string}`, options?: UseHistoricalOrdersOptions): {
+    data: OrderHistoryData | undefined;
+    ready: boolean;
+    loading: boolean;
+    error?: string;
+};

package/dist/use-order-history.js

@@ -0,0 +1,37 @@
+import { useMemo } from "react";
+import { useSymbolConverter } from "./use-symbol-converter.js";
+import { useHistoricalOrders, } from "./use-historical-orders.js";
+function formatOrderDirection(order, isSpot) {
+    if (order.reduceOnly) {
+        return order.side === "A" ? "Close Long" : "Close Short";
+    }
+    if (order.side === "B") {
+        return isSpot ? "Buy" : "Long";
+    }
+    return isSpot ? "Sell" : "Short";
+}
+function formatOrderHistoryEntry(historicalOrder, displayCoin) {
+    const isSpot = Boolean(displayCoin);
+    return {
+        ...historicalOrder,
+        displayCoin: displayCoin ?? historicalOrder.order.coin,
+        direction: formatOrderDirection(historicalOrder.order, isSpot),
+    };
+}
+export function useOrderHistory(user, options = {}) {
+    const historicalOrdersState = useHistoricalOrders(user, options);
+    const symbolConverter = useSymbolConverter();
+    const data = useMemo(() => {
+        if (!historicalOrdersState.data) {
+            return undefined;
+        }
+        return {
+            ...historicalOrdersState.data,
+            orderHistory: historicalOrdersState.data.orderHistory.map((historicalOrder) => formatOrderHistoryEntry(historicalOrder, symbolConverter?.getSpotByPairId(historicalOrder.order.coin))),
+        };
+    }, [historicalOrdersState.data, symbolConverter]);
+    return {
+        ...historicalOrdersState,
+        data,
+    };
+}

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

@@ -0,0 +1,12 @@
+import { type UseSubscribeState } from "@outofgas/react-stream";
+import type { UserFundingsEvent } from "@nktkas/hyperliquid/api/subscription";
+export type UserFunding = UserFundingsEvent["fundings"][number];
+export type UserFundingsData = {
+    user: `0x${string}`;
+    fundings: UserFunding[];
+};
+export type UseUserFundingsOptions = {
+    enabled?: boolean;
+    onUpdate?: (event: UserFundingsEvent) => void;
+};
+export declare function useUserFundings(user: `0x${string}`, options?: UseUserFundingsOptions): UseSubscribeState<UserFundingsData>;

package/dist/use-user-fundings.js

@@ -0,0 +1,43 @@
+import { useSubscribe } from "@outofgas/react-stream";
+import { wsClient } from "./config/hl.js";
+function mergeUserFundings(previousData, incomingEvent) {
+    const fundings = incomingEvent.isSnapshot
+        ? incomingEvent.fundings
+        : [...(previousData?.fundings ?? []), ...incomingEvent.fundings];
+    if (incomingEvent.isSnapshot) {
+        return {
+            user: incomingEvent.user,
+            fundings: [...fundings].sort((a, b) => b.time - a.time),
+        };
+    }
+    return {
+        user: incomingEvent.user,
+        fundings: fundings.sort((a, b) => b.time - a.time),
+    };
+}
+export function useUserFundings(user, options = {}) {
+    const { enabled: enabledOverride, onUpdate } = options;
+    const enabled = enabledOverride ?? Boolean(user);
+    return useSubscribe({
+        key: ["user-fundings", user],
+        enabled,
+        subscribe: async ({ onData, onError }) => {
+            let data;
+            const subscription = await wsClient.userFundings({ user }, (event) => {
+                try {
+                    if (!event.isSnapshot) {
+                        onUpdate?.(event);
+                    }
+                    data = mergeUserFundings(data, event);
+                    onData(data);
+                }
+                catch (error) {
+                    onError(error instanceof Error ? error : new Error("Failed to process user fundings event"));
+                }
+            });
+            return {
+                unsubscribe: () => subscription.unsubscribe(),
+            };
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperix/hooks",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",