@pear-protocol/symmio-client 0.2.6 → 0.2.8

package/dist/react/index.mjs

@@ -1,7 +1,8 @@
 'use client';
-import { createContext, useContext, useState, useEffect, useMemo, useRef, useCallback } from 'react';
+import { createContext, useContext, useEffect, useMemo, useRef, useCallback } from 'react';
 import { createSymmSDK, isAuthExpiredError, isNetworkError, isInsufficientMarginError, isRateLimitedError, isTimeoutError } from '@pear-protocol/symm-core';
 import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
+import { create } from 'zustand';
 import { jsx } from 'react/jsx-runtime';
 import { isAddress, encodeFunctionData } from 'viem';
 
@@ -52,6 +53,10 @@ var symmKeys = {
   delegation: (account, target, selectors, chainId) => ["symm", "delegation", account, target, selectors, chainId],
   chartMetadata: (symbolsKey, positionKey) => ["symm", "chartMetadata", symbolsKey, positionKey]
 };
+var useSymmWsStore = create((set) => ({
+  isConnected: false,
+  setConnected: (isConnected) => set({ isConnected })
+}));
 
 // src/react/hooks/use-symm-ws.ts
 function asUnsubscribeFn(value) {
@@ -59,18 +64,19 @@ function asUnsubscribeFn(value) {
 }
 function useSymmWs(params) {
   const queryClient = useQueryClient();
+  const isConnected = useSymmWsStore((state) => state.isConnected);
+  const setConnected = useSymmWsStore((state) => state.setConnected);
   const { symmCoreClient, accountAddress, chainId } = params;
-  const [isConnected, setIsConnected] = useState(false);
   useEffect(() => {
     if (!symmCoreClient || !accountAddress) {
-      setIsConnected(false);
+      setConnected(false);
       return;
     }
     const ws = symmCoreClient.ws;
     const addr = accountAddress;
     const unsubscribers = [];
-    const removeOnConnect = ws.onConnect(() => setIsConnected(true));
-    const removeOnDisconnect = ws.onDisconnect(() => setIsConnected(false));
+    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({
@@ -141,7 +147,7 @@ function useSymmWs(params) {
         ws.unsubscribeAll();
       }
     };
-  }, [symmCoreClient, accountAddress, chainId, queryClient]);
+  }, [symmCoreClient, accountAddress, chainId, queryClient, setConnected]);
   return { isConnected };
 }
 var noopRefreshAuth = async () => null;
@@ -369,20 +375,60 @@ async function fetchAccessToken(walletClient, signerAddress, accountAddress, cha
   writeStoredToken(accountAddress, chainId, cachedToken);
   return accessToken;
 }
