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

package/dist/core.js

@@ -139,22 +139,25 @@ 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);
+  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,
@@ -167,10 +170,11 @@ async function getQuote(params) {
     },
     amountIn: params.amount,
     pricePerInputToken,
-    slippage,
+    slippage: slippagePercent,
     internal: {
       ...data,
-      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage
+      estimatedAmountOutReduced: estimatedAmountOutAfterSlippage,
+      estimatedAmountOutUsdReduced: amountOutUsdAfterSlippage
     },
     warning
   };
@@ -243,7 +247,7 @@ async function getBalances(params, options) {
 }
 
 // src/core/executeOrder/execute.ts
-import { ChainID as ChainID4, isEvmChain as isEvmChain2 } from "@shogun-sdk/intents-sdk";
+import { ChainID as ChainID3, isEvmChain as isEvmChain2 } from "@shogun-sdk/intents-sdk";
 import { BaseError } from "viem";
 
 // src/wallet-adapter/evm-wallet-adapter/adapter.ts
@@ -269,15 +273,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 {
@@ -324,10 +339,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
@@ -366,6 +383,110 @@ async function buildOrder({
   });
 }
 
+// src/utils/pollOrderStatus.ts
+import { AUCTIONEER_URL } from "@shogun-sdk/intents-sdk";
+async function pollOrderStatus(address, orderId, options = {}) {
+  const { intervalMs = 2e3, timeoutMs = 3e5 } = options;
+  const startTime = Date.now();
+  const isDebug = process.env.NODE_ENV !== "production";
+  const isEvmAddress = /^0x[a-fA-F0-9]{40}$/.test(address);
+  const isSuiAddress = /^0x[a-fA-F0-9]{64}$/.test(address);
+  const isSolanaAddress = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+  let queryParam;
+  if (isEvmAddress) queryParam = `evmWallets=${address}`;
+  else if (isSuiAddress) queryParam = `suiWallets=${address}`;
+  else if (isSolanaAddress) queryParam = `solanaWallets=${address}`;
+  else throw new Error(`Unrecognized wallet address format: ${address}`);
+  const queryUrl = `${AUCTIONEER_URL}/user_intent?${queryParam}`;
+  return new Promise((resolve, reject) => {
+    const pollInterval = setInterval(async () => {
+      try {
+        if (Date.now() - startTime > timeoutMs) {
+          clearInterval(pollInterval);
+          return resolve("Timeout");
+        }
+        const res = await fetch(queryUrl, {
+          method: "GET",
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!res.ok) {
+          clearInterval(pollInterval);
+          return reject(
+            new Error(`Failed to fetch orders: ${res.status} ${res.statusText}`)
+          );
+        }
+        const json = await res.json();
+        const data = json?.data ?? {};
+        const allOrders = [
+          ...data.crossChainDcaOrders ?? [],
+          ...data.crossChainLimitOrders ?? [],
+          ...data.singleChainDcaOrders ?? [],
+          ...data.singleChainLimitOrders ?? []
+        ];
+        const targetOrder = allOrders.find((o) => o.orderId === orderId);
+        if (!targetOrder) {
+          if (isDebug)
+            console.debug(`[pollOrderStatus] [${orderId}] Not found yet`);
+          return;
+        }
+        const { orderStatus } = targetOrder;
+        if (isDebug) {
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          console.debug(`targetOrder`, targetOrder);
+          console.debug(
+            `[pollOrderStatus] [${orderId}] status=${orderStatus} (elapsed ${elapsed}s)`
+          );
+        }
+        if (["Fulfilled", "Cancelled", "Outdated"].includes(orderStatus)) {
+          clearInterval(pollInterval);
+          return resolve(orderStatus);
+        }
+      } catch (error) {
+        clearInterval(pollInterval);
+        return reject(error);
+      }
+    }, intervalMs);
+  });
+}
+
+// src/core/executeOrder/handleOrderPollingResult.ts
+async function handleOrderPollingResult({
+  status,
+  orderId,
+  chainId,
+  update,
+  messageFor
+}) {
+  switch (status) {
+    case "Fulfilled":
+      update("success", messageFor("success"));
+      return {
+        status: true,
+        orderId,
+        chainId,
+        finalStatus: status,
+        stage: "success"
+      };
+    case "Cancelled":
+      update("error", "Order was cancelled before fulfillment");
+      break;
+    case "Timeout":
+      update("error", "Order polling timed out");
+      break;
+    case "NotFound":
+    default:
+      update("error", "Order not found");
+      break;
+  }
+  return {
+    status: false,
+    orderId,
+    chainId,
+    finalStatus: status,
+    stage: "error"
+  };
+}
+
 // src/core/executeOrder/handleEvmExecution.ts
 async function handleEvmExecution({
   recipientAddress,
@@ -394,18 +515,18 @@ async function handleEvmExecution({
       from: accountAddress
     });
   }
-  update("approving", messageFor("approving"));
+  update("processing", messageFor("approving"));
   await wallet.sendTransaction({
     to: tokenIn,
     data: encodeFunctionData({
       abi: erc20Abi,
       functionName: "approve",
-      args: [PERMIT2_ADDRESS[chainId], BigInt(quote.amountIn)]
+      args: [PERMIT2_ADDRESS[chainId], quote.amountIn]
     }),
     value: 0n,
     from: accountAddress
   });
-  update("approved", messageFor("approved"));
+  update("processing", messageFor("approved"));
   const destination = recipientAddress ?? accountAddress;
   const order = await buildOrder({
     quote,
@@ -414,24 +535,40 @@ async function handleEvmExecution({
     deadline,
     isSingleChain
   });
-  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"));
+  const status = await pollOrderStatus(accountAddress, orderId);
+  return await handleOrderPollingResult({
+    status,
+    orderId,
+    chainId,
+    update,
+    messageFor
+  });
 }
 
 // src/core/executeOrder/handleSolanaExecution.ts
 import {
-  ChainID as ChainID3,
   getSolanaSingleChainOrderInstructions,
   getSolanaCrossChainOrderInstructions
 } from "@shogun-sdk/intents-sdk";
@@ -464,10 +601,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,
@@ -476,13 +612,17 @@ 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 { 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,
@@ -524,18 +664,33 @@ async function executeOrder({
   onStatus,
   options = {}
 }) {
-  const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+  const isDev = process.env.NODE_ENV !== "production";
+  const log = (...args) => {
+    if (isDev) console.debug("[OneShot::executeOrder]", ...args);
+  };
   const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
-  const update = (stage, message) => onStatus?.(stage, message ?? messageFor(stage));
+  const update = (stage, message) => {
+    log("Stage:", stage, "| Message:", message ?? messageFor(stage));
+    onStatus?.(stage, message ?? messageFor(stage));
+  };
   try {
+    const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+    log("Starting execution:", {
+      accountAddress,
+      recipientAddress,
+      deadline,
+      tokenIn: quote?.tokenIn,
+      tokenOut: quote?.tokenOut
+    });
     const adapter = normalizeWallet(wallet);
     if (!adapter) throw new Error("No wallet provided");
     const { tokenIn, tokenOut } = quote;
     const isSingleChain = tokenIn.chainId === tokenOut.chainId;
     const chainId = Number(tokenIn.chainId);
-    update("processing", messageFor("processing"));
+    update("processing");
     if (isEvmChain2(chainId)) {
-      return await handleEvmExecution({
+      log("Detected EVM chain:", chainId);
+      const result = await handleEvmExecution({
         recipientAddress,
         quote,
         chainId,
@@ -545,9 +700,12 @@ async function executeOrder({
         deadline,
         update
       });
+      log("EVM execution result:", result);
+      return result;
     }
-    if (chainId === ChainID4.Solana) {
-      return await handleSolanaExecution({
+    if (chainId === ChainID3.Solana) {
+      log("Detected Solana chain");
+      const result = await handleSolanaExecution({
         recipientAddress,
         quote,
         accountAddress,
@@ -556,11 +714,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 BaseError ? error.shortMessage : error instanceof Error ? error.message : String(error);
+    log("Execution failed:", { message, error });
     update("error", message);
     return { status: false, message, stage: "error" };
   }
@@ -572,9 +735,9 @@ function normalizeWallet(wallet) {
 }
 
 // src/core/index.ts
-import { ChainID as ChainID5, isEvmChain as isEvmChain3 } from "@shogun-sdk/intents-sdk";
+import { ChainID as ChainID4, isEvmChain as isEvmChain3 } from "@shogun-sdk/intents-sdk";
 export {
-  ChainID5 as ChainID,
+  ChainID4 as ChainID,
   NATIVE_TOKEN,
   SOLANA_CHAIN_ID,
   SupportedChains,

package/dist/{execute-HX1fQ7wG.d.ts → execute-CKTsf_tD.d.ts}

@@ -1,4 +1,4 @@
-import { ChainID, QuoteResponse, TokenSearchResponse as TokenSearchResponse$1, TokenInfo as TokenInfo$1 } from '@shogun-sdk/intents-sdk';
+import { ChainID, QuoteResponse, TokenSearchResponse as TokenSearchResponse$1, TokenInfo as TokenInfo$1, ChainOrderStatus } from '@shogun-sdk/intents-sdk';
 import { WalletClient } from 'viem';
 import { A as AdaptedWallet } from './wallet-MmUIz8GE.js';
 
@@ -65,7 +65,7 @@ type SwapQuoteResponse = {
     warning?: string;
 };
 
-type Stage = 'processing' | 'approving' | 'approved' | 'signing' | 'submitting' | 'success' | 'error';
+type Stage = 'processing' | 'approving' | 'approved' | 'signing' | 'submitting' | 'initiated' | 'shogun_processing' | 'success' | 'error';
 type PlaceOrderResult = {
     status: boolean;
     txHash?: string;
@@ -109,19 +109,17 @@ interface BalanceResponse {
 type TokenSearchResponse = TokenSearchResponse$1;
 type TokenInfo = TokenInfo$1;
 
+/**
+ * Types representing the structure of user orders and polling results.
+ */
+
+type OrderStatus = ChainOrderStatus | "Timeout" | "NotFound";
+type PollResult = OrderStatus;
+
 /**
  * Executes a swap order on the correct chain (EVM or Solana).
  *
- * @param quote - The quote object returned from the quote API.
- * @param accountAddress - The wallet address initiating the swap.
- * @param recipientAddress - recipient for output tokens.
- * @param wallet - Adapted wallet (EVM or Solana).
- * @param onStatus - Optional callback for UI updates.
- * @param options - Optional execution settings.
- *   - deadline: UNIX timestamp (seconds)
- *                Default = now + 20 minutes
- *
- * @returns Execution result { status, message, stage }
+ * Provides detailed logs for debugging when NODE_ENV !== 'production'.
  */
 declare function executeOrder({ quote, accountAddress, recipientAddress, wallet, onStatus, options, }: {
     quote: SwapQuoteResponse;
@@ -130,18 +128,18 @@ declare function executeOrder({ quote, accountAddress, recipientAddress, wallet,
     wallet: AdaptedWallet | WalletClient;
     onStatus?: (stage: Stage, message?: string) => void;
     options?: {
-        /**  Optional swap deadline (UNIX seconds). Default: now + 20 minutes */
         deadline?: number;
     };
 }): Promise<{
     status: boolean;
-    txHash: string;
+    orderId: string;
     chainId: number;
-    stage: string;
+    finalStatus: PollResult;
+    stage: Stage;
 } | {
     status: boolean;
     message: string;
     stage: string;
 }>;
 
-export { type BalanceRequestParams as B, type PlaceOrderResult as P, type QuoteTokenInfo as Q, type SwapQuoteParams as S, type TokenBalance as T, type SwapQuoteResponse as a, type Stage as b, type BalanceResponse as c, type TokenSearchResponse as d, executeOrder as e, type TokenInfo as f };
+export { type BalanceRequestParams as B, type PlaceOrderResult as P, type QuoteTokenInfo as Q, type SwapQuoteParams as S, type TokenBalance as T, type SwapQuoteResponse as a, type Stage as b, type BalanceResponse as c, type TokenSearchResponse as d, executeOrder as e, type TokenInfo as f, type PollResult as g };

package/dist/{execute-FaLLPp1i.d.cts → execute-DOv1i2Su.d.cts}

@@ -1,4 +1,4 @@
-import { ChainID, QuoteResponse, TokenSearchResponse as TokenSearchResponse$1, TokenInfo as TokenInfo$1 } from '@shogun-sdk/intents-sdk';
+import { ChainID, QuoteResponse, TokenSearchResponse as TokenSearchResponse$1, TokenInfo as TokenInfo$1, ChainOrderStatus } from '@shogun-sdk/intents-sdk';
 import { WalletClient } from 'viem';
 import { A as AdaptedWallet } from './wallet-MmUIz8GE.cjs';
 
@@ -65,7 +65,7 @@ type SwapQuoteResponse = {
     warning?: string;
 };
 
-type Stage = 'processing' | 'approving' | 'approved' | 'signing' | 'submitting' | 'success' | 'error';
+type Stage = 'processing' | 'approving' | 'approved' | 'signing' | 'submitting' | 'initiated' | 'shogun_processing' | 'success' | 'error';
 type PlaceOrderResult = {
     status: boolean;
     txHash?: string;
@@ -109,19 +109,17 @@ interface BalanceResponse {
 type TokenSearchResponse = TokenSearchResponse$1;
 type TokenInfo = TokenInfo$1;
 
+/**
+ * Types representing the structure of user orders and polling results.
+ */
+
+type OrderStatus = ChainOrderStatus | "Timeout" | "NotFound";
+type PollResult = OrderStatus;
+
 /**
  * Executes a swap order on the correct chain (EVM or Solana).
  *
- * @param quote - The quote object returned from the quote API.
- * @param accountAddress - The wallet address initiating the swap.
- * @param recipientAddress - recipient for output tokens.
- * @param wallet - Adapted wallet (EVM or Solana).
- * @param onStatus - Optional callback for UI updates.
- * @param options - Optional execution settings.
- *   - deadline: UNIX timestamp (seconds)
- *                Default = now + 20 minutes
- *
- * @returns Execution result { status, message, stage }
+ * Provides detailed logs for debugging when NODE_ENV !== 'production'.
  */
 declare function executeOrder({ quote, accountAddress, recipientAddress, wallet, onStatus, options, }: {
     quote: SwapQuoteResponse;
@@ -130,18 +128,18 @@ declare function executeOrder({ quote, accountAddress, recipientAddress, wallet,
     wallet: AdaptedWallet | WalletClient;
     onStatus?: (stage: Stage, message?: string) => void;
     options?: {
-        /**  Optional swap deadline (UNIX seconds). Default: now + 20 minutes */
         deadline?: number;
     };
 }): Promise<{
     status: boolean;
-    txHash: string;
+    orderId: string;
     chainId: number;
-    stage: string;
+    finalStatus: PollResult;
+    stage: Stage;
 } | {
     status: boolean;
     message: string;
     stage: string;
 }>;
 
-export { type BalanceRequestParams as B, type PlaceOrderResult as P, type QuoteTokenInfo as Q, type SwapQuoteParams as S, type TokenBalance as T, type SwapQuoteResponse as a, type Stage as b, type BalanceResponse as c, type TokenSearchResponse as d, executeOrder as e, type TokenInfo as f };
+export { type BalanceRequestParams as B, type PlaceOrderResult as P, type QuoteTokenInfo as Q, type SwapQuoteParams as S, type TokenBalance as T, type SwapQuoteResponse as a, type Stage as b, type BalanceResponse as c, type TokenSearchResponse as d, executeOrder as e, type TokenInfo as f, type PollResult as g };