@shogun-sdk/swap 0.0.2-test.25 → 0.0.2-test.27

package/dist/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,44 +17,26 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  NATIVE_TOKEN: () => NATIVE_TOKEN,
-  SOLANA_CHAIN_ID: () => SOLANA_CHAIN_ID,
+  ChainId: () => ChainId,
+  OrderExecutionType: () => OrderExecutionType,
   SupportedChains: () => SupportedChains,
-  adaptEthersSigner: () => adaptEthersSigner,
-  adaptSolanaWallet: () => adaptSolanaWallet,
-  adaptViemWallet: () => adaptViemWallet,
+  SwapSDK: () => SwapSDK,
   buildQuoteParams: () => buildQuoteParams,
-  executeOrder: () => executeOrder,
-  getBalances: () => getBalances,
-  getQuote: () => getQuote,
-  getTokenList: () => getTokenList,
-  isNativeAddress: () => isNativeAddress,
-  isViemWalletClient: () => isViemWalletClient,
-  normalizeEvmTokenAddress: () => normalizeEvmTokenAddress,
-  serializeBigIntsToStrings: () => serializeBigIntsToStrings,
-  useBalances: () => useBalances,
-  useExecuteOrder: () => useExecuteOrder,
-  useQuote: () => useQuote,
-  useTokenList: () => useTokenList
+  isEvmChain: () => isEvmChain
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/core/token-list.ts
-var import_intents_sdk = require("@shogun-sdk/intents-sdk");
-async function getTokenList(params) {
-  return (0, import_intents_sdk.getTokenList)(params);
-}
-
 // src/core/getQuote.ts
-var import_intents_sdk4 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk3 = require("@shogun-sdk/intents-sdk");
 var import_viem2 = require("viem");
 
-// src/core/executeOrder/normalizeNative.ts
-var import_intents_sdk3 = require("@shogun-sdk/intents-sdk");
+// src/core/execute/normalizeNative.ts
+var import_intents_sdk2 = require("@shogun-sdk/intents-sdk");
 
 // src/utils/address.ts
 var import_viem = require("viem");
@@ -73,11 +56,25 @@ function normalizeEvmTokenAddress(address) {
 }
 
 // src/utils/chain.ts