+function symmAuthTokenKey(address, chainId) {
+  return `${address.toLowerCase()}:${chainId}`;
+}
+var useSymmAuthStore = create((set, get) => ({
+  tokensByKey: {},
+  setToken: (address, chainId, token) => {
+    const key = symmAuthTokenKey(address, chainId);
+    set((state) => ({
+      tokensByKey: {
+        ...state.tokensByKey,
+        [key]: token
+      }
+    }));
+  },
+  getToken: (address, chainId) => {
+    const key = symmAuthTokenKey(address, chainId);
+    return get().tokensByKey[key] ?? null;
+  },
+  clearToken: (address, chainId) => {
+    const key = symmAuthTokenKey(address, chainId);
+    set((state) => {
+      if (!(key in state.tokensByKey)) return state;
+      const next = { ...state.tokensByKey };
+      delete next[key];
+      return { tokensByKey: next };
+    });
+  },
+  clearAll: () => {
+    set({ tokensByKey: {} });
+  }
+}));
 
 // src/react/hooks/use-symm-auth.ts
 function useSymmAuth(params) {
   const { address, chainId, walletClient, siweDomain } = params;
-  const [accessToken, setAccessToken] = useState(null);
+  const accessToken = useSymmAuthStore(
+    (state) => address ? state.tokensByKey[symmAuthTokenKey(address, chainId)] ?? null : null
+  );
+  const setToken = useSymmAuthStore((state) => state.setToken);
+  const getToken = useSymmAuthStore((state) => state.getToken);
+  const clearToken = useSymmAuthStore((state) => state.clearToken);
   const previousAddressRef = useRef(address);
   const previousChainIdRef = useRef(chainId);
   const refreshAuth = useCallback(
     async (accountAddress) => {
       if (!walletClient || !address) return null;
       const resolvedAccountAddress = accountAddress ?? address;
+      const inMemory = getToken(resolvedAccountAddress, chainId);
+      if (inMemory) {
+        return inMemory;
+      }
       const cached = getCachedToken(resolvedAccountAddress, chainId);
       if (cached) {
-        setAccessToken(cached);
+        setToken(resolvedAccountAddress, chainId, cached);
         return cached;
       }
       try {
@@ -393,21 +439,21 @@ function useSymmAuth(params) {
           chainId,
           siweDomain
         );
-        setAccessToken(token);
+        setToken(resolvedAccountAddress, chainId, token);
         return token;
       } catch {
-        setAccessToken(null);
+        clearToken(resolvedAccountAddress, chainId);
         return null;
       }
     },
-    [walletClient, address, chainId, siweDomain]
+    [walletClient, address, chainId, siweDomain, getToken, setToken, clearToken]
   );
   const clearAuth = useCallback(() => {
     if (address) {
       clearCachedToken(address, chainId);
+      clearToken(address, chainId);
     }
-    setAccessToken(null);
-  }, [address, chainId]);
+  }, [address, chainId, clearToken]);
   useEffect(() => {
     const previousAddress = previousAddressRef.current;
     const previousChainId = previousChainIdRef.current;
@@ -416,15 +462,19 @@ function useSymmAuth(params) {
     previousAddressRef.current = address;
     previousChainIdRef.current = chainId;
     if (!address || !walletClient) {
-      setAccessToken(null);
       return;
     }
     if (previousAddress && (addressChanged || chainChanged)) {
       clearCachedToken(previousAddress, previousChainId);
+      clearToken(previousAddress, previousChainId);
     }
     const cached = getCachedToken(address, chainId);
-    setAccessToken(cached);
-  }, [address, walletClient, chainId]);
+    if (cached) {
+      setToken(address, chainId, cached);
+    } else {
+      clearToken(address, chainId);
+    }
+  }, [address, walletClient, chainId, setToken, clearToken]);
   return {
     accessToken,
     authToken: accessToken,
@@ -1038,7 +1088,7 @@ function useSymmInstantTrade(params) {
       if (selectors.length === 0) {
         throw new Error("at least one delegation selector is required");
       }
-      const accessToken = await refreshAuth(accountAddress);
+      const accessToken = useSymmAuthStore.getState().getToken(accountAddress, chainId) ?? await refreshAuth(accountAddress);
       if (!accessToken) {
         throw new Error("failed to refresh instant-trading auth");
       }
@@ -1437,7 +1487,7 @@ function useSymmCancelClose() {
       if (!symmCoreClient) {
         throw new Error("symm-core client not available");
       }
-      const resolvedAuthToken = authToken ?? ctxAuthToken ?? (accountAddress ? await refreshAuth(accountAddress) : null);
+      const resolvedAuthToken = authToken ?? (accountAddress ? useSymmAuthStore.getState().getToken(accountAddress, chainId) : null) ?? ctxAuthToken ?? (accountAddress ? await refreshAuth(accountAddress) : null);
       if (!resolvedAuthToken) {
         throw new Error("auth token is required to cancel a pending close");
       }
@@ -25198,7 +25248,7 @@ function useSymmPendingInstantOpens(params) {
     ...params.query,
     queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
     queryFn: async () => {
-      const authToken = providedAuthToken ?? ctxAuthToken ?? await refreshAuth(accountAddress);
+      const authToken = providedAuthToken ?? useSymmAuthStore.getState().getToken(accountAddress, chainId) ?? ctxAuthToken ?? await refreshAuth(accountAddress);
       if (!authToken) {
         throw new Error("failed to acquire auth token for pending instant opens");
       }
@@ -25710,6 +25760,74 @@ function getBinanceWsManager() {
   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 = 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);
+      }
+    }
+    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 };
+    });
+  }
+}));
+
 // src/react/hooks/use-symm-token-selection-metadata.ts
 async function fetchTickerSnapshot(symbol) {
   const resolution = resolveBinanceSymbol(symbol);
@@ -25751,9 +25869,9 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
     ),
     [selectedSymbols]
   );
