@darksol/terminal 0.11.0 → 0.13.0

package/src/services/whale.js

@@ -0,0 +1,421 @@
+import EventEmitter from 'node:events';
+import fetch from 'node-fetch';
+import { ethers } from 'ethers';
+import { getConfig, setConfig, getRPC } from '../config/store.js';
+import { getApiKey } from '../config/keys.js';
+import { executeSwap } from '../trading/swap.js';
+import { theme } from '../ui/theme.js';
+import { kvDisplay, success, error, warn, info, table, formatAddress } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+const WHALE_CONFIG_KEY = 'whales';
+const DEFAULT_CHAIN = 'base';
+const DEFAULT_POLL_INTERVAL_MS = 15000;
+const TOKEN_ABI = [
+  'function symbol() view returns (string)',
+  'function decimals() view returns (uint8)',
+];
+
+const EXPLORER_APIS = {
+  base: 'https://api.basescan.org/api',
+  ethereum: 'https://api.etherscan.io/api',
+  arbitrum: 'https://api.arbiscan.io/api',
+  polygon: 'https://api.polygonscan.com/api',
+  optimism: 'https://api-optimistic.etherscan.io/api',
+};
+
+const STABLE_SYMBOLS = new Set(['USDC', 'USDT', 'USDBC', 'DAI']);
+
+const whaleEvents = new EventEmitter();
+whaleEvents.setMaxListeners(100);
+
+const whaleDeps = {
+  fetch,
+  executeSwap,
+  now: () => Date.now(),
+  providerFactory: (chain) => new ethers.JsonRpcProvider(getRPC(chain)),
+};
+
+function getWhaleStore() {
+  const current = getConfig(WHALE_CONFIG_KEY);
+  return {
+    tracked: current?.tracked || {},
+    feed: Array.isArray(current?.feed) ? current.feed : [],
+  };
+}
+
+function saveWhaleStore(store) {
+  setConfig(WHALE_CONFIG_KEY, store);
+}
+
+function normalizeAddress(address) {
+  if (!ethers.isAddress(address)) {
+    throw new Error(`Invalid wallet address: ${address}`);
+  }
+  return ethers.getAddress(address);
+}
+
+function normalizeChain(chain) {
+  const value = (chain || DEFAULT_CHAIN).toLowerCase();
+  if (!EXPLORER_APIS[value]) {
+    throw new Error(`Unsupported chain: ${chain}`);
+  }
+  return value;
+}
+
+function trackKey(address) {
+  return normalizeAddress(address).toLowerCase();
+}
+
+function getTrackedMap() {
+  return getWhaleStore().tracked;
+}
+
+function saveTrackedMap(tracked) {
+  const store = getWhaleStore();
+  store.tracked = tracked;
+  saveWhaleStore(store);
+}
+
+function formatWhaleTime(value) {
+  if (!value) return theme.dim('—');
+  return new Date(value).toLocaleString('en-US', {
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}
+
+function lastSeenActivity(txs = []) {
+  const latest = txs[0];
+  if (!latest) return null;
+  return new Date(parseInt(latest.timeStamp || '0', 10) * 1000).toISOString();
+}
+
+function createTrackedRecord(address, options = {}, current = {}) {
+  const normalized = normalizeAddress(address);
+  const nowIso = new Date(whaleDeps.now()).toISOString();
+  return {
+    address: normalized,
+    chain: normalizeChain(options.chain || current.chain || DEFAULT_CHAIN),
+    label: options.label ?? current.label ?? '',
+    notify: typeof options.notify === 'boolean' ? options.notify : (current.notify ?? true),
+    startedAt: current.startedAt || nowIso,
+    updatedAt: nowIso,
+    lastActivity: current.lastActivity || null,
+    lastSeenHash: current.lastSeenHash || null,
+    lastCheckedAt: current.lastCheckedAt || null,
+    knownTokens: Array.isArray(current.knownTokens) ? current.knownTokens : [],
+    mirror: current.mirror || null,
+  };
+}
+
+function buildExplorerUrl(chain, params) {
+  const url = new URL(EXPLORER_APIS[chain]);
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, String(value));
+  }
+
+  const apiKey = getApiKey('etherscan');
+  if (apiKey) {
+    url.searchParams.set('apikey', apiKey);
+  }
+
+  return url.toString();
+}
+
+async function explorerCall(chain, params) {
+  const response = await whaleDeps.fetch(buildExplorerUrl(chain, params));
+  const data = await response.json();
+
+  if (data.status === '0' && data.message && !String(data.result || '').includes('No transactions')) {
+    throw new Error(data.result || data.message);
+  }
+
+  return data;
+}
+
+export async function fetchExplorerTransactions(address, options = {}) {
+  const normalized = normalizeAddress(address);
+  const chain = normalizeChain(options.chain || DEFAULT_CHAIN);
+  const limit = Number(options.limit || 10);
+  const data = await explorerCall(chain, {
+    module: 'account',
+    action: 'txlist',
+    address: normalized,
+    startblock: 0,
+    endblock: 99999999,
+    page: 1,
+    offset: Math.max(limit, 1),
+    sort: 'desc',
+  });
+
+  return Array.isArray(data.result) ? data.result.slice(0, limit) : [];
+}
+
+export async function getWhaleActivity(address, limit = 10, options = {}) {
+  const normalized = normalizeAddress(address);
+  const chain = normalizeChain(options.chain || DEFAULT_CHAIN);
+  const txs = await fetchExplorerTransactions(normalized, { chain, limit });
+
+  if (!options.silent) {
+    showSection(`WHALE ACTIVITY — ${chain.toUpperCase()}`);
+    kvDisplay([
+      ['Wallet', normalized],
+      ['Transactions', String(txs.length)],
+    ]);
+    console.log('');
+
+    if (!txs.length) {
+      info('No recent transactions found');
+      return txs;
+    }
+
+    const rows = txs.map((tx) => {
+      const value = tx.value ? `${Number(ethers.formatEther(tx.value)).toFixed(4)} ETH` : theme.dim('0 ETH');
+      const method = tx.functionName ? tx.functionName.split('(')[0] : 'transfer';
+      return [
+        tx.hash.slice(0, 10) + '...',
+        formatAddress(tx.to || tx.from),
+        value,
+        method.slice(0, 18),
+        new Date(parseInt(tx.timeStamp || '0', 10) * 1000).toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }),
+      ];
+    });
+    table(['Hash', 'Counterparty', 'Value', 'Method', 'Time'], rows);
+    console.log('');
+  }
+
+  return txs;
+}
+
+export async function trackWallet(address, options = {}) {
+  const normalized = normalizeAddress(address);
+  const tracked = getTrackedMap();
+  const key = trackKey(normalized);
+  const next = createTrackedRecord(normalized, options, tracked[key] || {});
+
+  try {
+    const latest = await fetchExplorerTransactions(normalized, { chain: next.chain, limit: 1 });
+    if (latest[0]) {
+      next.lastSeenHash = latest[0].hash;
+      next.lastActivity = lastSeenActivity(latest);
+    }
+  } catch (err) {
+    warn(`Tracking started without initial explorer sync: ${err.message}`);
+  }
+
+  tracked[key] = next;
+  saveTrackedMap(tracked);
+
+  success(`Tracking ${next.label || formatAddress(normalized)} on ${next.chain}`);
+  kvDisplay([
+    ['Wallet', normalized],
+    ['Label', next.label || theme.dim('(none)')],
+    ['Notify', next.notify ? theme.success('on') : theme.dim('off')],
+    ['Last Activity', formatWhaleTime(next.lastActivity)],
+  ]);
+
+  return next;
+}
+
+export function listTracked(options = {}) {
+  const tracked = Object.values(getTrackedMap()).sort((a, b) => {
+    return (b.updatedAt || '').localeCompare(a.updatedAt || '');
+  });
+
+  if (!options.silent) {
+    showSection('WHALE TRACKER');
+    if (!tracked.length) {
+      info('No tracked wallets');
+      return tracked;
+    }
+
+    const rows = tracked.map((entry) => [
+      entry.label || theme.dim('unnamed'),
+      formatAddress(entry.address),
+      entry.chain,
+      entry.mirror ? theme.success('on') : theme.dim('off'),
+      formatWhaleTime(entry.lastActivity),
+    ]);
+    table(['Label', 'Wallet', 'Chain', 'Mirror', 'Last Activity'], rows);
+    console.log('');
+  }
+
+  return tracked;
+}
+
+export function stopTracking(address) {
+  const tracked = getTrackedMap();
+  const key = trackKey(address);
+  const existing = tracked[key];
+
+  if (!existing) {
+    warn(`Wallet not tracked: ${address}`);
+    return false;
+  }
+
+  delete tracked[key];
+  saveTrackedMap(tracked);
+  success(`Stopped tracking ${existing.label || formatAddress(existing.address)}`);
+  return true;
+}
+
+export function mirrorTrade(address, options = {}) {
+  const tracked = getTrackedMap();
+  const key = trackKey(address);
+  const existing = tracked[key];
+
+  if (!existing) {
+    throw new Error('Track the wallet before enabling mirror trading');
+  }
+
+  existing.mirror = {
+    enabled: true,
+    maxPerTrade: options.maxPerTrade ? Number(options.maxPerTrade) : null,
+    slippage: options.slippage !== undefined ? Number(options.slippage) : 2,
+    dryRun: Boolean(options.dryRun),
+    updatedAt: new Date(whaleDeps.now()).toISOString(),
+  };
+  existing.updatedAt = new Date(whaleDeps.now()).toISOString();
+  tracked[key] = existing;
+  saveTrackedMap(tracked);
+
+  success(`Mirror trading enabled for ${existing.label || formatAddress(existing.address)}`);
+  kvDisplay([
+    ['Max Per Trade', existing.mirror.maxPerTrade ? `$${existing.mirror.maxPerTrade} USDC` : theme.dim('no cap')],
+    ['Slippage', `${existing.mirror.slippage}%`],
+    ['Mode', existing.mirror.dryRun ? theme.warning('dry-run') : theme.success('live')],
+  ]);
+
+  return existing.mirror;
+}
+
+export function getTrackedWallet(address) {
+  return getTrackedMap()[trackKey(address)] || null;
+}
+
+export function updateTrackedWallet(address, updater) {
+  const tracked = getTrackedMap();
+  const key = trackKey(address);
+  const current = tracked[key];
+  if (!current) return null;
+  const next = typeof updater === 'function' ? updater(current) : updater;
+  tracked[key] = next;
+  saveTrackedMap(tracked);
+  return next;
+}
+
+export function appendWhaleFeed(event) {
+  const store = getWhaleStore();
+  const nextEvent = {
+    ...event,
+    createdAt: event.createdAt || new Date(whaleDeps.now()).toISOString(),
+  };
+  store.feed = [...store.feed, nextEvent].slice(-200);
+  saveWhaleStore(store);
+  return nextEvent;
+}
+
+export function getWhaleFeed(limit = 50) {
+  return getWhaleStore().feed.slice(-limit);
+}
+
+export async function getTokenMeta(address, chain, provider) {
+  if (!address || address === ethers.ZeroAddress) {
+    return { address: ethers.ZeroAddress, symbol: chain === 'polygon' ? 'POL' : 'ETH', decimals: 18 };
+  }
+
+  try {
+    const rpc = provider || whaleDeps.providerFactory(chain);
+    const contract = new ethers.Contract(address, TOKEN_ABI, rpc);
+    const [symbol, decimals] = await Promise.all([
+      contract.symbol(),
+      contract.decimals(),
+    ]);
+    return { address, symbol, decimals: Number(decimals) };
+  } catch {
+    return { address, symbol: formatAddress(address), decimals: 18 };
+  }
+}
+
+function formatMirrorAmount(amountRaw, decimals) {
+  return Number(ethers.formatUnits(amountRaw, decimals)).toString();
+}
+
+export async function runMirrorTrade(wallet, swapDetails) {
+  const tracked = getTrackedWallet(wallet.address);
+  if (!tracked?.mirror?.enabled) return null;
+
+  const mirror = tracked.mirror;
+  const tokenIn = swapDetails.tokenInMeta?.symbol || swapDetails.tokenIn;
+  const tokenOut = swapDetails.tokenOutMeta?.symbol || swapDetails.tokenOut;
+
+  if (mirror.maxPerTrade && swapDetails.tokenInMeta?.symbol && STABLE_SYMBOLS.has(swapDetails.tokenInMeta.symbol.toUpperCase())) {
+    const rawAmount = Number(ethers.formatUnits(swapDetails.amountIn, swapDetails.tokenInMeta.decimals));
+    if (rawAmount > mirror.maxPerTrade) {
+      warn(`Mirror cap hit for ${tracked.label || formatAddress(tracked.address)} — ${rawAmount} ${swapDetails.tokenInMeta.symbol} > ${mirror.maxPerTrade}`);
+      return null;
+    }
+  } else if (mirror.maxPerTrade && (!swapDetails.tokenInMeta?.symbol || !STABLE_SYMBOLS.has(swapDetails.tokenInMeta.symbol.toUpperCase()))) {
+    warn(`Skipping mirror trade for ${tracked.label || formatAddress(tracked.address)} — cannot enforce USDC cap on ${tokenIn}`);
+    return null;
+  }
+
+  const payload = {
+    address: tracked.address,
+    chain: tracked.chain,
+    txHash: swapDetails.txHash,
+    tokenIn,
+    tokenOut,
+    amount: formatMirrorAmount(swapDetails.amountIn, swapDetails.tokenInMeta?.decimals || 18),
+    slippage: mirror.slippage,
+    dryRun: mirror.dryRun,
+  };
+
+  if (mirror.dryRun) {
+    info(`Dry-run mirror: ${payload.amount} ${tokenIn} -> ${tokenOut}`);
+    whaleEvents.emit('whale:mirror-executed', { ...payload, executed: false, dryRun: true });
+    return payload;
+  }
+
+  await whaleDeps.executeSwap({
+    tokenIn: swapDetails.tokenIn,
+    tokenOut: swapDetails.tokenOut,
+    amount: payload.amount,
+    slippage: mirror.slippage,
+  });
+  whaleEvents.emit('whale:mirror-executed', { ...payload, executed: true, dryRun: false });
+  return payload;
+}
+
+export function registerWhaleEvent(type, payload) {
+  const event = appendWhaleFeed({ type, ...payload });
+  whaleEvents.emit(type, event);
+  return event;
+}
+
+export function __setWhaleDeps(overrides = {}) {
+  Object.assign(whaleDeps, overrides);
+}
+
+export function __resetWhaleDeps() {
+  whaleDeps.fetch = fetch;
+  whaleDeps.executeSwap = executeSwap;
+  whaleDeps.now = () => Date.now();
+  whaleDeps.providerFactory = (chain) => new ethers.JsonRpcProvider(getRPC(chain));
+}
+
+export function __resetWhaleStore() {
+  setConfig(WHALE_CONFIG_KEY, { tracked: {}, feed: [] });
+}
+
+export {
+  DEFAULT_CHAIN,
+  DEFAULT_POLL_INTERVAL_MS,
+  EXPLORER_APIS,
+  STABLE_SYMBOLS,
+  WHALE_CONFIG_KEY,
+  whaleEvents,
+};

