@shogun-sdk/swap 0.0.2-test.4 → 0.0.2-test.41

package/dist/react.js

@@ -1,90 +1,19 @@
-// src/react/useTokenList.ts
-import { useEffect, useMemo, useRef, useState } from "react";
-
-// src/core/token-list.ts
-import { getTokenList as intentsGetTokenList } from "@shogun-sdk/intents-sdk";
-async function getTokenList(params) {
-  return intentsGetTokenList(params);
-}
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/react/useTokenList.ts
-var tokenCache = /* @__PURE__ */ new Map();
-function useTokenList(params) {
-  const [data, setData] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const controllerRef = useRef(null);
-  const debounceRef = useRef(null);
-  const debounceMs = params.debounceMs ?? 250;
-  const cacheKey = useMemo(() => {
-    return JSON.stringify({
-      q: params.q?.trim().toLowerCase() ?? "",
-      networkId: params.networkId ?? "all",
-      page: params.page ?? 1,
-      limit: params.limit ?? 50
-    });
-  }, [params.q, params.networkId, params.page, params.limit]);
-  async function fetchTokens(signal) {
-    if (tokenCache.has(cacheKey)) {
-      setData(tokenCache.get(cacheKey));
-      setLoading(false);
-      setError(null);
-      return;
-    }
-    try {
-      setLoading(true);
-      const result = await getTokenList({ ...params, signal });
-      tokenCache.set(cacheKey, result);
-      setData(result);
-      setError(null);
-    } catch (err) {
-      if (err.name !== "AbortError") {
-        const e = err instanceof Error ? err : new Error("Unknown error while fetching tokens");
-        setError(e);
-      }
-    } finally {
-      setLoading(false);
-    }
-  }
-  useEffect(() => {
-    if (!params.q && !params.networkId) return;
-    if (debounceRef.current) clearTimeout(debounceRef.current);
-    if (controllerRef.current) controllerRef.current.abort();
-    const controller = new AbortController();
-    controllerRef.current = controller;
-    debounceRef.current = setTimeout(() => {
-      fetchTokens(controller.signal);
-    }, debounceMs);
-    return () => {
-      controller.abort();
-      if (debounceRef.current) clearTimeout(debounceRef.current);
-    };
-  }, [cacheKey, debounceMs]);
-  return useMemo(
-    () => ({
-      /** Current fetched data (cached when possible) */
-      data,
-      /** Whether a request is in progress */
-      loading,
-      /** Error object if a request failed */
-      error,
-      /** Manually refetch the token list */
-      refetch: () => fetchTokens(),
-      /** Clear all cached token results (shared across hook instances) */
-      clearCache: () => tokenCache.clear()
-    }),
-    [data, loading, error]
-  );
-}
+// src/react/SwapProvider.tsx
+import { createContext, useContext, useMemo } from "react";
 
-// src/react/useExecuteOrder.ts
-import { useState as useState2, useCallback, useRef as useRef2, useEffect as useEffect2 } from "react";
+// src/core/getQuote.ts
+import { QuoteProvider } from "@shogun-sdk/intents-sdk";
+import { parseUnits } from "viem";
 
-// src/core/executeOrder/execute.ts
-import { ChainID as ChainID4, isEvmChain as isEvmChain2 } from "@shogun-sdk/intents-sdk";
-import { BaseError } from "viem";
+// src/core/execute/normalizeNative.ts
+import { isEvmChain as isEvmChain2 } from "@shogun-sdk/intents-sdk";
 
 // src/utils/address.ts