-var import_intents_sdk2 = require("@shogun-sdk/intents-sdk");
-var SOLANA_CHAIN_ID = import_intents_sdk2.ChainID.Solana;
-var SupportedChains = [
+var import_intents_sdk = require("@shogun-sdk/intents-sdk");
+var SOLANA_CHAIN_ID = import_intents_sdk.ChainID.Solana;
+var CURRENT_SUPPORTED = [
+  import_intents_sdk.ChainID.Solana,
+  import_intents_sdk.ChainID.BSC,
+  import_intents_sdk.ChainID.Base
+];
+var ChainId = Object.entries(import_intents_sdk.ChainID).reduce(
+  (acc, [key, value]) => {
+    if (typeof value === "number" && CURRENT_SUPPORTED.includes(value)) {
+      acc[key] = value;
+    }
+    return acc;
+  },
+  {}
+);
+var SupportedChainsInternal = [
   {
-    id: import_intents_sdk2.ChainID.Arbitrum,
+    id: import_intents_sdk.ChainID.Arbitrum,
     name: "Arbitrum",
     isEVM: true,
     wrapped: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -86,7 +83,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: import_intents_sdk2.ChainID.Optimism,
+    id: import_intents_sdk.ChainID.Optimism,
     name: "Optimism",
     isEVM: true,
     wrapped: "0x4200000000000000000000000000000000000006",
@@ -95,7 +92,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: import_intents_sdk2.ChainID.Base,
+    id: import_intents_sdk.ChainID.Base,
     name: "Base",
     isEVM: true,
     wrapped: "0x4200000000000000000000000000000000000006",
@@ -104,7 +101,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: import_intents_sdk2.ChainID.Hyperliquid,
+    id: import_intents_sdk.ChainID.Hyperliquid,
     name: "Hyperliquid",
     isEVM: true,
     wrapped: "0x5555555555555555555555555555555555555555",
@@ -113,7 +110,7 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.ETH
   },
   {
-    id: import_intents_sdk2.ChainID.BSC,
+    id: import_intents_sdk.ChainID.BSC,
     name: "BSC",
     isEVM: true,
     wrapped: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
@@ -131,6 +128,10 @@ var SupportedChains = [
     tokenAddress: NATIVE_TOKEN.SOL
   }
 ];
+var SupportedChains = SupportedChainsInternal.filter(
+  (c) => CURRENT_SUPPORTED.includes(c.id)
+);
+var isEvmChain = import_intents_sdk.isEvmChain;
 
 // src/utils/viem.ts
 function isViemWalletClient(wallet) {
@@ -158,9 +159,9 @@ function serializeBigIntsToStrings(obj) {
   return obj;
 }
 
-// src/core/executeOrder/normalizeNative.ts
+// src/core/execute/normalizeNative.ts
 function normalizeNative(chainId, address) {
-  if ((0, import_intents_sdk3.isEvmChain)(chainId) && isNativeAddress(address)) {
+  if ((0, import_intents_sdk2.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}`);
@@ -171,22 +172,23 @@ function normalizeNative(chainId, 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 (params.amount <= 0n) {
+  if (amount <= 0n) {
     throw new Error("Amount must be greater than 0.");
   }
   const normalizedTokenIn = normalizeNative(params.sourceChainId, params.tokenIn.address);
-  const data = await import_intents_sdk4.QuoteProvider.getQuote({
+  const data = await import_intents_sdk3.QuoteProvider.getQuote({
     sourceChainId: params.sourceChainId,
     destChainId: params.destChainId,
     tokenIn: normalizedTokenIn,
     tokenOut: params.tokenOut.address,
-    amount: params.amount
+    amount
   });
   const slippagePercent = Math.min(Math.max(params.slippage ?? 0.5, 0), 50);
   let warning;
@@ -217,7 +219,7 @@ async function getQuote(params) {
       decimals: params.tokenOut.decimals ?? 18,
       chainId: params.destChainId
     },
-    amountIn: params.amount,
+    amountIn: BigInt(params.amount),
     pricePerInputToken,
     slippage: slippagePercent,
     internal: {
@@ -241,13 +243,13 @@ function buildQuoteParams({
     tokenOut,
     sourceChainId,
     destChainId,
-    amount: (0, import_viem2.parseUnits)(amount.toString(), tokenIn.decimals ?? 18),
+    amount: (0, import_viem2.parseUnits)(amount.toString(), tokenIn.decimals ?? 18).toString(),
     slippage
   };
 }
 
 // src/core/getBalances.ts
-var import_intents_sdk5 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk4 = require("@shogun-sdk/intents-sdk");
 async function getBalances(params, options) {
   const { addresses, cursorEvm, cursorSvm } = params;
   const { signal } = options ?? {};
@@ -260,7 +262,7 @@ async function getBalances(params, options) {
     cursorSvm
   });
   const start = performance.now();
-  const response = await fetch(`${import_intents_sdk5.TOKEN_SEARCH_API_BASE_URL}/tokens/balances`, {
+  const response = await fetch(`${import_intents_sdk4.TOKEN_SEARCH_API_BASE_URL}/tokens/balances`, {
     method: "POST",
     headers: {
       accept: "application/json",
@@ -288,119 +290,70 @@ async function getBalances(params, options) {
   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: combined,
+    results: filtered,
     nextCursorEvm: data.evm?.cursor ?? null,
     nextCursorSvm: data.svm?.cursor ?? null
   };
 }
 
-// src/core/executeOrder/execute.ts
-var import_intents_sdk11 = require("@shogun-sdk/intents-sdk");
-var import_viem6 = require("viem");
-
-// src/wallet-adapter/svm-wallet-adapter/adapter.ts
-var import_web3 = require("@solana/web3.js");
-var adaptSolanaWallet = (walletAddress, chainId, rpcUrl, signAndSendTransaction) => {
-  let _chainId = chainId;
-  const connection = new import_web3.Connection(rpcUrl, { commitment: "confirmed" });
-  const getChainId = async () => _chainId;
-  const sendTransaction = async (transaction) => {
-    const txHash = await signAndSendTransaction(transaction);
-    console.debug(`\u{1F6F0} Sent transaction: ${txHash}`);
-    const maxRetries = 20;
-    const delayMs = 2e3;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      const res = await connection.getSignatureStatus(txHash, { searchTransactionHistory: true });
-      if (res?.value?.confirmationStatus === "confirmed" || res?.value?.confirmationStatus === "finalized") {
-        return txHash;
-      }
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-    throw new Error(`Transaction not confirmed after ${maxRetries * (delayMs / 1e3)}s`);
-  };
-  const signTypedData = async () => {
-    throw new Error("signTypedData not implemented for Solana");
-  };
-  const switchChain = async (newChainId) => {
-    _chainId = newChainId;
-  };
+// src/core/token-list.ts
+var import_intents_sdk5 = require("@shogun-sdk/intents-sdk");
+async function getTokenList(params) {
+  const url = new URL(`${import_intents_sdk5.TOKEN_SEARCH_API_BASE_URL}/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 {
-    vmType: "SVM" /* SVM */,
-    getChainId,
-    address: async () => walletAddress,
-    sendTransaction,
-    switchChain,
-    signTypedData,
-    rpcUrl
+    ...data,
+    results: filteredResults,
+    count: filteredResults.length
   };
-};
+}
+
+// src/core/token.ts
+var import_intents_sdk6 = require("@shogun-sdk/intents-sdk");
+async function getTokensData(addresses) {
+  if (!addresses?.length) return [];
+  const response = await fetch(`${import_intents_sdk6.TOKEN_SEARCH_API_BASE_URL}/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
+var import_intents_sdk12 = require("@shogun-sdk/intents-sdk");
+var import_viem7 = require("viem");
 
 // src/wallet-adapter/evm-wallet-adapter/adapter.ts
-var import_ethers = require("ethers/lib/ethers.js");
-var import_utils2 = require("ethers/lib/utils.js");
 var import_viem3 = require("viem");
 function isEVMTransaction(tx) {
   return typeof tx.from === "string";
 }
-var adaptEthersSigner = (signer, transport) => {
-  const signTypedData = async (signData) => {
-    const typedSigner = signer;
-    return await typedSigner._signTypedData(
-      signData.domain,
-      signData.types,
-      signData.value
-    );
-  };
-  const sendTransaction = async (transaction) => {
-    if (!isEVMTransaction(transaction)) {
-      throw new Error("Expected EVMTransaction but got SolanaTransaction");
-    }
-    const tx = await signer.sendTransaction({
-      from: transaction.from,
-      to: transaction.to,
-      data: transaction.data,
-      value: transaction.value
-    });
-    return tx.hash;
-  };
-  const switchChain = async (chainId) => {
-    try {
-      await window.ethereum.request({
-        method: "wallet_switchEthereumChain",
-        params: [{ chainId: (0, import_utils2.hexValue)(chainId) }]
-      });
-    } catch (error) {
-      console.error("Failed to switch chain:", error);
-      throw error;
-    }
-  };
-  const readContract = async ({
-    address,
-    abi,
-    functionName,
-    args = []
-  }) => {
-    const iface = new import_ethers.utils.Interface(abi);
-    const fnArgs = Array.isArray(args) ? args : [];
-    const data = iface.encodeFunctionData(functionName, fnArgs);
-    const provider = signer.provider;
-    if (!provider) throw new Error("Signer has no provider");
-    const result = await provider.call({ to: address, data });
-    const decoded = iface.decodeFunctionResult(functionName, result);
-    return decoded[0];
-  };
-  return {
-    vmType: "EVM" /* EVM */,
-    transport,
-    getChainId: async () => signer.getChainId(),
-    address: async () => signer.getAddress(),
-    sendTransaction,
-    signTypedData,
-    switchChain,
-    readContract
-  };
-};
 var adaptViemWallet = (wallet) => {
   const signTypedData = async (signData) => {
     return await wallet.signTypedData({
@@ -483,11 +436,11 @@ var adaptViemWallet = (wallet) => {
   };
 };
 
-// src/core/executeOrder/handleEvmExecution.ts
-var import_intents_sdk9 = require("@shogun-sdk/intents-sdk");
-var import_viem5 = require("viem");
+// src/core/execute/handleEvmExecution.ts
+var import_intents_sdk10 = require("@shogun-sdk/intents-sdk");
+var import_viem6 = require("viem");
 
-// src/core/executeOrder/stageMessages.ts
+// src/core/execute/stageMessages.ts
 var DEFAULT_STAGE_MESSAGES = {
   processing: "Preparing transaction for execution",
   approving: "Approving token allowance",
@@ -496,33 +449,57 @@ var DEFAULT_STAGE_MESSAGES = {
   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
-var import_intents_sdk6 = require("@shogun-sdk/intents-sdk");
+// src/core/execute/buildOrder.ts
+var import_intents_sdk7 = require("@shogun-sdk/intents-sdk");
+var import_viem4 = require("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((0, import_viem4.formatUnits)(BigInt(quote.amountIn.toString()), decimalsIn));
+      const rawAmountOut = formattedAmountIn * executionPrice;
+      amountOutMin = (0, import_viem4.parseUnits)(rawAmountOut.toString(), decimalsOut);
+    }
+  }
   if (isSingleChain) {
-    return await import_intents_sdk6.SingleChainOrder.create({
+    return await import_intents_sdk7.SingleChainOrder.create({
       user: accountAddress,
       chainId: tokenIn.chainId,
       tokenIn: tokenIn.address,
       tokenOut: tokenOut.address,
       amountIn: quote.amountIn,
-      amountOutMin: quote.internal.estimatedAmountOutReduced,
+      amountOutMin,
       deadline,
       destinationAddress: destination
     });
   }
-  return await import_intents_sdk6.CrossChainOrder.create({
+  return await import_intents_sdk7.CrossChainOrder.create({
     user: accountAddress,
     sourceChainId: tokenIn.chainId,
     sourceTokenAddress: tokenIn.address,
@@ -531,13 +508,13 @@ async function buildOrder({
     destinationTokenAddress: tokenOut.address,
     destinationAddress: destination,
     deadline,
-    destinationTokenMinAmount: quote.internal.estimatedAmountOutReduced,
+    destinationTokenMinAmount: amountOutMin,
     minStablecoinAmount: quote.minStablecoinsAmount
   });
 }
 
 // src/utils/pollOrderStatus.ts
-var import_intents_sdk7 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk8 = require("@shogun-sdk/intents-sdk");
 async function pollOrderStatus(address, orderId, options = {}) {
   const { intervalMs = 2e3, timeoutMs = 3e5 } = options;
   const startTime = Date.now();
@@ -550,7 +527,7 @@ async function pollOrderStatus(address, orderId, options = {}) {
   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_sdk7.AUCTIONEER_URL}/user_intent?${queryParam}`;
+  const queryUrl = `${import_intents_sdk8.AUCTIONEER_URL}/user_intent?${queryParam}`;
   return new Promise((resolve, reject) => {
     const pollInterval = setInterval(async () => {
       try {
@@ -602,7 +579,7 @@ async function pollOrderStatus(address, orderId, options = {}) {
   });
 }
 
-// src/core/executeOrder/handleOrderPollingResult.ts
+// src/core/execute/handleOrderPollingResult.ts
 async function handleOrderPollingResult({
   status,
   orderId,
@@ -640,9 +617,9 @@ async function handleOrderPollingResult({
   };
 }
 
-// src/core/executeOrder/ensurePermit2Allowance.ts
-var import_viem4 = require("viem");
-var import_intents_sdk8 = require("@shogun-sdk/intents-sdk");
+// src/core/execute/ensurePermit2Allowance.ts
+var import_viem5 = require("viem");
+var import_intents_sdk9 = require("@shogun-sdk/intents-sdk");
 async function ensurePermit2Allowance({
   chainId,
   tokenIn,
@@ -651,7 +628,7 @@ async function ensurePermit2Allowance({
   requiredAmount,
   increaseByDelta = false
 }) {
-  const spender = import_intents_sdk8.PERMIT2_ADDRESS[chainId];
+  const spender = import_intents_sdk9.PERMIT2_ADDRESS[chainId];
   let currentAllowance = 0n;
   try {
     if (!wallet.readContract) {
@@ -659,22 +636,22 @@ async function ensurePermit2Allowance({
     }
     currentAllowance = await wallet.readContract({
       address: tokenIn,
-      abi: import_viem4.erc20Abi,
+      abi: import_viem5.erc20Abi,
       functionName: "allowance",
       args: [accountAddress, spender]
     });
   } catch (error) {
     console.warn(`[Permit2] Failed to read allowance for ${tokenIn}`, error);
   }
-  const approvalAmount = increaseByDelta ? currentAllowance + requiredAmount : import_viem4.maxUint256;
+  const approvalAmount = increaseByDelta ? currentAllowance + requiredAmount : import_viem5.maxUint256;
   console.debug(
     `[Permit2] Approving ${approvalAmount} for ${tokenIn} (current: ${currentAllowance}, required: ${requiredAmount})`
   );
   await wallet.sendTransaction({
     to: tokenIn,
     from: accountAddress,
-    data: (0, import_viem4.encodeFunctionData)({
-      abi: import_viem4.erc20Abi,
+    data: (0, import_viem5.encodeFunctionData)({
+      abi: import_viem5.erc20Abi,
       functionName: "approve",
       args: [spender, approvalAmount]
     }),
@@ -685,7 +662,7 @@ async function ensurePermit2Allowance({
   );
 }
 
-// src/core/executeOrder/handleEvmExecution.ts
+// src/core/execute/handleEvmExecution.ts
 async function handleEvmExecution({
   recipientAddress,
   quote,
@@ -693,19 +670,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: (0, import_viem5.encodeFunctionData)({
+      data: (0, import_viem6.encodeFunctionData)({
         abi: [{ type: "function", name: "deposit", stateMutability: "payable", inputs: [], outputs: [] }],
         functionName: "deposit",
         args: []
@@ -729,11 +709,13 @@ async function handleEvmExecution({
     accountAddress,
     destination,
     deadline,
-    isSingleChain
+    isSingleChain,
+    orderType,
+    options
   });
   console.debug(`order`, order);
   update("processing", messageFor("signing"));
-  const { orderTypedData, nonce } = isSingleChain ? await (0, import_intents_sdk9.getEVMSingleChainOrderTypedData)(order) : await (0, import_intents_sdk9.getEVMCrossChainOrderTypedData)(order);
+  const { orderTypedData, nonce } = isSingleChain ? await (0, import_intents_sdk10.getEVMSingleChainOrderTypedData)(order) : await (0, import_intents_sdk10.getEVMCrossChainOrderTypedData)(order);
   const typedData = serializeBigIntsToStrings(orderTypedData);
   if (!wallet.signTypedData) {
     throw new Error("Wallet does not support EIP-712 signing");
@@ -753,19 +735,30 @@ async function handleEvmExecution({
   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
-  });
+  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);
+    return await handleOrderPollingResult({
+      status,
+      orderId,
+      chainId,
+      update,
+      messageFor
+    });
+  }
 }
 
-// src/core/executeOrder/handleSolanaExecution.ts
-var import_intents_sdk10 = require("@shogun-sdk/intents-sdk");
-var import_web32 = require("@solana/web3.js");
+// src/core/execute/handleSolanaExecution.ts
+var import_intents_sdk11 = require("@shogun-sdk/intents-sdk");
+var import_web3 = require("@solana/web3.js");
 async function handleSolanaExecution({
   recipientAddress,
   quote,
@@ -773,12 +766,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({
@@ -786,14 +781,16 @@ async function handleSolanaExecution({
     accountAddress,
     destination,
     deadline,
-    isSingleChain
+    isSingleChain,
+    orderType,
+    options
   });
   const txData = await getSolanaOrderInstructions({
     order,
     isSingleChain,
     rpcUrl: wallet.rpcUrl
   });
-  const transaction = import_web32.VersionedTransaction.deserialize(Uint8Array.from(txData.txBytes));
+  const transaction = import_web3.VersionedTransaction.deserialize(Uint8Array.from(txData.txBytes));
   update("processing", messageFor("signing"));
   await wallet.sendTransaction(transaction);
   update("processing", messageFor("submitting"));
@@ -806,16 +803,27 @@ async function handleSolanaExecution({
     throw new Error("Auctioneer submission failed");
   }
   update("initiated", messageFor("initiated"));
-  const { jwt, intentId: orderId } = response.data;
+  const { 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
-  });
+  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);
+    return await handleOrderPollingResult({
+      status,
+      orderId,
+      chainId: SOLANA_CHAIN_ID,
+      update,
+      messageFor
+    });
+  }
 }
 async function getSolanaOrderInstructions({
   order,
@@ -823,11 +831,11 @@ async function getSolanaOrderInstructions({
   rpcUrl
 }) {
   if (isSingleChain) {
-    return await (0, import_intents_sdk10.getSolanaSingleChainOrderInstructions)(order, {
+    return await (0, import_intents_sdk11.getSolanaSingleChainOrderInstructions)(order, {
       rpcUrl
     });
   }
-  return await (0, import_intents_sdk10.getSolanaCrossChainOrderInstructions)(order, {
+  return await (0, import_intents_sdk11.getSolanaCrossChainOrderInstructions)(order, {
     rpcUrl
   });
 }
@@ -848,13 +856,14 @@ 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 isDev = process.env.NODE_ENV !== "production";
@@ -867,21 +876,31 @@ async function executeOrder({
     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 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");
-    if ((0, import_intents_sdk11.isEvmChain)(chainId)) {
+    if ((0, import_intents_sdk12.isEvmChain)(chainId)) {
       log("Detected EVM chain:", chainId);
       const result = await handleEvmExecution({
         recipientAddress,
@@ -890,13 +909,14 @@ async function executeOrder({
         accountAddress,
         wallet: adapter,
         isSingleChain,
-        deadline,
-        update
+        update,
+        orderType,
+        options
       });
       log("EVM execution result:", result);
       return result;
     }
-    if (chainId === import_intents_sdk11.ChainID.Solana) {
+    if (chainId === import_intents_sdk12.ChainID.Solana) {
       log("Detected Solana chain");
       const result = await handleSolanaExecution({
         recipientAddress,
@@ -904,8 +924,9 @@ async function executeOrder({
         accountAddress,
         wallet: adapter,
         isSingleChain,
-        deadline,
-        update
+        update,
+        orderType,
+        options
       });
       log("Solana execution result:", result);
       return result;
@@ -915,8 +936,13 @@ async function executeOrder({
     log("Error:", unsupported);
     return { status: false, message: unsupported, stage: "error" };
   } catch (error) {
-    const message = error instanceof import_viem6.BaseError ? error.shortMessage : error instanceof Error ? error.message : String(error);
-    log("Execution failed:", { message, 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" };
   }
@@ -927,299 +953,177 @@ function normalizeWallet(wallet) {
   return wallet;
 }
 
-// src/react/useTokenList.ts
-var import_react = require("react");
-var tokenCache = /* @__PURE__ */ new Map();
-function useTokenList(params) {
-  const [data, setData] = (0, import_react.useState)(null);
-  const [loading, setLoading] = (0, import_react.useState)(false);
-  const [error, setError] = (0, import_react.useState)(null);
-  const controllerRef = (0, import_react.useRef)(null);
-  const debounceRef = (0, import_react.useRef)(null);
-  const debounceMs = params.debounceMs ?? 250;
-  const cacheKey = (0, import_react.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);
-    }
+// src/core/orders/getOrders.ts
+var import_intents_sdk13 = require("@shogun-sdk/intents-sdk");
+async function getOrders({
+  evmAddress,
+  solAddress
+}) {
+  if (!evmAddress && !solAddress) {
+    throw new Error("At least one wallet address (EVM, Solana) must be provided.");
   }
-  (0, import_react.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 (0, import_react.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]
-  );
+  const orders = await (0, import_intents_sdk13.fetchUserOrders)(evmAddress, solAddress);
+  return orders;
 }
 
-// src/react/useExecuteOrder.ts
-var import_react2 = require("react");
-function useExecuteOrder() {
-  const [status, setStatus] = (0, import_react2.useState)("processing");
-  const [message, setMessage] = (0, import_react2.useState)(null);
-  const [loading, setLoading] = (0, import_react2.useState)(false);
-  const [data, setData] = (0, import_react2.useState)(null);
-  const [error, setError] = (0, import_react2.useState)(null);
-  const isMounted = (0, import_react2.useRef)(true);
-  (0, import_react2.useEffect)(() => {
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-  const execute = (0, import_react2.useCallback)(
-    async ({
+// 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,
-      wallet,
-      deadline
-    }) => {
-      if (!quote || !wallet) {
-        throw new Error("Quote and wallet are required for order execution.");
-      }
-      setLoading(true);
-      setError(null);
-      setData(null);
-      setMessage(null);
-      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({
-          quote,
-          accountAddress,
-          recipientAddress,
-          wallet,
-          onStatus,
-          options: { deadline: effectiveDeadline }
-        });
-        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
-          });
-        }
-        return {
-          status: false,
-          stage: "error",
-          message: errorObj.message
-        };
-      } finally {
-        if (isMounted.current) setLoading(false);
-      }
-    },
-    []
-  );
-  return {
-    /** Executes the swap order. */
-    execute,
-    /** Current execution stage. */
-    status,
-    /** Human-readable status message. */
-    message,
-    /** Whether execution is ongoing. */
-    loading,
-    /** Raw SDK response data. */
-    data,
-    /** Captured error (if execution failed). */
-    error
-  };
-}
-
-// src/react/useQuote.ts
-var import_react3 = require("react");
-function useQuote(params, options) {
-  const [data, setData] = (0, import_react3.useState)(null);
-  const [loading, setLoading] = (0, import_react3.useState)(false);
-  const [error, setError] = (0, import_react3.useState)(null);
-  const [warning, setWarning] = (0, import_react3.useState)(null);
-  const debounceMs = options?.debounceMs ?? 250;
-  const autoRefreshMs = options?.autoRefreshMs;
-  const abortRef = (0, import_react3.useRef)(null);
-  const debounceRef = (0, import_react3.useRef)(null);
-  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 () => {
-      mounted.current = false;
-      abortRef.current?.abort();
-      if (debounceRef.current) clearTimeout(debounceRef.current);
-    };
-  }, []);
-  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);
-    debounceRef.current = setTimeout(() => {
-      fetchQuote();
-    }, debounceMs);
-    return () => {
-      if (debounceRef.current) clearTimeout(debounceRef.current);
-      abortRef.current?.abort();
-    };
-  }, [paramsKey, debounceMs, fetchQuote]);
-  (0, import_react3.useEffect)(() => {
-    if (!autoRefreshMs || !paramsKey) return;
-    const interval = setInterval(() => fetchQuote(), autoRefreshMs);
-    return () => clearInterval(interval);
-  }, [autoRefreshMs, paramsKey, fetchQuote]);
-  return (0, import_react3.useMemo)(
-    () => ({
-      data,
-      loading,
-      error,
-      warning,
-      refetch: fetchQuote
-    }),
-    [data, loading, error, warning, fetchQuote]
-  );
-}
-
-// src/react/useBalances.ts
-var import_react4 = require("react");
-function useBalances(params) {
-  const [data, setData] = (0, import_react4.useState)(null);
-  const [loading, setLoading] = (0, import_react4.useState)(false);
-  const [error, setError] = (0, import_react4.useState)(null);
-  const abortRef = (0, import_react4.useRef)(null);
-  const stableParams = (0, import_react4.useMemo)(() => {
-    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 = (0, import_react4.useCallback)(async () => {
-    if (!stableParams) return;
-    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;
-    } catch (err) {
-      if (err.name === "AbortError") return;
-      const e = err instanceof Error ? err : new Error(String(err));
-      setError(e);
-      throw e;
-    } finally {
-      setLoading(false);
-    }
-  }, [stableParams]);
-  (0, import_react4.useEffect)(() => {
-    if (stableParams) fetchBalances().catch(() => {
+      onStatus,
+      orderType,
+      options
     });
-    return () => {
-      if (abortRef.current) abortRef.current.abort();
-    };
-  }, [fetchBalances]);
-  return (0, import_react4.useMemo)(
-    () => ({
-      /** Latest fetched balance data */
-      data,
-      /** Whether the hook is currently fetching */
-      loading,
-      /** Error object if fetching failed */
-      error,
-      /** Manually trigger a refresh */
-      refetch: fetchBalances
-    }),
-    [data, loading, error, fetchBalances]
-  );
-}
+  }
+  /**
+  * 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);
+  }
+};