-  const [liveMarkPrices, setLiveMarkPrices] = useState(
-    {}
-  );
+  const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
+  const subscribeSymbol = useBinanceMarkPriceStore((state) => state.subscribeSymbol);
+  const unsubscribeSymbol = useBinanceMarkPriceStore((state) => state.unsubscribeSymbol);
   const query = useQuery({
     queryKey: ["symm", "chart-metadata", symbolsKey],
     queryFn: async () => {
@@ -25781,36 +25899,25 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
   });
   useEffect(() => {
     if (!enabled || isUnsupported || selectedSymbols.length === 0) {
-      setLiveMarkPrices({});
       return;
     }
-    setLiveMarkPrices((current) => {
-      const next = {};
-      for (const symbol of selectedSymbols) {
-        if (current[symbol] != null) {
-          next[symbol] = current[symbol];
-        }
-      }
-      return next;
-    });
-    const wsManager = getBinanceWsManager();
-    const unsubscribes = Array.from(symbolToBinanceMap.entries()).map(
-      ([symbol, binanceSymbol]) => wsManager.subscribeMarkPrice(binanceSymbol, (data) => {
-        setLiveMarkPrices((current) => {
-          if (current[symbol] === data.markPrice) return current;
-          return {
-            ...current,
-            [symbol]: data.markPrice
-          };
-        });
-      })
+    const symbolEntries = Array.from(symbolToBinanceMap.entries());
+    symbolEntries.forEach(
+      ([symbol, binanceSymbol]) => subscribeSymbol(symbol, binanceSymbol)
     );
     return () => {
-      for (const unsubscribe of unsubscribes) {
-        unsubscribe();
-      }
+      symbolEntries.forEach(
+        ([symbol, binanceSymbol]) => unsubscribeSymbol(symbol, binanceSymbol)
+      );
     };
-  }, [enabled, isUnsupported, selectedSymbols, symbolToBinanceMap]);
+  }, [
+    enabled,
+    isUnsupported,
+    selectedSymbols.length,
+    symbolToBinanceMap,
+    subscribeSymbol,
+    unsubscribeSymbol
+  ]);
   return useMemo(() => {
     const tickerSnapshots = query.data?.tickerSnapshots ?? {};
     const longMeta = {};
@@ -26250,6 +26357,6 @@ function getSymmErrorMessage(error) {
   return "An unexpected error occurred.";
 }
 
-export { SymmProvider, getSymmErrorMessage, symmKeys, useSymmAccountData, useSymmAccountSummary, useSymmAccounts, useSymmAccountsApi, useSymmAccountsLength, useSymmAccountsWithPositions, useSymmApproval, useSymmAuth, useSymmAvailableMargin, useSymmBalances, useSymmCancelClose, useSymmChartCandles, useSymmChartSelection, useSymmCloseOrder, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDelegation, useSymmDeposit, useSymmFunding, useSymmFundingHistory, useSymmFundingPayments, useSymmHedgerMarketById, useSymmHedgerMarketBySymbol, useSymmHedgerMarkets, useSymmInstantTrade, useSymmLockedParams, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPendingIds, useSymmPendingInstantOpens, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTpslOrders, useSymmTrade, useSymmTradeHistory, useSymmTriggerConfig, useSymmTriggerOrders, useSymmTwap, useSymmTwapOrder, useSymmWithdraw, useSymmWs };
+export { SymmProvider, getSymmErrorMessage, symmKeys, useBinanceMarkPriceStore, useSymmAccountData, useSymmAccountSummary, useSymmAccounts, useSymmAccountsApi, useSymmAccountsLength, useSymmAccountsWithPositions, useSymmApproval, useSymmAuth, useSymmAuthStore, useSymmAvailableMargin, useSymmBalances, useSymmCancelClose, useSymmChartCandles, useSymmChartSelection, useSymmCloseOrder, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDelegation, useSymmDeposit, useSymmFunding, useSymmFundingHistory, useSymmFundingPayments, useSymmHedgerMarketById, useSymmHedgerMarketBySymbol, useSymmHedgerMarkets, useSymmInstantTrade, useSymmLockedParams, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPendingIds, useSymmPendingInstantOpens, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTpslOrders, useSymmTrade, useSymmTradeHistory, useSymmTriggerConfig, useSymmTriggerOrders, useSymmTwap, useSymmTwapOrder, useSymmWithdraw, useSymmWs, useSymmWsStore };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map