@pear-protocol/symmio-client 0.1.6 → 0.1.7

package/dist/react/index.mjs

@@ -24403,8 +24403,8 @@ function SymmProvider({
       setAccessToken(null);
       return;
     }
-    setAccessToken(null);
     if (previousAddress && (addressChanged || chainChanged)) {
+      setAccessToken(null);
       clearCachedToken(previousAddress, previousChainId);
     }
   }, [address, walletClient, chainId]);
@@ -24487,7 +24487,8 @@ var symmKeys = {
   notifications: (address, chainId) => ["symm", "notifications", address, chainId],
   unreadCount: (address, chainId) => ["symm", "unreadCount", address, chainId],
   availableMargin: (address, chainId) => ["symm", "availableMargin", address, chainId],
-  delegation: (account, target, selectors, chainId) => ["symm", "delegation", account, target, selectors, chainId]
+  delegation: (account, target, selectors, chainId) => ["symm", "delegation", account, target, selectors, chainId],
+  chartMetadata: (symbolsKey, positionKey) => ["symm", "chartMetadata", symbolsKey, positionKey]
 };
 
 // src/react/hooks/use-symm-delegation.ts
@@ -24634,6 +24635,7 @@ function useSymmInstantTrade(params) {
     execute
   };
 }
+var EMPTY_ACCOUNTS = [];
 function useSymmAccounts(userAddress) {
   const { symmioClient } = useSymmContext();
   const queryClient = useQueryClient();
@@ -24664,7 +24666,7 @@ function useSymmAccounts(userAddress) {
     }
   });
   return {
-    accounts: accountsQuery.data ?? [],
+    accounts: accountsQuery.data ?? EMPTY_ACCOUNTS,
     count: accountsQuery.data?.length ?? 0,
     isLoading: accountsQuery.isLoading,
     error: accountsQuery.error,
@@ -24679,21 +24681,23 @@ function useSymmApproval(params) {
   const { owner, amount, spender, collateralToken } = params;
   const resolvedSpender = spender ?? symmioClient?.addresses.multiAccount;
   const resolvedToken = collateralToken ?? symmioClient?.addresses.collateral;
+  const selectWithAmount = useCallback(
+    (data) => ({
+      ...data,
+      state: data.allowance >= amount ? "APPROVED" /* APPROVED */ : "NOT_APPROVED" /* NOT_APPROVED */
+    }),
+    [amount]
+  );
   const approvalQuery = useQuery({
     queryKey: symmKeys.approval(owner, resolvedSpender),
     queryFn: async () => {
-      const [state, allowance, balance] = await Promise.all([
-        symmioClient.approval.getState(
-          resolvedToken,
-          owner,
-          resolvedSpender,
-          amount
-        ),
+      const [allowance, balance] = await Promise.all([
         symmioClient.approval.getAllowance(resolvedToken, owner, resolvedSpender),
         symmioClient.approval.getBalance(resolvedToken, owner)
       ]);
-      return { state, allowance, balance };
+      return { allowance, balance };
     },
+    select: selectWithAmount,
     enabled: !!symmioClient && !!owner && !!resolvedSpender && !!resolvedToken
   });
   const approve2 = useMutation({
@@ -24837,18 +24841,19 @@ function useSymmSignature(userAddress) {
 function useSymmAvailableMargin(params) {
   const { symmioClient } = useSymmContext();
   const { accountAddress, upnl } = params;
+  const resolvedUpnl = upnl ?? 0n;
+  const selectWithUpnl = useCallback(
+    (stats) => ({
+      ...stats,
+      upnl: resolvedUpnl,
+      availableForOrder: calculateAvailableForOrder(stats, resolvedUpnl)
+    }),
+    [resolvedUpnl]
+  );
   const query = useQuery({
     queryKey: symmKeys.availableMargin(accountAddress, symmioClient?.chainId),
-    queryFn: async () => {
-      const stats = await symmioClient.stats.getPartyAStats(accountAddress);
-      const resolvedUpnl = upnl ?? 0n;
-      const availableForOrder = calculateAvailableForOrder(stats, resolvedUpnl);
-      return {
-        ...stats,
-        upnl: resolvedUpnl,
-        availableForOrder
-      };
-    },
+    queryFn: () => symmioClient.stats.getPartyAStats(accountAddress),
+    select: selectWithUpnl,
     enabled: !!symmioClient && !!accountAddress,
     staleTime: 1e4
   });
@@ -25068,37 +25073,37 @@ function useSymmMarkets(params) {
     refetch: query.refetch
   };
 }
+var EMPTY_MARKETS = [];
+var EMPTY_SYMBOLS = [];
+var EMPTY_MAP_BY_ID = /* @__PURE__ */ new Map();
+var EMPTY_MAP_BY_SYMBOL = /* @__PURE__ */ new Map();
 function useSymmHedgerMarkets(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
   const searchText = params?.searchText?.trim();
   const isEnabled = params?.enabled ?? true;
+  const { enabled: _, ...restParams } = params ?? {};
   const request = {
-    ...params,
+    ...restParams,
     chainId,
     searchText: searchText || void 0
   };
   const query = useQuery({
     queryKey: symmKeys.hedgerMarkets(request),
-    queryFn: async () => {
-      const { enabled: _enabled, ...queryRequest } = request;
-      return symmCoreClient.markets.listSymmHedger(queryRequest);
-    },
+    queryFn: () => symmCoreClient.markets.listSymmHedger(request),
     enabled: !!symmCoreClient && isEnabled,
     staleTime: 3e4
   });
   const data = query.data ?? null;
-  const emptyMap = /* @__PURE__ */ new Map();
-  const emptySymbolMap = /* @__PURE__ */ new Map();
   return {
     data,
-    markets: data?.markets ?? [],
-    rawMarkets: data?.rawMarkets ?? [],
-    filteredMarkets: data?.filteredMarkets ?? [],
-    allSymbols: data?.allSymbols ?? [],
-    filteredSymbols: data?.filteredSymbols ?? [],
-    marketsById: data?.marketsById ?? emptyMap,
-    marketsBySymbol: data?.marketsBySymbol ?? emptySymbolMap,
+    markets: data?.markets ?? EMPTY_MARKETS,
+    rawMarkets: data?.rawMarkets ?? EMPTY_MARKETS,
+    filteredMarkets: data?.filteredMarkets ?? EMPTY_MARKETS,
+    allSymbols: data?.allSymbols ?? EMPTY_SYMBOLS,
+    filteredSymbols: data?.filteredSymbols ?? EMPTY_SYMBOLS,
+    marketsById: data?.marketsById ?? EMPTY_MAP_BY_ID,
+    marketsBySymbol: data?.marketsBySymbol ?? EMPTY_MAP_BY_SYMBOL,
     category: data?.category ?? params?.category ?? "all",
     resolvedSearchText: data?.searchText ?? searchText ?? "",
     isLoading: query.isLoading,
@@ -25190,13 +25195,15 @@ function useSymmNotifications(params) {
     refetch: notificationsQuery.refetch
   };
 }
+function asUnsubscribeFn(value) {
+  return typeof value === "function" ? value : null;
+}
 function useSymmWs(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const queryClient = useQueryClient();
   const { accountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const [isConnected, setIsConnected] = useState(false);
-  const cleanupRef = useRef([]);
   useEffect(() => {
     if (!symmCoreClient || !accountAddress) {
       setIsConnected(false);
@@ -25204,61 +25211,75 @@ function useSymmWs(params) {
     }
     const ws = symmCoreClient.ws;
     const addr = accountAddress;
+    const unsubscribers = [];
     const removeOnConnect = ws.onConnect(() => setIsConnected(true));
     const removeOnDisconnect = ws.onDisconnect(() => setIsConnected(false));
-    ws.subscribeToPositions(addr, chainId, () => {
+    unsubscribers.push(removeOnConnect, removeOnDisconnect);
+    const positionsUnsub = asUnsubscribeFn(ws.subscribeToPositions(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.positions(accountAddress, chainId)
       });
-    });
-    ws.subscribeToOpenOrders(addr, chainId, () => {
+    }));
+    if (positionsUnsub) unsubscribers.push(positionsUnsub);
+    const openOrdersUnsub = asUnsubscribeFn(ws.subscribeToOpenOrders(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.openOrders(accountAddress, chainId)
       });
-    });
-    ws.subscribeToTrades(addr, chainId, () => {
+    }));
+    if (openOrdersUnsub) unsubscribers.push(openOrdersUnsub);
+    const tradesUnsub = asUnsubscribeFn(ws.subscribeToTrades(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.tradeHistory(accountAddress, chainId)
       });
-    });
-    ws.subscribeToAccountSummary(addr, chainId, () => {
+    }));
+    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)
       });
-    });
-    ws.subscribeToNotifications(addr, 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)
       });
