@pear-protocol/hyperliquid-sdk 0.0.74 → 0.0.76

package/dist/index.js

@@ -775,7 +775,7 @@ const useUserSelection$1 = create((set, get) => ({
     resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
 }));
 
-const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
+const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }) => {
     const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAssetContexts, setFinalAtOICaps, setAggregatedClearingHouseState, setRawClearinghouseStates, } = useHyperliquidData();
     const { setSpotState } = useUserData();
     const { candleInterval } = useUserSelection$1();
@@ -810,6 +810,14 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             if ('channel' in message && 'data' in message) {
                 const response = message;
                 switch (response.channel) {
+                    case 'userFills':
+                        {
+                            const maybePromise = onUserFills === null || onUserFills === void 0 ? void 0 : onUserFills();
+                            if (maybePromise instanceof Promise) {
+                                maybePromise.catch((err) => console.error('[HyperLiquid WS] userFills callback error', err));
+                            }
+                        }
+                        break;
                     case 'webData3':
                         const webData3 = response.data;
                         // finalAssetContexts now sourced from allDexsAssetCtxs channel
@@ -950,6 +958,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         setAggregatedClearingHouseState,
         setRawClearinghouseStates,
         setSpotState,
+        onUserFills,
     ]);
     const connect = useCallback(() => {
         if (!enabled)
@@ -1067,6 +1076,14 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
                 },
             };
             sendJsonMessage(unsubscribeAllDexsClearinghouseState);
+            const unsubscribeUserFills = {
+                method: 'unsubscribe',
+                subscription: {
+                    type: 'userFills',
+                    user: subscribedAddress,
+                },
+            };
+            sendJsonMessage(unsubscribeUserFills);
         }
         const subscribeWebData3 = {
             method: "subscribe",
@@ -1098,10 +1115,18 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
                 type: "allDexsAssetCtxs",
             },
         };
+        const subscribeUserFills = {
+            method: 'subscribe',
+            subscription: {
+                type: 'userFills',
+                user: userAddress,
+            },
+        };
         sendJsonMessage(subscribeWebData3);
         sendJsonMessage(subscribeAllDexsClearinghouseState);
         sendJsonMessage(subscribeAllMids);
         sendJsonMessage(subscribeAllDexsAssetCtxs);
+        sendJsonMessage(subscribeUserFills);
         // Subscribe to spotState for real-time spot balances (USDH, USDC, etc.)
         // Only subscribe if we have a real user address (not the default)
         if (userAddress !== DEFAULT_ADDRESS) {
@@ -6783,147 +6808,6 @@ function useAgentWallet() {
     };
 }
 
