@shogun-sdk/swap 0.0.2-test

package/dist/core.js

@@ -0,0 +1,590 @@
+// src/core/token-list.ts
+import { getTokenList as intentsGetTokenList } from "@shogun-sdk/intents-sdk";
+async function getTokenList(params) {
+  return intentsGetTokenList(params);
+}
+
+// src/core/getQuote.ts
+import { QuoteProvider } from "@shogun-sdk/intents-sdk";
+import { parseUnits } from "viem";
+
+// src/core/executeOrder/normalizeNative.ts
+import { isEvmChain } from "@shogun-sdk/intents-sdk";
+
+// src/utils/address.ts
+var NATIVE_TOKEN = {
+  ETH: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+  SOL: "So11111111111111111111111111111111111111111",
+  SUI: "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+};
+var isNativeAddress = (tokenAddress) => {
+  const NATIVE_ADDRESSES = Object.values(SupportedChains).map((chain) => chain.tokenAddress.toLowerCase());
+  const normalizedTokenAddress = tokenAddress.toLowerCase();
+  return !!tokenAddress && NATIVE_ADDRESSES.includes(normalizedTokenAddress);
+};
+
+// src/utils/chain.ts
+import { ChainID } from "@shogun-sdk/intents-sdk";
+var SOLANA_CHAIN_ID = ChainID.Solana;
+var SupportedChains = [
+  {
+    id: ChainID.Arbitrum,
+    name: "Arbitrum",
+    isEVM: true,
+    wrapped: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    symbol: "ETH",
+    decimals: 18,
+    tokenAddress: NATIVE_TOKEN.ETH
+  },
+  {
+    id: ChainID.Optimism,
+    name: "Optimism",
+    isEVM: true,
+    wrapped: "0x4200000000000000000000000000000000000006",
+    symbol: "ETH",
+    decimals: 18,
+    tokenAddress: NATIVE_TOKEN.ETH
+  },
+  {
+    id: ChainID.Base,
+    name: "Base",
+    isEVM: true,
+    wrapped: "0x4200000000000000000000000000000000000006",
+    symbol: "ETH",
+    decimals: 18,
+    tokenAddress: NATIVE_TOKEN.ETH
+  },
+  {
+    id: ChainID.Hyperliquid,
+    name: "Hyperliquid",
+    isEVM: true,
+    wrapped: "0x5555555555555555555555555555555555555555",
+    symbol: "ETH",
+    decimals: 18,
+    tokenAddress: NATIVE_TOKEN.ETH
+  },
+  {
+    id: ChainID.BSC,
+    name: "BSC",
+    isEVM: true,
+    wrapped: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    symbol: "BNB",
+    decimals: 18,
+    tokenAddress: NATIVE_TOKEN.ETH
+  },
+  {
+    id: SOLANA_CHAIN_ID,
+    name: "Solana",
+    isEVM: false,
+    wrapped: "So11111111111111111111111111111111111111112",
+    symbol: "SOL",
+    decimals: 9,
+    tokenAddress: NATIVE_TOKEN.SOL
+  }
+];
+
+// src/utils/viem.ts
+function isViemWalletClient(wallet) {
+  return wallet.extend !== void 0 && wallet.getPermissions !== void 0;
+}
+
+// src/utils/number.ts
+function serializeBigIntsToStrings(obj) {
+  if (typeof obj === "bigint") {
+    return obj.toString();
+  }
+  if (typeof obj === "string" && /^\d+n$/.test(obj)) {
+    return obj.slice(0, -1);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => serializeBigIntsToStrings(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = serializeBigIntsToStrings(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/core/executeOrder/normalizeNative.ts
+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;
+}
+
+// src/core/getQuote.ts
+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
+  };
+}
+function buildQuoteParams({
+  tokenIn,
+  tokenOut,
+  sourceChainId,
+  destChainId,
+  amount,
+  slippage
+}) {
+  return {
+    tokenIn,
+    tokenOut,
+    sourceChainId,
+    destChainId,
+    amount: parseUnits(amount.toString(), tokenIn.decimals ?? 18),
+    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];
+  return {
+    results: combined,
+    nextCursorEvm: data.evm?.cursor ?? null,
+    nextCursorSvm: data.svm?.cursor ?? null
+  };
+}
+
+// src/core/executeOrder/execute.ts
+import { ChainID as ChainID4, isEvmChain as isEvmChain2 } from "@shogun-sdk/intents-sdk";
+import { BaseError } from "viem";
+
+// src/wallet-adapter/evm-wallet-adapter/adapter.ts
+import "ethers/lib/ethers.js";
+import { hexValue } from "ethers/lib/utils.js";
+import {
+  custom
+} from "viem";
+function isEVMTransaction(tx) {
+  return typeof tx.from === "string";
+}
+var adaptViemWallet = (wallet) => {
+  const signTypedData = async (signData) => {
+    return await wallet.signTypedData({
+      account: wallet.account,
+      domain: signData.domain,
+      types: signData.types,
+      primaryType: signData.primaryType ?? "Order",
+      message: signData.value
+    });
+  };
+  const sendTransaction = async (transaction) => {
+    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;
+  };
+  const switchChain = async (chainId) => {
+    try {
+      await wallet.switchChain({ id: chainId });
+    } catch (e) {
+      const msg = e?.message || "";
+      if (msg.includes("does not support the requested chain")) {
+        throw new Error("Wallet does not support this chain");
+      }
+      if (msg.includes("rejected")) throw e;
+      if (msg.includes("already pending")) return;
+    }
+  };
+  const address = async () => {
+    let addr = wallet.account?.address;
+    if (!addr) {
+      const addresses = await wallet.getAddresses();
+      addr = addresses[0];
+    }
+    if (!addr) throw new Error("No address found");
+    return addr;
+  };
+  return {
+    vmType: "EVM" /* EVM */,
+    transport: custom(wallet.transport),
+    getChainId: async () => wallet.getChainId(),
+    address,
+    sendTransaction,
+    signTypedData,
+    switchChain
+  };
+};
+
+// src/core/executeOrder/handleEvmExecution.ts
+import {
+  getEVMSingleChainOrderTypedData,
+  getEVMCrossChainOrderTypedData,
+  PERMIT2_ADDRESS
+} from "@shogun-sdk/intents-sdk";
+import { encodeFunctionData, erc20Abi } from "viem";
+
+// src/core/executeOrder/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"
+};
+
+// src/core/executeOrder/buildOrder.ts
+import { CrossChainOrder, SingleChainOrder } from "@shogun-sdk/intents-sdk";
+async function buildOrder({
+  quote,
+  accountAddress,
+  destination,
+  deadline,
+  isSingleChain
+}) {
+  const { tokenIn, tokenOut } = quote;
+  if (isSingleChain) {
+    return await SingleChainOrder.create({
+      user: accountAddress,
+      chainId: tokenIn.chainId,
+      tokenIn: tokenIn.address,
+      tokenOut: tokenOut.address,
+      amountIn: quote.amountIn,
+      amountOutMin: quote.internal.estimatedAmountOutReduced,
+      deadline,
+      destinationAddress: destination
+    });
+  }
+  return await CrossChainOrder.create({
+    user: accountAddress,
+    sourceChainId: tokenIn.chainId,
+    sourceTokenAddress: tokenIn.address,
+    sourceTokenAmount: quote.amountIn,
+    destinationChainId: tokenOut.chainId,
+    destinationTokenAddress: tokenOut.address,
+    destinationAddress: destination,
+    deadline,
+    destinationTokenMinAmount: quote.internal.estimatedAmountOutReduced,
+    minStablecoinAmount: quote.minStablecoinsAmount
+  });
+}
+
+// src/core/executeOrder/handleEvmExecution.ts
+async function handleEvmExecution({
+  recipientAddress,
+  quote,
+  chainId,
+  accountAddress,
+  wallet,
+  isSingleChain,
+  deadline,
+  update
+}) {
+  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
+  await wallet.switchChain(chainId);
+  const tokenIn = normalizeNative(chainId, quote.tokenIn.address);
+  const shouldWrapNative = isNativeAddress(quote.tokenIn.address);
+  update("processing", shouldWrapNative ? `${messageFor("processing")} (wrapping native token)` : messageFor("processing"));
+  if (shouldWrapNative) {
+    await wallet.sendTransaction({
+      to: tokenIn,
+      data: encodeFunctionData({
+        abi: [{ type: "function", name: "deposit", stateMutability: "payable", inputs: [], outputs: [] }],
+        functionName: "deposit",
+        args: []
+      }),
+      value: BigInt(quote.amountIn),
+      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("approved", messageFor("approved"));
+  const destination = recipientAddress ?? accountAddress;
+  const order = await buildOrder({
+    quote,
+    accountAddress,
+    destination,
+    deadline,
+    isSingleChain
+  });
+  update("signing", messageFor("signing"));
+  const { orderTypedData, nonce } = isSingleChain ? await getEVMSingleChainOrderTypedData(order) : await getEVMCrossChainOrderTypedData(order);
+  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 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" };
+}
+
+// src/core/executeOrder/handleSolanaExecution.ts
+import {
+  ChainID as ChainID3,
+  getSolanaSingleChainOrderInstructions,
+  getSolanaCrossChainOrderInstructions
+} from "@shogun-sdk/intents-sdk";
+import { VersionedTransaction } from "@solana/web3.js";
+async function handleSolanaExecution({
+  recipientAddress,
+  quote,
+  wallet,
+  isSingleChain,
+  update,
+  accountAddress,
+  deadline
+}) {
+  if (!wallet.rpcUrl) {
+    throw new Error("Solana wallet is missing rpcUrl");
+  }
+  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
+  update("processing", messageFor("processing"));
+  const destination = recipientAddress ?? accountAddress;
+  const order = await buildOrder({
+    quote,
+    accountAddress,
+    destination,
+    deadline,
+    isSingleChain
+  });
+  const txData = await getSolanaOrderInstructions({
+    order,
+    isSingleChain,
+    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"));
+  const response = await submitToAuctioneer({
+    order,
+    isSingleChain,
+    txData
+  });
+  if (!response.success) {
+    throw new Error("Auctioneer submission failed");
+  }
+  update("success", messageFor("success"));
+  return {
+    status: true,
+    txHash: txSignature,
+    chainId: ChainID3.Solana,
+    stage: "success"
+  };
+}
+async function getSolanaOrderInstructions({
+  order,
+  isSingleChain,
+  rpcUrl
+}) {
+  if (isSingleChain) {
+    return await getSolanaSingleChainOrderInstructions(order, {
+      rpcUrl
+    });
+  }
+  return await getSolanaCrossChainOrderInstructions(order, {
+    rpcUrl
+  });
+}
+async function submitToAuctioneer({
+  order,
+  isSingleChain,
+  txData
+}) {
+  if (isSingleChain) {
+    const { orderAddress, secretNumber } = txData;
+    return await order.sendToAuctioneer({
+      orderPubkey: orderAddress,
+      secretNumber
+    });
+  }
+  return await order.sendToAuctioneer({
+    orderPubkey: txData.orderAddress
+  });
+}
+
+// src/core/executeOrder/execute.ts
+async function executeOrder({
+  quote,
+  accountAddress,
+  recipientAddress,
+  wallet,
+  onStatus,
+  options = {}
+}) {
+  const deadline = options.deadline ?? Math.floor(Date.now() / 1e3) + 20 * 60;
+  const messageFor = (stage) => DEFAULT_STAGE_MESSAGES[stage];
+  const update = (stage, message) => onStatus?.(stage, message ?? messageFor(stage));
+  try {
+    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 (isEvmChain2(chainId)) {
+      return await handleEvmExecution({
+        recipientAddress,
+        quote,
+        chainId,
+        accountAddress,
+        wallet: adapter,
+        isSingleChain,
+        deadline,
+        update
+      });
+    }
+    if (chainId === ChainID4.Solana) {
+      return await handleSolanaExecution({
+        recipientAddress,
+        quote,
+        accountAddress,
+        wallet: adapter,
+        isSingleChain,
+        deadline,
+        update
+      });
+    }
+    update("error", "Unsupported chain");
+    return { status: false, message: "Unsupported chain", stage: "error" };
+  } catch (error) {
+    const message = error instanceof BaseError ? error.shortMessage : error instanceof Error ? error.message : String(error);
+    update("error", message);
+    return { status: false, message, stage: "error" };
+  }
+}
+function normalizeWallet(wallet) {
+  if (!wallet) return void 0;
+  if (isViemWalletClient(wallet)) return adaptViemWallet(wallet);
+  return wallet;
+}
+
+// src/core/index.ts
+import { ChainID as ChainID5, isEvmChain as isEvmChain3 } from "@shogun-sdk/intents-sdk";
+export {
+  ChainID5 as ChainID,
+  NATIVE_TOKEN,
+  SOLANA_CHAIN_ID,
+  SupportedChains,
+  buildQuoteParams,
+  executeOrder,
+  getBalances,
+  getQuote,
+  getTokenList,
+  isEvmChain3 as isEvmChain,
+  isNativeAddress,
+  isViemWalletClient,
+  serializeBigIntsToStrings
+};