@pear-protocol/symmio-client 0.1.5 → 0.1.7

package/dist/react/index.js

@@ -29,6 +29,10 @@ var CLEARING_HOUSE_ADDRESS = {
 var SIGNATURE_STORE_ADDRESS = {
   [42161 /* ARBITRUM */]: "0x94eEa58De1C8945c342dB4bE9670301638E403e2"
 };
+var DEFAULT_PARTY_B_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x00c069d68bc7420740460DBC3cc3fFF9b3742421",
+  [8453 /* BASE */]: "0x1EcAbF0Eba136920677C9575FAccee36f30592cf"
+};
 function getAddress(addressMap, chainId, name) {
   const addr = addressMap[chainId];
   if (!addr || addr === "0x0000000000000000000000000000000000000000") {
@@ -23652,6 +23656,17 @@ async function revokeAccess(walletClient, publicClient, multiAccount, params) {
     chain: walletClient.chain
   });
 }
+async function hasDelegatedAccess(publicClient, multiAccount, params) {
+  validateAddress(params.account, "subAccount");
+  validateAddress(params.target, "target");
+  const result = await publicClient.readContract({
+    address: multiAccount,
+    abi: MultiAccountABI,
+    functionName: "delegatedAccesses",
+    args: [params.account, params.target, params.selector]
+  });
+  return Boolean(result);
+}
 
 // src/abis/SignatureStore.ts
 var SignatureStoreABI = [
@@ -23956,6 +23971,51 @@ async function getOpenInstantCloses(chainId, account, accessToken) {
   return response.json();
 }
 
+// src/actions/stats.ts
+async function getPartyAStats(publicClient, symmioDiamond, partyA) {
+  const result = await publicClient.readContract({
+    address: symmioDiamond,
+    abi: SymmioDiamondABI,
+    functionName: "partyAStats",
+    args: [partyA]
+  });
+  return {
+    collateralBalance: result[1],
+    allocatedBalance: result[2],
+    availableBalance: result[3],
+    lockedCVA: result[4],
+    lockedLF: result[5],
+    lockedPartyAMM: result[6],
+    lockedPartyBMM: result[7],
+    pendingLockedCVA: result[8],
+    pendingLockedLF: result[9],
+    pendingLockedPartyAMM: result[10],
+    pendingLockedPartyBMM: result[11],
+    positionsCount: Number(result[12]),
+    pendingCount: Number(result[13]),
+    nonces: 0
+  };
+}
+function calculateAvailableForOrder(stats, upnl) {
+  const {
+    allocatedBalance,
+    lockedCVA,
+    lockedLF,
+    lockedPartyAMM,
+    pendingLockedCVA,
+    pendingLockedLF,
+    pendingLockedPartyAMM
+  } = stats;
+  const totalPendingLocked = pendingLockedCVA + pendingLockedLF + pendingLockedPartyAMM;
+  if (upnl >= 0n) {
+    const totalLocked = lockedCVA + lockedLF + lockedPartyAMM;
+    return allocatedBalance + upnl - totalLocked - totalPendingLocked;
+  }
+  const absUpnl = -upnl;
+  const consideringMm = absUpnl > lockedPartyAMM ? absUpnl : lockedPartyAMM;
+  return allocatedBalance - lockedCVA - lockedLF - totalPendingLocked - consideringMm;
+}
+
 // src/client.ts
 var SymmioSDK = class {
   chainId;
@@ -24102,7 +24162,9 @@ var SymmioSDK = class {
       /** Propose to revoke delegated access (starts cooldown). */
       proposeRevoke: (params) => proposeRevoke(wc, pc, ma, params),
       /** Revoke delegated access (after cooldown). */
-      revokeAccess: (params) => revokeAccess(wc, pc, ma, params)
+      revokeAccess: (params) => revokeAccess(wc, pc, ma, params),
+      /** Reads whether a selector is delegated to a target for a sub-account. */
+      hasAccess: (params) => hasDelegatedAccess(pc, ma, params)
     };
   }
   // ─── Signature Module ──────────────────────────────────────────
@@ -24158,6 +24220,17 @@ var SymmioSDK = class {
       getOpenCloses: (account, accessToken) => getOpenInstantCloses(this.chainId, account, accessToken)
     };
   }
