@pear-protocol/symmio-client 0.2.26 → 0.2.28

package/dist/react/index.js

@@ -3,8 +3,8 @@
 
 var react = require('react');
 var symmCore = require('@pear-protocol/symm-core');
-var jsxRuntime = require('react/jsx-runtime');
 var zustand = require('zustand');
+var jsxRuntime = require('react/jsx-runtime');
 var reactQuery = require('@tanstack/react-query');
 var viem = require('viem');
 
@@ -16,342 +16,773 @@ function useSymmContext() {
   }
   return ctx;
 }
-function SymmProvider({
-  chainId = 42161,
-  address,
-  symmCoreConfig = {
-    apiUrl: "https://nginx-server-staging.up.railway.app",
-    wsUrl: "wss://nginx-server-staging.up.railway.app"
-  },
-  symmioConfig,
-  children
-}) {
-  const symmCoreClient = react.useMemo(() => {
-    return symmCore.createSymmSDK({
-      apiUrl: symmCoreConfig.apiUrl,
-      wsUrl: symmCoreConfig.wsUrl,
-      defaultChainId: chainId
-    });
-  }, [chainId, symmCoreConfig.apiUrl, symmCoreConfig.wsUrl]);
-  const value = react.useMemo(
-    () => ({
-      symmCoreClient,
-      chainId,
-      address,
-      symmioConfig
-    }),
-    [symmCoreClient, chainId, address, symmioConfig]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(SymmContext.Provider, { value, children });
-}
-
-// src/react/hooks/use-symm-core-client.ts
-function useSymmCoreClient() {
-  return useSymmContext().symmCoreClient;
-}
 
-// src/constants/defaults.ts
-var GAS_MARGIN_PERCENTAGE = 20n;
-var MUON_BASE_URLS = [
-  "https://muon-oracle1.rasa.capital/v1/",
-  "https://muon-oracle2.rasa.capital/v1/",
-  "https://muon-oracle3.rasa.capital/v1/",
-  "https://muon-oracle4.rasa.capital/v1/"
-];
-var MUON_APP_NAME = "symmio";
-var MUON_REQUEST_TIMEOUT = 15e3;
-var HEDGER_BASE_URLS = {
-  [42161 /* ARBITRUM */]: "https://www.perps-streaming.com/v1/42161a/0x6273242a7E88b3De90822b31648C212215caaFE4",
-  [8453 /* BASE */]: "https://www.perps-streaming.com/v1/8453a/0x6273242a7E88b3De90822b31648C212215caaFE4"
+// src/utils/binance-symbol-map.ts
+var SYMBOL_OVERRIDES = {
+  // Add overrides here as needed for SYMM markets that don't map 1:1 to Binance
+  // e.g., 'SOME_SYMM_SYMBOL': 'BINANCE_SYMBOL',
 };
-
-// src/actions/instant.ts
-function getHedgerBaseUrl(chainId) {
-  const baseUrl = HEDGER_BASE_URLS[chainId];
-  if (!baseUrl) {
-    throw new Error(`No hedger base URL configured for chain ${chainId}.`);
-  }
-  return baseUrl;
-}
-function createSiweMessage(params) {
-  const version = params.version ?? "1";
-  const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const expirationTime = new Date(
-    Date.now() + 30 * 24 * 60 * 60 * 1e3
-  ).toISOString();
-  const message = [
-    `${params.domain} wants you to sign in with your Ethereum account:`,
-    params.address,
-    "",
-    params.statement,
-    "",
-    `URI: ${params.uri}`,
-    `Version: ${version}`,
-    `Chain ID: ${params.chainId}`,
-    `Nonce: ${params.nonce}`,
-    `Issued At: ${issuedAt}`,
-    `Expiration Time: ${expirationTime}`
-  ].join("\n");
-  return { message, issuedAt, expirationTime };
-}
-async function getNonce(chainId, subAccount) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL(`nonce/${subAccount}`, hedgerBaseUrl).href;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch nonce: ${response.statusText}`);
+var UNSUPPORTED_SYMBOLS = /* @__PURE__ */ new Set([
+  // Add symbols here that have no Binance equivalent
+]);
+function resolveBinanceSymbol(symmSymbol) {
+  if (!symmSymbol || !symmSymbol.trim()) {
+    return {
+      symmSymbol,
+      normalizedSymbol: "",
+      binanceSymbol: null,
+      supported: false,
+      reason: "missing_symbol"
+    };
   }
-  const data = await response.json();
-  return data.nonce;
-}
-async function login(chainId, params) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL("login", hedgerBaseUrl).href;
-  const body = {
-    account_address: params.accountAddress,
-    expiration_time: params.expirationTime,
-    issued_at: params.issuedAt,
-    signature: params.signature,
-    nonce: params.nonce
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => null);
-    throw new Error(
-      errorData?.error_message ?? `Login failed: ${response.statusText}`
-    );
+  const normalized = symmSymbol.toUpperCase().trim();
+  if (!/^[A-Z0-9]+$/.test(normalized)) {
+    return {
+      symmSymbol,
+      normalizedSymbol: normalized,
+      binanceSymbol: null,
+      supported: false,
+      reason: "invalid_symbol"
+    };
   }
-  const data = await response.json();
-  if (!data.access_token) {
-    throw new Error("No access token received");
+  if (UNSUPPORTED_SYMBOLS.has(normalized)) {
+    return {
+      symmSymbol,
+      normalizedSymbol: normalized,
+      binanceSymbol: null,
+      supported: false,
+      reason: "unsupported_symbol"
+    };
   }
+  const binanceSymbol = SYMBOL_OVERRIDES[normalized] ?? (normalized.endsWith("USDT") ? normalized : `${normalized}USDT`);
   return {
-    accessToken: data.access_token,
-    expirationTime: params.expirationTime,
-    issuedAt: params.issuedAt
+    symmSymbol,
+    normalizedSymbol: normalized,
+    binanceSymbol,
+    supported: true,
+    reason: null
   };
 }
-
-// src/react/auth.ts
-var TOKEN_STORAGE_PREFIX = "symm_access_token";
-var TOKEN_STORAGE_VERSION = 1;
-var tokenCache = /* @__PURE__ */ new Map();
-function cacheKey(address, chainId) {
-  return `${address}:${chainId}`;
+function getUnsupportedBinanceSymbols(symbols) {
+  return symbols.filter((symbol) => !resolveBinanceSymbol(symbol).supported);
 }
-function storageKey(address, chainId) {
-  return `${TOKEN_STORAGE_PREFIX}:${TOKEN_STORAGE_VERSION}:${cacheKey(address, chainId)}`;
+function toBinanceSymbol(symmSymbol) {
+  return resolveBinanceSymbol(symmSymbol).binanceSymbol;
 }
-function readStoredToken(address, chainId) {
-  if (typeof window === "undefined") return null;
-  try {
-    const raw = window.localStorage.getItem(storageKey(address, chainId));
-    if (!raw) return null;
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed.token !== "string" || typeof parsed.expiresAt !== "number") {
-      window.localStorage.removeItem(storageKey(address, chainId));
-      return null;
-    }
-    if (Date.now() >= parsed.expiresAt) {
-      window.localStorage.removeItem(storageKey(address, chainId));
-      return null;
+
+// src/utils/binance-ws.ts
+var BINANCE_WS_URL = "wss://fstream.binance.com/ws";
+var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var STABLE_QUOTES = ["USDT0", "USDT", "USDC", "USDE", "USDH", "USD"];
+function normalizeBaseSymbol(symbol) {
+  const normalized = symbol.toUpperCase().trim();
+  for (const quote of STABLE_QUOTES) {
+    if (normalized.endsWith(quote) && normalized.length > quote.length) {
+      return normalized.slice(0, -quote.length);
     }
-    return parsed;
-  } catch {
-    window.localStorage.removeItem(storageKey(address, chainId));
-    return null;
   }
+  return normalized;
 }
-function writeStoredToken(address, chainId, cached) {
-  if (typeof window === "undefined") return;
-  try {
-    window.localStorage.setItem(
-      storageKey(address, chainId),
-      JSON.stringify(cached)
-    );
-  } catch {
-  }
+function isBinanceMarkPriceTicker(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.s === "string" && typeof value.p === "string" && typeof value.i === "string" && typeof value.E === "number"
+  );
 }
-function getCachedToken(address, chainId) {
-  const cached = tokenCache.get(cacheKey(address, chainId));
-  if (cached && Date.now() < cached.expiresAt) {
-    return cached.token;
+function extractTickers(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter(isBinanceMarkPriceTicker);
   }
-  if (cached) {
-    tokenCache.delete(cacheKey(address, chainId));
+  if (payload && typeof payload === "object") {
+    const maybeData = payload.data;
+    if (Array.isArray(maybeData)) {
+      return maybeData.filter(isBinanceMarkPriceTicker);
+    }
+    return isBinanceMarkPriceTicker(payload) ? [payload] : [];
   }
-  const stored = readStoredToken(address, chainId);
-  if (!stored) return null;
-  tokenCache.set(cacheKey(address, chainId), stored);
-  return stored.token;
+  return [];
 }
-function clearCachedToken(address, chainId) {
-  tokenCache.delete(cacheKey(address, chainId));
-  if (typeof window !== "undefined") {
-    window.localStorage.removeItem(storageKey(address, chainId));
+var BinanceWsManager = class {
+  ws = null;
+  streams = /* @__PURE__ */ new Map();
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  intentionalClose = false;
+  pendingSubscribes = [];
+  idCounter = 0;
+  /**
+   * Subscribe to a kline stream. Returns an unsubscribe function.
+   */
+  subscribeKline(symbol, interval, cb) {
+    const streamName = `${symbol.toLowerCase()}@kline_${interval}`;
+    const id = this.generateId();
+    const wrappedCb = (raw) => {
+      const k = raw.k;
+      if (!k) return;
+      cb({
+        symbol: raw.s,
+        interval: k.i,
+        openTime: k.t,
+        closeTime: k.T,
+        open: parseFloat(k.o),
+        high: parseFloat(k.h),
+        low: parseFloat(k.l),
+        close: parseFloat(k.c),
+        volume: parseFloat(k.v),
+        isFinal: k.x
+      });
+    };
+    this.addStreamCallback(streamName, id, wrappedCb);
+    return () => this.removeStreamCallback(streamName, id);
   }
-}
-async function fetchAccessToken(walletClient, signerAddress, accountAddress, chainId, domain) {
-  const resolvedDomain = domain ?? (typeof window !== "undefined" ? window.location.host : "localhost");
-  const uri = typeof window !== "undefined" ? window.location.origin : `https://${resolvedDomain}`;
-  const nonce = await getNonce(chainId, accountAddress);
-  const { message, issuedAt, expirationTime } = createSiweMessage({
-    address: signerAddress,
-    statement: "Sign in to Symm Protocol",
-    chainId,
-    nonce,
-    domain: resolvedDomain,
-    uri
-  });
-  const signature = await walletClient.signMessage({
-    account: signerAddress,
-    message
-  });
-  const { accessToken } = await login(chainId, {
-    accountAddress,
-    signature,
-    expirationTime,
-    issuedAt,
-    nonce
-  });
-  const expiresAt = new Date(expirationTime).getTime();
-  const cachedToken = {
-    token: accessToken,
-    expiresAt: expiresAt - 6e4
-  };
-  tokenCache.set(cacheKey(accountAddress, chainId), cachedToken);
-  writeStoredToken(accountAddress, chainId, cachedToken);
-  return accessToken;
-}
-function symmAuthTokenKey(address, chainId) {
-  return `${address.toLowerCase()}:${chainId}`;
-}
-var useSymmAuthStore = zustand.create((set, get) => ({
-  tokensByKey: {},
-  setToken: (address, chainId, token) => {
-    const key = symmAuthTokenKey(address, chainId);
-    set((state) => ({
-      tokensByKey: {
-        ...state.tokensByKey,
-        [key]: token
+  /**
+   * Subscribe to a mark price stream (1s updates). Returns an unsubscribe function.
+   */
+  subscribeMarkPrice(symbol, cb) {
+    const streamName = `${symbol.toLowerCase()}@markPrice@1s`;
+    const id = this.generateId();
+    const wrappedCb = (raw) => {
+      cb({
+        symbol: normalizeBaseSymbol(raw.s),
+        markPrice: parseFloat(raw.p),
+        indexPrice: parseFloat(raw.i),
+        time: raw.E
+      });
+    };
+    this.addStreamCallback(streamName, id, wrappedCb);
+    return () => this.removeStreamCallback(streamName, id);
+  }
+  /**
+   * Subscribe to the all-market mark price stream (1s updates).
+   * Returns an unsubscribe function.
+   */
+  subscribeAllMarkPrices(cb) {
+    const streamName = "!markPrice@arr@1s";
+    const id = this.generateId();
+    const wrappedCb = (raw) => {
+      cb(
+        extractTickers(raw).map((entry) => ({
+          symbol: normalizeBaseSymbol(entry.s),
+          markPrice: parseFloat(entry.p),
+          indexPrice: parseFloat(entry.i),
+          time: entry.E
+        }))
+      );
+    };
+    this.addStreamCallback(streamName, id, wrappedCb);
+    return () => this.removeStreamCallback(streamName, id);
+  }
+  /**
+   * Destroy the manager and close the connection.
+   */
+  destroy() {
+    this.intentionalClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.streams.clear();
+  }
+  // --- Private ---
+  generateId() {
+    return `sub_${++this.idCounter}_${Date.now()}`;
+  }
+  addStreamCallback(streamName, id, cb) {
+    let sub = this.streams.get(streamName);
+    const isNew = !sub;
+    if (!sub) {
+      sub = { callbacks: /* @__PURE__ */ new Map() };
+      this.streams.set(streamName, sub);
+    }
+    sub.callbacks.set(id, cb);
+    if (isNew) {
+      this.ensureConnected();
+      this.sendSubscribe([streamName]);
+    }
+  }
+  removeStreamCallback(streamName, id) {
+    const sub = this.streams.get(streamName);
+    if (!sub) return;
+    sub.callbacks.delete(id);
+    if (sub.callbacks.size === 0) {
+      this.streams.delete(streamName);
+      this.sendUnsubscribe([streamName]);
+      if (this.streams.size === 0 && this.ws) {
+        this.intentionalClose = true;
+        this.ws.close();
+        this.ws = null;
+        this.intentionalClose = false;
       }
-    }));
-  },
-  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 ctx = useSymmContext();
-  const address = params?.address ?? ctx.address;
-  const chainId = params?.chainId ?? ctx.chainId ?? 42161;
-  const walletClient = params?.walletClient ?? ctx.walletClient;
-  const siweDomain = params?.siweDomain;
-  const accessToken = useSymmAuthStore((state) => {
-    if (address) {
-      return state.tokensByKey[symmAuthTokenKey(address, chainId)] ?? null;
+  ensureConnected() {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      return;
     }
-    return ctx.accessToken ?? ctx.authToken ?? null;
-  });
-  const setToken = useSymmAuthStore((state) => state.setToken);
-  const getToken = useSymmAuthStore((state) => state.getToken);
-  const clearToken = useSymmAuthStore((state) => state.clearToken);
-  const previousAddressRef = react.useRef(address);
-  const previousChainIdRef = react.useRef(chainId);
-  const refreshAuth = react.useCallback(
-    async (accountAddress) => {
-      if (!walletClient || !address) return null;
-      const resolvedAccountAddress = accountAddress ?? address;
-      const inMemory = getToken(resolvedAccountAddress, chainId);
-      if (inMemory) {
-        return inMemory;
+    this.connect();
+  }
+  connect() {
+    if (typeof WebSocket === "undefined") return;
+    this.intentionalClose = false;
+    this.ws = new WebSocket(BINANCE_WS_URL);
+    this.ws.onopen = () => {
+      this.reconnectAttempt = 0;
+      const activeStreams = Array.from(this.streams.keys());
+      if (activeStreams.length > 0) {
+        this.sendSubscribe(activeStreams);
       }
-      const cached = getCachedToken(resolvedAccountAddress, chainId);
-      if (cached) {
-        setToken(resolvedAccountAddress, chainId, cached);
-        return cached;
+      if (this.pendingSubscribes.length > 0) {
+        this.sendSubscribe(this.pendingSubscribes);
+        this.pendingSubscribes = [];
       }
+    };
+    this.ws.onmessage = (event) => {
       try {
-        const token = await fetchAccessToken(
-          walletClient,
-          address,
-          resolvedAccountAddress,
-          chainId,
-          siweDomain
-        );
-        setToken(resolvedAccountAddress, chainId, token);
-        return token;
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
       } catch {
-        clearToken(resolvedAccountAddress, chainId);
-        return null;
       }
-    },
-    [walletClient, address, chainId, siweDomain, getToken, setToken, clearToken]
-  );
-  const clearAuth = react.useCallback(() => {
-    if (address) {
-      clearCachedToken(address, chainId);
-      clearToken(address, chainId);
-    }
-  }, [address, chainId, clearToken]);
-  react.useEffect(() => {
-    const previousAddress = previousAddressRef.current;
-    const previousChainId = previousChainIdRef.current;
-    const addressChanged = previousAddress !== address;
-    const chainChanged = previousChainId !== chainId;
-    previousAddressRef.current = address;
-    previousChainIdRef.current = chainId;
-    if (!address || !walletClient) {
+    };
+    this.ws.onclose = () => {
+      if (this.intentionalClose) return;
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  handleMessage(data) {
+    if (Array.isArray(data)) {
+      this.dispatchToStream("!markPrice@arr@1s", data);
       return;
     }
-    if (previousAddress && (addressChanged || chainChanged)) {
-      clearCachedToken(previousAddress, previousChainId);
-      clearToken(previousAddress, previousChainId);
+    if (data.e === "kline") {
+      const k = data.k;
+      const streamName = `${data.s.toLowerCase()}@kline_${k.i}`;
+      this.dispatchToStream(streamName, data);
+    } else if (data.e === "markPriceUpdate") {
+      const streamName = `${data.s.toLowerCase()}@markPrice@1s`;
+      this.dispatchToStream(streamName, data);
     }
-    const cached = getCachedToken(address, chainId);
-    if (cached) {
-      setToken(address, chainId, cached);
-    } else {
-      clearToken(address, chainId);
+  }
+  dispatchToStream(streamName, data) {
+    const sub = this.streams.get(streamName);
+    if (!sub) return;
+    sub.callbacks.forEach((cb) => {
+      try {
+        cb(data);
+      } catch {
+      }
+    });
+  }
+  sendSubscribe(streams) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.pendingSubscribes.push(...streams);
+      return;
     }
-  }, [address, walletClient, chainId, setToken, clearToken]);
-  return {
-    accessToken,
-    authToken: accessToken,
-    isAuthenticated: !!accessToken,
-    refresh: refreshAuth,
-    refreshAuth,
-    clear: clearAuth
-  };
-}
-
-// 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
-];
-
+    this.ws.send(JSON.stringify({
+      method: "SUBSCRIBE",
+      params: streams,
+      id: Date.now()
+    }));
+  }
+  sendUnsubscribe(streams) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.pendingSubscribes = this.pendingSubscribes.filter(
+        (s) => !streams.includes(s)
+      );
+      return;
+    }
+    this.ws.send(JSON.stringify({
+      method: "UNSUBSCRIBE",
+      params: streams,
+      id: Date.now()
+    }));
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    if (this.streams.size === 0) return;
+    const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)];
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+};
+var _instance = null;
+function getBinanceWsManager() {
+  if (!_instance) {
+    _instance = new BinanceWsManager();
+  }
+  return _instance;
+}
+
+// src/react/stores/use-binance-mark-price-store.ts
+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 getNextRefCount(binanceSymbol) {
+  return (refCounts.get(binanceSymbol) ?? 0) + 1;
+}
+function getPrevRefCount(binanceSymbol) {
+  return Math.max(0, (refCounts.get(binanceSymbol) ?? 0) - 1);
+}
+var useBinanceMarkPriceStore = zustand.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 (allMarkPricesRefCount === 0) {
+      const wsManager = getBinanceWsManager();
+      allMarkPricesUnsubscribe = wsManager.subscribeAllMarkPrices((entries) => {
+        set((state) => {
+          let nextMarkPrices = null;
+          entries.forEach((entry) => {
+            const canonicalSymbol = normalizeBinanceSymbol(entry.symbol);
+            const mappedSymbols = streamSymbols.get(canonicalSymbol);
+            if (!mappedSymbols || mappedSymbols.size === 0) return;
+            nextMarkPrices ??= { ...state.markPrices };
+            mappedSymbols.forEach((mappedSymbol) => {
+              nextMarkPrices[mappedSymbol] = entry.markPrice;
+            });
+          });
+          return nextMarkPrices ? { markPrices: nextMarkPrices } : state;
+        });
+      });
+    }
+    allMarkPricesRefCount += 1;
+  },
+  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) {
+      refCounts.delete(binanceSymbol);
+    } else {
+      refCounts.set(binanceSymbol, nextRefCount);
+    }
+    allMarkPricesRefCount = Math.max(0, allMarkPricesRefCount - 1);
+    if (allMarkPricesRefCount === 0) {
+      allMarkPricesUnsubscribe?.();
+      allMarkPricesUnsubscribe = null;
+    }
+    set((state) => {
+      if (state.markPrices[symmSymbol] == null) return state;
+      const nextMarkPrices = { ...state.markPrices };
+      delete nextMarkPrices[symmSymbol];
+      return { markPrices: nextMarkPrices };
+    });
+  }
+}));
+
+// src/react/hooks/use-binance-ws.ts
+function useBinanceWs(params) {
+  const { symmCoreClient, chainId } = params;
+  const subscribeSymbol = useBinanceMarkPriceStore((state) => state.subscribeSymbol);
+  const unsubscribeSymbol = useBinanceMarkPriceStore((state) => state.unsubscribeSymbol);
+  react.useEffect(() => {
+    if (!symmCoreClient) {
+      return;
+    }
+    let cancelled = false;
+    let subscribedPairs = [];
+    const run = async () => {
+      try {
+        const result = await symmCoreClient.markets.listSymmHedger({ chainId });
+        if (cancelled) {
+          return;
+        }
+        const uniqueSymbols = Array.from(
+          new Set(
+            result.markets.map((market) => market.symbol).filter((symbol) => !!symbol)
+          )
+        );
+        subscribedPairs = uniqueSymbols.map((symbol) => {
+          const binanceSymbol = resolveBinanceSymbol(symbol).binanceSymbol;
+          if (!binanceSymbol) return null;
+          return [symbol, binanceSymbol];
+        }).filter((entry) => !!entry);
+        subscribedPairs.forEach(([symbol, binanceSymbol]) => {
+          subscribeSymbol(symbol, binanceSymbol);
+        });
+      } catch {
+      }
+    };
+    void run();
+    return () => {
+      cancelled = true;
+      subscribedPairs.forEach(([symbol, binanceSymbol]) => {
+        unsubscribeSymbol(symbol, binanceSymbol);
+      });
+    };
+  }, [symmCoreClient, chainId, subscribeSymbol, unsubscribeSymbol]);
+}
+function SymmProvider({
+  chainId = 42161,
+  address,
+  symmCoreConfig = {
+    apiUrl: "https://nginx-server-staging.up.railway.app",
+    wsUrl: "wss://nginx-server-staging.up.railway.app"
+  },
+  symmioConfig,
+  children
+}) {
+  const symmCoreClient = react.useMemo(() => {
+    return symmCore.createSymmSDK({
+      apiUrl: symmCoreConfig.apiUrl,
+      wsUrl: symmCoreConfig.wsUrl,
+      defaultChainId: chainId
+    });
+  }, [chainId, symmCoreConfig.apiUrl, symmCoreConfig.wsUrl]);
+  const value = react.useMemo(
+    () => ({
+      symmCoreClient,
+      chainId,
+      address,
+      symmioConfig
+    }),
+    [symmCoreClient, chainId, address, symmioConfig]
+  );
+  useBinanceWs({
+    symmCoreClient,
+    chainId
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(SymmContext.Provider, { value, children });
+}
+
+// src/react/hooks/use-symm-core-client.ts
+function useSymmCoreClient() {
+  return useSymmContext().symmCoreClient;
+}
+
+// src/constants/defaults.ts
+var GAS_MARGIN_PERCENTAGE = 20n;
+var MUON_BASE_URLS = [
+  "https://muon-oracle1.rasa.capital/v1/",
+  "https://muon-oracle2.rasa.capital/v1/",
+  "https://muon-oracle3.rasa.capital/v1/",
+  "https://muon-oracle4.rasa.capital/v1/"
+];
+var MUON_APP_NAME = "symmio";
+var MUON_REQUEST_TIMEOUT = 15e3;
+var HEDGER_BASE_URLS = {
+  [42161 /* ARBITRUM */]: "https://www.perps-streaming.com/v1/42161a/0x6273242a7E88b3De90822b31648C212215caaFE4",
+  [8453 /* BASE */]: "https://www.perps-streaming.com/v1/8453a/0x6273242a7E88b3De90822b31648C212215caaFE4"
+};
+
+// src/actions/instant.ts
+function getHedgerBaseUrl(chainId) {
+  const baseUrl = HEDGER_BASE_URLS[chainId];
+  if (!baseUrl) {
+    throw new Error(`No hedger base URL configured for chain ${chainId}.`);
+  }
+  return baseUrl;
+}
+function createSiweMessage(params) {
+  const version = params.version ?? "1";
+  const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const expirationTime = new Date(
+    Date.now() + 30 * 24 * 60 * 60 * 1e3
+  ).toISOString();
+  const message = [
+    `${params.domain} wants you to sign in with your Ethereum account:`,
+    params.address,
+    "",
+    params.statement,
+    "",
+    `URI: ${params.uri}`,
+    `Version: ${version}`,
+    `Chain ID: ${params.chainId}`,
+    `Nonce: ${params.nonce}`,
+    `Issued At: ${issuedAt}`,
+    `Expiration Time: ${expirationTime}`
+  ].join("\n");
+  return { message, issuedAt, expirationTime };
+}
+async function getNonce(chainId, subAccount) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL(`nonce/${subAccount}`, hedgerBaseUrl).href;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch nonce: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.nonce;
+}
+async function login(chainId, params) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL("login", hedgerBaseUrl).href;
+  const body = {
+    account_address: params.accountAddress,
+    expiration_time: params.expirationTime,
+    issued_at: params.issuedAt,
+    signature: params.signature,
+    nonce: params.nonce
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => null);
+    throw new Error(
+      errorData?.error_message ?? `Login failed: ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.access_token) {
+    throw new Error("No access token received");
+  }
+  return {
+    accessToken: data.access_token,
+    expirationTime: params.expirationTime,
+    issuedAt: params.issuedAt
+  };
+}
+
+// src/react/auth.ts
+var TOKEN_STORAGE_PREFIX = "symm_access_token";
+var TOKEN_STORAGE_VERSION = 1;
+var tokenCache = /* @__PURE__ */ new Map();
+function cacheKey(address, chainId) {
+  return `${address}:${chainId}`;
+}
+function storageKey(address, chainId) {
+  return `${TOKEN_STORAGE_PREFIX}:${TOKEN_STORAGE_VERSION}:${cacheKey(address, chainId)}`;
+}
+function readStoredToken(address, chainId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(storageKey(address, chainId));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.token !== "string" || typeof parsed.expiresAt !== "number") {
+      window.localStorage.removeItem(storageKey(address, chainId));
+      return null;
+    }
+    if (Date.now() >= parsed.expiresAt) {
+      window.localStorage.removeItem(storageKey(address, chainId));
+      return null;
+    }
+    return parsed;
+  } catch {
+    window.localStorage.removeItem(storageKey(address, chainId));
+    return null;
+  }
+}
+function writeStoredToken(address, chainId, cached) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(
+      storageKey(address, chainId),
+      JSON.stringify(cached)
+    );
+  } catch {
+  }
+}
+function getCachedToken(address, chainId) {
+  const cached = tokenCache.get(cacheKey(address, chainId));
+  if (cached && Date.now() < cached.expiresAt) {
+    return cached.token;
+  }
+  if (cached) {
+    tokenCache.delete(cacheKey(address, chainId));
+  }
+  const stored = readStoredToken(address, chainId);
+  if (!stored) return null;
+  tokenCache.set(cacheKey(address, chainId), stored);
+  return stored.token;
+}
+function clearCachedToken(address, chainId) {
+  tokenCache.delete(cacheKey(address, chainId));
+  if (typeof window !== "undefined") {
+    window.localStorage.removeItem(storageKey(address, chainId));
+  }
+}
+async function fetchAccessToken(walletClient, signerAddress, accountAddress, chainId, domain) {
+  const resolvedDomain = domain ?? (typeof window !== "undefined" ? window.location.host : "localhost");
+  const uri = typeof window !== "undefined" ? window.location.origin : `https://${resolvedDomain}`;
+  const nonce = await getNonce(chainId, accountAddress);
+  const { message, issuedAt, expirationTime } = createSiweMessage({
+    address: signerAddress,
+    statement: "Sign in to Symm Protocol",
+    chainId,
+    nonce,
+    domain: resolvedDomain,
+    uri
+  });
+  const signature = await walletClient.signMessage({
+    account: signerAddress,
+    message
+  });
+  const { accessToken } = await login(chainId, {
+    accountAddress,
+    signature,
+    expirationTime,
+    issuedAt,
+    nonce
+  });
+  const expiresAt = new Date(expirationTime).getTime();
+  const cachedToken = {
+    token: accessToken,
+    expiresAt: expiresAt - 6e4
+  };
+  tokenCache.set(cacheKey(accountAddress, chainId), cachedToken);
+  writeStoredToken(accountAddress, chainId, cachedToken);
+  return accessToken;
+}
+function symmAuthTokenKey(address, chainId) {
+  return `${address.toLowerCase()}:${chainId}`;
+}
+var useSymmAuthStore = zustand.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 ctx = useSymmContext();
+  const address = params?.address ?? ctx.address;
+  const chainId = params?.chainId ?? ctx.chainId ?? 42161;
+  const walletClient = params?.walletClient ?? ctx.walletClient;
+  const siweDomain = params?.siweDomain;
+  const accessToken = useSymmAuthStore((state) => {
+    if (address) {
+      return state.tokensByKey[symmAuthTokenKey(address, chainId)] ?? null;
+    }
+    return ctx.accessToken ?? ctx.authToken ?? null;
+  });
+  const setToken = useSymmAuthStore((state) => state.setToken);
+  const getToken = useSymmAuthStore((state) => state.getToken);
+  const clearToken = useSymmAuthStore((state) => state.clearToken);
+  const previousAddressRef = react.useRef(address);
+  const previousChainIdRef = react.useRef(chainId);
+  const refreshAuth = react.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) {
+        setToken(resolvedAccountAddress, chainId, cached);
+        return cached;
+      }
+      try {
+        const token = await fetchAccessToken(
+          walletClient,
+          address,
+          resolvedAccountAddress,
+          chainId,
+          siweDomain
+        );
+        setToken(resolvedAccountAddress, chainId, token);
+        return token;
+      } catch {
+        clearToken(resolvedAccountAddress, chainId);
+        return null;
+      }
+    },
+    [walletClient, address, chainId, siweDomain, getToken, setToken, clearToken]
+  );
+  const clearAuth = react.useCallback(() => {
+    if (address) {
+      clearCachedToken(address, chainId);
+      clearToken(address, chainId);
+    }
+  }, [address, chainId, clearToken]);
+  react.useEffect(() => {
+    const previousAddress = previousAddressRef.current;
+    const previousChainId = previousChainIdRef.current;
+    const addressChanged = previousAddress !== address;
+    const chainChanged = previousChainId !== chainId;
+    previousAddressRef.current = address;
+    previousChainIdRef.current = chainId;
+    if (!address || !walletClient) {
+      return;
+    }
+    if (previousAddress && (addressChanged || chainChanged)) {
+      clearCachedToken(previousAddress, previousChainId);
+      clearToken(previousAddress, previousChainId);
+    }
+    const cached = getCachedToken(address, chainId);
+    if (cached) {
+      setToken(address, chainId, cached);
+    } else {
+      clearToken(address, chainId);
+    }
+  }, [address, walletClient, chainId, setToken, clearToken]);
+  return {
+    accessToken,
+    authToken: accessToken,
+    isAuthenticated: !!accessToken,
+    refresh: refreshAuth,
+    refreshAuth,
+    clear: clearAuth
+  };
+}
+
+// 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/constants/addresses.ts
 var MULTI_ACCOUNT_ADDRESS = {
   [42161 /* ARBITRUM */]: "0x6273242a7E88b3De90822b31648C212215caaFE4",
@@ -24524,852 +24955,540 @@ function useSymmAccountSummary(params) {
       userAddress,
       chainId
     }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmAccountData(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { address, upnl } = params;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!address;
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.accountData(address, chainId, upnl),
-    queryFn: () => symmCoreClient.accounts.getData({
-      address,
-      chainId,
-      upnl
-    }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-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),
-    queryFn: () => symmCoreClient.accounts.getBalanceInfo({
-      userAddress,
-      chainId,
-      multiAccountAddress
-    }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useResolveTradeAuthToken() {
-  const context = useSymmContext();
-  const { address, chainId } = context;
-  const { refreshAuth } = useSymmAuth({ address, chainId });
-  const refreshAuthFromContext = context.refreshAuth;
-  return react.useCallback(
-    async (providedAuthToken, accountAddress) => {
-      if (providedAuthToken) {
-        return providedAuthToken;
-      }
-      const resolvedAccountAddress = accountAddress ?? address;
-      if (!resolvedAccountAddress) {
-        return null;
-      }
-      const inMemoryToken = useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId);
-      if (inMemoryToken) {
-        return inMemoryToken;
-      }
-      if (refreshAuthFromContext) {
-        return refreshAuthFromContext(resolvedAccountAddress);
-      }
-      return refreshAuth(resolvedAccountAddress);
-    },
-    [address, chainId, refreshAuth, refreshAuthFromContext]
-  );
-}
-function useSymmOpenBasketMutation(options) {
-  const { symmCoreClient } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        invalidatePositions(queryClient);
-      }
-    }),
-    mutationFn: async (request) => {
-      if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.positions.openBasket(request);
-    }
-  });
-}
-function useSymmClosePositionMutation(options) {
-  const { symmCoreClient } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
-  const resolveAuthToken = useResolveTradeAuthToken();
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        invalidatePositions(queryClient);
-      }
-    }),
-    mutationFn: async (request) => {
-      if (!symmCoreClient) throw new Error("symm-core client not available");
-      const typedRequest = request;
-      const authToken = await resolveAuthToken(
-        typedRequest.authToken,
-        typedRequest.accountAddress
-      );
-      if (!authToken) {
-        throw new Error("auth token is required to close a position");
-      }
-      return symmCoreClient.positions.close({
-        ...request,
-        authToken
-      });
-    }
-  });
-}
-function useSymmCloseAllPositionsMutation(options) {
-  const { symmCoreClient } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        invalidatePositions(queryClient);
-      }
-    }),
-    mutationFn: async (request) => {
-      if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.positions.closeAll(request);
-    }
-  });
-}
-function useSymmCancelOpenMutation(options) {
-  const { symmCoreClient } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        invalidatePositions(queryClient);
-      }
-    }),
-    mutationFn: async (request) => {
-      if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.positions.cancelOpen(request);
-    }
-  });
-}
-function useSymmUpdatePositionMutation(options) {
-  const { symmCoreClient } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
-  const resolveAuthToken = useResolveTradeAuthToken();
-  return reactQuery.useMutation({
-    ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        invalidatePositions(queryClient);
-      }
-    }),
-    mutationFn: async ({
-      positionId,
-      request
-    }) => {
-      if (!symmCoreClient) throw new Error("symm-core client not available");
-      const typedRequest = request;
-      const authToken = await resolveAuthToken(
-        typedRequest.authToken,
-        typedRequest.accountAddress
-      );
-      if (!authToken) {
-        throw new Error("auth token is required to update a position");
-      }
-      return symmCoreClient.positions.update(positionId, {
-        ...request,
-        authToken
-      });
-    }
-  });
-}
-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
+    enabled: internalEnabled && (params.query?.enabled ?? true)
   });
 }