+import { zeroAddress } from "viem";
 var NATIVE_TOKEN = {
   ETH: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
   SOL: "So11111111111111111111111111111111111111111",
@@ -95,13 +24,32 @@ var isNativeAddress = (tokenAddress) => {
   const normalizedTokenAddress = tokenAddress.toLowerCase();
   return !!tokenAddress && NATIVE_ADDRESSES.includes(normalizedTokenAddress);
 };
+function normalizeEvmTokenAddress(address) {
+  const lower = address.toLowerCase();
+  return lower === NATIVE_TOKEN.ETH.toLowerCase() ? zeroAddress : address;
+}
 
 // src/utils/chain.ts
-import { ChainID } from "@shogun-sdk/intents-sdk";
-var SOLANA_CHAIN_ID = ChainID.Solana;
-var SupportedChains = [
+import { ChainID as BaseChainID, isEvmChain as isEvmChainIntent } from "@shogun-sdk/intents-sdk";
+var SOLANA_CHAIN_ID = BaseChainID.Solana;
+var CURRENT_SUPPORTED = [
+  BaseChainID.Solana,
+  BaseChainID.BSC,
+  BaseChainID.Base,
+  BaseChainID.MONAD
+];
+var ChainId = Object.entries(BaseChainID).reduce(
+  (acc, [key, value]) => {
+    if (typeof value === "number" && CURRENT_SUPPORTED.includes(value)) {
+      acc[key] = value;
+    }
+    return acc;
+  },
+  {}
+);
+var SupportedChainsInternal = [
   {
-    id: ChainID.Arbitrum,
+    id: BaseChainID.Arbitrum,
     name: "Arbitrum",
     isEVM: true,
     wrapped: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -110,7 +58,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: ChainID.Optimism,
+    id: BaseChainID.Optimism,
     name: "Optimism",
     isEVM: true,
     wrapped: "0x4200000000000000000000000000000000000006",
@@ -119,7 +67,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: ChainID.Base,
+    id: BaseChainID.Base,
     name: "Base",
     isEVM: true,
     wrapped: "0x4200000000000000000000000000000000000006",
@@ -128,7 +76,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: ChainID.Hyperliquid,
+    id: BaseChainID.Hyperliquid,
     name: "Hyperliquid",
     isEVM: true,
     wrapped: "0x5555555555555555555555555555555555555555",
@@ -137,7 +85,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: ChainID.BSC,
+    id: BaseChainID.BSC,
     name: "BSC",
     isEVM: true,
     wrapped: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
@@ -153,8 +101,21 @@ var SupportedChains = [
     symbol: "SOL",
     decimals: 9,
     tokenAddress: NATIVE_TOKEN.SOL
+  },
+  {
+    id: BaseChainID.MONAD,
+    name: "Monad",
+    isEVM: true,
+    wrapped: "0x3bd359C1119dA7Da1D913D1C4D2B7c461115433A",
+    symbol: "MON",
+    decimals: 18,
+    tokenAddress: NATIVE_TOKEN.ETH
   }
 ];
+var SupportedChains = SupportedChainsInternal.filter(
+  (c) => CURRENT_SUPPORTED.includes(c.id)
+);
+var isEvmChain = isEvmChainIntent;
 
 // src/utils/viem.ts
 function isViemWalletClient(wallet) {
@@ -182,11 +143,229 @@ function serializeBigIntsToStrings(obj) {
   return obj;
 }
 
+// src/core/execute/normalizeNative.ts
+function normalizeNative(chainId, address) {
+  if (isEvmChain2(chainId) && isNativeAddress(address)) {
+    const chain = SupportedChains.find((c) => c.id === chainId);
+    if (!chain?.wrapped)
+      throw new Error(`Wrapped token not found for chainId ${chainId}`);
+    return chain.wrapped;
+  }
+  return address;
+}
+
+// src/core/getQuote.ts
+async function getQuote(params) {
+  const amount = BigInt(params.amount);
+  if (!params.tokenIn?.address || !params.tokenOut?.address) {
+    throw new Error("Both tokenIn and tokenOut must include an address.");
+  }
+  if (!params.sourceChainId || !params.destChainId) {
+    throw new Error("Both sourceChainId and destChainId are required.");
+  }
+  if (amount <= 0n) {
+    throw new Error("Amount must be greater than 0.");
+  }
+  const slippagePercent = Math.min(Math.max(params.slippage ?? 0.5, 0), 50);
+  const slippageBps = BigInt(Math.round(slippagePercent * 100));
+  const applyUserSlippage = (value) => value * (10000n - slippageBps) / 10000n;
+  let warning;
+  if (slippagePercent > 10) {
+    warning = `\u26A0\uFE0F High slippage tolerance (${slippagePercent.toFixed(2)}%) \u2014 price may vary significantly.`;
+  }
+  const normalizedTokenIn = normalizeNative(params.sourceChainId, params.tokenIn.address);
+  const isSingleChain = params.sourceChainId === params.destChainId;
+  let data;
+  let netFloor;
+  let minStablecoinsAmount;
+  if (isSingleChain) {
+    const { quote, netAmountOut } = await QuoteProvider.getSingleChainNetQuote({
+      chainId: params.sourceChainId,
+      amount,
+      tokenIn: normalizedTokenIn,
+      tokenOut: params.tokenOut.address
+    });
+    netFloor = netAmountOut;
+    minStablecoinsAmount = 0n;
+    data = {
+      amountInUsd: quote.amountInUsd,
+      estimatedAmountInAsMinStablecoinAmount: 0n,
+      estimatedAmountOut: quote.amountOut,
+      estimatedAmountOutUsd: quote.amountOutUsd,
+      // filled in below once the user slippage buffer is known
+      estimatedAmountOutReduced: netAmountOut,
+      estimatedAmountOutUsdReduced: quote.amountOutUsd,
+      tokenIn: { address: params.tokenIn.address, chainId: params.sourceChainId },
+      tokenOut: { address: params.tokenOut.address, chainId: params.destChainId }
+    };
+  } else {
+    const crossChainQuote = await QuoteProvider.getCrossChainNetQuote({
+      sourceChainId: params.sourceChainId,
+      destChainId: params.destChainId,
+      tokenIn: normalizedTokenIn,
+      tokenOut: params.tokenOut.address,
+      amount
+    });
+    data = crossChainQuote;
+    netFloor = BigInt(crossChainQuote.estimatedAmountOutReduced);
+    minStablecoinsAmount = applyUserSlippage(
+      BigInt(crossChainQuote.estimatedAmountInAsMinStablecoinAmount)
+    );
+  }
+  const amountOut = applyUserSlippage(netFloor);
+  const grossAmountOut = BigInt(data.estimatedAmountOut);
+  const pricePerTokenOutInUsd = grossAmountOut > 0n ? data.estimatedAmountOutUsd / Number(grossAmountOut) : 0;
+  const amountOutUsd = Number(amountOut) * pricePerTokenOutInUsd;
+  const pricePerInputToken = grossAmountOut * 10n ** BigInt(params.tokenIn.decimals ?? 18) / amount;
+  return {
+    amountOut,
+    amountOutUsd,
+    amountInUsd: data.amountInUsd,
+    minStablecoinsAmount,
+    tokenIn: {
+      address: params.tokenIn.address,
+      decimals: params.tokenIn.decimals ?? 18,
+      chainId: params.sourceChainId
+    },
+    tokenOut: {
+      address: params.tokenOut.address,
+      decimals: params.tokenOut.decimals ?? 18,
+      chainId: params.destChainId
+    },
+    amountIn: amount,
+    pricePerInputToken,
+    slippage: slippagePercent,
+    internal: {
+      ...data,
+      estimatedAmountOutReduced: amountOut,
+      estimatedAmountOutUsdReduced: amountOutUsd
+    },
+    warning
+  };
+}
+function buildQuoteParams({
+  tokenIn,
+  tokenOut,
+  sourceChainId,
+  destChainId,
+  amount,
+  slippage
+}) {
+  return {
+    tokenIn,
+    tokenOut,
+    sourceChainId,
+    destChainId,
+    amount: parseUnits(amount.toString(), tokenIn.decimals ?? 18).toString(),
+    slippage
+  };
+}
+
+// src/core/getBalances.ts
+import { TOKEN_SEARCH_API_BASE_URL } from "@shogun-sdk/intents-sdk";
+async function getBalances(params, options) {
+  const { addresses, cursorEvm, cursorSvm } = params;
+  const { signal } = options ?? {};
+  if (!addresses?.evm && !addresses?.svm) {
+    throw new Error("At least one address (EVM or SVM) must be provided.");
+  }
+  const payload = JSON.stringify({
+    addresses,
+    cursorEvm,
+    cursorSvm
+  });
+  const start = performance.now();
+  const response = await fetch(`${TOKEN_SEARCH_API_BASE_URL}/tokens/balances`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: payload,
+    signal
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      throw new Error("Balance request was cancelled.");
+    }
+    throw err;
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Failed to fetch balances: ${response.status} ${text}`);
+  }
+  const data = await response.json().catch(() => {
+    throw new Error("Invalid JSON response from balances API.");
+  });
+  const duration = (performance.now() - start).toFixed(1);
+  if (process.env.NODE_ENV !== "production") {
+    console.debug(`[Shogun SDK] Fetched balances in ${duration}ms`);
+  }
+  const evmItems = data.evm?.items ?? [];
+  const svmItems = data.svm?.items ?? [];
+  const combined = [...evmItems, ...svmItems];
+  const filtered = combined.filter(
+    (b) => CURRENT_SUPPORTED.includes(b.chainId)
+  );
+  return {
+    results: filtered,
+    nextCursorEvm: data.evm?.cursor ?? null,
+    nextCursorSvm: data.svm?.cursor ?? null
+  };
+}
+
+// src/core/token-list.ts
+import { TOKEN_SEARCH_API_BASE_URL as TOKEN_SEARCH_API_BASE_URL2 } from "@shogun-sdk/intents-sdk";
+async function getTokenList(params) {
+  const url = new URL(`${TOKEN_SEARCH_API_BASE_URL2}/tokens/search`);
+  if (params.q) url.searchParams.append("q", params.q);
+  if (params.networkId) url.searchParams.append("networkId", String(params.networkId));
+  if (params.page) url.searchParams.append("page", String(params.page));
+  if (params.limit) url.searchParams.append("limit", String(params.limit));
+  const res = await fetch(url.toString(), {
+    signal: params.signal
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch tokens: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  const filteredResults = data.results.filter(
+    (token) => CURRENT_SUPPORTED.includes(token.chainId)
+  );
+  return {
+    ...data,
+    results: filteredResults,
+    count: filteredResults.length
+  };
+}
+
+// src/core/token.ts
+import { TOKEN_SEARCH_API_BASE_URL as TOKEN_SEARCH_API_BASE_URL3 } from "@shogun-sdk/intents-sdk";
+async function getTokensData(addresses) {
+  if (!addresses?.length) return [];
+  const response = await fetch(`${TOKEN_SEARCH_API_BASE_URL3}/tokens/tokens`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      accept: "*/*"
+    },
+    body: JSON.stringify({ addresses })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch token data: ${response.statusText}`);
+  }
+  const data = await response.json();
+  const filtered = data.filter((t) => CURRENT_SUPPORTED.includes(Number(t.chainId)));
+  return filtered;
+}
+
+// src/core/execute/execute.ts
+import { ChainID as ChainID2, isEvmChain as isEvmChain3 } from "@shogun-sdk/intents-sdk";
+import "viem";
+
 // src/wallet-adapter/evm-wallet-adapter/adapter.ts
-import "ethers/lib/ethers.js";
-import { hexValue } from "ethers/lib/utils.js";
 import {
-  custom
+  custom,
+  publicActions
 } from "viem";
 function isEVMTransaction(tx) {
   return typeof tx.from === "string";
@@ -205,15 +384,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 {
@@ -236,6 +426,20 @@ var adaptViemWallet = (wallet) => {
     if (!addr) throw new Error("No address found");
     return addr;
   };
+  const readContract = async ({
+    address: address2,
+    abi,
+    functionName,
+    args = []
+  }) => {
+    const publicClient = wallet.extend(publicActions);
+    return await publicClient.readContract({
+      address: address2,
+      abi,
+      functionName,
+      args
+    });
+  };
   return {
     vmType: "EVM" /* EVM */,
     transport: custom(wallet.transport),
@@ -243,51 +447,65 @@ var adaptViemWallet = (wallet) => {
     address,
     sendTransaction,
     signTypedData,
-    switchChain
+    switchChain,
+    readContract
   };
 };
 
-// src/core/executeOrder/handleEvmExecution.ts
+// src/core/execute/handleEvmExecution.ts
 import {
   getEVMSingleChainOrderTypedData,
-  getEVMCrossChainOrderTypedData,
-  PERMIT2_ADDRESS
+  getEVMCrossChainOrderTypedData
 } from "@shogun-sdk/intents-sdk";
-import { encodeFunctionData, erc20Abi } from "viem";
-
-// src/core/executeOrder/normalizeNative.ts
-import { isEvmChain } from "@shogun-sdk/intents-sdk";
-function normalizeNative(chainId, address) {
-  if (isEvmChain(chainId) && isNativeAddress(address)) {
-    const chain = SupportedChains.find((c) => c.id === chainId);
-    if (!chain?.wrapped)
-      throw new Error(`Wrapped token not found for chainId ${chainId}`);
-    return chain.wrapped;
-  }
-  return address;
-}
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
 
-// src/core/executeOrder/stageMessages.ts
+// src/core/execute/stageMessages.ts
 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",
+  success_limit: "Limit order has been submitted successfully.",
+  shogun_processing: "Shogun is processing your transaction",
+  error: "Transaction failed during submission"
 };
 
-// src/core/executeOrder/buildOrder.ts
+// src/core/execute/buildOrder.ts
 import { CrossChainOrder, SingleChainOrder } from "@shogun-sdk/intents-sdk";
+import { formatUnits, parseUnits as parseUnits2 } from "viem";
+
+// src/utils/order.ts
+var OrderExecutionType = /* @__PURE__ */ ((OrderExecutionType2) => {
+  OrderExecutionType2["LIMIT"] = "limit";
+  OrderExecutionType2["MARKET"] = "market";
+  return OrderExecutionType2;
+})(OrderExecutionType || {});
+
+// src/core/execute/buildOrder.ts
 async function buildOrder({
   quote,
   accountAddress,
   destination,
   deadline,
-  isSingleChain
+  isSingleChain,
+  orderType,
+  options
 }) {
   const { tokenIn, tokenOut } = quote;
+  let amountOutMin = BigInt(quote.internal.estimatedAmountOutReduced);
+  if (orderType === "limit" /* LIMIT */ && options && "executionPrice" in options) {
+    const executionPrice = Number(options.executionPrice);
+    if (Number.isFinite(executionPrice) && executionPrice > 0) {
+      const decimalsIn = tokenIn.decimals ?? 18;
+      const decimalsOut = tokenOut.decimals ?? 18;
+      const formattedAmountIn = Number(formatUnits(BigInt(quote.amountIn.toString()), decimalsIn));
+      const rawAmountOut = formattedAmountIn * executionPrice;
+      amountOutMin = parseUnits2(rawAmountOut.toString(), decimalsOut);
+    }
+  }
   if (isSingleChain) {
     return await SingleChainOrder.create({
       user: accountAddress,
@@ -295,7 +513,7 @@ async function buildOrder({
       tokenIn: tokenIn.address,
       tokenOut: tokenOut.address,
       amountIn: quote.amountIn,
-      amountOutMin: quote.internal.estimatedAmountOutReduced,
+      amountOutMin,
       deadline,
       destinationAddress: destination
     });
@@ -309,12 +527,166 @@ async function buildOrder({
     destinationTokenAddress: tokenOut.address,
     destinationAddress: destination,
     deadline,
-    destinationTokenMinAmount: quote.internal.estimatedAmountOutReduced,
+    destinationTokenMinAmount: amountOutMin,
     minStablecoinAmount: quote.minStablecoinsAmount
   });
 }
 
-// src/core/executeOrder/handleEvmExecution.ts
+// src/utils/pollOrderStatus.ts
+import { AUCTIONEER_URL } from "@shogun-sdk/intents-sdk";
+async function pollOrderStatus(address, orderId, options = {}) {
+  const { intervalMs = 2e3, timeoutMs = 3e5, authToken } = 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 = `${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",
+            // The /user_intent status endpoint requires the SIWE JWT; without it
+            // the request 401s after the order has already been submitted.
+            ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
+          }
+        });
+        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/execute/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/execute/ensurePermit2Allowance.ts
+import { encodeFunctionData, erc20Abi, maxUint256 } from "viem";
+import { PERMIT2_ADDRESS } from "@shogun-sdk/intents-sdk";
+async function ensurePermit2Allowance({
+  chainId,
+  tokenIn,
+  wallet,
+  accountAddress,
+  requiredAmount,
+  increaseByDelta = false
+}) {
+  const spender = PERMIT2_ADDRESS[chainId];
+  let currentAllowance = 0n;
+  try {
+    if (!wallet.readContract) {
+      throw new Error("Wallet does not implement readContract()");
+    }
+    currentAllowance = await wallet.readContract({
+      address: tokenIn,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [accountAddress, spender]
+    });
+  } catch (error) {
+    console.warn(`[Permit2] Failed to read allowance for ${tokenIn}`, error);
+  }
+  const approvalAmount = increaseByDelta ? currentAllowance + requiredAmount : maxUint256;
+  console.debug(
+    `[Permit2] Approving ${approvalAmount} for ${tokenIn} (current: ${currentAllowance}, required: ${requiredAmount})`
+  );
+  await wallet.sendTransaction({
+    to: tokenIn,
+    from: accountAddress,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [spender, approvalAmount]
+    }),
+    value: 0n
+  });
+  console.info(
+    `[Permit2] Approval transaction sent for ${tokenIn} on chain ${chainId}`
+  );
+}
+
+// src/core/execute/handleEvmExecution.ts
 async function handleEvmExecution({
   recipientAddress,
   quote,
@@ -322,18 +694,22 @@ async function handleEvmExecution({
   accountAddress,
   wallet,
   isSingleChain,
-  deadline,
-  update
+  update,
+  orderType,
+  options
 }) {
-  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
+  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage] ?? "";
+  const deadline = options?.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
   await wallet.switchChain(chainId);
   const tokenIn = normalizeNative(chainId, quote.tokenIn.address);
+  quote.tokenOut.address = normalizeEvmTokenAddress(quote.tokenOut.address);
   const shouldWrapNative = isNativeAddress(quote.tokenIn.address);
   update("processing", shouldWrapNative ? `${messageFor("processing")} (wrapping native token)` : messageFor("processing"));
   if (shouldWrapNative) {
+    quote.tokenIn.address === tokenIn;
     await wallet.sendTransaction({
       to: tokenIn,
-      data: encodeFunctionData({
+      data: encodeFunctionData2({
         abi: [{ type: "function", name: "deposit", stateMutability: "payable", inputs: [], outputs: [] }],
         functionName: "deposit",
         args: []
@@ -342,44 +718,70 @@ async function handleEvmExecution({
       from: accountAddress
     });
   }
-  update("approving", messageFor("approving"));
-  await wallet.sendTransaction({
-    to: tokenIn,
-    data: encodeFunctionData({
-      abi: erc20Abi,
-      functionName: "approve",
-      args: [PERMIT2_ADDRESS[chainId], BigInt(quote.amountIn)]
-    }),
-    value: 0n,
-    from: accountAddress
+  update("processing", messageFor("approving"));
+  await ensurePermit2Allowance({
+    chainId,
+    tokenIn,
+    wallet,
+    accountAddress,
+    requiredAmount: BigInt(quote.amountIn)
   });
-  update("approved", messageFor("approved"));
+  update("processing", messageFor("approved"));
   const destination = recipientAddress ?? accountAddress;
   const order = await buildOrder({
     quote,
     accountAddress,
     destination,
     deadline,
-    isSingleChain
+    isSingleChain,
+    orderType,
+    options
   });
-  update("signing", messageFor("signing"));
+  console.debug(`order`, order);
+  update("processing", messageFor("signing"));
   const { orderTypedData, nonce } = isSingleChain ? await getEVMSingleChainOrderTypedData(order) : await 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"));
+  if (orderType === "limit" /* LIMIT */) {
+    update("success", messageFor("success_limit"));
+    return {
+      status: true,
+      orderId,
+      chainId,
+      finalStatus: "OrderPlaced",
+      stage: "success"
+    };
+  } else {
+    const status = await pollOrderStatus(accountAddress, orderId, { authToken: options?.authToken });
+    return await handleOrderPollingResult({
+      status,
+      orderId,
+      chainId,
+      update,
+      messageFor
+    });
+  }
 }
 
-// src/core/executeOrder/handleSolanaExecution.ts
+// src/core/execute/handleSolanaExecution.ts
 import {
-  ChainID as ChainID3,
   getSolanaSingleChainOrderInstructions,
   getSolanaCrossChainOrderInstructions
 } from "@shogun-sdk/intents-sdk";
@@ -391,12 +793,14 @@ async function handleSolanaExecution({
   isSingleChain,
   update,
   accountAddress,
-  deadline
+  orderType,
+  options
 }) {
   if (!wallet.rpcUrl) {
     throw new Error("Solana wallet is missing rpcUrl");
   }
-  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
+  const deadline = options?.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage] ?? "";
   update("processing", messageFor("processing"));
   const destination = recipientAddress ?? accountAddress;
   const order = await buildOrder({
@@ -404,7 +808,9 @@ async function handleSolanaExecution({
     accountAddress,
     destination,
     deadline,
-    isSingleChain
+    isSingleChain,
+    orderType,
+    options
   });
   const txData = await getSolanaOrderInstructions({
     order,
@@ -412,10 +818,9 @@ async function handleSolanaExecution({
     rpcUrl: wallet.rpcUrl
   });
   const transaction = 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,
@@ -424,13 +829,28 @@ async function handleSolanaExecution({
   if (!response.success) {
     throw new Error("Auctioneer submission failed");
   }
-  update("success", messageFor("success"));
-  return {
-    status: true,
-    txHash: txSignature,
-    chainId: ChainID3.Solana,
-    stage: "success"
-  };
+  update("initiated", messageFor("initiated"));
+  const { intentId: orderId } = response.data;
+  update("initiated", messageFor("shogun_processing"));
+  if (orderType === "limit" /* LIMIT */) {
+    update("success", messageFor("success_limit"));
+    return {
+      status: true,
+      orderId,
+      chainId: SOLANA_CHAIN_ID,
+      finalStatus: "OrderPlaced",
+      stage: "success"
+    };
+  } else {
+    const status = await pollOrderStatus(accountAddress, orderId, { authToken: options?.authToken });
+    return await handleOrderPollingResult({
+      status,
+      orderId,
+      chainId: SOLANA_CHAIN_ID,
+      update,
+      messageFor
+    });
+  }
 }
 async function getSolanaOrderInstructions({
   order,
@@ -463,52 +883,93 @@ async function submitToAuctioneer({
   });
 }
 
-// src/core/executeOrder/execute.ts
+// src/core/execute/execute.ts
 async function executeOrder({
   quote,
   accountAddress,
   recipientAddress,
   wallet,
   onStatus,
+  orderType = "market" /* MARKET */,
   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 {
+    log("Starting execution:", {
+      accountAddress,
+      recipientAddress,
+      tokenIn: quote?.tokenIn,
+      tokenOut: quote?.tokenOut
+    });
     const adapter = normalizeWallet(wallet);
     if (!adapter) throw new Error("No wallet provided");
     const { tokenIn, tokenOut } = quote;
+    const srcChain = Number(tokenIn.chainId);
+    const destChain = Number(tokenOut.chainId);
+    if (!CURRENT_SUPPORTED.includes(srcChain) || !CURRENT_SUPPORTED.includes(destChain)) {
+      const unsupportedChains = [
+        !CURRENT_SUPPORTED.includes(srcChain) ? srcChain : null,
+        !CURRENT_SUPPORTED.includes(destChain) ? destChain : null
+      ].filter(Boolean).join(", ");
+      const errorMsg = `Unsupported chain(s): ${unsupportedChains}`;
+      update("error", errorMsg);
+      log("Error:", errorMsg);
+      throw new Error(errorMsg);
+    }
     const isSingleChain = tokenIn.chainId === tokenOut.chainId;
     const chainId = Number(tokenIn.chainId);
-    update("processing", messageFor("processing"));
-    if (isEvmChain2(chainId)) {
-      return await handleEvmExecution({
+    update("processing");
+    if (isEvmChain3(chainId)) {
+      log("Detected EVM chain:", chainId);
+      const result = await handleEvmExecution({
         recipientAddress,
         quote,
         chainId,
         accountAddress,
         wallet: adapter,
         isSingleChain,
-        deadline,
-        update
+        update,
+        orderType,
+        options
       });
+      log("EVM execution result:", result);
+      return result;
     }
-    if (chainId === ChainID4.Solana) {
-      return await handleSolanaExecution({
+    if (chainId === ChainID2.Solana) {
+      log("Detected Solana chain");
+      const result = await handleSolanaExecution({
         recipientAddress,
         quote,
         accountAddress,
         wallet: adapter,
         isSingleChain,
-        deadline,
-        update
+        update,
+        orderType,
+        options
       });
+      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 BaseError ? error.shortMessage : error instanceof Error ? error.message : String(error);
+    let message = "An unknown error occurred";
+    if (error && typeof error === "object") {
+      const err = error;
+      message = err.details ?? err.message ?? message;
+    } else if (typeof error === "string") {
+      message = error;
+    }
     update("error", message);
     return { status: false, message, stage: "error" };
   }
@@ -519,348 +980,998 @@ function normalizeWallet(wallet) {
   return wallet;
 }
 
-// src/react/useExecuteOrder.ts
-function useExecuteOrder() {
-  const [status, setStatus] = useState2("processing");
-  const [message, setMessage] = useState2(null);
-  const [loading, setLoading] = useState2(false);
-  const [data, setData] = useState2(null);
-  const [error, setError] = useState2(null);
-  const isMounted = useRef2(true);
-  useEffect2(() => {
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-  const execute = useCallback(
+// src/core/orders/getOrders.ts
+import { fetchUserOrders } from "@shogun-sdk/intents-sdk";
+async function getOrders({
+  evmAddress,
+  solAddress
+}) {
+  const wallets = [evmAddress, solAddress].filter(
+    (wallet) => Boolean(wallet)
+  );
+  if (wallets.length === 0) {
+    throw new Error("At least one wallet address (EVM, Solana) must be provided.");
+  }
+  const results = await Promise.all(
+    wallets.map((wallet) => fetchUserOrders({ wallet }))
+  );
+  return results.reduce(
+    (merged, orders) => {
+      merged.singleChainLimitOrders.push(...orders.singleChainLimitOrders);
+      merged.crossChainLimitOrders.push(...orders.crossChainLimitOrders);
+      return merged;
+    },
+    { singleChainLimitOrders: [], crossChainLimitOrders: [] }
+  );
+}
+
+// src/core/orders/cancelOrder.ts
+import {
+  cancelCrossChainOrderInstructionsAsBytes,
+  cancelSingleChainOrderInstructionsAsBytes,
+  ChainID as ChainID3,
+  CROSS_CHAIN_GUARD_ADDRESSES,
+  PERMIT2_ADDRESS as PERMIT2_ADDRESS2,
+  SINGLE_CHAIN_GUARD_ADDRESSES
+} from "@shogun-sdk/intents-sdk";
+import {
+  VersionedMessage,
+  VersionedTransaction as VersionedTransaction2
+} from "@solana/web3.js";
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+var inFlightCancels = /* @__PURE__ */ new Map();
+function cancelIntentsOrder(args) {
+  const srcChain = "srcChainId" in args.order ? args.order.srcChainId : args.order.chainId;
+  const key = `${srcChain}:${args.order.orderId}`;
+  const existing = inFlightCancels.get(key);
+  if (existing) return existing;
+  const pending = performCancel(args).finally(() => {
+    inFlightCancels.delete(key);
+  });
+  inFlightCancels.set(key, pending);
+  return pending;
+}
+async function performCancel({
+  order,
+  wallet,
+  sol_rpc
+}) {
+  const isCrossChain = "srcChainId" in order && "destChainId" in order && order.srcChainId !== order.destChainId;
+  const srcChain = "srcChainId" in order ? order.srcChainId : order.chainId;
+  const isSolanaOrder = srcChain === ChainID3.Solana;
+  if (isSolanaOrder) {
+    if (!isCrossChain) {
+      const { versionedMessageBytes: versionedMessageBytes2 } = await cancelSingleChainOrderInstructionsAsBytes(
+        order.orderId,
+        order.user,
+        { rpcUrl: sol_rpc }
+      );
+      const message2 = VersionedMessage.deserialize(
+        versionedMessageBytes2
+      );
+      const tx2 = new VersionedTransaction2(message2);
+      return await wallet.sendTransaction(tx2);
+    }
+    const { versionedMessageBytes } = await cancelCrossChainOrderInstructionsAsBytes(
+      order.orderId,
+      order.user,
+      { rpcUrl: sol_rpc }
+    );
+    const message = VersionedMessage.deserialize(
+      versionedMessageBytes
+    );
+    const tx = new VersionedTransaction2(message);
+    return await wallet.sendTransaction(tx);
+  }
+  const chainId = srcChain;
+  const { readContract } = wallet;
+  if (!readContract) {
+    throw new Error("Wallet does not support readContract");
+  }
+  const nonce = BigInt(order.nonce ?? "0");
+  const nonceWordPos = nonce >> 8n;
+  const nonceBitPos = nonce - nonceWordPos * 256n;
+  if (isCrossChain) {
+    const [orderData = [false, false], currentNonceBitmap = 0n] = await Promise.all([
+      readContract({
+        address: CROSS_CHAIN_GUARD_ADDRESSES[chainId],
+        abi: [
+          {
+            inputs: [{ name: "orderId", type: "bytes32" }],
+            name: "orderData",
+            outputs: [
+              { name: "initialized", type: "bool" },
+              { name: "deactivated", type: "bool" }
+            ],
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "orderData",
+        args: [order.orderId]
+      }),
+      readContract({
+        address: PERMIT2_ADDRESS2[chainId],
+        abi: [
+          {
+            inputs: [
+              { name: "owner", type: "address" },
+              { name: "wordPos", type: "uint256" }
+            ],
+            name: "nonceBitmap",
+            outputs: [{ name: "", type: "uint256" }],
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "nonceBitmap",
+        args: [order.user, nonceWordPos]
+      })
+    ]);
+    const [initialized, deactivated] = orderData;
+    if (initialized) {
+      if (deactivated) {
+        throw new Error("Order is already deactivated");
+      }
+      return await wallet.sendTransaction({
+        to: CROSS_CHAIN_GUARD_ADDRESSES[order.srcChainId],
+        data: encodeFunctionData3({
+          abi: [
+            {
+              inputs: [
+                {
+                  components: [
+                    { name: "user", type: "address" },
+                    { name: "tokenIn", type: "address" },
+                    { name: "srcChainId", type: "uint256" },
+                    { name: "deadline", type: "uint256" },
+                    { name: "amountIn", type: "uint256" },
+                    { name: "minStablecoinsAmount", type: "uint256" },
+                    { name: "executionDetailsHash", type: "bytes32" },
+                    { name: "nonce", type: "uint256" }
+                  ],
+                  name: "orderInfo",
+                  type: "tuple"
+                }
+              ],
+              name: "cancelOrder",
+              outputs: [],
+              stateMutability: "nonpayable",
+              type: "function"
+            }
+          ],
+          functionName: "cancelOrder",
+          args: [
+            {
+              user: order.user,
+              tokenIn: order.tokenIn,
+              srcChainId: BigInt(order.srcChainId),
+              deadline: BigInt(order.deadline),
+              amountIn: BigInt(order.amountIn),
+              minStablecoinsAmount: BigInt(order.minStablecoinsAmount),
+              executionDetailsHash: order.executionDetailsHash,
+              nonce
+            }
+          ]
+        }),
+        value: BigInt(0),
+        from: order.user
+      });
+    } else {
+      if ((currentNonceBitmap & 1n << nonceBitPos) !== 0n) {
+        throw new Error("Nonce is already invalidated");
+      }
+      const mask2 = 1n << nonceBitPos;
+      return await wallet.sendTransaction({
+        to: PERMIT2_ADDRESS2[order.srcChainId],
+        data: encodeFunctionData3({
+          abi: [
+            {
+              inputs: [
+                { name: "wordPos", type: "uint256" },
+                { name: "mask", type: "uint256" }
+              ],
+              name: "invalidateUnorderedNonces",
+              outputs: [],
+              stateMutability: "nonpayable",
+              type: "function"
+            }
+          ],
+          functionName: "invalidateUnorderedNonces",
+          args: [nonceWordPos, mask2]
+        }),
+        value: BigInt(0),
+        from: order.user
+      });
+    }
+  }
+  const [wasManuallyInitialized, currentBitmap = 0n] = await Promise.all([
+    readContract({
+      address: SINGLE_CHAIN_GUARD_ADDRESSES[chainId],
+      abi: [
+        {
+          inputs: [{ name: "orderHash", type: "bytes32" }],
+          name: "orderManuallyInitialized",
+          outputs: [{ name: "", type: "bool" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ],
+      functionName: "orderManuallyInitialized",
+      args: [order.orderId]
+    }),
+    readContract({
+      address: PERMIT2_ADDRESS2[chainId],
+      abi: [
+        {
+          inputs: [
+            { name: "owner", type: "address" },
+            { name: "wordPos", type: "uint256" }
+          ],
+          name: "nonceBitmap",
+          outputs: [{ name: "", type: "uint256" }],
+          stateMutability: "view",
+          type: "function"
+        }
+      ],
+      functionName: "nonceBitmap",
+      args: [order.user, nonceWordPos]
+    })
+  ]);
+  if (wasManuallyInitialized) {
+    return await wallet.sendTransaction({
+      to: SINGLE_CHAIN_GUARD_ADDRESSES[chainId],
+      data: encodeFunctionData3({
+        abi: [
+          {
+            inputs: [
+              {
+                name: "order",
+                type: "tuple",
+                components: [
+                  { name: "amountIn", type: "uint256" },
+                  { name: "tokenIn", type: "address" },
+                  { name: "deadline", type: "uint256" },
+                  { name: "nonce", type: "uint256" },
+                  { name: "encodedExternalCallData", type: "bytes" },
+                  {
+                    name: "extraTransfers",
+                    type: "tuple[]",
+                    components: [
+                      { name: "amount", type: "uint256" },
+                      { name: "receiver", type: "address" },
+                      { name: "token", type: "address" }
+                    ]
+                  },
+                  {
+                    name: "requestedOutput",
+                    type: "tuple",
+                    components: [
+                      { name: "amount", type: "uint256" },
+                      { name: "receiver", type: "address" },
+                      { name: "token", type: "address" }
+                    ]
+                  },
+                  { name: "user", type: "address" }
+                ]
+              }
+            ],
+            name: "cancelManuallyCreatedOrder",
+            outputs: [],
+            stateMutability: "nonpayable",
+            type: "function"
+          }
+        ],
+        functionName: "cancelManuallyCreatedOrder",
+        args: [
+          {
+            amountIn: BigInt(order.amountIn),
+            tokenIn: order.tokenIn,
+            deadline: BigInt(order.deadline),
+            nonce,
+            encodedExternalCallData: "0x",
+            extraTransfers: (order.extraTransfers || []).map((t) => ({
+              amount: BigInt(t.amount),
+              receiver: t.receiver,
+              token: t.token
+            })),
+            requestedOutput: {
+              amount: BigInt(order.amountOutMin),
+              receiver: order.destinationAddress,
+              token: order.tokenOut
+            },
+            user: order.user
+          }
+        ]
+      }),
+      value: 0n,
+      from: order.user
+    });
+  }
+  const mask = 1n << nonceBitPos;
+  if ((currentBitmap & mask) !== 0n) {
+    throw new Error("Nonce is already invalidated");
+  }
+  return await wallet.sendTransaction({
+    to: PERMIT2_ADDRESS2[chainId],
+    data: encodeFunctionData3({
+      abi: [
+        {
+          inputs: [
+            { name: "wordPos", type: "uint256" },
+            { name: "mask", type: "uint256" }
+          ],
+          name: "invalidateUnorderedNonces",
+          outputs: [],
+          stateMutability: "nonpayable",
+          type: "function"
+        }
+      ],
+      functionName: "invalidateUnorderedNonces",
+      args: [nonceWordPos, mask]
+    }),
+    value: 0n,
+    from: order.user
+  });
+}
+
+// src/core/client.ts
+var SwapSDK = class {
+  constructor(config) {
+    __publicField(this, "apiKey");
+    /**
+     * Fetches metadata for one or more tokens from the Shogun Token Search API.
+     *
+     * ---
+     * ### Overview
+     * `getTokensData` retrieves normalized token information — such as symbol, name,
+     * decimals, logo URI, and verified status — for a given list of token addresses.
+     *
+     * It supports both **EVM** and **SVM (Solana)** tokens, returning metadata from
+     * Shogun’s unified token registry.
+     *
+     * ---
+     * @example
+     * ```ts
+     * const tokens = await getTokensData([
+     *   "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+     *   "So11111111111111111111111111111111111111112", // SOL
+     * ]);
+     *
+     * console.log(tokens);
+     * [
+     * { symbol: "USDC", name: "USD Coin", chainId: 1, decimals: 6, ... },
+     * { symbol: "SOL", name: "Solana", chainId: 101, decimals: 9, ... }
+     * ]
+     * ```
+     *
+     * @param addresses - An array of token addresses (EVM or SVM) to fetch metadata for.
+     * @returns A promise resolving to an array of {@link TokenInfo} objects.
+     *
+     * @throws Will throw an error if the network request fails or the API responds with a non-OK status.
+     */
+    __publicField(this, "getTokensData", getTokensData.bind(this));
+    if (!config.apiKey) {
+      throw new Error("SwapSDK: Missing API key");
+    }
+    this.apiKey = config.apiKey;
+    if (this.apiKey) void this.apiKey;
+  }
+  /**
+   * Retrieves a swap quote for the given input and output tokens.
+   *
+   * @param params - Quote parameters including source/destination tokens and amount.
+   * @returns A normalized `SwapQuoteResponse` containing output amount, route, and metadata.
+   */
+  async getQuote(params) {
+    return getQuote(params);
+  }
+  /**
+   * Fetches token balances for the specified user wallet(s).
+   *
+   * Supports both EVM and SVM (Solana) wallet addresses.
+   *
+   * @param params - Wallet address and optional chain filters.
+   * @param options - Optional abort signal for cancellation.
+   * @returns A unified balance response with per-chain token details.
+   */
+  async getBalances(params, options) {
+    return getBalances(params, options);
+  }
+  /**
+   * Retrieves a list of verified tokens based on search query or chain filter.
+   *
+   * @param params - Search parameters (query, chain ID, pagination options).
+   * @returns Paginated `TokenSearchResponse` containing token metadata.
+   */
+  async getTokenList(params) {
+    return getTokenList(params);
+  }
+  /**
+   * Executes a prepared swap quote using the provided wallet and configuration.
+   *
+   * Handles:
+   * - Token approval (if required)
+   * - Transaction signing and broadcasting
+   * - Confirmation polling and stage-based status updates
+   *
+   * Supports both:
+   * - Market orders (with optional deadline)
+   * - Limit orders (requires executionPrice and deadline)
+   *
+   * @param quote - The swap quote to execute, containing route and metadata.
+   * @param accountAddress - The user's wallet address executing the swap.
+   * @param recipientAddress - Optional recipient address for the output tokens (defaults to sender).
+   * @param wallet - Adapted wallet instance (EVM/Solana) or a standard Viem `WalletClient`.
+   * @param onStatus - Optional callback for receiving execution stage updates and messages.
+   * @param orderType - Defines whether this is a market or limit order.
+   * @param options - Execution parameters (different per order type).
+   *
+   * @returns A finalized execution result containing transaction hash, status, and any returned data.
+   *
+   * @example
+   * ```ts
+   * * Market order
+   * const result = await sdk.executeTransaction({
+   *   quote,
+   *   accountAddress: "0x123...",
+   *   wallet,
+   *   orderType: OrderExecutionType.MARKET,
+   *   options: { deadline: 1800 },
+   *   onStatus: (stage, msg) => console.log(stage, msg),
+   * });
+   *
+   * * Limit order
+   * const result = await sdk.executeTransaction({
+   *   quote,
+   *   accountAddress: "0x123...",
+   *   wallet,
+   *   orderType: OrderExecutionType.LIMIT,
+   *   options: { executionPrice: "0.0021", deadline: 3600 },
+   * });
+   * ```
+   */
+  async executeTransaction({
+    quote,
+    accountAddress,
+    recipientAddress,
+    wallet,
+    onStatus,
+    orderType,
+    options
+  }) {
+    return executeOrder({
+      quote,
+      wallet,
+      accountAddress,
+      recipientAddress,
+      onStatus,
+      orderType,
+      options
+    });
+  }
+  /**
+  * Fetches all user orders (Market, Limit, Cross-chain) for connected wallets.
+  *
+  * ---
+  * ### Overview
+  * Retrieves both **single-chain** and **cross-chain** orders from the Shogun Intents API.
+  * Works across EVM, Solana
+  *
+  * ---
+  * @example
+  * ```ts
+  * const orders = await sdk.getOrders({
+  *   evmAddress: "0x123...",
+  *   solAddress: "9d12hF...abc",
+  * });
+  *
+  * console.log(orders.singleChainLimitOrders);
+  * ```
+  *
+  * @param params - Wallet addresses to fetch orders for (EVM, Solana).
+  * @returns A structured {@link ApiUserOrders} object containing all user orders.
+  */
+  async getOrders(params) {
+    return getOrders(params);
+  }
+  /**
+   * Cancels an order (single-chain or cross-chain) on EVM or Solana.
+   *
+   * Internally routes to the correct guard contract or Solana program to
+   * deactivate the order or invalidate its nonce.
+   *
+   * @param params.order - Order payload returned from the Intents API.
+   * @param params.wallet - Adapted wallet used to submit the cancellation transaction.
+   * @param params.solRpc - Solana RPC URL used for SVM cancellations.
+   *
+   * @returns A transaction signature or hash from the underlying wallet.
+   */
+  async cancelOrder(params) {
+    return cancelIntentsOrder({
+      order: params.order,
+      wallet: params.wallet,
+      sol_rpc: params.solRpc
+    });
+  }
+};
+
+// src/react/SwapProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var SwapContext = createContext(null);
+var SwapProvider = ({ config, children }) => {
+  const sdk = useMemo(() => new SwapSDK(config), [config.apiKey]);
+  return /* @__PURE__ */ jsx(SwapContext.Provider, { value: sdk, children });
+};
+var useSwap = () => {
+  const ctx = useContext(SwapContext);
+  if (!ctx) {
+    throw new Error("useSwap must be used within <SwapProvider>");
+  }
+  return ctx;
+};
+
+// src/react/useQuote.ts
+import { useCallback, useEffect, useMemo as useMemo2, useRef } from "react";
+import useSWR, { mutate } from "swr";
+var QUOTE_KEY = "quote-global";
+function isValidQuoteParams(p) {
+  if (!p) return false;
+  const { tokenIn, tokenOut, amount } = p;
+  if (!tokenIn || !tokenOut || !amount) return false;
+  const n = Number(amount);
+  return Number.isFinite(n) && n > 0;
+}
+function useQuote(initialParams) {
+  const sdk = useSwap();
+  const abortRef = useRef(null);
+  const paramsRef = globalThis.__QUOTE_PARAMS_REF__ ?? (globalThis.__QUOTE_PARAMS_REF__ = { current: initialParams ?? null });
+  useEffect(() => {
+    if (initialParams && JSON.stringify(paramsRef.current) !== JSON.stringify(initialParams)) {
+      paramsRef.current = initialParams;
+      void mutate(QUOTE_KEY);
+    }
+  }, [initialParams]);
+  const fetcher = useCallback(async () => {
+    const activeParams = paramsRef.current;
+    if (!isValidQuoteParams(activeParams)) return null;
+    if (abortRef.current) abortRef.current.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    try {
+      return await sdk.getQuote(activeParams);
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") return null;
+      if (err instanceof Error) throw err;
+      throw new Error(String(err));
+    }
+  }, [sdk]);
+  const {
+    data,
+    error,
+    isValidating: loading,
+    mutate: mutateQuote
+  } = useSWR(QUOTE_KEY, fetcher, {
+    revalidateOnFocus: false,
+    shouldRetryOnError: false,
+    keepPreviousData: true
+  });
+  const refetch = useCallback(async () => {
+    await mutateQuote();
+  }, [mutateQuote]);
+  const setParams = useCallback(
+    (next) => {
+      paramsRef.current = next;
+      void mutate(QUOTE_KEY);
+    },
+    []
+  );
+  return useMemo2(
+    () => ({
+      data,
+      loading,
+      error: error instanceof Error ? error.message : null,
+      refetch,
+      setParams,
+      get activeParams() {
+        return paramsRef.current;
+      }
+    }),
+    [data, loading, error, refetch, setParams]
+  );
+}
+
+// src/react/useExecuteTransaction.ts
+import { useState, useCallback as useCallback3 } from "react";
+
+// src/react/useBalances.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2 } from "react";
+import useSWR2, { mutate as mutate2 } from "swr";
+var BALANCE_KEY = "balances-global";
+function useBalances(initialParams, options) {
+  const sdk = useSwap();
+  const abortRef = useRef2(null);
+  const lastDataRef = useRef2(null);
+  const paramsRef = globalThis.__BALANCES_PARAMS_REF__ ?? (globalThis.__BALANCES_PARAMS_REF__ = { current: initialParams ?? null });
+  const fetcher = useCallback2(async () => {
+    const activeParams = paramsRef.current;
+    if (!activeParams) return null;
+    if (abortRef.current) abortRef.current.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    try {
+      const balances = await sdk.getBalances(activeParams, { signal: controller.signal });
+      lastDataRef.current = balances;
+      return balances;
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") return lastDataRef.current;
+      if (err instanceof Error) throw err;
+      throw new Error(String(err));
+    }
+  }, [sdk, paramsRef]);
+  const {
+    data,
+    error,
+    // `isLoading` is only true on the initial fetch (no data yet), so background
+    // refreshes on `refreshInterval` don't toggle it and flicker the UI.
+    isLoading: loading,
+    isValidating,
+    mutate: mutateBalances
+  } = useSWR2(BALANCE_KEY, fetcher, {
+    revalidateOnFocus: false,
+    shouldRetryOnError: false,
+    keepPreviousData: true,
+    // 0 (default) disables polling; a positive value re-fetches on that interval.
+    refreshInterval: options?.refreshInterval ?? 0
+  });
+  const refetch = useCallback2(async () => {
+    await mutateBalances();
+  }, [mutateBalances]);
+  const setParams = useCallback2((next) => {
+    paramsRef.current = next;
+    void mutate2(BALANCE_KEY);
+  }, [paramsRef]);
+  useEffect2(() => {
+    if (initialParams) {
+      const prevParams = paramsRef.current;
+      const paramsChanged = !prevParams || prevParams.addresses.svm !== initialParams.addresses.svm || prevParams.addresses.evm !== initialParams.addresses.evm;
+      if (paramsChanged) {
+        paramsRef.current = initialParams;
+        void mutate2(BALANCE_KEY);
+      }
+    }
+  }, [initialParams, paramsRef]);
+  return useMemo3(
+    () => ({
+      data,
+      loading,
+      // True during background revalidation (e.g. `refreshInterval` polls) while
+      // previous `data` stays visible — use for a subtle refresh indicator.
+      isValidating,
+      error: error instanceof Error ? error : null,
+      refetch,
+      setParams,
+      get activeParams() {
+        return paramsRef.current;
+      }
+    }),
+    [data, loading, isValidating, error, refetch, setParams, paramsRef]
+  );
+}
+
+// src/react/useExecuteTransaction.ts
+function useExecuteTransaction() {
+  const sdk = useSwap();
+  const [isLoading, setLoading] = useState(false);
+  const [stage, setStage] = useState(null);
+  const [message, setMessage] = useState(null);
+  const [error, setError] = useState(null);
+  const [result, setResult] = useState(null);
+  const { refetch: refetchQuote } = useQuote();
+  const { refetch: refetchBalances } = useBalances();
+  const execute = useCallback3(
     async ({
       quote,
       accountAddress,
       recipientAddress,
       wallet,
-      deadline
+      orderType,
+      options
     }) => {
-      if (!quote || !wallet) {
-        throw new Error("Quote and wallet are required for order execution.");
-      }
       setLoading(true);
       setError(null);
-      setData(null);
-      setMessage(null);
+      setResult(null);
+      const onStatus = (s, msg) => {
+        setStage(s);
+        setMessage(msg ?? "");
+      };
       try {
-        const effectiveDeadline = deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
-        const onStatus = (stage, msg) => {
-          if (!isMounted.current) return;
-          setStatus(stage);
-          if (msg) setMessage(msg);
-        };
-        const result = await executeOrder({
+        const res = await sdk.executeTransaction({
           quote,
+          wallet,
           accountAddress,
           recipientAddress,
-          wallet,
           onStatus,
-          options: { deadline: effectiveDeadline }
+          orderType,
+          options
         });
-        if (!isMounted.current) return result;
-        setData(result);
-        setStatus(result.stage);
-        setMessage("Order executed successfully");
-        return result;
-      } catch (err) {
-        const errorObj = err instanceof Error ? err : new Error(String(err));
-        if (isMounted.current) {
-          setError(errorObj);
-          setStatus("error");
-          setMessage(errorObj.message);
-          setData({
-            status: false,
-            stage: "error",
-            message: errorObj.message
+        if (res && typeof res === "object" && "status" in res && "stage" in res && typeof res.stage === "string") {
+          setResult({
+            ...res,
+            stage: res.stage
           });
+        } else {
+          setResult(res);
         }
-        return {
-          status: false,
-          stage: "error",
-          message: errorObj.message
-        };
+        return res;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        setError(msg);
+        throw err;
       } finally {
-        if (isMounted.current) setLoading(false);
+        await Promise.allSettled([refetchQuote(), refetchBalances()]);
+        setLoading(false);
       }
     },
-    []
+    [sdk, refetchQuote, refetchBalances]
   );
   return {
-    /** Executes the swap order. */
     execute,
-    /** Current execution stage. */
-    status,
-    /** Human-readable status message. */
+    isLoading,
+    stage,
     message,
-    /** Whether execution is ongoing. */
-    loading,
-    /** Raw SDK response data. */
-    data,
-    /** Captured error (if execution failed). */
-    error
-  };
-}
-
-// src/react/useQuote.ts
-import { useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef3, useState as useState3 } from "react";
-
-// src/core/getQuote.ts
-import { QuoteProvider } from "@shogun-sdk/intents-sdk";
-import { parseUnits } from "viem";
-async function getQuote(params) {
-  if (!params.tokenIn?.address || !params.tokenOut?.address) {
-    throw new Error("Both tokenIn and tokenOut must include an address.");
-  }
-  if (!params.sourceChainId || !params.destChainId) {
-    throw new Error("Both sourceChainId and destChainId are required.");
-  }
-  if (params.amount <= 0n) {
-    throw new Error("Amount must be greater than 0.");
-  }
-  const normalizedTokenIn = normalizeNative(params.sourceChainId, params.tokenIn.address);
-  const data = await 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);
-  let warning;
-  if (slippage > 0.1) {
-    warning = `\u26A0\uFE0F High slippage tolerance (${(slippage * 100).toFixed(2)}%) \u2014 price may vary significantly.`;
-  }
-  const estimatedAmountOut = BigInt(data.estimatedAmountOutReduced);
-  const slippageBps = BigInt(Math.round(slippage * 1e4));
-  const estimatedAmountOutAfterSlippage = estimatedAmountOut * (10000n - slippageBps) / 10000n;
-  const pricePerInputToken = estimatedAmountOut * 10n ** BigInt(params.tokenIn.decimals ?? 18) / BigInt(params.amount);
-  return {
-    amountOut: estimatedAmountOut,
-    amountOutUsd: data.estimatedAmountOutUsd,
-    amountInUsd: data.amountInUsd,
-    minStablecoinsAmount: data.estimatedAmountInAsMinStablecoinAmount,
-    tokenIn: {
-      address: params.tokenIn.address,
-      decimals: params.tokenIn.decimals ?? 18,
-      chainId: params.sourceChainId
-    },
-    tokenOut: {
-      address: params.tokenOut.address,
-      decimals: params.tokenOut.decimals ?? 18,
-      chainId: params.destChainId
-    },
-    amountIn: params.amount,
-    pricePerInputToken,
-    slippage,
-    internal: {
-      ...data,
-      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage
-    },
-    warning
+    error,
+    result
   };
 }
 
-// src/react/useQuote.ts
-function useQuote(params, options) {
-  const [data, setData] = useState3(null);
-  const [loading, setLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const [warning, setWarning] = useState3(null);
-  const debounceMs = options?.debounceMs ?? 250;
-  const autoRefreshMs = options?.autoRefreshMs;
-  const abortRef = useRef3(null);
-  const debounceRef = useRef3(null);
-  const mounted = useRef3(false);
-  useEffect3(() => {
-    mounted.current = true;
-    return () => {
-      mounted.current = false;
-      abortRef.current?.abort();
-      if (debounceRef.current) clearTimeout(debounceRef.current);
-    };
-  }, []);
-  const fetchQuote = useCallback2(
-    async () => {
-      if (!params) return;
+// src/react/useTokenList.ts
+import { useRef as useRef3, useState as useState2, useCallback as useCallback4 } from "react";
+function useTokenList() {
+  const [tokens, setTokens] = useState2([]);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [hasMore, setHasMore] = useState2(true);
+  const [page, setPage] = useState2(1);
+  const sdk = useSwap();
+  const pageRef = useRef3(1);
+  const hasMoreRef = useRef3(true);
+  const lastQuery = useRef3({});
+  const cache = useRef3(/* @__PURE__ */ new Map());
+  const isLoadingRef = useRef3(false);
+  pageRef.current = page;
+  hasMoreRef.current = hasMore;
+  const loadTokens = useCallback4(
+    async (params) => {
+      const { q, networkId, reset } = params;
+      if (isLoadingRef.current && !reset) return;
       try {
+        let currentPage = pageRef.current;
+        if (reset) {
+          currentPage = 1;
+          setTokens([]);
+          setPage(1);
+          setHasMore(true);
+          pageRef.current = 1;
+          hasMoreRef.current = true;
+        }
+        if (!reset && !hasMoreRef.current) return;
+        isLoadingRef.current = true;
         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)));
+        const cacheKey = JSON.stringify({
+          q: q?.toLowerCase() ?? "",
+          networkId: networkId ?? void 0,
+          page: currentPage
+        });
+        if (cache.current.has(cacheKey)) {
+          const cached = cache.current.get(cacheKey);
+          setTokens((prev) => reset ? cached.results : [...prev, ...cached.results]);
+          if (!reset && cached.results.length > 0) {
+            const nextPage = currentPage + 1;
+            setPage(nextPage);
+            pageRef.current = nextPage;
+          }
+          isLoadingRef.current = false;
+          setLoading(false);
+          return;
+        }
+        const apiParams = {
+          q,
+          page: currentPage,
+          limit: 20,
+          ...networkId !== void 0 ? { networkId } : {}
+        };
+        const res = await sdk.getTokenList(apiParams);
+        cache.current.set(cacheKey, res);
+        setTokens((prev) => reset ? res.results : [...prev, ...res.results]);
+        const isLastPage = res.results.length === 0 || res.results.length < 20 || res.count && currentPage * 20 >= res.count;
+        setHasMore(!isLastPage);
+        hasMoreRef.current = !isLastPage;
+        if (!reset && !isLastPage) {
+          const nextPage = currentPage + 1;
+          setPage(nextPage);
+          pageRef.current = nextPage;
+        }
+        lastQuery.current = { q, networkId };
+      } catch (e) {
+        console.error("useTokenList error:", e);
+        setError("Failed to load tokens");
       } finally {
-        if (mounted.current) setLoading(false);
+        setLoading(false);
+        isLoadingRef.current = false;
       }
     },
-    [params]
+    [sdk]
   );
+  const resetTokens = useCallback4(() => {
+    setTokens([]);
+    setPage(1);
+    setHasMore(true);
+    pageRef.current = 1;
+    hasMoreRef.current = true;
+    cache.current.clear();
+    lastQuery.current = {};
+  }, []);
+  return {
+    tokens,
+    loading,
+    error,
+    hasMore,
+    page,
+    lastQuery: lastQuery.current,
+    loadTokens,
+    resetTokens
+  };
+}
+
+// src/react/useTokensData.ts
+import { useState as useState3, useEffect as useEffect3 } from "react";
+function useTokensData(addresses) {
+  const sdk = useSwap();
+  const [data, setData] = useState3([]);
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
   useEffect3(() => {
-    if (!params) return;
-    if (debounceRef.current) clearTimeout(debounceRef.current);
-    debounceRef.current = setTimeout(() => {
-      fetchQuote();
-    }, debounceMs);
+    if (!addresses?.length) return;
+    let isMounted = true;
+    setLoading(true);
+    setError(null);
+    sdk.getTokensData(addresses).then((res) => {
+      if (isMounted) setData(res);
+    }).catch((e) => {
+      if (isMounted) setError(e instanceof Error ? e : new Error(String(e)));
+    }).finally(() => {
+      if (isMounted) setLoading(false);
+    });
     return () => {
-      if (debounceRef.current) clearTimeout(debounceRef.current);
-      abortRef.current?.abort();
+      isMounted = false;
     };
-  }, [params, debounceMs, fetchQuote]);
-  useEffect3(() => {
-    if (!autoRefreshMs || !params) return;
-    const interval = setInterval(() => fetchQuote(), autoRefreshMs);
-    return () => clearInterval(interval);
-  }, [autoRefreshMs, params, fetchQuote]);
-  return useMemo2(
-    () => ({
-      data,
-      loading,
-      error,
-      warning,
-      refetch: () => fetchQuote()
-    }),
-    [data, loading, error, warning, fetchQuote]
-  );
+  }, [sdk, JSON.stringify(addresses)]);
+  return { data, loading, error };
 }
 
-// src/react/useBalances.ts
-import { useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef4, useState as useState4 } from "react";
-
-// src/core/getBalances.ts
-import { TOKEN_SEARCH_API_BASE_URL } from "@shogun-sdk/intents-sdk";
-async function getBalances(params, options) {
-  const { addresses, cursorEvm, cursorSvm } = params;
-  const { signal } = options ?? {};
-  if (!addresses?.evm && !addresses?.svm) {
-    throw new Error("At least one address (EVM or SVM) must be provided.");
-  }
-  const payload = JSON.stringify({
-    addresses,
-    cursorEvm,
-    cursorSvm
-  });
-  const start = performance.now();
-  const response = await fetch(`${TOKEN_SEARCH_API_BASE_URL}/tokens/balances`, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "Content-Type": "application/json"
-    },
-    body: payload,
-    signal
-  }).catch((err) => {
-    if (err.name === "AbortError") {
-      throw new Error("Balance request was cancelled.");
-    }
-    throw err;
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(`Failed to fetch balances: ${response.status} ${text}`);
-  }
-  const data = await response.json().catch(() => {
-    throw new Error("Invalid JSON response from balances API.");
-  });
-  const duration = (performance.now() - start).toFixed(1);
-  if (process.env.NODE_ENV !== "production") {
-    console.debug(`[Shogun SDK] Fetched balances in ${duration}ms`);
-  }
-  const evmItems = data.evm?.items ?? [];
-  const svmItems = data.svm?.items ?? [];
-  const combined = [...evmItems, ...svmItems];
-  return {
-    results: combined,
-    nextCursorEvm: data.evm?.cursor ?? null,
-    nextCursorSvm: data.svm?.cursor ?? null
-  };
+// src/react/useOrders.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useMemo as useMemo4, useRef as useRef4 } from "react";
+import useSWR3, { mutate as mutate3 } from "swr";
+var ORDERS_KEY = "orders-global";
+function hasValidAddress(addrs) {
+  if (!addrs) return false;
+  return Boolean(addrs.evmAddress || addrs.solAddress || addrs.suiAddress);
 }
-
-// src/react/useBalances.ts
-function useBalances(params) {
-  const [data, setData] = useState4(null);
-  const [loading, setLoading] = useState4(false);
-  const [error, setError] = useState4(null);
+function useOrders(initialAddresses) {
+  const sdk = useSwap();
   const abortRef = useRef4(null);
-  const stableParams = useMemo3(() => {
-    if (!params) return null;
-    const { addresses, cursorEvm, cursorSvm } = params;
-    return {
-      addresses: {
-        evm: addresses?.evm ?? void 0,
-        svm: addresses?.svm ?? void 0
-      },
-      cursorEvm,
-      cursorSvm
-    };
-  }, [params?.addresses?.evm, params?.addresses?.svm, params?.cursorEvm, params?.cursorSvm]);
-  const fetchBalances = useCallback3(async () => {
-    if (!stableParams) return;
+  const addrRef = globalThis.__ORDERS_ADDR_REF__ ?? (globalThis.__ORDERS_ADDR_REF__ = { current: initialAddresses ?? null });
+  useEffect4(() => {
+    if (initialAddresses && JSON.stringify(addrRef.current) !== JSON.stringify(initialAddresses)) {
+      addrRef.current = initialAddresses;
+      void mutate3(ORDERS_KEY);
+    }
+  }, [initialAddresses]);
+  const fetcher = useCallback5(async () => {
+    const active = addrRef.current;
+    if (!hasValidAddress(active)) return null;
     if (abortRef.current) abortRef.current.abort();
     const controller = new AbortController();
     abortRef.current = controller;
-    setLoading(true);
-    setError(null);
     try {
-      const result = await getBalances(stableParams, { signal: controller.signal });
-      setData((prev) => {
-        if (JSON.stringify(prev) === JSON.stringify(result)) return prev;
-        return result;
-      });
-      return result;
+      return await sdk.getOrders(active ?? {});
     } catch (err) {
-      if (err.name === "AbortError") return;
-      const e = err instanceof Error ? err : new Error(String(err));
-      setError(e);
-      throw e;
-    } finally {
-      setLoading(false);
+      if (err instanceof DOMException && err.name === "AbortError") return null;
+      if (err instanceof Error) throw err;
+      throw new Error(String(err));
     }
-  }, [stableParams]);
-  useEffect4(() => {
-    if (stableParams) fetchBalances().catch(() => {
-    });
-    return () => {
-      if (abortRef.current) abortRef.current.abort();
-    };
-  }, [fetchBalances]);
-  return useMemo3(
+  }, [sdk]);
+  const {
+    data,
+    error,
+    isValidating: loading,
+    mutate: mutateOrders
+  } = useSWR3(ORDERS_KEY, fetcher, {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    shouldRetryOnError: false,
+    keepPreviousData: true
+  });
+  const refetch = useCallback5(async () => {
+    await mutateOrders();
+  }, [mutateOrders]);
+  const setAddresses = useCallback5(
+    (next) => {
+      if (!next) return;
+      addrRef.current = next;
+      void mutate3(ORDERS_KEY);
+    },
+    []
+  );
+  return useMemo4(
     () => ({
-      /** Latest fetched balance data */
       data,
-      /** Whether the hook is currently fetching */
       loading,
-      /** Error object if fetching failed */
-      error,
-      /** Manually trigger a refresh */
-      refetch: fetchBalances
+      error: error instanceof Error ? error.message : null,
+      refetch,
+      setAddresses,
+      get activeAddresses() {
+        return addrRef.current;
+      }
     }),
-    [data, loading, error, fetchBalances]
+    [data, loading, error, refetch, setAddresses]
   );
 }
 
-// src/react/index.ts
-import { ChainID as ChainID5, isEvmChain as isEvmChain3 } from "@shogun-sdk/intents-sdk";
+// src/react/useCancelOrder.ts
+import { useCallback as useCallback6, useState as useState4 } from "react";
+import { mutate as mutate4 } from "swr";
+function useCancelOrder() {
+  const sdk = useSwap();
+  const [isLoading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [result, setResult] = useState4(null);
+  const cancel = useCallback6(
+    async (params) => {
+      setLoading(true);
+      setError(null);
+      setResult(null);
+      try {
+        const tx = await sdk.cancelOrder({
+          order: params.order,
+          wallet: params.wallet,
+          solRpc: params.solRpc
+        });
+        setResult(tx);
+        void mutate4("orders-global");
+        return tx;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        setError(msg);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [sdk]
+  );
+  return {
+    cancel,
+    isLoading,
+    error,
+    result
+  };
+}
 export {
-  ChainID5 as ChainID,
-  isEvmChain3 as isEvmChain,
+  ChainId,
+  OrderExecutionType,
+  SupportedChains,
+  SwapProvider,
+  buildQuoteParams,
+  isEvmChain,
   useBalances,
-  useExecuteOrder,
+  useCancelOrder,
+  useExecuteTransaction,
+  useOrders,
   useQuote,
-  useTokenList
+  useSwap,
+  useTokenList,
+  useTokensData
 };