@pear-protocol/hyperliquid-sdk 0.1.2 → 0.1.4

package/dist/index.js

@@ -1453,8 +1453,9 @@ const getAssetByName = (tokenMetadata, symbol) => {
  * Hook to access webData
  */
 const useMarket = () => {
+    const supportedMarkets = ['USDT', 'USDT0', 'USDC', 'USDH'];
     const tokenMetadata = useHyperliquidData((state) => state.tokenMetadata);
-    const allTokenMetadata = useMemo(() => Object.values(tokenMetadata).filter((metadata) => Boolean(metadata)), [tokenMetadata]);
+    const allTokenMetadata = useMemo(() => Object.values(tokenMetadata).filter((metadata) => Boolean(metadata)).filter((token) => { var _a; return supportedMarkets.includes((_a = token.collateralToken) !== null && _a !== void 0 ? _a : ''); }), [tokenMetadata]);
     const getAssetByName$1 = useCallback((symbol) => getAssetByName(tokenMetadata, symbol), [tokenMetadata]);
     return { allTokenMetadata, getAssetByName: getAssetByName$1 };
 };
@@ -1513,7 +1514,36 @@ const useOpenOrders = () => {
 };
 
 const useUserSelection = () => {
-    return useUserSelection$1();
+    const longTokens = useUserSelection$1((s) => s.longTokens);
+    const shortTokens = useUserSelection$1((s) => s.shortTokens);
+    const candleInterval = useUserSelection$1((s) => s.candleInterval);
+    const openTokenSelector = useUserSelection$1((s) => s.openTokenSelector);
+    const selectorConfig = useUserSelection$1((s) => s.selectorConfig);
+    const openConflictModal = useUserSelection$1((s) => s.openConflictModal);
+    const setLongTokens = useUserSelection$1((s) => s.setLongTokens);
+    const setShortTokens = useUserSelection$1((s) => s.setShortTokens);
+    const setCandleInterval = useUserSelection$1((s) => s.setCandleInterval);
+    const setTokenSelections = useUserSelection$1((s) => s.setTokenSelections);
+    const setOpenTokenSelector = useUserSelection$1((s) => s.setOpenTokenSelector);
+    const setSelectorConfig = useUserSelection$1((s) => s.setSelectorConfig);
+    const setOpenConflictModal = useUserSelection$1((s) => s.setOpenConflictModal);
+    const addToken = useUserSelection$1((s) => s.addToken);
+    return {
+        longTokens,
+        shortTokens,
+        candleInterval,
+        openTokenSelector,
+        selectorConfig,
+        openConflictModal,
+        setLongTokens,
+        setShortTokens,
+        setCandleInterval,
+        setTokenSelections,
+        setOpenTokenSelector,
+        setSelectorConfig,
+        setOpenConflictModal,
+        addToken,
+    };
 };
 
 const useTokenSelectionMetadataStore = create((set) => ({
@@ -1529,11 +1559,10 @@ const useTokenSelectionMetadataStore = create((set) => ({
     volume: "0",
     sumNetFunding: 0,
     maxLeverage: 0,
-    minMargin: 0,
+    minSize: {},
     leverageMatched: true,
-    recompute: ({ perpMetaAssets, tokenMetadata, marketData, longTokens, shortTokens, }) => {
+    recompute: ({ tokenMetadata, marketData, longTokens, shortTokens, }) => {
         const isPriceDataReady = Object.keys(tokenMetadata).length > 0;
-        // Get token symbols for lookups
         const longSymbols = longTokens.map((t) => t.symbol);
         const shortSymbols = shortTokens.map((t) => t.symbol);
         // Get metadata
@@ -1656,24 +1685,37 @@ const useTokenSelectionMetadataStore = create((set) => ({
         })();
         // Max leverage (maximum across all tokens)
         const maxLeverage = (() => {
-            if (!perpMetaAssets)
+            if (!tokenMetadata)
                 return 0;
             const allSymbols = [...longSymbols, ...shortSymbols];
             if (allSymbols.length === 0)
                 return 0;
             let maxLev = 0;
             allSymbols.forEach((symbol) => {
-                const tokenUniverse = perpMetaAssets.find((u) => u.name === symbol);
-                if (tokenUniverse === null || tokenUniverse === void 0 ? void 0 : tokenUniverse.maxLeverage) {
-                    maxLev = Math.max(maxLev, tokenUniverse.maxLeverage);
+                var _a;
+                const tokenDetail = tokenMetadata[symbol];
+                if ((_a = tokenDetail === null || tokenDetail === void 0 ? void 0 : tokenDetail.leverage) === null || _a === void 0 ? void 0 : _a.value) {
+                    maxLev = Math.max(maxLev, tokenDetail.leverage.value);
                 }
             });
             return maxLev;
         })();
-        // Min margin (10 * total number of tokens)
-        const minMargin = (() => {
-            const totalTokenCount = longTokens.length + shortTokens.length;
-            return 10 * totalTokenCount;
+        const minSize = (() => {
+            const allSymbols = [...longSymbols, ...shortSymbols];
+            const collateralCounts = {};
+            allSymbols.forEach((symbol) => {
+                var _a;
+                const collateralToken = (_a = tokenMetadata[symbol]) === null || _a === void 0 ? void 0 : _a.collateralToken;
+                if (collateralToken) {
+                    collateralCounts[collateralToken] =
+                        (collateralCounts[collateralToken] || 0) + 1;
+                }
+            });
+            const minSizeMap = {};
+            Object.entries(collateralCounts).forEach(([collateral, count]) => {
+                minSizeMap[collateral] = 11 * count;
+            });
+            return minSizeMap;
         })();
         // Whether all tokens have matching leverage
         const leverageMatched = (() => {
@@ -1708,7 +1750,7 @@ const useTokenSelectionMetadataStore = create((set) => ({
             volume,
             sumNetFunding,
             maxLeverage,
-            minMargin,
+            minSize,
             leverageMatched,
         });
     },
@@ -1723,11 +1765,10 @@ const useTokenSelectionMetadata = () => {
     const tokenMetadata = useHyperliquidData((state) => state.tokenMetadata);
     const marketData = useMarketData((state) => state.marketData);
     const { longTokens, shortTokens } = useUserSelection$1();
-    const { isLoading, isPriceDataReady, longTokensMetadata, shortTokensMetadata, weightedRatio, weightedRatio24h, priceRatio, priceRatio24h, openInterest, volume, sumNetFunding, maxLeverage, minMargin, leverageMatched, recompute, } = useTokenSelectionMetadataStore();
+    const { isLoading, isPriceDataReady, longTokensMetadata, shortTokensMetadata, weightedRatio, weightedRatio24h, priceRatio, priceRatio24h, openInterest, volume, sumNetFunding, maxLeverage, minSize, leverageMatched, recompute, } = useTokenSelectionMetadataStore();
     // Recompute derived metadata when inputs change
     useEffect(() => {
         recompute({
-            perpMetaAssets,
             tokenMetadata,
             marketData: marketData || null,
             longTokens,
@@ -1751,8 +1792,8 @@ const useTokenSelectionMetadata = () => {
         volume,
         sumNetFunding,
         maxLeverage,
-        minMargin,
         leverageMatched,
+        minSize,
     };
 };
 
@@ -7197,122 +7238,62 @@ function useNotifications() {
     };
 }
 
-// Convert a basket item to the expected type
-function enrichBasketItem(item) {
-    const enrichedLongs = item.longAssets.map((a) => ({
-        ...a,
-    }));
-    const enrichedShorts = item.shortAssets.map((a) => ({
-        ...a,
-    }));
+function enrichBasketWithMetadata(basket, tokenMetadata) {
     return {
-        ...item,
-        longAssets: enrichedLongs,
-        shortAssets: enrichedShorts,
-        collateralType: 'USDC', //TODO: change
+        ...basket,
+        longAssets: basket.longAssets.map((asset) => {
+            var _a;
+            return ({
+                ...asset,
+                metadata: (_a = tokenMetadata[asset.asset]) !== null && _a !== void 0 ? _a : null,
+            });
+        }),
+        shortAssets: basket.shortAssets.map((asset) => {
+            var _a;
+            return ({
+                ...asset,
+                metadata: (_a = tokenMetadata[asset.asset]) !== null && _a !== void 0 ? _a : null,
+            });
+        }),
     };
 }
-/**
- * Filter baskets by collateral type
- * - 'USDC': Only baskets where ALL assets use USDC (collateralType === 'USDC')
- * - 'USDH': Only baskets where ALL assets use USDH (collateralType === 'USDH')
- * - 'ALL' or undefined: No filtering, returns all baskets
- */
-function filterByCollateral(baskets, filter) {
-    if (!filter || filter === 'ALL') {
-        return baskets;
-    }
-    return baskets.filter((basket) => {
-        if (filter === 'USDC') {
-            // Include baskets that are purely USDC or have USDC assets
-            return (basket.collateralType === 'USDC' || basket.collateralType === 'MIXED');
-        }
-        if (filter === 'USDH') {
-            // Include baskets that are purely USDH or have USDH assets
-            return (basket.collateralType === 'USDH' || basket.collateralType === 'MIXED');
-        }
-        return true;
-    });
+function enrichBasketsWithMetadata(baskets, tokenMetadata) {
+    return baskets.map((basket) => enrichBasketWithMetadata(basket, tokenMetadata));
 }
-// Base selector for the full market-data payload (raw from WS)
-const useMarketDataPayload = () => {
-    return useMarketData((s) => s.marketData);
-};
-// Active baskets
-const useActiveBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.active))
-            return [];
-        const enriched = data.active.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Top gainers
-const useTopGainers = (limit, collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        var _a;
-        const list = (_a = data === null || data === void 0 ? void 0 : data.topGainers) !== null && _a !== void 0 ? _a : [];
-        const limited = typeof limit === 'number' ? list.slice(0, Math.max(0, limit)) : list;
-        const enriched = limited.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, limit, collateralFilter]);
-};
-// Top losers
-const useTopLosers = (limit, collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        var _a;
-        const list = (_a = data === null || data === void 0 ? void 0 : data.topLosers) !== null && _a !== void 0 ? _a : [];
-        const limited = typeof limit === 'number' ? list.slice(0, Math.max(0, limit)) : list;
-        const enriched = limited.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, limit, collateralFilter]);
-};
-// Highlighted baskets
-const useHighlightedBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.highlighted))
-            return [];
-        const enriched = data.highlighted.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Watchlist baskets
-const useWatchlistBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
+const useMarketDataHook = (options = {}) => {
+    const { topGainersLimit, topLosersLimit } = options;
+    const data = useMarketData((s) => s.marketData);
+    const tokenMetadata = useHyperliquidData((s) => s.tokenMetadata);
     return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.watchlist))
-            return [];
-        const enriched = data.watchlist.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Find a basket by its exact asset composition (order-insensitive)
-const useFindBasket = (longs, shorts) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!data)
-            return undefined;
-        const normalize = (arr) => Array.isArray(arr)
-            ? arr
-                .map((v) => (typeof v === 'string' ? v : v === null || v === void 0 ? void 0 : v.asset))
-                .filter(Boolean)
-                .map((s) => s.toUpperCase())
-                .sort()
-                .join(',')
-            : '';
-        const lKey = normalize(longs);
-        const sKey = normalize(shorts);
-        const match = (item) => normalize(item.longAssets) === lKey &&
-            normalize(item.shortAssets) === sKey;
-        const found = data.active.find(match) || data.highlighted.find(match);
-        return found
-            ? enrichBasketItem(found)
-            : undefined;
-    }, [data, longs, shorts]);
+        var _a, _b, _c;
+        const activeBaskets = enrichBasketsWithMetadata((_a = data === null || data === void 0 ? void 0 : data.active) !== null && _a !== void 0 ? _a : [], tokenMetadata);
+        const topGainers = (() => {
+            var _a;
+            const list = (_a = data === null || data === void 0 ? void 0 : data.topGainers) !== null && _a !== void 0 ? _a : [];
+            const limited = typeof topGainersLimit === 'number'
+                ? list.slice(0, Math.max(0, topGainersLimit))
+                : list;
+            return enrichBasketsWithMetadata(limited, tokenMetadata);
+        })();
+        const topLosers = (() => {
+            var _a;
+            const list = (_a = data === null || data === void 0 ? void 0 : data.topLosers) !== null && _a !== void 0 ? _a : [];
+            const limited = typeof topLosersLimit === 'number'
+                ? list.slice(0, Math.max(0, topLosersLimit))
+                : list;
+            return enrichBasketsWithMetadata(limited, tokenMetadata);
+        })();
+        const highlightedBaskets = enrichBasketsWithMetadata((_b = data === null || data === void 0 ? void 0 : data.highlighted) !== null && _b !== void 0 ? _b : [], tokenMetadata);
+        const watchlistBaskets = enrichBasketsWithMetadata((_c = data === null || data === void 0 ? void 0 : data.watchlist) !== null && _c !== void 0 ? _c : [], tokenMetadata);
+        return {
+            marketData: data,
+            activeBaskets,
+            topGainers,
+            topLosers,
+            highlightedBaskets,
+            watchlistBaskets,
+        };
+    }, [data, tokenMetadata, topGainersLimit, topLosersLimit]);
 };
 
 async function toggleWatchlist(baseUrl, longAssets, shortAssets) {
@@ -7338,7 +7319,7 @@ function useWatchlist() {
     if (!context)
         throw new Error('useWatchlist must be used within a PearHyperliquidProvider');
     const { apiBaseUrl, isConnected } = context;
-    const marketData = useMarketDataPayload();
+    const marketData = useMarketData(s => s.marketData);
     const isLoading = useMemo(() => !marketData && isConnected, [marketData, isConnected]);
     const toggle = async (longAssets, shortAssets) => {
         const resp = await toggleWatchlist(apiBaseUrl, longAssets, shortAssets);
@@ -7597,104 +7578,174 @@ function useAuth() {
 
 const useAllUserBalances = () => {
     const spotState = useUserData((state) => state.spotState);
-    const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
-    const rawClearinghouseStates = useHyperliquidData((state) => state.rawClearinghouseStates);
     const { longTokensMetadata, shortTokensMetadata } = useTokenSelectionMetadata();
-    return useMemo(() => {
-        const isLoading = !spotState || !aggregatedClearingHouseState;
-        // Helper function to truncate to 2 decimal places without rounding
-        const truncateToTwoDecimals = (value) => {
-            return Math.floor(value * 100) / 100;
-        };
-        // Get spot balances from spotState
-        let spotUsdcBal = undefined;
-        let spotUsdhBal = undefined;
-        if (spotState) {
-            const balances = spotState.balances || [];
-            for (const balance of balances) {
+    const { longTokens, shortTokens } = useUserSelection$1();
+    const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
+    const { spotBalances, availableToTrades, isLoading } = useMemo(() => {
+        const isLoading = !spotState;
+        const spotBalances = {};
+        const availableToTrades = {};
+        if (spotState === null || spotState === void 0 ? void 0 : spotState.balances) {
+            for (const balance of spotState.balances) {
                 const total = parseFloat(balance.total || '0');
-                if (balance.coin === 'USDC') {
-                    spotUsdcBal = truncateToTwoDecimals(total);
-                }
-                if (balance.coin === 'USDH') {
-                    spotUsdhBal = truncateToTwoDecimals(total);
-                }
+                spotBalances[balance.coin] = total;
             }
         }
-        // Get available to trade from tokenMetadata for both USDC and USDH markets
-        let availableToTradeUsdcFromAsset = 0;
-        let availableToTradeUsdhFromAsset = 0;
-        // Token metadata only contains availableToTrade for SELECTED tokens (user's long and short Tokens)
-        // It does NOT contain data for all tokens, so we cannot reliably use it for available to trade as used on hl trade page
-        // so intead, we rely on rawClearinghouseStates which provides market-specific data
-        const selectedMetadataEntries = [
-            ...Object.entries(longTokensMetadata),
-            ...Object.entries(shortTokensMetadata),
+        const allMetadataWithSource = [
+            ...Object.values(longTokensMetadata).map((m) => ({
+                metadata: m,
+                isLong: true,
+            })),
+            ...Object.values(shortTokensMetadata).map((m) => ({
+                metadata: m,
+                isLong: false,
+            })),
         ];
-        selectedMetadataEntries.forEach(([symbol, metadata]) => {
-            var _a;
-            const availableStr = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.availableToTrade) === null || _a === void 0 ? void 0 : _a[0];
-            if (!availableStr)
-                return;
-            const availableValue = truncateToTwoDecimals(parseFloat(availableStr || '0'));
-            if ((metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) === 'USDH') {
-                availableToTradeUsdhFromAsset = Math.max(availableToTradeUsdhFromAsset, availableValue);
-                return;
-            }
-            if ((metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) === 'USDC') {
-                availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-                return;
-            }
-            if (symbol.includes(':')) {
-                const prefix = symbol.split(':')[0];
-                if (prefix === 'xyz') {
-                    availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-                }
-                else {
-                    availableToTradeUsdhFromAsset = Math.max(availableToTradeUsdhFromAsset, availableValue);
-                }
-                return;
+        for (const { metadata, isLong } of allMetadataWithSource) {
+            if (!(metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) || !(metadata === null || metadata === void 0 ? void 0 : metadata.availableToTrade))
+                continue;
+            const collateralCoin = metadata.collateralToken;
+            const availableToTrade = metadata.availableToTrade;
+            let value = parseFloat(availableToTrade[isLong ? 0 : 1] || '0');
+            if (!(collateralCoin in availableToTrades) ||
+                value < availableToTrades[collateralCoin]) {
+                availableToTrades[collateralCoin] = value;
             }
-            availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-        });
-        // Calculate USDC available to trade
-        // Priority 1: Use value from activeAssetData if available (> 0)
-        // Priority 2: Calculate from USDC-specific clearinghouseState (empty prefix)
-        let availableToTradeUsdcValue = undefined;
-        if (availableToTradeUsdcFromAsset > 0) {
-            availableToTradeUsdcValue = availableToTradeUsdcFromAsset;
         }
-        else if (rawClearinghouseStates) {
-            // Find USDC market (empty prefix)
-            const usdcMarket = rawClearinghouseStates.find(([prefix]) => prefix === '');
-            const usdcState = usdcMarket === null || usdcMarket === void 0 ? void 0 : usdcMarket[1];
-            if (usdcState === null || usdcState === void 0 ? void 0 : usdcState.marginSummary) {
-                const accountValue = parseFloat(usdcState.marginSummary.accountValue || '0');
-                const totalMarginUsed = parseFloat(usdcState.marginSummary.totalMarginUsed || '0');
-                const calculatedValue = Math.max(0, accountValue - totalMarginUsed);
-                availableToTradeUsdcValue = truncateToTwoDecimals(calculatedValue);
-            }
+        if (!availableToTrades['USDC']) {
+            availableToTrades['USDC'] = parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.totalRawUsd) || '0');
         }
-        // Calculate USDH available to trade
-        // Priority 1: Use value from activeAssetData if available (> 0)
-        // Priority 2: Use spot USDH balance
-        const availableToTradeUsdhValue = availableToTradeUsdhFromAsset > 0
-            ? availableToTradeUsdhFromAsset
-            : spotUsdhBal;
         return {
-            spotUsdcBalance: spotUsdcBal,
-            availableToTradeUsdc: availableToTradeUsdcValue,
-            spotUsdhBalance: spotUsdhBal,
-            availableToTradeUsdh: availableToTradeUsdhValue,
+            spotBalances,
+            availableToTrades,
             isLoading,
         };
+    }, [spotState, longTokensMetadata, shortTokensMetadata, aggregatedClearingHouseState]);
+    /**
+     * Calculate margin required for every collateral token based on asset leverages and size.
+     * Returns margin required per collateral and whether there's sufficient margin.
+     */
+    const getMarginRequired = useCallback((assetsLeverage, size) => {
+        const sizeValue = parseFloat(String(size)) || 0;
+        // Group tokens by collateral type and calculate margin required
+        const marginByCollateral = {};
+        // Process all tokens (long and short)
+        const allTokensWithMetadata = [
+            ...longTokens.map((t) => ({
+                ...t,
+                metadata: longTokensMetadata[t.symbol],
+            })),
+            ...shortTokens.map((t) => ({
+                ...t,
+                metadata: shortTokensMetadata[t.symbol],
+            })),
+        ];
+        let totalMarginRequired = 0;
+        allTokensWithMetadata.forEach((token) => {
+            var _a;
+            const weight = token.weight || 0;
+            const assetSize = (sizeValue * weight) / 100;
+            const assetLeverage = assetsLeverage[token.symbol] || 1;
+            const assetMargin = assetLeverage > 0 ? assetSize / assetLeverage : 0;
+            // Get collateral type from metadata, default to USDC
+            const collateralToken = ((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.collateralToken) || 'USDC';
+            if (!marginByCollateral[collateralToken]) {
+                marginByCollateral[collateralToken] = 0;
+            }
+            marginByCollateral[collateralToken] += assetMargin;
+            totalMarginRequired += assetMargin;
+        });
+        const perCollateral = Object.entries(marginByCollateral).map(([collateral, marginRequired]) => {
+            var _a;
+            const collateralToken = collateral;
+            const availableBalance = (_a = availableToTrades[collateralToken]) !== null && _a !== void 0 ? _a : 0;
+            const hasEnough = marginRequired <= availableBalance;
+            const shortfall = Math.max(0, marginRequired - availableBalance);
+            return {
+                collateral: collateralToken,
+                marginRequired: Number(marginRequired.toFixed(2)),
+                availableBalance: Number(availableBalance.toFixed(2)),
+                hasEnough,
+                shortfall: Number(shortfall.toFixed(2)),
+            };
+        });
+        const hasEnoughTotal = perCollateral.every((c) => c.hasEnough);
+        return {
+            totalMarginRequired: Number(totalMarginRequired.toFixed(2)),
+            orderValue: sizeValue,
+            perCollateral,
+            hasEnoughTotal,
+        };
+    }, [
+        longTokens,
+        shortTokens,
+        longTokensMetadata,
+        shortTokensMetadata,
+        spotBalances,
+        availableToTrades,
+    ]);
+    /**
+     * Calculate the maximum order size ($) based on available balances and asset leverages.
+     * Returns the overall maximum order size constrained by all collateral types.
+     */
+    const getMaxSize = useCallback((assetsLeverage) => {
+        const marginFactorByCollateral = {};
+        const allTokensWithMetadata = [
+            ...longTokens.map((t) => ({
+                ...t,
+                metadata: longTokensMetadata[t.symbol],
+            })),
+            ...shortTokens.map((t) => ({
+                ...t,
+                metadata: shortTokensMetadata[t.symbol],
+            })),
+        ];
+        // Calculate the margin factor for each collateral type
+        // marginFactor = sum of (weight / leverage) for all assets using that collateral
+        allTokensWithMetadata.forEach((token) => {
+            var _a;
+            const weight = token.weight || 0;
+            const assetLeverage = assetsLeverage[token.symbol] || 1;
+            const collateralToken = ((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.collateralToken) || 'USDC';
+            // marginFactor represents how much margin is needed per $1 of order size
+            const marginFactor = assetLeverage > 0 ? weight / (100 * assetLeverage) : 0;
+            if (!marginFactorByCollateral[collateralToken]) {
+                marginFactorByCollateral[collateralToken] = 0;
+            }
+            marginFactorByCollateral[collateralToken] += marginFactor;
+        });
+        // Calculate max size for each collateral type
+        // maxSize = availableBalance / marginFactor
+        // Each maxSize represents the total order size that collateral can support
+        const maxSizePerCollateral = [];
+        Object.entries(marginFactorByCollateral).forEach(([collateral, marginFactor]) => {
+            var _a;
+            const collateralToken = collateral;
+            const availableBalance = (_a = availableToTrades[collateralToken]) !== null && _a !== void 0 ? _a : 0;
+            if (marginFactor > 0) {
+                const maxSize = availableBalance / marginFactor;
+                maxSizePerCollateral.push(maxSize);
+            }
+        });
+        if (maxSizePerCollateral.length === 0) {
+            return 0;
+        }
+        const overallMaxSize = Math.min(...maxSizePerCollateral);
+        return Number(overallMaxSize.toFixed(2));
     }, [
-        spotState,
-        aggregatedClearingHouseState,
-        rawClearinghouseStates,
+        longTokens,
+        shortTokens,
         longTokensMetadata,
         shortTokensMetadata,
+        availableToTrades,
     ]);
+    return {
+        spotBalances,
+        availableToTrades,
+        isLoading,
+        getMarginRequired,
+        getMaxSize,
+    };
 };
 
 /**
@@ -7879,7 +7930,7 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
                         collateralToken = 'USDE';
                     }
                     if (item.collateralToken === 268) {
-                        collateralToken = 'USDT';
+                        collateralToken = 'USDT0';
                     }
                     const universeAssets = item.universe.map((asset) => ({
                         ...asset,
@@ -8175,4 +8226,4 @@ function getOrderTrailingInfo(order) {
     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, getAssetByName, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, selectTokenMetadataBySymbols, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidUserFills, useHyperliquidWebSocket, useMarket, useMarketData, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };

package/dist/store/tokenSelectionMetadataStore.d.ts

@@ -1,4 +1,4 @@
-import type { TokenSelection, TokenMetadata, ActiveAssetsResponse, UniverseAsset } from "../types";
+import type { TokenSelection, TokenMetadata, ActiveAssetsResponse } from "../types";
 export interface TokenSelectionMetadataState {
     isPriceDataReady: boolean;
     isLoading: boolean;
@@ -12,10 +12,9 @@ export interface TokenSelectionMetadataState {
     volume: string;
     sumNetFunding: number;
     maxLeverage: number;
-    minMargin: number;
+    minSize: Record<string, number>;
     leverageMatched: boolean;
     recompute: (args: {
-        perpMetaAssets: UniverseAsset[] | null;
         tokenMetadata: Record<string, TokenMetadata | null>;
         marketData: ActiveAssetsResponse | null;
         longTokens: TokenSelection[];