@pear-protocol/symmio-client 0.2.23 → 0.2.26

package/dist/react/index.js

@@ -24936,11 +24936,10 @@ function useSymmMarkets(params) {
     ...params?.query,
     queryKey: symmKeys.markets(chainId, searchText),
     queryFn: () => {
-      const marketsApi = symmCoreClient.markets;
       if (searchText) {
-        return marketsApi.search(searchText, chainId);
+        return symmCoreClient.markets.search(searchText, { chainId });
       }
-      return marketsApi.list({ pageSize: "500", chainId });
+      return symmCoreClient.markets.list({ pageSize: "1000", chainId });
     },
     enabled: internalEnabled && (params?.query?.enabled ?? true)
   });
@@ -25004,634 +25003,128 @@ function useSymmHedgerMarkets(params) {
     enabled: internalEnabled && consumerEnabled
   });
 }
-function useSymmFunding(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const chainId = params?.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient;
-  return reactQuery.useQuery({
-    ...params?.query,
-    queryKey: symmKeys.fundingRates(chainId),
-    queryFn: () => symmCoreClient.funding.getRates({ chainId }),
-    enabled: internalEnabled && (params?.query?.enabled ?? true)
-  });
-}
-function useSymmFundingHistory(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const chainId = params.chainId ?? ctxChainId;
-  const {
-    period,
-    longSymbols,
-    shortSymbols,
-    interval,
-    weightMode,
-    includeContributions
-  } = params;
-  const internalEnabled = !!symmCoreClient;
-  const request = {
-    chainId,
-    period,
-    longSymbols,
-    shortSymbols,
+
+// src/utils/binance-api.ts
+var BINANCE_FAPI_BASE = "https://fapi.binance.com";
+async function fetchMarkPriceKlines(symbol, interval, startTime, endTime, limit = 1500) {
+  const params = new URLSearchParams({
+    symbol,
     interval,
-    weightMode,
-    includeContributions
-  };
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.fundingHistory(request),
-    queryFn: () => symmCoreClient.funding.getHistory(request),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    startTime: String(startTime),
+    endTime: String(endTime),
+    limit: String(Math.min(limit, 1500))
   });
+  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/markPriceKlines?${params}`);
+  if (!response.ok) {
+    throw new Error(`Binance markPriceKlines failed: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.map((k) => ({
+    openTime: Number(k[0]),
+    open: parseFloat(k[1]),
+    high: parseFloat(k[2]),
+    low: parseFloat(k[3]),
+    close: parseFloat(k[4]),
+    volume: parseFloat(k[5]),
+    closeTime: Number(k[6])
+  }));
 }
-function useSymmFundingPayments(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { address, positionId, limit, offset } = params;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!(address || positionId);
-  const request = {
-    address,
-    positionId,
-    chainId,
-    limit,
-    offset
+async function fetch24hrTicker(symbol) {
+  const params = new URLSearchParams({ symbol });
+  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/ticker/24hr?${params}`);
+  if (!response.ok) return null;
+  const data = await response.json();
+  return {
+    lastPrice: parseFloat(data.lastPrice),
+    prevClosePrice: parseFloat(data.prevClosePrice),
+    priceChangePercent: parseFloat(data.priceChangePercent)
   };
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.fundingPayments({
-      address,
-      positionId,
-      chainId,
-      limit,
-      offset
-    }),
-    queryFn: () => symmCoreClient.funding.getPayments(request),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmPortfolio(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress, address } = params;
-  const resolvedAddress = accountAddress ? void 0 : address;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.portfolio({
-      accountAddress,
-      address: resolvedAddress,
-      chainId
-    }),
-    queryFn: () => {
-      const request = {
-        accountAddress,
-        address: resolvedAddress,
-        chainId
-      };
-      return symmCoreClient.portfolio.getMetrics(request);
-    },
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
 }
-function useResolvedNotificationsParams(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const chainId = params.chainId ?? ctxChainId;
+
+// src/utils/binance-symbol-map.ts
+var SYMBOL_OVERRIDES = {
+  // Add overrides here as needed for SYMM markets that don't map 1:1 to Binance
+  // e.g., 'SOME_SYMM_SYMBOL': 'BINANCE_SYMBOL',
+};
+var UNSUPPORTED_SYMBOLS = /* @__PURE__ */ new Set([
+  // Add symbols here that have no Binance equivalent
+]);
+function resolveBinanceSymbol(symmSymbol) {
+  if (!symmSymbol || !symmSymbol.trim()) {
+    return {
+      symmSymbol,
+      normalizedSymbol: "",
+      binanceSymbol: null,
+      supported: false,
+      reason: "missing_symbol"
+    };
+  }
+  const normalized = symmSymbol.toUpperCase().trim();
+  if (!/^[A-Z0-9]+$/.test(normalized)) {
+    return {
+      symmSymbol,
+      normalizedSymbol: normalized,
+      binanceSymbol: null,
+      supported: false,
+      reason: "invalid_symbol"
+    };
+  }
+  if (UNSUPPORTED_SYMBOLS.has(normalized)) {
+    return {
+      symmSymbol,
+      normalizedSymbol: normalized,
+      binanceSymbol: null,
+      supported: false,
+      reason: "unsupported_symbol"
+    };
+  }
+  const binanceSymbol = SYMBOL_OVERRIDES[normalized] ?? (normalized.endsWith("USDT") ? normalized : `${normalized}USDT`);
   return {
-    symmCoreClient,
-    chainId,
-    userAddress: params.userAddress,
-    query: params.query
+    symmSymbol,
+    normalizedSymbol: normalized,
+    binanceSymbol,
+    supported: true,
+    reason: null
   };
 }
-function useSymmNotificationsQuery(params) {
-  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
-  const internalEnabled = !!symmCoreClient && !!userAddress;
-  return reactQuery.useQuery({
-    ...query,
-    queryKey: symmKeys.notifications(userAddress, chainId),
-    queryFn: () => symmCoreClient.notifications.list({
-      userAddress,
-      chainId
-    }),
-    enabled: internalEnabled && (query?.enabled ?? true)
-  });
+function getUnsupportedBinanceSymbols(symbols) {
+  return symbols.filter((symbol) => !resolveBinanceSymbol(symbol).supported);
 }
-function useSymmUnreadCountQuery(params) {
-  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
-  const internalEnabled = !!symmCoreClient && !!userAddress;
-  return reactQuery.useQuery({
-    ...query,
-    queryKey: symmKeys.unreadCount(userAddress, chainId),
-    queryFn: () => symmCoreClient.notifications.getUnreadCount({
-      userAddress,
-      chainId
-    }),
-    enabled: internalEnabled && (query?.enabled ?? true)
-  });
+function toBinanceSymbol(symmSymbol) {
+  return resolveBinanceSymbol(symmSymbol).binanceSymbol;
 }
-function useSymmMarkReadNotificationMutation(params, options) {
-  const { symmCoreClient, chainId, userAddress } = useResolvedNotificationsParams(params);
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.notifications(userAddress, chainId)
-        });
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.unreadCount(userAddress, chainId)
-        });
-      }
-    }),
-    mutationFn: async ({ id, timestamp }) => {
-      if (!symmCoreClient || !userAddress) {
-        throw new Error("symm-core client not available");
-      }
-      return symmCoreClient.notifications.markRead({
-        id,
-        timestamp,
-        userAddress,
-        chainId
-      });
-    }
-  });
-}
-function useSymmPendingIds(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress } = params;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!accountAddress;
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.pendingIds(accountAddress, chainId),
-    queryFn: () => symmCoreClient.positions.getPendingIds({
-      address: accountAddress,
-      chainId
-    }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmPendingInstantOpens(params) {
-  const {
-    symmCoreClient,
-    chainId: ctxChainId
-  } = useSymmContext();
-  const { accountAddress, authToken: providedAuthToken } = params;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!accountAddress;
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
-    queryFn: async () => {
-      const authToken = providedAuthToken ?? useSymmAuthStore.getState().getToken(accountAddress, chainId);
-      if (!authToken) {
-        throw new Error("failed to acquire auth token for pending instant opens");
-      }
-      return symmCoreClient.positions.getPendingInstantOpens({
-        accountAddress,
-        chainId,
-        authToken
-      });
-    },
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmTwapOrder(params) {
-  const { symmCoreClient } = useSymmContext();
-  const { orderId } = params;
-  const internalEnabled = !!symmCoreClient && !!orderId;
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.twapOrder(orderId),
-    queryFn: () => symmCoreClient.orders.getTwapOrder(orderId),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-var useSymmWsStore = zustand.create((set) => ({
-  isConnected: false,
-  setConnected: (isConnected) => set({ isConnected })
-}));
-
-// src/react/hooks/use-symm-ws.ts
-function asUnsubscribeFn(value) {
-  return typeof value === "function" ? value : null;
-}
-function useSymmWs(params = {}) {
-  const {
-    symmCoreClient: ctxClient,
-    address: ctxAddress,
-    chainId: ctxChainId
-  } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
-  const isConnected = useSymmWsStore((state) => state.isConnected);
-  const setConnected = useSymmWsStore((state) => state.setConnected);
-  const symmCoreClient = params.symmCoreClient ?? ctxClient;
-  const accountAddress = params.accountAddress ?? ctxAddress;
-  const chainId = params.chainId ?? ctxChainId;
-  react.useEffect(() => {
-    if (!symmCoreClient || !accountAddress) {
-      setConnected(false);
-      return;
-    }
-    const ws = symmCoreClient.ws;
-    const addr = accountAddress;
-    const unsubscribers = [];
-    const removeOnConnect = ws.onConnect(() => setConnected(true));
-    const removeOnDisconnect = ws.onDisconnect(() => setConnected(false));
-    unsubscribers.push(removeOnConnect, removeOnDisconnect);
-    const positionsUnsub = asUnsubscribeFn(
-      ws.subscribeToPositions(addr, chainId, () => {
-        queryClient.invalidateQueries({
-          queryKey: ["symm", "positions"]
-        });
-      })
-    );
-    if (positionsUnsub) unsubscribers.push(positionsUnsub);
-    const openOrdersUnsub = asUnsubscribeFn(
-      ws.subscribeToOpenOrders(addr, chainId, () => {
-        queryClient.invalidateQueries({
-          queryKey: ["symm", "openOrders"]
-        });
-      })
-    );
-    if (openOrdersUnsub) unsubscribers.push(openOrdersUnsub);
-    const tradesUnsub = asUnsubscribeFn(
-      ws.subscribeToTrades(addr, chainId, () => {
-        queryClient.invalidateQueries({
-          queryKey: ["symm", "tradeHistory"]
-        });
-      })
-    );
-    if (tradesUnsub) unsubscribers.push(tradesUnsub);
-    const accountSummaryUnsub = asUnsubscribeFn(
-      ws.subscribeToAccountSummary(addr, chainId, () => {
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.balances(accountAddress, chainId)
-        });
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.accountSummary(accountAddress, chainId)
-        });
-      })
-    );
-    if (accountSummaryUnsub) unsubscribers.push(accountSummaryUnsub);
-    const notificationsUnsub = asUnsubscribeFn(
-      ws.subscribeToNotifications(addr, chainId, () => {
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.notifications(accountAddress, chainId)
-        });
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.unreadCount(accountAddress, chainId)
-        });
-      })
-    );
-    if (notificationsUnsub) unsubscribers.push(notificationsUnsub);
-    const tpslUnsub = asUnsubscribeFn(
-      ws.subscribeToTpsl(addr, chainId, () => {
-        queryClient.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
-        queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-      })
-    );
-    if (tpslUnsub) unsubscribers.push(tpslUnsub);
-    const twapUnsub = asUnsubscribeFn(
-      ws.subscribeToTwapOrders(addr, chainId, () => {
-        queryClient.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
-        queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-      })
-    );
-    if (twapUnsub) unsubscribers.push(twapUnsub);
-    const triggerOrdersUnsub = asUnsubscribeFn(
-      ws.subscribeToTriggerOrders(addr, chainId, () => {
-        queryClient.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
-        queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-      })
-    );
-    if (triggerOrdersUnsub) unsubscribers.push(triggerOrdersUnsub);
-    const executionsUnsub = asUnsubscribeFn(
-      ws.subscribeToExecutions(addr, chainId, () => {
-        queryClient.invalidateQueries({
-          queryKey: ["symm", "positions"]
-        });
-        queryClient.invalidateQueries({
-          queryKey: ["symm", "portfolio"]
-        });
-      })
-    );
-    if (executionsUnsub) unsubscribers.push(executionsUnsub);
-    return () => {
-      unsubscribers.forEach((unsubscribe) => unsubscribe());
-    };
-  }, [symmCoreClient, accountAddress, chainId, queryClient, setConnected]);
-  return { isConnected };
-}
-var STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USD", "USDT", "USDE", "USDH", "USDT0"]);
-function useSymmChartSelection(input) {
-  const {
-    longSymbol,
-    shortSymbol,
-    longWeight = 100,
-    shortWeight = 100,
-    longTokens: explicitLongTokens,
-    shortTokens: explicitShortTokens
-  } = input;
-  return react.useMemo(() => {
-    const longTokens = explicitLongTokens?.length ? explicitLongTokens : longSymbol ? [{ symbol: longSymbol, weight: longWeight }] : [];
-    const shortTokens = explicitShortTokens?.length ? explicitShortTokens : shortSymbol ? [{ symbol: shortSymbol, weight: shortWeight }] : [];
-    const selectedSymbols = [
-      ...longTokens.map((t) => t.symbol),
-      ...shortTokens.map((t) => t.symbol)
-    ];
-    const uniqueSelectedSymbols = Array.from(new Set(selectedSymbols));
-    const longPrimarySymbol = longTokens[0]?.symbol ?? null;
-    const shortPrimarySymbol = shortTokens[0]?.symbol ?? null;
-    const longIsStable = longPrimarySymbol ? STABLE_SYMBOLS.has(longPrimarySymbol.toUpperCase()) : true;
-    const shortIsStable = shortPrimarySymbol ? STABLE_SYMBOLS.has(shortPrimarySymbol.toUpperCase()) : true;
-    let isSingleSided = false;
-    let activeSide = null;
-    let activeTokenSymbol;
-    if (longTokens.length > 0 && !longIsStable && (shortTokens.length === 0 || shortIsStable)) {
-      isSingleSided = true;
-      activeSide = "long";
-      activeTokenSymbol = longPrimarySymbol ?? void 0;
-    } else if (shortTokens.length > 0 && !shortIsStable && (longTokens.length === 0 || longIsStable)) {
-      isSingleSided = true;
-      activeSide = "short";
-      activeTokenSymbol = shortPrimarySymbol ?? void 0;
-    }
-    const longLabel = longTokens.map((token) => token.symbol).join("+") || "USDC";
-    const shortLabel = shortTokens.map((token) => token.symbol).join("+") || "USDC";
-    const pairLabel = `${longLabel}/${shortLabel}`;
-    return {
-      longTokens,
-      shortTokens,
-      isSingleSided,
-      activeSide,
-      activeTokenSymbol,
-      pairLabel,
-      selectedSymbols: uniqueSelectedSymbols
-    };
-  }, [
-    explicitLongTokens,
-    explicitShortTokens,
-    longSymbol,
-    shortSymbol,
-    longWeight,
-    shortWeight
-  ]);
-}
-
-// src/utils/binance-symbol-map.ts
-var SYMBOL_OVERRIDES = {
-  // Add overrides here as needed for SYMM markets that don't map 1:1 to Binance
-  // e.g., 'SOME_SYMM_SYMBOL': 'BINANCE_SYMBOL',
-};
-var UNSUPPORTED_SYMBOLS = /* @__PURE__ */ new Set([
-  // Add symbols here that have no Binance equivalent
-]);
-function resolveBinanceSymbol(symmSymbol) {
-  if (!symmSymbol || !symmSymbol.trim()) {
-    return {
-      symmSymbol,
-      normalizedSymbol: "",
-      binanceSymbol: null,
-      supported: false,
-      reason: "missing_symbol"
-    };
-  }
-  const normalized = symmSymbol.toUpperCase().trim();
-  if (!/^[A-Z0-9]+$/.test(normalized)) {
-    return {
-      symmSymbol,
-      normalizedSymbol: normalized,
-      binanceSymbol: null,
-      supported: false,
-      reason: "invalid_symbol"
-    };
-  }
-  if (UNSUPPORTED_SYMBOLS.has(normalized)) {
-    return {
-      symmSymbol,
-      normalizedSymbol: normalized,
-      binanceSymbol: null,
-      supported: false,
-      reason: "unsupported_symbol"
-    };
-  }
-  const binanceSymbol = SYMBOL_OVERRIDES[normalized] ?? (normalized.endsWith("USDT") ? normalized : `${normalized}USDT`);
-  return {
-    symmSymbol,
-    normalizedSymbol: normalized,
-    binanceSymbol,
-    supported: true,
-    reason: null
-  };
-}
-function getUnsupportedBinanceSymbols(symbols) {
-  return symbols.filter((symbol) => !resolveBinanceSymbol(symbol).supported);
-}
-function toBinanceSymbol(symmSymbol) {
-  return resolveBinanceSymbol(symmSymbol).binanceSymbol;
-}
-
-// src/utils/binance-api.ts
-var BINANCE_FAPI_BASE = "https://fapi.binance.com";
-async function fetchMarkPriceKlines(symbol, interval, startTime, endTime, limit = 1500) {
-  const params = new URLSearchParams({
-    symbol,
-    interval,
-    startTime: String(startTime),
-    endTime: String(endTime),
-    limit: String(Math.min(limit, 1500))
-  });
-  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/markPriceKlines?${params}`);
-  if (!response.ok) {
-    throw new Error(`Binance markPriceKlines failed: ${response.status}`);
-  }
-  const data = await response.json();
-  return data.map((k) => ({
-    openTime: Number(k[0]),
-    open: parseFloat(k[1]),
-    high: parseFloat(k[2]),
-    low: parseFloat(k[3]),
-    close: parseFloat(k[4]),
-    volume: parseFloat(k[5]),
-    closeTime: Number(k[6])
-  }));
-}
-async function fetch24hrTicker(symbol) {
-  const params = new URLSearchParams({ symbol });
-  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/ticker/24hr?${params}`);
-  if (!response.ok) return null;
-  const data = await response.json();
-  return {
-    lastPrice: parseFloat(data.lastPrice),
-    prevClosePrice: parseFloat(data.prevClosePrice),
-    priceChangePercent: parseFloat(data.priceChangePercent)
-  };
-}
-
-// src/utils/chart-metrics.ts
-function getPositiveValue(metadata, field) {
-  const value = metadata?.[field];
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    return null;
-  }
-  return value;
-}
-function computeWeightedProduct(tokens, metadataMap, field, invert = false) {
-  let product = 1;
-  let hasToken = false;
-  for (const token of tokens) {
-    if (!(token.weight > 0)) {
-      continue;
-    }
-    const price = getPositiveValue(metadataMap[token.symbol], field);
-    if (price === null) {
-      return null;
-    }
-    hasToken = true;
-    const exponent = invert ? -(token.weight / 100) : token.weight / 100;
-    product *= Math.pow(price, exponent);
-  }
-  return hasToken ? product : 1;
-}
-function computePriceRatio({
-  longTokens,
-  shortTokens,
-  longTokensMetadata,
-  shortTokensMetadata
-}) {
-  const firstLong = longTokens[0];
-  const firstShort = shortTokens[0];
-  const longPrice = firstLong ? getPositiveValue(longTokensMetadata[firstLong.symbol], "currentPrice") : null;
-  const shortPrice = firstShort ? getPositiveValue(shortTokensMetadata[firstShort.symbol], "currentPrice") : null;
-  if (longPrice !== null && shortPrice !== null) {
-    return longPrice / shortPrice;
-  }
-  if (longPrice !== null && shortTokens.length === 0) {
-    return longPrice;
-  }
-  if (shortPrice !== null && longTokens.length === 0) {
-    return shortPrice;
-  }
-  return null;
-}
-function computePriceRatio24h({
-  longTokens,
-  shortTokens,
-  longTokensMetadata,
-  shortTokensMetadata
-}) {
-  const firstLong = longTokens[0];
-  const firstShort = shortTokens[0];
-  const longPrice = firstLong ? getPositiveValue(longTokensMetadata[firstLong.symbol], "prevDayPrice") : null;
-  const shortPrice = firstShort ? getPositiveValue(shortTokensMetadata[firstShort.symbol], "prevDayPrice") : null;
-  if (longPrice !== null && shortPrice !== null) {
-    return longPrice / shortPrice;
-  }
-  if (longPrice !== null && shortTokens.length === 0) {
-    return longPrice;
-  }
-  if (shortPrice !== null && longTokens.length === 0) {
-    return shortPrice;
-  }
-  return null;
-}
-function computeWeightedRatio({
-  longTokens,
-  shortTokens,
-  longTokensMetadata,
-  shortTokensMetadata
-}) {
-  const longProduct = computeWeightedProduct(
-    longTokens,
-    longTokensMetadata,
-    "currentPrice"
-  );
-  const shortProduct = computeWeightedProduct(
-    shortTokens,
-    shortTokensMetadata,
-    "currentPrice",
-    true
-  );
-  if (longProduct === null || shortProduct === null) {
-    return null;
-  }
-  return longProduct * shortProduct;
-}
-function computeWeightedRatio24h({
-  longTokens,
-  shortTokens,
-  longTokensMetadata,
-  shortTokensMetadata
-}) {
-  const longProduct = computeWeightedProduct(
-    longTokens,
-    longTokensMetadata,
-    "prevDayPrice"
-  );
-  const shortProduct = computeWeightedProduct(
-    shortTokens,
-    shortTokensMetadata,
-    "prevDayPrice",
-    true
-  );
-  if (longProduct === null || shortProduct === null) {
-    return null;
-  }
-  return longProduct * shortProduct;
-}
-function computeNetFundingSum({
-  longTokens,
-  shortTokens,
-  longTokensMetadata,
-  shortTokensMetadata
-}) {
-  let funding = 0;
-  for (const token of longTokens) {
-    const value = longTokensMetadata[token.symbol]?.netFunding;
-    if (typeof value === "number" && Number.isFinite(value)) {
-      funding += value;
-    }
-  }
-  for (const token of shortTokens) {
-    const value = shortTokensMetadata[token.symbol]?.netFunding;
-    if (typeof value === "number" && Number.isFinite(value)) {
-      funding += value;
-    }
-  }
-  return funding;
-}
-
-// src/utils/binance-ws.ts
-var BINANCE_WS_URL = "wss://fstream.binance.com/ws";
-var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
-var BinanceWsManager = class {
-  ws = null;
-  streams = /* @__PURE__ */ new Map();
-  reconnectAttempt = 0;
-  reconnectTimer = null;
-  intentionalClose = false;
-  pendingSubscribes = [];
-  idCounter = 0;
-  /**
-   * Subscribe to a kline stream. Returns an unsubscribe function.
-   */
-  subscribeKline(symbol, interval, cb) {
-    const streamName = `${symbol.toLowerCase()}@kline_${interval}`;
-    const id = this.generateId();
-    const wrappedCb = (raw) => {
-      const k = raw.k;
-      if (!k) return;
-      cb({
-        symbol: raw.s,
-        interval: k.i,
-        openTime: k.t,
-        closeTime: k.T,
-        open: parseFloat(k.o),
-        high: parseFloat(k.h),
-        low: parseFloat(k.l),
-        close: parseFloat(k.c),
-        volume: parseFloat(k.v),
-        isFinal: k.x
+
+// src/utils/binance-ws.ts
+var BINANCE_WS_URL = "wss://fstream.binance.com/ws";
+var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var BinanceWsManager = class {
+  ws = null;
+  streams = /* @__PURE__ */ new Map();
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  intentionalClose = false;
+  pendingSubscribes = [];
+  idCounter = 0;
+  /**
+   * Subscribe to a kline stream. Returns an unsubscribe function.
+   */
+  subscribeKline(symbol, interval, cb) {
+    const streamName = `${symbol.toLowerCase()}@kline_${interval}`;
+    const id = this.generateId();
+    const wrappedCb = (raw) => {
+      const k = raw.k;
+      if (!k) return;
+      cb({
+        symbol: raw.s,
+        interval: k.i,
+        openTime: k.t,
+        closeTime: k.T,
+        open: parseFloat(k.o),
+        high: parseFloat(k.h),
+        low: parseFloat(k.l),
+        close: parseFloat(k.c),
+        volume: parseFloat(k.v),
+        isFinal: k.x
       });
     };
     this.addStreamCallback(streamName, id, wrappedCb);
@@ -25650,225 +25143,837 @@ var BinanceWsManager = class {
         indexPrice: parseFloat(raw.i),
         time: raw.E
       });
-    };
-    this.addStreamCallback(streamName, id, wrappedCb);
-    return () => this.removeStreamCallback(streamName, id);
-  }
-  /**
-   * Destroy the manager and close the connection.
-   */
-  destroy() {
-    this.intentionalClose = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
+    };
+    this.addStreamCallback(streamName, id, wrappedCb);
+    return () => this.removeStreamCallback(streamName, id);
+  }
+  /**
+   * Destroy the manager and close the connection.
+   */
+  destroy() {
+    this.intentionalClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.streams.clear();
+  }
+  // --- Private ---
+  generateId() {
+    return `sub_${++this.idCounter}_${Date.now()}`;
+  }
+  addStreamCallback(streamName, id, cb) {
+    let sub = this.streams.get(streamName);
+    const isNew = !sub;
+    if (!sub) {
+      sub = { callbacks: /* @__PURE__ */ new Map() };
+      this.streams.set(streamName, sub);
+    }
+    sub.callbacks.set(id, cb);
+    if (isNew) {
+      this.ensureConnected();
+      this.sendSubscribe([streamName]);
+    }
+  }
+  removeStreamCallback(streamName, id) {
+    const sub = this.streams.get(streamName);
+    if (!sub) return;
+    sub.callbacks.delete(id);
+    if (sub.callbacks.size === 0) {
+      this.streams.delete(streamName);
+      this.sendUnsubscribe([streamName]);
+      if (this.streams.size === 0 && this.ws) {
+        this.intentionalClose = true;
+        this.ws.close();
+        this.ws = null;
+        this.intentionalClose = false;
+      }
+    }
+  }
+  ensureConnected() {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.connect();
+  }
+  connect() {
+    if (typeof WebSocket === "undefined") return;
+    this.intentionalClose = false;
+    this.ws = new WebSocket(BINANCE_WS_URL);
+    this.ws.onopen = () => {
+      this.reconnectAttempt = 0;
+      const activeStreams = Array.from(this.streams.keys());
+      if (activeStreams.length > 0) {
+        this.sendSubscribe(activeStreams);
+      }
+      if (this.pendingSubscribes.length > 0) {
+        this.sendSubscribe(this.pendingSubscribes);
+        this.pendingSubscribes = [];
+      }
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      if (this.intentionalClose) return;
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  handleMessage(data) {
+    if (data.e === "kline") {
+      const k = data.k;
+      const streamName = `${data.s.toLowerCase()}@kline_${k.i}`;
+      this.dispatchToStream(streamName, data);
+    } else if (data.e === "markPriceUpdate") {
+      const streamName = `${data.s.toLowerCase()}@markPrice@1s`;
+      this.dispatchToStream(streamName, data);
+    }
+  }
+  dispatchToStream(streamName, data) {
+    const sub = this.streams.get(streamName);
+    if (!sub) return;
+    sub.callbacks.forEach((cb) => {
+      try {
+        cb(data);
+      } catch {
+      }
+    });
+  }
+  sendSubscribe(streams) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.pendingSubscribes.push(...streams);
+      return;
+    }
+    this.ws.send(JSON.stringify({
+      method: "SUBSCRIBE",
+      params: streams,
+      id: Date.now()
+    }));
+  }
+  sendUnsubscribe(streams) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.pendingSubscribes = this.pendingSubscribes.filter(
+        (s) => !streams.includes(s)
+      );
+      return;
+    }
+    this.ws.send(JSON.stringify({
+      method: "UNSUBSCRIBE",
+      params: streams,
+      id: Date.now()
+    }));
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    if (this.streams.size === 0) return;
+    const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)];
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+};
+var _instance = null;
+function getBinanceWsManager() {
+  if (!_instance) {
+    _instance = new BinanceWsManager();
+  }
+  return _instance;
+}
+
+// src/react/stores/use-binance-mark-price-store.ts
+var refCounts = /* @__PURE__ */ new Map();
+var streamUnsubs = /* @__PURE__ */ new Map();
+var streamSymbols = /* @__PURE__ */ new Map();
+function normalizeBinanceSymbol(symbol) {
+  return symbol.toUpperCase().trim();
+}
+function getNextRefCount(binanceSymbol) {
+  return (refCounts.get(binanceSymbol) ?? 0) + 1;
+}
+function getPrevRefCount(binanceSymbol) {
+  return Math.max(0, (refCounts.get(binanceSymbol) ?? 0) - 1);
+}
+var useBinanceMarkPriceStore = zustand.create((set) => ({
+  markPrices: {},
+  subscribeSymbol: (symmSymbol, rawBinanceSymbol) => {
+    const binanceSymbol = normalizeBinanceSymbol(rawBinanceSymbol);
+    const nextRefCount = getNextRefCount(binanceSymbol);
+    refCounts.set(binanceSymbol, nextRefCount);
+    const symbols = streamSymbols.get(binanceSymbol) ?? /* @__PURE__ */ new Set();
+    symbols.add(symmSymbol);
+    streamSymbols.set(binanceSymbol, symbols);
+    if (nextRefCount === 1) {
+      const wsManager = getBinanceWsManager();
+      const unsubscribe = wsManager.subscribeMarkPrice(binanceSymbol, (data) => {
+        const canonicalSymbol = normalizeBinanceSymbol(data.symbol);
+        const mappedSymbols = streamSymbols.get(canonicalSymbol);
+        if (!mappedSymbols || mappedSymbols.size === 0) return;
+        set((state) => {
+          const nextMarkPrices = { ...state.markPrices };
+          mappedSymbols.forEach((mappedSymbol) => {
+            nextMarkPrices[mappedSymbol] = data.markPrice;
+          });
+          return { markPrices: nextMarkPrices };
+        });
+      });
+      streamUnsubs.set(binanceSymbol, unsubscribe);
     }
-    this.streams.clear();
-  }
-  // --- Private ---
-  generateId() {
-    return `sub_${++this.idCounter}_${Date.now()}`;
-  }
-  addStreamCallback(streamName, id, cb) {
-    let sub = this.streams.get(streamName);
-    const isNew = !sub;
-    if (!sub) {
-      sub = { callbacks: /* @__PURE__ */ new Map() };
-      this.streams.set(streamName, sub);
+  },
+  unsubscribeSymbol: (symmSymbol, rawBinanceSymbol) => {
+    const binanceSymbol = normalizeBinanceSymbol(rawBinanceSymbol);
+    const symbols = streamSymbols.get(binanceSymbol);
+    if (symbols) {
+      symbols.delete(symmSymbol);
+      if (symbols.size === 0) {
+        streamSymbols.delete(binanceSymbol);
+      } else {
+        streamSymbols.set(binanceSymbol, symbols);
+      }
     }
-    sub.callbacks.set(id, cb);
-    if (isNew) {
-      this.ensureConnected();
-      this.sendSubscribe([streamName]);
+    const nextRefCount = getPrevRefCount(binanceSymbol);
+    if (nextRefCount === 0) {
+      const unsubscribe = streamUnsubs.get(binanceSymbol);
+      if (unsubscribe) unsubscribe();
+      streamUnsubs.delete(binanceSymbol);
+      refCounts.delete(binanceSymbol);
+    } else {
+      refCounts.set(binanceSymbol, nextRefCount);
     }
+    set((state) => {
+      if (state.markPrices[symmSymbol] == null) return state;
+      const nextMarkPrices = { ...state.markPrices };
+      delete nextMarkPrices[symmSymbol];
+      return { markPrices: nextMarkPrices };
+    });
   }
-  removeStreamCallback(streamName, id) {
-    const sub = this.streams.get(streamName);
-    if (!sub) return;
-    sub.callbacks.delete(id);
-    if (sub.callbacks.size === 0) {
-      this.streams.delete(streamName);
-      this.sendUnsubscribe([streamName]);
-      if (this.streams.size === 0 && this.ws) {
-        this.intentionalClose = true;
-        this.ws.close();
-        this.ws = null;
-        this.intentionalClose = false;
+}));
+
+// src/react/hooks/use-symm-token-selection-markets.ts
+async function fetchTickerSnapshot(symbol) {
+  const resolution = resolveBinanceSymbol(symbol);
+  if (!resolution.binanceSymbol) return null;
+  const ticker = await fetch24hrTicker(resolution.binanceSymbol);
+  if (!ticker) return null;
+  return {
+    prevClosePrice: ticker.prevClosePrice
+  };
+}
+function useSymmTokenSelectionMarkets(params) {
+  const query = useSymmHedgerMarkets(params);
+  const baseMarkets = query.data?.filteredMarkets ?? query.data?.markets ?? [];
+  const marketSymbols = react.useMemo(
+    () => Array.from(
+      new Set(
+        baseMarkets.map((market) => market.symbol).filter((symbol) => !!symbol)
+      )
+    ),
+    [baseMarkets]
+  );
+  const symbolsKey = react.useMemo(
+    () => [...marketSymbols].sort().join(","),
+    [marketSymbols]
+  );
+  const symbolToBinanceMap = react.useMemo(
+    () => new Map(
+      marketSymbols.map((symbol) => {
+        const binanceSymbol = resolveBinanceSymbol(symbol).binanceSymbol;
+        if (!binanceSymbol) return null;
+        return [symbol, binanceSymbol];
+      }).filter((entry) => !!entry)
+    ),
+    [marketSymbols]
+  );
+  const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
+  const subscribeSymbol = useBinanceMarkPriceStore((state) => state.subscribeSymbol);
+  const unsubscribeSymbol = useBinanceMarkPriceStore((state) => state.unsubscribeSymbol);
+  const priceQuery = reactQuery.useQuery({
+    queryKey: ["symm", "token-selection-markets-price", symbolsKey],
+    queryFn: async () => {
+      const tickerSnapshots = {};
+      await Promise.all(
+        marketSymbols.map(async (symbol) => {
+          tickerSnapshots[symbol] = await fetchTickerSnapshot(symbol);
+        })
+      );
+      return { tickerSnapshots };
+    },
+    enabled: query.isSuccess && marketSymbols.length > 0,
+    staleTime: 6e4,
+    gcTime: 5 * 6e4
+  });
+  react.useEffect(() => {
+    if (!query.isSuccess || symbolToBinanceMap.size === 0) {
+      return;
+    }
+    const symbolEntries = Array.from(symbolToBinanceMap.entries());
+    symbolEntries.forEach(
+      ([symbol, binanceSymbol]) => subscribeSymbol(symbol, binanceSymbol)
+    );
+    return () => {
+      symbolEntries.forEach(
+        ([symbol, binanceSymbol]) => unsubscribeSymbol(symbol, binanceSymbol)
+      );
+    };
+  }, [query.isSuccess, symbolsKey, symbolToBinanceMap, subscribeSymbol, unsubscribeSymbol]);
+  const markets = react.useMemo(() => {
+    const snapshots = priceQuery.data?.tickerSnapshots ?? {};
+    return baseMarkets.map((market) => {
+      const symbol = market.symbol ?? "";
+      const markPrice = symbol ? liveMarkPrices[symbol] ?? null : null;
+      const prevDayPrice = symbol ? snapshots[symbol]?.prevClosePrice ?? null : null;
+      const priceChange24h = markPrice != null && prevDayPrice != null ? markPrice - prevDayPrice : null;
+      const priceChange24hPercent = markPrice != null && prevDayPrice != null && prevDayPrice !== 0 ? (markPrice - prevDayPrice) / prevDayPrice * 100 : null;
+      return {
+        ...market,
+        collateralToken: "USDC",
+        markPrice,
+        prevDayPrice,
+        priceChange24h,
+        priceChange24hPercent
+      };
+    });
+  }, [baseMarkets, liveMarkPrices, priceQuery.data]);
+  const marketsBySymbol = react.useMemo(
+    () => new Map(
+      markets.filter((m) => !!m.symbol).map((m) => [m.symbol, m])
+    ),
+    [markets]
+  );
+  const marketsById = react.useMemo(
+    () => new Map(markets.map((market) => [market.id, market])),
+    [markets]
+  );
+  return {
+    query,
+    priceQuery,
+    markets,
+    marketsBySymbol,
+    marketsById,
+    isLoading: query.isLoading || priceQuery.isLoading,
+    isPriceLoading: priceQuery.isLoading
+  };
+}
+function useSymmFunding(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient;
+  return reactQuery.useQuery({
+    ...params?.query,
+    queryKey: symmKeys.fundingRates(chainId),
+    queryFn: () => symmCoreClient.funding.getRates({ chainId }),
+    enabled: internalEnabled && (params?.query?.enabled ?? true)
+  });
+}
+function useSymmFundingHistory(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const {
+    period,
+    longSymbols,
+    shortSymbols,
+    interval,
+    weightMode,
+    includeContributions
+  } = params;
+  const internalEnabled = !!symmCoreClient;
+  const request = {
+    chainId,
+    period,
+    longSymbols,
+    shortSymbols,
+    interval,
+    weightMode,
+    includeContributions
+  };
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.fundingHistory(request),
+    queryFn: () => symmCoreClient.funding.getHistory(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmFundingPayments(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { address, positionId, limit, offset } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(address || positionId);
+  const request = {
+    address,
+    positionId,
+    chainId,
+    limit,
+    offset
+  };
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.fundingPayments({
+      address,
+      positionId,
+      chainId,
+      limit,
+      offset
+    }),
+    queryFn: () => symmCoreClient.funding.getPayments(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmPortfolio(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { accountAddress, address } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.portfolio({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
+    }),
+    queryFn: () => {
+      const request = {
+        accountAddress,
+        address: resolvedAddress,
+        chainId
+      };
+      return symmCoreClient.portfolio.getMetrics(request);
+    },
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useResolvedNotificationsParams(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  return {
+    symmCoreClient,
+    chainId,
+    userAddress: params.userAddress,
+    query: params.query
+  };
+}
+function useSymmNotificationsQuery(params) {
+  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
+  const internalEnabled = !!symmCoreClient && !!userAddress;
+  return reactQuery.useQuery({
+    ...query,
+    queryKey: symmKeys.notifications(userAddress, chainId),
+    queryFn: () => symmCoreClient.notifications.list({
+      userAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (query?.enabled ?? true)
+  });
+}
+function useSymmUnreadCountQuery(params) {
+  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
+  const internalEnabled = !!symmCoreClient && !!userAddress;
+  return reactQuery.useQuery({
+    ...query,
+    queryKey: symmKeys.unreadCount(userAddress, chainId),
+    queryFn: () => symmCoreClient.notifications.getUnreadCount({
+      userAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (query?.enabled ?? true)
+  });
+}
+function useSymmMarkReadNotificationMutation(params, options) {
+  const { symmCoreClient, chainId, userAddress } = useResolvedNotificationsParams(params);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.notifications(userAddress, chainId)
+        });
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.unreadCount(userAddress, chainId)
+        });
+      }
+    }),
+    mutationFn: async ({ id, timestamp }) => {
+      if (!symmCoreClient || !userAddress) {
+        throw new Error("symm-core client not available");
       }
+      return symmCoreClient.notifications.markRead({
+        id,
+        timestamp,
+        userAddress,
+        chainId
+      });
     }
-  }
-  ensureConnected() {
-    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+  });
+}
+function useSymmPendingIds(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { accountAddress } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!accountAddress;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.pendingIds(accountAddress, chainId),
+    queryFn: () => symmCoreClient.positions.getPendingIds({
+      address: accountAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmPendingInstantOpens(params) {
+  const {
+    symmCoreClient,
+    chainId: ctxChainId
+  } = useSymmContext();
+  const { accountAddress, authToken: providedAuthToken } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!accountAddress;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
+    queryFn: async () => {
+      const authToken = providedAuthToken ?? useSymmAuthStore.getState().getToken(accountAddress, chainId);
+      if (!authToken) {
+        throw new Error("failed to acquire auth token for pending instant opens");
+      }
+      return symmCoreClient.positions.getPendingInstantOpens({
+        accountAddress,
+        chainId,
+        authToken
+      });
+    },
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmTwapOrder(params) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const internalEnabled = !!symmCoreClient && !!orderId;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.twapOrder(orderId),
+    queryFn: () => symmCoreClient.orders.getTwapOrder(orderId),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+var useSymmWsStore = zustand.create((set) => ({
+  isConnected: false,
+  setConnected: (isConnected) => set({ isConnected })
+}));
+
+// src/react/hooks/use-symm-ws.ts
+function asUnsubscribeFn(value) {
+  return typeof value === "function" ? value : null;
+}
+function useSymmWs(params = {}) {
+  const {
+    symmCoreClient: ctxClient,
+    address: ctxAddress,
+    chainId: ctxChainId
+  } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const isConnected = useSymmWsStore((state) => state.isConnected);
+  const setConnected = useSymmWsStore((state) => state.setConnected);
+  const symmCoreClient = params.symmCoreClient ?? ctxClient;
+  const accountAddress = params.accountAddress ?? ctxAddress;
+  const chainId = params.chainId ?? ctxChainId;
+  react.useEffect(() => {
+    if (!symmCoreClient || !accountAddress) {
+      setConnected(false);
       return;
     }
-    this.connect();
-  }
-  connect() {
-    if (typeof WebSocket === "undefined") return;
-    this.intentionalClose = false;
-    this.ws = new WebSocket(BINANCE_WS_URL);
-    this.ws.onopen = () => {
-      this.reconnectAttempt = 0;
-      const activeStreams = Array.from(this.streams.keys());
-      if (activeStreams.length > 0) {
-        this.sendSubscribe(activeStreams);
-      }
-      if (this.pendingSubscribes.length > 0) {
-        this.sendSubscribe(this.pendingSubscribes);
-        this.pendingSubscribes = [];
-      }
-    };
-    this.ws.onmessage = (event) => {
-      try {
-        const data = JSON.parse(event.data);
-        this.handleMessage(data);
-      } catch {
-      }
-    };
-    this.ws.onclose = () => {
-      if (this.intentionalClose) return;
-      this.scheduleReconnect();
+    const ws = symmCoreClient.ws;
+    const addr = accountAddress;
+    const unsubscribers = [];
+    const removeOnConnect = ws.onConnect(() => setConnected(true));
+    const removeOnDisconnect = ws.onDisconnect(() => setConnected(false));
+    unsubscribers.push(removeOnConnect, removeOnDisconnect);
+    const positionsUnsub = asUnsubscribeFn(
+      ws.subscribeToPositions(addr, chainId, () => {
+        queryClient.invalidateQueries({
+          queryKey: ["symm", "positions"]
+        });
+      })
+    );
+    if (positionsUnsub) unsubscribers.push(positionsUnsub);
+    const openOrdersUnsub = asUnsubscribeFn(
+      ws.subscribeToOpenOrders(addr, chainId, () => {
+        queryClient.invalidateQueries({
+          queryKey: ["symm", "openOrders"]
+        });
+      })
+    );
+    if (openOrdersUnsub) unsubscribers.push(openOrdersUnsub);
+    const tradesUnsub = asUnsubscribeFn(
+      ws.subscribeToTrades(addr, chainId, () => {
+        queryClient.invalidateQueries({
+          queryKey: ["symm", "tradeHistory"]
+        });
+      })
+    );
+    if (tradesUnsub) unsubscribers.push(tradesUnsub);
+    const accountSummaryUnsub = asUnsubscribeFn(
+      ws.subscribeToAccountSummary(addr, chainId, () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.balances(accountAddress, chainId)
+        });
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.accountSummary(accountAddress, chainId)
+        });
+      })
+    );
+    if (accountSummaryUnsub) unsubscribers.push(accountSummaryUnsub);
+    const notificationsUnsub = asUnsubscribeFn(
+      ws.subscribeToNotifications(addr, chainId, () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.notifications(accountAddress, chainId)
+        });
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.unreadCount(accountAddress, chainId)
+        });
+      })
+    );
+    if (notificationsUnsub) unsubscribers.push(notificationsUnsub);
+    const tpslUnsub = asUnsubscribeFn(
+      ws.subscribeToTpsl(addr, chainId, () => {
+        queryClient.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
+        queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+      })
+    );
+    if (tpslUnsub) unsubscribers.push(tpslUnsub);
+    const twapUnsub = asUnsubscribeFn(
+      ws.subscribeToTwapOrders(addr, chainId, () => {
+        queryClient.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
+        queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+      })
+    );
+    if (twapUnsub) unsubscribers.push(twapUnsub);
+    const triggerOrdersUnsub = asUnsubscribeFn(
+      ws.subscribeToTriggerOrders(addr, chainId, () => {
+        queryClient.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
+        queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+      })
+    );
+    if (triggerOrdersUnsub) unsubscribers.push(triggerOrdersUnsub);
+    const executionsUnsub = asUnsubscribeFn(
+      ws.subscribeToExecutions(addr, chainId, () => {
+        queryClient.invalidateQueries({
+          queryKey: ["symm", "positions"]
+        });
+        queryClient.invalidateQueries({
+          queryKey: ["symm", "portfolio"]
+        });
+      })
+    );
+    if (executionsUnsub) unsubscribers.push(executionsUnsub);
+    return () => {
+      unsubscribers.forEach((unsubscribe) => unsubscribe());
     };
-    this.ws.onerror = () => {
+  }, [symmCoreClient, accountAddress, chainId, queryClient, setConnected]);
+  return { isConnected };
+}
+var STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USD", "USDT", "USDE", "USDH", "USDT0"]);
+function useSymmChartSelection(input) {
+  const {
+    longSymbol,
+    shortSymbol,
+    longWeight = 100,
+    shortWeight = 100,
+    longTokens: explicitLongTokens,
+    shortTokens: explicitShortTokens
+  } = input;
+  return react.useMemo(() => {
+    const longTokens = explicitLongTokens?.length ? explicitLongTokens : longSymbol ? [{ symbol: longSymbol, weight: longWeight }] : [];
+    const shortTokens = explicitShortTokens?.length ? explicitShortTokens : shortSymbol ? [{ symbol: shortSymbol, weight: shortWeight }] : [];
+    const selectedSymbols = [
+      ...longTokens.map((t) => t.symbol),
+      ...shortTokens.map((t) => t.symbol)
+    ];
+    const uniqueSelectedSymbols = Array.from(new Set(selectedSymbols));
+    const longPrimarySymbol = longTokens[0]?.symbol ?? null;
+    const shortPrimarySymbol = shortTokens[0]?.symbol ?? null;
+    const longIsStable = longPrimarySymbol ? STABLE_SYMBOLS.has(longPrimarySymbol.toUpperCase()) : true;
+    const shortIsStable = shortPrimarySymbol ? STABLE_SYMBOLS.has(shortPrimarySymbol.toUpperCase()) : true;
+    let isSingleSided = false;
+    let activeSide = null;
+    let activeTokenSymbol;
+    if (longTokens.length > 0 && !longIsStable && (shortTokens.length === 0 || shortIsStable)) {
+      isSingleSided = true;
+      activeSide = "long";
+      activeTokenSymbol = longPrimarySymbol ?? void 0;
+    } else if (shortTokens.length > 0 && !shortIsStable && (longTokens.length === 0 || longIsStable)) {
+      isSingleSided = true;
+      activeSide = "short";
+      activeTokenSymbol = shortPrimarySymbol ?? void 0;
+    }
+    const longLabel = longTokens.map((token) => token.symbol).join("+") || "USDC";
+    const shortLabel = shortTokens.map((token) => token.symbol).join("+") || "USDC";
+    const pairLabel = `${longLabel}/${shortLabel}`;
+    return {
+      longTokens,
+      shortTokens,
+      isSingleSided,
+      activeSide,
+      activeTokenSymbol,
+      pairLabel,
+      selectedSymbols: uniqueSelectedSymbols
     };
+  }, [
+    explicitLongTokens,
+    explicitShortTokens,
+    longSymbol,
+    shortSymbol,
+    longWeight,
+    shortWeight
+  ]);
+}
+
+// src/utils/chart-metrics.ts
+function getPositiveValue(metadata, field) {
+  const value = metadata?.[field];
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return null;
   }
-  handleMessage(data) {
-    if (data.e === "kline") {
-      const k = data.k;
-      const streamName = `${data.s.toLowerCase()}@kline_${k.i}`;
-      this.dispatchToStream(streamName, data);
-    } else if (data.e === "markPriceUpdate") {
-      const streamName = `${data.s.toLowerCase()}@markPrice@1s`;
-      this.dispatchToStream(streamName, data);
+  return value;
+}
+function computeWeightedProduct(tokens, metadataMap, field, invert = false) {
+  let product = 1;
+  let hasToken = false;
+  for (const token of tokens) {
+    if (!(token.weight > 0)) {
+      continue;
     }
-  }
-  dispatchToStream(streamName, data) {
-    const sub = this.streams.get(streamName);
-    if (!sub) return;
-    sub.callbacks.forEach((cb) => {
-      try {
-        cb(data);
-      } catch {
-      }
-    });
-  }
-  sendSubscribe(streams) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.pendingSubscribes.push(...streams);
-      return;
+    const price = getPositiveValue(metadataMap[token.symbol], field);
+    if (price === null) {
+      return null;
     }
-    this.ws.send(JSON.stringify({
-      method: "SUBSCRIBE",
-      params: streams,
-      id: Date.now()
-    }));
+    hasToken = true;
+    const exponent = invert ? -(token.weight / 100) : token.weight / 100;
+    product *= Math.pow(price, exponent);
   }
-  sendUnsubscribe(streams) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.pendingSubscribes = this.pendingSubscribes.filter(
-        (s) => !streams.includes(s)
-      );
-      return;
-    }
-    this.ws.send(JSON.stringify({
-      method: "UNSUBSCRIBE",
-      params: streams,
-      id: Date.now()
-    }));
+  return hasToken ? product : 1;
+}
+function computePriceRatio({
+  longTokens,
+  shortTokens,
+  longTokensMetadata,
+  shortTokensMetadata
+}) {
+  const firstLong = longTokens[0];
+  const firstShort = shortTokens[0];
+  const longPrice = firstLong ? getPositiveValue(longTokensMetadata[firstLong.symbol], "currentPrice") : null;
+  const shortPrice = firstShort ? getPositiveValue(shortTokensMetadata[firstShort.symbol], "currentPrice") : null;
+  if (longPrice !== null && shortPrice !== null) {
+    return longPrice / shortPrice;
   }
-  scheduleReconnect() {
-    if (this.reconnectTimer) return;
-    if (this.streams.size === 0) return;
-    const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)];
-    this.reconnectAttempt++;
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.connect();
-    }, delay);
+  if (longPrice !== null && shortTokens.length === 0) {
+    return longPrice;
   }
-};
-var _instance = null;
-function getBinanceWsManager() {
-  if (!_instance) {
-    _instance = new BinanceWsManager();
+  if (shortPrice !== null && longTokens.length === 0) {
+    return shortPrice;
   }
-  return _instance;
+  return null;
 }
-
-// src/react/stores/use-binance-mark-price-store.ts
-var refCounts = /* @__PURE__ */ new Map();
-var streamUnsubs = /* @__PURE__ */ new Map();
-var streamSymbols = /* @__PURE__ */ new Map();
-function normalizeBinanceSymbol(symbol) {
-  return symbol.toUpperCase().trim();
+function computePriceRatio24h({
+  longTokens,
+  shortTokens,
+  longTokensMetadata,
+  shortTokensMetadata
+}) {
+  const firstLong = longTokens[0];
+  const firstShort = shortTokens[0];
+  const longPrice = firstLong ? getPositiveValue(longTokensMetadata[firstLong.symbol], "prevDayPrice") : null;
+  const shortPrice = firstShort ? getPositiveValue(shortTokensMetadata[firstShort.symbol], "prevDayPrice") : null;
+  if (longPrice !== null && shortPrice !== null) {
+    return longPrice / shortPrice;
+  }
+  if (longPrice !== null && shortTokens.length === 0) {
+    return longPrice;
+  }
+  if (shortPrice !== null && longTokens.length === 0) {
+    return shortPrice;
+  }
+  return null;
 }
-function getNextRefCount(binanceSymbol) {
-  return (refCounts.get(binanceSymbol) ?? 0) + 1;
+function computeWeightedRatio({
+  longTokens,
+  shortTokens,
+  longTokensMetadata,
+  shortTokensMetadata
+}) {
+  const longProduct = computeWeightedProduct(
+    longTokens,
+    longTokensMetadata,
+    "currentPrice"
+  );
+  const shortProduct = computeWeightedProduct(
+    shortTokens,
+    shortTokensMetadata,
+    "currentPrice",
+    true
+  );
+  if (longProduct === null || shortProduct === null) {
+    return null;
+  }
+  return longProduct * shortProduct;
 }
-function getPrevRefCount(binanceSymbol) {
-  return Math.max(0, (refCounts.get(binanceSymbol) ?? 0) - 1);
+function computeWeightedRatio24h({
+  longTokens,
+  shortTokens,
+  longTokensMetadata,
+  shortTokensMetadata
+}) {
+  const longProduct = computeWeightedProduct(
+    longTokens,
+    longTokensMetadata,
+    "prevDayPrice"
+  );
+  const shortProduct = computeWeightedProduct(
+    shortTokens,
+    shortTokensMetadata,
+    "prevDayPrice",
+    true
+  );
+  if (longProduct === null || shortProduct === null) {
+    return null;
+  }
+  return longProduct * shortProduct;
 }
-var useBinanceMarkPriceStore = zustand.create((set) => ({
-  markPrices: {},
-  subscribeSymbol: (symmSymbol, rawBinanceSymbol) => {
-    const binanceSymbol = normalizeBinanceSymbol(rawBinanceSymbol);
-    const nextRefCount = getNextRefCount(binanceSymbol);
-    refCounts.set(binanceSymbol, nextRefCount);
-    const symbols = streamSymbols.get(binanceSymbol) ?? /* @__PURE__ */ new Set();
-    symbols.add(symmSymbol);
-    streamSymbols.set(binanceSymbol, symbols);
-    if (nextRefCount === 1) {
-      const wsManager = getBinanceWsManager();
-      const unsubscribe = wsManager.subscribeMarkPrice(binanceSymbol, (data) => {
-        const canonicalSymbol = normalizeBinanceSymbol(data.symbol);
-        const mappedSymbols = streamSymbols.get(canonicalSymbol);
-        if (!mappedSymbols || mappedSymbols.size === 0) return;
-        set((state) => {
-          const nextMarkPrices = { ...state.markPrices };
-          mappedSymbols.forEach((mappedSymbol) => {
-            nextMarkPrices[mappedSymbol] = data.markPrice;
-          });
-          return { markPrices: nextMarkPrices };
-        });
-      });
-      streamUnsubs.set(binanceSymbol, unsubscribe);
-    }
-  },
-  unsubscribeSymbol: (symmSymbol, rawBinanceSymbol) => {
-    const binanceSymbol = normalizeBinanceSymbol(rawBinanceSymbol);
-    const symbols = streamSymbols.get(binanceSymbol);
-    if (symbols) {
-      symbols.delete(symmSymbol);
-      if (symbols.size === 0) {
-        streamSymbols.delete(binanceSymbol);
-      } else {
-        streamSymbols.set(binanceSymbol, symbols);
-      }
+function computeNetFundingSum({
+  longTokens,
+  shortTokens,
+  longTokensMetadata,
+  shortTokensMetadata
+}) {
+  let funding = 0;
+  for (const token of longTokens) {
+    const value = longTokensMetadata[token.symbol]?.netFunding;
+    if (typeof value === "number" && Number.isFinite(value)) {
+      funding += value;
     }
-    const nextRefCount = getPrevRefCount(binanceSymbol);
-    if (nextRefCount === 0) {
-      const unsubscribe = streamUnsubs.get(binanceSymbol);
-      if (unsubscribe) unsubscribe();
-      streamUnsubs.delete(binanceSymbol);
-      refCounts.delete(binanceSymbol);
-    } else {
-      refCounts.set(binanceSymbol, nextRefCount);
+  }
+  for (const token of shortTokens) {
+    const value = shortTokensMetadata[token.symbol]?.netFunding;
+    if (typeof value === "number" && Number.isFinite(value)) {
+      funding += value;
     }
-    set((state) => {
-      if (state.markPrices[symmSymbol] == null) return state;
-      const nextMarkPrices = { ...state.markPrices };
-      delete nextMarkPrices[symmSymbol];
-      return { markPrices: nextMarkPrices };
-    });
   }
-}));
+  return funding;
+}
 
 // src/react/hooks/use-symm-token-selection-metadata.ts
-async function fetchTickerSnapshot(symbol) {
+async function fetchTickerSnapshot2(symbol) {
   const resolution = resolveBinanceSymbol(symbol);
   if (!resolution.binanceSymbol) return null;
   const ticker = await fetch24hrTicker(resolution.binanceSymbol);
@@ -25924,7 +26029,7 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
       const results = await Promise.all(
         allSymbols.map(async ({ symbol }) => ({
           symbol,
-          ticker: await fetchTickerSnapshot(symbol)
+          ticker: await fetchTickerSnapshot2(symbol)
         }))
       );
       const tickerSnapshots = {};
@@ -26456,6 +26561,7 @@ exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;
 exports.useSymmSignTermsMutation = useSymmSignTermsMutation;
 exports.useSymmSignatureQuery = useSymmSignatureQuery;
+exports.useSymmTokenSelectionMarkets = useSymmTokenSelectionMarkets;
 exports.useSymmTokenSelectionMetadata = useSymmTokenSelectionMetadata;
 exports.useSymmTpslOrders = useSymmTpslOrders;
 exports.useSymmTradeHistory = useSymmTradeHistory;