-    });
-    ws.subscribeToTpsl(addr, chainId, () => {
+    }));
+    if (notificationsUnsub) unsubscribers.push(notificationsUnsub);
+    const tpslUnsub = asUnsubscribeFn(ws.subscribeToTpsl(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.tpslOrders(accountAddress, chainId)
       });
-    });
-    ws.subscribeToTwapOrders(addr, chainId, () => {
+    }));
+    if (tpslUnsub) unsubscribers.push(tpslUnsub);
+    const twapUnsub = asUnsubscribeFn(ws.subscribeToTwapOrders(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.twapOrders(accountAddress, chainId)
       });
-    });
-    ws.subscribeToExecutions(addr, chainId, () => {
+    }));
+    if (twapUnsub) unsubscribers.push(twapUnsub);
+    const executionsUnsub = asUnsubscribeFn(ws.subscribeToExecutions(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.positions(accountAddress, chainId)
       });
       queryClient.invalidateQueries({
         queryKey: symmKeys.portfolio(accountAddress, chainId)
       });
-    });
-    cleanupRef.current = [removeOnConnect, removeOnDisconnect];
+    }));
+    if (executionsUnsub) unsubscribers.push(executionsUnsub);
     return () => {
-      cleanupRef.current.forEach((fn) => fn());
-      ws.unsubscribeAll();
+      if (unsubscribers.length > 2) {
+        unsubscribers.forEach((unsubscribe) => unsubscribe());
+      } else {
+        removeOnConnect();
+        removeOnDisconnect();
+        ws.unsubscribeAll();
+      }
     };
   }, [symmCoreClient, accountAddress, chainId, queryClient]);
   return { isConnected };
