@pear-protocol/symmio-client 0.3.16 → 0.3.18

package/dist/react/index.js

@@ -633,6 +633,7 @@ var symmKeys = {
   triggerOrders: (params) => ["symm", "triggerOrders", params],
   triggerConfig: (orderId) => ["symm", "triggerConfig", orderId],
   markets: (chainId, search, pageSize) => ["symm", "markets", chainId, search, pageSize],
+  marketPositioning: (chainId, market) => ["symm", "marketPositioning", chainId, market],
   hedgerMarketById: (id, chainId) => ["symm", "hedgerMarketById", id, chainId],
   hedgerMarketBySymbol: (symbol, chainId) => ["symm", "hedgerMarketBySymbol", symbol, chainId],
   lockedParams: (marketName, leverage, chainId) => ["symm", "lockedParams", marketName, leverage, chainId],
@@ -1705,6 +1706,7 @@ var SymmioSDKError = class extends Error {
     this.code = code;
     this.name = "SymmioSDKError";
   }
+  code;
 };
 function validateAddress(address, name) {
   if (!viem.isAddress(address)) {
@@ -2662,24 +2664,288 @@ function useSymmDepositAndAllocateMutation(params = {}, options) {
     }
   });
 }
-function prepareWithdraw(multiAccount, account, params) {
-  validateAmount(params.amount, "withdraw amount");
-  validateAddress(params.account, "account");
+
+// src/abis/WithdrawFacet.ts
+var WithdrawFacetABI = [
+  // ─── Mutations ──────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "initiateWithdraw",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "parts",
+        type: "tuple[]",
+        internalType: "struct WithdrawReceiverPart[]",
+        components: [
+          { name: "id", type: "uint256", internalType: "uint256" },
+          { name: "amount", type: "uint256", internalType: "uint256" },
+          { name: "chainId", type: "int256", internalType: "int256" },
+          { name: "receiver", type: "bytes", internalType: "bytes" },
+          { name: "virtualProvider", type: "address", internalType: "address" },
+          { name: "expressProvider", type: "address", internalType: "address" }
+        ]
+      },
+      { name: "speedUp", type: "bool", internalType: "bool" },
+      { name: "data", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [
+      { name: "requestId", type: "uint256", internalType: "uint256" },
+      { name: "cooldownEndTime", type: "uint256", internalType: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "finalizeWithdrawRequest",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address", internalType: "address" },
+      { name: "requestId", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "requestCancelWithdraw",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "requestId", type: "uint256", internalType: "uint256" }],
+    outputs: []
+  },
+  // ─── Views ──────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "getWithdrawableTime",
+    stateMutability: "view",
+    inputs: [{ name: "user", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "getLastWithdrawRequestId",
+    stateMutability: "view",
+    inputs: [{ name: "user", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "isSpeedUpEligible",
+    stateMutability: "view",
+    inputs: [{ name: "user", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }]
+  },
+  {
+    type: "function",
+    name: "isExpressProviderRegistered",
+    stateMutability: "view",
+    inputs: [{ name: "provider", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }]
+  },
+  {
+    type: "function",
+    name: "isVirtualProviderRegistered",
+    stateMutability: "view",
+    inputs: [{ name: "provider", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }]
+  },
+  // ─── Events ─────────────────────────────────────────────────────
+  {
+    type: "event",
+    name: "WithdrawInitiated",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "user", type: "address", indexed: true, internalType: "address" },
+      {
+        name: "parts",
+        type: "tuple[]",
+        indexed: false,
+        internalType: "struct WithdrawReceiverPart[]",
+        components: [
+          { name: "id", type: "uint256", internalType: "uint256" },
+          { name: "amount", type: "uint256", internalType: "uint256" },
+          { name: "chainId", type: "int256", internalType: "int256" },
+          { name: "receiver", type: "bytes", internalType: "bytes" },
+          { name: "virtualProvider", type: "address", internalType: "address" },
+          { name: "expressProvider", type: "address", internalType: "address" }
+        ]
+      },
+      { name: "speedUp", type: "bool", indexed: false, internalType: "bool" },
+      { name: "providerData", type: "bytes", indexed: false, internalType: "bytes" },
+      { name: "cooldownEndTime", type: "uint256", indexed: false, internalType: "uint256" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawAccepted",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "user", type: "address", indexed: true, internalType: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawFinalized",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "user", type: "address", indexed: true, internalType: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawCancelRequested",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "user", type: "address", indexed: true, internalType: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawCancelled",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: true, internalType: "uint256" },
+      { name: "user", type: "address", indexed: true, internalType: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawRejected",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: false, internalType: "uint256" },
+      { name: "user", type: "address", indexed: false, internalType: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawSuspended",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: false, internalType: "uint256" },
+      { name: "user", type: "address", indexed: false, internalType: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "WithdrawSpeedUpAccepted",
+    anonymous: false,
+    inputs: [
+      { name: "requestId", type: "uint256", indexed: false, internalType: "uint256" },
+      { name: "user", type: "address", indexed: false, internalType: "address" },
+      { name: "newCooldown", type: "uint256", indexed: false, internalType: "uint256" }
+    ]
+  }
+];
+
+// src/types/withdraw.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
   const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount]
+    abi: accountDiamondAbi,
+    functionName: "_call",
+    args: [subAccount, callDatas]
   });
   return {
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount],
-    config: { account, to: multiAccount, data, value: 0n }
+    functionName: "_call",
+    args: [subAccount, callDatas],
+    data
+  };
+}
+
+// src/actions/withdraw.ts
+function buildExpressWithdrawPart(amount, chainId, receiver, expressProvider, partId = 0n) {
+  return {
+    id: partId,
+    amount,
+    chainId,
+    receiver,
+    virtualProvider: ZERO_ADDRESS,
+    expressProvider
+  };
+}
+function validateParts(parts) {
+  if (parts.length === 0) {
+    throw new Error("initiateWithdraw: at least one withdraw part is required");
+  }
+  for (const part of parts) {
+    validateAmount(part.amount, "withdraw part amount");
+    if (part.expressProvider !== ZERO_ADDRESS && part.expressProvider === part.virtualProvider) {
+      throw new Error(
+        "initiateWithdraw: a single provider cannot be set as both express and virtual"
+      );
+    }
+  }
+}
+function prepareInitiateWithdraw(multiAccount, account, subAccount, params) {
+  validateParts(params.parts);
+  const innerData = viem.encodeFunctionData({
+    abi: WithdrawFacetABI,
+    functionName: "initiateWithdraw",
+    args: [params.parts, params.speedUp, params.providerData]
+  });
+  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+function prepareFinalizeWithdraw(multiAccount, account, subAccount, params) {
+  validateAddress(params.user, "user");
+  const innerData = viem.encodeFunctionData({
+    abi: WithdrawFacetABI,
+    functionName: "finalizeWithdrawRequest",
+    args: [params.user, params.requestId]
+  });
+  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+function prepareRequestCancelWithdraw(multiAccount, account, subAccount, params) {
+  const innerData = viem.encodeFunctionData({
+    abi: WithdrawFacetABI,
+    functionName: "requestCancelWithdraw",
+    args: [params.requestId]
+  });
+  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, [innerData]);
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
   };
 }
-async function withdraw(walletClient, publicClient, multiAccount, params) {
+async function initiateWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareInitiateWithdraw(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function finalizeWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
   const account = walletClient.account?.address;
   if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareWithdraw(multiAccount, account, params);
+  const prepared = prepareFinalizeWithdraw(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function requestCancelWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareRequestCancelWithdraw(multiAccount, account, subAccount, params);
   const gas = await publicClient.estimateGas(prepared.config);
   return walletClient.sendTransaction({
     ...prepared.config,
@@ -2689,26 +2955,201 @@ async function withdraw(walletClient, publicClient, multiAccount, params) {
 }
 
 // src/react/hooks/use-symm-withdraw.ts
-function useSymmWithdraw(params = {}, options) {
+function useResolvedWithdrawConfig(params) {
   const { chainId, symmioConfig } = useSymmContext();
-  const { publicClient, walletClient } = params;
-  const queryClient = reactQuery.useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
+  return {
+    multiAccount,
+    publicClient: params.publicClient,
+    walletClient: params.walletClient,
+    contextSubAccount: params.subAccount
+  };
+}
+function useSymmInitiateWithdraw(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
   return reactQuery.useMutation({
     ...withSymmMutationConfig(options?.mutation, {
-      onSuccess: () => {
-        invalidateBalances(queryClient);
-      }
+      onSuccess: () => invalidateBalances(queryClient)
     }),
-    mutationFn: async ({
-      account,
-      amount
-    }) => {
+    mutationFn: async (vars) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
-      return withdraw(walletClient, publicClient, multiAccount, { account, amount });
+      const subAccount = vars.subAccount ?? contextSubAccount;
+      if (!subAccount) throw new Error("subAccount required");
+      return initiateWithdraw(walletClient, publicClient, multiAccount, subAccount, {
+        parts: vars.parts,
+        speedUp: vars.speedUp,
+        providerData: vars.providerData
+      });
     }
   });
 }
+function useSymmFinalizeWithdraw(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => invalidateBalances(queryClient)
+    }),
+    mutationFn: async (vars) => {
+      if (!walletClient || !publicClient) throw new Error("Clients not available");
+      const subAccount = vars.subAccount ?? contextSubAccount;
+      if (!subAccount) throw new Error("subAccount required");
+      return finalizeWithdraw(walletClient, publicClient, multiAccount, subAccount, {
+        user: vars.user,
+        requestId: vars.requestId
+      });
+    }
+  });
+}
+function useSymmRequestCancelWithdraw(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => invalidateBalances(queryClient)
+    }),
+    mutationFn: async (vars) => {
+      if (!walletClient || !publicClient) throw new Error("Clients not available");
+      const subAccount = vars.subAccount ?? contextSubAccount;
+      if (!subAccount) throw new Error("subAccount required");
+      return requestCancelWithdraw(walletClient, publicClient, multiAccount, subAccount, {
+        requestId: vars.requestId
+      });
+    }
+  });
+}
+function useSymmWithdraw(params = {}) {
+  return {
+    initiate: useSymmInitiateWithdraw(params),
+    finalize: useSymmFinalizeWithdraw(params),
+    requestCancel: useSymmRequestCancelWithdraw(params)
+  };
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function useSymmInstantWithdraw(params = {}) {
+  const queryClient = reactQuery.useQueryClient();
+  const { chainId, symmioConfig } = useSymmContext();
+  const { multiAccount, publicClient, walletClient, contextSubAccount } = useResolvedWithdrawConfig(params);
+  const diamond = params.diamond ?? symmioConfig?.symmioDiamondAddress ?? getAddress(SYMMIO_DIAMOND_ADDRESS, chainId, "SymmioDiamond");
+  const providerTimeoutMs = params.providerAcceptanceTimeoutMs ?? 6e4;
+  const pollIntervalMs = params.pollIntervalMs ?? 3e3;
+  const [status, setStatus] = react.useState("idle" /* IDLE */);
+  const [requestId, setRequestId] = react.useState();
+  const [txHashes, setTxHashes] = react.useState({});
+  const [error, setError] = react.useState();
+  const reset = react.useCallback(() => {
+    setStatus("idle" /* IDLE */);
+    setRequestId(void 0);
+    setTxHashes({});
+    setError(void 0);
+  }, []);
+  const withdraw = react.useCallback(
+    async (vars) => {
+      setError(void 0);
+      setRequestId(void 0);
+      setTxHashes({});
+      try {
+        if (!walletClient || !publicClient) throw new Error("Clients not available");
+        const subAccount = vars.subAccount ?? contextSubAccount;
+        if (!subAccount) throw new Error("subAccount required");
+        setStatus("initiating" /* INITIATING */);
+        const part = buildExpressWithdrawPart(
+          vars.amount,
+          vars.chainId,
+          vars.receiver,
+          vars.expressProvider,
+          vars.partId ?? 0n
+        );
+        const initiateHash = await initiateWithdraw(
+          walletClient,
+          publicClient,
+          multiAccount,
+          subAccount,
+          {
+            parts: [part],
+            speedUp: vars.speedUp ?? false,
+            providerData: vars.providerData ?? "0x"
+          }
+        );
+        setTxHashes({ initiate: initiateHash });
+        const initiateReceipt = await publicClient.waitForTransactionReceipt({
+          hash: initiateHash
+        });
+        const [initiated] = viem.parseEventLogs({
+          abi: WithdrawFacetABI,
+          eventName: "WithdrawInitiated",
+          logs: initiateReceipt.logs
+        });
+        if (!initiated) {
+          throw new Error("WithdrawInitiated event not found in initiate receipt");
+        }
+        const reqId = initiated.args.requestId;
+        const cooldownEndTime = initiated.args.cooldownEndTime;
+        setRequestId(reqId);
+        setStatus("awaitingProvider" /* AWAITING_PROVIDER */);
+        const acceptanceDeadline = Date.now() + providerTimeoutMs;
+        let fromBlock = initiateReceipt.blockNumber;
+        let accepted = false;
+        while (Date.now() < acceptanceDeadline) {
+          const events = await publicClient.getContractEvents({
+            address: diamond,
+            abi: WithdrawFacetABI,
+            eventName: "WithdrawAccepted",
+            args: { requestId: reqId, user: subAccount },
+            fromBlock,
+            toBlock: "latest"
+          });
+          if (events.length > 0) {
+            accepted = true;
+            break;
+          }
+          await sleep(pollIntervalMs);
+        }
+        if (!accepted) {
+          throw new Error(
+            `Express provider did not accept within ${providerTimeoutMs}ms (requestId=${reqId})`
+          );
+        }
+        setStatus("awaitingCooldown" /* AWAITING_COOLDOWN */);
+        const nowSec = Math.floor(Date.now() / 1e3);
+        const remainingSec = Number(cooldownEndTime) - nowSec;
+        if (remainingSec > 0) {
+          await sleep((remainingSec + 1) * 1e3);
+        }
+        setStatus("finalizing" /* FINALIZING */);
+        const finalizeHash = await finalizeWithdraw(
+          walletClient,
+          publicClient,
+          multiAccount,
+          subAccount,
+          { user: subAccount, requestId: reqId }
+        );
+        setTxHashes((t) => ({ ...t, finalize: finalizeHash }));
+        await publicClient.waitForTransactionReceipt({ hash: finalizeHash });
+        setStatus("completed" /* COMPLETED */);
+        invalidateBalances(queryClient);
+        return { requestId: reqId, initiateHash, finalizeHash };
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        setError(err);
+        setStatus("failed" /* FAILED */);
+        throw err;
+      }
+    },
+    [
+      walletClient,
+      publicClient,
+      multiAccount,
+      diamond,
+      contextSubAccount,
+      providerTimeoutMs,
+      pollIntervalMs,
+      queryClient
+    ]
+  );
+  return { withdraw, status, requestId, txHashes, error, reset };
+}
 
 // src/abis/SymmioDiamond.ts
 var SymmioDiamondABI = [
@@ -25094,18 +25535,6 @@ var SymmioDiamondABI = [
     type: "function"
   }
 ];
-function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
-  const data = viem.encodeFunctionData({
-    abi: accountDiamondAbi,
-    functionName: "_call",
-    args: [subAccount, callDatas]
-  });
-  return {
-    functionName: "_call",
-    args: [subAccount, callDatas],
-    data
-  };
-}
 
 // src/actions/allocate.ts
 function prepareAllocate(multiAccount, account, subAccount, params) {
@@ -26100,8 +26529,8 @@ function computeSymmNetDeposited(totals, decimals = 6) {
     return "0";
   }
   const deposit2 = parseRawCollateralUnits(totals.deposit);
-  const withdraw2 = parseRawCollateralUnits(totals.withdraw);
-  const value = deposit2 - withdraw2;
+  const withdraw = parseRawCollateralUnits(totals.withdraw);
+  const value = deposit2 - withdraw;
   const negative = value < 0n;
   const absolute = negative ? -value : value;
   const scale = 10n ** BigInt(decimals);
@@ -26159,7 +26588,7 @@ function useSymmAccountOverview(params) {
     chainId: params.chainId,
     query: {
       ...params.query,
-      enabled: upnlReady && (params.query?.enabled ?? true)
+      enabled: params.query?.enabled ?? true
     }
   });
   const data = react.useMemo(() => {
@@ -26681,6 +27110,34 @@ function useSymmMarkets(params) {
     enabled: internalEnabled && (params?.query?.enabled ?? true)
   });
 }
