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

package/dist/core.cjs

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  ChainID: () => import_intents_sdk10.ChainID,
+  ChainID: () => import_intents_sdk11.ChainID,
   NATIVE_TOKEN: () => NATIVE_TOKEN,
   SOLANA_CHAIN_ID: () => SOLANA_CHAIN_ID,
   SupportedChains: () => SupportedChains,
@@ -29,7 +29,7 @@ __export(core_exports, {
   getBalances: () => getBalances,
   getQuote: () => getQuote,
   getTokenList: () => getTokenList,
-  isEvmChain: () => import_intents_sdk10.isEvmChain,
+  isEvmChain: () => import_intents_sdk11.isEvmChain,
   isNativeAddress: () => isNativeAddress,
   isViemWalletClient: () => isViemWalletClient,
   serializeBigIntsToStrings: () => serializeBigIntsToStrings
@@ -177,22 +177,26 @@ async function getQuote(params) {
     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);
+  console.log({ data });
+  const slippagePercent = Math.min(Math.max(params.slippage ?? 0.5, 0), 50);
   let warning;
-  if (slippage > 0.1) {
-    warning = `\u26A0\uFE0F High slippage tolerance (${(slippage * 100).toFixed(2)}%) \u2014 price may vary significantly.`;
+  if (slippagePercent > 10) {
+    warning = `\u26A0\uFE0F High slippage tolerance (${slippagePercent.toFixed(2)}%) \u2014 price may vary significantly.`;
   }
-  const estimatedAmountOut = BigInt(data.estimatedAmountOutReduced);
-  const slippageBps = BigInt(Math.round(slippage * 1e4));
+  const estimatedAmountOut = BigInt(data.estimatedAmountOut);
+  const slippageBps = BigInt(Math.round(slippagePercent * 100));
   const estimatedAmountOutAfterSlippage = estimatedAmountOut * (10000n - slippageBps) / 10000n;
+  const pricePerTokenOutInUsd = data.estimatedAmountOutUsd / Number(data.estimatedAmountOut);
+  const amountOutUsdAfterSlippage = Number(estimatedAmountOutAfterSlippage) * pricePerTokenOutInUsd;
+  const minStablecoinsAmountValue = BigInt(data.estimatedAmountInAsMinStablecoinAmount);
+  const minStablecoinsAmountAfterSlippage = minStablecoinsAmountValue * (10000n - slippageBps) / 10000n;
   const pricePerInputToken = estimatedAmountOut * 10n ** BigInt(params.tokenIn.decimals ?? 18) / BigInt(params.amount);
   return {
-    amountOut: estimatedAmountOut,
-    amountOutUsd: data.estimatedAmountOutUsd,
+    amountOut: estimatedAmountOutAfterSlippage,
+    amountOutUsd: amountOutUsdAfterSlippage,
     amountInUsd: data.amountInUsd,
-    minStablecoinsAmount: data.estimatedAmountInAsMinStablecoinAmount,
+    // Input USD stays the same
+    minStablecoinsAmount: minStablecoinsAmountAfterSlippage,
     tokenIn: {
       address: params.tokenIn.address,
       decimals: params.tokenIn.decimals ?? 18,
@@ -205,10 +209,11 @@ async function getQuote(params) {
     },
     amountIn: params.amount,
     pricePerInputToken,
-    slippage,
+    slippage: slippagePercent,
     internal: {
       ...data,
-      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage
+      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage,
+      estimatedAmountOutUsdReduced: amountOutUsdAfterSlippage
     },
     warning
   };
@@ -281,7 +286,7 @@ async function getBalances(params, options) {
 }
 
 // src/core/executeOrder/execute.ts
-var import_intents_sdk9 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk10 = require("@shogun-sdk/intents-sdk");
 var import_viem4 = require("viem");
 
 // src/wallet-adapter/evm-wallet-adapter/adapter.ts
@@ -305,15 +310,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 {
@@ -348,7 +364,7 @@ var adaptViemWallet = (wallet) => {
 };
 
 // src/core/executeOrder/handleEvmExecution.ts
-var import_intents_sdk7 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk8 = require("@shogun-sdk/intents-sdk");
 var import_viem3 = require("viem");
 
 // src/core/executeOrder/stageMessages.ts
@@ -356,10 +372,12 @@ var DEFAULT_STAGE_MESSAGES = {
   processing: "Preparing transaction for execution",
   approving: "Approving token allowance",
   approved: "Token approved successfully",
-  signing: "Signing order for submission",
-  submitting: "Submitting order to Auctioneer",
-  success: "Order executed successfully",
-  error: "Order execution failed"
+  signing: "Signing transaction for submission",
+  submitting: "Submitting transaction",
+  initiated: "Transaction initiated.",
+  success: "Transaction Executed successfully",
+  shogun_processing: "Shogun is processing your transaction",
+  error: "Transaction failed during submission"
 };
 
 // src/core/executeOrder/buildOrder.ts
@@ -398,6 +416,106 @@ async function buildOrder({
   });
 }
 
+// src/utils/pollOrderStatus.ts
+var import_intents_sdk7 = require("@shogun-sdk/intents-sdk");
+async function pollOrderStatus(address, orderId, options = {}) {
+  const { intervalMs = 2e3, timeoutMs = 3e5 } = options;
+  const startTime = Date.now();
+  const isEvmAddress = /^0x[a-fA-F0-9]{40}$/.test(address);
+  const isSuiAddress = /^0x[a-fA-F0-9]{64}$/.test(address);
+  const isSolanaAddress = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+  let queryParam;
+  if (isEvmAddress) {
+    queryParam = `evmWallets=${address}`;
+  } else if (isSuiAddress) {
+    queryParam = `suiWallets=${address}`;
+  } else if (isSolanaAddress) {
+    queryParam = `solanaWallets=${address}`;
+  } else {
+    throw new Error(`Unrecognized wallet address format: ${address}`);
+  }
+  const queryUrl = `${import_intents_sdk7.AUCTIONEER_URL}/user_intent?${queryParam}`;
+  return new Promise((resolve, reject) => {
+    const pollInterval = setInterval(async () => {
+      try {
+        if (Date.now() - startTime > timeoutMs) {
+          clearInterval(pollInterval);
+          return resolve("Timeout");
+        }
+        const res = await fetch(queryUrl, {
+          method: "GET",
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!res.ok) {
+          clearInterval(pollInterval);
+          return reject(
+            new Error(`Failed to fetch orders: ${res.status} ${res.statusText}`)
+          );
+        }
+        const json = await res.json();
+        const data = json?.data ?? {};
+        const allOrders = [
+          ...data.crossChainDcaOrders ?? [],
+          ...data.crossChainLimitOrders ?? [],
+          ...data.singleChainDcaOrders ?? [],
+          ...data.singleChainLimitOrders ?? []
+        ];
+        const targetOrder = allOrders.find((o) => o.orderId === orderId);
+        if (!targetOrder) {
+          clearInterval(pollInterval);
+          return resolve("NotFound");
+        }
+        const { orderStatus } = targetOrder;
+        if (["Fulfilled", "Cancelled", "Outdated"].includes(orderStatus)) {
+          clearInterval(pollInterval);
+          return resolve(orderStatus);
+        }
+      } catch (error) {
+        clearInterval(pollInterval);
+        return reject(error);
+      }
+    }, intervalMs);
+  });
+}
+
+// src/core/executeOrder/handleOrderPollingResult.ts
+async function handleOrderPollingResult({
+  status,
+  orderId,
+  chainId,
+  update,
+  messageFor
+}) {
+  switch (status) {
+    case "Fulfilled":
+      update("success", messageFor("success"));
+      return {
+        status: true,
+        orderId,
+        chainId,
+        finalStatus: status,
+        stage: "success"
+      };
+    case "Cancelled":
+      update("error", "Order was cancelled before fulfillment");
+      break;
+    case "Timeout":
+      update("error", "Order polling timed out");
+      break;
+    case "NotFound":
+    default:
+      update("error", "Order not found");
+      break;
+  }
+  return {
+    status: false,
+    orderId,
+    chainId,
+    finalStatus: status,
+    stage: "error"
+  };
+}
+
 // src/core/executeOrder/handleEvmExecution.ts
 async function handleEvmExecution({
   recipientAddress,
@@ -426,18 +544,18 @@ async function handleEvmExecution({
       from: accountAddress
     });
   }
-  update("approving", messageFor("approving"));
+  update("processing", messageFor("approving"));
   await wallet.sendTransaction({
     to: tokenIn,
     data: (0, import_viem3.encodeFunctionData)({
       abi: import_viem3.erc20Abi,
       functionName: "approve",
-      args: [import_intents_sdk7.PERMIT2_ADDRESS[chainId], BigInt(quote.amountIn)]
+      args: [import_intents_sdk8.PERMIT2_ADDRESS[chainId], BigInt(quote.amountIn)]
     }),
     value: 0n,
     from: accountAddress
   });
-  update("approved", messageFor("approved"));
+  update("processing", messageFor("approved"));
   const destination = recipientAddress ?? accountAddress;
   const order = await buildOrder({
     quote,
@@ -446,23 +564,39 @@ async function handleEvmExecution({
     deadline,
     isSingleChain
   });
-  update("signing", messageFor("signing"));
-  const { orderTypedData, nonce } = isSingleChain ? await (0, import_intents_sdk7.getEVMSingleChainOrderTypedData)(order) : await (0, import_intents_sdk7.getEVMCrossChainOrderTypedData)(order);
+  update("processing", messageFor("signing"));
+  const { orderTypedData, nonce } = isSingleChain ? await (0, import_intents_sdk8.getEVMSingleChainOrderTypedData)(order) : await (0, import_intents_sdk8.getEVMCrossChainOrderTypedData)(order);
+  const typedData = serializeBigIntsToStrings(orderTypedData);
   if (!wallet.signTypedData) {
     throw new Error("Wallet does not support EIP-712 signing");
   }
-  const signature = await wallet.signTypedData(serializeBigIntsToStrings(orderTypedData));
-  update("submitting", messageFor("submitting"));
+  const signature = await wallet.signTypedData({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    value: typedData.message,
+    message: typedData.message
+  });
+  update("processing", messageFor("submitting"));
   const res = await order.sendToAuctioneer({ signature, nonce: nonce.toString() });
   if (!res.success) {
     throw new Error("Auctioneer submission failed");
   }
-  update("success", messageFor("success"));
-  return { status: true, txHash: res.data, chainId, stage: "success" };
+  update("initiated", messageFor("initiated"));
+  const { intentId: orderId } = res.data;
+  update("initiated", messageFor("shogun_processing"));
+  const status = await pollOrderStatus(accountAddress, orderId);
+  return await handleOrderPollingResult({
+    status,
+    orderId,
+    chainId,
+    update,
+    messageFor
+  });
 }
 
 // src/core/executeOrder/handleSolanaExecution.ts
-var import_intents_sdk8 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk9 = require("@shogun-sdk/intents-sdk");
 var import_web3 = require("@solana/web3.js");
 async function handleSolanaExecution({
   recipientAddress,
@@ -492,10 +626,9 @@ async function handleSolanaExecution({
     rpcUrl: wallet.rpcUrl
   });
   const transaction = import_web3.VersionedTransaction.deserialize(Uint8Array.from(txData.txBytes));
-  update("signing", messageFor("signing"));
-  console.log({ order });
-  const txSignature = await wallet.sendTransaction(transaction);
-  update("submitting", messageFor("submitting"));
+  update("processing", messageFor("signing"));
+  await wallet.sendTransaction(transaction);
+  update("processing", messageFor("submitting"));
   const response = await submitToAuctioneer({
     order,
     isSingleChain,
@@ -504,13 +637,17 @@ async function handleSolanaExecution({
   if (!response.success) {
     throw new Error("Auctioneer submission failed");
   }
-  update("success", messageFor("success"));
-  return {
-    status: true,
-    txHash: txSignature,
-    chainId: import_intents_sdk8.ChainID.Solana,
-    stage: "success"
-  };
+  update("initiated", messageFor("initiated"));
+  const { jwt, intentId: orderId } = response.data;
+  update("initiated", messageFor("shogun_processing"));
+  const status = await pollOrderStatus(jwt, orderId);
+  return await handleOrderPollingResult({
+    status,
+    orderId,
+    chainId: SOLANA_CHAIN_ID,
+    update,
+    messageFor
+  });
 }
 async function getSolanaOrderInstructions({
   order,
@@ -518,11 +655,11 @@ async function getSolanaOrderInstructions({
   rpcUrl
 }) {
   if (isSingleChain) {
-    return await (0, import_intents_sdk8.getSolanaSingleChainOrderInstructions)(order, {
+    return await (0, import_intents_sdk9.getSolanaSingleChainOrderInstructions)(order, {
       rpcUrl
     });
   }
-  return await (0, import_intents_sdk8.getSolanaCrossChainOrderInstructions)(order, {
+  return await (0, import_intents_sdk9.getSolanaCrossChainOrderInstructions)(order, {
     rpcUrl
   });
 }
@@ -552,18 +689,33 @@ async function executeOrder({
   onStatus,
   options = {}
 }) {
-  const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+  const isDev = process.env.NODE_ENV !== "production";
+  const log = (...args) => {
+    if (isDev) console.log("[OneShot::executeOrder]", ...args);
+  };
   const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
-  const update = (stage, message) => onStatus?.(stage, message ?? messageFor(stage));
+  const update = (stage, message) => {
+    log("Stage:", stage, "| Message:", message ?? messageFor(stage));
+    onStatus?.(stage, message ?? messageFor(stage));
+  };
   try {
+    const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+    log("Starting execution:", {
+      accountAddress,
+      recipientAddress,
+      deadline,
+      tokenIn: quote?.tokenIn,
+      tokenOut: quote?.tokenOut
+    });
     const adapter = normalizeWallet(wallet);
     if (!adapter) throw new Error("No wallet provided");
     const { tokenIn, tokenOut } = quote;
     const isSingleChain = tokenIn.chainId === tokenOut.chainId;
     const chainId = Number(tokenIn.chainId);
-    update("processing", messageFor("processing"));
-    if ((0, import_intents_sdk9.isEvmChain)(chainId)) {
-      return await handleEvmExecution({
+    update("processing");
+    if ((0, import_intents_sdk10.isEvmChain)(chainId)) {
+      log("Detected EVM chain:", chainId);
+      const result = await handleEvmExecution({
         recipientAddress,
         quote,
         chainId,
@@ -573,9 +725,12 @@ async function executeOrder({
         deadline,
         update
       });
+      log("EVM execution result:", result);
+      return result;
     }
-    if (chainId === import_intents_sdk9.ChainID.Solana) {
-      return await handleSolanaExecution({
+    if (chainId === import_intents_sdk10.ChainID.Solana) {
+      log("Detected Solana chain");
+      const result = await handleSolanaExecution({
         recipientAddress,
         quote,
         accountAddress,
@@ -584,11 +739,16 @@ async function executeOrder({
         deadline,
         update
       });
+      log("Solana execution result:", result);
+      return result;
     }
-    update("error", "Unsupported chain");
-    return { status: false, message: "Unsupported chain", stage: "error" };
+    const unsupported = `Unsupported chain: ${chainId}`;
+    update("error", unsupported);
+    log("Error:", unsupported);
+    return { status: false, message: unsupported, stage: "error" };
   } catch (error) {
     const message = error instanceof import_viem4.BaseError ? error.shortMessage : error instanceof Error ? error.message : String(error);
+    log("Execution failed:", { message, error });
     update("error", message);
     return { status: false, message, stage: "error" };
   }
@@ -600,7 +760,7 @@ function normalizeWallet(wallet) {
 }
 
 // src/core/index.ts
-var import_intents_sdk10 = require("@shogun-sdk/intents-sdk");
+var import_intents_sdk11 = require("@shogun-sdk/intents-sdk");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChainID,

package/dist/core.d.cts

@@ -1,7 +1,7 @@
 import { TokenSearchParams, TokenSearchResponse, ChainID } from '@shogun-sdk/intents-sdk';
 export { ChainID, isEvmChain } from '@shogun-sdk/intents-sdk';
-import { S as SwapQuoteParams, a as SwapQuoteResponse, Q as QuoteTokenInfo, B as BalanceRequestParams, c as BalanceResponse } from './execute-FaLLPp1i.cjs';
-export { P as PlaceOrderResult, b as Stage, T as TokenBalance, f as TokenInfo, d as TokenSearchResponse, e as executeOrder } from './execute-FaLLPp1i.cjs';
+import { S as SwapQuoteParams, a as SwapQuoteResponse, Q as QuoteTokenInfo, B as BalanceRequestParams, c as BalanceResponse } from './execute-DOv1i2Su.cjs';
+export { P as PlaceOrderResult, b as Stage, T as TokenBalance, f as TokenInfo, d as TokenSearchResponse, e as executeOrder } from './execute-DOv1i2Su.cjs';
 import { WalletClient } from 'viem';
 import { A as AdaptedWallet } from './wallet-MmUIz8GE.cjs';
 import '@mysten/sui/transactions';

package/dist/core.d.ts

@@ -1,7 +1,7 @@
 import { TokenSearchParams, TokenSearchResponse, ChainID } from '@shogun-sdk/intents-sdk';
 export { ChainID, isEvmChain } from '@shogun-sdk/intents-sdk';
-import { S as SwapQuoteParams, a as SwapQuoteResponse, Q as QuoteTokenInfo, B as BalanceRequestParams, c as BalanceResponse } from './execute-HX1fQ7wG.js';
-export { P as PlaceOrderResult, b as Stage, T as TokenBalance, f as TokenInfo, d as TokenSearchResponse, e as executeOrder } from './execute-HX1fQ7wG.js';
+import { S as SwapQuoteParams, a as SwapQuoteResponse, Q as QuoteTokenInfo, B as BalanceRequestParams, c as BalanceResponse } from './execute-CKTsf_tD.js';
+export { P as PlaceOrderResult, b as Stage, T as TokenBalance, f as TokenInfo, d as TokenSearchResponse, e as executeOrder } from './execute-CKTsf_tD.js';
 import { WalletClient } from 'viem';
 import { A as AdaptedWallet } from './wallet-MmUIz8GE.js';
 import '@mysten/sui/transactions';