@pear-protocol/symmio-client 0.2.47 → 0.3.0

package/dist/react/index.js

@@ -707,6 +707,17 @@ async function fetchAccessTokenEntry(walletClient, signerAddress, accountAddress
 // src/react/query-keys.ts
 var symmKeys = {
   all: ["symm"],
+  balancesRoot: ["symm", "balances"],
+  accountSummaryRoot: ["symm", "accountSummary"],
+  accountDataRoot: ["symm", "accountData"],
+  approvalRoot: ["symm", "approval"],
+  positionsRoot: ["symm", "positions"],
+  openOrdersRoot: ["symm", "openOrders"],
+  tradeHistoryRoot: ["symm", "tradeHistory"],
+  portfolioRoot: ["symm", "portfolio"],
+  tpslOrdersRoot: ["symm", "tpslOrders"],
+  twapOrdersRoot: ["symm", "twapOrders"],
+  triggerOrdersRoot: ["symm", "triggerOrders"],
   accounts: (address, chainId) => ["symm", "accounts", address, chainId],
   accountsApi: (address, chainId) => ["symm", "accountsApi", address, chainId],
   accountsLength: (address, chainId) => ["symm", "accountsLength", address, chainId],
@@ -714,7 +725,7 @@ var symmKeys = {
   accountSummary: (address, chainId) => ["symm", "accountSummary", address, chainId],
   accountData: (address, chainId, upnl) => ["symm", "accountData", address, chainId, upnl],
   signature: (address, chainId) => ["symm", "signature", address, chainId],
-  auth: (accountAddress, chainId) => ["symm", "auth", accountAddress, chainId],
+  auth: (accountAddress, chainId, signerAddress) => ["symm", "auth", accountAddress, chainId, signerAddress],
   approval: (owner, spender, chainId, token) => ["symm", "approval", owner, spender, chainId, token],
   balances: (address, chainId) => ["symm", "balances", address, chainId],
   positions: (params) => ["symm", "positions", params],
@@ -734,8 +745,8 @@ var symmKeys = {
   fundingPayments: (params) => ["symm", "fundingPayments", params],
   fundingHistory: (params) => ["symm", "fundingHistory", params],
   portfolio: (params) => ["symm", "portfolio", params],
-  notifications: (address, chainId) => ["symm", "notifications", address, chainId],
-  unreadCount: (address, chainId) => ["symm", "unreadCount", address, chainId],
+  notifications: (params) => ["symm", "notifications", params],
+  unreadCount: (params) => ["symm", "unreadCount", params],
   availableMargin: (address, chainId) => ["symm", "availableMargin", address, chainId],
   pendingIds: (address, chainId) => ["symm", "pendingIds", address, chainId],
   pendingInstantOpens: (accountAddress, chainId) => ["symm", "pendingInstantOpens", accountAddress, chainId],
@@ -745,23 +756,25 @@ var symmKeys = {
 };
 
 // src/react/auth-cache.ts
-function getAuthQueryData(queryClient, accountAddress, chainId) {
-  return queryClient.getQueryData(symmKeys.auth(accountAddress, chainId)) ?? null;
+function getAuthQueryData(queryClient, accountAddress, chainId, signerAddress) {
+  return queryClient.getQueryData(
+    symmKeys.auth(accountAddress, chainId, signerAddress)
+  ) ?? null;
 }
-function setAuthQueryData(queryClient, accountAddress, chainId, entry) {
-  queryClient.setQueryData(symmKeys.auth(accountAddress, chainId), entry);
+function setAuthQueryData(queryClient, accountAddress, chainId, signerAddress, entry) {
+  queryClient.setQueryData(symmKeys.auth(accountAddress, chainId, signerAddress), entry);
 }
-function clearAuthQueryData(queryClient, accountAddress, chainId) {
+function clearAuthQueryData(queryClient, accountAddress, chainId, signerAddress) {
   queryClient.removeQueries({
-    queryKey: symmKeys.auth(accountAddress, chainId),
+    queryKey: symmKeys.auth(accountAddress, chainId, signerAddress),
     exact: true
   });
 }
 function clearPersistedAuthState(accountAddress, chainId) {
   clearCachedToken(accountAddress, chainId);
 }
-function getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId) {
-  const inQuery = getAuthQueryData(queryClient, accountAddress, chainId);
+function getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId, signerAddress) {
+  const inQuery = getAuthQueryData(queryClient, accountAddress, chainId, signerAddress) ?? getAuthQueryData(queryClient, accountAddress, chainId);
   if (inQuery && inQuery.expiresAt > Date.now()) {
     return inQuery.token;
   }
@@ -769,7 +782,7 @@ function getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId) {
   if (!persisted) {
     return null;
   }
-  setAuthQueryData(queryClient, accountAddress, chainId, persisted);
+  setAuthQueryData(queryClient, accountAddress, chainId, signerAddress, persisted);
   return persisted.token;
 }
 async function resolveAuthTokenEntry({
@@ -785,13 +798,13 @@ async function resolveAuthTokenEntry({
     return null;
   }
   if (!force) {
-    const inQuery = getAuthQueryData(queryClient, accountAddress, chainId);
+    const inQuery = getAuthQueryData(queryClient, accountAddress, chainId, signerAddress);
     if (inQuery && inQuery.expiresAt > Date.now()) {
       return inQuery;
     }
     const persisted = getCachedTokenEntry(accountAddress, chainId);
     if (persisted) {
-      setAuthQueryData(queryClient, accountAddress, chainId, persisted);
+      setAuthQueryData(queryClient, accountAddress, chainId, signerAddress, persisted);
       return persisted;
     }
   }
@@ -802,12 +815,12 @@ async function resolveAuthTokenEntry({
     chainId,
     siweDomain
   );
-  setAuthQueryData(queryClient, accountAddress, chainId, fresh);
+  setAuthQueryData(queryClient, accountAddress, chainId, signerAddress, fresh);
   return fresh;
 }
-function clearAuthState(queryClient, accountAddress, chainId) {
+function clearAuthState(queryClient, accountAddress, chainId, signerAddress) {
   clearPersistedAuthState(accountAddress, chainId);
-  clearAuthQueryData(queryClient, accountAddress, chainId);
+  clearAuthQueryData(queryClient, accountAddress, chainId, signerAddress);
 }
 
 // src/react/hooks/use-symm-auth.ts
@@ -881,7 +894,7 @@ function useSymmAuth(params) {
     ]
   );
   const authQuery = reactQuery.useQuery({
-    queryKey: symmKeys.auth(activeAccountAddress, chainId),
+    queryKey: symmKeys.auth(activeAccountAddress, chainId, address),
     queryFn: async () => {
       const tokenEntry = await resolveAuthTokenEntry({
         queryClient,
@@ -903,9 +916,9 @@ function useSymmAuth(params) {
   });
   const clearAuth = react.useCallback(() => {
     if (activeAccountAddress) {
-      clearAuthState(queryClient, activeAccountAddress, chainId);
+      clearAuthState(queryClient, activeAccountAddress, chainId, address);
     }
-  }, [activeAccountAddress, chainId, queryClient]);
+  }, [activeAccountAddress, address, chainId, queryClient]);
   const token = authQuery.data?.token ?? null;
   return {
     accessToken: token,
@@ -1670,22 +1683,22 @@ function useSymmRevokeDelegationMutation(params = {}, options) {
 
 // src/react/cache.ts
 function invalidateBalances(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "balances"] });
-  qc.invalidateQueries({ queryKey: ["symm", "accountSummary"] });
-  qc.invalidateQueries({ queryKey: ["symm", "accountData"] });
-  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
+  qc.invalidateQueries({ queryKey: symmKeys.balancesRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.accountSummaryRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.accountDataRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.portfolioRoot });
 }
 function invalidatePositions(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "positions"] });
-  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "tradeHistory"] });
-  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
+  qc.invalidateQueries({ queryKey: symmKeys.positionsRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.openOrdersRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.tradeHistoryRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.portfolioRoot });
 }
 function invalidateOrders(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
+  qc.invalidateQueries({ queryKey: symmKeys.openOrdersRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.tpslOrdersRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.twapOrdersRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.triggerOrdersRoot });
 }
 
 // src/react/hooks/use-symm-instant-trade.ts
@@ -1702,12 +1715,13 @@ function useInstantTradeDeps(params) {
     defaultTarget,
     multiAccount,
     publicClient: params.publicClient,
+    signerAddress: address,
     symmCoreClient,
     walletClient: params.walletClient
   };
 }
 async function ensureInstantTradeReady(deps, queryClient, request) {
-  const { chainId, defaultAccountAddress, defaultSelectors, defaultTarget, multiAccount, publicClient, walletClient } = deps;
+  const { chainId, defaultAccountAddress, defaultSelectors, defaultTarget, multiAccount, publicClient, signerAddress, walletClient } = deps;
   if (!publicClient || !walletClient) throw new Error("Clients not available");
   const accountAddress = request?.accountAddress ?? defaultAccountAddress;
   const target = request?.target ?? defaultTarget;
@@ -1717,7 +1731,12 @@ async function ensureInstantTradeReady(deps, queryClient, request) {
   if (selectors.length === 0) {
     throw new Error("at least one delegation selector is required");
   }
-  const accessToken = getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId);
+  const accessToken = getAuthTokenFromRuntimeCache(
+    queryClient,
+    accountAddress,
+    chainId,
+    signerAddress
+  );
   if (!accessToken) {
     throw new Error("auth token is required for instant trading");
   }
@@ -2130,7 +2149,12 @@ function useSymmCancelClose(options) {
       }
       const resolvedAccountAddress = accountAddress ?? address;
       const resolvedChainId = overrideChainId ?? chainId;
-      const resolvedAuthToken = authToken ?? (resolvedAccountAddress ? getAuthTokenFromRuntimeCache(queryClient, resolvedAccountAddress, resolvedChainId) : null);
+      const resolvedAuthToken = authToken ?? (resolvedAccountAddress ? getAuthTokenFromRuntimeCache(
+        queryClient,
+        resolvedAccountAddress,
+        resolvedChainId,
+        address
+      ) : null);
       if (!resolvedAuthToken) {
         throw new Error("auth token is required to cancel a pending close");
       }
@@ -2161,7 +2185,12 @@ function useSymmCloseOrder(options) {
       return symmCoreClient.orders.close(request.id, {
         kind: request.kind,
         type: request.type,
-        authToken: request.authToken ?? (resolvedAccountAddress ? getAuthTokenFromRuntimeCache(queryClient, resolvedAccountAddress, chainId) ?? void 0 : void 0)
+        authToken: request.authToken ?? (resolvedAccountAddress ? getAuthTokenFromRuntimeCache(
+          queryClient,
+          resolvedAccountAddress,
+          chainId,
+          address
+        ) ?? void 0 : void 0)
       });
     }
   });
@@ -2234,7 +2263,7 @@ function useSymmDepositMutation(params = {}, options) {
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
         invalidateBalances(queryClient);
-        queryClient.invalidateQueries({ queryKey: ["symm", "approval"] });
+        queryClient.invalidateQueries({ queryKey: symmKeys.approvalRoot });
       }
     }),
     mutationFn: async ({
@@ -2253,7 +2282,7 @@ function useSymmDepositAndAllocateMutation(params = {}, options) {
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
         invalidateBalances(queryClient);
-        queryClient.invalidateQueries({ queryKey: ["symm", "approval"] });
+        queryClient.invalidateQueries({ queryKey: symmKeys.approvalRoot });
       }
     }),
     mutationFn: async ({
@@ -25310,7 +25339,8 @@ function useResolveTradeAuthToken(params = {}) {
       const inMemoryToken = getAuthTokenFromRuntimeCache(
         queryClient,
         resolvedAccountAddress,
-        chainId
+        chainId,
+        address
       );
       if (inMemoryToken) {
         logTradeAuth("resolve-auth:store-hit", {
@@ -25446,13 +25476,14 @@ function useSymmUpdatePositionMutation(paramsOrOptions, maybeOptions) {
         typedRequest.authToken,
         typedRequest.accountAddress
       );
-      if (!authToken) {
-        throw new Error("auth token is required to update a position");
-      }
-      return symmCoreClient.positions.update(positionId, {
+      const requestWithOptionalAuth = authToken ? {
         ...request,
         authToken
-      });
+      } : request;
+      return symmCoreClient.positions.update(
+        positionId,
+        requestWithOptionalAuth
+      );
     }
   });
 }
@@ -25828,9 +25859,10 @@ async function fetch24hrTickers() {
 }
 
 // src/react/hooks/use-symm-token-selection-markets.ts
+var EMPTY_MARKETS = [];
 function useSymmTokenSelectionMarkets(params) {
   const query = useSymmHedgerMarkets(params);
-  const baseMarkets = query.data?.filteredMarkets ?? query.data?.markets ?? [];
+  const baseMarkets = query.data?.filteredMarkets ?? query.data?.markets ?? EMPTY_MARKETS;
   const marketSymbols = react.useMemo(
     () => Array.from(
       new Set(
@@ -26009,61 +26041,81 @@ function useSymmPortfolio(params) {
 function useResolvedNotificationsParams(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params.chainId ?? ctxChainId;
+  const accountAddress = params.accountAddress;
+  const address = accountAddress ? void 0 : params.address;
   return {
     symmCoreClient,
     chainId,
-    userAddress: params.userAddress,
+    accountAddress,
+    address,
     query: params.query
   };
 }
 function useSymmNotificationsQuery(params) {
-  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
-  const internalEnabled = !!symmCoreClient && !!userAddress;
+  const { symmCoreClient, chainId, accountAddress, address, query } = useResolvedNotificationsParams(params);
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || address);
+  const queryParams = {
+    accountAddress,
+    address,
+    chainId
+  };
   return reactQuery.useQuery({
     ...query,
-    queryKey: symmKeys.notifications(userAddress, chainId),
+    queryKey: symmKeys.notifications(queryParams),
     queryFn: () => symmCoreClient.notifications.list({
-      userAddress,
+      accountAddress,
+      address,
       chainId
     }),
     enabled: internalEnabled && (query?.enabled ?? true)
   });
 }
 function useSymmUnreadCountQuery(params) {
-  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
-  const internalEnabled = !!symmCoreClient && !!userAddress;
+  const { symmCoreClient, chainId, accountAddress, address, query } = useResolvedNotificationsParams(params);
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || address);
+  const queryParams = {
+    accountAddress,
+    address,
+    chainId
+  };
   return reactQuery.useQuery({
     ...query,
-    queryKey: symmKeys.unreadCount(userAddress, chainId),
+    queryKey: symmKeys.unreadCount(queryParams),
     queryFn: () => symmCoreClient.notifications.getUnreadCount({
-      userAddress,
+      accountAddress,
+      address,
       chainId
     }),
     enabled: internalEnabled && (query?.enabled ?? true)
   });
 }
 function useSymmMarkReadNotificationMutation(params, options) {
-  const { symmCoreClient, chainId, userAddress } = useResolvedNotificationsParams(params);
+  const { symmCoreClient, chainId, accountAddress, address } = useResolvedNotificationsParams(params);
   const queryClient = reactQuery.useQueryClient();
+  const queryParams = {
+    accountAddress,
+    address,
+    chainId
+  };
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
         queryClient.invalidateQueries({
-          queryKey: symmKeys.notifications(userAddress, chainId)
+          queryKey: symmKeys.notifications(queryParams)
         });
         queryClient.invalidateQueries({
-          queryKey: symmKeys.unreadCount(userAddress, chainId)
+          queryKey: symmKeys.unreadCount(queryParams)
         });
       }
     }),
     mutationFn: async ({ id, timestamp }) => {
-      if (!symmCoreClient || !userAddress) {
+      if (!symmCoreClient || !accountAddress) {
         throw new Error("symm-core client not available");
       }
       return symmCoreClient.notifications.markRead({
         id,
         timestamp,
-        userAddress,
+        accountAddress,
         chainId
       });
     }
@@ -26087,7 +26139,8 @@ function useSymmPendingIds(params) {
 function useSymmPendingInstantOpens(params) {
   const {
     symmCoreClient,
-    chainId: ctxChainId
+    chainId: ctxChainId,
+    address
   } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
   const { accountAddress, authToken: providedAuthToken } = params;
@@ -26097,7 +26150,12 @@ function useSymmPendingInstantOpens(params) {
     ...params.query,
     queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
     queryFn: async () => {
-      const authToken = providedAuthToken ?? getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId);
+      const authToken = providedAuthToken ?? getAuthTokenFromRuntimeCache(
+        queryClient,
+        accountAddress,
+        chainId,
+        address
+      );
       if (!authToken) {
         throw new Error("failed to acquire auth token for pending instant opens");
       }
@@ -26121,122 +26179,6 @@ function useSymmTwapOrder(params) {
     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 {
@@ -26466,7 +26408,10 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
   );
   const isUnsupported = unsupportedSymbols.length > 0;
   const unavailableReason = isUnsupported ? `Binance market data is unavailable for ${unsupportedSymbols.join(", ")}.` : null;
-  const symbolsKey = [...selectedSymbols].sort().join(",");
+  const symbolsKey = react.useMemo(
+    () => [...selectedSymbols].sort().join(","),
+    [selectedSymbols]
+  );
   const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
   const liveFundingRates = useBinanceMarkPriceStore(
     (state) => state.fundingRates
@@ -26563,7 +26508,6 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
   }, [
     isUnsupported,
     longTokens,
-    query,
     query.data,
     query.isLoading,
     shortTokens,
@@ -26977,6 +26921,10 @@ function getSymmErrorMessage(error) {
   if (error instanceof Error) return error.message;
   return "An unexpected error occurred.";
 }
+var useSymmWsStore = zustand.create((set) => ({
+  isConnected: false,
+  setConnected: (isConnected) => set({ isConnected })
+}));
 
 exports.SymmProvider = SymmProvider;
 exports.getSymmErrorMessage = getSymmErrorMessage;
@@ -27051,7 +26999,6 @@ exports.useSymmTwapOrdersQuery = useSymmTwapOrdersQuery;
 exports.useSymmUnreadCountQuery = useSymmUnreadCountQuery;
 exports.useSymmUpdatePositionMutation = useSymmUpdatePositionMutation;
 exports.useSymmWithdraw = useSymmWithdraw;
-exports.useSymmWs = useSymmWs;
 exports.useSymmWsStore = useSymmWsStore;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map