@pear-protocol/symmio-client 0.3.14 → 0.3.16

package/dist/react/index.js

@@ -75,6 +75,7 @@ var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
 var IDLE_CLOSE_DELAY_MS = 3e4;
 var STALE_CONNECTION_MS = 3e4;
 var STALE_CHECK_INTERVAL_MS = 1e4;
+var RECONNECT_RESET_MS = 6e4;
 var STABLE_QUOTES = ["USDT0", "USDT", "USDC", "USDE", "USDH", "USD"];
 function normalizeBaseSymbol(symbol) {
   const normalized = symbol.toUpperCase().trim();
@@ -126,6 +127,7 @@ var BinanceWsManager = class {
   reconnectTimer = null;
   idleCloseTimer = null;
   staleCheckTimer = null;
+  reconnectResetTimer = null;
   intentionalClose = false;
   pendingSubscribes = /* @__PURE__ */ new Set();
   lastMessageAt = 0;
@@ -164,6 +166,7 @@ var BinanceWsManager = class {
     const wrappedCb = (raw) => {
       cb({
         symbol: normalizeBaseSymbol(raw.s),
+        binanceSymbol: raw.s,
         markPrice: parseFloat(raw.p),
         indexPrice: parseFloat(raw.i),
         time: raw.E,
@@ -185,6 +188,7 @@ var BinanceWsManager = class {
       cb(
         extractTickers(raw).map((entry) => ({
           symbol: normalizeBaseSymbol(entry.s),
+          binanceSymbol: entry.s,
           markPrice: parseFloat(entry.p),
           indexPrice: parseFloat(entry.i),
           time: entry.E,
@@ -204,6 +208,7 @@ var BinanceWsManager = class {
     this.clearReconnectTimer();
     this.clearIdleCloseTimer();
     this.clearStaleCheckTimer();
+    this.clearReconnectResetTimer();
     this.pendingSubscribes.clear();
     if (this.ws) {
       this.ws.close();
@@ -240,20 +245,26 @@ var BinanceWsManager = class {
     }
   }
   ensureConnected() {
-    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
-      return;
+    if (this.ws) {
+      const state = this.ws.readyState;
+      if (state === WebSocket.OPEN || state === WebSocket.CONNECTING || state === WebSocket.CLOSING) {
+        return;
+      }
     }
     this.clearReconnectTimer();
     this.connect();
   }
   connect() {
     if (typeof WebSocket === "undefined") return;
+    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+      return;
+    }
     this.intentionalClose = false;
     this.ws = new WebSocket(BINANCE_WS_URL);
     this.ws.onopen = () => {
-      this.reconnectAttempt = 0;
       this.lastMessageAt = Date.now();
       this.startStaleCheck();
+      this.scheduleReconnectReset();
       const activeStreams = Array.from(
         /* @__PURE__ */ new Set([...this.streams.keys(), ...this.pendingSubscribes])
       );
@@ -266,14 +277,24 @@ var BinanceWsManager = class {
       try {
         const data = JSON.parse(event.data);
         this.lastMessageAt = Date.now();
+        this.resetReconnectAttempt();
         this.handleMessage(data);
       } catch {
       }
     };
     this.ws.onclose = () => {
+      const wasIntentional = this.intentionalClose;
+      this.intentionalClose = false;
       this.ws = null;
       this.clearStaleCheckTimer();
-      if (this.intentionalClose) return;
+      this.clearReconnectResetTimer();
+      if (this.streams.size === 0) {
+        return;
+      }
+      if (wasIntentional) {
+        this.connect();
+        return;
+      }
       this.scheduleReconnect();
     };
     this.ws.onerror = () => {
@@ -349,9 +370,6 @@ var BinanceWsManager = class {
       if (this.streams.size > 0 || !this.ws) return;
       this.intentionalClose = true;
       this.ws.close();
-      this.ws = null;
-      this.intentionalClose = false;
-      this.clearStaleCheckTimer();
     }, IDLE_CLOSE_DELAY_MS);
   }
   startStaleCheck() {
@@ -363,6 +381,17 @@ var BinanceWsManager = class {
       this.ws.close();
     }, STALE_CHECK_INTERVAL_MS);
   }
+  scheduleReconnectReset() {
+    this.clearReconnectResetTimer();
+    this.reconnectResetTimer = setTimeout(() => {
+      this.reconnectResetTimer = null;
+      this.resetReconnectAttempt();
+    }, RECONNECT_RESET_MS);
+  }
+  resetReconnectAttempt() {
+    this.reconnectAttempt = 0;
+    this.clearReconnectResetTimer();
+  }
   clearReconnectTimer() {
     if (!this.reconnectTimer) return;
     clearTimeout(this.reconnectTimer);
@@ -378,13 +407,21 @@ var BinanceWsManager = class {
     clearInterval(this.staleCheckTimer);
     this.staleCheckTimer = null;
   }
+  clearReconnectResetTimer() {
+    if (!this.reconnectResetTimer) return;
+    clearTimeout(this.reconnectResetTimer);
+    this.reconnectResetTimer = null;
+  }
 };
-var _instance = null;
+var BINANCE_WS_SINGLETON_KEY = "__pearBinanceWsManager__";
 function getBinanceWsManager() {
-  if (!_instance) {
-    _instance = new BinanceWsManager();
+  const g = globalThis;
+  let manager = g[BINANCE_WS_SINGLETON_KEY];
+  if (!manager) {
+    manager = new BinanceWsManager();
+    g[BINANCE_WS_SINGLETON_KEY] = manager;
   }
-  return _instance;
+  return manager;
 }
 
 // src/react/stores/use-binance-mark-price-store.ts
@@ -392,15 +429,8 @@ var refCounts = /* @__PURE__ */ new Map();
 var streamSymbols = /* @__PURE__ */ new Map();
 var allMarkPricesRefCount = 0;
 var allMarkPricesUnsubscribe = null;
-var STABLE_QUOTES2 = ["USDT0", "USDT", "USDC", "USDE", "USDH", "USD"];
-function normalizeBinanceSymbol(symbol) {
-  const normalized = symbol.toUpperCase().trim();
-  for (const quote of STABLE_QUOTES2) {
-    if (normalized.endsWith(quote) && normalized.length > quote.length) {
-      return normalized.slice(0, -quote.length);
-    }
-  }
-  return normalized;
+function normalizeBinanceSymbolKey(symbol) {
+  return symbol.toUpperCase().trim();
 }
 function getNextRefCount(binanceSymbol) {
   return (refCounts.get(binanceSymbol) ?? 0) + 1;
@@ -435,7 +465,7 @@ var useBinanceMarkPriceStore = zustand.create((set) => ({
   fundingRates: {},
   nextFundingTimes: {},
   subscribeSymbol: (symmSymbol, rawBinanceSymbol) => {
-    const binanceSymbol = normalizeBinanceSymbol(rawBinanceSymbol);
+    const binanceSymbol = normalizeBinanceSymbolKey(rawBinanceSymbol);
     const nextRefCount = getNextRefCount(binanceSymbol);
     refCounts.set(binanceSymbol, nextRefCount);
     addMappedSymbol(binanceSymbol, symmSymbol);
@@ -447,8 +477,10 @@ var useBinanceMarkPriceStore = zustand.create((set) => ({
           let nextFundingRates = null;
           let nextFundingTimes = null;
           entries.forEach((entry) => {
-            const canonicalSymbol = normalizeBinanceSymbol(entry.symbol);
-            const mappedSymbols = streamSymbols.get(canonicalSymbol);
+            const binanceSymbolKey = normalizeBinanceSymbolKey(
+              entry.binanceSymbol ?? entry.symbol
+            );
+            const mappedSymbols = streamSymbols.get(binanceSymbolKey);
             if (!mappedSymbols || mappedSymbols.size === 0) return;
             nextMarkPrices ??= { ...state.markPrices };
             nextFundingRates ??= { ...state.fundingRates };
@@ -473,7 +505,7 @@ var useBinanceMarkPriceStore = zustand.create((set) => ({
     allMarkPricesRefCount += 1;
   },
   unsubscribeSymbol: (symmSymbol, rawBinanceSymbol) => {
-    const binanceSymbol = normalizeBinanceSymbol(rawBinanceSymbol);
+    const binanceSymbol = normalizeBinanceSymbolKey(rawBinanceSymbol);
     const removedSubscription = removeMappedSymbol(binanceSymbol, symmSymbol);
     if (!removedSubscription) {
       return;
@@ -513,6 +545,7 @@ var useBinanceMarkPriceStore = zustand.create((set) => ({
 }));
 
 // src/react/hooks/use-binance-ws.ts
+var BOOTSTRAP_RETRY_DELAYS_MS = [1e3, 2e3, 5e3];
 function useBinanceWs(params) {
   const { symmCoreClient, chainId } = params;
   const subscribeSymbol = useBinanceMarkPriceStore((state) => state.subscribeSymbol);
@@ -523,7 +556,8 @@ function useBinanceWs(params) {
     }
     let cancelled = false;
     let subscribedPairs = [];
-    const run = async () => {
+    let retryTimer = null;
+    const run = async (attempt = 0) => {
       try {
         const result = await symmCoreClient.markets.listSymmHedger({ chainId });
         if (cancelled) {
@@ -543,11 +577,22 @@ function useBinanceWs(params) {
           subscribeSymbol(symbol, binanceSymbol);
         });
       } catch {
+        const delay = BOOTSTRAP_RETRY_DELAYS_MS[attempt];
+        if (cancelled || delay == null) {
+          return;
+        }
+        retryTimer = setTimeout(() => {
+          retryTimer = null;
+          void run(attempt + 1);
+        }, delay);
       }
     };
     void run();
     return () => {
       cancelled = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+      }
       subscribedPairs.forEach(([symbol, binanceSymbol]) => {
         unsubscribeSymbol(symbol, binanceSymbol);
       });
@@ -25635,21 +25680,196 @@ function useSymmAccountData(params) {
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
 }
-function useSymmBalances(params) {
+
+// src/utils/account-pnl.ts
+function toNumber(value) {
+  if (value === null || value === void 0 || value === "") {
+    return 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function readOpenedPrice(leg) {
+  return toNumber(leg.openedPrice ?? leg.opened_price);
+}
+function readCurrentPrice(leg) {
+  const parsed = Number(leg.currentPrice ?? leg.current_price);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function readMarkPrice(leg, markPrices) {
+  const symbol = leg.symbol?.trim().toUpperCase();
+  if (symbol) {
+    const markPrice = Number(markPrices[symbol]);
+    if (Number.isFinite(markPrice)) {
+      return markPrice;
+    }
+  }
+  return readCurrentPrice(leg);
+}
+function getSymbol(leg) {
+  return leg.symbol?.trim().toUpperCase() || void 0;
+}
+function computeLegUpnl(leg, side, markPrices) {
+  const markPrice = readMarkPrice(leg, markPrices);
+  if (markPrice === void 0) {
+    return { upnl: 0, missingSymbol: getSymbol(leg) };
+  }
+  const quantity = toNumber(leg.quantity);
+  const openedPrice = readOpenedPrice(leg);
+  const direction = side === "short" ? -1 : 1;
+  return {
+    upnl: quantity * (markPrice - openedPrice) * direction
+  };
+}
+function computeSymmPositionUpnl(position, markPrices = {}) {
+  const missingSymbols = /* @__PURE__ */ new Set();
+  let upnl = 0;
+  let legsCount = 0;
+  for (const leg of position.longAssets ?? []) {
+    legsCount += 1;
+    const result = computeLegUpnl(leg, "long", markPrices);
+    upnl += result.upnl;
+    if (result.missingSymbol) missingSymbols.add(result.missingSymbol);
+  }
+  for (const leg of position.shortAssets ?? []) {
+    legsCount += 1;
+    const result = computeLegUpnl(leg, "short", markPrices);
+    upnl += result.upnl;
+    if (result.missingSymbol) missingSymbols.add(result.missingSymbol);
+  }
+  if (legsCount === 0) {
+    return {
+      upnl: toNumber(position.unrealizedPnl ?? position.unrealized_pnl),
+      missingSymbols: [],
+      positionsCount: 1,
+      legsCount,
+      usedFallbackPositions: 1
+    };
+  }
+  return {
+    upnl,
+    missingSymbols: Array.from(missingSymbols),
+    positionsCount: 1,
+    legsCount,
+    usedFallbackPositions: 0
+  };
+}
+function computeSymmPositionsUpnl(positions = [], markPrices = {}) {
+  const missingSymbols = /* @__PURE__ */ new Set();
+  let upnl = 0;
+  let legsCount = 0;
+  let usedFallbackPositions = 0;
+  for (const position of positions) {
+    const result = computeSymmPositionUpnl(position, markPrices);
+    upnl += result.upnl;
+    legsCount += result.legsCount;
+    usedFallbackPositions += result.usedFallbackPositions;
+    result.missingSymbols.forEach((symbol) => missingSymbols.add(symbol));
+  }
+  return {
+    upnl,
+    missingSymbols: Array.from(missingSymbols),
+    positionsCount: positions.length,
+    legsCount,
+    usedFallbackPositions
+  };
+}
+function readMessageNumber(message, keys) {
+  for (const key of keys) {
+    if (key in message) {
+      return toNumber(message[key]);
+    }
+  }
+  return 0;
+}
+function normalizeSymmUpnlWebSocketMessage(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return void 0;
+  }
+  const message = raw;
+  const timestamp = readMessageNumber(message, ["timestamp"]);
+  return {
+    upnl: readMessageNumber(message, ["upnl"]),
+    timestamp: timestamp || void 0,
+    availableBalance: readMessageNumber(message, [
+      "availableBalance",
+      "available_balance"
+    ]),
+    allocatedBalance: readMessageNumber(message, [
+      "allocatedBalance",
+      "allocated_balance"
+    ]),
+    cva: readMessageNumber(message, ["cva"]),
+    lf: readMessageNumber(message, ["lf"]),
+    partyAmm: readMessageNumber(message, ["partyAmm", "party_a_mm", "mm"]),
+    pendingPartyAmm: readMessageNumber(message, [
+      "pendingPartyAmm",
+      "pending_party_a_mm",
+      "pending_mm"
+    ]),
+    pendingCva: readMessageNumber(message, ["pendingCva", "pending_cva"]),
+    pendingLf: readMessageNumber(message, ["pendingLf", "pending_lf"]),
+    raw
+  };
+}
+function useSymmPositions(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { userAddress, multiAccountAddress } = params;
+  const { accountAddress, address } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!userAddress;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  const enabled = internalEnabled && (params.query?.enabled ?? true);
   return reactQuery.useQuery({
     ...params.query,
-    queryKey: symmKeys.balances(userAddress, chainId, multiAccountAddress),
-    queryFn: () => symmCoreClient.accounts.getBalanceInfo({
-      userAddress,
-      chainId,
-      multiAccountAddress
+    queryKey: symmKeys.positions({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
     }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    queryFn: () => symmCoreClient.positions.getOpen({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
+    }),
+    enabled
+  });
+}
+
+// src/react/hooks/use-symm-account-current-pnl.ts
+function readPositions(response) {
+  if (typeof response !== "object" || response === null) {
+    return [];
+  }
+  const data = response.data;
+  if (typeof data !== "object" || data === null) {
+    return [];
+  }
+  const positions = data.positions;
+  return Array.isArray(positions) ? positions : [];
+}
+function useSymmAccountCurrentPnl(params) {
+  const { accountAddress, address, positions, query } = params;
+  const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
+  const positionsQuery = useSymmPositions({
+    accountAddress,
+    address,
+    chainId: params.chainId,
+    query: {
+      ...query,
+      enabled: positions === void 0 && (query?.enabled ?? true)
+    }
   });
+  const resolvedPositions = positions ?? readPositions(positionsQuery.data);
+  const pnl = react.useMemo(
+    () => computeSymmPositionsUpnl(resolvedPositions, liveMarkPrices),
+    [liveMarkPrices, resolvedPositions]
+  );
+  return {
+    ...pnl,
+    value: pnl.upnl,
+    positions: resolvedPositions,
+    positionsQuery
+  };
 }
 
 // src/utils/account-overview.ts
@@ -25679,7 +25899,7 @@ function readValue(source, keys) {
   }
   return void 0;
 }
-function toNumber(value) {
+function toNumber2(value) {
   if (value === null || value === void 0 || value === "") {
     return 0;
   }
@@ -25696,7 +25916,7 @@ function toDisplayString(value) {
   return String(value);
 }
 function readNumber(source, keys) {
-  return toNumber(readValue(source, keys));
+  return toNumber2(readValue(source, keys));
 }
 function readTimestamp(source) {
   const timestamp = readValue(source, ["timestamp"]);
@@ -25706,6 +25926,28 @@ function readTimestamp(source) {
   const parsed = Number(timestamp);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
+function hasAccountDataShape(value) {
+  return isRecord(value) && ("equity" in value || "maintenanceMargin" in value || "availableForOrder" in value || "totalLocked" in value);
+}
+function getSymmAccountData(response) {
+  if (!isRecord(response)) {
+    return void 0;
+  }
+  const data = response.data;
+  if (isRecord(data)) {
+    if (hasAccountDataShape(data.accountData)) {
+      return data.accountData;
+    }
+    if (hasAccountDataShape(data)) {
+      return data;
+    }
+    return void 0;
+  }
+  if (hasAccountDataShape(response)) {
+    return response;
+  }
+  return void 0;
+}
 function getBalanceInfoContainer(response) {
   if (!isRecord(response)) {
     return void 0;
@@ -25786,7 +26028,7 @@ function computeSymmAccountOverview({
     "pendingLockedPartyAMM",
     "pending_locked_party_a_mm"
   ]);
-  const upnl = upnlOverride === void 0 ? readNumber(balanceInfo, ["upnl"]) : toNumber(upnlOverride);
+  const upnl = upnlOverride === void 0 ? readNumber(balanceInfo, ["upnl"]) : toNumber2(upnlOverride);
   const computedTotalLocked = cva + lf + partyAmm;
   const totalLocked = readValue(
     balanceInfo,
@@ -25816,11 +26058,43 @@ function computeSymmAccountOverview({
     availableForOrder: toDisplayString(availableForOrder),
     availableMargin: toDisplayString(availableForOrder),
     availableBalance: toDisplayString(availableBalance),
-    netDeposited: toDisplayString(toNumber(netDeposited)),
+    netDeposited: toDisplayString(toNumber2(netDeposited)),
     notional: toDisplayString(notional),
     timestamp: readTimestamp(balanceInfo)
   };
 }
+function computeSymmAccountOverviewFromData({
+  accountData,
+  upnl,
+  netDeposited
+}) {
+  const equity = readNumber(accountData, ["equity"]);
+  const maintenanceMargin = readNumber(accountData, [
+    "maintenanceMargin",
+    "maintenance_margin"
+  ]);
+  const availableForOrder = readNumber(accountData, [
+    "availableForOrder",
+    "available_for_order"
+  ]);
+  const totalLocked = readNumber(accountData, ["totalLocked", "total_locked"]);
+  return {
+    allocatedBalance: "0",
+    upnl: toDisplayString(toNumber2(upnl)),
+    equity: toDisplayString(equity),
+    totalAccountValue: toDisplayString(equity),
+    maintenanceMargin: toDisplayString(maintenanceMargin),
+    accountHealthData: accountData.accountHealthData,
+    totalLocked: toDisplayString(totalLocked),
+    marginUsed: toDisplayString(totalLocked),
+    totalPendingLocked: "0",
+    availableForOrder: toDisplayString(availableForOrder),
+    availableMargin: toDisplayString(availableForOrder),
+    availableBalance: toDisplayString(availableForOrder),
+    netDeposited: toDisplayString(toNumber2(netDeposited)),
+    notional: "0"
+  };
+}
 function computeSymmNetDeposited(totals, decimals = 6) {
   if (!totals) {
     return "0";
@@ -25861,32 +26135,186 @@ function useSymmAccountOverview(params) {
   const {
     userAddress,
     accountAddress,
-    multiAccountAddress,
     upnl,
-    netDeposited
+    netDeposited,
+    positions,
+    currentPnlQuery
   } = params;
-  const query = useSymmBalances({
-    userAddress,
-    multiAccountAddress,
+  const address = accountAddress ?? userAddress;
+  const shouldUseLocalPnl = upnl === void 0;
+  const currentPnl = useSymmAccountCurrentPnl({
+    accountAddress: address,
+    positions,
     chainId: params.chainId,
-    query: params.query
+    query: {
+      ...currentPnlQuery,
+      enabled: shouldUseLocalPnl && (currentPnlQuery?.enabled ?? true)
+    }
+  });
+  const resolvedUpnl = shouldUseLocalPnl ? currentPnl.value : upnl;
+  const upnlReady = !shouldUseLocalPnl || positions !== void 0 || currentPnl.positionsQuery.isSuccess;
+  const query = useSymmAccountData({
+    address,
+    upnl: upnlReady ? String(resolvedUpnl ?? 0) : void 0,
+    chainId: params.chainId,
+    query: {
+      ...params.query,
+      enabled: upnlReady && (params.query?.enabled ?? true)
+    }
   });
   const data = react.useMemo(() => {
     if (query.data === void 0) {
       return void 0;
     }
-    const balanceInfo = getSymmAccountBalanceInfo(
-      query.data,
-      accountAddress ?? userAddress
-    );
+    const accountData = getSymmAccountData(query.data);
     return {
       response: query.data,
-      balanceInfo,
-      overview: balanceInfo ? computeSymmAccountOverview({ balanceInfo, upnl, netDeposited }) : void 0
+      accountData,
+      coreAccountData: accountData,
+      currentPnl,
+      overview: accountData ? computeSymmAccountOverviewFromData({
+        accountData,
+        upnl: resolvedUpnl,
+        netDeposited
+      }) : void 0
     };
-  }, [accountAddress, netDeposited, query.data, upnl, userAddress]);
+  }, [currentPnl, netDeposited, query.data, resolvedUpnl]);
   return { ...query, data };
 }
+function parseMessageData(data) {
+  if (typeof data !== "string") {
+    return data;
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+}
+function toBalanceInfo(message) {
+  return {
+    allocatedBalance: message.allocatedBalance,
+    cva: message.cva,
+    lf: message.lf,
+    partyAmm: message.partyAmm,
+    pendingCva: message.pendingCva,
+    pendingLf: message.pendingLf,
+    pendingPartyAmm: message.pendingPartyAmm,
+    upnl: message.upnl,
+    availableBalance: message.availableBalance,
+    timestamp: message.timestamp
+  };
+}
+function useSymmUpnlWebSocket(params) {
+  const {
+    url,
+    accountAddress,
+    enabled = true,
+    reconnectAttempts = 2,
+    reconnectDelayMs = 1e3,
+    webSocketFactory
+  } = params;
+  const [data, setData] = react.useState();
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState();
+  const socketRef = react.useRef(null);
+  const sendAccountAddress = react.useCallback(() => {
+    if (!accountAddress || socketRef.current?.readyState !== 1) {
+      return;
+    }
+    socketRef.current.send(accountAddress);
+  }, [accountAddress]);
+  react.useEffect(() => {
+    if (!enabled || !url || !accountAddress) {
+      setStatus("idle");
+      setData(void 0);
+      setError(void 0);
+      return;
+    }
+    const createSocket = webSocketFactory ?? ((wsUrl) => new WebSocket(wsUrl));
+    let closedByHook = false;
+    let reconnectCount = 0;
+    let reconnectTimer;
+    const connect = () => {
+      setStatus("connecting");
+      const socket = createSocket(url);
+      socketRef.current = socket;
+      socket.onopen = () => {
+        reconnectCount = 0;
+        setStatus("open");
+        setError(void 0);
+        socket.send(accountAddress);
+      };
+      socket.onmessage = (event) => {
+        const parsed = parseMessageData(event.data);
+        const nextMessage = normalizeSymmUpnlWebSocketMessage(parsed);
+        if (nextMessage) {
+          setData(nextMessage);
+        }
+      };
+      socket.onerror = (event) => {
+        setError(event);
+        setStatus("error");
+      };
+      socket.onclose = () => {
+        if (closedByHook) {
+          setStatus("closed");
+          return;
+        }
+        if (reconnectCount < reconnectAttempts) {
+          reconnectCount += 1;
+          reconnectTimer = setTimeout(connect, reconnectDelayMs);
+          return;
+        }
+        setStatus("closed");
+      };
+    };
+    connect();
+    return () => {
+      closedByHook = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+      }
+      socketRef.current?.close();
+      socketRef.current = null;
+    };
+  }, [
+    accountAddress,
+    enabled,
+    reconnectAttempts,
+    reconnectDelayMs,
+    url,
+    webSocketFactory
+  ]);
+  const balanceInfo = react.useMemo(
+    () => data ? toBalanceInfo(data) : void 0,
+    [data]
+  );
+  return {
+    data,
+    upnl: data?.upnl,
+    balanceInfo,
+    status,
+    error,
+    sendAccountAddress
+  };
+}
+function useSymmBalances(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { userAddress, multiAccountAddress } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!userAddress;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.balances(userAddress, chainId, multiAccountAddress),
+    queryFn: () => symmCoreClient.accounts.getBalanceInfo({
+      userAddress,
+      chainId,
+      multiAccountAddress
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
 function useSymmOpenBasketMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
@@ -26017,28 +26445,6 @@ function useSymmUpdatePositionMutation(paramsOrOptions, maybeOptions) {
     }
   });
 }
-function useSymmPositions(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);
-  const enabled = internalEnabled && (params.query?.enabled ?? true);
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.positions({
-      accountAddress,
-      address: resolvedAddress,
-      chainId
-    }),
-    queryFn: () => symmCoreClient.positions.getOpen({
-      accountAddress,
-      address: resolvedAddress,
-      chainId
-    }),
-    enabled
-  });
-}
 function useSymmOpenOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { accountAddress, address } = params;
@@ -27461,11 +27867,17 @@ function getSymmErrorMessage(error) {
 
 exports.SymmProvider = SymmProvider;
 exports.computeSymmAccountOverview = computeSymmAccountOverview;
+exports.computeSymmAccountOverviewFromData = computeSymmAccountOverviewFromData;
 exports.computeSymmNetDeposited = computeSymmNetDeposited;
+exports.computeSymmPositionUpnl = computeSymmPositionUpnl;
+exports.computeSymmPositionsUpnl = computeSymmPositionsUpnl;
 exports.getSymmAccountBalanceInfo = getSymmAccountBalanceInfo;
+exports.getSymmAccountData = getSymmAccountData;
 exports.getSymmErrorMessage = getSymmErrorMessage;
+exports.normalizeSymmUpnlWebSocketMessage = normalizeSymmUpnlWebSocketMessage;
 exports.symmKeys = symmKeys;
 exports.useBinanceMarkPriceStore = useBinanceMarkPriceStore;
+exports.useSymmAccountCurrentPnl = useSymmAccountCurrentPnl;
 exports.useSymmAccountData = useSymmAccountData;
 exports.useSymmAccountOverview = useSymmAccountOverview;
 exports.useSymmAccountSummary = useSymmAccountSummary;
@@ -27535,6 +27947,7 @@ exports.useSymmTwapOrder = useSymmTwapOrder;
 exports.useSymmTwapOrdersQuery = useSymmTwapOrdersQuery;
 exports.useSymmUnreadCountQuery = useSymmUnreadCountQuery;
 exports.useSymmUpdatePositionMutation = useSymmUpdatePositionMutation;
+exports.useSymmUpnlWebSocket = useSymmUpnlWebSocket;
 exports.useSymmWithdraw = useSymmWithdraw;
 exports.useSymmWsStore = useSymmWsStore;
 //# sourceMappingURL=index.js.map