-function useSymmOpenOrders(params) {
+function useSymmAccountData(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress, address } = params;
-  const resolvedAddress = accountAddress ? void 0 : address;
+  const { address, upnl } = params;
   const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  const internalEnabled = !!symmCoreClient && !!address;
   return reactQuery.useQuery({
     ...params.query,
-    queryKey: symmKeys.openOrders({
-      accountAddress,
-      address: resolvedAddress,
-      chainId
-    }),
-    queryFn: () => symmCoreClient.orders.list({
-      address: accountAddress ?? resolvedAddress,
-      chainId
+    queryKey: symmKeys.accountData(address, chainId, upnl),
+    queryFn: () => symmCoreClient.accounts.getData({
+      address,
+      chainId,
+      upnl
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
 }
-function useSymmTradeHistory(params) {
+function useSymmBalances(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress, address } = params;
-  const resolvedAddress = accountAddress ? void 0 : address;
+  const { userAddress, multiAccountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  const internalEnabled = !!symmCoreClient && !!userAddress;
   return reactQuery.useQuery({
     ...params.query,
-    queryKey: symmKeys.tradeHistory({
-      accountAddress,
-      address: resolvedAddress,
-      chainId
+    queryKey: symmKeys.balances(userAddress, chainId),
+    queryFn: () => symmCoreClient.accounts.getBalanceInfo({
+      userAddress,
+      chainId,
+      multiAccountAddress
     }),
-    queryFn: () => {
-      const request = {
-        accountAddress,
-        address: resolvedAddress,
-        chainId
-      };
-      return symmCoreClient.positions.getTradeHistory(request);
-    },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
 }
-function useSymmSetTpslMutation(options) {
+function useResolveTradeAuthToken() {
+  const context = useSymmContext();
+  const { address, chainId } = context;
+  const { refreshAuth } = useSymmAuth({ address, chainId });
+  const refreshAuthFromContext = context.refreshAuth;
+  return react.useCallback(
+    async (providedAuthToken, accountAddress) => {
+      if (providedAuthToken) {
+        return providedAuthToken;
+      }
+      const resolvedAccountAddress = accountAddress ?? address;
+      if (!resolvedAccountAddress) {
+        return null;
+      }
+      const inMemoryToken = useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId);
+      if (inMemoryToken) {
+        return inMemoryToken;
+      }
+      if (refreshAuthFromContext) {
+        return refreshAuthFromContext(resolvedAccountAddress);
+      }
+      return refreshAuth(resolvedAccountAddress);
+    },
+    [address, chainId, refreshAuth, refreshAuthFromContext]
+  );
+}
+function useSymmOpenBasketMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
-        invalidateOrders(queryClient);
         invalidatePositions(queryClient);
       }
     }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.orders.setTpsl(request);
+      return symmCoreClient.positions.openBasket(request);
     }
   });
 }
-function useSymmCancelTpslMutation(options) {
+function useSymmClosePositionMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
+  const resolveAuthToken = useResolveTradeAuthToken();
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
-        invalidateOrders(queryClient);
         invalidatePositions(queryClient);
       }
     }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.orders.cancelTpsl(request);
+      const typedRequest = request;
+      const authToken = await resolveAuthToken(
+        typedRequest.authToken,
+        typedRequest.accountAddress
+      );
+      if (!authToken) {
+        throw new Error("auth token is required to close a position");
+      }
+      return symmCoreClient.positions.close({
+        ...request,
+        authToken
+      });
     }
   });
 }
-function useSymmTpslOrders(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress, address, positionId, type, status } = params;
-  const resolvedAddress = accountAddress ? void 0 : address;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress || positionId);
-  const request = {
-    address: accountAddress ?? resolvedAddress,
-    positionId,
-    type,
-    status,
-    chainId
-  };
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.tpslOrdersList({
-      accountAddress,
-      address: resolvedAddress,
-      positionId,
-      type,
-      status,
-      chainId
-    }),
-    queryFn: () => symmCoreClient.orders.getTpslOrders(request),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useResolvedTwapParams(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress, address } = params;
-  const resolvedAddress = accountAddress ? void 0 : address;
-  const chainId = params.chainId ?? ctxChainId;
-  return { symmCoreClient, accountAddress, resolvedAddress, chainId, query: params.query };
-}
-function useSymmTwapOrdersQuery(params) {
-  const { symmCoreClient, accountAddress, resolvedAddress, chainId, query } = useResolvedTwapParams(params);
-  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  return reactQuery.useQuery({
-    ...query,
-    queryKey: symmKeys.twapOrders(accountAddress ?? resolvedAddress, chainId),
-    queryFn: () => symmCoreClient.orders.getTwapOrders({
-      address: accountAddress ?? resolvedAddress,
-      chainId
-    }),
-    enabled: internalEnabled && (query?.enabled ?? true)
-  });
-}
-function useSymmCancelTwapOrderMutation(options) {
+function useSymmCloseAllPositionsMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
-        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
       }
     }),
-    mutationFn: async (orderId) => {
+    mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.orders.cancelTwapOrder(orderId);
+      return symmCoreClient.positions.closeAll(request);
     }
   });
 }
-function useSymmTriggerConfigQuery(params) {
-  const { symmCoreClient } = useSymmContext();
-  const { orderId } = params;
-  const internalEnabled = !!symmCoreClient && !!orderId;
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.triggerConfig(orderId),
-    queryFn: () => symmCoreClient.orders.getTriggerConfig(orderId),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmSetTriggerConfigMutation(params, options) {
+function useSymmCancelOpenMutation(options) {
   const { symmCoreClient } = useSymmContext();
-  const { orderId } = params;
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.triggerConfig(orderId)
-        });
-        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
       }
     }),
     mutationFn: async (request) => {
-      if (!symmCoreClient || !orderId) {
-        throw new Error("symm-core client or orderId not available");
-      }
-      return symmCoreClient.orders.setTriggerConfig(orderId, request);
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      return symmCoreClient.positions.cancelOpen(request);
     }
   });
 }
-function useSymmClearTriggerConfigMutation(params, options) {
+function useSymmUpdatePositionMutation(options) {
   const { symmCoreClient } = useSymmContext();
-  const { orderId } = params;
   const queryClient = reactQuery.useQueryClient();
+  const resolveAuthToken = useResolveTradeAuthToken();
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
-        queryClient.invalidateQueries({
-          queryKey: symmKeys.triggerConfig(orderId)
-        });
-        invalidateOrders(queryClient);
-      }
-    }),
-    mutationFn: async () => {
-      if (!symmCoreClient || !orderId) {
-        throw new Error("symm-core client or orderId not available");
+        invalidatePositions(queryClient);
       }
-      return symmCoreClient.orders.clearTriggerConfig(orderId);
-    }
-  });
-}
-function useSymmTriggerOrders(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { accountAddress, address, status, limit, offset } = params;
-  const resolvedAddress = accountAddress ? void 0 : address;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const request = {
-    address: accountAddress ?? resolvedAddress,
-    chainId,
-    status,
-    limit,
-    offset
-  };
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.triggerOrders({
-      accountAddress,
-      address: resolvedAddress,
-      chainId,
-      status,
-      limit,
-      offset
     }),
-    queryFn: () => symmCoreClient.orders.listTriggerOrders(request),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmMarkets(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const chainId = params?.chainId ?? ctxChainId;
-  const searchText = params?.searchText;
-  const internalEnabled = !!symmCoreClient;
-  return reactQuery.useQuery({
-    ...params?.query,
-    queryKey: symmKeys.markets(chainId, searchText),
-    queryFn: () => {
-      if (searchText) {
-        return symmCoreClient.markets.search(searchText, { chainId });
-      }
-      return symmCoreClient.markets.list({ pageSize: "1000", chainId });
-    },
-    enabled: internalEnabled && (params?.query?.enabled ?? true)
-  });
-}
-function useSymmHedgerMarketById(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { id } = params;
-  const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && id != null;
-  return reactQuery.useQuery({
-    ...params.query,
-    queryKey: symmKeys.hedgerMarketById(id, chainId),
-    queryFn: () => symmCoreClient.markets.getById(id, chainId),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    mutationFn: async ({
+      positionId,
+      request
+    }) => {
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      const typedRequest = request;
+      const authToken = await resolveAuthToken(
+        typedRequest.authToken,
+        typedRequest.accountAddress
+      );
+      if (!authToken) {
+        throw new Error("auth token is required to update a position");
+      }
+      return symmCoreClient.positions.update(positionId, {
+        ...request,
+        authToken
+      });
+    }
   });
 }
-function useSymmHedgerMarketBySymbol(params) {
+function useSymmPositions(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { symbol } = params;
+  const { accountAddress, address } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!symbol;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  const enabled = internalEnabled && (params.query?.enabled ?? true);
   return reactQuery.useQuery({
     ...params.query,
-    queryKey: symmKeys.hedgerMarketBySymbol(symbol, chainId),
-    queryFn: () => symmCoreClient.markets.getBySymbol(symbol, chainId),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    queryKey: symmKeys.positions({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
+    }),
+    queryFn: () => symmCoreClient.positions.getOpen({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
+    }),
+    enabled
   });
 }
-function useSymmLockedParams(params) {
+function useSymmOpenOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const { marketName, leverage } = params;
+  const { accountAddress, address } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
-  const internalEnabled = !!symmCoreClient && !!marketName && leverage != null;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
   return reactQuery.useQuery({
     ...params.query,
-    queryKey: symmKeys.lockedParams(marketName, leverage, chainId),
-    queryFn: () => symmCoreClient.markets.getLockedParams({
-      marketName,
-      leverage,
+    queryKey: symmKeys.openOrders({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
+    }),
+    queryFn: () => symmCoreClient.orders.list({
+      address: accountAddress ?? resolvedAddress,
       chainId
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
-  });
-}
-function useSymmHedgerMarkets(params) {
-  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const chainId = params?.chainId ?? ctxChainId;
-  const searchText = params?.searchText?.trim();
-  const consumerEnabled = params?.query?.enabled ?? params?.enabled ?? true;
-  const { enabled: _, query: __, ...restParams } = params ?? {};
-  const request = {
-    ...restParams,
-    chainId,
-    searchText: searchText || void 0
-  };
-  const internalEnabled = !!symmCoreClient;
-  return reactQuery.useQuery({
-    ...params?.query,
-    queryKey: symmKeys.hedgerMarkets(request),
-    queryFn: () => symmCoreClient.markets.listSymmHedger(request),
-    enabled: internalEnabled && consumerEnabled
-  });
-}
-
-// src/utils/binance-api.ts
-var BINANCE_FAPI_BASE = "https://fapi.binance.com";
-async function fetchMarkPriceKlines(symbol, interval, startTime, endTime, limit = 1500) {
-  const params = new URLSearchParams({
-    symbol,
-    interval,
-    startTime: String(startTime),
-    endTime: String(endTime),
-    limit: String(Math.min(limit, 1500))
-  });
-  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/markPriceKlines?${params}`);
-  if (!response.ok) {
-    throw new Error(`Binance markPriceKlines failed: ${response.status}`);
-  }
-  const data = await response.json();
-  return data.map((k) => ({
-    openTime: Number(k[0]),
-    open: parseFloat(k[1]),
-    high: parseFloat(k[2]),
-    low: parseFloat(k[3]),
-    close: parseFloat(k[4]),
-    volume: parseFloat(k[5]),
-    closeTime: Number(k[6])
-  }));
-}
-async function fetch24hrTicker(symbol) {
-  const params = new URLSearchParams({ symbol });
-  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/ticker/24hr?${params}`);
-  if (!response.ok) return null;
-  const data = await response.json();
-  return {
-    lastPrice: parseFloat(data.lastPrice),
-    prevClosePrice: parseFloat(data.prevClosePrice),
-    priceChangePercent: parseFloat(data.priceChangePercent)
-  };
-}
-
-// src/utils/binance-symbol-map.ts
-var SYMBOL_OVERRIDES = {
-  // Add overrides here as needed for SYMM markets that don't map 1:1 to Binance
-  // e.g., 'SOME_SYMM_SYMBOL': 'BINANCE_SYMBOL',
-};
-var UNSUPPORTED_SYMBOLS = /* @__PURE__ */ new Set([
-  // Add symbols here that have no Binance equivalent
-]);
-function resolveBinanceSymbol(symmSymbol) {
-  if (!symmSymbol || !symmSymbol.trim()) {
-    return {
-      symmSymbol,
-      normalizedSymbol: "",
-      binanceSymbol: null,
-      supported: false,
-      reason: "missing_symbol"
-    };
-  }
-  const normalized = symmSymbol.toUpperCase().trim();
-  if (!/^[A-Z0-9]+$/.test(normalized)) {
-    return {
-      symmSymbol,
-      normalizedSymbol: normalized,
-      binanceSymbol: null,
-      supported: false,
-      reason: "invalid_symbol"
-    };
-  }
-  if (UNSUPPORTED_SYMBOLS.has(normalized)) {
-    return {
-      symmSymbol,
-      normalizedSymbol: normalized,
-      binanceSymbol: null,
-      supported: false,
-      reason: "unsupported_symbol"
-    };
-  }
-  const binanceSymbol = SYMBOL_OVERRIDES[normalized] ?? (normalized.endsWith("USDT") ? normalized : `${normalized}USDT`);
-  return {
-    symmSymbol,
-    normalizedSymbol: normalized,
-    binanceSymbol,
-    supported: true,
-    reason: null
-  };
-}
-function getUnsupportedBinanceSymbols(symbols) {
-  return symbols.filter((symbol) => !resolveBinanceSymbol(symbol).supported);
-}
-function toBinanceSymbol(symmSymbol) {
-  return resolveBinanceSymbol(symmSymbol).binanceSymbol;
-}
-
-// src/utils/binance-ws.ts
-var BINANCE_WS_URL = "wss://fstream.binance.com/ws";
-var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
-var BinanceWsManager = class {
-  ws = null;
-  streams = /* @__PURE__ */ new Map();
-  reconnectAttempt = 0;
-  reconnectTimer = null;
-  intentionalClose = false;
-  pendingSubscribes = [];
-  idCounter = 0;
-  /**
-   * Subscribe to a kline stream. Returns an unsubscribe function.
-   */
-  subscribeKline(symbol, interval, cb) {
-    const streamName = `${symbol.toLowerCase()}@kline_${interval}`;
-    const id = this.generateId();
-    const wrappedCb = (raw) => {
-      const k = raw.k;
-      if (!k) return;
-      cb({
-        symbol: raw.s,
-        interval: k.i,
-        openTime: k.t,
-        closeTime: k.T,
-        open: parseFloat(k.o),
-        high: parseFloat(k.h),
-        low: parseFloat(k.l),
-        close: parseFloat(k.c),
-        volume: parseFloat(k.v),
-        isFinal: k.x
-      });
-    };
-    this.addStreamCallback(streamName, id, wrappedCb);
-    return () => this.removeStreamCallback(streamName, id);
-  }
-  /**
-   * Subscribe to a mark price stream (1s updates). Returns an unsubscribe function.
-   */
-  subscribeMarkPrice(symbol, cb) {
-    const streamName = `${symbol.toLowerCase()}@markPrice@1s`;
-    const id = this.generateId();
-    const wrappedCb = (raw) => {
-      cb({
-        symbol: raw.s,
-        markPrice: parseFloat(raw.p),
-        indexPrice: parseFloat(raw.i),
-        time: raw.E
-      });
-    };
-    this.addStreamCallback(streamName, id, wrappedCb);
-    return () => this.removeStreamCallback(streamName, id);
-  }
-  /**
-   * Destroy the manager and close the connection.
-   */
-  destroy() {
-    this.intentionalClose = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    this.streams.clear();
-  }
-  // --- Private ---
-  generateId() {
-    return `sub_${++this.idCounter}_${Date.now()}`;
-  }
-  addStreamCallback(streamName, id, cb) {
-    let sub = this.streams.get(streamName);
-    const isNew = !sub;
-    if (!sub) {
-      sub = { callbacks: /* @__PURE__ */ new Map() };
-      this.streams.set(streamName, sub);
-    }
-    sub.callbacks.set(id, cb);
-    if (isNew) {
-      this.ensureConnected();
-      this.sendSubscribe([streamName]);
-    }
-  }
-  removeStreamCallback(streamName, id) {
-    const sub = this.streams.get(streamName);
-    if (!sub) return;
-    sub.callbacks.delete(id);
-    if (sub.callbacks.size === 0) {
-      this.streams.delete(streamName);
-      this.sendUnsubscribe([streamName]);
-      if (this.streams.size === 0 && this.ws) {
-        this.intentionalClose = true;
-        this.ws.close();
-        this.ws = null;
-        this.intentionalClose = false;
+  });
+}
+function useSymmTradeHistory(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);
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.tradeHistory({
+      accountAddress,
+      address: resolvedAddress,
+      chainId
+    }),
+    queryFn: () => {
+      const request = {
+        accountAddress,
+        address: resolvedAddress,
+        chainId
+      };
+      return symmCoreClient.positions.getTradeHistory(request);
+    },
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmSetTpslMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
       }
+    }),
+    mutationFn: async (request) => {
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      return symmCoreClient.orders.setTpsl(request);
     }
-  }
-  ensureConnected() {
-    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
-      return;
+  });
+}
+function useSymmCancelTpslMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
+    mutationFn: async (request) => {
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      return symmCoreClient.orders.cancelTpsl(request);
     }
-    this.connect();
-  }
-  connect() {
-    if (typeof WebSocket === "undefined") return;
-    this.intentionalClose = false;
-    this.ws = new WebSocket(BINANCE_WS_URL);
-    this.ws.onopen = () => {
-      this.reconnectAttempt = 0;
-      const activeStreams = Array.from(this.streams.keys());
-      if (activeStreams.length > 0) {
-        this.sendSubscribe(activeStreams);
+  });
+}
+function useSymmTpslOrders(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { accountAddress, address, positionId, type, status } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress || positionId);
+  const request = {
+    address: accountAddress ?? resolvedAddress,
+    positionId,
+    type,
+    status,
+    chainId
+  };
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.tpslOrdersList({
+      accountAddress,
+      address: resolvedAddress,
+      positionId,
+      type,
+      status,
+      chainId
+    }),
+    queryFn: () => symmCoreClient.orders.getTpslOrders(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useResolvedTwapParams(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { accountAddress, address } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
+  const chainId = params.chainId ?? ctxChainId;
+  return { symmCoreClient, accountAddress, resolvedAddress, chainId, query: params.query };
+}
+function useSymmTwapOrdersQuery(params) {
+  const { symmCoreClient, accountAddress, resolvedAddress, chainId, query } = useResolvedTwapParams(params);
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  return reactQuery.useQuery({
+    ...query,
+    queryKey: symmKeys.twapOrders(accountAddress ?? resolvedAddress, chainId),
+    queryFn: () => symmCoreClient.orders.getTwapOrders({
+      address: accountAddress ?? resolvedAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (query?.enabled ?? true)
+  });
+}
+function useSymmCancelTwapOrderMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
       }
-      if (this.pendingSubscribes.length > 0) {
-        this.sendSubscribe(this.pendingSubscribes);
-        this.pendingSubscribes = [];
+    }),
+    mutationFn: async (orderId) => {
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      return symmCoreClient.orders.cancelTwapOrder(orderId);
+    }
+  });
+}
+function useSymmTriggerConfigQuery(params) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const internalEnabled = !!symmCoreClient && !!orderId;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.triggerConfig(orderId),
+    queryFn: () => symmCoreClient.orders.getTriggerConfig(orderId),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmSetTriggerConfigMutation(params, options) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.triggerConfig(orderId)
+        });
+        invalidateOrders(queryClient);
       }
-    };
-    this.ws.onmessage = (event) => {
-      try {
-        const data = JSON.parse(event.data);
-        this.handleMessage(data);
-      } catch {
+    }),
+    mutationFn: async (request) => {
+      if (!symmCoreClient || !orderId) {
+        throw new Error("symm-core client or orderId not available");
       }
-    };
-    this.ws.onclose = () => {
-      if (this.intentionalClose) return;
-      this.scheduleReconnect();
-    };
-    this.ws.onerror = () => {
-    };
-  }
-  handleMessage(data) {
-    if (data.e === "kline") {
-      const k = data.k;
-      const streamName = `${data.s.toLowerCase()}@kline_${k.i}`;
-      this.dispatchToStream(streamName, data);
-    } else if (data.e === "markPriceUpdate") {
-      const streamName = `${data.s.toLowerCase()}@markPrice@1s`;
-      this.dispatchToStream(streamName, data);
+      return symmCoreClient.orders.setTriggerConfig(orderId, request);
     }
-  }
-  dispatchToStream(streamName, data) {
-    const sub = this.streams.get(streamName);
-    if (!sub) return;
-    sub.callbacks.forEach((cb) => {
-      try {
-        cb(data);
-      } catch {
+  });
+}
+function useSymmClearTriggerConfigMutation(params, options) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.triggerConfig(orderId)
+        });
+        invalidateOrders(queryClient);
       }
-    });
-  }
-  sendSubscribe(streams) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.pendingSubscribes.push(...streams);
-      return;
-    }
-    this.ws.send(JSON.stringify({
-      method: "SUBSCRIBE",
-      params: streams,
-      id: Date.now()
-    }));
-  }
-  sendUnsubscribe(streams) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.pendingSubscribes = this.pendingSubscribes.filter(
-        (s) => !streams.includes(s)
-      );
-      return;
+    }),
+    mutationFn: async () => {
+      if (!symmCoreClient || !orderId) {
+        throw new Error("symm-core client or orderId not available");
+      }
+      return symmCoreClient.orders.clearTriggerConfig(orderId);
     }
-    this.ws.send(JSON.stringify({
-      method: "UNSUBSCRIBE",
-      params: streams,
-      id: Date.now()
-    }));
-  }
-  scheduleReconnect() {
-    if (this.reconnectTimer) return;
-    if (this.streams.size === 0) return;
-    const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)];
-    this.reconnectAttempt++;
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.connect();
-    }, delay);
-  }
-};
-var _instance = null;
-function getBinanceWsManager() {
-  if (!_instance) {
-    _instance = new BinanceWsManager();
-  }
-  return _instance;
+  });
+}
+function useSymmTriggerOrders(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { accountAddress, address, status, limit, offset } = params;
+  const resolvedAddress = accountAddress ? void 0 : address;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
+  const request = {
+    address: accountAddress ?? resolvedAddress,
+    chainId,
+    status,
+    limit,
+    offset
+  };
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.triggerOrders({
+      accountAddress,
+      address: resolvedAddress,
+      chainId,
+      status,
+      limit,
+      offset
+    }),
+    queryFn: () => symmCoreClient.orders.listTriggerOrders(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
 }
-
-// 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 useSymmMarkets(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  const searchText = params?.searchText;
+  const internalEnabled = !!symmCoreClient;
+  return reactQuery.useQuery({
+    ...params?.query,
+    queryKey: symmKeys.markets(chainId, searchText),
+    queryFn: () => {
+      if (searchText) {
+        return symmCoreClient.markets.search(searchText, { chainId });
+      }
+      return symmCoreClient.markets.list({ pageSize: "1000", chainId });
+    },
+    enabled: internalEnabled && (params?.query?.enabled ?? true)
+  });
 }
