@shogun-sdk/swap 0.0.2-test.2 → 0.0.2-test.21

package/dist/react.cjs

@@ -20,8 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/react/index.ts
 var react_exports = {};
 __export(react_exports, {
-  ChainID: () => import_intents_sdk10.ChainID,
-  isEvmChain: () => import_intents_sdk10.isEvmChain,
+  ChainID: () => import_intents_sdk11.ChainID,
+  isEvmChain: () => import_intents_sdk11.isEvmChain,
   useBalances: () => useBalances,
   useExecuteOrder: () => useExecuteOrder,
   useQuote: () => useQuote,
@@ -112,7 +112,7 @@ function useTokenList(params) {
 var import_react2 = require("react");
 
 // src/core/executeOrder/execute.ts
-var import_intents_sdk7 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk8 = require("@shogun-sdk/intents-sdk");
 var import_viem3 = require("viem");
 
 // src/utils/address.ts
@@ -234,15 +234,26 @@ var adaptViemWallet = (wallet) => {
     if (!isEVMTransaction(transaction)) {
       throw new Error("Expected EVMTransaction but got SolanaTransaction");
     }
-    const tx = await wallet.sendTransaction({
-      from: transaction.from,
-      to: transaction.to,
-      data: transaction.data,
-      value: transaction.value,
-      account: wallet.account?.address,
-      chain: wallet.chain
-    });
-    return tx;
+    if (wallet.transport.type === "http") {
+      const request = await wallet.prepareTransactionRequest({
+        to: transaction.to,
+        data: transaction.data,
+        value: transaction.value,
+        chain: wallet.chain
+      });
+      const serializedTransaction = await wallet.signTransaction(request);
+      const tx = await wallet.sendRawTransaction({ serializedTransaction });
+      return tx;
+    } else {
+      const hash = await wallet.sendTransaction({
+        to: transaction.to,
+        data: transaction.data,
+        value: transaction.value,
+        chain: wallet.chain,
+        account: wallet.account
+      });
+      return hash;
+    }
   };
   const switchChain = async (chainId) => {
     try {
@@ -277,7 +288,7 @@ var adaptViemWallet = (wallet) => {
 };
 
 // src/core/executeOrder/handleEvmExecution.ts
-var import_intents_sdk5 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk6 = require("@shogun-sdk/intents-sdk");
 var import_viem2 = require("viem");
 
 // src/core/executeOrder/normalizeNative.ts
@@ -297,10 +308,12 @@ var DEFAULT_STAGE_MESSAGES = {
   processing: "Preparing transaction for execution",
   approving: "Approving token allowance",
   approved: "Token approved successfully",
-  signing: "Signing order for submission",
-  submitting: "Submitting order to Auctioneer",
-  success: "Order executed successfully",
-  error: "Order execution failed"
+  signing: "Signing transaction for submission",
+  submitting: "Submitting transaction",
+  initiated: "Transaction initiated.",
+  success: "Transaction Executed successfully",
+  shogun_processing: "Shogun is processing your transaction",
+  error: "Transaction failed during submission"
 };
 
 // src/core/executeOrder/buildOrder.ts
@@ -339,6 +352,110 @@ async function buildOrder({
   });
 }
 
+// src/utils/pollOrderStatus.ts
+var import_intents_sdk5 = require("@shogun-sdk/intents-sdk");
+async function pollOrderStatus(address, orderId, options = {}) {
+  const { intervalMs = 2e3, timeoutMs = 3e5 } = options;
+  const startTime = Date.now();
+  const isDebug = process.env.NODE_ENV !== "production";
+  const isEvmAddress = /^0x[a-fA-F0-9]{40}$/.test(address);
+  const isSuiAddress = /^0x[a-fA-F0-9]{64}$/.test(address);
+  const isSolanaAddress = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+  let queryParam;
+  if (isEvmAddress) queryParam = `evmWallets=${address}`;
+  else if (isSuiAddress) queryParam = `suiWallets=${address}`;
+  else if (isSolanaAddress) queryParam = `solanaWallets=${address}`;
+  else throw new Error(`Unrecognized wallet address format: ${address}`);
+  const queryUrl = `${import_intents_sdk5.AUCTIONEER_URL}/user_intent?${queryParam}`;
+  return new Promise((resolve, reject) => {
+    const pollInterval = setInterval(async () => {
+      try {
+        if (Date.now() - startTime > timeoutMs) {
+          clearInterval(pollInterval);
+          return resolve("Timeout");
+        }
+        const res = await fetch(queryUrl, {
+          method: "GET",
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!res.ok) {
+          clearInterval(pollInterval);
+          return reject(
+            new Error(`Failed to fetch orders: ${res.status} ${res.statusText}`)
+          );
+        }
+        const json = await res.json();
+        const data = json?.data ?? {};
+        const allOrders = [
+          ...data.crossChainDcaOrders ?? [],
+          ...data.crossChainLimitOrders ?? [],
+          ...data.singleChainDcaOrders ?? [],
+          ...data.singleChainLimitOrders ?? []
+        ];
+        const targetOrder = allOrders.find((o) => o.orderId === orderId);
+        if (!targetOrder) {
+          if (isDebug)
+            console.debug(`[pollOrderStatus] [${orderId}] Not found yet`);
+          return;
+        }
+        const { orderStatus } = targetOrder;
+        if (isDebug) {
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          console.debug(`targetOrder`, targetOrder);
+          console.debug(
+            `[pollOrderStatus] [${orderId}] status=${orderStatus} (elapsed ${elapsed}s)`
+          );
+        }
+        if (["Fulfilled", "Cancelled", "Outdated"].includes(orderStatus)) {
+          clearInterval(pollInterval);
+          return resolve(orderStatus);
+        }
+      } catch (error) {
+        clearInterval(pollInterval);
+        return reject(error);
+      }
+    }, intervalMs);
+  });
+}
+
+// src/core/executeOrder/handleOrderPollingResult.ts
+async function handleOrderPollingResult({
+  status,
+  orderId,
+  chainId,
+  update,
+  messageFor
+}) {
+  switch (status) {
+    case "Fulfilled":
+      update("success", messageFor("success"));
+      return {
+        status: true,
+        orderId,
+        chainId,
+        finalStatus: status,
+        stage: "success"
+      };
+    case "Cancelled":
+      update("error", "Order was cancelled before fulfillment");
+      break;
+    case "Timeout":
+      update("error", "Order polling timed out");
+      break;
+    case "NotFound":
+    default:
+      update("error", "Order not found");
+      break;
+  }
+  return {
+    status: false,
+    orderId,
+    chainId,
+    finalStatus: status,
+    stage: "error"
+  };
+}
+
 // src/core/executeOrder/handleEvmExecution.ts
 async function handleEvmExecution({
   recipientAddress,
@@ -367,18 +484,18 @@ async function handleEvmExecution({
       from: accountAddress
     });
   }
-  update("approving", messageFor("approving"));
+  update("processing", messageFor("approving"));
   await wallet.sendTransaction({
     to: tokenIn,
     data: (0, import_viem2.encodeFunctionData)({
       abi: import_viem2.erc20Abi,
       functionName: "approve",
-      args: [import_intents_sdk5.PERMIT2_ADDRESS[chainId], BigInt(quote.amountIn)]
+      args: [import_intents_sdk6.PERMIT2_ADDRESS[chainId], quote.amountIn]
     }),
     value: 0n,
     from: accountAddress
   });
-  update("approved", messageFor("approved"));
+  update("processing", messageFor("approved"));
   const destination = recipientAddress ?? accountAddress;
   const order = await buildOrder({
     quote,
@@ -387,23 +504,40 @@ async function handleEvmExecution({
     deadline,
     isSingleChain
   });
-  update("signing", messageFor("signing"));
-  const { orderTypedData, nonce } = isSingleChain ? await (0, import_intents_sdk5.getEVMSingleChainOrderTypedData)(order) : await (0, import_intents_sdk5.getEVMCrossChainOrderTypedData)(order);
+  console.debug(`order`, order);
+  update("processing", messageFor("signing"));
+  const { orderTypedData, nonce } = isSingleChain ? await (0, import_intents_sdk6.getEVMSingleChainOrderTypedData)(order) : await (0, import_intents_sdk6.getEVMCrossChainOrderTypedData)(order);
+  const typedData = serializeBigIntsToStrings(orderTypedData);
   if (!wallet.signTypedData) {
     throw new Error("Wallet does not support EIP-712 signing");
   }
-  const signature = await wallet.signTypedData(serializeBigIntsToStrings(orderTypedData));
-  update("submitting", messageFor("submitting"));
+  const signature = await wallet.signTypedData({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    value: typedData.message,
+    message: typedData.message
+  });
+  update("processing", messageFor("submitting"));
   const res = await order.sendToAuctioneer({ signature, nonce: nonce.toString() });
   if (!res.success) {
     throw new Error("Auctioneer submission failed");
   }
-  update("success", messageFor("success"));
-  return { status: true, txHash: res.data, chainId, stage: "success" };
+  update("initiated", messageFor("initiated"));
+  const { intentId: orderId } = res.data;
+  update("initiated", messageFor("shogun_processing"));
+  const status = await pollOrderStatus(accountAddress, orderId);
+  return await handleOrderPollingResult({
+    status,
+    orderId,
+    chainId,
+    update,
+    messageFor
+  });
 }
 
 // src/core/executeOrder/handleSolanaExecution.ts
-var import_intents_sdk6 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk7 = require("@shogun-sdk/intents-sdk");
 var import_web3 = require("@solana/web3.js");
 async function handleSolanaExecution({
   recipientAddress,
@@ -433,10 +567,9 @@ async function handleSolanaExecution({
     rpcUrl: wallet.rpcUrl
   });
   const transaction = import_web3.VersionedTransaction.deserialize(Uint8Array.from(txData.txBytes));
-  update("signing", messageFor("signing"));
-  console.log({ order });
-  const txSignature = await wallet.sendTransaction(transaction);
-  update("submitting", messageFor("submitting"));
+  update("processing", messageFor("signing"));
+  await wallet.sendTransaction(transaction);
+  update("processing", messageFor("submitting"));
   const response = await submitToAuctioneer({
     order,
     isSingleChain,
@@ -445,13 +578,17 @@ async function handleSolanaExecution({
   if (!response.success) {
     throw new Error("Auctioneer submission failed");
   }
-  update("success", messageFor("success"));
-  return {
-    status: true,
-    txHash: txSignature,
-    chainId: import_intents_sdk6.ChainID.Solana,
-    stage: "success"
-  };
+  update("initiated", messageFor("initiated"));
+  const { jwt, intentId: orderId } = response.data;
+  update("initiated", messageFor("shogun_processing"));
+  const status = await pollOrderStatus(jwt, orderId);
+  return await handleOrderPollingResult({
+    status,
+    orderId,
+    chainId: SOLANA_CHAIN_ID,
+    update,
+    messageFor
+  });
 }
 async function getSolanaOrderInstructions({
   order,
@@ -459,11 +596,11 @@ async function getSolanaOrderInstructions({
   rpcUrl
 }) {
   if (isSingleChain) {
-    return await (0, import_intents_sdk6.getSolanaSingleChainOrderInstructions)(order, {
+    return await (0, import_intents_sdk7.getSolanaSingleChainOrderInstructions)(order, {
       rpcUrl
     });
   }
-  return await (0, import_intents_sdk6.getSolanaCrossChainOrderInstructions)(order, {
+  return await (0, import_intents_sdk7.getSolanaCrossChainOrderInstructions)(order, {
     rpcUrl
   });
 }
@@ -493,18 +630,33 @@ async function executeOrder({
   onStatus,
   options = {}
 }) {
-  const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+  const isDev = process.env.NODE_ENV !== "production";
+  const log = (...args) => {
+    if (isDev) console.debug("[OneShot::executeOrder]", ...args);
+  };
   const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
-  const update = (stage, message) => onStatus?.(stage, message ?? messageFor(stage));
+  const update = (stage, message) => {
+    log("Stage:", stage, "| Message:", message ?? messageFor(stage));
+    onStatus?.(stage, message ?? messageFor(stage));
+  };
   try {
+    const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+    log("Starting execution:", {
+      accountAddress,
+      recipientAddress,
+      deadline,
+      tokenIn: quote?.tokenIn,
+      tokenOut: quote?.tokenOut
+    });
     const adapter = normalizeWallet(wallet);
     if (!adapter) throw new Error("No wallet provided");
     const { tokenIn, tokenOut } = quote;
     const isSingleChain = tokenIn.chainId === tokenOut.chainId;
     const chainId = Number(tokenIn.chainId);
-    update("processing", messageFor("processing"));
-    if ((0, import_intents_sdk7.isEvmChain)(chainId)) {
-      return await handleEvmExecution({
+    update("processing");
+    if ((0, import_intents_sdk8.isEvmChain)(chainId)) {
+      log("Detected EVM chain:", chainId);
+      const result = await handleEvmExecution({
         recipientAddress,
         quote,
         chainId,
@@ -514,9 +666,12 @@ async function executeOrder({
         deadline,
         update
       });
+      log("EVM execution result:", result);
+      return result;
     }
-    if (chainId === import_intents_sdk7.ChainID.Solana) {
-      return await handleSolanaExecution({
+    if (chainId === import_intents_sdk8.ChainID.Solana) {
+      log("Detected Solana chain");
+      const result = await handleSolanaExecution({
         recipientAddress,
         quote,
         accountAddress,
@@ -525,11 +680,16 @@ async function executeOrder({
         deadline,
         update
       });
+      log("Solana execution result:", result);
+      return result;
     }
-    update("error", "Unsupported chain");
-    return { status: false, message: "Unsupported chain", stage: "error" };
+    const unsupported = `Unsupported chain: ${chainId}`;
+    update("error", unsupported);
+    log("Error:", unsupported);
+    return { status: false, message: unsupported, stage: "error" };
   } catch (error) {
     const message = error instanceof import_viem3.BaseError ? error.shortMessage : error instanceof Error ? error.message : String(error);
+    log("Execution failed:", { message, error });
     update("error", message);
     return { status: false, message, stage: "error" };
   }
@@ -631,7 +791,7 @@ function useExecuteOrder() {
 var import_react3 = require("react");
 
 // src/core/getQuote.ts
-var import_intents_sdk8 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk9 = require("@shogun-sdk/intents-sdk");
 var import_viem4 = require("viem");
 async function getQuote(params) {
   if (!params.tokenIn?.address || !params.tokenOut?.address) {
@@ -644,29 +804,32 @@ async function getQuote(params) {
     throw new Error("Amount must be greater than 0.");
   }
   const normalizedTokenIn = normalizeNative(params.sourceChainId, params.tokenIn.address);
-  const data = await import_intents_sdk8.QuoteProvider.getQuote({
+  const data = await import_intents_sdk9.QuoteProvider.getQuote({
     sourceChainId: params.sourceChainId,
     destChainId: params.destChainId,
     tokenIn: normalizedTokenIn,
     tokenOut: params.tokenOut.address,
     amount: params.amount
   });
-  const inputSlippage = params.slippage ?? 5;
-  const slippageDecimal = inputSlippage / 100;
-  const slippage = Math.min(Math.max(slippageDecimal, 0), 0.5);
+  const slippagePercent = Math.min(Math.max(params.slippage ?? 0.5, 0), 50);
   let warning;
-  if (slippage > 0.1) {
-    warning = `\u26A0\uFE0F High slippage tolerance (${(slippage * 100).toFixed(2)}%) \u2014 price may vary significantly.`;
+  if (slippagePercent > 10) {
+    warning = `\u26A0\uFE0F High slippage tolerance (${slippagePercent.toFixed(2)}%) \u2014 price may vary significantly.`;
   }
-  const estimatedAmountOut = BigInt(data.estimatedAmountOutReduced);
-  const slippageBps = BigInt(Math.round(slippage * 1e4));
+  const estimatedAmountOut = BigInt(data.estimatedAmountOut);
+  const slippageBps = BigInt(Math.round(slippagePercent * 100));
   const estimatedAmountOutAfterSlippage = estimatedAmountOut * (10000n - slippageBps) / 10000n;
+  const pricePerTokenOutInUsd = data.estimatedAmountOutUsd / Number(data.estimatedAmountOut);
+  const amountOutUsdAfterSlippage = Number(estimatedAmountOutAfterSlippage) * pricePerTokenOutInUsd;
+  const minStablecoinsAmountValue = BigInt(data.estimatedAmountInAsMinStablecoinAmount);
+  const minStablecoinsAmountAfterSlippage = minStablecoinsAmountValue * (10000n - slippageBps) / 10000n;
   const pricePerInputToken = estimatedAmountOut * 10n ** BigInt(params.tokenIn.decimals ?? 18) / BigInt(params.amount);
   return {
-    amountOut: estimatedAmountOut,
-    amountOutUsd: data.estimatedAmountOutUsd,
+    amountOut: estimatedAmountOutAfterSlippage,
+    amountOutUsd: amountOutUsdAfterSlippage,
     amountInUsd: data.amountInUsd,
-    minStablecoinsAmount: data.estimatedAmountInAsMinStablecoinAmount,
+    // Input USD stays the same
+    minStablecoinsAmount: minStablecoinsAmountAfterSlippage,
     tokenIn: {
       address: params.tokenIn.address,
       decimals: params.tokenIn.decimals ?? 18,
@@ -679,10 +842,11 @@ async function getQuote(params) {
     },
     amountIn: params.amount,
     pricePerInputToken,
-    slippage,
+    slippage: slippagePercent,
     internal: {
       ...data,
-      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage
+      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage,
+      estimatedAmountOutUsdReduced: amountOutUsdAfterSlippage
     },
     warning
   };
@@ -698,77 +862,64 @@ function useQuote(params, options) {
   const autoRefreshMs = options?.autoRefreshMs;
   const abortRef = (0, import_react3.useRef)(null);
   const debounceRef = (0, import_react3.useRef)(null);
-  const mountedRef = (0, import_react3.useRef)(true);
+  const mounted = (0, import_react3.useRef)(false);
+  const paramsKey = (0, import_react3.useMemo)(
+    () => params ? JSON.stringify(serializeBigIntsToStrings(params)) : null,
+    [params]
+  );
   (0, import_react3.useEffect)(() => {
+    mounted.current = true;
     return () => {
-      mountedRef.current = false;
+      mounted.current = false;
       abortRef.current?.abort();
       if (debounceRef.current) clearTimeout(debounceRef.current);
     };
   }, []);
-  const fetchQuote = (0, import_react3.useCallback)(
-    async (signal) => {
-      if (!params) return;
-      try {
-        setLoading(true);
-        setWarning(null);
-        const result = await getQuote({ ...params, signal });
-        if (!mountedRef.current) return;
-        setData((prev) => {
-          if (JSON.stringify(prev) === JSON.stringify(result)) return prev;
-          return result;
-        });
-        setWarning(result.warning ?? null);
-        setError(null);
-      } catch (err) {
-        if (err.name === "AbortError") return;
-        const e = err instanceof Error ? err : new Error(String(err));
-        if (mountedRef.current) setError(e);
-      } finally {
-        if (mountedRef.current) setLoading(false);
-      }
-    },
-    [params]
-  );
-  (0, import_react3.useEffect)(() => {
+  const fetchQuote = (0, import_react3.useCallback)(async () => {
     if (!params) return;
+    try {
+      setLoading(true);
+      setWarning(null);
+      const result = await getQuote(params);
+      const serializeResult = serializeBigIntsToStrings(result);
+      if (!mounted.current) return;
+      setData((prev) => {
+        if (JSON.stringify(prev) === JSON.stringify(serializeResult)) return prev;
+        return serializeResult;
+      });
+      setWarning(result.warning ?? null);
+      setError(null);
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      console.error("[useQuote] fetch error:", err);
+      if (mounted.current) setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (mounted.current) setLoading(false);
+    }
+  }, [paramsKey]);
+  (0, import_react3.useEffect)(() => {
+    if (!paramsKey) return;
     if (debounceRef.current) clearTimeout(debounceRef.current);
-    abortRef.current?.abort();
-    const controller = new AbortController();
-    abortRef.current = controller;
     debounceRef.current = setTimeout(() => {
-      fetchQuote(controller.signal);
+      fetchQuote();
     }, debounceMs);
     return () => {
-      controller.abort();
       if (debounceRef.current) clearTimeout(debounceRef.current);
+      abortRef.current?.abort();
     };
-  }, [
-    params?.tokenIn?.address,
-    params?.tokenOut?.address,
-    params?.sourceChainId,
-    params?.destChainId,
-    params?.amount,
-    debounceMs,
-    fetchQuote
-  ]);
+  }, [paramsKey, debounceMs, fetchQuote]);
   (0, import_react3.useEffect)(() => {
-    if (!autoRefreshMs || !params) return;
+    if (!autoRefreshMs || !paramsKey) return;
     const interval = setInterval(() => fetchQuote(), autoRefreshMs);
     return () => clearInterval(interval);
-  }, [autoRefreshMs, params, fetchQuote]);
+  }, [autoRefreshMs, paramsKey, fetchQuote]);
   return (0, import_react3.useMemo)(
     () => ({
-      /** Latest quote data */
       data,
-      /** Whether a fetch is ongoing */
       loading,
-      /** Error (if any) */
       error,
-      /** Warning (e.g. high slippage alert) */
       warning,
-      /** Manual refetch */
-      refetch: () => fetchQuote()
+      refetch: fetchQuote
     }),
     [data, loading, error, warning, fetchQuote]
   );
@@ -778,7 +929,7 @@ function useQuote(params, options) {
 var import_react4 = require("react");
 
 // src/core/getBalances.ts
-var import_intents_sdk9 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk10 = require("@shogun-sdk/intents-sdk");
 async function getBalances(params, options) {
   const { addresses, cursorEvm, cursorSvm } = params;
   const { signal } = options ?? {};
@@ -791,7 +942,7 @@ async function getBalances(params, options) {
     cursorSvm
   });
   const start = performance.now();
-  const response = await fetch(`${import_intents_sdk9.TOKEN_SEARCH_API_BASE_URL}/tokens/balances`, {
+  const response = await fetch(`${import_intents_sdk10.TOKEN_SEARCH_API_BASE_URL}/tokens/balances`, {
     method: "POST",
     headers: {
       accept: "application/json",
@@ -890,7 +1041,7 @@ function useBalances(params) {
 }
 
 // src/react/index.ts
-var import_intents_sdk10 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk11 = require("@shogun-sdk/intents-sdk");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChainID,

package/dist/react.d.cts

@@ -1,7 +1,7 @@
 import { TokenSearchParams, TokenSearchResponse } from '@shogun-sdk/intents-sdk';
 export { ChainID, isEvmChain } from '@shogun-sdk/intents-sdk';
-import { a as SwapQuoteResponse, e as executeOrder, b as Stage, S as SwapQuoteParams, B as BalanceRequestParams, c as BalanceResponse } from './execute-FaLLPp1i.cjs';
-export { P as PlaceOrderResult, Q as QuoteTokenInfo, T as TokenBalance, f as TokenInfo, d as TokenSearchResponse } from './execute-FaLLPp1i.cjs';
+import { a as SwapQuoteResponse, e as executeOrder, b as Stage, g as PollResult, S as SwapQuoteParams, B as BalanceRequestParams, c as BalanceResponse } from './execute-DOv1i2Su.cjs';
+export { P as PlaceOrderResult, Q as QuoteTokenInfo, T as TokenBalance, f as TokenInfo, d as TokenSearchResponse } from './execute-DOv1i2Su.cjs';
 import { A as AdaptedWallet } from './wallet-MmUIz8GE.cjs';
 import { WalletClient } from 'viem';
 import '@mysten/sui/transactions';
@@ -29,13 +29,6 @@ type ExecuteOrderResult = Awaited<ReturnType<typeof executeOrder>>;
  * built-in stage tracking, loading states, and error handling.
  *
  * ---
- * ## Features
- * - Live stage updates (processing, approving, signing, submitting, etc.)
- * - Built-in 20-min deadline by default (current timestamp + 1200s)
- * - Safe state handling with unmount guards
- * - Works for both EVM and Solana wallets
- *
- * ---
  * ## Example
  * ```tsx
  * import { useExecuteOrder } from "@shogun-sdk/swap/react"
@@ -79,9 +72,10 @@ declare function useExecuteOrder(): {
     /** Raw SDK response data. */
     data: {
         status: boolean;
-        txHash: string;
+        orderId: string;
         chainId: number;
-        stage: string;
+        finalStatus: PollResult;
+        stage: Stage;
     } | {
         status: boolean;
         message: string;
@@ -92,44 +86,16 @@ declare function useExecuteOrder(): {
 };
 
 /**
- *  useQuote — React hook for fetching live swap quotes (single or cross-chain).
- *
- * @example
- * ```tsx
- * import { useQuote } from "@shogun-sdk/swap/react"
- *
- * export function SwapQuote({ params }) {
- *   const { data, loading, error, warning, refetch } = useQuote(params, { debounceMs: 300 })
- *
- *   if (loading) return <p>Fetching quote...</p>
- *   if (error) return <p style={{ color: "red" }}>{error.message}</p>
- *   if (warning) return <p style={{ color: "orange" }}>{warning}</p>
- *
- *   return (
- *     <div>
- *       <p>Output: {data?.amountOut.toString()}</p>
- *       <p>Reduced (after slippage): {data?.internal?.estimatedAmountOutReduced?.toString()}</p>
- *       <button onClick={refetch}>Refresh</button>
- *     </div>
- *   )
- * }
- * ```
+ * useQuote — React hook for fetching live swap quotes.
  */
 declare function useQuote(params: SwapQuoteParams | null, options?: {
-    /** Debounce duration (ms) for reactive fetches. Default: 250 */
     debounceMs?: number;
-    /** Optional polling interval (ms) for auto refresh */
     autoRefreshMs?: number;
 }): {
-    /** Latest quote data */
     data: SwapQuoteResponse | null;
-    /** Whether a fetch is ongoing */
     loading: boolean;
-    /** Error (if any) */
     error: Error | null;
-    /** Warning (e.g. high slippage alert) */
     warning: string | null;
-    /** Manual refetch */
     refetch: () => Promise<void>;
 };