@continuumdao/ctm-mpc-defi 0.2.30 → 0.2.32

package/dist/protocols/evm/aerodrome/index.js

@@ -0,0 +1,3843 @@
+import { zeroAddress, getAddress, encodePacked, parseUnits, formatUnits, encodeFunctionData, defineChain, createPublicClient, http, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/core/expiry.ts
+var DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS = 30 * 60;
+
+// src/protocols/evm/aerodrome/support.ts
+var AERODROME_PROTOCOL_ID = "aerodrome";
+var AERODROME_CHAIN_ID = 8453;
+var AERODROME_NATIVE_PLACEHOLDER = zeroAddress;
+var AERODROME_WETH_BASE = "0x4200000000000000000000000000000000000006";
+var AERODROME_USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+function isAerodromeChainSupported(chainId) {
+  const n = typeof chainId === "number" ? chainId : Number.parseInt(String(chainId), 10);
+  return n === AERODROME_CHAIN_ID;
+}
+function aerodromeOnChainDeadlineUnix(expiryDate) {
+  if (typeof expiryDate === "number" && Number.isFinite(expiryDate) && expiryDate > 0) {
+    return BigInt(Math.floor(expiryDate));
+  }
+  return BigInt(Math.floor(Date.now() / 1e3) + DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS);
+}
+function requireAerodromeRpcUrl(rpcUrl) {
+  const url = (rpcUrl ?? "").trim();
+  if (!url) {
+    throw new Error(
+      "rpcUrl is required. The MCP server injects it from get_chain_registry rpcGateway \u2014 pass chainId 8453 only, do not pass a public RPC URL."
+    );
+  }
+  return url;
+}
+function isAerodromeNativeToken(address) {
+  const t = (address ?? "").trim().toLowerCase();
+  if (!t) return false;
+  if (t === "eth" || t === "native" || t === "native_eth") return true;
+  if (t === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee") return true;
+  try {
+    return getAddress(address) === zeroAddress;
+  } catch {
+    return false;
+  }
+}
+var AERODROME_BASE_ADDRESSES_FALLBACK = {
+  chainId: AERODROME_CHAIN_ID,
+  aero: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+  router: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+  poolFactory: "0x420DD381b31aEf6683db6B902084cB0FFECe40Da",
+  factoryRegistry: "0x5C3F18F06CC09CA1910767A34a20F771039E37C0",
+  voter: "0x16613524e02ad97eDfeF371bC883F2F5d6C480A5",
+  votingEscrow: "0xeBf418Fe2512e7E6bd9b87a8F0f294aCDC67e6B4",
+  rewardsDistributor: "0x227f65131A261548b057215bB1D5Ab2997964C7d",
+  mixedQuoter: "0x0A5aA5D3a4d28014f967Bf0f29EAA3FF9807D5c6",
+  /** MixedRouteQuoterV3 — v2 + all three CL factories (bitmask path encoding). */
+  mixedQuoterV3: "0xCd2A7D98e82D6107eac1828ce8DeAA6acB65b555",
+  nfpm: "0x827922686190790b37229fd06084350E74485b72",
+  /** Oldest Slipstream CL factory (Gauges V1). Path bit 1<<20. */
+  clFactory: "0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A",
+  /** Slipstream CL factory 2 (gauge caps). Raw tickSpacing in MixedQuoterV3. */
+  clFactory2: "0xaDe65c38CD4849aDBA595a4323a8C7DdfE89716a",
+  /** Newest Slipstream CL factory (Gauges V3) — Coinbase B20 stock pools. Path bit 1<<19. */
+  clFactory3: "0xf8f2eB4940CFE7d13603DDDD87f123820Fc061Ef",
+  universalRouter: "0x6Cb442acF35158D5eDa88fe602221b67B400Be3E",
+  swapRouter: "0xBE6D8f0d05cC4be24d5167a3eF062215bE6D18a5",
+  swapRouter2: "0xcbBb8035cAc7D4B3Ca7aBb74cF7BdF900215Ce0D",
+  swapRouter3: "0x698Cb2b6dd822994581fEa6eA4Fc755d1363A92F",
+  pricesOracle: "0xee717411f6E44F9feE011835C8E6FAaC5dEfF166",
+  slipstreamHelper: "0x0AD09A66af0154a84e86F761313d02d0abB6edd5",
+  lpSugar: "0x69dD9db6d8f8E7d83887A704f447b1a584b599A1",
+  sugarSlipstreamHelper: "0x9c62ab10577fB3C20A22E231b7703Ed6D456CC7a",
+  swapper: "0x91616a7B9CF6D23f8C17845581051EBdC4BcB916",
+  weth: AERODROME_WETH_BASE
+};
+var SUGAR_ENV_URL = "https://raw.githubusercontent.com/velodrome-finance/sugar/main/deployments/base.env";
+var SECURITY_MDX_URL = "https://raw.githubusercontent.com/aerodrome-finance/docs/main/content/security.mdx";
+function asAddr(raw) {
+  const s = (raw ?? "").trim();
+  if (!s) return null;
+  try {
+    return getAddress(s.startsWith("0x") ? s : `0x${s}`);
+  } catch {
+    return null;
+  }
+}
+function parseSugarBaseEnv(text) {
+  const out = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const val = trimmed.slice(eq + 1).trim().replace(/^['"]|['"]$/g, "");
+    if (key && val) out[key] = val;
+  }
+  return out;
+}
+function parseSecurityMdxAddresses(text) {
+  const out = {};
+  const re = /([A-Za-z][A-Za-z0-9 /_-]{1,80})\s+((?:0x)[a-fA-F0-9]{40})/g;
+  let m;
+  while (m = re.exec(text)) {
+    const name = (m[1] ?? "").trim().toLowerCase().replace(/\s+/g, "");
+    const addr = m[2];
+    if (name && addr && !out[name]) out[name] = addr;
+  }
+  return out;
+}
+function nthAddr(csv, n) {
+  if (!csv) return null;
+  const part = csv.split(",")[n];
+  return part ? asAddr(part.trim()) : null;
+}
+function firstAddr(csv) {
+  return nthAddr(csv, 0);
+}
+function mergeLoaded(sugar, docs) {
+  const fb = AERODROME_BASE_ADDRESSES_FALLBACK;
+  const pick = (loaded, fallback) => loaded ?? getAddress(fallback);
+  return {
+    chainId: AERODROME_CHAIN_ID,
+    aero: pick(asAddr(docs.aero), fb.aero),
+    router: pick(asAddr(docs.router), fb.router),
+    poolFactory: pick(firstAddr(sugar.V2_FACTORIES_8453) ?? asAddr(docs.poolfactory), fb.poolFactory),
+    factoryRegistry: pick(asAddr(sugar.REGISTRY_8453) ?? asAddr(docs.factoryregistry), fb.factoryRegistry),
+    voter: pick(asAddr(sugar.VOTER_8453) ?? asAddr(docs.voter), fb.voter),
+    votingEscrow: pick(asAddr(docs.votingescrow), fb.votingEscrow),
+    rewardsDistributor: pick(asAddr(sugar.DIST_8453) ?? asAddr(docs.rewardsdistributor), fb.rewardsDistributor),
+    mixedQuoter: pick(asAddr(docs.mixedquoter), fb.mixedQuoter),
+    mixedQuoterV3: pick(asAddr(docs.mixedquoterv3), fb.mixedQuoterV3),
+    nfpm: pick(asAddr(docs.nonfungiblepositionmanager), fb.nfpm),
+    clFactory: pick(firstAddr(sugar.CL_FACTORIES_8453) ?? asAddr(docs.poolfactory), fb.clFactory),
+    clFactory2: pick(nthAddr(sugar.CL_FACTORIES_8453, 1), fb.clFactory2),
+    clFactory3: pick(nthAddr(sugar.CL_FACTORIES_8453, 2), fb.clFactory3),
+    universalRouter: pick(asAddr(docs.universalrouter), fb.universalRouter),
+    swapRouter: pick(asAddr(docs.swaprouter), fb.swapRouter),
+    swapRouter2: pick(asAddr(docs.swaprouter2), fb.swapRouter2),
+    swapRouter3: pick(asAddr(docs.swaprouter3), fb.swapRouter3),
+    pricesOracle: pick(asAddr(docs.pricesoracle), fb.pricesOracle),
+    slipstreamHelper: pick(asAddr(docs.slipstreamhelper), fb.slipstreamHelper),
+    lpSugar: pick(asAddr(sugar.LP_SUGAR_ADDRESS_8453), fb.lpSugar),
+    sugarSlipstreamHelper: pick(asAddr(sugar.SLIPSTREAM_HELPER_8453), fb.sugarSlipstreamHelper),
+    swapper: pick(asAddr(sugar.SWAPPER_8453), fb.swapper),
+    weth: pick(asAddr(AERODROME_WETH_BASE), fb.weth)
+  };
+}
+var cache = null;
+async function fetchText(url) {
+  try {
+    const res = await fetch(url, { cache: "force-cache" });
+    if (!res.ok) return null;
+    return await res.text();
+  } catch {
+    return null;
+  }
+}
+async function loadAerodromeAddresses() {
+  if (!cache) {
+    cache = (async () => {
+      const [sugarText, docsText] = await Promise.all([fetchText(SUGAR_ENV_URL), fetchText(SECURITY_MDX_URL)]);
+      const sugar = sugarText ? parseSugarBaseEnv(sugarText) : {};
+      const docs = docsText ? parseSecurityMdxAddresses(docsText) : {};
+      return mergeLoaded(sugar, docs);
+    })();
+  }
+  return cache;
+}
+function resetAerodromeAddressCache() {
+  cache = null;
+}
+function aerodromeFallbackAddresses() {
+  return mergeLoaded({}, {});
+}
+function aerodromeClFactoryList(addrs) {
+  return [addrs.clFactory, addrs.clFactory2, addrs.clFactory3];
+}
+function aerodromeClSwapRouterForFactory(addrs, factory) {
+  const f = getAddress(factory).toLowerCase();
+  if (f === addrs.clFactory3.toLowerCase()) return addrs.swapRouter3;
+  if (f === addrs.clFactory2.toLowerCase()) return addrs.swapRouter2;
+  return addrs.swapRouter;
+}
+
+// src/protocols/evm/aerodrome/abi.ts
+var lpSugarAbi = [
+  {
+    type: "function",
+    name: "tokens",
+    stateMutability: "view",
+    inputs: [
+      { name: "_limit", type: "uint256" },
+      { name: "_offset", type: "uint256" },
+      { name: "_account", type: "address" },
+      { name: "_addresses", type: "address[]" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        components: [
+          { name: "token_address", type: "address" },
+          { name: "symbol", type: "string" },
+          { name: "decimals", type: "uint8" },
+          { name: "account_balance", type: "uint256" },
+          { name: "listed", type: "bool" },
+          { name: "emerging", type: "bool" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "forSwaps",
+    stateMutability: "view",
+    inputs: [
+      { name: "_limit", type: "uint256" },
+      { name: "_offset", type: "uint256" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        components: [
+          { name: "lp", type: "address" },
+          { name: "type", type: "int24" },
+          { name: "token0", type: "address" },
+          { name: "token1", type: "address" },
+          { name: "factory", type: "address" },
+          { name: "pool_fee", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "all",
+    stateMutability: "view",
+    inputs: [
+      { name: "_limit", type: "uint256" },
+      { name: "_offset", type: "uint256" },
+      { name: "_filter", type: "uint256" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        components: [
+          { name: "lp", type: "address" },
+          { name: "symbol", type: "string" },
+          { name: "decimals", type: "uint8" },
+          { name: "liquidity", type: "uint256" },
+          { name: "type", type: "int24" },
+          { name: "tick", type: "int24" },
+          { name: "sqrt_ratio", type: "uint160" },
+          { name: "token0", type: "address" },
+          { name: "reserve0", type: "uint256" },
+          { name: "staked0", type: "uint256" },
+          { name: "token1", type: "address" },
+          { name: "reserve1", type: "uint256" },
+          { name: "staked1", type: "uint256" },
+          { name: "gauge", type: "address" },
+          { name: "gauge_liquidity", type: "uint256" },
+          { name: "gauge_alive", type: "bool" },
+          { name: "fee", type: "address" },
+          { name: "bribe", type: "address" },
+          { name: "factory", type: "address" },
+          { name: "emissions", type: "uint256" },
+          { name: "emissions_token", type: "address" },
+          { name: "emissions_cap", type: "uint256" },
+          { name: "pool_fee", type: "uint256" },
+          { name: "unstaked_fee", type: "uint256" },
+          { name: "token0_fees", type: "uint256" },
+          { name: "token1_fees", type: "uint256" },
+          { name: "locked", type: "uint256" },
+          { name: "emerging", type: "uint256" },
+          { name: "created_at", type: "uint32" },
+          { name: "nfpm", type: "address" },
+          { name: "alm", type: "address" },
+          { name: "root", type: "address" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "byAddress",
+    stateMutability: "view",
+    inputs: [{ name: "_address", type: "address" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "lp", type: "address" },
+          { name: "symbol", type: "string" },
+          { name: "decimals", type: "uint8" },
+          { name: "liquidity", type: "uint256" },
+          { name: "type", type: "int24" },
+          { name: "tick", type: "int24" },
+          { name: "sqrt_ratio", type: "uint160" },
+          { name: "token0", type: "address" },
+          { name: "reserve0", type: "uint256" },
+          { name: "staked0", type: "uint256" },
+          { name: "token1", type: "address" },
+          { name: "reserve1", type: "uint256" },
+          { name: "staked1", type: "uint256" },
+          { name: "gauge", type: "address" },
+          { name: "gauge_liquidity", type: "uint256" },
+          { name: "gauge_alive", type: "bool" },
+          { name: "fee", type: "address" },
+          { name: "bribe", type: "address" },
+          { name: "factory", type: "address" },
+          { name: "emissions", type: "uint256" },
+          { name: "emissions_token", type: "address" },
+          { name: "emissions_cap", type: "uint256" },
+          { name: "pool_fee", type: "uint256" },
+          { name: "unstaked_fee", type: "uint256" },
+          { name: "token0_fees", type: "uint256" },
+          { name: "token1_fees", type: "uint256" },
+          { name: "locked", type: "uint256" },
+          { name: "emerging", type: "uint256" },
+          { name: "created_at", type: "uint32" },
+          { name: "nfpm", type: "address" },
+          { name: "alm", type: "address" },
+          { name: "root", type: "address" }
+        ]
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "count",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "positions",
+    stateMutability: "view",
+    inputs: [
+      { name: "_limit", type: "uint256" },
+      { name: "_offset", type: "uint256" },
+      { name: "_account", type: "address" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "lp", type: "address" },
+          { name: "liquidity", type: "uint256" },
+          { name: "staked", type: "uint256" },
+          { name: "amount0", type: "uint256" },
+          { name: "amount1", type: "uint256" },
+          { name: "staked0", type: "uint256" },
+          { name: "staked1", type: "uint256" },
+          { name: "unstaked_earned0", type: "uint256" },
+          { name: "unstaked_earned1", type: "uint256" },
+          { name: "emissions_earned", type: "uint256" },
+          { name: "tick_lower", type: "int24" },
+          { name: "tick_upper", type: "int24" },
+          { name: "sqrt_ratio_lower", type: "uint160" },
+          { name: "sqrt_ratio_upper", type: "uint160" },
+          { name: "locker", type: "address" },
+          { name: "unlocks_at", type: "uint32" },
+          { name: "alm", type: "address" }
+        ]
+      }
+    ]
+  }
+];
+var routerAbi = [
+  {
+    type: "function",
+    name: "weth",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "defaultFactory",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "poolFor",
+    stateMutability: "view",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "_factory", type: "address" }
+    ],
+    outputs: [{ name: "pool", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "getAmountsOut",
+    stateMutability: "view",
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      {
+        name: "routes",
+        type: "tuple[]",
+        components: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "stable", type: "bool" },
+          { name: "factory", type: "address" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amounts", type: "uint256[]" }]
+  },
+  {
+    type: "function",
+    name: "quoteAddLiquidity",
+    stateMutability: "view",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "_factory", type: "address" },
+      { name: "amountADesired", type: "uint256" },
+      { name: "amountBDesired", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountA", type: "uint256" },
+      { name: "amountB", type: "uint256" },
+      { name: "liquidity", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "addLiquidity",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "amountADesired", type: "uint256" },
+      { name: "amountBDesired", type: "uint256" },
+      { name: "amountAMin", type: "uint256" },
+      { name: "amountBMin", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountA", type: "uint256" },
+      { name: "amountB", type: "uint256" },
+      { name: "liquidity", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "addLiquidityETH",
+    stateMutability: "payable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "amountTokenDesired", type: "uint256" },
+      { name: "amountTokenMin", type: "uint256" },
+      { name: "amountETHMin", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountToken", type: "uint256" },
+      { name: "amountETH", type: "uint256" },
+      { name: "liquidity", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "removeLiquidity",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "liquidity", type: "uint256" },
+      { name: "amountAMin", type: "uint256" },
+      { name: "amountBMin", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountA", type: "uint256" },
+      { name: "amountB", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "removeLiquidityETH",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "liquidity", type: "uint256" },
+      { name: "amountTokenMin", type: "uint256" },
+      { name: "amountETHMin", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountToken", type: "uint256" },
+      { name: "amountETH", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "swapExactTokensForTokens",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      { name: "amountOutMin", type: "uint256" },
+      {
+        name: "routes",
+        type: "tuple[]",
+        components: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "stable", type: "bool" },
+          { name: "factory", type: "address" }
+        ]
+      },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "amounts", type: "uint256[]" }]
+  },
+  {
+    type: "function",
+    name: "swapExactETHForTokens",
+    stateMutability: "payable",
+    inputs: [
+      { name: "amountOutMin", type: "uint256" },
+      {
+        name: "routes",
+        type: "tuple[]",
+        components: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "stable", type: "bool" },
+          { name: "factory", type: "address" }
+        ]
+      },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "amounts", type: "uint256[]" }]
+  },
+  {
+    type: "function",
+    name: "swapExactTokensForETH",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      { name: "amountOutMin", type: "uint256" },
+      {
+        name: "routes",
+        type: "tuple[]",
+        components: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "stable", type: "bool" },
+          { name: "factory", type: "address" }
+        ]
+      },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "amounts", type: "uint256[]" }]
+  }
+];
+var mixedQuoterAbi = [
+  {
+    type: "function",
+    name: "quoteExactInput",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "path", type: "bytes" },
+      { name: "amountIn", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "v3RouteStartTickSpacing", type: "uint160[]" },
+      { name: "v3RouteStartSqrtPriceX96AfterList", type: "uint160[]" },
+      { name: "v3RouteInitializedTicksCrossedList", type: "uint32[]" },
+      { name: "v3SwapGasEstimate", type: "uint256" }
+    ]
+  }
+];
+var mixedQuoterV3Abi = [
+  {
+    type: "function",
+    name: "quoteExactInput",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "path", type: "bytes" },
+      { name: "amountIn", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "v3SqrtPriceX96AfterList", type: "uint160[]" },
+      { name: "v3InitializedTicksCrossedList", type: "uint32[]" },
+      { name: "v3SwapGasEstimate", type: "uint256" }
+    ]
+  }
+];
+var v2PoolFactoryAbi = [
+  {
+    type: "function",
+    name: "getPool",
+    stateMutability: "view",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" }
+    ],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+var clPoolFactoryAbi = [
+  {
+    type: "function",
+    name: "getPool",
+    stateMutability: "view",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "tickSpacing", type: "int24" }
+    ],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "tickSpacings",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "int24[]" }]
+  }
+];
+var clPoolAbi = [
+  {
+    type: "function",
+    name: "slot0",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "sqrtPriceX96", type: "uint160" },
+      { name: "tick", type: "int24" },
+      { name: "observationIndex", type: "uint16" },
+      { name: "observationCardinality", type: "uint16" },
+      { name: "observationCardinalityNext", type: "uint16" },
+      { name: "unlocked", type: "bool" }
+    ]
+  },
+  {
+    type: "function",
+    name: "liquidity",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint128" }]
+  }
+];
+var sugarHelperAbi = [
+  {
+    type: "function",
+    name: "estimateAmount0",
+    stateMutability: "view",
+    inputs: [
+      { name: "amount1", type: "uint256" },
+      { name: "sqrtRatioX96", type: "uint160" },
+      { name: "sqrtRatioAX96", type: "uint160" },
+      { name: "sqrtRatioBX96", type: "uint160" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "estimateAmount1",
+    stateMutability: "view",
+    inputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "sqrtRatioX96", type: "uint160" },
+      { name: "sqrtRatioAX96", type: "uint160" },
+      { name: "sqrtRatioBX96", type: "uint160" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var nfpmAbi = [
+  {
+    type: "function",
+    name: "mint",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "token0", type: "address" },
+          { name: "token1", type: "address" },
+          { name: "tickSpacing", type: "int24" },
+          { name: "tickLower", type: "int24" },
+          { name: "tickUpper", type: "int24" },
+          { name: "amount0Desired", type: "uint256" },
+          { name: "amount1Desired", type: "uint256" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" },
+          { name: "sqrtPriceX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "liquidity", type: "uint128" },
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "increaseLiquidity",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "amount0Desired", type: "uint256" },
+          { name: "amount1Desired", type: "uint256" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "liquidity", type: "uint128" },
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "decreaseLiquidity",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "liquidity", type: "uint128" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "collect",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "amount0Max", type: "uint128" },
+          { name: "amount1Max", type: "uint128" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "burn",
+    stateMutability: "payable",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var clSwapRouterAbi = [
+  {
+    type: "function",
+    name: "exactInputSingle",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "tickSpacing", type: "int24" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+var poolClaimFeesAbi = [
+  {
+    type: "function",
+    name: "claimFees",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: [
+      { name: "claimed0", type: "uint256" },
+      { name: "claimed1", type: "uint256" }
+    ]
+  }
+];
+var gaugeAbi = [
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "_amount", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "_amount", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "getReward",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "_account", type: "address" }],
+    outputs: []
+  }
+];
+var clGaugeAbi = [
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "getReward",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: []
+  }
+];
+var aerodromePoolMetaAbi = [
+  { type: "function", name: "symbol", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+  { type: "function", name: "token0", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "token1", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "stable", stateMutability: "view", inputs: [], outputs: [{ type: "bool" }] },
+  {
+    type: "function",
+    name: "getReserves",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "_reserve0", type: "uint256" },
+      { name: "_reserve1", type: "uint256" },
+      { name: "_blockTimestampLast", type: "uint256" }
+    ]
+  }
+];
+var aerodromeVoterAbi = [
+  {
+    type: "function",
+    name: "gauges",
+    stateMutability: "view",
+    inputs: [{ name: "pool", type: "address" }],
+    outputs: [{ type: "address" }]
+  }
+];
+var erc20Abi = [
+  { type: "function", name: "name", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
+  { type: "function", name: "decimals", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+  { type: "function", name: "totalSupply", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  }
+];
+function aerodromePublicClient(rpcUrl) {
+  const url = requireAerodromeRpcUrl(rpcUrl);
+  const chain = defineChain({
+    id: AERODROME_CHAIN_ID,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [url] } },
+    contracts: {
+      multicall3: {
+        address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+        blockCreated: 5022
+      }
+    }
+  });
+  return createPublicClient({ chain, transport: http(url) });
+}
+
+// src/protocols/evm/aerodrome/stockTokens.ts
+var AERODROME_COINBASE_STOCK_TOKENS = [
+  { symbol: "AAPLc", name: "Apple Inc.", address: "0xb200000000000000000000C2e324d24d7eEcd1fb" },
+  { symbol: "NVDAc", name: "NVIDIA Corporation", address: "0xb20000000000000000000078ee7ce2fE4908108C" },
+  { symbol: "METAc", name: "Meta Platforms Inc.", address: "0xb2000000000000000000008bC8786B856E61707C" },
+  { symbol: "GOOGLc", name: "Alphabet Inc.", address: "0xb2000000000000000000002D0BA3164cc74f58B7" },
+  { symbol: "AMZNc", name: "Amazon.com Inc.", address: "0xb200000000000000000000d9192b6B456483C2E8" },
+  { symbol: "TSLAc", name: "Tesla Inc.", address: "0xb2000000000000000000001e800a7f5189430cD0" },
+  { symbol: "MSFTc", name: "Microsoft Corporation", address: "0xB200000000000000000000Ab99cFa739E253872B" },
+  { symbol: "COINc", name: "Coinbase Global Inc.", address: "0xb200000000000000000000c85a31389D71F3ecfb" },
+  { symbol: "MSTRc", name: "Strategy Inc.", address: "0xb2000000000000000000004884b426556b92883d" },
+  { symbol: "CRCLc", name: "Circle Internet Group Inc.", address: "0xB20000000000000000000019f6E7C675b73C2e4D" },
+  { symbol: "INTCc", name: "Intel Corporation", address: "0xB2000000000000000000004AFF16039bA04bdFBc" },
+  { symbol: "SNDKc", name: "Sandisk Corporation", address: "0xb200000000000000000000397293Cb8cda9a10c5" },
+  { symbol: "SPCXc", name: "Space Exploration Technologies Corp.", address: "0xb2000000000000000000007b9fcbd005511aCBd5" }
+];
+var AERODROME_COINBASE_STOCK_DECIMALS = 8;
+var AERODROME_B20_ASSET_PREFIX = "0xb200000000000000000000";
+var BASE_STOCKS_DOCS_URLS = [
+  "https://docs.base.org/base-chain/asset-issuance/tokenized-stocks-on-base.md",
+  "https://docs.base.org/base-chain/asset-issuance/tokenized-stocks-on-base"
+];
+function isAerodromeB20AssetToken(address) {
+  try {
+    return getAddress(address).toLowerCase().startsWith(AERODROME_B20_ASSET_PREFIX);
+  } catch {
+    return false;
+  }
+}
+function isAerodromeCoinbaseStockToken(address) {
+  return isAerodromeB20AssetToken(address);
+}
+function looksLikeCoinbaseStockSymbol(symbol) {
+  return /^[A-Za-z][A-Za-z0-9]{0,10}c$/.test((symbol ?? "").trim());
+}
+function lookupAerodromeKnownToken(token) {
+  const key = (token ?? "").trim();
+  if (!key) return null;
+  const lower = key.toLowerCase();
+  if (lower === "weth") {
+    return { address: getAddress(AERODROME_WETH_BASE), symbol: "WETH", decimals: 18 };
+  }
+  if (lower === "usdc") {
+    return { address: getAddress(AERODROME_USDC_BASE), symbol: "USDC", decimals: 6 };
+  }
+  if (lower === "aero") {
+    return { address: getAddress(AERODROME_BASE_ADDRESSES_FALLBACK.aero), symbol: "AERO", decimals: 18 };
+  }
+  const stock = AERODROME_COINBASE_STOCK_TOKENS.find((t) => t.symbol.toLowerCase() === lower);
+  if (stock) {
+    return {
+      address: getAddress(stock.address),
+      symbol: stock.symbol,
+      decimals: AERODROME_COINBASE_STOCK_DECIMALS
+    };
+  }
+  try {
+    const address = getAddress(key);
+    const want = address.toLowerCase();
+    if (want === getAddress(AERODROME_WETH_BASE).toLowerCase()) {
+      return { address, symbol: "WETH", decimals: 18 };
+    }
+    if (want === getAddress(AERODROME_USDC_BASE).toLowerCase()) {
+      return { address, symbol: "USDC", decimals: 6 };
+    }
+    if (want === getAddress(AERODROME_BASE_ADDRESSES_FALLBACK.aero).toLowerCase()) {
+      return { address, symbol: "AERO", decimals: 18 };
+    }
+    const byAddr = AERODROME_COINBASE_STOCK_TOKENS.find((t) => getAddress(t.address).toLowerCase() === want);
+    if (byAddr) {
+      return { address, symbol: byAddr.symbol, decimals: AERODROME_COINBASE_STOCK_DECIMALS };
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveAerodromeErc20OrWeth(token, weth) {
+  const raw = (token ?? "").trim();
+  if (!raw) throw new Error("Token is required.");
+  if (isAerodromeNativeToken(raw)) return getAddress(weth);
+  const known = lookupAerodromeKnownToken(raw);
+  if (known) return known.address;
+  try {
+    return getAddress(raw);
+  } catch {
+    throw new Error(
+      `Unknown Aerodrome token "${raw}". Pass a 0x address or a known ticker (ETH, WETH, USDC, AERO, AAPLc, NVDAc, \u2026). Coinbase B20 stocks are seeded \u2014 do not ask the user for a contract address.`
+    );
+  }
+}
+function aerodromeUnissuedStockMessage(symbolOrAddress) {
+  const label = (symbolOrAddress ?? "").trim() || "This token";
+  return `${label} is listed but not issued yet (zero supply). There is no Aerodrome liquidity to quote.`;
+}
+async function assertAerodromeStockIssued(args) {
+  if (args.isNative || !isAerodromeCoinbaseStockToken(args.token)) return;
+  try {
+    const client = aerodromePublicClient(args.rpcUrl);
+    const supply = await client.readContract({
+      address: args.token,
+      abi: erc20Abi,
+      functionName: "totalSupply"
+    });
+    if (supply === 0n) throw new Error(aerodromeUnissuedStockMessage(args.label));
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("not issued yet")) throw e;
+  }
+}
+function aerodromeCoinbaseStockAddresses() {
+  return AERODROME_COINBASE_STOCK_TOKENS.map((t) => getAddress(t.address));
+}
+var MAX_DOCS_CHARS = 4e5;
+var MAX_OFFICIAL_STOCKS = 40;
+function parseBaseTokenizedStockDocs(text) {
+  try {
+    if (typeof text !== "string" || text.length < 20) return [];
+    const clipped = text.length > MAX_DOCS_CHARS ? text.slice(0, MAX_DOCS_CHARS) : text;
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const patterns = [
+      /\|\s*`?([A-Za-z][A-Za-z0-9]{0,10}c)`?\s*\|\s*`?(0x[bB]200[a-fA-F0-9]{36})`?/g,
+      /([A-Za-z][A-Za-z0-9]{0,10}c)[^0]{0,40}(0x[bB]200[a-fA-F0-9]{36})/g
+    ];
+    for (const re of patterns) {
+      let m;
+      while (m = re.exec(clipped)) {
+        const symbol = (m[1] ?? "").trim();
+        if (!looksLikeCoinbaseStockSymbol(symbol)) continue;
+        let address;
+        try {
+          address = getAddress(m[2] ?? "");
+        } catch {
+          continue;
+        }
+        if (!isAerodromeB20AssetToken(address)) continue;
+        const key = address.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push({ symbol, address });
+        if (out.length > MAX_OFFICIAL_STOCKS) return [];
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function fetchOfficialBaseTokenizedStocks() {
+  for (const url of BASE_STOCKS_DOCS_URLS) {
+    try {
+      const res = await fetch(url, { cache: "no-store", signal: AbortSignal.timeout(8e3) });
+      if (!res.ok) continue;
+      const parsed = parseBaseTokenizedStockDocs(await res.text());
+      if (parsed.length > 0) return parsed;
+    } catch {
+    }
+  }
+  return [];
+}
+function seedName(address) {
+  const want = address.toLowerCase();
+  return AERODROME_COINBASE_STOCK_TOKENS.find((t) => getAddress(t.address).toLowerCase() === want)?.name;
+}
+function seedSymbol(address) {
+  const want = address.toLowerCase();
+  return AERODROME_COINBASE_STOCK_TOKENS.find((t) => getAddress(t.address).toLowerCase() === want)?.symbol;
+}
+function seedStockRows() {
+  return AERODROME_COINBASE_STOCK_TOKENS.map((t) => ({
+    address: getAddress(t.address),
+    symbol: t.symbol,
+    name: t.name,
+    decimals: AERODROME_COINBASE_STOCK_DECIMALS,
+    issued: false
+  }));
+}
+async function aerodromeResolveStockTokens(args) {
+  let official = [];
+  try {
+    official = args.official ?? await fetchOfficialBaseTokenizedStocks();
+  } catch {
+    official = [];
+  }
+  const candidates = /* @__PURE__ */ new Map();
+  const add = (addressRaw, meta) => {
+    if (!isAerodromeB20AssetToken(addressRaw)) return;
+    const address = getAddress(addressRaw);
+    const key = address.toLowerCase();
+    const prev = candidates.get(key);
+    candidates.set(key, {
+      address,
+      symbol: meta?.symbol || prev?.symbol,
+      name: meta?.name || prev?.name,
+      decimals: meta?.decimals ?? prev?.decimals
+    });
+  };
+  for (const t of AERODROME_COINBASE_STOCK_TOKENS) {
+    add(t.address, { symbol: t.symbol, name: t.name, decimals: AERODROME_COINBASE_STOCK_DECIMALS });
+  }
+  for (const t of official) {
+    add(t.address, { symbol: t.symbol, decimals: AERODROME_COINBASE_STOCK_DECIMALS });
+  }
+  for (const t of args.knownTokens ?? []) {
+    if (!isAerodromeB20AssetToken(t.address)) continue;
+    const symbol = (t.symbol ?? "").trim();
+    const seeded = Boolean(seedSymbol(getAddress(t.address)));
+    if (!seeded && symbol && !looksLikeCoinbaseStockSymbol(symbol)) continue;
+    add(t.address, { symbol, decimals: t.decimals });
+  }
+  const rows = [...candidates.values()];
+  if (rows.length === 0) return seedStockRows();
+  try {
+    const client = aerodromePublicClient(args.rpcUrl);
+    const meta = await client.multicall({
+      allowFailure: true,
+      contracts: rows.flatMap((row) => [
+        { address: row.address, abi: erc20Abi, functionName: "symbol" },
+        { address: row.address, abi: erc20Abi, functionName: "name" },
+        { address: row.address, abi: erc20Abi, functionName: "decimals" },
+        { address: row.address, abi: erc20Abi, functionName: "totalSupply" }
+      ])
+    });
+    return rows.map((row, i) => {
+      const base = i * 4;
+      const onchainSymbol = meta[base]?.status === "success" ? String(meta[base].result) : "";
+      const onchainName = meta[base + 1]?.status === "success" ? String(meta[base + 1].result) : "";
+      const onchainDecimals = meta[base + 2]?.status === "success" ? Number(meta[base + 2].result) : NaN;
+      const supply = meta[base + 3]?.status === "success" ? meta[base + 3].result : 0n;
+      return {
+        address: row.address,
+        symbol: onchainSymbol || row.symbol || seedSymbol(row.address) || row.address.slice(0, 8),
+        name: seedName(row.address) || onchainName || onchainSymbol || row.symbol || "",
+        decimals: Number.isFinite(onchainDecimals) ? onchainDecimals : row.decimals ?? AERODROME_COINBASE_STOCK_DECIMALS,
+        issued: supply > 0n
+      };
+    });
+  } catch {
+    return seedStockRows();
+  }
+}
+var FALLBACK_TICK_SPACINGS = [1, 10, 50, 100, 200, 500, 2e3];
+function checksum(addr) {
+  return getAddress(addr);
+}
+function pairKey(a, b) {
+  const [x, y] = [a.toLowerCase(), b.toLowerCase()].sort();
+  return `${x}-${y}`;
+}
+function connectorPairs(tokenIn, tokenOut, connectors) {
+  const pairs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (a, b) => {
+    if (a.toLowerCase() === b.toLowerCase()) return;
+    const key = pairKey(a, b);
+    if (seen.has(key)) return;
+    seen.add(key);
+    pairs.push([a, b]);
+  };
+  add(tokenIn, tokenOut);
+  for (const c of connectors) {
+    add(tokenIn, c);
+    add(tokenOut, c);
+  }
+  const weth = connectors[0];
+  const usdc = connectors[1];
+  if (weth && usdc) add(weth, usdc);
+  return pairs;
+}
+async function tickSpacingsForFactory(rpcUrl, factory) {
+  const client = aerodromePublicClient(rpcUrl);
+  try {
+    const rows = await client.readContract({
+      address: factory,
+      abi: clPoolFactoryAbi,
+      functionName: "tickSpacings"
+    });
+    const nums = rows.map((n) => Number(n)).filter((n) => Number.isFinite(n) && n > 0);
+    return nums.length > 0 ? nums : [...FALLBACK_TICK_SPACINGS];
+  } catch {
+    return [...FALLBACK_TICK_SPACINGS];
+  }
+}
+async function aerodromeDiscoverConnectorPools(args) {
+  const client = aerodromePublicClient(args.rpcUrl);
+  const connectors = [args.addrs.weth, getAddress(AERODROME_USDC_BASE), args.addrs.aero];
+  const pairs = connectorPairs(args.tokenIn, args.tokenOut, connectors);
+  const clFactories = aerodromeClFactoryList(args.addrs);
+  const spacingsByFactory = await Promise.all(
+    clFactories.map(async (factory) => ({ factory, spacings: await tickSpacingsForFactory(args.rpcUrl, factory) }))
+  );
+  const jobs = [];
+  for (const [tokenA, tokenB] of pairs) {
+    jobs.push({ kind: "v2", tokenA, tokenB, stable: false });
+    jobs.push({ kind: "v2", tokenA, tokenB, stable: true });
+    for (const { factory, spacings } of spacingsByFactory) {
+      for (const spacing of spacings) {
+        jobs.push({ kind: "cl", factory, tokenA, tokenB, spacing });
+      }
+    }
+  }
+  const results = await client.multicall({
+    allowFailure: true,
+    contracts: jobs.map(
+      (job) => job.kind === "v2" ? {
+        address: args.addrs.poolFactory,
+        abi: v2PoolFactoryAbi,
+        functionName: "getPool",
+        args: [job.tokenA, job.tokenB, job.stable]
+      } : {
+        address: job.factory,
+        abi: clPoolFactoryAbi,
+        functionName: "getPool",
+        args: [job.tokenA, job.tokenB, job.spacing]
+      }
+    )
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const pools = [];
+  for (let i = 0; i < jobs.length; i++) {
+    const job = jobs[i];
+    const row = results[i];
+    if (!row || row.status !== "success") continue;
+    const lp = row.result;
+    if (!lp || lp === zeroAddress) continue;
+    const key = lp.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const token0 = job.tokenA.toLowerCase() < job.tokenB.toLowerCase() ? job.tokenA : job.tokenB;
+    const token1 = token0.toLowerCase() === job.tokenA.toLowerCase() ? job.tokenB : job.tokenA;
+    if (job.kind === "v2") {
+      pools.push({
+        lp: checksum(lp),
+        type: job.stable ? 0 : -1,
+        token0: checksum(token0),
+        token1: checksum(token1),
+        factory: args.addrs.poolFactory,
+        poolFee: "0",
+        kind: job.stable ? "stable" : "volatile"
+      });
+    } else {
+      pools.push({
+        lp: checksum(lp),
+        type: job.spacing,
+        token0: checksum(token0),
+        token1: checksum(token1),
+        factory: checksum(job.factory),
+        poolFee: "0",
+        kind: "cl"
+      });
+    }
+  }
+  return pools;
+}
+async function aerodromeDiscoverConnectorPoolsLoaded(args) {
+  const addrs = await loadAerodromeAddresses();
+  return aerodromeDiscoverConnectorPools({ ...args, addrs });
+}
+async function aerodromeDiscoverDirectPools(args) {
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const tokenA = checksum(args.tokenA);
+  const tokenB = checksum(args.tokenB);
+  const clFactories = aerodromeClFactoryList(addrs);
+  const spacingsByFactory = await Promise.all(
+    clFactories.map(async (factory) => ({ factory, spacings: await tickSpacingsForFactory(args.rpcUrl, factory) }))
+  );
+  const jobs = [
+    { kind: "v2", stable: false },
+    { kind: "v2", stable: true }
+  ];
+  for (const { factory, spacings } of spacingsByFactory) {
+    for (const spacing of spacings) jobs.push({ kind: "cl", factory, spacing });
+  }
+  const results = await client.multicall({
+    allowFailure: true,
+    contracts: jobs.map(
+      (job) => job.kind === "v2" ? {
+        address: addrs.poolFactory,
+        abi: v2PoolFactoryAbi,
+        functionName: "getPool",
+        args: [tokenA, tokenB, job.stable]
+      } : {
+        address: job.factory,
+        abi: clPoolFactoryAbi,
+        functionName: "getPool",
+        args: [tokenA, tokenB, job.spacing]
+      }
+    )
+  });
+  const token0 = tokenA.toLowerCase() < tokenB.toLowerCase() ? tokenA : tokenB;
+  const token1 = token0.toLowerCase() === tokenA.toLowerCase() ? tokenB : tokenA;
+  const seen = /* @__PURE__ */ new Set();
+  const pools = [];
+  for (let i = 0; i < jobs.length; i++) {
+    const job = jobs[i];
+    const row = results[i];
+    if (!row || row.status !== "success") continue;
+    const lp = row.result;
+    if (!lp || lp === zeroAddress) continue;
+    const key = lp.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (job.kind === "v2") {
+      pools.push({
+        lp: checksum(lp),
+        type: job.stable ? 0 : -1,
+        token0,
+        token1,
+        factory: addrs.poolFactory,
+        poolFee: "0",
+        kind: job.stable ? "stable" : "volatile"
+      });
+    } else {
+      pools.push({
+        lp: checksum(lp),
+        type: job.spacing,
+        token0,
+        token1,
+        factory: checksum(job.factory),
+        poolFee: "0",
+        kind: "cl"
+      });
+    }
+  }
+  return pools;
+}
+function tokenLabel(raw, resolved, isNative) {
+  if (isNative) return "ETH";
+  return lookupAerodromeKnownToken(raw)?.symbol || lookupAerodromeKnownToken(resolved)?.symbol || resolved.slice(0, 8);
+}
+async function aerodromeDiscoverPoolsSummary(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const rpcUrl = requireAerodromeRpcUrl(args.rpcUrl);
+  const addrs = await loadAerodromeAddresses();
+  const isNative = isAerodromeNativeToken(args.token);
+  const token = resolveAerodromeErc20OrWeth(args.token, addrs.weth);
+  await assertAerodromeStockIssued({ rpcUrl, token, isNative, label: args.token });
+  const counterpartRaw = (args.tokenOut ?? "").trim() || "USDC";
+  const isNativeOut = isAerodromeNativeToken(counterpartRaw);
+  const tokenOut = resolveAerodromeErc20OrWeth(counterpartRaw, addrs.weth);
+  await assertAerodromeStockIssued({ rpcUrl, token: tokenOut, isNative: isNativeOut, label: counterpartRaw });
+  if (token.toLowerCase() === tokenOut.toLowerCase()) {
+    throw new Error("token and tokenOut must differ (default tokenOut is USDC).");
+  }
+  const pools = await aerodromeDiscoverConnectorPools({ rpcUrl, tokenIn: token, tokenOut, addrs });
+  const inLabel = tokenLabel(args.token, token, isNative);
+  const outLabel = tokenLabel(counterpartRaw, tokenOut, isNativeOut);
+  return {
+    chainId: AERODROME_CHAIN_ID,
+    token: {
+      address: isNative ? zeroAddress : token,
+      symbol: inLabel,
+      decimals: lookupAerodromeKnownToken(args.token)?.decimals ?? lookupAerodromeKnownToken(token)?.decimals ?? null
+    },
+    tokenOut: {
+      address: isNativeOut ? zeroAddress : tokenOut,
+      symbol: outLabel,
+      decimals: lookupAerodromeKnownToken(counterpartRaw)?.decimals ?? lookupAerodromeKnownToken(tokenOut)?.decimals ?? null
+    },
+    pools: pools.map((p) => ({
+      lp: p.lp,
+      kind: p.kind,
+      tickSpacing: p.kind === "cl" ? p.type : void 0,
+      token0: p.token0,
+      token1: p.token1,
+      factory: p.factory
+    })),
+    notes: pools.length === 0 ? `No factory pool on the ${inLabel}/${outLabel} connector graph (direct + WETH/USDC/AERO hops). B20 stocks LP vs USDC; ETH\u2192stock quotes hop WETH\u2192USDC\u2192stock. Call ctm_aerodrome_quote with tickers for a price.` : `Factory-discovered pools on the ${inLabel}/${outLabel} connector graph (v2 + Slipstream 1/2/3). Not a Sugar dump. Call ctm_aerodrome_quote({ tokenIn: "${inLabel}", tokenOut: "${outLabel}", amountHuman }) for a price.`
+  };
+}
+function poolKind(type) {
+  if (type === 0) return "stable";
+  if (type === -1) return "volatile";
+  return "cl";
+}
+async function paginate(pageSize, maxPages, readPage) {
+  const out = [];
+  for (let page = 0; page < maxPages; page++) {
+    const rows = await readPage(BigInt(pageSize), BigInt(page * pageSize));
+    out.push(...rows);
+    if (rows.length < pageSize) break;
+  }
+  return out;
+}
+async function aerodromeFetchListedTokens(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const account = args.account?.trim() ? getAddress(args.account) : zeroAddress;
+  const extra = [...aerodromeCoinbaseStockAddresses(), ...args.extraAddresses ?? []].map((a) => {
+    try {
+      return getAddress(a);
+    } catch {
+      return null;
+    }
+  }).filter((a) => Boolean(a));
+  const rows = await paginate(
+    200,
+    15,
+    (limit, offset) => client.readContract({
+      address: addrs.lpSugar,
+      abi: lpSugarAbi,
+      functionName: "tokens",
+      args: [limit, offset, account, extra]
+    })
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const tokens = [];
+  for (const t of rows) {
+    const address = getAddress(t.token_address);
+    const key = address.toLowerCase();
+    if (seen.has(key) || address === zeroAddress) continue;
+    seen.add(key);
+    tokens.push({
+      address,
+      symbol: t.symbol,
+      decimals: Number(t.decimals),
+      listed: Boolean(t.listed),
+      emerging: Boolean(t.emerging),
+      accountBalance: t.account_balance.toString()
+    });
+  }
+  return tokens;
+}
+async function aerodromeFetchSwapPools(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const rows = await paginate(
+    200,
+    20,
+    (limit, offset) => client.readContract({
+      address: addrs.lpSugar,
+      abi: lpSugarAbi,
+      functionName: "forSwaps",
+      args: [limit, offset]
+    })
+  );
+  return rows.map((p) => ({
+    lp: getAddress(p.lp),
+    type: Number(p.type),
+    token0: getAddress(p.token0),
+    token1: getAddress(p.token1),
+    factory: getAddress(p.factory),
+    poolFee: p.pool_fee.toString(),
+    kind: poolKind(Number(p.type))
+  }));
+}
+async function aerodromeFetchPools(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const limit = BigInt(args.limit ?? 50);
+  const offset = BigInt(args.offset ?? 0);
+  const rows = await client.readContract({
+    address: addrs.lpSugar,
+    abi: lpSugarAbi,
+    functionName: "all",
+    args: [limit, offset, 0n]
+  });
+  return rows.map(mapSugarLp);
+}
+function mapSugarLp(p) {
+  return {
+    lp: getAddress(p.lp),
+    symbol: p.symbol,
+    type: Number(p.type),
+    kind: poolKind(Number(p.type)),
+    token0: getAddress(p.token0),
+    token1: getAddress(p.token1),
+    gauge: getAddress(p.gauge),
+    gaugeAlive: Boolean(p.gauge_alive),
+    nfpm: getAddress(p.nfpm),
+    reserve0: p.reserve0.toString(),
+    reserve1: p.reserve1.toString()
+  };
+}
+async function aerodromeFetchPoolsByAddress(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of args.lps) {
+    try {
+      const lp = getAddress(raw);
+      const key = lp.toLowerCase();
+      if (lp === zeroAddress || seen.has(key)) continue;
+      seen.add(key);
+      unique.push(lp);
+    } catch {
+    }
+  }
+  const out = /* @__PURE__ */ new Map();
+  if (unique.length === 0) return out;
+  const contracts = unique.flatMap((lp) => [
+    { address: lp, abi: aerodromePoolMetaAbi, functionName: "symbol" },
+    { address: lp, abi: aerodromePoolMetaAbi, functionName: "token0" },
+    { address: lp, abi: aerodromePoolMetaAbi, functionName: "token1" },
+    { address: lp, abi: aerodromePoolMetaAbi, functionName: "stable" },
+    { address: addrs.voter, abi: aerodromeVoterAbi, functionName: "gauges", args: [lp] }
+  ]);
+  const results = await client.multicall({ allowFailure: true, contracts });
+  const tokenAddrs = /* @__PURE__ */ new Set();
+  const rawRows = [];
+  for (let i = 0; i < unique.length; i++) {
+    const base = i * 5;
+    const symbolRow = results[base];
+    const token0Row = results[base + 1];
+    const token1Row = results[base + 2];
+    const stableRow = results[base + 3];
+    const gaugeRow = results[base + 4];
+    if (token0Row?.status !== "success" || token1Row?.status !== "success") continue;
+    if (typeof token0Row.result !== "string" || typeof token1Row.result !== "string") continue;
+    const token0 = getAddress(token0Row.result);
+    const token1 = getAddress(token1Row.result);
+    tokenAddrs.add(token0.toLowerCase());
+    tokenAddrs.add(token1.toLowerCase());
+    const stable = stableRow?.status === "success" ? Boolean(stableRow.result) : null;
+    rawRows.push({
+      lp: unique[i],
+      symbol: symbolRow?.status === "success" ? String(symbolRow.result || "") : "",
+      token0,
+      token1,
+      kind: stable == null ? "cl" : stable ? "stable" : "volatile",
+      gauge: gaugeRow?.status === "success" && typeof gaugeRow.result === "string" ? getAddress(gaugeRow.result) : zeroAddress
+    });
+  }
+  const tokens = [...tokenAddrs].map((a) => getAddress(a));
+  const tokenSymbols = /* @__PURE__ */ new Map();
+  if (tokens.length > 0) {
+    const syms = await client.multicall({
+      allowFailure: true,
+      contracts: tokens.map((token) => ({
+        address: token,
+        abi: erc20Abi,
+        functionName: "symbol"
+      }))
+    });
+    for (let i = 0; i < tokens.length; i++) {
+      const row = syms[i];
+      if (row?.status === "success" && row.result) tokenSymbols.set(tokens[i].toLowerCase(), String(row.result));
+    }
+  }
+  for (const row of rawRows) {
+    const kindTag = row.kind === "stable" ? "sAMM" : row.kind === "cl" ? "CL" : "vAMM";
+    const s0 = tokenSymbols.get(row.token0.toLowerCase()) || "";
+    const s1 = tokenSymbols.get(row.token1.toLowerCase()) || "";
+    const pair = s0 && s1 ? `${kindTag}-${s0}/${s1}` : "";
+    out.set(row.lp.toLowerCase(), {
+      lp: row.lp,
+      symbol: row.symbol.trim() || pair,
+      type: row.kind === "stable" ? 0 : row.kind === "volatile" ? -1 : 100,
+      kind: row.kind,
+      token0: row.token0,
+      token1: row.token1,
+      gauge: row.gauge,
+      gaugeAlive: row.gauge !== zeroAddress,
+      nfpm: zeroAddress,
+      reserve0: "0",
+      reserve1: "0"
+    });
+  }
+  return out;
+}
+async function aerodromeFetchPositions(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const account = getAddress(args.account);
+  const rows = await paginate(
+    50,
+    8,
+    (limit, offset) => client.readContract({
+      address: addrs.lpSugar,
+      abi: lpSugarAbi,
+      functionName: "positions",
+      args: [limit, offset, account]
+    })
+  );
+  return rows.map((p) => ({
+    id: p.id.toString(),
+    lp: getAddress(p.lp),
+    liquidity: p.liquidity.toString(),
+    staked: p.staked.toString(),
+    amount0: p.amount0.toString(),
+    amount1: p.amount1.toString(),
+    unstakedEarned0: p.unstaked_earned0.toString(),
+    unstakedEarned1: p.unstaked_earned1.toString(),
+    emissionsEarned: p.emissions_earned.toString(),
+    tickLower: Number(p.tick_lower),
+    tickUpper: Number(p.tick_upper)
+  }));
+}
+async function aerodromeFetchPositionsWithPools(args) {
+  const positions = await aerodromeFetchPositions(args);
+  const pools = await aerodromeFetchPoolsByAddress({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    lps: positions.map((p) => p.lp)
+  });
+  return positions.map((p) => {
+    const pool = pools.get(p.lp.toLowerCase());
+    const cl = pool?.kind === "cl" || p.id !== "0" || p.tickLower !== p.tickUpper;
+    return {
+      ...p,
+      symbol: pool?.symbol ?? "",
+      kind: pool?.kind ?? (cl ? "cl" : "volatile"),
+      gauge: pool?.gauge ?? zeroAddress,
+      gaugeAlive: pool?.gaugeAlive ?? false,
+      token0: pool?.token0 ?? zeroAddress,
+      token1: pool?.token1 ?? zeroAddress
+    };
+  }).filter(isMeaningfulAerodromePosition);
+}
+function isMeaningfulAerodromePosition(p) {
+  if (p.kind === "cl" || p.id !== "0") return true;
+  if (BigInt(p.staked || "0") > 0n) return true;
+  if (BigInt(p.emissionsEarned || "0") > 0n) return true;
+  return BigInt(p.liquidity || "0") >= 10n ** 12n;
+}
+
+// src/protocols/evm/aerodrome/priceImpact.ts
+function aerodromeProbeAmountIn(amountIn) {
+  if (amountIn <= 1n) return null;
+  let probe = amountIn / 10000n;
+  if (probe < 1n) probe = 1n;
+  if (probe >= amountIn) return null;
+  return probe;
+}
+function computeAerodromePriceImpactPercent(args) {
+  const { amountIn, amountOut, probeIn, probeOut } = args;
+  if (amountIn <= 0n || amountOut <= 0n || probeIn <= 0n || probeOut <= 0n) return null;
+  const executed = amountOut * probeIn;
+  const spot = amountIn * probeOut;
+  if (spot === 0n) return null;
+  if (executed >= spot) return 0;
+  const scale = 100000000n;
+  const scaled = (spot - executed) * scale * 100n / spot;
+  const pct = Number(scaled) / Number(scale);
+  if (!Number.isFinite(pct)) return null;
+  return Math.max(0, pct);
+}
+function formatAerodromePriceImpact(percent0to100) {
+  if (percent0to100 == null || !Number.isFinite(percent0to100) || percent0to100 < 0) return "\u2014";
+  if (percent0to100 === 0) return "0%";
+  if (percent0to100 < 1e-4) return "<0.0001%";
+  const t = percent0to100 < 0.01 ? percent0to100.toFixed(4) : percent0to100 < 1 ? percent0to100.toFixed(3) : percent0to100 < 10 ? percent0to100.toFixed(2) : percent0to100.toFixed(1);
+  return `${t.replace(/(\.\d*?[1-9])0+$/g, "$1").replace(/\.0$/, "")}%`;
+}
+
+// src/protocols/evm/aerodrome/sdkSession.ts
+async function loadSdkJs() {
+  try {
+    return await import('@dromos-labs/sdk.js');
+  } catch {
+    return null;
+  }
+}
+async function tryAerodromeSdkQuote(args) {
+  const sdk = await loadSdkJs();
+  if (!sdk?.getDefaultConfig || !sdk.getQuoteForSwap || !sdk.base) return null;
+  try {
+    const config = sdk.getDefaultConfig({
+      chains: [{ chain: sdk.base, rpcUrl: args.rpcUrl }]
+    });
+    const quote = await sdk.getQuoteForSwap({
+      config,
+      fromToken: { address: args.tokenIn, chainId: AERODROME_CHAIN_ID },
+      toToken: { address: args.tokenOut, chainId: AERODROME_CHAIN_ID },
+      amountIn: args.amountIn
+    });
+    if (!quote) return null;
+    const out = quote.amountOut ?? quote.expectedAmount;
+    if (out == null || out <= 0n) return null;
+    let priceImpactPercent = null;
+    const probeIn = aerodromeProbeAmountIn(args.amountIn);
+    if (probeIn != null) {
+      try {
+        const probeQuote = await sdk.getQuoteForSwap({
+          config,
+          fromToken: { address: args.tokenIn, chainId: AERODROME_CHAIN_ID },
+          toToken: { address: args.tokenOut, chainId: AERODROME_CHAIN_ID },
+          amountIn: probeIn
+        });
+        const probeOut = probeQuote?.amountOut ?? probeQuote?.expectedAmount;
+        if (probeOut != null && probeOut > 0n) {
+          priceImpactPercent = computeAerodromePriceImpactPercent({
+            amountIn: args.amountIn,
+            amountOut: out,
+            probeIn,
+            probeOut
+          });
+        }
+      } catch {
+        priceImpactPercent = null;
+      }
+    }
+    return {
+      chainId: AERODROME_CHAIN_ID,
+      tokenIn: args.isNativeIn ? zeroAddress : args.tokenIn,
+      tokenOut: args.isNativeOut ? zeroAddress : args.tokenOut,
+      amountInWei: args.amountIn.toString(),
+      amountOutWei: out.toString(),
+      amountOutHuman: null,
+      priceImpactPercent,
+      hops: [],
+      pathPacked: null,
+      isNativeIn: args.isNativeIn,
+      isNativeOut: args.isNativeOut,
+      source: "sdk.js"
+    };
+  } catch {
+    return null;
+  }
+}
+async function tryAerodromeSdkUnsignedSwap(args) {
+  const sdk = await loadSdkJs();
+  if (!sdk?.getDefaultConfig || !sdk.swap || !sdk.base) return null;
+  try {
+    const config = sdk.getDefaultConfig({
+      chains: [{ chain: sdk.base, rpcUrl: args.rpcUrl }]
+    });
+    const tx = await sdk.swap({
+      config,
+      quote: args.quote,
+      account: args.account,
+      slippage: args.slippage,
+      unsignedTransactionOnly: true
+    });
+    if (!tx?.to || !tx.data) return null;
+    return {
+      to: getAddress(tx.to),
+      data: tx.data.startsWith("0x") ? tx.data : `0x${tx.data}`,
+      value: typeof tx.value === "bigint" ? tx.value : BigInt(tx.value ?? 0)
+    };
+  } catch {
+    return null;
+  }
+}
+var AERODROME_STABLE_FILLER = 2097152;
+var AERODROME_VOLATILE_FILLER = 4194304;
+var AERODROME_CL_FACTORY_OLDEST_BIT = 1048576;
+var AERODROME_CL_FACTORY_NEWEST_BIT = 524288;
+function aerodromeMixedPathFiller(hop) {
+  if (hop.kind === "stable") return AERODROME_STABLE_FILLER;
+  if (hop.kind === "volatile") return AERODROME_VOLATILE_FILLER;
+  const f = hop.factory.toLowerCase();
+  if (f === AERODROME_BASE_ADDRESSES_FALLBACK.clFactory3.toLowerCase()) {
+    return hop.type | AERODROME_CL_FACTORY_NEWEST_BIT;
+  }
+  if (f === AERODROME_BASE_ADDRESSES_FALLBACK.clFactory.toLowerCase()) {
+    return hop.type | AERODROME_CL_FACTORY_OLDEST_BIT;
+  }
+  return hop.type;
+}
+function encodeAerodromeMixedPath(hops) {
+  if (hops.length === 0) throw new Error("Aerodrome path requires at least one hop.");
+  const types = ["address"];
+  const values = [hops[0].from];
+  for (const hop of hops) {
+    types.push("int24", "address");
+    values.push(aerodromeMixedPathFiller(hop), hop.to);
+  }
+  return encodePacked(types, values);
+}
+function neighbors(pools, token) {
+  const t = token.toLowerCase();
+  return pools.filter(
+    (p) => p.token0.toLowerCase() === t || p.token1.toLowerCase() === t
+  );
+}
+function hopFromPool(pool, from) {
+  const fromL = from.toLowerCase();
+  const to = pool.token0.toLowerCase() === fromL ? pool.token1 : pool.token0;
+  return {
+    from: getAddress(from),
+    to: getAddress(to),
+    stable: pool.kind === "stable",
+    factory: pool.factory,
+    type: pool.type,
+    kind: pool.kind,
+    lp: pool.lp
+  };
+}
+function findAerodromePaths(pools, tokenIn, tokenOut, maxDepth = 3) {
+  const goal = tokenOut.toLowerCase();
+  const start = getAddress(tokenIn);
+  const out = [];
+  const walk = (current, path, usedLp) => {
+    if (path.length >= maxDepth) return;
+    for (const pool of neighbors(pools, current)) {
+      const lpKey = pool.lp.toLowerCase();
+      if (usedLp.has(lpKey)) continue;
+      const hop = hopFromPool(pool, current);
+      const nextPath = [...path, hop];
+      if (hop.to.toLowerCase() === goal) {
+        out.push(nextPath);
+        continue;
+      }
+      usedLp.add(lpKey);
+      walk(hop.to, nextPath, usedLp);
+      usedLp.delete(lpKey);
+    }
+  };
+  walk(start, [], /* @__PURE__ */ new Set());
+  return out.slice(0, 40);
+}
+function mergePools(into, extra) {
+  const seen = new Set(into.map((p) => p.lp.toLowerCase()));
+  const out = [...into];
+  for (const p of extra) {
+    const key = p.lp.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(p);
+  }
+  return out;
+}
+async function quoteViaRouter(rpcUrl, router, amountIn, hops) {
+  if (hops.some((h) => h.kind === "cl")) return null;
+  const client = aerodromePublicClient(rpcUrl);
+  try {
+    const amounts = await client.readContract({
+      address: router,
+      abi: routerAbi,
+      functionName: "getAmountsOut",
+      args: [
+        amountIn,
+        hops.map((h) => ({ from: h.from, to: h.to, stable: h.stable, factory: h.factory }))
+      ]
+    });
+    const last = amounts[amounts.length - 1];
+    return last ?? null;
+  } catch {
+    return null;
+  }
+}
+async function quoteViaMixedQuoter(rpcUrl, quoter, amountIn, hops, abi) {
+  const client = aerodromePublicClient(rpcUrl);
+  const path = encodeAerodromeMixedPath(hops);
+  try {
+    const res = await client.simulateContract({
+      address: quoter,
+      abi,
+      functionName: "quoteExactInput",
+      args: [path, amountIn]
+    });
+    return res.result[0];
+  } catch {
+    return null;
+  }
+}
+async function quoteAerodromeHopsAmountOut(args) {
+  const viaRouter = await quoteViaRouter(args.rpcUrl, args.router, args.amountIn, args.hops);
+  if (viaRouter != null && viaRouter > 0n) return { out: viaRouter, source: "router" };
+  const viaV3 = await quoteViaMixedQuoter(
+    args.rpcUrl,
+    args.mixedQuoterV3,
+    args.amountIn,
+    args.hops,
+    mixedQuoterV3Abi
+  );
+  if (viaV3 != null && viaV3 > 0n) return { out: viaV3, source: "mixed_quoter" };
+  const viaV1 = await quoteViaMixedQuoter(
+    args.rpcUrl,
+    args.mixedQuoter,
+    args.amountIn,
+    args.hops,
+    mixedQuoterAbi
+  );
+  if (viaV1 != null && viaV1 > 0n) return { out: viaV1, source: "mixed_quoter" };
+  return null;
+}
+async function readTokenDecimals(rpcUrl, token, isNative) {
+  if (isNative) return 18;
+  if (isAerodromeCoinbaseStockToken(token)) return AERODROME_COINBASE_STOCK_DECIMALS;
+  if (token.toLowerCase() === AERODROME_USDC_BASE.toLowerCase()) return 6;
+  const client = aerodromePublicClient(rpcUrl);
+  return Number(
+    await client.readContract({
+      address: token,
+      abi: erc20Abi,
+      functionName: "decimals"
+    })
+  );
+}
+async function throwIfUnissuedStock(args) {
+  await assertAerodromeStockIssued(args);
+}
+async function aerodromeQuote(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const rpcUrl = requireAerodromeRpcUrl(args.rpcUrl);
+  const addrs = await loadAerodromeAddresses();
+  const isNativeIn = isAerodromeNativeToken(args.tokenIn);
+  const isNativeOut = isAerodromeNativeToken(args.tokenOut);
+  const tokenIn = resolveAerodromeErc20OrWeth(args.tokenIn, addrs.weth);
+  const tokenOut = resolveAerodromeErc20OrWeth(args.tokenOut, addrs.weth);
+  if (tokenIn.toLowerCase() === tokenOut.toLowerCase()) {
+    throw new Error("tokenIn and tokenOut must differ.");
+  }
+  let decimals = args.tokenInDecimals;
+  if (isAerodromeCoinbaseStockToken(tokenIn)) {
+    decimals = AERODROME_COINBASE_STOCK_DECIMALS;
+  } else if (decimals == null) {
+    decimals = await readTokenDecimals(rpcUrl, tokenIn, isNativeIn);
+  }
+  const amountIn = parseUnits(args.amountHuman.trim(), decimals);
+  if (amountIn <= 0n) throw new Error("amountHuman must be a positive decimal string.");
+  const sdkQuote = await tryAerodromeSdkQuote({
+    rpcUrl,
+    tokenIn,
+    tokenOut,
+    amountIn,
+    isNativeIn,
+    isNativeOut
+  });
+  if (sdkQuote) return sdkQuote;
+  let pools = await aerodromeDiscoverConnectorPools({ rpcUrl, tokenIn, tokenOut, addrs });
+  let paths = findAerodromePaths(pools, tokenIn, tokenOut);
+  if (paths.length === 0) {
+    const sugarPools = await aerodromeFetchSwapPools({ chainId: AERODROME_CHAIN_ID, rpcUrl });
+    pools = mergePools(pools, sugarPools);
+    const connectors = [addrs.weth, getAddress(AERODROME_USDC_BASE), addrs.aero];
+    const relevant = pools.filter((p) => {
+      const a = p.token0.toLowerCase();
+      const b = p.token1.toLowerCase();
+      const tin = tokenIn.toLowerCase();
+      const tout = tokenOut.toLowerCase();
+      const conn = new Set(connectors.map((c) => c.toLowerCase()));
+      return a === tin || b === tin || a === tout || b === tout || conn.has(a) || conn.has(b);
+    });
+    paths = findAerodromePaths(relevant, tokenIn, tokenOut);
+  }
+  if (paths.length === 0) {
+    await throwIfUnissuedStock({ rpcUrl, token: tokenOut, isNative: isNativeOut, label: args.tokenOut });
+    await throwIfUnissuedStock({ rpcUrl, token: tokenIn, isNative: isNativeIn, label: args.tokenIn });
+    const tout = tokenOut.toLowerCase();
+    const outHasPool = pools.some(
+      (p) => p.token0.toLowerCase() === tout || p.token1.toLowerCase() === tout
+    );
+    if (!outHasPool) {
+      throw new Error(
+        `No Aerodrome pool for ${args.tokenOut}. This token may not be issued yet or has no liquidity on Aerodrome.`
+      );
+    }
+    throw new Error("No Aerodrome route found for this pair.");
+  }
+  let best = null;
+  for (const hops of paths) {
+    const quoted = await quoteAerodromeHopsAmountOut({
+      rpcUrl,
+      router: addrs.router,
+      mixedQuoter: addrs.mixedQuoter,
+      mixedQuoterV3: addrs.mixedQuoterV3,
+      amountIn,
+      hops
+    });
+    if (!quoted) continue;
+    if (!best || quoted.out > best.out) {
+      best = { hops, out: quoted.out, source: quoted.source };
+    }
+  }
+  if (!best) {
+    await throwIfUnissuedStock({ rpcUrl, token: tokenOut, isNative: isNativeOut, label: args.tokenOut });
+    await throwIfUnissuedStock({ rpcUrl, token: tokenIn, isNative: isNativeIn, label: args.tokenIn });
+    throw new Error("Aerodrome quote returned zero for all candidate routes.");
+  }
+  let amountOutHuman = null;
+  try {
+    const outDecimals = await readTokenDecimals(rpcUrl, tokenOut, isNativeOut);
+    amountOutHuman = formatUnits(best.out, outDecimals);
+  } catch {
+    amountOutHuman = null;
+  }
+  let priceImpactPercent = null;
+  const probeIn = aerodromeProbeAmountIn(amountIn);
+  if (probeIn != null) {
+    const probeQuoted = await quoteAerodromeHopsAmountOut({
+      rpcUrl,
+      router: addrs.router,
+      mixedQuoter: addrs.mixedQuoter,
+      mixedQuoterV3: addrs.mixedQuoterV3,
+      amountIn: probeIn,
+      hops: best.hops
+    });
+    if (probeQuoted && probeQuoted.out > 0n) {
+      priceImpactPercent = computeAerodromePriceImpactPercent({
+        amountIn,
+        amountOut: best.out,
+        probeIn,
+        probeOut: probeQuoted.out
+      });
+    }
+  }
+  return {
+    chainId: AERODROME_CHAIN_ID,
+    tokenIn: isNativeIn ? zeroAddress : tokenIn,
+    tokenOut: isNativeOut ? zeroAddress : tokenOut,
+    amountInWei: amountIn.toString(),
+    amountOutWei: best.out.toString(),
+    amountOutHuman,
+    priceImpactPercent,
+    hops: best.hops,
+    pathPacked: encodeAerodromeMixedPath(best.hops),
+    isNativeIn,
+    isNativeOut,
+    source: best.source
+  };
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/aerodrome/batch.ts
+async function pushErc20ApproveIfNeeded(args) {
+  const client = aerodromePublicClient(args.rpcUrl);
+  const allowance = await client.readContract({
+    address: args.token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [args.owner, args.spender]
+  });
+  if (allowance >= args.amountWei) return;
+  if (allowance > 0n) {
+    args.steps.push({
+      to: args.token,
+      data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: [args.spender, 0n] }),
+      value: 0n,
+      kind: "approve",
+      fallbackGas: 80000n
+    });
+  }
+  args.steps.push({
+    to: args.token,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [args.spender, args.amountWei]
+    }),
+    value: 0n,
+    kind: "approve",
+    fallbackGas: 80000n
+  });
+}
+async function buildAerodromeMultisignBatch(args) {
+  if (args.steps.length === 0) throw new Error("Aerodrome batch has no steps.");
+  const executor = getAddress(args.executorAddress);
+  const first = args.steps[0];
+  const firstDataNo0x = first.data.startsWith("0x") ? first.data.slice(2) : first.data;
+  const payableValueWei = args.steps.reduce((a, s) => a + s.value, 0n);
+  const chainGasLimitRouter = args.chainDetail?.gasLimit != null && Number.isFinite(Number(args.chainDetail.gasLimit)) && Number(args.chainDetail.gasLimit) > 0 ? Number(args.chainDetail.gasLimit) : void 0;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: AERODROME_CHAIN_ID,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate: args.expiryDate
+    },
+    steps: args.steps,
+    purposeSuffix: args.purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: first.to,
+    payableValueWei: payableValueWei > 0n ? payableValueWei : void 0,
+    resolveGasLimit: async ({ step, estimatedGas }) => {
+      const s = step;
+      if (s.routerSwap) return routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+      return estimatedGas;
+    },
+    buildBatchMeta: ({ step }) => args.meta(step)
+  });
+}
+
+// src/protocols/evm/aerodrome/swapMultisign.ts
+function applySlippage(amountOut, slippagePercent) {
+  if (!Number.isFinite(slippagePercent) || slippagePercent <= 0 || slippagePercent >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const bps = BigInt(Math.round(slippagePercent * 100));
+  return amountOut - amountOut * bps / 10000n;
+}
+function routerRoutes(hops) {
+  return hops.map((h) => ({ from: h.from, to: h.to, stable: h.stable, factory: h.factory }));
+}
+async function appendSequentialMixedHops(args) {
+  let remainingIn = args.amountIn;
+  for (let i = 0; i < args.hops.length; i++) {
+    const hop = args.hops[i];
+    const isFirst = i === 0;
+    const isLast = i === args.hops.length - 1;
+    const quoted = await quoteAerodromeHopsAmountOut({
+      rpcUrl: args.rpcUrl,
+      router: args.addrs.router,
+      mixedQuoter: args.addrs.mixedQuoter,
+      mixedQuoterV3: args.addrs.mixedQuoterV3,
+      amountIn: remainingIn,
+      hops: [hop]
+    });
+    if (!quoted) {
+      throw new Error(`Aerodrome hop ${i + 1} of ${args.hops.length} returned no quote.`);
+    }
+    const hopOutMin = isLast ? args.amountOutMin : applySlippage(quoted.out, args.slippagePercent);
+    const payNative = isFirst && args.isNativeIn;
+    if (hop.kind === "cl") {
+      const swapRouter = aerodromeClSwapRouterForFactory(args.addrs, hop.factory);
+      if (!payNative) {
+        await pushErc20ApproveIfNeeded({
+          steps: args.steps,
+          rpcUrl: args.rpcUrl,
+          token: hop.from,
+          owner: args.executor,
+          spender: swapRouter,
+          amountWei: remainingIn
+        });
+      }
+      args.steps.push({
+        to: swapRouter,
+        data: encodeFunctionData({
+          abi: clSwapRouterAbi,
+          functionName: "exactInputSingle",
+          args: [
+            {
+              tokenIn: hop.from,
+              tokenOut: hop.to,
+              tickSpacing: hop.type,
+              recipient: args.executor,
+              deadline: args.deadline,
+              amountIn: remainingIn,
+              amountOutMinimum: hopOutMin,
+              sqrtPriceLimitX96: 0n
+            }
+          ]
+        }),
+        value: payNative ? remainingIn : 0n,
+        kind: "swap",
+        routerSwap: true,
+        fallbackGas: 400000n
+      });
+    } else {
+      if (!payNative) {
+        await pushErc20ApproveIfNeeded({
+          steps: args.steps,
+          rpcUrl: args.rpcUrl,
+          token: hop.from,
+          owner: args.executor,
+          spender: args.addrs.router,
+          amountWei: remainingIn
+        });
+      }
+      const routes = routerRoutes([hop]);
+      if (payNative) {
+        args.steps.push({
+          to: args.addrs.router,
+          data: encodeFunctionData({
+            abi: routerAbi,
+            functionName: "swapExactETHForTokens",
+            args: [hopOutMin, routes, args.executor, args.deadline]
+          }),
+          value: remainingIn,
+          kind: "swap",
+          routerSwap: true,
+          fallbackGas: 350000n
+        });
+      } else if (isLast && args.isNativeOut) {
+        args.steps.push({
+          to: args.addrs.router,
+          data: encodeFunctionData({
+            abi: routerAbi,
+            functionName: "swapExactTokensForETH",
+            args: [remainingIn, hopOutMin, routes, args.executor, args.deadline]
+          }),
+          value: 0n,
+          kind: "swap",
+          routerSwap: true,
+          fallbackGas: 350000n
+        });
+      } else {
+        args.steps.push({
+          to: args.addrs.router,
+          data: encodeFunctionData({
+            abi: routerAbi,
+            functionName: "swapExactTokensForTokens",
+            args: [remainingIn, hopOutMin, routes, args.executor, args.deadline]
+          }),
+          value: 0n,
+          kind: "swap",
+          routerSwap: true,
+          fallbackGas: 350000n
+        });
+      }
+    }
+    remainingIn = hopOutMin;
+  }
+}
+async function buildEvmMultisignBodyAerodromeSwapBatch(args) {
+  if (args.chainId !== AERODROME_CHAIN_ID) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const quote = args.quoteSnapshot?.hops?.length && args.quoteSnapshot.amountOutWei ? args.quoteSnapshot : await aerodromeQuote({
+    chainId: AERODROME_CHAIN_ID,
+    rpcUrl: args.rpcUrl,
+    tokenIn: args.tokenIn,
+    tokenOut: args.tokenOut,
+    amountHuman: args.amountHuman
+  });
+  const amountIn = BigInt(quote.amountInWei);
+  const amountOutMin = applySlippage(BigInt(quote.amountOutWei), args.slippagePercent);
+  const isNativeIn = quote.isNativeIn || isAerodromeNativeToken(args.tokenIn);
+  const isNativeOut = quote.isNativeOut || isAerodromeNativeToken(args.tokenOut);
+  const hops = quote.hops;
+  const deadline = aerodromeOnChainDeadlineUnix(args.expiryDate);
+  const steps = [];
+  const sdkTx = await tryAerodromeSdkUnsignedSwap({
+    rpcUrl: args.rpcUrl,
+    account: executor,
+    quote,
+    slippage: args.slippagePercent / 100
+  });
+  if (sdkTx) {
+    const tokenInAddr = getAddress(isNativeIn ? addrs.weth : quote.tokenIn);
+    if (!isNativeIn) {
+      await pushErc20ApproveIfNeeded({
+        steps,
+        rpcUrl: args.rpcUrl,
+        token: tokenInAddr,
+        owner: executor,
+        spender: sdkTx.to,
+        amountWei: amountIn
+      });
+    }
+    steps.push({
+      to: sdkTx.to,
+      data: sdkTx.data,
+      value: sdkTx.value,
+      kind: "swap",
+      routerSwap: true,
+      fallbackGas: 400000n
+    });
+  } else if (hops.length > 0 && hops.every((h) => h.kind !== "cl")) {
+    const routes = routerRoutes(hops);
+    if (!isNativeIn) {
+      await pushErc20ApproveIfNeeded({
+        steps,
+        rpcUrl: args.rpcUrl,
+        token: hops[0].from,
+        owner: executor,
+        spender: addrs.router,
+        amountWei: amountIn
+      });
+    }
+    if (isNativeIn) {
+      steps.push({
+        to: addrs.router,
+        data: encodeFunctionData({
+          abi: routerAbi,
+          functionName: "swapExactETHForTokens",
+          args: [amountOutMin, routes, executor, deadline]
+        }),
+        value: amountIn,
+        kind: "swap",
+        routerSwap: true,
+        fallbackGas: 350000n
+      });
+    } else if (isNativeOut) {
+      steps.push({
+        to: addrs.router,
+        data: encodeFunctionData({
+          abi: routerAbi,
+          functionName: "swapExactTokensForETH",
+          args: [amountIn, amountOutMin, routes, executor, deadline]
+        }),
+        value: 0n,
+        kind: "swap",
+        routerSwap: true,
+        fallbackGas: 350000n
+      });
+    } else {
+      steps.push({
+        to: addrs.router,
+        data: encodeFunctionData({
+          abi: routerAbi,
+          functionName: "swapExactTokensForTokens",
+          args: [amountIn, amountOutMin, routes, executor, deadline]
+        }),
+        value: 0n,
+        kind: "swap",
+        routerSwap: true,
+        fallbackGas: 350000n
+      });
+    }
+  } else if (hops.length === 1 && hops[0].kind === "cl") {
+    const hop = hops[0];
+    const swapRouter = aerodromeClSwapRouterForFactory(addrs, hop.factory);
+    if (!isNativeIn) {
+      await pushErc20ApproveIfNeeded({
+        steps,
+        rpcUrl: args.rpcUrl,
+        token: hop.from,
+        owner: executor,
+        spender: swapRouter,
+        amountWei: amountIn
+      });
+    }
+    steps.push({
+      to: swapRouter,
+      data: encodeFunctionData({
+        abi: clSwapRouterAbi,
+        functionName: "exactInputSingle",
+        args: [
+          {
+            tokenIn: hop.from,
+            tokenOut: hop.to,
+            tickSpacing: hop.type,
+            recipient: executor,
+            deadline,
+            amountIn,
+            amountOutMinimum: amountOutMin,
+            sqrtPriceLimitX96: 0n
+          }
+        ]
+      }),
+      value: isNativeIn ? amountIn : 0n,
+      kind: "swap",
+      routerSwap: true,
+      fallbackGas: 400000n
+    });
+  } else if (hops.length > 1) {
+    await appendSequentialMixedHops({
+      steps,
+      addrs,
+      rpcUrl: args.rpcUrl,
+      executor,
+      hops,
+      amountIn,
+      amountOutMin,
+      slippagePercent: args.slippagePercent,
+      deadline,
+      isNativeIn,
+      isNativeOut
+    });
+  } else {
+    throw new Error(
+      "No unsigned Aerodrome swap path: install @dromos-labs/sdk.js for mixed routes, or use a v2 / single-hop CL quote."
+    );
+  }
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: steps.length === 1 ? "Aerodrome: 1-tx swap." : `Aerodrome: ${steps.length}-tx batch \u2014 ERC-20 approve then swap.`,
+    meta: (step) => step.kind === "approve" ? {
+      signatureText: JSON.stringify({
+        kind: "Aerodrome",
+        name: "ERC20.approve",
+        note: "Allowance for this swap amount only."
+      }),
+      evm: { type: "aerodrome_erc20_approve", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    } : {
+      signatureText: JSON.stringify({
+        kind: "Aerodrome",
+        name: "swap",
+        hops: hops.map((h) => ({ from: h.from, to: h.to, kind: h.kind }))
+      }),
+      evm: { type: "aerodrome_swap", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    }
+  });
+}
+var OTHER_SIDE_DESIRED = 10n ** 36n;
+var Q96 = 1n << 96n;
+function pairTokenLabel(address, isNative) {
+  if (isNative) return "ETH";
+  if (address.toLowerCase() === AERODROME_WETH_BASE.toLowerCase()) return "WETH";
+  if (address.toLowerCase() === AERODROME_USDC_BASE.toLowerCase()) return "USDC";
+  const stock = AERODROME_COINBASE_STOCK_TOKENS.find((t) => t.address.toLowerCase() === address.toLowerCase());
+  return stock?.symbol || `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function noDirectPoolHint(args) {
+  const a = pairTokenLabel(args.tokenA, args.isNativeA);
+  const b = pairTokenLabel(args.tokenB, args.isNativeB);
+  const stockAddr = isAerodromeB20AssetToken(args.tokenB) ? args.tokenB : isAerodromeB20AssetToken(args.tokenA) ? args.tokenA : null;
+  if (stockAddr) {
+    const sym = pairTokenLabel(stockAddr, false);
+    return `No ${a}/${b} pool on Aerodrome. ${sym} liquidity is on Slipstream vs USDC (swaps hop through USDC). Pick USDC as the pair token to add ${sym}/USDC liquidity.`;
+  }
+  return `No vAMM, sAMM, or Slipstream pool for ${a}/${b}. This pair cannot be deposited as a single LP.`;
+}
+function formatLpHuman(wei, decimals) {
+  const maxFrac = Math.min(Math.max(decimals, 0), 8);
+  const dust = decimals > maxFrac ? 10n ** BigInt(decimals - maxFrac) : 1n;
+  const rounded = dust === 1n ? wei : (wei + dust / 2n) / dust * dust;
+  const s = formatUnits(rounded, decimals);
+  if (!s.includes(".")) return s;
+  const [i, f] = s.split(".");
+  const trimmed = (f ?? "").replace(/0+$/, "");
+  return trimmed ? `${i}.${trimmed}` : i ?? s;
+}
+async function aerodromeQuoteAddLiquidity(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const isNativeA = isAerodromeNativeToken(args.tokenA);
+  const isNativeB = isAerodromeNativeToken(args.tokenB);
+  const tokenA = resolveAerodromeErc20OrWeth(args.tokenA, addrs.weth);
+  const tokenB = resolveAerodromeErc20OrWeth(args.tokenB, addrs.weth);
+  await assertAerodromeStockIssued({
+    rpcUrl: args.rpcUrl,
+    token: tokenA,
+    isNative: isNativeA,
+    label: args.tokenA
+  });
+  await assertAerodromeStockIssued({
+    rpcUrl: args.rpcUrl,
+    token: tokenB,
+    isNative: isNativeB,
+    label: args.tokenB
+  });
+  const rawA = (args.amountAHuman ?? "").trim().replace(/,/g, "");
+  const rawB = (args.amountBHuman ?? "").trim().replace(/,/g, "");
+  if (!rawA && !rawB) throw new Error("Enter amount A or amount B.");
+  const decA = isAerodromeCoinbaseStockToken(tokenA) ? AERODROME_COINBASE_STOCK_DECIMALS : args.tokenADecimals ?? (isNativeA ? 18 : Number(await client.readContract({ address: tokenA, abi: erc20Abi, functionName: "decimals" })));
+  const decB = isAerodromeCoinbaseStockToken(tokenB) ? AERODROME_COINBASE_STOCK_DECIMALS : args.tokenBDecimals ?? (isNativeB ? 18 : Number(await client.readContract({ address: tokenB, abi: erc20Abi, functionName: "decimals" })));
+  const pool = await client.readContract({
+    address: addrs.router,
+    abi: routerAbi,
+    functionName: "poolFor",
+    args: [tokenA, tokenB, args.stable, addrs.poolFactory]
+  });
+  let emptyPool = pool === zeroAddress;
+  if (!emptyPool) {
+    try {
+      const reserves = await client.readContract({
+        address: pool,
+        abi: aerodromePoolMetaAbi,
+        functionName: "getReserves"
+      });
+      emptyPool = reserves[0] === 0n || reserves[1] === 0n;
+    } catch {
+      emptyPool = true;
+    }
+  }
+  const amountAParsed = rawA ? parseUnits(rawA, decA) : 0n;
+  const amountBParsed = rawB ? parseUnits(rawB, decB) : 0n;
+  if (emptyPool) {
+    const cl = await quoteClPairRatio({
+      rpcUrl: args.rpcUrl,
+      tokenA,
+      tokenB,
+      rawA,
+      rawB,
+      amountAParsed,
+      amountBParsed});
+    if (cl) {
+      return {
+        tokenA,
+        tokenB,
+        stable: args.stable,
+        amountA: cl.amountA.toString(),
+        amountB: cl.amountB.toString(),
+        amountAHuman: formatLpHuman(cl.amountA, decA),
+        amountBHuman: formatLpHuman(cl.amountB, decB),
+        liquidity: "0",
+        isNativeA,
+        isNativeB,
+        pool: cl.pool,
+        emptyPool: false,
+        kind: "cl",
+        tickSpacing: cl.tickSpacing
+      };
+    }
+    return {
+      tokenA,
+      tokenB,
+      stable: args.stable,
+      amountA: amountAParsed.toString(),
+      amountB: amountBParsed.toString(),
+      amountAHuman: rawA,
+      amountBHuman: rawB,
+      liquidity: "0",
+      isNativeA,
+      isNativeB,
+      pool,
+      emptyPool: true,
+      seedable: false,
+      hint: noDirectPoolHint({ tokenA, tokenB, isNativeA, isNativeB })
+    };
+  }
+  const amountADesired = rawA ? amountAParsed : OTHER_SIDE_DESIRED;
+  const amountBDesired = rawB ? amountBParsed : OTHER_SIDE_DESIRED;
+  const [amountA, amountB, liquidity] = await client.readContract({
+    address: addrs.router,
+    abi: routerAbi,
+    functionName: "quoteAddLiquidity",
+    args: [tokenA, tokenB, args.stable, addrs.poolFactory, amountADesired, amountBDesired]
+  });
+  return {
+    tokenA,
+    tokenB,
+    stable: args.stable,
+    amountA: amountA.toString(),
+    amountB: amountB.toString(),
+    amountAHuman: formatLpHuman(amountA, decA),
+    amountBHuman: formatLpHuman(amountB, decB),
+    liquidity: liquidity.toString(),
+    isNativeA,
+    isNativeB,
+    pool,
+    emptyPool: false,
+    kind: args.stable ? "stable" : "volatile",
+    seedable: true
+  };
+}
+async function quoteClPairRatio(args) {
+  const directs = await aerodromeDiscoverDirectPools({
+    rpcUrl: args.rpcUrl,
+    tokenA: args.tokenA,
+    tokenB: args.tokenB
+  });
+  const cls = directs.filter((p) => p.kind === "cl");
+  if (cls.length === 0) return null;
+  const client = aerodromePublicClient(args.rpcUrl);
+  const meta = await client.multicall({
+    allowFailure: true,
+    contracts: cls.flatMap((p) => [
+      { address: p.lp, abi: clPoolAbi, functionName: "liquidity" },
+      { address: p.lp, abi: clPoolAbi, functionName: "slot0" }
+    ])
+  });
+  let best = null;
+  for (let i = 0; i < cls.length; i++) {
+    const liqRow = meta[i * 2];
+    const slotRow = meta[i * 2 + 1];
+    if (slotRow?.status !== "success" || !slotRow.result) continue;
+    const slot = slotRow.result;
+    if (!Array.isArray(slot)) continue;
+    const sqrtP = BigInt(slot[0]);
+    if (sqrtP === 0n) continue;
+    const liquidity = liqRow?.status === "success" && (typeof liqRow.result === "bigint" || typeof liqRow.result === "string" || typeof liqRow.result === "number") ? BigInt(liqRow.result) : 0n;
+    if (!best || liquidity > best.liquidity) {
+      best = { pool: cls[i].lp, tickSpacing: cls[i].type, sqrtP, liquidity };
+    }
+  }
+  if (!best) return null;
+  const token0 = args.tokenA.toLowerCase() < args.tokenB.toLowerCase() ? args.tokenA : args.tokenB;
+  const aIs0 = args.tokenA.toLowerCase() === token0.toLowerCase();
+  const addrs = await loadAerodromeAddresses();
+  let amount0 = aIs0 ? args.amountAParsed : args.amountBParsed;
+  let amount1 = aIs0 ? args.amountBParsed : args.amountAParsed;
+  if (args.rawA && !args.rawB) {
+    if (aIs0) {
+      amount0 = args.amountAParsed;
+      amount1 = await estimateClOtherSide(client, addrs.sugarSlipstreamHelper, amount0, best.sqrtP, true);
+    } else {
+      amount1 = args.amountAParsed;
+      amount0 = await estimateClOtherSide(client, addrs.sugarSlipstreamHelper, amount1, best.sqrtP, false);
+    }
+  } else if (args.rawB && !args.rawA) {
+    if (aIs0) {
+      amount1 = args.amountBParsed;
+      amount0 = await estimateClOtherSide(client, addrs.sugarSlipstreamHelper, amount1, best.sqrtP, false);
+    } else {
+      amount0 = args.amountBParsed;
+      amount1 = await estimateClOtherSide(client, addrs.sugarSlipstreamHelper, amount0, best.sqrtP, true);
+    }
+  }
+  return {
+    pool: best.pool,
+    tickSpacing: best.tickSpacing,
+    amountA: aIs0 ? amount0 : amount1,
+    amountB: aIs0 ? amount1 : amount0
+  };
+}
+async function estimateClOtherSide(client, helper, amount, sqrtP, amountIs0) {
+  try {
+    const out = await client.readContract({
+      address: helper,
+      abi: sugarHelperAbi,
+      functionName: amountIs0 ? "estimateAmount1" : "estimateAmount0",
+      args: [amount, sqrtP, sqrtP, sqrtP]
+    });
+    if (out > 0n) return out;
+  } catch {
+  }
+  if (sqrtP === 0n) return 0n;
+  return amountIs0 ? amount * sqrtP / Q96 * sqrtP / Q96 : amount * Q96 / sqrtP * Q96 / sqrtP;
+}
+function minAfterSlippage(amount, slippagePercent) {
+  if (!Number.isFinite(slippagePercent) || slippagePercent <= 0 || slippagePercent >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const bps = BigInt(Math.round(slippagePercent * 100));
+  return amount - amount * bps / 10000n;
+}
+async function buildEvmMultisignBodyAerodromeAddLiquidityBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const quote = await aerodromeQuoteAddLiquidity({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    tokenA: args.tokenA,
+    tokenB: args.tokenB,
+    stable: args.stable,
+    amountAHuman: args.amountAHuman,
+    amountBHuman: args.amountBHuman
+  });
+  if (quote.emptyPool || quote.seedable === false) {
+    throw new Error(
+      quote.hint || "No Aerodrome pool to deposit into. Coinbase stocks such as AAPLc have no ETH pool \u2014 pair vs USDC."
+    );
+  }
+  if (quote.kind === "cl") {
+    throw new Error(
+      `This pair\u2019s live liquidity is Slipstream (tick spacing ${quote.tickSpacing ?? "?"}). Use ctm_aerodrome_quote_cl_deposit + ctm_aerodrome_build_cl_mint_multisign. Basic addLiquidity would seed a new empty vAMM.`
+    );
+  }
+  const amountA = BigInt(quote.amountA);
+  const amountB = BigInt(quote.amountB);
+  const minA = minAfterSlippage(amountA, args.slippagePercent);
+  const minB = minAfterSlippage(amountB, args.slippagePercent);
+  const deadline = aerodromeOnChainDeadlineUnix(args.expiryDate);
+  const steps = [];
+  if (!quote.isNativeA) {
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: quote.tokenA,
+      owner: executor,
+      spender: addrs.router,
+      amountWei: amountA
+    });
+  }
+  if (!quote.isNativeB) {
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: quote.tokenB,
+      owner: executor,
+      spender: addrs.router,
+      amountWei: amountB
+    });
+  }
+  if (quote.isNativeA || quote.isNativeB) {
+    const token = quote.isNativeA ? quote.tokenB : quote.tokenA;
+    const amountToken = quote.isNativeA ? amountB : amountA;
+    const amountEth = quote.isNativeA ? amountA : amountB;
+    const minToken = quote.isNativeA ? minB : minA;
+    const minEth = quote.isNativeA ? minA : minB;
+    steps.push({
+      to: addrs.router,
+      data: encodeFunctionData({
+        abi: routerAbi,
+        functionName: "addLiquidityETH",
+        args: [token, args.stable, amountToken, minToken, minEth, executor, deadline]
+      }),
+      value: amountEth,
+      kind: "add_liquidity",
+      fallbackGas: 400000n
+    });
+  } else {
+    steps.push({
+      to: addrs.router,
+      data: encodeFunctionData({
+        abi: routerAbi,
+        functionName: "addLiquidity",
+        args: [
+          quote.tokenA,
+          quote.tokenB,
+          args.stable,
+          amountA,
+          amountB,
+          minA,
+          minB,
+          executor,
+          deadline
+        ]
+      }),
+      value: 0n,
+      kind: "add_liquidity",
+      fallbackGas: 400000n
+    });
+  }
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome: add basic-pool liquidity.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "addLiquidity", stable: args.stable }),
+      evm: { type: "aerodrome_add_liquidity", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeRemoveLiquidityBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const lp = getAddress(args.lpToken);
+  const dec = args.lpDecimals ?? Number(await client.readContract({ address: lp, abi: erc20Abi, functionName: "decimals" }));
+  const liquidity = parseUnits(args.liquidityHuman.trim(), dec);
+  const tokenA = resolveAerodromeErc20OrWeth(args.tokenA, addrs.weth);
+  const tokenB = resolveAerodromeErc20OrWeth(args.tokenB, addrs.weth);
+  const isNativeA = isAerodromeNativeToken(args.tokenA);
+  const isNativeB = isAerodromeNativeToken(args.tokenB);
+  const minA = parseUnits(args.amountAMinHuman?.trim() || "0", 18);
+  const minB = parseUnits(args.amountBMinHuman?.trim() || "0", 18);
+  const deadline = aerodromeOnChainDeadlineUnix(args.expiryDate);
+  const steps = [];
+  await pushErc20ApproveIfNeeded({
+    steps,
+    rpcUrl: args.rpcUrl,
+    token: lp,
+    owner: executor,
+    spender: addrs.router,
+    amountWei: liquidity
+  });
+  if (isNativeA || isNativeB) {
+    const token = isNativeA ? tokenB : tokenA;
+    steps.push({
+      to: addrs.router,
+      data: encodeFunctionData({
+        abi: routerAbi,
+        functionName: "removeLiquidityETH",
+        args: [token, args.stable, liquidity, isNativeA ? minB : minA, isNativeA ? minA : minB, executor, deadline]
+      }),
+      value: 0n,
+      kind: "remove_liquidity",
+      fallbackGas: 350000n
+    });
+  } else {
+    steps.push({
+      to: addrs.router,
+      data: encodeFunctionData({
+        abi: routerAbi,
+        functionName: "removeLiquidity",
+        args: [tokenA, tokenB, args.stable, liquidity, minA, minB, executor, deadline]
+      }),
+      value: 0n,
+      kind: "remove_liquidity",
+      fallbackGas: 350000n
+    });
+  }
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome: remove basic-pool liquidity.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "removeLiquidity", lp }),
+      evm: { type: "aerodrome_remove_liquidity", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function aerodromeQuoteClDeposit(args) {
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const addrs = await loadAerodromeAddresses();
+  const client = aerodromePublicClient(args.rpcUrl);
+  const token0 = resolveAerodromeErc20OrWeth(args.token0, addrs.weth);
+  const token1 = resolveAerodromeErc20OrWeth(args.token1, addrs.weth);
+  const dec0 = args.token0Decimals ?? (isAerodromeNativeToken(args.token0) ? 18 : Number(await client.readContract({ address: token0, abi: erc20Abi, functionName: "decimals" })));
+  const dec1 = args.token1Decimals ?? (isAerodromeNativeToken(args.token1) ? 18 : Number(await client.readContract({ address: token1, abi: erc20Abi, functionName: "decimals" })));
+  const helper = addrs.sugarSlipstreamHelper;
+  const sqrt = BigInt(args.sqrtPriceX96 || "0");
+  let amount0 = args.amount0Human?.trim() ? parseUnits(args.amount0Human.trim(), dec0) : 0n;
+  let amount1 = args.amount1Human?.trim() ? parseUnits(args.amount1Human.trim(), dec1) : 0n;
+  if (sqrt > 0n && amount0 > 0n && amount1 === 0n) {
+    try {
+      amount1 = await client.readContract({
+        address: helper,
+        abi: sugarHelperAbi,
+        functionName: "estimateAmount1",
+        args: [amount0, sqrt, sqrt, sqrt]
+      });
+    } catch {
+    }
+  } else if (sqrt > 0n && amount1 > 0n && amount0 === 0n) {
+    try {
+      amount0 = await client.readContract({
+        address: helper,
+        abi: sugarHelperAbi,
+        functionName: "estimateAmount0",
+        args: [amount1, sqrt, sqrt, sqrt]
+      });
+    } catch {
+    }
+  }
+  return {
+    token0,
+    token1,
+    amount0: amount0.toString(),
+    amount1: amount1.toString(),
+    tickSpacing: args.tickSpacing,
+    tickLower: args.tickLower,
+    tickUpper: args.tickUpper,
+    sqrtPriceX96: args.sqrtPriceX96
+  };
+}
+function minAfterSlippage2(amount, slippagePercent) {
+  if (!Number.isFinite(slippagePercent) || slippagePercent <= 0 || slippagePercent >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const bps = BigInt(Math.round(slippagePercent * 100));
+  return amount - amount * bps / 10000n;
+}
+async function buildEvmMultisignBodyAerodromeClMintBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const quote = await aerodromeQuoteClDeposit({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    token0: args.token0,
+    token1: args.token1,
+    amount0Human: args.amount0Human,
+    amount1Human: args.amount1Human,
+    tickSpacing: args.tickSpacing,
+    tickLower: args.tickLower,
+    tickUpper: args.tickUpper,
+    sqrtPriceX96: args.sqrtPriceX96
+  });
+  const amount0 = BigInt(quote.amount0);
+  const amount1 = BigInt(quote.amount1);
+  const steps = [];
+  let value = 0n;
+  if (!isAerodromeNativeToken(args.token0)) {
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: quote.token0,
+      owner: executor,
+      spender: addrs.nfpm,
+      amountWei: amount0
+    });
+  } else {
+    value += amount0;
+  }
+  if (!isAerodromeNativeToken(args.token1)) {
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: quote.token1,
+      owner: executor,
+      spender: addrs.nfpm,
+      amountWei: amount1
+    });
+  } else {
+    value += amount1;
+  }
+  const poolExists = BigInt(args.sqrtPriceX96) === 0n;
+  steps.push({
+    to: addrs.nfpm,
+    data: encodeFunctionData({
+      abi: nfpmAbi,
+      functionName: "mint",
+      args: [
+        {
+          token0: quote.token0,
+          token1: quote.token1,
+          tickSpacing: args.tickSpacing,
+          tickLower: args.tickLower,
+          tickUpper: args.tickUpper,
+          amount0Desired: amount0,
+          amount1Desired: amount1,
+          amount0Min: minAfterSlippage2(amount0, args.slippagePercent),
+          amount1Min: minAfterSlippage2(amount1, args.slippagePercent),
+          recipient: executor,
+          deadline: aerodromeOnChainDeadlineUnix(args.expiryDate),
+          sqrtPriceX96: poolExists ? 0n : BigInt(args.sqrtPriceX96)
+        }
+      ]
+    }),
+    value,
+    kind: "cl_mint",
+    fallbackGas: 600000n
+  });
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome Slipstream: mint concentrated position NFT.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "nfpm.mint" }),
+      evm: { type: "aerodrome_cl_mint", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeClIncreaseBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const amount0 = BigInt(args.amount0Wei);
+  const amount1 = BigInt(args.amount1Wei);
+  const token0 = resolveAerodromeErc20OrWeth(args.token0, addrs.weth);
+  const token1 = resolveAerodromeErc20OrWeth(args.token1, addrs.weth);
+  const steps = [];
+  let value = 0n;
+  if (!isAerodromeNativeToken(args.token0)) {
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: token0,
+      owner: executor,
+      spender: addrs.nfpm,
+      amountWei: amount0
+    });
+  } else value += amount0;
+  if (!isAerodromeNativeToken(args.token1)) {
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: token1,
+      owner: executor,
+      spender: addrs.nfpm,
+      amountWei: amount1
+    });
+  } else value += amount1;
+  steps.push({
+    to: addrs.nfpm,
+    data: encodeFunctionData({
+      abi: nfpmAbi,
+      functionName: "increaseLiquidity",
+      args: [
+        {
+          tokenId: BigInt(args.tokenId),
+          amount0Desired: amount0,
+          amount1Desired: amount1,
+          amount0Min: minAfterSlippage2(amount0, args.slippagePercent),
+          amount1Min: minAfterSlippage2(amount1, args.slippagePercent),
+          deadline: aerodromeOnChainDeadlineUnix(args.expiryDate)
+        }
+      ]
+    }),
+    value,
+    kind: "cl_increase",
+    fallbackGas: 400000n
+  });
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome Slipstream: increase liquidity.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "nfpm.increaseLiquidity", tokenId: args.tokenId }),
+      evm: { type: "aerodrome_cl_increase", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeClDecreaseBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const steps = [
+    {
+      to: addrs.nfpm,
+      data: encodeFunctionData({
+        abi: nfpmAbi,
+        functionName: "decreaseLiquidity",
+        args: [
+          {
+            tokenId: BigInt(args.tokenId),
+            liquidity: BigInt(args.liquidity),
+            amount0Min: BigInt(args.amount0MinWei ?? "0"),
+            amount1Min: BigInt(args.amount1MinWei ?? "0"),
+            deadline: aerodromeOnChainDeadlineUnix(args.expiryDate)
+          }
+        ]
+      }),
+      value: 0n,
+      kind: "cl_decrease",
+      fallbackGas: 300000n
+    }
+  ];
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome Slipstream: decrease liquidity.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "nfpm.decreaseLiquidity", tokenId: args.tokenId }),
+      evm: { type: "aerodrome_cl_decrease", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeClCollectBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const max = 2n ** 128n - 1n;
+  const steps = [
+    {
+      to: addrs.nfpm,
+      data: encodeFunctionData({
+        abi: nfpmAbi,
+        functionName: "collect",
+        args: [{ tokenId: BigInt(args.tokenId), recipient: executor, amount0Max: max, amount1Max: max }]
+      }),
+      value: 0n,
+      kind: "cl_collect",
+      fallbackGas: 200000n
+    }
+  ];
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome Slipstream: collect fees.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "nfpm.collect", tokenId: args.tokenId }),
+      evm: { type: "aerodrome_cl_collect", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeClBurnBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const addrs = await loadAerodromeAddresses();
+  const steps = [
+    {
+      to: addrs.nfpm,
+      data: encodeFunctionData({
+        abi: nfpmAbi,
+        functionName: "burn",
+        args: [BigInt(args.tokenId)]
+      }),
+      value: 0n,
+      kind: "cl_burn",
+      fallbackGas: 120000n
+    }
+  ];
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome Slipstream: burn empty position NFT.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "nfpm.burn", tokenId: args.tokenId }),
+      evm: { type: "aerodrome_cl_burn", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeGaugeStakeBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const gauge = getAddress(args.gauge);
+  const steps = [];
+  if (args.cl) {
+    if (!args.tokenId) throw new Error("tokenId is required to stake a Slipstream NFT.");
+    if (!args.lpToken) throw new Error("nfpm / lpToken address is required to approve a Slipstream NFT.");
+    const tokenId = BigInt(args.tokenId);
+    const nfpm = getAddress(args.lpToken);
+    steps.push({
+      to: nfpm,
+      data: encodeFunctionData({
+        abi: nfpmAbi,
+        functionName: "approve",
+        args: [gauge, tokenId]
+      }),
+      value: 0n,
+      kind: "nft_approve",
+      fallbackGas: 80000n
+    });
+    steps.push({
+      to: gauge,
+      data: encodeFunctionData({ abi: clGaugeAbi, functionName: "deposit", args: [tokenId] }),
+      value: 0n,
+      kind: "gauge_stake",
+      fallbackGas: 200000n
+    });
+  } else {
+    if (!args.lpToken || !args.amountHuman) throw new Error("lpToken and amountHuman are required to stake basic LP.");
+    const amount = parseUnits(args.amountHuman.trim(), args.lpDecimals ?? 18);
+    await pushErc20ApproveIfNeeded({
+      steps,
+      rpcUrl: args.rpcUrl,
+      token: getAddress(args.lpToken),
+      owner: executor,
+      spender: gauge,
+      amountWei: amount
+    });
+    steps.push({
+      to: gauge,
+      data: encodeFunctionData({ abi: gaugeAbi, functionName: "deposit", args: [amount] }),
+      value: 0n,
+      kind: "gauge_stake",
+      fallbackGas: 180000n
+    });
+  }
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome: stake LP in gauge.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "gauge.deposit" }),
+      evm: { type: "aerodrome_gauge_stake", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeGaugeUnstakeBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const gauge = getAddress(args.gauge);
+  const steps = [];
+  if (args.cl) {
+    if (!args.tokenId) throw new Error("tokenId is required to unstake a Slipstream NFT.");
+    steps.push({
+      to: gauge,
+      data: encodeFunctionData({
+        abi: clGaugeAbi,
+        functionName: "withdraw",
+        args: [BigInt(args.tokenId)]
+      }),
+      value: 0n,
+      kind: "gauge_unstake",
+      fallbackGas: 200000n
+    });
+  } else {
+    if (!args.amountHuman) throw new Error("amountHuman is required to unstake basic LP.");
+    const amount = parseUnits(args.amountHuman.trim(), args.lpDecimals ?? 18);
+    steps.push({
+      to: gauge,
+      data: encodeFunctionData({ abi: gaugeAbi, functionName: "withdraw", args: [amount] }),
+      value: 0n,
+      kind: "gauge_unstake",
+      fallbackGas: 180000n
+    });
+  }
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome: unstake LP from gauge.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "gauge.withdraw" }),
+      evm: { type: "aerodrome_gauge_unstake", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeClaimFeesBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const pool = getAddress(args.pool);
+  const steps = [
+    {
+      to: pool,
+      data: encodeFunctionData({ abi: poolClaimFeesAbi, functionName: "claimFees" }),
+      value: 0n,
+      kind: "claim_fees",
+      fallbackGas: 150000n
+    }
+  ];
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome: claim basic-pool fees.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "pool.claimFees", pool }),
+      evm: { type: "aerodrome_claim_fees", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyAerodromeClaimEmissionsBatch(args) {
+  const executor = getAddress(args.executorAddress);
+  const gauge = getAddress(args.gauge);
+  const steps = [
+    args.cl ? {
+      to: gauge,
+      data: encodeFunctionData({
+        abi: clGaugeAbi,
+        functionName: "getReward",
+        args: [BigInt(args.tokenId ?? "0")]
+      }),
+      value: 0n,
+      kind: "claim_emissions",
+      fallbackGas: 150000n
+    } : {
+      to: gauge,
+      data: encodeFunctionData({
+        abi: gaugeAbi,
+        functionName: "getReward",
+        args: [executor]
+      }),
+      value: 0n,
+      kind: "claim_emissions",
+      fallbackGas: 150000n
+    }
+  ];
+  return buildAerodromeMultisignBatch({
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    executorAddress: executor,
+    purposeText: args.purposeText,
+    expiryDate: args.expiryDate,
+    steps,
+    purposeSuffix: "Aerodrome: claim gauge emissions.",
+    meta: () => ({
+      signatureText: JSON.stringify({ kind: "Aerodrome", name: "gauge.getReward" }),
+      evm: { type: "aerodrome_claim_emissions", version: 1, chainId: String(AERODROME_CHAIN_ID) }
+    })
+  });
+}
+
+// src/protocols/evm/aerodrome/purpose.ts
+function buildAerodromeSwapPurposePrefill(args) {
+  const symIn = (args.tokenInSymbol || "").trim() || "token in";
+  const symOut = (args.tokenOutSymbol || "").trim() || "token out";
+  const slip = Number.parseFloat(String(args.slippageInput || "0.5").replace(/,/g, ""));
+  const slipText = Number.isFinite(slip) ? String(Math.round(slip * 100) / 100) : "0.5";
+  const amt = (args.amountIn || "").trim();
+  const qo = (args.quoteOutAmount || "").trim();
+  const mid = amt && qo ? `${amt} ${symIn} for an estimated ${qo} ${symOut}` : `${amt || "\u2026"} ${symIn} \u2192 ${symOut}`;
+  return `Aerodrome: swap ${mid} (max slippage ${slipText}%) on Base (chainId 8453)`;
+}
+function buildAerodromeLiquidityPurposePrefill(args) {
+  return `Aerodrome: ${args.action} ${args.tokenASymbol}/${args.tokenBSymbol} on Base (chainId 8453)`;
+}
+function buildAerodromeRewardsPurposePrefill(args) {
+  const action = args?.action ?? "claim fees/emissions";
+  const label = (args?.poolLabel || "").trim();
+  const mid = label ? `${action} on ${label}` : action;
+  return `Aerodrome: ${mid} on Base (chainId 8453)`;
+}
+function aerodromePositionLabel(row) {
+  const symbol = (row.symbol || "").trim();
+  if (symbol) {
+    if (row.kind === "cl" && row.id && row.id !== "0") return `${symbol} #${row.id}`;
+    return symbol;
+  }
+  const kind = row.kind === "stable" ? "sAMM" : row.kind === "cl" ? "CL" : "vAMM";
+  const short = row.lp.length > 12 ? `${row.lp.slice(0, 6)}\u2026${row.lp.slice(-4)}` : row.lp;
+  return row.id && row.id !== "0" ? `${kind} ${short} #${row.id}` : `${kind} ${short}`;
+}
+function aerodromePositionKey(row) {
+  return `${row.lp.toLowerCase()}:${row.id || "0"}`;
+}
+
+// src/protocols/evm/aerodrome/reads.ts
+function mergeStocksIntoListed(tokens, stocks) {
+  const byAddr = new Map(tokens.map((t) => [t.address.toLowerCase(), { ...t }]));
+  for (const stock of stocks) {
+    const key = stock.address.toLowerCase();
+    const prev = byAddr.get(key);
+    byAddr.set(key, {
+      address: stock.address,
+      symbol: stock.symbol || prev?.symbol || "",
+      decimals: stock.decimals || prev?.decimals || AERODROME_COINBASE_STOCK_DECIMALS,
+      listed: prev?.listed ?? true,
+      emerging: prev?.emerging ?? false,
+      accountBalance: prev?.accountBalance ?? "0",
+      name: stock.name,
+      issued: stock.issued
+    });
+  }
+  const stocksFirst = stocks.map((s) => byAddr.get(s.address.toLowerCase())).filter(Boolean);
+  const rest = [...byAddr.values()].filter((t) => !isAerodromeB20AssetToken(t.address));
+  return [...stocksFirst, ...rest];
+}
+async function aerodromeFetchListedTokensSummary(args) {
+  const includeSugar = args.includeSugarListed !== false;
+  const officialPromise = fetchOfficialBaseTokenizedStocks().catch(() => []);
+  const tokens = includeSugar ? await aerodromeFetchListedTokens(args) : [];
+  const official = await officialPromise;
+  const stocks = await aerodromeResolveStockTokens({
+    rpcUrl: args.rpcUrl,
+    official,
+    knownTokens: tokens
+  });
+  const addrs = await loadAerodromeAddresses();
+  const core = [
+    { address: zeroAddress, symbol: "ETH", decimals: 18, listed: true, emerging: false, accountBalance: "0" },
+    {
+      address: AERODROME_WETH_BASE,
+      symbol: "WETH",
+      decimals: 18,
+      listed: true,
+      emerging: false,
+      accountBalance: "0"
+    },
+    {
+      address: AERODROME_USDC_BASE,
+      symbol: "USDC",
+      decimals: 6,
+      listed: true,
+      emerging: false,
+      accountBalance: "0"
+    },
+    { address: addrs.aero, symbol: "AERO", decimals: 18, listed: true, emerging: false, accountBalance: "0" }
+  ];
+  return {
+    chainId: AERODROME_CHAIN_ID,
+    native: { address: zeroAddress, symbol: "ETH", decimals: 18 },
+    aero: { address: addrs.aero, symbol: "AERO", decimals: 18 },
+    stocks,
+    includeSugarListed: includeSugar,
+    tokens: mergeStocksIntoListed([...core, ...tokens], stocks),
+    notes: includeSugar ? "Full LpSugar.tokens plus Coinbase B20 stocks. issued is totalSupply > 0. For a price, call ctm_aerodrome_quote with the ticker \u2014 do not grep this list." : "Slim list: ETH, WETH, USDC, AERO, and Coinbase B20 stocks (AAPLc, \u2026). issued is totalSupply > 0. Do not use this for a price \u2014 call ctm_aerodrome_quote({ tokenIn, tokenOut, amountHuman }) with tickers. Pass includeSugarListed:true only if you need the full Sugar dump."
+  };
+}
+async function aerodromeFetchPoolsSummary(args) {
+  const pools = await aerodromeFetchPools(args);
+  return { chainId: AERODROME_CHAIN_ID, pools };
+}
+async function aerodromeFetchPositionsSummary(args) {
+  const account = (args.account ?? args.executorAddress ?? "").trim();
+  if (!account) throw new Error("account or executorAddress is required.");
+  if (!isAerodromeChainSupported(args.chainId)) {
+    throw new Error(`Aerodrome is Base-only (chainId ${AERODROME_CHAIN_ID}).`);
+  }
+  const positions = await aerodromeFetchPositionsWithPools({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    account
+  });
+  return {
+    chainId: AERODROME_CHAIN_ID,
+    account,
+    notes: "Dust v2 rows hidden (liquidity < 1e12 and no stake/emissions). Claim fees from the pool (claimFees.pool = lp). Claim emissions from the gauge in AERO (claimEmissions); CL staked also needs tokenId + cl. Skip emissions when claimEmissions is null.",
+    positions: positions.map((p) => {
+      const gaugeOk = Boolean(p.gauge) && p.gauge.toLowerCase() !== zeroAddress.toLowerCase();
+      return {
+        ...p,
+        label: aerodromePositionLabel(p),
+        stakedInGauge: BigInt(p.staked || "0") > 0n,
+        claimFees: { pool: p.lp },
+        claimEmissions: gaugeOk ? {
+          gauge: p.gauge,
+          ...p.kind === "cl" && p.id !== "0" ? { tokenId: p.id, cl: true } : { cl: false }
+        } : null
+      };
+    })
+  };
+}
+
+// src/protocols/evm/aerodrome/index.ts
+var aerodromeProtocolModule = {
+  id: AERODROME_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return isAerodromeChainSupported(ctx.chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "aerodrome.quote",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Quote an Aerodrome swap on Base via factory discovery + MixedRouteQuoterV3 / Router. Tickers (AAPLc, USDC, ETH) accepted.",
+      commonParams: [],
+      params: {
+        chainId: { type: "number", required: true, description: `Must be ${AERODROME_CHAIN_ID}` },
+        tokenIn: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native" },
+        tokenOut: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount (B20 stocks are 8 decimals)" }
+      }
+    },
+    {
+      id: "aerodrome.swap",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Swap via Aerodrome Router / Slipstream SwapRouter (optional ERC-20 approve batch)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenIn: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        tokenOut: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount" },
+        slippagePercent: { type: "number", required: true, description: "Slippage percent (0\u2013100 exclusive)" }
+      }
+    },
+    {
+      id: "aerodrome.add-liquidity",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Deposit into a basic vAMM/sAMM pool (one-sided amounts; tickers OK)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenA: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        tokenB: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        stable: { type: "boolean", required: true, description: "true = sAMM, false = vAMM" },
+        amountAHuman: { type: "string", required: false, description: "Amount A; omit to solve from B" },
+        amountBHuman: { type: "string", required: false, description: "Amount B; omit to solve from A" },
+        slippagePercent: { type: "number", required: true, description: "Slippage percent" }
+      }
+    },
+    {
+      id: "aerodrome.remove-liquidity",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw from a basic vAMM/sAMM pool",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        lpToken: { type: "address", required: true, description: "LP token" },
+        liquidityHuman: { type: "string", required: true, description: "LP amount" }
+      }
+    },
+    {
+      id: "aerodrome.cl-mint",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint a Slipstream concentrated liquidity NFT",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        token0: { type: "address", required: true, description: "Token0" },
+        token1: { type: "address", required: true, description: "Token1" },
+        tickSpacing: { type: "number", required: true, description: "Pool tick spacing" },
+        tickLower: { type: "number", required: true, description: "Lower tick" },
+        tickUpper: { type: "number", required: true, description: "Upper tick" }
+      }
+    },
+    {
+      id: "aerodrome.gauge-stake",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Stake basic LP tokens or a Slipstream NFT in a gauge",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        gauge: { type: "address", required: true, description: "Gauge address" }
+      }
+    },
+    {
+      id: "aerodrome.claim-fees",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim unstaked fees from the pool (not the gauge)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { pool: { type: "address", required: true, description: "Pool lp from fetch_positions claimFees.pool" } }
+    },
+    {
+      id: "aerodrome.claim-emissions",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim gauge emissions in AERO (not the pool)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { gauge: { type: "address", required: true, description: "Gauge from fetch_positions claimEmissions" } }
+    }
+  ]
+};
+registerProtocolModule(aerodromeProtocolModule);
+
+export { AERODROME_B20_ASSET_PREFIX, AERODROME_BASE_ADDRESSES_FALLBACK, AERODROME_CHAIN_ID, AERODROME_CL_FACTORY_NEWEST_BIT, AERODROME_CL_FACTORY_OLDEST_BIT, AERODROME_COINBASE_STOCK_DECIMALS, AERODROME_COINBASE_STOCK_TOKENS, AERODROME_NATIVE_PLACEHOLDER, AERODROME_PROTOCOL_ID, AERODROME_STABLE_FILLER, AERODROME_USDC_BASE, AERODROME_VOLATILE_FILLER, AERODROME_WETH_BASE, aerodromeClFactoryList, aerodromeClSwapRouterForFactory, aerodromeCoinbaseStockAddresses, aerodromeDiscoverConnectorPools, aerodromeDiscoverConnectorPoolsLoaded, aerodromeDiscoverDirectPools, aerodromeDiscoverPoolsSummary, aerodromeFallbackAddresses, aerodromeFetchListedTokens, aerodromeFetchListedTokensSummary, aerodromeFetchPools, aerodromeFetchPoolsByAddress, aerodromeFetchPoolsSummary, aerodromeFetchPositions, aerodromeFetchPositionsSummary, aerodromeFetchPositionsWithPools, aerodromeFetchSwapPools, aerodromeMixedPathFiller, aerodromeOnChainDeadlineUnix, aerodromePositionKey, aerodromePositionLabel, aerodromeProbeAmountIn, aerodromeProtocolModule, aerodromeQuote, aerodromeQuoteAddLiquidity, aerodromeQuoteClDeposit, aerodromeResolveStockTokens, aerodromeUnissuedStockMessage, assertAerodromeStockIssued, buildAerodromeLiquidityPurposePrefill, buildAerodromeRewardsPurposePrefill, buildAerodromeSwapPurposePrefill, buildEvmMultisignBodyAerodromeAddLiquidityBatch, buildEvmMultisignBodyAerodromeClBurnBatch, buildEvmMultisignBodyAerodromeClCollectBatch, buildEvmMultisignBodyAerodromeClDecreaseBatch, buildEvmMultisignBodyAerodromeClIncreaseBatch, buildEvmMultisignBodyAerodromeClMintBatch, buildEvmMultisignBodyAerodromeClaimEmissionsBatch, buildEvmMultisignBodyAerodromeClaimFeesBatch, buildEvmMultisignBodyAerodromeGaugeStakeBatch, buildEvmMultisignBodyAerodromeGaugeUnstakeBatch, buildEvmMultisignBodyAerodromeRemoveLiquidityBatch, buildEvmMultisignBodyAerodromeSwapBatch, computeAerodromePriceImpactPercent, encodeAerodromeMixedPath, fetchOfficialBaseTokenizedStocks, findAerodromePaths, formatAerodromePriceImpact, isAerodromeB20AssetToken, isAerodromeChainSupported, isAerodromeCoinbaseStockToken, isAerodromeNativeToken, loadAerodromeAddresses, looksLikeCoinbaseStockSymbol, lookupAerodromeKnownToken, parseBaseTokenizedStockDocs, parseSecurityMdxAddresses, parseSugarBaseEnv, quoteAerodromeHopsAmountOut, requireAerodromeRpcUrl, resetAerodromeAddressCache, resolveAerodromeErc20OrWeth, tryAerodromeSdkQuote, tryAerodromeSdkUnsignedSwap };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map