-function getNextRefCount(binanceSymbol) {
-  return (refCounts.get(binanceSymbol) ?? 0) + 1;
+function useSymmHedgerMarketById(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { id } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && id != null;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.hedgerMarketById(id, chainId),
+    queryFn: () => symmCoreClient.markets.getById(id, chainId),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
 }
-function getPrevRefCount(binanceSymbol) {
-  return Math.max(0, (refCounts.get(binanceSymbol) ?? 0) - 1);
+function useSymmHedgerMarketBySymbol(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { symbol } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!symbol;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.hedgerMarketBySymbol(symbol, chainId),
+    queryFn: () => symmCoreClient.markets.getBySymbol(symbol, chainId),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmLockedParams(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { marketName, leverage } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!marketName && leverage != null;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.lockedParams(marketName, leverage, chainId),
+    queryFn: () => symmCoreClient.markets.getLockedParams({
+      marketName,
+      leverage,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmHedgerMarkets(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  const searchText = params?.searchText?.trim();
+  const consumerEnabled = params?.query?.enabled ?? params?.enabled ?? true;
+  const { enabled: _, query: __, ...restParams } = params ?? {};
+  const request = {
+    ...restParams,
+    chainId,
+    searchText: searchText || void 0
+  };
+  const internalEnabled = !!symmCoreClient;
+  return reactQuery.useQuery({
+    ...params?.query,
+    queryKey: symmKeys.hedgerMarkets(request),
+    queryFn: () => symmCoreClient.markets.listSymmHedger(request),
+    enabled: internalEnabled && consumerEnabled
+  });
 }
-var useBinanceMarkPriceStore = zustand.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-markets.ts
-async function fetchTickerSnapshot(symbol) {
-  const resolution = resolveBinanceSymbol(symbol);
-  if (!resolution.binanceSymbol) return null;
-  const ticker = await fetch24hrTicker(resolution.binanceSymbol);
-  if (!ticker) return null;
+// src/utils/binance-api.ts
+var BINANCE_FAPI_BASE = "https://fapi.binance.com";
+async function fetchMarkPriceKlines(symbol, interval, startTime, endTime, limit = 1500) {
+  const params = new URLSearchParams({
+    symbol,
+    interval,
+    startTime: String(startTime),
+    endTime: String(endTime),
+    limit: String(Math.min(limit, 1500))
+  });
+  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/markPriceKlines?${params}`);
+  if (!response.ok) {
+    throw new Error(`Binance markPriceKlines failed: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.map((k) => ({
+    openTime: Number(k[0]),
+    open: parseFloat(k[1]),
+    high: parseFloat(k[2]),
+    low: parseFloat(k[3]),
+    close: parseFloat(k[4]),
+    volume: parseFloat(k[5]),
+    closeTime: Number(k[6])
+  }));
+}
+async function fetch24hrTicker(symbol) {
+  const params = new URLSearchParams({ symbol });
+  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/ticker/24hr?${params}`);
+  if (!response.ok) return null;
+  const data = await response.json();
   return {
-    prevClosePrice: ticker.prevClosePrice
+    lastPrice: parseFloat(data.lastPrice),
+    prevClosePrice: parseFloat(data.prevClosePrice),
+    priceChangePercent: parseFloat(data.priceChangePercent)
   };
 }
+async function fetch24hrTickers() {
+  const response = await fetch(`${BINANCE_FAPI_BASE}/fapi/v1/ticker/24hr`);
+  if (!response.ok) {
+    throw new Error(`Binance 24hr tickers failed: ${response.status}`);
+  }
+  const data = await response.json();
+  const result = {};
+  for (const item of data) {
+    result[item.symbol] = {
+      lastPrice: parseFloat(item.lastPrice),
+      prevClosePrice: parseFloat(item.prevClosePrice),
+      priceChangePercent: parseFloat(item.priceChangePercent)
+    };
+  }
+  return result;
+}
+
+// src/react/hooks/use-symm-token-selection-markets.ts
 function useSymmTokenSelectionMarkets(params) {
   const query = useSymmHedgerMarkets(params);
   const baseMarkets = query.data?.filteredMarkets ?? query.data?.markets ?? [];
@@ -25385,48 +25504,27 @@ function useSymmTokenSelectionMarkets(params) {
     () => [...marketSymbols].sort().join(","),
     [marketSymbols]
   );
-  const symbolToBinanceMap = react.useMemo(
-    () => new Map(
-      marketSymbols.map((symbol) => {
-        const binanceSymbol = resolveBinanceSymbol(symbol).binanceSymbol;
-        if (!binanceSymbol) return null;
-        return [symbol, binanceSymbol];
-      }).filter((entry) => !!entry)
-    ),
-    [marketSymbols]
-  );
   const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
-  const subscribeSymbol = useBinanceMarkPriceStore((state) => state.subscribeSymbol);
-  const unsubscribeSymbol = useBinanceMarkPriceStore((state) => state.unsubscribeSymbol);
   const priceQuery = reactQuery.useQuery({
     queryKey: ["symm", "token-selection-markets-price", symbolsKey],
     queryFn: async () => {
+      const allTickers = await fetch24hrTickers();
       const tickerSnapshots = {};
-      await Promise.all(
-        marketSymbols.map(async (symbol) => {
-          tickerSnapshots[symbol] = await fetchTickerSnapshot(symbol);
-        })
-      );
+      marketSymbols.forEach((symbol) => {
+        const binanceSymbol = resolveBinanceSymbol(symbol).binanceSymbol;
+        if (!binanceSymbol) {
+          tickerSnapshots[symbol] = null;
+          return;
+        }
+        const ticker = allTickers[binanceSymbol];
+        tickerSnapshots[symbol] = ticker ? { prevClosePrice: ticker.prevClosePrice } : null;
+      });
       return { tickerSnapshots };
     },
     enabled: query.isSuccess && marketSymbols.length > 0,
     staleTime: 6e4,
     gcTime: 5 * 6e4
   });
-  react.useEffect(() => {
-    if (!query.isSuccess || symbolToBinanceMap.size === 0) {
-      return;
-    }
-    const symbolEntries = Array.from(symbolToBinanceMap.entries());
-    symbolEntries.forEach(
-      ([symbol, binanceSymbol]) => subscribeSymbol(symbol, binanceSymbol)
-    );
-    return () => {
-      symbolEntries.forEach(
-        ([symbol, binanceSymbol]) => unsubscribeSymbol(symbol, binanceSymbol)
-      );
-    };
-  }, [query.isSuccess, symbolsKey, symbolToBinanceMap, subscribeSymbol, unsubscribeSymbol]);
   const markets = react.useMemo(() => {
     const snapshots = priceQuery.data?.tickerSnapshots ?? {};
     return baseMarkets.map((market) => {
@@ -25455,6 +25553,61 @@ function useSymmTokenSelectionMarkets(params) {
     () => new Map(markets.map((market) => [market.id, market])),
     [markets]
   );
+  react.useEffect(() => {
+    console.debug("[useSymmTokenSelectionMarkets] data flow", {
+      params,
+      query: {
+        status: query.status,
+        fetchStatus: query.fetchStatus,
+        isLoading: query.isLoading,
+        isSuccess: query.isSuccess,
+        isError: query.isError,
+        error: query.error
+      },
+      priceQuery: {
+        status: priceQuery.status,
+        fetchStatus: priceQuery.fetchStatus,
+        isLoading: priceQuery.isLoading,
+        isSuccess: priceQuery.isSuccess,
+        isError: priceQuery.isError,
+        error: priceQuery.error
+      },
+      marketSymbols,
+      symbolsKey,
+      liveMarkPrices,
+      tickerSnapshots: priceQuery.data?.tickerSnapshots ?? {},
+      result: {
+        marketCount: markets.length,
+        markets: markets.map((market) => ({
+          id: market.id,
+          symbol: market.symbol,
+          markPrice: market.markPrice,
+          prevDayPrice: market.prevDayPrice,
+          priceChange24h: market.priceChange24h,
+          priceChange24hPercent: market.priceChange24hPercent
+        }))
+      }
+    });
+  }, [
+    liveMarkPrices,
+    marketSymbols,
+    markets,
+    params,
+    priceQuery.data,
+    priceQuery.error,
+    priceQuery.fetchStatus,
+    priceQuery.isError,
+    priceQuery.isLoading,
+    priceQuery.isSuccess,
+    priceQuery.status,
+    query.error,
+    query.fetchStatus,
+    query.isError,
+    query.isLoading,
+    query.isSuccess,
+    query.status,
+    symbolsKey
+  ]);
   return {
     query,
     priceQuery,
@@ -25465,6 +25618,22 @@ function useSymmTokenSelectionMarkets(params) {
     isPriceLoading: priceQuery.isLoading
   };
 }
+function useSymmTokenMarkPrice(symbol) {
+  const normalizedSymbol = symbol?.trim().toUpperCase() || null;
+  const resolution = resolveBinanceSymbol(normalizedSymbol ?? "");
+  const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
+  const markPrice = react.useMemo(() => {
+    if (!normalizedSymbol) return null;
+    return liveMarkPrices[normalizedSymbol] ?? null;
+  }, [liveMarkPrices, normalizedSymbol]);
+  return {
+    symbol: normalizedSymbol,
+    binanceSymbol: resolution.binanceSymbol,
+    markPrice,
+    isSupported: resolution.supported,
+    reason: resolution.reason
+  };
+}
 function useSymmFunding(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
@@ -25973,7 +26142,7 @@ function computeNetFundingSum({
 }
 
 // src/react/hooks/use-symm-token-selection-metadata.ts
-async function fetchTickerSnapshot2(symbol) {
+async function fetchTickerSnapshot(symbol) {
   const resolution = resolveBinanceSymbol(symbol);
   if (!resolution.binanceSymbol) return null;
   const ticker = await fetch24hrTicker(resolution.binanceSymbol);
@@ -26005,17 +26174,7 @@ 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 symbolToBinanceMap = react.useMemo(
-    () => new Map(
-      selectedSymbols.map(
-        (symbol) => [symbol, resolveBinanceSymbol(symbol).binanceSymbol]
-      ).filter((entry) => !!entry[1])
-    ),
-    [selectedSymbols]
-  );
   const liveMarkPrices = useBinanceMarkPriceStore((state) => state.markPrices);
-  const subscribeSymbol = useBinanceMarkPriceStore((state) => state.subscribeSymbol);
-  const unsubscribeSymbol = useBinanceMarkPriceStore((state) => state.unsubscribeSymbol);
   const query = reactQuery.useQuery({
     queryKey: ["symm", "chart-metadata", symbolsKey],
     queryFn: async () => {
@@ -26029,7 +26188,7 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
       const results = await Promise.all(
         allSymbols.map(async ({ symbol }) => ({
           symbol,
-          ticker: await fetchTickerSnapshot2(symbol)
+          ticker: await fetchTickerSnapshot(symbol)
         }))
       );
       const tickerSnapshots = {};
@@ -26041,28 +26200,7 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
     enabled: enabled && selectedSymbols.length > 0 && !isUnsupported,
     gcTime: 5 * 6e4
   });
-  react.useEffect(() => {
-    if (!enabled || isUnsupported || selectedSymbols.length === 0) {
-      return;
-    }
-    const symbolEntries = Array.from(symbolToBinanceMap.entries());
-    symbolEntries.forEach(
-      ([symbol, binanceSymbol]) => subscribeSymbol(symbol, binanceSymbol)
-    );
-    return () => {
-      symbolEntries.forEach(
-        ([symbol, binanceSymbol]) => unsubscribeSymbol(symbol, binanceSymbol)
-      );
-    };
-  }, [
-    enabled,
-    isUnsupported,
-    selectedSymbols.length,
-    symbolToBinanceMap,
-    subscribeSymbol,
-    unsubscribeSymbol
-  ]);
-  return react.useMemo(() => {
+  const result = react.useMemo(() => {
     const tickerSnapshots = query.data?.tickerSnapshots ?? {};
     const longMeta = {};
     const shortMeta = {};
@@ -26121,6 +26259,53 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
     selectedSymbols.length,
     liveMarkPrices
   ]);
+  react.useEffect(() => {
+    console.debug("[useSymmTokenSelectionMetadata] data flow", {
+      selection,
+      options,
+      query: {
+        status: query.status,
+        fetchStatus: query.fetchStatus,
+        isLoading: query.isLoading,
+        isSuccess: query.isSuccess,
+        isError: query.isError,
+        error: query.error
+      },
+      selectedSymbols,
+      unsupportedSymbols,
+      unavailableReason,
+      liveMarkPrices,
+      tickerSnapshots: query.data?.tickerSnapshots ?? {},
+      result: {
+        isLoading: result.isLoading,
+        isPriceDataReady: result.isPriceDataReady,
+        isUnsupported: result.isUnsupported,
+        longTokensMetadata: result.longTokensMetadata,
+        shortTokensMetadata: result.shortTokensMetadata,
+        weightedRatio: result.weightedRatio,
+        weightedRatio24h: result.weightedRatio24h,
+        priceRatio: result.priceRatio,
+        priceRatio24h: result.priceRatio24h,
+        sumNetFunding: result.sumNetFunding
+      }
+    });
+  }, [
+    liveMarkPrices,
+    options,
+    query.data,
+    query.error,
+    query.fetchStatus,
+    query.isError,
+    query.isLoading,
+    query.isSuccess,
+    query.status,
+    result,
+    selectedSymbols,
+    selection,
+    unavailableReason,
+    unsupportedSymbols
+  ]);
+  return result;
 }
 
 // src/utils/binance-intervals.ts
@@ -26561,6 +26746,7 @@ exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;
 exports.useSymmSignTermsMutation = useSymmSignTermsMutation;
 exports.useSymmSignatureQuery = useSymmSignatureQuery;
+exports.useSymmTokenMarkPrice = useSymmTokenMarkPrice;
 exports.useSymmTokenSelectionMarkets = useSymmTokenSelectionMarkets;
 exports.useSymmTokenSelectionMetadata = useSymmTokenSelectionMetadata;
 exports.useSymmTpslOrders = useSymmTpslOrders;