+  // ─── Stats Module ───────────────────────────────────────────
+  get stats() {
+    const pc = this._publicClient;
+    const sd = this._symmioDiamond;
+    return {
+      /** Reads partyA statistics (balances, locks) from the Diamond contract. */
+      getPartyAStats: (partyA) => getPartyAStats(pc, sd, partyA),
+      /** Calculates available margin for placing orders given uPNL. */
+      calculateAvailableForOrder: (stats, upnl) => calculateAvailableForOrder(stats, upnl)
+    };
+  }
   // ─── Muon Signatures ──────────────────────────────────────────
   async getQuoteSig(partyA, symbolId) {
     return this.muon.getQuoteSig({
@@ -24332,8 +24405,8 @@ function SymmProvider({
       setAccessToken(null);
       return;
     }
-    setAccessToken(null);
     if (previousAddress && (addressChanged || chainChanged)) {
+      setAccessToken(null);
       clearCachedToken(previousAddress, previousChainId);
     }
   }, [address, walletClient, chainId]);
@@ -24388,6 +24461,14 @@ function useSymmAuth() {
   };
 }
 
+// src/constants/selectors.ts
+var SEND_QUOTE_WITH_AFFILIATE_SELECTOR = "0x40f1310c";
+var CLOSE_QUOTE_SELECTOR = "0x501e891f";
+var ALL_TRADING_SELECTORS = [
+  SEND_QUOTE_WITH_AFFILIATE_SELECTOR,
+  CLOSE_QUOTE_SELECTOR
+];
+
 // src/react/query-keys.ts
 var symmKeys = {
   all: ["symm"],
@@ -24406,10 +24487,157 @@ var symmKeys = {
   fundingRates: (chainId) => ["symm", "fundingRates", chainId],
   portfolio: (address, chainId) => ["symm", "portfolio", address, chainId],
   notifications: (address, chainId) => ["symm", "notifications", address, chainId],
-  unreadCount: (address, chainId) => ["symm", "unreadCount", 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],
+  chartMetadata: (symbolsKey, positionKey) => ["symm", "chartMetadata", symbolsKey, positionKey]
 };
 
-// src/react/hooks/use-symm-accounts.ts
+// src/react/hooks/use-symm-delegation.ts
+function useSymmDelegation(params) {
+  const { symmioClient, chainId, address } = useSymmContext();
+  const accountAddress = params?.accountAddress ?? address;
+  const target = params?.target ?? DEFAULT_PARTY_B_ADDRESS[chainId];
+  const selectors = params?.selectors ?? ALL_TRADING_SELECTORS;
+  const enabled = (params?.enabled ?? true) && !!symmioClient && !!accountAddress && !!target && selectors.length > 0;
+  return reactQuery.useQuery({
+    queryKey: symmKeys.delegation(accountAddress, target, selectors, chainId),
+    enabled,
+    queryFn: async () => {
+      if (!symmioClient) throw new Error("symmio client not available");
+      if (!accountAddress) throw new Error("account address is required");
+      if (!target) throw new Error("delegation target is not configured");
+      const entries = await Promise.all(
+        selectors.map(async (selector) => [
+          selector,
+          await symmioClient.delegation.hasAccess({
+            account: accountAddress,
+            target,
+            selector
+          })
+        ])
+      );
+      const accessBySelector = Object.fromEntries(entries);
+      return {
+        hasAccess: selectors.every((selector) => accessBySelector[selector] === true),
+        account: accountAddress,
+        target,
+        selectors,
+        accessBySelector,
+        openAccess: accessBySelector[SEND_QUOTE_WITH_AFFILIATE_SELECTOR] ?? void 0,
+        closeAccess: accessBySelector[CLOSE_QUOTE_SELECTOR] ?? void 0
+      };
+    }
+  });
+}
+
+// src/react/cache.ts
+function invalidateBalances(qc) {
+  qc.invalidateQueries({ queryKey: ["symm", "balances"] });
+  qc.invalidateQueries({ queryKey: ["symm", "accountSummary"] });
+  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
+}
+function invalidatePositions(qc) {
+  qc.invalidateQueries({ queryKey: ["symm", "positions"] });
+  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "tradeHistory"] });
+  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
+}
+function invalidateOrders(qc) {
+  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
+}
+
+// src/react/hooks/use-symm-instant-trade.ts
+function useSymmInstantTrade(params) {
+  const {
+    symmioClient,
+    symmCoreClient,
+    chainId,
+    address,
+    refreshAuth
+  } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const defaultAccountAddress = params?.accountAddress ?? address;
+  const defaultTarget = params?.target ?? DEFAULT_PARTY_B_ADDRESS[chainId];
+  const defaultSelectors = params?.selectors ?? ALL_TRADING_SELECTORS;
+  const delegation = useSymmDelegation({
+    accountAddress: defaultAccountAddress,
+    target: defaultTarget,
+    selectors: defaultSelectors,
+    enabled: params?.enabled
+  });
+  const ensureReady = reactQuery.useMutation({
+    mutationFn: async (request) => {
+      if (!symmioClient) throw new Error("symmio client not available");
+      const accountAddress = request?.accountAddress ?? defaultAccountAddress;
+      const target = request?.target ?? defaultTarget;
+      const selectors = request?.selectors ?? defaultSelectors;
+      if (!accountAddress) throw new Error("account address is required");
+      if (!target) throw new Error("delegation target is not configured");
+      if (selectors.length === 0) {
+        throw new Error("at least one delegation selector is required");
+      }
+      const accessToken = await refreshAuth(accountAddress);
+      if (!accessToken) {
+        throw new Error("failed to refresh instant-trading auth");
+      }
+      const accessStates = await Promise.all(
+        selectors.map(
+          (selector) => symmioClient.delegation.hasAccess({
+            account: accountAddress,
+            target,
+            selector
+          })
+        )
+      );
+      if (!accessStates.every(Boolean)) {
+        await symmioClient.delegation.delegateAccess({
+          account: accountAddress,
+          target,
+          selectors: [...selectors],
+          activate: true
+        });
+        await queryClient.invalidateQueries({
+          queryKey: symmKeys.delegation(accountAddress, target, selectors, chainId)
+        });
+      }
+      return {
+        accessToken,
+        accountAddress,
+        target,
+        selectors
+      };
+    }
+  });
+  const execute = reactQuery.useMutation({
+    mutationFn: async (request) => {
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      const setup = await ensureReady.mutateAsync({
+        accountAddress: request.accountAddress,
+        target: request.target,
+        selectors: request.selectors
+      });
+      return request.action({
+        symmCoreClient,
+        accessToken: setup.accessToken,
+        accountAddress: setup.accountAddress
+      });
+    },
+    onSuccess: (_data, variables) => {
+      if (variables.invalidatePositionsOnSuccess !== false) {
+        invalidatePositions(queryClient);
+      }
+    }
+  });
+  return {
+    delegation,
+    ensureReady,
+    execute
+  };
+}
+var EMPTY_ACCOUNTS = [];
 function useSymmAccounts(userAddress) {
   const { symmioClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
@@ -24440,7 +24668,7 @@ function useSymmAccounts(userAddress) {
     }
   });
   return {
-    accounts: accountsQuery.data ?? [],
+    accounts: accountsQuery.data ?? EMPTY_ACCOUNTS,
     count: accountsQuery.data?.length ?? 0,
     isLoading: accountsQuery.isLoading,
     error: accountsQuery.error,
@@ -24455,21 +24683,23 @@ function useSymmApproval(params) {
   const { owner, amount, spender, collateralToken } = params;
   const resolvedSpender = spender ?? symmioClient?.addresses.multiAccount;
   const resolvedToken = collateralToken ?? symmioClient?.addresses.collateral;
+  const selectWithAmount = react.useCallback(
+    (data) => ({
+      ...data,
+      state: data.allowance >= amount ? "APPROVED" /* APPROVED */ : "NOT_APPROVED" /* NOT_APPROVED */
+    }),
+    [amount]
+  );
   const approvalQuery = reactQuery.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 = reactQuery.useMutation({
@@ -24491,26 +24721,6 @@ function useSymmApproval(params) {
     approve: approve2
   };
 }
-
-// src/react/cache.ts
-function invalidateBalances(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "balances"] });
-  qc.invalidateQueries({ queryKey: ["symm", "accountSummary"] });
-  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
-}
-function invalidatePositions(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "positions"] });
-  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "tradeHistory"] });
-  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
-}
-function invalidateOrders(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
-}
-
-// src/react/hooks/use-symm-deposit.ts
 function useSymmDeposit() {
   const { symmioClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
@@ -24630,6 +24840,32 @@ function useSymmSignature(userAddress) {
     signTerms
   };
 }
+function useSymmAvailableMargin(params) {
+  const { symmioClient } = useSymmContext();
+  const { accountAddress, upnl } = params;
+  const resolvedUpnl = upnl ?? 0n;
+  const selectWithUpnl = react.useCallback(
+    (stats) => ({
+      ...stats,
+      upnl: resolvedUpnl,
+      availableForOrder: calculateAvailableForOrder(stats, resolvedUpnl)
+    }),
+    [resolvedUpnl]
+  );
+  const query = reactQuery.useQuery({
+    queryKey: symmKeys.availableMargin(accountAddress, symmioClient?.chainId),
+    queryFn: () => symmioClient.stats.getPartyAStats(accountAddress),
+    select: selectWithUpnl,
+    enabled: !!symmioClient && !!accountAddress,
+    staleTime: 1e4
+  });
+  return {
+    availableForOrder: query.data?.availableForOrder ?? null,
+    stats: query.data ?? null,
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
 function useSymmBalances(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress, multiAccountAddress } = params;
@@ -24839,37 +25075,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 = reactQuery.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,
@@ -24961,13 +25197,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 = reactQuery.useQueryClient();
   const { accountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const [isConnected, setIsConnected] = react.useState(false);
-  const cleanupRef = react.useRef([]);
   react.useEffect(() => {
     if (!symmCoreClient || !accountAddress) {
       setIsConnected(false);
@@ -24975,61 +25213,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 };
@@ -25356,8 +25608,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 = reactQuery.useQuery({
-    queryKey: ["symm", "chart-metadata", symbolsKey],
+    queryKey: symmKeys.chartMetadata(symbolsKey, positionKey),
     queryFn: async () => {
       const allSymbols = [
         ...longTokens.map((t) => ({ symbol: t.symbol, side: "long" })),
@@ -25792,7 +26048,6 @@ function useSymmChartCandles(selection) {
       low: longValues.l * shortValues.l,
       close: longValues.c * shortValues.c
     };
-    if (!bar) return;
     listenersRef.current.forEach((cb) => {
       try {
         cb(bar);
@@ -25817,11 +26072,14 @@ function useSymmChartCandles(selection) {
     }
   }, [emitRealtimeBar, isUnsupported, selectedSymbols]);
   react.useEffect(() => {
+    if (listenersRef.current.size > 0) {
+      setupWsSubscriptions();
+    }
     return () => {
       wsUnsubsRef.current.forEach((unsub) => unsub());
       wsUnsubsRef.current = [];
     };
-  }, [longTokens, shortTokens]);
+  }, [setupWsSubscriptions]);
   const fetchBasketCandles = react.useCallback(
     async (start, end, interval) => {
       const longSymbol = longTokens[0]?.symbol;
@@ -25987,10 +26245,8 @@ function useSymmPerformanceOverlays(selection) {
       weight: -token.weight
     }))
   ], [longTokens, shortTokens]);
-  const generateOverlaySymbols = react.useCallback(() => {
-    return overlays.map((o) => o.symbol);
-  }, [overlays]);
-  return { overlays, generateOverlaySymbols };
+  const overlaySymbols = react.useMemo(() => overlays.map((o) => o.symbol), [overlays]);
+  return { overlays, overlaySymbols };
 }
 function getSymmErrorMessage(error) {
   if (error instanceof SymmioSDKError) return error.message;
@@ -26010,15 +26266,18 @@ exports.symmKeys = symmKeys;
 exports.useSymmAccounts = useSymmAccounts;
 exports.useSymmApproval = useSymmApproval;
 exports.useSymmAuth = useSymmAuth;
+exports.useSymmAvailableMargin = useSymmAvailableMargin;
 exports.useSymmBalances = useSymmBalances;
 exports.useSymmChartCandles = useSymmChartCandles;
 exports.useSymmChartSelection = useSymmChartSelection;
 exports.useSymmCollateral = useSymmCollateral;
 exports.useSymmContext = useSymmContext;
 exports.useSymmCoreClient = useSymmCoreClient;
+exports.useSymmDelegation = useSymmDelegation;
 exports.useSymmDeposit = useSymmDeposit;
 exports.useSymmFunding = useSymmFunding;
 exports.useSymmHedgerMarkets = useSymmHedgerMarkets;
+exports.useSymmInstantTrade = useSymmInstantTrade;
 exports.useSymmMarkets = useSymmMarkets;
 exports.useSymmNotifications = useSymmNotifications;
 exports.useSymmOpenOrders = useSymmOpenOrders;