@@ -25585,8 +25606,12 @@ function useSymmTokenSelectionMetadata(selection) {
   const isUnsupported = unsupportedSymbols.length > 0;
   const unavailableReason = isUnsupported ? `Binance market data is unavailable for ${unsupportedSymbols.join(", ")}.` : null;
   const symbolsKey = [...selectedSymbols].sort().join(",");
+  const positionKey = [
+    longTokens.map((token) => `${token.symbol}:${token.weight}`).join("|"),
+    shortTokens.map((token) => `${token.symbol}:${token.weight}`).join("|")
+  ].join("::");
   const query = useQuery({
-    queryKey: ["symm", "chart-metadata", symbolsKey],
+    queryKey: symmKeys.chartMetadata(symbolsKey, positionKey),
     queryFn: async () => {
       const allSymbols = [
         ...longTokens.map((t) => ({ symbol: t.symbol, side: "long" })),
@@ -26021,7 +26046,6 @@ function useSymmChartCandles(selection) {
       low: longValues.l * shortValues.l,
       close: longValues.c * shortValues.c
     };
-    if (!bar) return;
     listenersRef.current.forEach((cb) => {
       try {
         cb(bar);
@@ -26046,11 +26070,14 @@ function useSymmChartCandles(selection) {
     }
   }, [emitRealtimeBar, isUnsupported, selectedSymbols]);
   useEffect(() => {
+    if (listenersRef.current.size > 0) {
+      setupWsSubscriptions();
+    }
     return () => {
       wsUnsubsRef.current.forEach((unsub) => unsub());
       wsUnsubsRef.current = [];
     };
-  }, [longTokens, shortTokens]);
+  }, [setupWsSubscriptions]);
   const fetchBasketCandles = useCallback(
     async (start, end, interval) => {
       const longSymbol = longTokens[0]?.symbol;
@@ -26216,10 +26243,8 @@ function useSymmPerformanceOverlays(selection) {
       weight: -token.weight
     }))
   ], [longTokens, shortTokens]);
-  const generateOverlaySymbols = useCallback(() => {
-    return overlays.map((o) => o.symbol);
-  }, [overlays]);
-  return { overlays, generateOverlaySymbols };
+  const overlaySymbols = useMemo(() => overlays.map((o) => o.symbol), [overlays]);
+  return { overlays, overlaySymbols };
 }
 function getSymmErrorMessage(error) {
   if (error instanceof SymmioSDKError) return error.message;