package/src/trading/arb-dexes.js

@@ -0,0 +1,291 @@
+/**
+ * arb-dexes.js — DEX Adapter Registry
+ * Each adapter implements: getQuote(tokenIn, tokenOut, amountIn, chain, provider)
+ * Returns: { amountOut: bigint, fee: number, gasEstimate: bigint }
+ */
+import { ethers } from 'ethers';
+
+// ═══════════════════════════════════════════════════════════════
+// VERIFIED CONTRACT ADDRESSES
+// ═══════════════════════════════════════════════════════════════
+
+export const DEX_ADDRESSES = {
+  uniswapV3: {
+    base: {
+      router:  '0x2626664c2603336E57B271c5C0b26F421741e481', // SwapRouter02
+      quoter:  '0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a', // QuoterV2
+    },
+    ethereum: {
+      router:  '0xE592427A0AEce92De3Edee1F18E0157C05861564', // SwapRouter V1
+      quoter:  '0x61fFE014bA17989E743c5F6cB21bF9697530B21e', // QuoterV2
+    },
+    arbitrum: {
+      router:  '0xE592427A0AEce92De3Edee1F18E0157C05861564',
+      quoter:  '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+    },
+    optimism: {
+      router:  '0xE592427A0AEce92De3Edee1F18E0157C05861564',
+      quoter:  '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+    },
+    polygon: {
+      router:  '0xE592427A0AEce92De3Edee1F18E0157C05861564',
+      quoter:  '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
+    },
+  },
+  aerodrome: {
+    base: {
+      router:  '0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43',
+      factory: '0x420DD381b31aEf6683db6B902084cB0FFECe40Da',
+    },
+  },
+  sushiswap: {
+    base: {
+      router:  '0xFB7eF66a7e61224DD6FcD0D7d9C3Ae5362F52e76', // SushiSwap V3 RouteProcessor3
+      quoter:  '0xb1E835Dc2785b52265711e17fCCb0fd018226a6e', // SushiSwap QuoterV2
+    },
+    ethereum: {
+      router:  '0x2c9E897Ed5A48BbB2da7A4EF68BC9FC1CD12Bb7B',
+      quoter:  '0x64e829B4fE5ef4dF9E74E44c0d1ABb4E7d253E96',
+    },
+    arbitrum: {
+      router:  '0xb590D17D71E7Ff2F332F77fb85Fc45A03D4DAf40',
+      quoter:  '0x0524E833cCD057e4d7A296e3aaAb9f7675964Ce1',
+    },
+  },
+  velodrome: {
+    optimism: {
+      router:  '0xa062aE8A9c5e11aaA026fc2670B0D65cCc8B2858',
+    },
+  },
+  quickswap: {
+    polygon: {
+      router:  '0xf5b509bB0909a69B1c207E495f687a596C168E12', // QuickSwap V3
+      quoter:  '0xa15F0D7377B2A0C0c10db057f641beD21028FC89',
+    },
+  },
+  camelot: {
+    arbitrum: {
+      router:  '0xc873fEcbd354f5A56E00E710B90EF4201db2448d', // Camelot V2 Router
+    },
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════
+// ABIs
+// ═══════════════════════════════════════════════════════════════
+
+const QUOTER_V2_ABI = [
+  'function quoteExactInputSingle(tuple(address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96) params) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+];
+
+const AERODROME_ROUTER_ABI = [
+  'function getAmountsOut(uint256 amountIn, tuple(address from, address to, bool stable, address factory)[] routes) external view returns (uint256[] amounts)',
+];
+
+const VELODROME_ROUTER_ABI = [
+  'function getAmountsOut(uint256 amountIn, tuple(address from, address to, bool stable)[] routes) external view returns (uint256[] amounts)',
+];
+
+const CAMELOT_ROUTER_ABI = [
+  'function getAmountsOut(uint amountIn, address[] path) external view returns (uint[] amounts)',
+];
+
+const QUICKSWAP_QUOTER_ABI = [
+  'function quoteExactInputSingle(address tokenIn, address tokenOut, uint256 amountIn, uint160 limitSqrtPrice) external returns (uint256 amountOut, uint16 fee)',
+];
+
+// ═══════════════════════════════════════════════════════════════
+// ADAPTER IMPLEMENTATIONS
+// ═══════════════════════════════════════════════════════════════
+
+async function getUniswapV3Quote(tokenIn, tokenOut, amountIn, chain, provider, overrideAddrs = {}) {
+  const addrs = (overrideAddrs[chain]?.uniswapV3) || DEX_ADDRESSES.uniswapV3[chain];
+  if (!addrs?.quoter) throw new Error(`No Uniswap V3 quoter for chain: ${chain}`);
+
+  const quoter = new ethers.Contract(addrs.quoter, QUOTER_V2_ABI, provider);
+  const feeTiers = [500, 3000, 10000];
+
+  let bestOut = 0n;
+  let bestFee = 3000;
+  let bestGas = 180000n;
+
+  for (const fee of feeTiers) {
+    try {
+      const result = await quoter.quoteExactInputSingle.staticCall({
+        tokenIn, tokenOut, amountIn, fee, sqrtPriceLimitX96: 0,
+      });
+      if (result[0] > bestOut) {
+        bestOut = result[0];
+        bestFee = fee;
+        bestGas = result[3] || 180000n;
+      }
+    } catch {
+      // fee tier may not have liquidity — skip
+    }
+  }
+
+  if (bestOut === 0n) throw new Error(`No Uniswap V3 liquidity for pair on ${chain}`);
+  return { amountOut: bestOut, fee: bestFee, gasEstimate: bestGas };
+}
+
+async function getAerodromeQuote(tokenIn, tokenOut, amountIn, provider) {
+  const { router, factory } = DEX_ADDRESSES.aerodrome.base;
+  const routerContract = new ethers.Contract(router, AERODROME_ROUTER_ABI, provider);
+
+  let bestOut = 0n;
+
+  for (const stable of [false, true]) {
+    try {
+      const routes = [{ from: tokenIn, to: tokenOut, stable, factory }];
+      const amounts = await routerContract.getAmountsOut(amountIn, routes);
+      const out = amounts[amounts.length - 1];
+      if (out > bestOut) bestOut = out;
+    } catch {
+      // pool may not exist
+    }
+  }
+
+  if (bestOut === 0n) throw new Error('No Aerodrome liquidity for pair');
+  return { amountOut: bestOut, fee: 0, gasEstimate: 200000n };
+}
+
+async function getSushiswapQuote(tokenIn, tokenOut, amountIn, chain, provider) {
+  const addrs = DEX_ADDRESSES.sushiswap[chain];
+  if (!addrs?.quoter) throw new Error(`No SushiSwap quoter for chain: ${chain}`);
+
+  // SushiSwap V3 quoter shares the same interface as Uniswap V3 QuoterV2
+  const quoter = new ethers.Contract(addrs.quoter, QUOTER_V2_ABI, provider);
+  const feeTiers = [500, 3000, 10000];
+
+  let bestOut = 0n;
+  let bestFee = 3000;
+  let bestGas = 180000n;
+
+  for (const fee of feeTiers) {
+    try {
+      const result = await quoter.quoteExactInputSingle.staticCall({
+        tokenIn, tokenOut, amountIn, fee, sqrtPriceLimitX96: 0,
+      });
+      if (result[0] > bestOut) {
+        bestOut = result[0];
+        bestFee = fee;
+        bestGas = result[3] || 180000n;
+      }
+    } catch {}
+  }
+
+  if (bestOut === 0n) throw new Error(`No SushiSwap liquidity for pair on ${chain}`);
+  return { amountOut: bestOut, fee: bestFee, gasEstimate: bestGas };
+}
+
+async function getVelodromeQuote(tokenIn, tokenOut, amountIn, provider) {
+  const { router } = DEX_ADDRESSES.velodrome.optimism;
+  const routerContract = new ethers.Contract(router, VELODROME_ROUTER_ABI, provider);
+
+  let bestOut = 0n;
+
+  for (const stable of [false, true]) {
+    try {
+      const amounts = await routerContract.getAmountsOut(amountIn, [{ from: tokenIn, to: tokenOut, stable }]);
+      const out = amounts[amounts.length - 1];
+      if (out > bestOut) bestOut = out;
+    } catch {}
+  }
+
+  if (bestOut === 0n) throw new Error('No Velodrome liquidity for pair');
+  return { amountOut: bestOut, fee: 0, gasEstimate: 180000n };
+}
+
+async function getQuickswapQuote(tokenIn, tokenOut, amountIn, provider) {
+  const { quoter } = DEX_ADDRESSES.quickswap.polygon;
+  const quoterContract = new ethers.Contract(quoter, QUICKSWAP_QUOTER_ABI, provider);
+
+  try {
+    const result = await quoterContract.quoteExactInputSingle.staticCall(tokenIn, tokenOut, amountIn, 0);
+    return { amountOut: result[0], fee: Number(result[1]), gasEstimate: 200000n };
+  } catch (e) {
+    throw new Error(`No QuickSwap liquidity: ${e.message}`);
+  }
+}
+
+async function getCamelotQuote(tokenIn, tokenOut, amountIn, provider) {
+  const { router } = DEX_ADDRESSES.camelot.arbitrum;
+  const routerContract = new ethers.Contract(router, CAMELOT_ROUTER_ABI, provider);
+
+  try {
+    const amounts = await routerContract.getAmountsOut(amountIn, [tokenIn, tokenOut]);
+    return { amountOut: amounts[1], fee: 0, gasEstimate: 150000n };
+  } catch (e) {
+    throw new Error(`No Camelot liquidity: ${e.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// DEX ADAPTER REGISTRY
+// ═══════════════════════════════════════════════════════════════
+
+export const DEX_ADAPTERS = {
+  uniswapV3: {
+    name: 'Uniswap V3',
+    chains: ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon'],
+    async getQuote(tokenIn, tokenOut, amountIn, chain, provider, opts = {}) {
+      return getUniswapV3Quote(tokenIn, tokenOut, amountIn, chain, provider, opts.overrideAddrs);
+    },
+  },
+  aerodrome: {
+    name: 'Aerodrome',
+    chains: ['base'],
+    async getQuote(tokenIn, tokenOut, amountIn, chain, provider) {
+      if (chain !== 'base') throw new Error('Aerodrome is Base-only');
+      return getAerodromeQuote(tokenIn, tokenOut, amountIn, provider);
+    },
+  },
+  sushiswap: {
+    name: 'SushiSwap V3',
+    chains: ['base', 'ethereum', 'arbitrum'],
+    async getQuote(tokenIn, tokenOut, amountIn, chain, provider) {
+      return getSushiswapQuote(tokenIn, tokenOut, amountIn, chain, provider);
+    },
+  },
+  velodrome: {
+    name: 'Velodrome',
+    chains: ['optimism'],
+    async getQuote(tokenIn, tokenOut, amountIn, chain, provider) {
+      if (chain !== 'optimism') throw new Error('Velodrome is Optimism-only');
+      return getVelodromeQuote(tokenIn, tokenOut, amountIn, provider);
+    },
+  },
+  quickswap: {
+    name: 'QuickSwap V3',
+    chains: ['polygon'],
+    async getQuote(tokenIn, tokenOut, amountIn, chain, provider) {
+      if (chain !== 'polygon') throw new Error('QuickSwap is Polygon-only');
+      return getQuickswapQuote(tokenIn, tokenOut, amountIn, provider);
+    },
+  },
+  camelot: {
+    name: 'Camelot',
+    chains: ['arbitrum'],
+    async getQuote(tokenIn, tokenOut, amountIn, chain, provider) {
+      if (chain !== 'arbitrum') throw new Error('Camelot is Arbitrum-only');
+      return getCamelotQuote(tokenIn, tokenOut, amountIn, provider);
+    },
+  },
+};
+
+/**
+ * Get all enabled adapters for a chain
+ * @param {string} chain
+ * @param {string[]} [enabledKeys] - whitelist of dex keys; null = all
+ * @returns {{ key: string, name: string, getQuote: Function }[]}
+ */
+export function getDexesForChain(chain, enabledKeys = null) {
+  return Object.entries(DEX_ADAPTERS)
+    .filter(([key, adapter]) => {
+      if (enabledKeys && !enabledKeys.includes(key)) return false;
+      return adapter.chains.includes(chain);
+    })
+    .map(([key, adapter]) => ({ key, ...adapter }));
+}
+
+export default DEX_ADAPTERS;