@hyperix/hooks 0.2.0 → 0.2.1

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/package.json

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