+function normalizeMarket(market) {
+  if (Array.isArray(market)) {
+    const markets = market.map((marketName2) => marketName2.trim()).filter((marketName2) => marketName2.length > 0);
+    return markets.length > 0 ? markets : void 0;
+  }
+  const marketName = market?.trim();
+  return marketName ? marketName : void 0;
+}
+function hasMarket(market) {
+  return Array.isArray(market) ? market.length > 0 : market !== void 0;
+}
+function useSymmMarketPositioning(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  const market = normalizeMarket(params?.market);
+  const internalEnabled = !!symmCoreClient && hasMarket(market);
+  return reactQuery.useQuery({
+    ...params?.query,
+    queryKey: symmKeys.marketPositioning(chainId, market),
+    queryFn: () => {
+      if (!hasMarket(market)) {
+        throw new Error("Market is required to fetch positioning");
+      }
+      return symmCoreClient.markets.getPositioning({ chainId, market });
+    },
+    enabled: internalEnabled && (params?.query?.enabled ?? true)
+  });
+}
 function useSymmHedgerMarketById(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { id } = params;
@@ -26786,7 +27243,9 @@ async function fetch24hrTicker(symbol) {
   return {
     lastPrice: parseFloat(data.lastPrice),
     openPrice: parseFloat(data.openPrice),
-    priceChangePercent: parseFloat(data.priceChangePercent)
+    priceChangePercent: parseFloat(data.priceChangePercent),
+    volume: parseFloat(data.volume),
+    quoteVolume: parseFloat(data.quoteVolume)
   };
 }
 async function fetch24hrTickers() {
@@ -26800,7 +27259,9 @@ async function fetch24hrTickers() {
     result[item.symbol] = {
       lastPrice: parseFloat(item.lastPrice),
       openPrice: parseFloat(item.openPrice),
-      priceChangePercent: parseFloat(item.priceChangePercent)
+      priceChangePercent: parseFloat(item.priceChangePercent),
+      volume: parseFloat(item.volume),
+      quoteVolume: parseFloat(item.quoteVolume)
     };
   }
   return result;
@@ -26836,7 +27297,11 @@ function useSymmTokenSelectionMarkets(params) {
           return;
         }
         const ticker = allTickers[binanceSymbol];
-        tickerSnapshots[symbol] = ticker ? { openPrice: ticker.openPrice } : null;
+        tickerSnapshots[symbol] = ticker ? {
+          openPrice: ticker.openPrice,
+          volume: ticker.volume,
+          quoteVolume: ticker.quoteVolume
+        } : null;
       });
       return { tickerSnapshots };
     },