-/**
- * Sync external fills into Pear Hyperliquid service (POST /sync/fills)
- */
-const syncFills = async (baseUrl, payload) => {
-    const url = joinUrl(baseUrl, '/sync/fills');
-    try {
-        const response = await apiClient.post(url, payload, {
-            headers: { 'Content-Type': 'application/json' },
-            timeout: 30000,
-        });
-        return { data: response.data, status: response.status, headers: response.headers };
-    }
-    catch (error) {
-        throw toApiError(error);
-    }
-};
-/**
- * Convenience: fetch user fills from HyperLiquid, then sync them to Pear backend
- */
-const syncUserFillsFromHyperliquid = async (baseUrl, user, aggregateByTime = true, lastSyncAt = null, assetPositions) => {
-    const firstStartTime = lastSyncAt ? Number(lastSyncAt) + 1 : 0;
-    const allFills = [];
-    const seenTids = new Set();
-    let startTime = firstStartTime;
-    let batchSize = 0;
-    do {
-        const { data: batch } = await fetchUserFillsFromHyperliquid(user, startTime, aggregateByTime);
-        batchSize = batch.length;
-        for (const fill of batch) {
-            const tid = fill.tid;
-            if (tid === undefined)
-                continue;
-            if (!seenTids.has(tid)) {
-                seenTids.add(tid);
-                allFills.push(fill);
-            }
-        }
-        if (batchSize === 2000) {
-            const last = batch[batch.length - 1];
-            startTime = last.time;
-        }
-    } while (batchSize === 2000);
-    startTime = firstStartTime;
-    batchSize = 0;
-    do {
-        const { data: twapBatch } = await fetchUserTwapSliceFillsByTime(user, startTime, aggregateByTime);
-        batchSize = twapBatch.length;
-        for (const item of twapBatch) {
-            const fill = item.fill;
-            const tid = fill.tid;
-            if (tid === undefined)
-                continue;
-            if (!seenTids.has(tid)) {
-                seenTids.add(tid);
-                allFills.push(fill);
-            }
-        }
-        if (batchSize === 2000) {
-            const last = twapBatch[twapBatch.length - 1];
-            startTime = last.fill.time;
-        }
-    } while (batchSize === 2000);
-    const sortedFills = [...allFills].sort((a, b) => Number(a.time) - Number(b.time));
-    return syncFills(baseUrl, { user, fills: sortedFills, assetPositions });
-};
-
-/**
- * Listens to address changes and periodically syncs user fills
- * Defaults: aggregate=true, interval=60s
- */
-function useAutoSyncFills(options) {
-    const { baseUrl, address, intervalMs = 60000, aggregateByTime = true, } = options;
-    const [lastRunAt, setLastRunAt] = useState(null);
-    const [lastResult, setLastResult] = useState(null);
-    const [error, setError] = useState(null);
-    const [isSyncing, setIsSyncing] = useState(false);
-    const mountedRef = useRef(true);
-    const runningRef = useRef(null);
-    const lastSyncedAt = useUserData((state) => { var _a; return (_a = state.accountSummary) === null || _a === void 0 ? void 0 : _a.lastSyncedAt; });
-    const enabled = useUserData((state) => state.isAuthenticated);
-    useEffect(() => {
-        mountedRef.current = true;
-        return () => { mountedRef.current = false; };
-    }, []);
-    const canRun = useMemo(() => {
-        return Boolean(enabled && address && baseUrl);
-    }, [enabled, address, baseUrl]);
-    const doSync = useCallback(async () => {
-        var _a;
-        if (!canRun)
-            return;
-        if (runningRef.current)
-            return;
-        if (!useUserData.getState().accountSummary)
-            return;
-        if (!((_a = useHyperliquidData.getState().aggregatedClearingHouseState) === null || _a === void 0 ? void 0 : _a.assetPositions))
-            return;
-        setIsSyncing(true);
-        setError(null);
-        const promise = (async () => {
-            var _a;
-            try {
-                const { data } = await syncUserFillsFromHyperliquid(baseUrl, address, aggregateByTime, lastSyncedAt, useHyperliquidData.getState().aggregatedClearingHouseState.assetPositions);
-                if (!mountedRef.current)
-                    return;
-                setLastResult(data);
-                setLastRunAt(Date.now());
-            }
-            catch (e) {
-                if (!mountedRef.current)
-                    return;
-                setError((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : 'Failed to sync user fills');
-            }
-            finally {
-                if (mountedRef.current)
-                    setIsSyncing(false);
-                runningRef.current = null;
-            }
-        })();
-        runningRef.current = promise;
-        await promise;
-    }, [canRun, baseUrl, address, aggregateByTime, lastSyncedAt]);
-    useEffect(() => {
-        if (!canRun)
-            return;
-        // Fire immediately on address change/enable
-        void doSync();
-        const id = setInterval(() => {
-            void doSync();
-        }, Math.max(1000, intervalMs));
-        return () => clearInterval(id);
-    }, [canRun, doSync, intervalMs]);
-    return {
-        lastRunAt,
-        lastResult,
-        error,
-        isSyncing,
-        triggerSync: doSync,
-    };
-}
-
 /**
  * Create a position (MARKET/LIMIT/TWAP) using Pear Hyperliquid service
  * Authorization is derived from headers (Axios defaults or browser localStorage fallback)
@@ -6942,6 +6826,9 @@ async function createPosition(baseUrl, payload, hip3Assets) {
         ...payload,
         longAssets: mapAssets(payload.longAssets),
         shortAssets: mapAssets(payload.shortAssets),
+        assetName: payload.assetName
+            ? toBackendSymbol(payload.assetName, hip3Assets)
+            : undefined,
     };
     try {
         const resp = await apiClient.post(url, translatedPayload, {
@@ -8353,6 +8240,138 @@ const useAllUserBalances = () => {
     ]);
 };
 
+/**
+ * Sync external fills into Pear Hyperliquid service (POST /sync/fills)
+ */
+const syncFills = async (baseUrl, payload) => {
+    const url = joinUrl(baseUrl, '/sync/fills');
+    try {
+        const response = await apiClient.post(url, payload, {
+            headers: { 'Content-Type': 'application/json' },
+            timeout: 30000,
+        });
+        return { data: response.data, status: response.status, headers: response.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+};
+/**
+ * Convenience: fetch user fills from HyperLiquid, then sync them to Pear backend
+ */
+const syncUserFillsFromHyperliquid = async (baseUrl, user, aggregateByTime = true, lastSyncAt = null, assetPositions) => {
+    const firstStartTime = lastSyncAt ? Number(lastSyncAt) + 1 : 0;
+    const allFills = [];
+    const seenTids = new Set();
+    let startTime = firstStartTime;
+    let batchSize = 0;
+    do {
+        const { data: batch } = await fetchUserFillsFromHyperliquid(user, startTime, aggregateByTime);
+        batchSize = batch.length;
+        for (const fill of batch) {
+            const tid = fill.tid;
+            if (tid === undefined)
+                continue;
+            if (!seenTids.has(tid)) {
+                seenTids.add(tid);
+                allFills.push(fill);
+            }
+        }
+        if (batchSize === 2000) {
+            const last = batch[batch.length - 1];
+            startTime = last.time;
+        }
+    } while (batchSize === 2000);
+    startTime = firstStartTime;
+    batchSize = 0;
+    do {
+        const { data: twapBatch } = await fetchUserTwapSliceFillsByTime(user, startTime, aggregateByTime);
+        batchSize = twapBatch.length;
+        for (const item of twapBatch) {
+            const fill = item.fill;
+            const tid = fill.tid;
+            if (tid === undefined)
+                continue;
+            if (!seenTids.has(tid)) {
+                seenTids.add(tid);
+                allFills.push(fill);
+            }
+        }
+        if (batchSize === 2000) {
+            const last = twapBatch[twapBatch.length - 1];
+            startTime = last.fill.time;
+        }
+    } while (batchSize === 2000);
+    const sortedFills = [...allFills].sort((a, b) => Number(a.time) - Number(b.time));
+    return syncFills(baseUrl, { user, fills: sortedFills, assetPositions });
+};
+
+/**
+ * Provides a callback to sync user fills whenever the native WebSocket emits a userFills event.
+ */
+function useHyperliquidUserFills(options) {
+    const { baseUrl, address: addressOverride, aggregateByTime = true } = options;
+    const [lastRunAt, setLastRunAt] = useState(null);
+    const [lastResult, setLastResult] = useState(null);
+    const [error, setError] = useState(null);
+    const [isSyncing, setIsSyncing] = useState(false);
+    const mountedRef = useRef(true);
+    const runningRef = useRef(null);
+    const enabled = useUserData((state) => state.isAuthenticated);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    const handleUserFillsEvent = useCallback(async () => {
+        var _a;
+        const userState = useUserData.getState();
+        const currentAddress = userState.address || addressOverride;
+        const lastSyncedAt = (_a = userState.accountSummary) === null || _a === void 0 ? void 0 : _a.lastSyncedAt;
+        if (!(enabled && currentAddress && baseUrl))
+            return;
+        if (runningRef.current)
+            return;
+        if (!userState.accountSummary)
+            return;
+        const clearinghouseState = useHyperliquidData.getState().aggregatedClearingHouseState;
+        if (!(clearinghouseState === null || clearinghouseState === void 0 ? void 0 : clearinghouseState.assetPositions))
+            return;
+        setIsSyncing(true);
+        setError(null);
+        const promise = (async () => {
+            var _a;
+            try {
+                const { data } = await syncUserFillsFromHyperliquid(baseUrl, currentAddress, aggregateByTime, lastSyncedAt, clearinghouseState.assetPositions);
+                if (!mountedRef.current)
+                    return;
+                setLastResult(data);
+                setLastRunAt(Date.now());
+            }
+            catch (e) {
+                if (!mountedRef.current)
+                    return;
+                setError((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : 'Failed to sync user fills');
+            }
+            finally {
+                if (mountedRef.current)
+                    setIsSyncing(false);
+                runningRef.current = null;
+            }
+        })();
+        runningRef.current = promise;
+        await promise;
+    }, [baseUrl, addressOverride, aggregateByTime, enabled]);
+    return {
+        lastRunAt,
+        lastResult,
+        error,
+        isSyncing,
+        handleUserFillsEvent,
+    };
+}
+
 const PearHyperliquidContext = createContext(undefined);
 /**
  * React Provider for PearHyperliquidClient
@@ -8366,6 +8385,11 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
     const setHip3Assets = useHyperliquidData((state) => state.setHip3Assets);
     const setHip3MarketPrefixes = useHyperliquidData((state) => state.setHip3MarketPrefixes);
     const websocketsEnabled = useMemo(() => Array.isArray(perpsMetaAssets) && perpsMetaAssets.length > 0, [perpsMetaAssets]);
+    const { handleUserFillsEvent } = useHyperliquidUserFills({
+        baseUrl: apiBaseUrl,
+        address,
+        aggregateByTime: true,
+    });
     const { isConnected, lastError } = useHyperliquidWebSocket({
         wsUrl,
         address,
@@ -8374,6 +8398,7 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
     const { isConnected: nativeIsConnected, lastError: nativeLastError } = useHyperliquidNativeWebSocket({
         address,
         enabled: websocketsEnabled,
+        onUserFills: handleUserFillsEvent,
     });
     useEffect(() => {
         if (perpsMetaAssets === null) {
@@ -8480,12 +8505,6 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
         setHip3Assets,
         setHip3MarketPrefixes,
     ]);
-    useAutoSyncFills({
-        baseUrl: apiBaseUrl,
-        address,
-        intervalMs: 60000,
-        aggregateByTime: true,
-    });
     const contextValue = useMemo(() => ({
         // Config
         clientId,
@@ -8521,6 +8540,42 @@ function usePearHyperliquid() {
     return ctx;
 }
 
+const KALSHI_API_BASE_URL = 'https://api.elections.kalshi.com/trade-api/v2';
+async function getKalshiMarkets(params) {
+    const url = new URL(`${KALSHI_API_BASE_URL}/markets`);
+    if (params) {
+        if (params.limit !== undefined) {
+            url.searchParams.set('limit', String(params.limit));
+        }
+        if (params.cursor) {
+            url.searchParams.set('cursor', params.cursor);
+        }
+        if (params.tickers && params.tickers.length > 0) {
+            url.searchParams.set('tickers', params.tickers.join(','));
+        }
+        if (params.event_ticker) {
+            url.searchParams.set('event_ticker', params.event_ticker);
+        }
+        if (params.series_ticker) {
+            url.searchParams.set('series_ticker', params.series_ticker);
+        }
+        if (params.status) {
+            url.searchParams.set('status', params.status);
+        }
+    }
+    try {
+        const response = await axios$1.get(url.toString());
+        return {
+            data: response.data,
+            status: response.status,
+            headers: response.headers,
+        };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+
 /**
  * Detects conflicts between selected tokens and existing positions
  */
@@ -8608,4 +8663,129 @@ function mapCandleIntervalToTradingViewInterval(interval) {
     }
 }
 
-export { AccountSummaryCalculator, ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, TokenMetadataExtractor, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getAvailableMarkets, getCompleteTimestamps, getMarketPrefix, getPortfolio, isHip3Market, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toBackendSymbol, toBackendSymbolWithMarket, toDisplaySymbol, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllBaskets, useAllUserBalances, useAuth, useAutoSyncFills, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMarketData, useMarketDataAllPayload, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePerpMetaAssets, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, useWebData, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+/**
+ * Helper functions to safely extract values from order parameters
+ * based on the order type and parameter structure.
+ */
+/**
+ * Get leverage from order parameters (available for Market, Trigger, Twap, Ladder orders)
+ */
+function getOrderLeverage(order) {
+    const p = order.parameters;
+    if ('leverage' in p && p.leverage !== undefined) {
+        return p.leverage;
+    }
+    return undefined;
+}
+/**
+ * Get USD value from order parameters (available for Market, Trigger, Twap, Ladder orders)
+ */
+function getOrderUsdValue(order) {
+    const p = order.parameters;
+    if ('usdValue' in p) {
+        return p.usdValue;
+    }
+    return undefined;
+}
+/**
+ * Get trigger value from order parameters (available for TP/SL and Trigger orders)
+ */
+function getOrderTriggerValue(order) {
+    const p = order.parameters;
+    if ('triggerValue' in p) {
+        return p.triggerValue;
+    }
+    return undefined;
+}
+/**
+ * Get TP/SL trigger type from order parameters (only for TP/SL orders)
+ */
+function getOrderTpSlTriggerType(order) {
+    if (order.orderType === 'TP' || order.orderType === 'SL') {
+        const p = order.parameters;
+        return p.triggerType;
+    }
+    return undefined;
+}
+/**
+ * Get trigger type from order parameters (for Trigger orders)
+ */
+function getOrderTriggerType(order) {
+    if (order.orderType === 'TRIGGER') {
+        const p = order.parameters;
+        return p.triggerType;
+    }
+    return undefined;
+}
+/**
+ * Get order direction from order parameters (for Trigger orders)
+ */
+function getOrderDirection(order) {
+    if (order.orderType === 'TRIGGER') {
+        const p = order.parameters;
+        return p.direction;
+    }
+    return undefined;
+}
+/**
+ * Get reduce only flag from order parameters (available for all order types)
+ */
+function getOrderReduceOnly(order) {
+    var _a;
+    const p = order.parameters;
+    if ('reduceOnly' in p) {
+        return (_a = p.reduceOnly) !== null && _a !== void 0 ? _a : false;
+    }
+    return false;
+}
+/**
+ * Get TWAP duration from order parameters (only for TWAP orders)
+ */
+function getOrderTwapDuration(order) {
+    if (order.orderType === 'TWAP') {
+        const p = order.parameters;
+        return p.duration;
+    }
+    return undefined;
+}
+/**
+ * Get ladder config from order parameters (only for Ladder orders)
+ */
+function getOrderLadderConfig(order) {
+    if (order.orderType === 'LADDER') {
+        const p = order.parameters;
+        return {
+            ratioStart: p.ratioStart,
+            ratioEnd: p.ratioEnd,
+            numberOfLevels: p.numberOfLevels,
+        };
+    }
+    return undefined;
+}
+/**
+ * Check if the order is a BTC Dominance trigger order
+ */
+function isBtcDomOrder(order) {
+    if (order.orderType === 'TRIGGER') {
+        const p = order.parameters;
+        return p.triggerType === 'BTC_DOM';
+    }
+    return false;
+}
+/**
+ * Get trailing info from TP/SL order parameters
+ */
+function getOrderTrailingInfo(order) {
+    var _a;
+    if (order.orderType === 'TP' || order.orderType === 'SL') {
+        const p = order.parameters;
+        return {
+            isTrailing: (_a = p.isTrailing) !== null && _a !== void 0 ? _a : false,
+            trailingDeltaValue: p.trailingDeltaValue,
+            trailingActivationValue: p.trailingActivationValue,
+        };
+    }
+    return undefined;
+}
+
+export { AccountSummaryCalculator, ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, TokenMetadataExtractor, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getAvailableMarkets, getCompleteTimestamps, getKalshiMarkets, getMarketPrefix, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, isHip3Market, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toBackendSymbol, toBackendSymbolWithMarket, toDisplaySymbol, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllBaskets, useAllUserBalances, useAuth, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidUserFills, useHyperliquidWebSocket, useMarketData, useMarketDataAllPayload, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePerpMetaAssets, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, useWebData, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };