@kaspacom/swap-sdk 1.0.9 → 1.0.11

package/dist/index.cjs

@@ -0,0 +1,982 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_SWAP_SETTINGS: () => DEFAULT_SETTINGS,
+  LoaderStatuses: () => LoaderStatuses,
+  NETWORKS: () => NETWORKS,
+  SwapSdkController: () => SwapSdkController,
+  SwapService: () => SwapService,
+  WalletService: () => WalletService,
+  createKaspaComSwapController: () => createKaspaComSwapController
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/index.ts
+var LoaderStatuses = /* @__PURE__ */ ((LoaderStatuses2) => {
+  LoaderStatuses2[LoaderStatuses2["CALCULATING_QUOTE"] = 1] = "CALCULATING_QUOTE";
+  LoaderStatuses2[LoaderStatuses2["APPROVING"] = 2] = "APPROVING";
+  LoaderStatuses2[LoaderStatuses2["SWAPPING"] = 3] = "SWAPPING";
+  return LoaderStatuses2;
+})(LoaderStatuses || {});
+
+// src/services/wallet.service.ts
+var import_ethers = require("ethers");
+var WalletService = class {
+  // injected provider (window.ethereum or similar)
+  constructor(config, injectedProvider) {
+    this.signer = null;
+    this.address = null;
+    this.config = config;
+    this.networkProvider = new import_ethers.JsonRpcProvider(config.rpcUrl, {
+      name: config.name,
+      chainId: config.chainId
+    }, config.additionalJsonRpcApiProviderOptionsOptions);
+    if (injectedProvider) {
+      this.connect(this.injectedProvider);
+    }
+  }
+  async connect(injectedProvider) {
+    if (injectedProvider) {
+      this.injectedProvider = injectedProvider;
+      this.walletProvider = new import_ethers.BrowserProvider(this.injectedProvider);
+    }
+    if (!this.injectedProvider || !this.walletProvider) {
+      throw new Error("Please connect wallet.");
+    }
+    try {
+      const accounts = await this.injectedProvider.request({
+        method: "eth_requestAccounts"
+      });
+      if (accounts.length === 0) {
+        throw new Error("No accounts found");
+      }
+      this.address = accounts[0];
+      const chainId = await this.injectedProvider.request({
+        method: "eth_chainId"
+      });
+      const currentChainId = parseInt(chainId, 16);
+      if (currentChainId !== this.config.chainId) {
+        try {
+          await this.injectedProvider.request({
+            method: "wallet_switchEthereumChain",
+            params: [{ chainId: `0x${this.config.chainId.toString(16)}` }]
+          });
+        } catch (switchError) {
+          if (switchError.code === 4902) {
+            await this.injectedProvider.request({
+              method: "wallet_addEthereumChain",
+              params: [{
+                chainId: `0x${this.config.chainId.toString(16)}`,
+                chainName: this.config.name,
+                nativeCurrency: {
+                  name: "ETH",
+                  symbol: "ETH",
+                  decimals: 18
+                },
+                rpcUrls: [this.config.rpcUrl],
+                blockExplorerUrls: this.config.blockExplorerUrl ? [this.config.blockExplorerUrl] : []
+              }]
+            });
+            await this.injectedProvider.request({
+              method: "wallet_switchEthereumChain",
+              params: [{ chainId: `0x${this.config.chainId.toString(16)}` }]
+            });
+          } else {
+            throw new Error(`Please switch to ${this.config.name} network`);
+          }
+        }
+      }
+      this.signer = await this.walletProvider.getSigner();
+      return this.address;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new Error("User rejected wallet connection");
+      }
+      throw new Error(`Failed to connect wallet: ${error.message}`);
+    }
+  }
+  disconnect() {
+    this.address = null;
+    this.signer = null;
+  }
+  isConnected() {
+    return !!this.address && !!this.signer;
+  }
+  getAddress() {
+    return this.address;
+  }
+  getProvider() {
+    return this.walletProvider || this.networkProvider;
+  }
+  getSigner() {
+    return this.signer;
+  }
+  // Helper method to get current chain ID
+  async getCurrentChainId() {
+    if (!this.injectedProvider) {
+      throw new Error("No Ethereum wallet detected");
+    }
+    const chainId = await this.injectedProvider.request({
+      method: "eth_chainId"
+    });
+    return parseInt(chainId, 16);
+  }
+  // Connect wallet and emit event with address
+  async connectWallet() {
+    if (this.injectedProvider) {
+      try {
+        const accounts = await this.injectedProvider.request({
+          method: "eth_requestAccounts"
+        });
+        if (accounts.length > 0 && typeof accounts[0] === "string") {
+          const address = accounts[0];
+          this.address = address;
+          return address;
+        } else {
+          throw new Error("No accounts found");
+        }
+      } catch (error) {
+        console.error("Failed to connect wallet:", error);
+        throw error;
+      }
+    } else {
+      throw new Error("No Ethereum wallet detected. Please connect a wallet provider.");
+    }
+  }
+  // Disconnect wallet and emit event
+  disconnectWallet() {
+    this.address = null;
+    this.signer = null;
+  }
+};
+
+// src/services/swap.service.ts
+var import_ethers2 = require("ethers");
+var import_sdk_core = require("@uniswap/sdk-core");
+var import_v2_sdk = require("@uniswap/v2-sdk");
+var PARTNER_FEE_BPS_DIVISOR = 10000n;
+var SwapService = class {
+  constructor(provider, config, swapOptions) {
+    this.config = config;
+    this.swapOptions = swapOptions;
+    this.signer = null;
+    this.pairs = [];
+    this.resolvePairsLoaded = null;
+    this.resolvePartnerFeeLoaded = null;
+    this.partnerFee = 0n;
+    this.isFeeActive = false;
+    this.provider = provider;
+    this.wethAddress = config.wethAddress;
+    this.chainId = config.chainId;
+    const routerAbi = [
+      // Swaps (ERC20 <-> ERC20)
+      "function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      "function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      // Swaps (ETH <-> ERC20)
+      "function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)",
+      "function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)",
+      "function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      "function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      // Get Amounts
+      "function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)",
+      "function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut)",
+      "function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn)",
+      "function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts)",
+      // Get WETH
+      "function WETH() external pure returns (address)"
+    ];
+    const factoryAbi = [
+      "function getPair(address tokenA, address tokenB) external view returns (address pair)",
+      "function allPairs(uint) external view returns (address pair)",
+      "function allPairsLength() external view returns (uint)"
+    ];
+    const proxyAbi = [
+      ...routerAbi,
+      "function partnerFee(bytes32) external view returns (address feeRecipient, uint16 feeBps)",
+      "function feeEnabled() external view returns (bool)"
+    ];
+    this.routerContract = new import_ethers2.Contract(config.routerAddress, routerAbi, provider);
+    this.factoryContract = new import_ethers2.Contract(config.factoryAddress, factoryAbi, provider);
+    if (config.proxyAddress) {
+      this.proxyContract = new import_ethers2.Contract(config.proxyAddress, proxyAbi, provider);
+    }
+    this.pairsLoadedPromise = new Promise((resolve) => {
+      this.resolvePairsLoaded = resolve;
+    });
+    this.partnerFeeLoadedPromise = new Promise((resolve) => {
+      this.resolvePartnerFeeLoaded = resolve;
+    });
+    this.loadAllPairsFromGraph();
+    this.loadPartnerFee();
+  }
+  // parnter fee is BPS_DIVISOR = 10_000n;
+  async loadPartnerFee() {
+    if (!this.resolvePairsLoaded) {
+      return this.partnerFee;
+    }
+    if (this.swapOptions.partnerKey) {
+      const [, fee] = await this.proxyContract?.partnerFee(this.swapOptions.partnerKey);
+      this.partnerFee = fee;
+    }
+    this.partnerFee = 100n;
+    const isFeeActive = await this.proxyContract?.feeEnabled();
+    this.isFeeActive = isFeeActive;
+    if (this.resolvePartnerFeeLoaded) {
+      this.resolvePartnerFeeLoaded();
+      this.resolvePartnerFeeLoaded = null;
+    }
+    return this.partnerFee;
+  }
+  setSigner(signer) {
+    this.signer = signer;
+    this.routerContract = this.routerContract.connect(signer);
+    if (this.proxyContract) {
+      this.proxyContract = this.proxyContract.connect(signer);
+    }
+  }
+  /**
+   * Rounds a number string to the specified number of decimal places
+   * to avoid parseUnits errors with too many decimals
+   */
+  roundToDecimals(value, decimals) {
+    const num = parseFloat(value);
+    if (isNaN(num)) {
+      return "0";
+    }
+    return num.toFixed(decimals);
+  }
+  /**
+   * Loads all pairs from The Graph and caches them as Uniswap SDK Pair instances.
+   * @param graphEndpoint The GraphQL endpoint URL
+   */
+  async loadAllPairsFromGraph() {
+    const query = `{
+      pairs(first: 1000) {
+        id
+        reserve0
+        reserve1
+        token0 { id symbol name decimals }
+        token1 { id symbol name decimals }
+      }
+    }`;
+    try {
+      const response = await fetch(this.config.graphEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query })
+      });
+      if (!response.ok) throw new Error(`Network error: ${response.status}`);
+      const { data } = await response.json();
+      if (!data || !data.pairs) return;
+      const pairs = [];
+      for (const pair of data.pairs) {
+        pairs.push(
+          this.createSDKPair(pair)
+        );
+      }
+      this.pairs = pairs;
+      const wethPair = data.pairs.find(
+        (pair) => pair.token0.id.toLowerCase() === this.wethAddress.toLowerCase() || pair.token1.id.toLowerCase() === this.wethAddress.toLowerCase()
+      );
+      if (wethPair) {
+        const tokenData = wethPair.token0.id.toLowerCase() === this.wethAddress.toLowerCase() ? wethPair.token0 : wethPair.token1;
+        this.wethToken = {
+          address: tokenData.id,
+          symbol: tokenData.symbol,
+          name: tokenData.name,
+          decimals: Number(tokenData.decimals)
+        };
+      } else {
+        throw new Error("No weth token found");
+      }
+      if (this.resolvePairsLoaded) {
+        this.resolvePairsLoaded();
+        this.resolvePairsLoaded = null;
+      }
+    } catch (error) {
+      console.error("Error loading pairs from graph:", error);
+      if (this.resolvePairsLoaded) {
+        this.resolvePairsLoaded();
+        this.resolvePairsLoaded = null;
+      }
+    }
+  }
+  async waitForPairsLoaded() {
+    return await this.pairsLoadedPromise;
+  }
+  async waitForPartnerFeeLoaded() {
+    return await this.partnerFeeLoadedPromise;
+  }
+  createSDKPair(pair) {
+    const { token0, token1, id, reserve0, reserve1 } = pair;
+    const sdkToken0 = new import_sdk_core.Token(
+      this.chainId,
+      token0.id,
+      Number(token0.decimals),
+      token0.symbol,
+      token0.name
+    );
+    const sdkToken1 = new import_sdk_core.Token(
+      this.chainId,
+      token1.id,
+      Number(token1.decimals),
+      token1.symbol,
+      token1.name
+    );
+    let reserve0BN;
+    let reserve1BN;
+    if (reserve0 && reserve1) {
+      reserve0BN = (0, import_ethers2.parseUnits)(reserve0, Number(token0.decimals));
+      reserve1BN = (0, import_ethers2.parseUnits)(reserve1, Number(token1.decimals));
+    } else {
+      throw new Error("No reserves data");
+    }
+    const amount0 = import_sdk_core.CurrencyAmount.fromRawAmount(
+      sdkToken0,
+      reserve0BN.toString()
+    );
+    const amount1 = import_sdk_core.CurrencyAmount.fromRawAmount(
+      sdkToken1,
+      reserve1BN.toString()
+    );
+    const sdkPair = new import_v2_sdk.Pair(amount0, amount1);
+    return sdkPair;
+  }
+  /**
+   * Returns the cached pairs for use in routing.
+   */
+  getPairs() {
+    return this.pairs;
+  }
+  /**
+   * Finds the best trade path using Uniswap SDK for a given input amount.
+   * Returns the best path as an array of addresses, or null if no trade found.
+   */
+  async getBestTrade(fromToken, toToken, amountInWei, isOutputAmount) {
+    const sdkFromToken = new import_sdk_core.Token(
+      this.chainId,
+      fromToken.address,
+      fromToken.decimals,
+      fromToken.symbol,
+      fromToken.name
+    );
+    const sdkToToken = new import_sdk_core.Token(
+      this.chainId,
+      toToken.address,
+      toToken.decimals,
+      toToken.symbol,
+      toToken.name
+    );
+    const currencyAmount = import_sdk_core.CurrencyAmount.fromRawAmount(
+      isOutputAmount ? sdkToToken : sdkFromToken,
+      amountInWei
+    );
+    await this.waitForPairsLoaded();
+    await this.waitForPartnerFeeLoaded();
+    const pairs = this.getPairs();
+    if (!pairs || pairs.length === 0) {
+      throw new Error("Pairs not loaded yet. Please wait for initialization.");
+    }
+    const tradeConfig = {
+      maxHops: 3,
+      maxNumResults: 1
+    };
+    const trades = isOutputAmount ? import_v2_sdk.Trade.bestTradeExactOut(pairs, sdkFromToken, currencyAmount, tradeConfig) : import_v2_sdk.Trade.bestTradeExactIn(
+      pairs,
+      currencyAmount,
+      sdkToToken,
+      tradeConfig
+    );
+    if (trades.length > 0) {
+      return trades[0];
+    } else {
+      return null;
+    }
+  }
+  trimTrailingZeros(value) {
+    if (!value.includes(".")) return value;
+    value = value.replace(/\.?0+$/, "");
+    return value;
+  }
+  /**
+   * 
+   * @param sellToken 
+   * @param buyToken 
+   * @param targetAmount 
+   * @param isOutputAmount true if user input output (How much tokens to receive) and not input (how much tokens to sell)
+   * @param slippage 
+   * @returns 
+   */
+  async calculateTrade(sellToken, buyToken, targetAmount, isOutputAmount, slippage) {
+    try {
+      const roundedAmountIn = this.roundToDecimals(targetAmount, isOutputAmount ? buyToken.decimals : sellToken.decimals);
+      let sellAmountWei = (0, import_ethers2.parseUnits)(
+        roundedAmountIn,
+        isOutputAmount ? buyToken.decimals : sellToken.decimals
+      );
+      if (isOutputAmount && this.partnerFee && this.partnerFee > 0n) {
+        const numerator = sellAmountWei * PARTNER_FEE_BPS_DIVISOR;
+        const denominator = PARTNER_FEE_BPS_DIVISOR - this.partnerFee;
+        sellAmountWei = (numerator + denominator - 1n) / denominator;
+      }
+      const trade = await this.getBestTrade(
+        sellToken.address == import_ethers2.ethers.ZeroAddress ? this.wethToken : sellToken,
+        buyToken.address == import_ethers2.ethers.ZeroAddress ? this.wethToken : buyToken,
+        sellAmountWei.toString(),
+        isOutputAmount
+      );
+      if (!trade) {
+        throw new Error("No trade path found for the given tokens and amount.");
+      }
+      const amountIn = trade.inputAmount.quotient.toString();
+      const amountOut = trade.outputAmount.quotient.toString();
+      let amounts = {
+        amountIn: (0, import_ethers2.formatUnits)(amountIn, sellToken.decimals),
+        amountOut: isOutputAmount ? this.trimTrailingZeros(roundedAmountIn) : (0, import_ethers2.formatUnits)(amountOut, buyToken.decimals),
+        amountInRaw: amountIn,
+        amountOutRaw: amountOut
+      };
+      const slippagePercent = new import_sdk_core.Percent(Math.round(parseFloat(slippage) * 100), 1e4);
+      let maxAmountIn, minAmountOut;
+      if (isOutputAmount) {
+        maxAmountIn = trade.maximumAmountIn(slippagePercent).quotient.toString();
+        amounts.maxAmountInRaw = maxAmountIn;
+        amounts.maxAmountIn = (0, import_ethers2.formatUnits)(maxAmountIn, sellToken.decimals);
+      } else {
+        minAmountOut = trade.minimumAmountOut(slippagePercent).quotient.toString();
+        amounts.minAmountOutRaw = minAmountOut;
+        amounts.minAmountOut = (0, import_ethers2.formatUnits)(minAmountOut, buyToken.decimals);
+      }
+      if (this.partnerFee && this.partnerFee > 0n) {
+        if (!isOutputAmount) {
+          const amountOut2 = BigInt(trade.outputAmount.quotient.toString());
+          const amountOutMinusFee = amountOut2 * (PARTNER_FEE_BPS_DIVISOR - this.partnerFee) / PARTNER_FEE_BPS_DIVISOR;
+          amounts.amountOutRaw = amountOutMinusFee.toString();
+          amounts.amountOut = (0, import_ethers2.formatUnits)(amountOutMinusFee, buyToken.decimals);
+          if (minAmountOut) {
+            const minOut = BigInt(minAmountOut.toString());
+            const minOutMinusFee = minOut * (PARTNER_FEE_BPS_DIVISOR - this.partnerFee) / PARTNER_FEE_BPS_DIVISOR;
+            amounts.minAmountOutRaw = minOutMinusFee.toString();
+            amounts.minAmountOut = (0, import_ethers2.formatUnits)(minOutMinusFee, buyToken.decimals);
+          }
+        }
+      }
+      return {
+        trade,
+        computed: amounts
+      };
+    } catch (error) {
+      console.error("Error calculating expected output:", error);
+      throw error;
+    }
+  }
+  async checkApproval(tokenAddress, amount, spenderAddress) {
+    try {
+      const tokenContract = new import_ethers2.Contract(
+        tokenAddress,
+        ["function allowance(address,address) view returns (uint256)"],
+        this.provider
+      );
+      const signerAddress = await this.signer?.getAddress();
+      if (!signerAddress) {
+        throw new Error("Please connect wallet first");
+      }
+      const allowance = await tokenContract.allowance(signerAddress, spenderAddress);
+      const amountWei = (0, import_ethers2.parseUnits)(amount, 18);
+      return allowance >= amountWei;
+    } catch (error) {
+      console.error("Error checking approval:", error);
+      return false;
+    }
+  }
+  async isApprovalNeeded(fromToken, amountInWei) {
+    if (!this.signer) {
+      throw new Error("Please connect wallet first");
+    }
+    if (fromToken.address !== import_ethers2.ethers.ZeroAddress) {
+      const tokenContract = new import_ethers2.Contract(
+        fromToken.address,
+        ["function allowance(address,address) view returns (uint256)", "function approve(address,uint256) returns (bool)"],
+        this.signer
+      );
+      const signerAddress = await this.signer.getAddress();
+      const allowanceTo = this.config.proxyAddress || this.config.routerAddress;
+      const allowance = await tokenContract.allowance(signerAddress, allowanceTo);
+      if (allowance < amountInWei) {
+        return {
+          isApprovalNeeded: true,
+          tokenContract,
+          signerAddress,
+          allowanceTo
+        };
+      }
+    }
+    return {
+      isApprovalNeeded: false
+    };
+  }
+  async approveIfNeedApproval(fromToken, amountInWei) {
+    const isApprovalNeededInfo = await this.isApprovalNeeded(fromToken, amountInWei);
+    if (!isApprovalNeededInfo.isApprovalNeeded) {
+      return null;
+    }
+    return await isApprovalNeededInfo.tokenContract.approve(isApprovalNeededInfo.allowanceTo, import_ethers2.ethers.MaxUint256);
+  }
+  async swapTokens(fromToken, toToken, amountInWei, amountOutWei, path, isOutputAmount, deadline) {
+    if (!this.signer) {
+      throw new Error("Please connect wallet first");
+    }
+    try {
+      const deadlineTimestamp = Math.floor(Date.now() / 1e3) + deadline * 60;
+      let tx;
+      const signerAddress = await this.signer.getAddress();
+      const iface = this.proxyContract ? this.proxyContract.interface : this.routerContract.interface;
+      let swapData;
+      const to = this.isFeeActive ? this.config.proxyAddress : signerAddress;
+      if (isOutputAmount) {
+        if (fromToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapETHForExactTokens", [
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else if (toToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapTokensForExactETH", [
+            amountOutWei,
+            amountInWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else {
+          swapData = iface.encodeFunctionData("swapTokensForExactTokens", [
+            amountOutWei,
+            amountInWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        }
+      } else {
+        if (fromToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapExactETHForTokens", [
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else if (toToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapExactTokensForETH", [
+            amountInWei,
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else {
+          swapData = iface.encodeFunctionData("swapExactTokensForTokens", [
+            amountInWei,
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        }
+      }
+      if (this.proxyContract) {
+        swapData = (0, import_ethers2.hexlify)(this.concatSelectorAndParams(import_ethers2.ethers.getBytes(swapData), [], "permit", this.swapOptions.partnerKey));
+      }
+      tx = await this.signer.sendTransaction({
+        to: this.config.proxyAddress || this.config.routerAddress,
+        from: signerAddress,
+        data: swapData,
+        value: fromToken.address === import_ethers2.ethers.ZeroAddress ? amountInWei : 0n
+      });
+      return tx;
+    } catch (error) {
+      console.error("Error swapping tokens:", error);
+      throw error;
+    }
+  }
+  async getPairAddress(tokenA, tokenB) {
+    try {
+      return await this.factoryContract.getPair(tokenA, tokenB);
+    } catch (error) {
+      console.error("Error getting pair address:", error);
+      throw error;
+    }
+  }
+  async checkLiquidityExists(tokenA, tokenB) {
+    try {
+      const pairAddress = await this.getPairAddress(tokenA, tokenB);
+      return pairAddress !== import_ethers2.ZeroAddress;
+    } catch (error) {
+      console.error("Error checking liquidity:", error);
+      return false;
+    }
+  }
+  // Uniswap SDK methods for advanced trading
+  async createTrade(fromToken, toToken, amountIn, slippageTolerance = 0.5) {
+    try {
+      const fromTokenInstance = new import_sdk_core.Token(
+        this.chainId,
+        fromToken.address,
+        fromToken.decimals,
+        fromToken.symbol,
+        fromToken.name
+      );
+      const toTokenInstance = new import_sdk_core.Token(
+        this.chainId,
+        toToken.address,
+        toToken.decimals,
+        toToken.symbol,
+        toToken.name
+      );
+      const currencyAmount = import_sdk_core.CurrencyAmount.fromRawAmount(
+        fromTokenInstance,
+        (0, import_ethers2.parseUnits)(amountIn, fromToken.decimals).toString()
+      );
+      const pairAddress = await this.getPairAddress(fromToken.address, toToken.address);
+      if (pairAddress === import_ethers2.ZeroAddress) {
+        throw new Error("No liquidity pair found");
+      }
+      const pair = new import_v2_sdk.Pair(
+        import_sdk_core.CurrencyAmount.fromRawAmount(fromTokenInstance, "0"),
+        import_sdk_core.CurrencyAmount.fromRawAmount(toTokenInstance, "0")
+      );
+      const route = new import_v2_sdk.Route([pair], fromTokenInstance, toTokenInstance);
+      const trade = new import_v2_sdk.Trade(
+        route,
+        currencyAmount,
+        import_sdk_core.TradeType.EXACT_INPUT
+      );
+      return trade;
+    } catch (error) {
+      console.error("Error creating trade:", error);
+      throw error;
+    }
+  }
+  /**
+   * Fetch tokens from the graph endpoint (subgraph)
+   * @param graphEndpoint The GraphQL endpoint URL
+   * @param search Optional search string for symbol or name
+   */
+  async getTokensFromGraph(limit = 100, search) {
+    const finalLimit = Math.min(limit, 1e3);
+    const query = `{
+      tokens(first: ${finalLimit}, where: {
+        ${search ? `or: [
+          { symbol_contains_nocase: "${search}" }
+          { name_contains_nocase: "${search}" }
+        ]` : ""}
+      }) {
+        id
+        symbol
+        name
+        decimals
+      }
+    }`;
+    try {
+      const response = await fetch(this.config.graphEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query })
+      });
+      if (!response.ok) throw new Error(`Network error: ${response.status}`);
+      const { data } = await response.json();
+      if (!data || !data.tokens) return [];
+      return data.tokens.map((token) => ({
+        address: token.id,
+        symbol: token.symbol,
+        name: token.name,
+        decimals: Number(token.decimals)
+      }));
+    } catch (error) {
+      console.error("Error fetching tokens from graph:", error);
+      return [];
+    }
+  }
+  /**
+   * Concatenates bytes: selector, array of bytes (each element is Uint8Array), array length (uint8, 1 byte), marker (bytes16(keccak256(markerString)))
+   * @param selectorBytes Uint8Array — function selector (usually 4 bytes)
+   * @param arrayOfBytes Uint8Array[] — array of bytes (each element is Uint8Array)
+   * @param markerString string — string from which bytes16(keccak256(...)) will be derived
+   * @returns Uint8Array — concatenated result
+   */
+  concatSelectorAndParams(selectorBytes, arrayOfBytes, markerString, partnerKey) {
+    const paramsBytes = arrayOfBytes.length === 0 ? new Uint8Array(0) : arrayOfBytes.reduce((acc, arr) => {
+      const res = new Uint8Array(acc.length + arr.length);
+      res.set(acc, 0);
+      res.set(arr, acc.length);
+      return res;
+    });
+    const arrayLengthByte = new Uint8Array([arrayOfBytes.length & 255]);
+    const markerHash = import_ethers2.ethers.keccak256(import_ethers2.ethers.toUtf8Bytes(markerString));
+    const markerBytes = import_ethers2.ethers.getBytes(markerHash).slice(0, 16);
+    const parts = [
+      selectorBytes,
+      paramsBytes,
+      arrayLengthByte,
+      markerBytes
+    ];
+    if (partnerKey) {
+      const partnerKeyBytes = import_ethers2.ethers.getBytes(partnerKey);
+      const partnerFlagHash = import_ethers2.ethers.keccak256(import_ethers2.ethers.toUtf8Bytes("is_partner_fee"));
+      const partnerFlagBytes = import_ethers2.ethers.getBytes(partnerFlagHash).slice(0, 16);
+      parts.push(partnerKeyBytes, partnerFlagBytes);
+    }
+    const totalLen = parts.reduce((sum, p) => sum + p.length, 0);
+    const out = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const p of parts) {
+      out.set(p, offset);
+      offset += p.length;
+    }
+    return out;
+  }
+};
+
+// src/controllers/swap-sdk.controller.ts
+var DEFAULT_SETTINGS = {
+  maxSlippage: "0.5",
+  swapDeadline: 20
+};
+var SwapSdkController = class {
+  constructor(options) {
+    this.state = {
+      loader: null
+    };
+    this.input = {
+      fromToken: null,
+      toToken: null,
+      amount: void 0,
+      isOutputAmount: false,
+      settings: DEFAULT_SETTINGS
+    };
+    this.options = options;
+    this.initServices();
+  }
+  initServices() {
+    this.walletService = new WalletService(
+      this.options.networkConfig,
+      this.options.walletProvider
+    );
+    this.swapService = new SwapService(
+      this.walletService.getProvider(),
+      this.options.networkConfig,
+      this.options
+    );
+  }
+  async setChange(patch) {
+    const next = {
+      ...this.state,
+      ...patch
+    };
+    this.state = next;
+    if (typeof this.options.onChange === "function") {
+      await this.options.onChange(next, patch);
+    }
+  }
+  async connectWallet(injectedProvider) {
+    const address = await this.walletService.connect(injectedProvider);
+    const signer = this.walletService.getSigner();
+    if (signer) this.swapService.setSigner(signer);
+    return address;
+  }
+  disconnectWallet() {
+    this.walletService.disconnect();
+    this.swapService.setSigner(null);
+  }
+  getState() {
+    return this.state;
+  }
+  get settings() {
+    return {
+      ...DEFAULT_SETTINGS,
+      ...this.input.settings || {}
+    };
+  }
+  async calculateQuoteIfNeeded() {
+    const { fromToken, toToken, amount, isOutputAmount } = this.input;
+    if (!fromToken || !toToken || !amount || amount <= 0) {
+      return;
+    }
+    await this.setChange({ loader: 1 /* CALCULATING_QUOTE */, error: void 0 });
+    try {
+      const tradeResult = await this.swapService.calculateTrade(
+        fromToken,
+        toToken,
+        String(amount),
+        isOutputAmount == true,
+        // isOutputAmount: true for input amount, false for output amount
+        this.settings.maxSlippage
+      );
+      await this.setChange({
+        computed: tradeResult.computed,
+        tradeInfo: tradeResult.trade,
+        loader: null
+      });
+    } catch (error) {
+      await this.setChange({ error: error?.message || String(error), loader: null });
+    }
+  }
+  async setData(input) {
+    this.input = {
+      ...this.input,
+      ...input
+    };
+    await this.calculateQuoteIfNeeded();
+    return this.getState();
+  }
+  async isNeedApproval() {
+    if (!this.input || !this.walletService.isConnected() || !this.swapService) throw new Error("Wallet not connected or input missing");
+    const { fromToken, amount } = this.input;
+    if (!fromToken || amount === void 0 || !this.state.computed?.amountInRaw) throw new Error("fromToken or amount missing");
+    return (await this.swapService.isApprovalNeeded(fromToken, BigInt(this.state.computed.amountInRaw))).isApprovalNeeded;
+  }
+  async approveIfNeeded() {
+    if (!this.input || !this.walletService.isConnected()) throw new Error("Wallet not connected or input missing");
+    const { fromToken, amount } = this.input;
+    if (!fromToken || amount === void 0 || !this.state.computed?.amountInRaw) throw new Error("fromToken or amount missing");
+    await this.setChange({ loader: 2 /* APPROVING */ });
+    try {
+      const tx = await this.swapService?.approveIfNeedApproval(
+        fromToken,
+        BigInt(this.state.computed.amountInRaw)
+      );
+      let receipt;
+      if (tx) {
+        await this.setChange({ approveTxHash: tx.hash });
+        receipt = await tx.wait();
+        if (!receipt) {
+          throw new Error("Receipt not found, Please try again");
+        }
+        if (receipt.status != 1) {
+          throw new Error("Transaction Rejected");
+        }
+      }
+      return receipt?.hash;
+    } catch (error) {
+      await this.setChange({ error: error?.message || String(error), loader: null });
+      throw error;
+    }
+  }
+  async swap() {
+    try {
+      await this.setChange({
+        txHash: void 0,
+        approveTxHash: void 0
+      });
+      const { fromToken, toToken, amount } = this.input;
+      if (!fromToken || !toToken || amount === void 0) throw new Error("Tokens or amount not set");
+      await this.approveIfNeeded();
+      await this.setChange({ loader: 3 /* SWAPPING */ });
+      const trade = this.state.tradeInfo;
+      if (!trade) throw new Error("Trade info missing - calculate quote first");
+      const path = trade.route.path.map((token) => token.address);
+      if (path.length === 0) throw new Error("Trade path missing");
+      const computed = this.state.computed;
+      if (!computed) throw new Error("Computed amounts missing");
+      const transaction = await this.swapService.swapTokens(
+        fromToken,
+        toToken,
+        computed.maxAmountInRaw || computed.amountInRaw,
+        computed.minAmountOutRaw || computed.amountOutRaw,
+        path,
+        this.input.isOutputAmount == true,
+        this.settings.swapDeadline
+      );
+      await this.setChange({ txHash: transaction.hash });
+      const receipt = await transaction.wait();
+      if (!receipt) {
+        throw new Error("Receipt not found, Please try again");
+      }
+      if (receipt.status != 1) {
+        throw new Error("Transaction Rejected");
+      }
+      await this.setChange({
+        loader: null
+      });
+      return receipt.hash;
+    } catch (error) {
+      await this.setChange({ error: error?.message || String(error), loader: null });
+      throw error;
+    }
+  }
+  async getPartnerFee() {
+    return Number(await this.swapService.loadPartnerFee()) / Number(PARTNER_FEE_BPS_DIVISOR);
+  }
+  async getTokensFromGraph(limit = 100, search) {
+    if (!this.swapService) {
+      throw new Error("Swap Service not exists");
+    }
+    return await this.swapService.getTokensFromGraph(limit, search);
+  }
+  get currentNetworkConfig() {
+    return this.options.networkConfig;
+  }
+};
+
+// src/config/networks.ts
+var NETWORKS = {
+  "kasplex-testnet": {
+    name: "Kasplex Test",
+    chainId: 167012,
+    rpcUrl: "https://rpc.kasplextest.xyz",
+    routerAddress: "0x5A410f79f58a11344E3523d99820Cf231bc888bd",
+    factoryAddress: "0x772B3321B37C1a9aeF0Da1B5A6453E1C2A264beF",
+    proxyAddress: "0xbE448f863d2bB7bCcD9185A854DF2D8d63498dB0",
+    wethAddress: "0x654A3287c317D4Fc6e8482FeF523Dc4572b563AA",
+    graphEndpoint: "https://dev-graph-kasplex.kaspa.com/subgraphs/name/uniswap-v2",
+    blockExplorerUrl: "https://explorer.testnet.kasplextest.xyz",
+    additionalJsonRpcApiProviderOptionsOptions: {
+      batchMaxCount: 1,
+      batchMaxSize: 1,
+      batchStallTime: 0
+    }
+  }
+  // Add more networks as needed
+};
+
+// src/index.ts
+function createKaspaComSwapController(options) {
+  let resolvedOptions;
+  if ("networkConfig" in options && typeof options.networkConfig === "string") {
+    const networkConfig = NETWORKS[options.networkConfig];
+    if (!networkConfig) throw new Error(`Unknown network key: ${options.networkConfig}`);
+    resolvedOptions = { ...options, networkConfig };
+  } else {
+    resolvedOptions = options;
+  }
+  return new SwapSdkController(resolvedOptions);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SWAP_SETTINGS,
+  LoaderStatuses,
+  NETWORKS,
+  SwapSdkController,
+  SwapService,
+  WalletService,
+  createKaspaComSwapController
+});