@nonnux/world-swap 0.1.0

package/src/defaults.js

@@ -0,0 +1,187 @@
+// @nonnux/world-swap/defaults
+// Default configuration for the nonnux / World Chain ecosystem.
+// Every value here can be overridden via props (client) or config (server),
+// so third parties can plug in their own tokens, contracts and RPC.
+
+export const DEFAULT_RPC_URL = 'https://worldchain-mainnet.g.alchemy.com/public';
+
+export const DEFAULT_EXPLORER_URL = 'https://worldscan.org';
+
+// Swap + Uniswap infrastructure (World Chain mainnet).
+export const DEFAULT_CONTRACTS = {
+  // nonnux swap contracts
+  swapV2: '0x4479A14811274D0eEB8Eb8932fA5A49b51F37852', // SliceSwapV6 (V2 only)
+  swapV3: '0x4Cf23b3C9BeB48b85bc8F01E3dAB674Ce94E180a', // SliceSwapUniV3 (V3 only)
+  swapRouter: '0x380a940524C4cC1829f654B7790B338f676C31b8', // SliceSwapRouter (V2 <-> V3)
+
+  // Uniswap V2
+  uniV2Router: '0x541aB7c31A119441eF3575F6973277DE0eF460bd',
+  uniV2Factory: '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f',
+
+  // Uniswap V3
+  uniV3Factory: '0x7a5028BDa40e7B173C278C5342087826455ea25a',
+  uniV3Quoter: '0x10158D43e6cc414deE1Bd1eB0EfC6a5cBCfF244c',
+
+  // Routing hub token
+  wld: '0x2cFc85d8E48F8EAB294be644d9E25C3030863003',
+};
+
+// Uniswap V3 fee tiers.
+export const V3_FEE_TIERS = {
+  LOWEST: 100, // 0.01%
+  LOW: 500, // 0.05%
+  MEDIUM: 3000, // 0.3%
+  HIGH: 10000, // 1% (common for memecoins)
+};
+
+// Pairs that have a direct V3 pool and should skip cross-version routing.
+export const DEFAULT_DIRECT_V3_PAIRS = [['SUSHI', 'WLD']];
+
+// Default platform fee, in basis points (100 = 1%).
+export const DEFAULT_PLATFORM_FEE_BPS = 100;
+
+// Token list. `icon` paths are app-relative (served from /public). Override
+// `tokens` with your own list to swap a different set.
+export const DEFAULT_TOKENS = [
+  {
+    symbol: 'SLICE',
+    name: 'UFO PIZZA',
+    address: '0x513530649BAC862c38b65e957E6EA38d3f86F3dc',
+    icon: '/tokens/slice.gif',
+    gradient: 'from-orange-500 to-yellow-500',
+    decimals: 18,
+    emoji: '🍕',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'REI$',
+    name: 'REIS',
+    address: '0x10377A2e9CC81A8822885cd847e577F7F39B5574',
+    icon: '/tokens/reis.gif',
+    gradient: 'from-white via-gray-200 to-gray-300',
+    decimals: 18,
+    emoji: '♔',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'PAU$',
+    name: 'PAUS',
+    address: '0x2e5f6BB8C993e64B3bC1fC9473C8B2CDEd772D06',
+    icon: '/tokens/paus.gif',
+    gradient: 'from-emerald-900 via-teal-900 to-slate-900',
+    decimals: 18,
+    emoji: '₽',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'CONTO$',
+    name: 'CONTOS',
+    address: '0xE67Fb81ca7d20eB90bA3a53220018a9A7f870de8',
+    icon: '/tokens/contos.gif',
+    gradient: 'from-cyan-500 via-teal-600 to-slate-800',
+    decimals: 18,
+    emoji: '©️',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'WLC',
+    name: 'WorldChain OGs',
+    address: '0x9d59Bb9d85Ae4622116Ad11055B5be4349b67dc2',
+    icon: '/tokens/wlc.gif',
+    gradient: 'from-green-500 to-emerald-500',
+    decimals: 18,
+    emoji: '🪙',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'CDT',
+    name: 'TRIBO',
+    address: '0x3Cb880f7ac84950c369e700deE2778d023b0C52d',
+    icon: '/tokens/cdt.gif',
+    gradient: 'from-green-500 to-emerald-500',
+    decimals: 18,
+    emoji: '🏴',
+    externalTaxPercent: 2,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: '$PVO',
+    name: 'PaVcOin',
+    address: '0xE977de70dd1F571Aa563E41525C28b4F1eDB69ba',
+    icon: '/tokens/pvo.gif',
+    gradient: 'from-yellow-500 to-red-500',
+    decimals: 18,
+    emoji: '🦃',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'RFX2.0',
+    name: 'Roflex 2.0 MemeToken',
+    address: '0x03995cE5Ad612a2cC3E4DFBEEb0EeD7BC165749b',
+    icon: '/tokens/rfx2.0.gif',
+    gradient: 'from-blue-500 to-slate-500',
+    decimals: 18,
+    emoji: '🐲',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'SWIFH',
+    name: 'Samwifhat',
+    address: '0x06B4C6830bb19BF07A88ff96758003074EaE9c52',
+    icon: '/tokens/swifh.gif',
+    gradient: 'from-white-500 to-pink-500',
+    decimals: 18,
+    emoji: '🎩',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'WLD',
+    name: 'Worldcoin',
+    address: '0x2cFc85d8E48F8EAB294be644d9E25C3030863003',
+    icon: '/tokens/wld.gif',
+    gradient: 'from-blue-500 to-purple-500',
+    decimals: 18,
+    emoji: '🌍',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'WETH',
+    name: 'Wrapped Ether',
+    address: '0x4200000000000000000000000000000000000006',
+    icon: '/tokens/weth.gif',
+    gradient: 'from-purple-500 to-pink-500',
+    decimals: 18,
+    emoji: '🔹',
+    externalTaxPercent: 0,
+    poolVersion: 'v2',
+  },
+  {
+    symbol: 'SUSHI',
+    name: 'SUSHI Token',
+    address: '0xab09A728E53d3d6BC438BE95eeD46Da0Bbe7FB38',
+    icon: '/tokens/sushi.gif',
+    gradient: 'from-pink-500 to-purple-500',
+    decimals: 18,
+    emoji: '🍣',
+    externalTaxPercent: 0,
+    poolVersion: 'v3', // SUSHI only has a V3 pool
+    v3FeeTier: 10000, // 1% fee tier
+  },
+];
+
+// Find a token by symbol within a given list (case-insensitive).
+export const getTokenBySymbol = (tokens, symbol) =>
+  tokens.find((t) => t.symbol.toLowerCase() === String(symbol).toLowerCase());
+
+// Find a token by address within a given list (case-insensitive).
+export const getTokenByAddress = (tokens, address) =>
+  tokens.find((t) => t.address.toLowerCase() === String(address).toLowerCase());