@@ -26846,21 +27311,30 @@ function useSymmTokenSelectionMarkets(params) {
   });
   const markets = react.useMemo(() => {
     const snapshots = priceQuery.data?.tickerSnapshots ?? {};
-    return baseMarkets.map((market) => {
+    return baseMarkets.map((market, index) => {
       const symbol = market.symbol ?? "";
       const markPrice = symbol ? liveMarkPrices[symbol] ?? null : null;
-      const prevDayPrice = symbol ? snapshots[symbol]?.openPrice ?? null : null;
+      const ticker = symbol ? snapshots[symbol] ?? null : null;
+      const prevDayPrice = ticker?.openPrice ?? null;
       const priceChange24h = markPrice != null && prevDayPrice != null ? markPrice - prevDayPrice : null;
       const priceChange24hPercent = markPrice != null && prevDayPrice != null && prevDayPrice !== 0 ? (markPrice - prevDayPrice) / prevDayPrice * 100 : null;
       return {
-        ...market,
-        collateralToken: "USDC",
-        markPrice,
-        prevDayPrice,
-        priceChange24h,
-        priceChange24hPercent
+        market: {
+          ...market,
+          collateralToken: "USDC",
+          markPrice,
+          prevDayPrice,
+          priceChange24h,
+          priceChange24hPercent,
+          volume24h: ticker?.volume ?? null,
+          quoteVolume24h: ticker?.quoteVolume ?? null
+        },
+        index
       };
-    });
+    }).sort((a, b) => {
+      const volumeDelta = (b.market.quoteVolume24h ?? 0) - (a.market.quoteVolume24h ?? 0);
+      return volumeDelta === 0 ? a.index - b.index : volumeDelta;
+    }).map(({ market }) => market);
   }, [baseMarkets, liveMarkPrices, priceQuery.data]);
   const marketsBySymbol = react.useMemo(
     () => new Map(
@@ -27910,17 +28384,21 @@ exports.useSymmDelegation = useSymmDelegation;
 exports.useSymmDepositAndAllocateMutation = useSymmDepositAndAllocateMutation;
 exports.useSymmDepositMutation = useSymmDepositMutation;
 exports.useSymmEditAccountNameMutation = useSymmEditAccountNameMutation;
+exports.useSymmFinalizeWithdraw = useSymmFinalizeWithdraw;
 exports.useSymmFunding = useSymmFunding;
 exports.useSymmFundingHistory = useSymmFundingHistory;
 exports.useSymmFundingPayments = useSymmFundingPayments;
 exports.useSymmHedgerMarketById = useSymmHedgerMarketById;
 exports.useSymmHedgerMarketBySymbol = useSymmHedgerMarketBySymbol;
 exports.useSymmHedgerMarkets = useSymmHedgerMarkets;
+exports.useSymmInitiateWithdraw = useSymmInitiateWithdraw;
 exports.useSymmInstantTradeEnsureReadyMutation = useSymmInstantTradeEnsureReadyMutation;
 exports.useSymmInstantTradeExecuteMutation = useSymmInstantTradeExecuteMutation;
+exports.useSymmInstantWithdraw = useSymmInstantWithdraw;
 exports.useSymmInternalTransferCollateralMutation = useSymmInternalTransferCollateralMutation;
 exports.useSymmLockedParams = useSymmLockedParams;
 exports.useSymmMarkReadNotificationMutation = useSymmMarkReadNotificationMutation;
+exports.useSymmMarketPositioning = useSymmMarketPositioning;
 exports.useSymmMarkets = useSymmMarkets;
 exports.useSymmNotificationsQuery = useSymmNotificationsQuery;
 exports.useSymmOpenBasketMutation = useSymmOpenBasketMutation;
@@ -27931,6 +28409,7 @@ exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
 exports.useSymmProposeRevokeDelegationMutation = useSymmProposeRevokeDelegationMutation;
+exports.useSymmRequestCancelWithdraw = useSymmRequestCancelWithdraw;
 exports.useSymmRevokeDelegationMutation = useSymmRevokeDelegationMutation;
 exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;