package/src/server.js

@@ -0,0 +1,458 @@
+// @nonnux/world-swap/server
+// Swap quote API for World Chain (Uniswap V2 / V3 / cross-version).
+// Self-contained: only `ethers` + a public RPC. No database, no secrets.
+//
+// Usage in a Next.js app (app/api/swap/quote/route.js):
+//
+//   // Batteries-included (nonnux / World Chain defaults):
+//   export { POST, GET } from '@nonnux/world-swap/server';
+//
+//   // Or with your own tokens / contracts:
+//   import { createSwapQuoteHandler } from '@nonnux/world-swap/server';
+//   import { MY_TOKENS } from '@/config/tokens';
+//   export const { POST, GET } = createSwapQuoteHandler({ tokens: MY_TOKENS });
+
+import { ethers } from 'ethers';
+import {
+  DEFAULT_TOKENS,
+  DEFAULT_CONTRACTS,
+  DEFAULT_RPC_URL,
+  DEFAULT_DIRECT_V3_PAIRS,
+  DEFAULT_PLATFORM_FEE_BPS,
+  V3_FEE_TIERS,
+  getTokenBySymbol,
+} from './defaults.js';
+
+// ---------------------------------------------------------------------------
+// ABIs
+// ---------------------------------------------------------------------------
+const ROUTER_V2_ABI = [
+  'function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts)',
+];
+const FACTORY_V2_ABI = [
+  'function getPair(address tokenA, address tokenB) external view returns (address pair)',
+];
+const PAIR_V2_ABI = [
+  'function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+  'function token0() external view returns (address)',
+];
+const FACTORY_V3_ABI = [
+  'function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool)',
+];
+const QUOTER_V3_ABI = [
+  'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96)) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+];
+const POOL_V3_ABI = ['function liquidity() external view returns (uint128)'];
+
+const BPS_DENOMINATOR = 10000n;
+
+// ---------------------------------------------------------------------------
+// Price impact (V2)
+// ---------------------------------------------------------------------------
+async function calculatePriceImpactV2(provider, factory, tokenInAddress, tokenOutAddress, amountInWei, amountOutWei) {
+  try {
+    const pairAddress = await factory.getPair(tokenInAddress, tokenOutAddress);
+    if (pairAddress === ethers.ZeroAddress) return 0;
+
+    const pair = new ethers.Contract(pairAddress, PAIR_V2_ABI, provider);
+    const [reserve0, reserve1] = await pair.getReserves();
+    const token0 = await pair.token0();
+
+    const isToken0 = token0.toLowerCase() === tokenInAddress.toLowerCase();
+    const reserveIn = isToken0 ? reserve0 : reserve1;
+    const reserveOut = isToken0 ? reserve1 : reserve0;
+
+    const spotPrice = Number(reserveOut) / Number(reserveIn);
+    const effectivePrice = Number(amountOutWei) / Number(amountInWei);
+    const priceImpact = ((spotPrice - effectivePrice) / spotPrice) * 100;
+
+    return Math.max(0, priceImpact);
+  } catch (e) {
+    return 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Quote: V2
+// ---------------------------------------------------------------------------
+async function getQuoteV2(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, tokenInSymbol, tokenOutSymbol) {
+  const { provider, c, WLD } = ctx;
+  const factory = new ethers.Contract(c.uniV2Factory, FACTORY_V2_ABI, provider);
+  const router = new ethers.Contract(c.uniV2Router, ROUTER_V2_ABI, provider);
+
+  let amountOutWei = 0n;
+  let routeType = 'direct';
+  let pathDisplay = `${tokenInSymbol} → ${tokenOutSymbol}`;
+  let path = [tokenInAddress, tokenOutAddress];
+  let priceImpact = 0;
+
+  const directPair = await factory.getPair(tokenInAddress, tokenOutAddress);
+
+  if (directPair !== ethers.ZeroAddress) {
+    try {
+      const directPath = [tokenInAddress, tokenOutAddress];
+      const amounts = await router.getAmountsOut(amountAfterFeeWei, directPath);
+      amountOutWei = amounts[amounts.length - 1];
+      path = directPath;
+      priceImpact = await calculatePriceImpactV2(provider, factory, tokenInAddress, tokenOutAddress, amountAfterFeeWei, amountOutWei);
+    } catch (e) {
+      /* fall through to multi-hop */
+    }
+  }
+
+  if (
+    amountOutWei === 0n &&
+    tokenInAddress.toLowerCase() !== WLD.toLowerCase() &&
+    tokenOutAddress.toLowerCase() !== WLD.toLowerCase()
+  ) {
+    try {
+      const multiHopPath = [tokenInAddress, WLD, tokenOutAddress];
+      const amounts = await router.getAmountsOut(amountAfterFeeWei, multiHopPath);
+      amountOutWei = amounts[amounts.length - 1];
+      routeType = 'multi-hop';
+      pathDisplay = `${tokenInSymbol} → WLD → ${tokenOutSymbol}`;
+      path = multiHopPath;
+
+      const wldAmount = amounts[1];
+      const impact1 = await calculatePriceImpactV2(provider, factory, tokenInAddress, WLD, amountAfterFeeWei, wldAmount);
+      const impact2 = await calculatePriceImpactV2(provider, factory, WLD, tokenOutAddress, wldAmount, amountOutWei);
+      priceImpact = impact1 + impact2;
+    } catch (e) {
+      /* no route */
+    }
+  }
+
+  if (amountOutWei === 0n) {
+    return { success: false, error: 'NO_LIQUIDITY', message: `No V2 pool for ${tokenInSymbol}/${tokenOutSymbol}` };
+  }
+
+  return {
+    success: true,
+    amountOutWei,
+    routeType,
+    poolVersion: 'v2',
+    pathDisplay,
+    path,
+    priceImpact: Math.round(priceImpact * 100) / 100,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Quote: V3
+// ---------------------------------------------------------------------------
+async function getQuoteV3(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, tokenInSymbol, tokenOutSymbol, tokenConfig) {
+  const { provider, c, FEE } = ctx;
+  const factory = new ethers.Contract(c.uniV3Factory, FACTORY_V3_ABI, provider);
+  const quoter = new ethers.Contract(c.uniV3Quoter, QUOTER_V3_ABI, provider);
+
+  const feeTiersToTry = [tokenConfig?.v3FeeTier || FEE.HIGH, FEE.HIGH, FEE.MEDIUM, FEE.LOW];
+
+  for (const feeTier of [...new Set(feeTiersToTry)]) {
+    try {
+      const poolAddress = await factory.getPool(tokenInAddress, tokenOutAddress, feeTier);
+
+      if (poolAddress !== ethers.ZeroAddress) {
+        const pool = new ethers.Contract(poolAddress, POOL_V3_ABI, provider);
+        const liquidity = await pool.liquidity();
+
+        if (liquidity > 0n) {
+          const quoteResult = await quoter.quoteExactInputSingle.staticCall({
+            tokenIn: tokenInAddress,
+            tokenOut: tokenOutAddress,
+            amountIn: amountAfterFeeWei,
+            fee: feeTier,
+            sqrtPriceLimitX96: 0,
+          });
+
+          let priceImpact = 0;
+          try {
+            const smallAmount = ethers.parseEther('0.001');
+            if (amountAfterFeeWei > smallAmount) {
+              const spotQuote = await quoter.quoteExactInputSingle.staticCall({
+                tokenIn: tokenInAddress,
+                tokenOut: tokenOutAddress,
+                amountIn: smallAmount,
+                fee: feeTier,
+                sqrtPriceLimitX96: 0,
+              });
+
+              const spotPrice = Number(spotQuote[0]) / Number(smallAmount);
+              const effectivePrice = Number(quoteResult[0]) / Number(amountAfterFeeWei);
+              priceImpact = ((spotPrice - effectivePrice) / spotPrice) * 100;
+              priceImpact = Math.max(0, Math.round(priceImpact * 100) / 100);
+            }
+          } catch (e) {
+            priceImpact = 0.1;
+          }
+
+          return {
+            success: true,
+            amountOutWei: quoteResult[0],
+            routeType: 'direct',
+            poolVersion: 'v3',
+            pathDisplay: `${tokenInSymbol} → ${tokenOutSymbol}`,
+            priceImpact,
+            v3FeeTier: feeTier,
+          };
+        }
+      }
+    } catch (e) {
+      /* try next fee tier */
+    }
+  }
+
+  return { success: false, error: 'NO_LIQUIDITY', message: `No V3 pool for ${tokenInSymbol}/${tokenOutSymbol}` };
+}
+
+// ---------------------------------------------------------------------------
+// Quote: cross-version (V3 <-> V2 via WLD)
+// ---------------------------------------------------------------------------
+async function getQuoteCrossVersion(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, tokenInSymbol, tokenOutSymbol, direction, v3TokenConfig) {
+  const { provider, c, FEE, WLD } = ctx;
+  const factoryV2 = new ethers.Contract(c.uniV2Factory, FACTORY_V2_ABI, provider);
+  const routerV2 = new ethers.Contract(c.uniV2Router, ROUTER_V2_ABI, provider);
+  const factoryV3 = new ethers.Contract(c.uniV3Factory, FACTORY_V3_ABI, provider);
+  const quoterV3 = new ethers.Contract(c.uniV3Quoter, QUOTER_V3_ABI, provider);
+
+  let intermediateWldWei = 0n;
+  let finalAmountOutWei = 0n;
+  let v3FeeTier = 0;
+
+  if (direction === 'v3_to_v2') {
+    const feeTiersToTry = [v3TokenConfig?.v3FeeTier || FEE.HIGH, FEE.HIGH, FEE.MEDIUM];
+
+    for (const feeTier of [...new Set(feeTiersToTry)]) {
+      try {
+        const poolAddress = await factoryV3.getPool(tokenInAddress, WLD, feeTier);
+
+        if (poolAddress !== ethers.ZeroAddress) {
+          const pool = new ethers.Contract(poolAddress, POOL_V3_ABI, provider);
+          const liquidity = await pool.liquidity();
+
+          if (liquidity > 0n) {
+            const quoteResult = await quoterV3.quoteExactInputSingle.staticCall({
+              tokenIn: tokenInAddress,
+              tokenOut: WLD,
+              amountIn: amountAfterFeeWei,
+              fee: feeTier,
+              sqrtPriceLimitX96: 0,
+            });
+
+            intermediateWldWei = quoteResult[0];
+            v3FeeTier = feeTier;
+            break;
+          }
+        }
+      } catch (e) {
+        /* try next fee tier */
+      }
+    }
+
+    if (intermediateWldWei === 0n) {
+      return { success: false, error: 'NO_LIQUIDITY', message: `No V3 pool for ${tokenInSymbol}/WLD` };
+    }
+
+    try {
+      const path = [WLD, tokenOutAddress];
+      const amounts = await routerV2.getAmountsOut(intermediateWldWei, path);
+      finalAmountOutWei = amounts[amounts.length - 1];
+    } catch (e) {
+      return { success: false, error: 'NO_LIQUIDITY', message: `No V2 pool for WLD/${tokenOutSymbol}` };
+    }
+  } else {
+    // v2_to_v3
+    try {
+      const path = [tokenInAddress, WLD];
+      const amounts = await routerV2.getAmountsOut(amountAfterFeeWei, path);
+      intermediateWldWei = amounts[amounts.length - 1];
+    } catch (e) {
+      return { success: false, error: 'NO_LIQUIDITY', message: `No V2 pool for ${tokenInSymbol}/WLD` };
+    }
+
+    const feeTiersToTry = [v3TokenConfig?.v3FeeTier || FEE.HIGH, FEE.HIGH, FEE.MEDIUM];
+
+    for (const feeTier of [...new Set(feeTiersToTry)]) {
+      try {
+        const poolAddress = await factoryV3.getPool(WLD, tokenOutAddress, feeTier);
+
+        if (poolAddress !== ethers.ZeroAddress) {
+          const pool = new ethers.Contract(poolAddress, POOL_V3_ABI, provider);
+          const liquidity = await pool.liquidity();
+
+          if (liquidity > 0n) {
+            const quoteResult = await quoterV3.quoteExactInputSingle.staticCall({
+              tokenIn: WLD,
+              tokenOut: tokenOutAddress,
+              amountIn: intermediateWldWei,
+              fee: feeTier,
+              sqrtPriceLimitX96: 0,
+            });
+
+            finalAmountOutWei = quoteResult[0];
+            v3FeeTier = feeTier;
+            break;
+          }
+        }
+      } catch (e) {
+        /* try next fee tier */
+      }
+    }
+
+    if (finalAmountOutWei === 0n) {
+      return { success: false, error: 'NO_LIQUIDITY', message: `No V3 pool for WLD/${tokenOutSymbol}` };
+    }
+  }
+
+  let priceImpact = 0;
+  try {
+    if (direction === 'v2_to_v3') {
+      priceImpact = await calculatePriceImpactV2(provider, factoryV2, tokenInAddress, WLD, amountAfterFeeWei, intermediateWldWei);
+    } else {
+      priceImpact = await calculatePriceImpactV2(provider, factoryV2, WLD, tokenOutAddress, intermediateWldWei, finalAmountOutWei);
+    }
+    priceImpact += 0.1; // small allowance for the V3 leg
+  } catch (e) {
+    priceImpact = 0.5;
+  }
+
+  return {
+    success: true,
+    amountOutWei: finalAmountOutWei,
+    routeType: 'cross-version',
+    poolVersion: direction,
+    pathDisplay: `${tokenInSymbol} → WLD → ${tokenOutSymbol}`,
+    priceImpact: Math.round(priceImpact * 100) / 100,
+    intermediateAmount: parseFloat(ethers.formatEther(intermediateWldWei)),
+    v3FeeTier,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Handler factory
+// ---------------------------------------------------------------------------
+/**
+ * Build a Next.js route handler ({ POST, GET }) for swap quotes.
+ *
+ * @param {Object} [userConfig]
+ * @param {Array}  [userConfig.tokens]        Token list (defaults to nonnux ecosystem).
+ * @param {Object} [userConfig.contracts]     Contract address overrides (merged with defaults).
+ * @param {string} [userConfig.rpcUrl]        JSON-RPC URL for World Chain.
+ * @param {Array}  [userConfig.directV3Pairs] Symbol pairs that use a direct V3 pool.
+ * @param {number} [userConfig.platformFeeBps] Platform fee in basis points (100 = 1%).
+ * @param {Object} [userConfig.v3FeeTiers]    V3 fee tier map override.
+ */
+export function createSwapQuoteHandler(userConfig = {}) {
+  const tokens = userConfig.tokens || DEFAULT_TOKENS;
+  const c = { ...DEFAULT_CONTRACTS, ...(userConfig.contracts || {}) };
+  const RPC_URL = userConfig.rpcUrl || DEFAULT_RPC_URL;
+  const FEE = userConfig.v3FeeTiers || V3_FEE_TIERS;
+  const directV3Pairs = userConfig.directV3Pairs || DEFAULT_DIRECT_V3_PAIRS;
+  const platformFeeBps = BigInt(userConfig.platformFeeBps ?? DEFAULT_PLATFORM_FEE_BPS);
+  const WLD = c.wld;
+
+  const isDirectV3Pair = (a, b) =>
+    directV3Pairs.some(([x, y]) => (x === a && y === b) || (x === b && y === a));
+
+  async function POST(request) {
+    try {
+      const body = await request.json();
+      const { token_in, token_out, amount_in, token_in_address, token_out_address } = body;
+
+      if (!token_in || !token_out || !amount_in || parseFloat(amount_in) <= 0) {
+        return Response.json({ success: false, error: 'INVALID_PARAMETERS' }, { status: 400 });
+      }
+      if (!token_in_address || !token_out_address) {
+        return Response.json({ success: false, error: 'MISSING_ADDRESSES' }, { status: 400 });
+      }
+
+      let tokenInAddress, tokenOutAddress;
+      try {
+        tokenInAddress = ethers.getAddress(token_in_address);
+        tokenOutAddress = ethers.getAddress(token_out_address);
+      } catch (e) {
+        return Response.json({ success: false, error: 'INVALID_ADDRESS' }, { status: 400 });
+      }
+
+      const provider = new ethers.JsonRpcProvider(RPC_URL);
+      const ctx = { provider, c, FEE, WLD };
+
+      const tokenInConfig = getTokenBySymbol(tokens, token_in);
+      const tokenOutConfig = getTokenBySymbol(tokens, token_out);
+      const tokenInVersion = tokenInConfig?.poolVersion || 'v2';
+      const tokenOutVersion = tokenOutConfig?.poolVersion || 'v2';
+
+      const amountInWei = ethers.parseEther(amount_in.toString());
+      const platformFeeWei = (amountInWei * platformFeeBps) / BPS_DENOMINATOR;
+      const amountAfterFeeWei = amountInWei - platformFeeWei;
+
+      let result;
+      if (isDirectV3Pair(token_in, token_out)) {
+        const cfg = tokenInConfig?.poolVersion === 'v3' ? tokenInConfig : tokenOutConfig;
+        result = await getQuoteV3(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, token_in, token_out, cfg);
+      } else if (tokenInVersion === 'v2' && tokenOutVersion === 'v2') {
+        result = await getQuoteV2(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, token_in, token_out);
+      } else if (tokenInVersion === 'v3' && tokenOutVersion === 'v3') {
+        result = await getQuoteV3(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, token_in, token_out, tokenInConfig);
+      } else if (tokenInVersion === 'v3' && tokenOutVersion === 'v2') {
+        result = await getQuoteCrossVersion(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, token_in, token_out, 'v3_to_v2', tokenInConfig);
+      } else {
+        result = await getQuoteCrossVersion(ctx, tokenInAddress, tokenOutAddress, amountAfterFeeWei, token_in, token_out, 'v2_to_v3', tokenOutConfig);
+      }
+
+      if (!result || !result.success) {
+        return Response.json(result || { success: false, error: 'QUOTE_FAILED' });
+      }
+
+      const amountInFormatted = parseFloat(amount_in);
+      const platformFee = parseFloat(ethers.formatEther(platformFeeWei));
+      const amountAfterFee = parseFloat(ethers.formatEther(amountAfterFeeWei));
+      const amountOut = parseFloat(ethers.formatEther(result.amountOutWei));
+      const rate = amountOut / amountAfterFee;
+      const feePercent = Number(platformFeeBps) / 100;
+
+      return Response.json({
+        success: true,
+        quote: {
+          token_in,
+          token_out,
+          amount_in: amountInFormatted,
+          platform_fee: platformFee,
+          platform_fee_percent: feePercent,
+          amount_after_fee: amountAfterFee,
+          amount_out: amountOut,
+          rate,
+          rate_display: `1 ${token_in} = ${rate.toFixed(6)} ${token_out}`,
+          price_impact: result.priceImpact || 1,
+          route_type: result.routeType,
+          pool_version: result.poolVersion,
+          path_display: result.pathDisplay,
+          path: result.path,
+          intermediate_amount: result.intermediateAmount,
+          v3_fee_tier: result.v3FeeTier,
+          expires_at: new Date(Date.now() + 30000).toISOString(),
+        },
+      });
+    } catch (error) {
+      console.error('[world-swap/quote] Error:', error);
+      return Response.json({ success: false, error: 'QUOTE_FAILED', message: error.message }, { status: 500 });
+    }
+  }
+
+  async function GET() {
+    return Response.json({
+      success: true,
+      supported_tokens: tokens.map((t) => ({
+        symbol: t.symbol,
+        address: t.address,
+        poolVersion: t.poolVersion || 'v2',
+      })),
+      platform_fee: `${Number(platformFeeBps) / 100}%`,
+      features: ['v2', 'v3', 'cross-version'],
+    });
+  }
+
+  return { POST, GET };
+}
+
+// Batteries-included handler using nonnux / World Chain defaults.
+export const { POST, GET } = createSwapQuoteHandler();