@continuumdao/ctm-mpc-defi 0.2.30 → 0.2.31

package/dist/agent/catalog.cjs

@@ -95,17 +95,27 @@ var init_api = __esm({
 // src/protocols/evm/morpho/midnightConstants.ts
 var midnightConstants_exports = {};
 __export(midnightConstants_exports, {
+  MORPHO_BLUE_CANONICAL: () => MORPHO_BLUE_CANONICAL,
   MORPHO_MIDNIGHT_ADDRESSES: () => MORPHO_MIDNIGHT_ADDRESSES,
   MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS: () => MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS,
   MORPHO_MIDNIGHT_BASE_CHAIN_ID: () => MORPHO_MIDNIGHT_BASE_CHAIN_ID,
+  MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS,
   MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT: () => MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT,
   MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_CALLBACK_SALT: () => MORPHO_MIDNIGHT_CALLBACK_SALT,
+  MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS: () => MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS,
   MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS: () => MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS,
+  MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS: () => MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS,
   MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT: () => MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT,
   MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK: () => MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK,
+  MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID: () => MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID,
   MORPHO_MIDNIGHT_LEND_FALLBACK_GAS: () => MORPHO_MIDNIGHT_LEND_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS: () => MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS,
   MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS: () => MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS,
   MORPHO_MIDNIGHT_REST_BASE: () => MORPHO_MIDNIGHT_REST_BASE,
+  MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS: () => MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS: () => MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS,
   MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK: () => MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK,
   TOKEN_PERMIT_NONE: () => TOKEN_PERMIT_NONE,
   morphoMidnightAddressesForChain: () => morphoMidnightAddressesForChain
@@ -113,18 +123,36 @@ __export(midnightConstants_exports, {
 function morphoMidnightAddressesForChain(chainId) {
   return MORPHO_MIDNIGHT_ADDRESSES[chainId] ?? null;
 }
-var MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_ADDRESSES, TOKEN_PERMIT_NONE, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK;
+var MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID, MORPHO_BLUE_CANONICAL, MORPHO_MIDNIGHT_CALLBACK_SALT, MORPHO_MIDNIGHT_ADDRESSES, TOKEN_PERMIT_NONE, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK, MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS, MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS, MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS, MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS, MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS, MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS;
 var init_midnightConstants = __esm({
   "src/protocols/evm/morpho/midnightConstants.ts"() {
     MORPHO_MIDNIGHT_REST_BASE = "https://api.morpho.org/v0/midnight";
     MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT = 20;
     MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT = "0.5";
     MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS = 3600;
+    MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS = 7 * 24 * 3600;
     MORPHO_MIDNIGHT_BASE_CHAIN_ID = 8453;
+    MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID = 1;
+    MORPHO_BLUE_CANONICAL = "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";
+    MORPHO_MIDNIGHT_CALLBACK_SALT = viem.keccak256(viem.toBytes("continuum-midnight-lend-v1"));
     MORPHO_MIDNIGHT_ADDRESSES = {
+      [MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID]: {
+        midnight: "0x471686c42792F93528B000beF54bC10E3aa2045f",
+        bundles: "0x7c00dBB2b6b6b9B28745332e550dC8782Fcf77EC",
+        mempool: "0xde2d62449301a09A51EbF9326EA60d2e8BF4A8F7",
+        setterRatifier: "0xb72c416382c8A6399D0765CebfB032F040B00B3c",
+        ecrecoverRatifier: "0xAC439c81CAA6ef4C7B7E8F0110F8CE63A4b6D43e",
+        blueBuyCallbackFactory: "0x172d1FdC5f79bFe1ED46448f18541E591E5c93a7",
+        morphoBlue: MORPHO_BLUE_CANONICAL
+      },
       [MORPHO_MIDNIGHT_BASE_CHAIN_ID]: {
-        midnight: "0xadedd8ab6de832766fedf0fac4992e5c4d3ea18a",
-        bundles: "0x6688dEc8878f43905e11B3C6Bc025E098133144f"
+        midnight: "0xAdedD8ab6dE832766Fedf0FaC4992E5C4D3EA18A",
+        bundles: "0x091183d729BE9f808c212b475E387A12E67850A7",
+        mempool: "0xdD6DCE32e21f7b020898a8258dA37355b4017993",
+        setterRatifier: "0x800B5F12A61B8198a5a6EfD794Cac6699B294d63",
+        ecrecoverRatifier: "0xd6e70365C8E8DDa9a4ca662C07bbE663b017755E",
+        blueBuyCallbackFactory: "0x7337f119Eca028bD39E0e543cEf71631D2333425",
+        morphoBlue: MORPHO_BLUE_CANONICAL
       }
     };
     TOKEN_PERMIT_NONE = { kind: 0, data: "0x" };
@@ -134,6 +162,12 @@ var init_midnightConstants = __esm({
     MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS = 80000n;
     MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK = 100000n;
     MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK = 120000n;
+    MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS = 1200000n;
+    MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS = 400000n;
+    MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS = 350000n;
+    MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS = 80000n;
+    MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS = 250000n;
+    MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS = 80000n;
   }
 });
 
@@ -143,6 +177,7 @@ __export(midnightApi_exports, {
   fetchMorphoMidnightBook: () => fetchMorphoMidnightBook,
   fetchMorphoMidnightBookQuote: () => fetchMorphoMidnightBookQuote,
   fetchMorphoMidnightBooks: () => fetchMorphoMidnightBooks,
+  fetchMorphoMidnightMakerOffers: () => fetchMorphoMidnightMakerOffers,
   fetchMorphoMidnightMarketById: () => fetchMorphoMidnightMarketById,
   fetchMorphoMidnightUserMarketPosition: () => fetchMorphoMidnightUserMarketPosition,
   fetchMorphoMidnightUserPositions: () => fetchMorphoMidnightUserPositions,
@@ -284,6 +319,39 @@ async function fetchMorphoMidnightUserPositions(args) {
   }
   return rows;
 }
+async function fetchMorphoMidnightMakerOffers(args) {
+  const qs = new URLSearchParams();
+  qs.set("maker", viem.getAddress(args.maker));
+  if (args.chainId != null) qs.set("chain_ids", String(args.chainId));
+  const j = await midnightGetJson(`/takeable-offers?${qs}`);
+  const out = [];
+  for (const row of j.data ?? []) {
+    const o = row.offer;
+    if (!o?.maker || !viem.isAddress(o.maker) || !o.market?.loan_token || !viem.isAddress(o.market.loan_token)) continue;
+    if (!o.market.midnight || !viem.isAddress(o.market.midnight)) continue;
+    const group = (o.group ?? "").trim();
+    if (!group.startsWith("0x") || group.length !== 66) continue;
+    const callback = o.callback && viem.isAddress(o.callback) ? viem.getAddress(o.callback) : "0x0000000000000000000000000000000000000000";
+    out.push({
+      marketId: String(row.market_id ?? ""),
+      chainId: Number(o.market.chain_id ?? args.chainId ?? 0),
+      midnight: viem.getAddress(o.market.midnight),
+      loanToken: viem.getAddress(o.market.loan_token),
+      maker: viem.getAddress(o.maker),
+      buy: o.buy === true,
+      tick: String(o.tick ?? "0"),
+      maxAssets: String(o.max_assets ?? "0"),
+      maxUnits: String(o.max_units ?? "0"),
+      expiry: Number(o.expiry ?? 0),
+      group,
+      callback,
+      callbackData: o.callback_data ?? "0x",
+      units: String(row.units ?? "0"),
+      maturity: o.market.maturity != null ? Number(o.market.maturity) : null
+    });
+  }
+  return out;
+}
 async function fetchMorphoMidnightUserMarketPosition(args) {
   const marketId = args.marketId.trim();
   const user = args.user.trim();
@@ -921,7 +989,7 @@ var evmMultisignCommonInputSchema = zod.z.object({
   chainDetail: chainDetailSchema.optional().describe("Server-filled gas row from chain registry when keyGenId is set."),
   customGasChainDetails: zod.z.record(zod.z.unknown()).optional().describe("Snapshot written to extraJSON.customGasChainDetails when useCustomGas is true."),
   expiryDate: zod.z.number().int().positive().optional().describe(
-    "Optional Unix seconds (UTC) when the MPC sign request expires. Uniswap V4, GMX, Hyperliquid, and Curve DAO default to 30 minutes when omitted; other protocols use the node default (7 days)."
+    "Optional Unix seconds (UTC) when the MPC sign request expires. Uniswap V4, GMX, Hyperliquid, Curve DAO, and Aerodrome default to 30 minutes when omitted; other protocols use the node default (7 days)."
   )
 });
 function withMultisignKeySourceRefine(schema) {
@@ -1657,6 +1725,182 @@ var mcpCurveDaoBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
     })
   )
 );
+var chain8453 = agentEvmChainIdSchema.describe("Must be 8453 (Base). Aerodrome is Base-only.");
+var rpcUrlOptional = zod.z.string().min(1).optional().describe("JSON-RPC URL; continuum-mcp-server injects from chain registry \u2014 do not pass a public RPC URL");
+var mcpAerodromeDiscoverPoolsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  token: zod.z.string().min(1).describe("Ticker or 0x address to find pools for (AAPLc, USDC, ETH, WETH, AERO)."),
+  tokenOut: zod.z.string().min(1).optional().describe("Optional counterpart. Defaults to USDC so B20 stocks resolve. Tickers OK.")
+});
+var mcpAerodromeDiscoverPoolsOutputSchema = jsonObjectSchema.describe(
+  "{ token, tokenOut, pools[] (lp, kind, tickSpacing, factory), notes }. Factory getPool only \u2014 not LpSugar. Then call ctm_aerodrome_quote."
+);
+var mcpAerodromeFetchPoolsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  limit: zod.z.number().int().positive().max(200).optional(),
+  offset: zod.z.number().int().min(0).optional()
+});
+var mcpAerodromeFetchPoolsOutputSchema = jsonObjectSchema.describe("{ chainId, pools[] }");
+var mcpAerodromeFetchPositionsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  account: evmAddressSchema.optional(),
+  executorAddress: evmAddressSchema.optional().describe("Server-filled from keyGenId when omitted")
+});
+var mcpAerodromeFetchPositionsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, account, notes, positions[] } \u2014 each row has label (vAMM-USDC/AERO \xB7 #id), kind, gauge, stakedInGauge, claimFees.pool, claimEmissions (gauge + tokenId/cl for Slipstream, or null if no gauge). Dust v2 rows omitted."
+);
+var mcpAerodromeQuoteInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  tokenIn: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address. Native: 0x0 / eth. B20 stocks need no address lookup."),
+  tokenOut: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address. Native: 0x0 / eth."),
+  amountHuman: zod.z.string().min(1).describe("Human-readable amount of tokenIn (B20 stocks are 8 decimals)"),
+  tokenInDecimals: zod.z.number().int().min(0).max(18).optional().describe("Optional override. Omit for known tickers \u2014 AAPLc and other B20 stocks always use 8.")
+});
+var mcpAerodromeQuoteOutputSchema = jsonObjectSchema.describe(
+  "{ tokenIn, tokenOut, amountInWei, amountOutWei, amountOutHuman, priceImpactPercent (0\u2013100 vs a tiny same-route probe, or null), hops, pathPacked, isNativeIn, isNativeOut, source }"
+);
+var mcpAerodromeBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address / 0x0 native"),
+    tokenOut: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address / 0x0 native"),
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    quoteSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpAerodromeQuoteAddLiquidityInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  tokenA: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native"),
+  tokenB: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native"),
+  stable: agentBooleanSchema(false),
+  amountAHuman: zod.z.string().optional().describe("Human amount of tokenA. Omit to solve from tokenB (one-sided, same as the dialog)."),
+  amountBHuman: zod.z.string().optional().describe("Human amount of tokenB. Omit to solve from tokenA (one-sided, same as the dialog)."),
+  tokenADecimals: zod.z.number().int().min(0).max(18).optional(),
+  tokenBDecimals: zod.z.number().int().min(0).max(18).optional()
+}).refine((v) => Boolean((v.amountAHuman ?? "").trim() || (v.amountBHuman ?? "").trim()), {
+  message: "Enter amountAHuman or amountBHuman. The other side is filled from the current vAMM, sAMM, or Slipstream pool."
+});
+var mcpAerodromeQuoteAddLiquidityOutputSchema = jsonObjectSchema.describe(
+  "{ tokenA, tokenB, amountAHuman, amountBHuman, kind (stable|volatile|cl), tickSpacing?, emptyPool, seedable, hint }. seedable:false = do not first-deposit (ETH/AAPLc has no pool \u2014 pair vs USDC). kind:cl is a Slipstream ratio; basic addLiquidity is v2 only."
+);
+var mcpAerodromeQuoteClDepositInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  token0: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+  token1: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+  amount0Human: zod.z.string().optional(),
+  amount1Human: zod.z.string().optional(),
+  tickSpacing: zod.z.number().int(),
+  tickLower: zod.z.number().int(),
+  tickUpper: zod.z.number().int(),
+  sqrtPriceX96: zod.z.string().min(1).describe("0 if the CL pool already exists")
+});
+var mcpAerodromeQuoteClDepositOutputSchema = jsonObjectSchema;
+var mcpAerodromeBuildAddLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenA: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+    tokenB: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+    stable: agentBooleanSchema(false),
+    amountAHuman: zod.z.string().optional().describe("Omit to solve from amountBHuman (one-sided)."),
+    amountBHuman: zod.z.string().optional().describe("Omit to solve from amountAHuman (one-sided)."),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  }).refine((v) => Boolean((v.amountAHuman ?? "").trim() || (v.amountBHuman ?? "").trim()), {
+    message: "Enter amountAHuman or amountBHuman."
+  })
+);
+var mcpAerodromeBuildRemoveLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenA: zod.z.string().min(1),
+    tokenB: zod.z.string().min(1),
+    stable: agentBooleanSchema(false),
+    lpToken: evmAddressSchema,
+    liquidityHuman: zod.z.string().min(1),
+    lpDecimals: zod.z.number().int().min(0).max(18).optional(),
+    amountAMinHuman: zod.z.string().optional(),
+    amountBMinHuman: zod.z.string().optional()
+  })
+);
+var mcpAerodromeBuildClMintMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    token0: zod.z.string().min(1),
+    token1: zod.z.string().min(1),
+    amount0Human: zod.z.string().optional(),
+    amount1Human: zod.z.string().optional(),
+    tickSpacing: zod.z.number().int(),
+    tickLower: zod.z.number().int(),
+    tickUpper: zod.z.number().int(),
+    sqrtPriceX96: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  })
+);
+var mcpAerodromeBuildClIncreaseMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1),
+    token0: zod.z.string().min(1),
+    token1: zod.z.string().min(1),
+    amount0Wei: zod.z.string().min(1),
+    amount1Wei: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  })
+);
+var mcpAerodromeBuildClDecreaseMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1),
+    liquidity: zod.z.string().min(1),
+    amount0MinWei: zod.z.string().optional(),
+    amount1MinWei: zod.z.string().optional()
+  })
+);
+var mcpAerodromeBuildClBurnMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1)
+  })
+);
+var mcpAerodromeBuildGaugeStakeMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    gauge: evmAddressSchema,
+    lpToken: evmAddressSchema.optional(),
+    amountHuman: zod.z.string().optional(),
+    lpDecimals: zod.z.number().int().min(0).max(18).optional(),
+    tokenId: zod.z.string().optional(),
+    cl: agentBooleanSchema(false)
+  })
+);
+var mcpAerodromeBuildGaugeUnstakeMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    gauge: evmAddressSchema,
+    amountHuman: zod.z.string().optional(),
+    lpDecimals: zod.z.number().int().min(0).max(18).optional(),
+    tokenId: zod.z.string().optional(),
+    cl: agentBooleanSchema(false)
+  })
+);
+var mcpAerodromeBuildClaimFeesMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pool: evmAddressSchema.describe(
+      "Pool (lp) from ctm_aerodrome_fetch_positions claimFees.pool \u2014 not the gauge. Dialog: \u201CFees from the pool\u201D."
+    )
+  })
+);
+var mcpAerodromeBuildClCollectFeesMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1)
+  })
+);
+var mcpAerodromeBuildClaimEmissionsMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    gauge: evmAddressSchema.describe(
+      "Gauge from fetch_positions claimEmissions.gauge \u2014 not the pool. Dialog: \u201CEmissions from the gauge in AERO\u201D. Skip if claimEmissions is null."
+    ),
+    tokenId: zod.z.string().optional().describe("Required for Slipstream staked positions (claimEmissions.tokenId)."),
+    cl: agentBooleanSchema(false).describe("true when claimEmissions.cl (Slipstream NFT getReward).")
+  })
+);
 
 // src/protocols/evm/morpho/robinhoodEarn.ts
 var ROBINHOOD_CHAIN_ID = 4663;
@@ -1833,6 +2077,23 @@ function preprocessMorphoMidnightBorrowInput(raw) {
   }
   return o;
 }
+function preprocessMorphoMidnightLendOfferInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) {
+    const amt = String(o.amountHuman ?? "").trim();
+    if (amt) o.purposeText = `Morpho Midnight lend offer ${amt}`;
+  }
+  return o;
+}
+function preprocessMorphoMidnightCancelLendOfferInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) o.purposeText = "Morpho Midnight cancel lend offer";
+  return o;
+}
 function preprocessMorphoMidnightRepayInput(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
   const o = { ...raw };
@@ -1914,6 +2175,34 @@ var mcpMorphoFetchMidnightPositionsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpMorphoFetchMidnightOffersInputSchema = zod.z.object({
+  user: zod.z.string().min(1).describe("Maker EVM address"),
+  chainId: agentEvmChainIdSchema.optional()
+});
+var mcpMorphoFetchMidnightOffersOutputSchema = zod.z.object({
+  offers: zod.z.array(
+    zod.z.object({
+      marketId: zod.z.string(),
+      chainId: zod.z.number().int(),
+      midnightAddress: zod.z.string(),
+      loanTokenAddress: zod.z.string(),
+      maker: zod.z.string(),
+      group: zod.z.string().describe("Pass to ctm_morpho_build_midnight_cancel_lend_offer_multisign"),
+      callback: zod.z.string(),
+      callbackData: zod.z.string(),
+      tick: zod.z.string(),
+      maxAssets: zod.z.string(),
+      remainingUnits: zod.z.string(),
+      expiry: zod.z.number(),
+      expiryIso: zod.z.string(),
+      maturity: zod.z.number().nullable(),
+      maturityIso: zod.z.string(),
+      lendApr: zod.z.string(),
+      lendAprNumeric: zod.z.number().nullable(),
+      marketLabel: zod.z.string()
+    })
+  )
+});
 var mcpServerCommonInputSchema = zod.z.object({
   keyGenId: zod.z.string().min(1).describe("KeyGen id from fetch_key_gen_result / node preferred KeyGen"),
   chainId: zod.z.number().int().positive().describe("EVM chain id; RPC and gas config resolved from chain registry"),
@@ -2293,6 +2582,35 @@ var mcpMorphoMidnightBorrowInputSchema = withMultisignKeySourceRefine(
     })
   )
 );
+var mcpMorphoMidnightLendOfferInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightLendOfferInput,
+    evmMultisignCommonInputSchema.extend({
+      marketId: zod.z.string().min(1).describe("marketId from ctm_morpho_fetch_midnight_books"),
+      amountHuman: zod.z.string().min(1).describe("Loan-token amount to park in Blue and quote on Midnight"),
+      loanToken: evmAddressSchema.optional(),
+      lendAprPct: zod.z.string().optional().describe("Target fixed lend APR percent, e.g. 5.2. Defaults to book best bid."),
+      tick: zod.z.string().optional().describe("Override Midnight tick (takes precedence over lendAprPct)"),
+      blueMarketId: zod.z.string().optional().describe("Morpho Blue market to earn variable yield until the offer fills"),
+      expirySeconds: agentCoercedOptionalIntSchema(zod.z.number().int().min(60)),
+      marketLabel: zod.z.string().optional(),
+      isNativeIn: agentOptionalBooleanSchema()
+    })
+  )
+);
+var mcpMorphoMidnightCancelLendOfferInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightCancelLendOfferInput,
+    evmMultisignCommonInputSchema.extend({
+      group: zod.z.string().min(1).describe("Offer group id from ctm_morpho_fetch_midnight_offers"),
+      callback: evmAddressSchema.optional(),
+      callbackData: zod.z.string().optional().describe("Hex Blue MarketParams from the offer row"),
+      midnight: evmAddressSchema.optional(),
+      withdrawRemaining: agentOptionalBooleanSchema(),
+      marketLabel: zod.z.string().optional()
+    })
+  )
+);
 var mcpMorphoMidnightRepayInputSchema = withMultisignKeySourceRefine(
   zod.z.preprocess(
     preprocessMorphoMidnightRepayInput,
@@ -2794,6 +3112,96 @@ var mcpEulerV2FetchLendVaultsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpCompoundV3FetchMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpCompoundV3MarketAssetSchema = zod.z.object({
+  asset: zod.z.string(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number(),
+  borrowCollateralFactorPercent: zod.z.number(),
+  liquidateCollateralFactorPercent: zod.z.number(),
+  priceRaw: zod.z.string(),
+  role: zod.z.enum(["base", "collateral"])
+});
+var mcpCompoundV3MarketSummarySchema = zod.z.object({
+  chainId: zod.z.number(),
+  slug: zod.z.string(),
+  symbol: zod.z.string(),
+  comet: zod.z.string().describe("Comet proxy \u2014 copy as comet for write tools"),
+  rewards: zod.z.string(),
+  bulker: zod.z.string().nullable(),
+  baseToken: zod.z.string().nullable(),
+  utilization: zod.z.number().nullable(),
+  supplyAprPercent: zod.z.string().nullable(),
+  borrowAprPercent: zod.z.string().nullable(),
+  assets: zod.z.array(mcpCompoundV3MarketAssetSchema)
+});
+var mcpCompoundV3FetchMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpCompoundV3MarketSummarySchema),
+  notes: zod.z.string()
+});
+var mcpCompoundV3FetchMarketInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets"),
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpCompoundV3FetchMarketOutputSchema = mcpCompoundV3MarketSummarySchema;
+var mcpCompoundV3FetchAccountInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets"),
+  account: evmAddressSchema.describe("MPC executor / user address"),
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpCompoundV3FetchAccountOutputSchema = zod.z.object({
+  comet: zod.z.string(),
+  symbol: zod.z.string(),
+  baseSupplied: zod.z.string(),
+  baseBorrowed: zod.z.string(),
+  collaterals: zod.z.array(
+    zod.z.object({
+      asset: zod.z.string(),
+      symbol: zod.z.string(),
+      balance: zod.z.string()
+    })
+  ),
+  isBorrowCollateralized: zod.z.boolean(),
+  isLiquidatable: zod.z.boolean(),
+  rewardToken: zod.z.string().nullable(),
+  rewardOwed: zod.z.string().nullable()
+});
+var compoundV3WriteFields = {
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets. Never the implementation."),
+  asset: evmAddressSchema.describe(
+    "Token to supply/withdraw. Native ETH: 0x0000000000000000000000000000000000000000 or set isNative true."
+  ),
+  amountHuman: zod.z.string().min(1).describe('Human amount (e.g. "100"). Withdraw base while undercollateralized borrows.'),
+  isNative: agentOptionalBooleanSchema().describe(
+    "Wrap/unwrap native ETH automatically (WETH.deposit/withdraw). Independent of useBulker."
+  ),
+  isNativeIn: agentOptionalBooleanSchema().describe("Alias of isNative for supply/repay."),
+  useBulker: agentOptionalBooleanSchema().describe(
+    "If true, prefer ctm_compound_v3_build_bulker_multisign for combined actions. ETH wrap still works when false."
+  )
+};
+var mcpCompoundV3SupplyInputSchema = mcpMultisignInput(compoundV3WriteFields);
+var mcpCompoundV3WithdrawInputSchema = mcpMultisignInput(compoundV3WriteFields);
+var mcpCompoundV3RepayInputSchema = mcpMultisignInput(compoundV3WriteFields);
+var mcpCompoundV3ClaimRewardsInputSchema = mcpMultisignInput({
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets")
+});
+var mcpCompoundV3BulkerInputSchema = mcpMultisignInput({
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets"),
+  steps: zod.z.array(
+    zod.z.object({
+      action: zod.z.enum(["supply", "withdraw", "claim"]),
+      asset: evmAddressSchema.optional(),
+      amountHuman: zod.z.string().optional(),
+      isNative: agentOptionalBooleanSchema()
+    })
+  ).min(1).describe("Combined Bulker actions. Native supply/withdraw uses Bulker native token actions.")
+});
 function mcpGmxMultisignInput(fields, preprocess) {
   const inner = evmMultisignCommonInputSchema.extend(fields);
   const shaped = preprocess ? zod.z.preprocess(preprocess, inner) : inner;
@@ -4078,6 +4486,26 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightLendBatch" },
     inputZod: mcpMorphoMidnightLendInputSchema
   }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_lend_offer_multisign",
+    actionId: "morpho.midnight-lend-offer",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build a Morpho Midnight lend limit offer. Parks the loan token in Morpho Blue (variable yield) until a borrower takes the offer via BlueBuyCallback.",
+    prerequisites: ["keyGenId", "chainId", "marketId from ctm_morpho_fetch_midnight_books", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightLendOfferBatch" },
+    inputZod: mcpMorphoMidnightLendOfferInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_cancel_lend_offer_multisign",
+    actionId: "morpho.midnight-cancel-lend-offer",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Cancel a Morpho Midnight lend offer (exhaust the offer group) and withdraw unused Blue-parked funds.",
+    prerequisites: ["keyGenId", "chainId", "group from ctm_morpho_fetch_midnight_offers"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightCancelLendOfferBatch" },
+    inputZod: mcpMorphoMidnightCancelLendOfferInputSchema
+  }),
   defineProtocolMcpTool({
     name: "ctm_morpho_build_midnight_borrow_multisign",
     actionId: "morpho.midnight-borrow",
@@ -4650,6 +5078,56 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     followUp: [...MCP_MULTISIGN_SUBMIT_FOLLOW_UP, "ctm_continuum_dao_forum_me"],
     handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoForumSignIn" },
     inputZod: mcpContinuumDaoForumSignInInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_supply_multisign",
+    actionId: "compound-v3.supply",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Supply base (earn or repay) or collateral to a Comet proxy. Native ETH always wraps via WETH.deposit even when useBulker is false.",
+    prerequisites: ["keyGenId", "chainId", "comet from ctm_compound_v3_fetch_markets", "asset", "amountHuman"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Supply" },
+    inputZod: mcpCompoundV3SupplyInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_withdraw_multisign",
+    actionId: "compound-v3.withdraw",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Withdraw collateral or base from a Comet. Withdraw of base while undercollateralized borrows. Native ETH always unwraps via WETH.withdraw.",
+    prerequisites: ["keyGenId", "chainId", "comet", "asset", "amountHuman", "ctm_compound_v3_fetch_account"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Withdraw" },
+    inputZod: mcpCompoundV3WithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_repay_multisign",
+    actionId: "compound-v3.repay",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Repay Comet base debt by supplying the base asset (same as supply of base while borrowed).",
+    prerequisites: ["keyGenId", "chainId", "comet", "asset (base token)", "amountHuman"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Repay" },
+    inputZod: mcpCompoundV3RepayInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_claim_rewards_multisign",
+    actionId: "compound-v3.claim-rewards",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Claim COMP / reward token from the market Rewards contract.",
+    prerequisites: ["keyGenId", "chainId", "comet", "ctm_compound_v3_fetch_account for claimable"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3ClaimRewards" },
+    inputZod: mcpCompoundV3ClaimRewardsInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_bulker_multisign",
+    actionId: "compound-v3.bulker",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Optional combined Bulker.invoke (supply + borrow, claim + withdraw, native via Bulker). ETH wrap still works without this tool.",
+    prerequisites: ["keyGenId", "chainId", "comet", "steps"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Bulker" },
+    inputZod: mcpCompoundV3BulkerInputSchema
   })
 ];
 
@@ -5027,6 +5505,210 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveDaoBatch" },
     inputZod: mcpCurveDaoBuildSwapMultisignInputSchema
   }),
+  defineMcpTool({
+    name: "ctm_aerodrome_discover_pools",
+    actionId: "aerodrome.discover-pools",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Find Aerodrome v2 + Slipstream pools for one token (optional tokenOut, default USDC) via factory getPool. Tickers OK (AAPLc, USDC, ETH). Use this instead of dumping listed tokens or LpSugar.all. For a price, skip this and call ctm_aerodrome_quote. rpcUrl is injected.",
+    prerequisites: ["chainId 8453", "token (ticker or 0x)"],
+    followUp: ["ctm_aerodrome_quote", "ctm_aerodrome_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeDiscoverPoolsSummary" },
+    inputZod: mcpAerodromeDiscoverPoolsInputSchema,
+    outputZod: mcpAerodromeDiscoverPoolsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_fetch_pools",
+    actionId: "aerodrome.fetch-pools",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Paginated LpSugar.all pool dump on Base. Heavy \u2014 can time out. Not required for swaps: ctm_aerodrome_quote discovers Slipstream 3 / v2 routes itself (including AAPLc/USDC). Use only when browsing LP inventory.",
+    prerequisites: ["chainId 8453"],
+    followUp: ["ctm_aerodrome_quote_add_liquidity", "ctm_aerodrome_fetch_positions"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeFetchPoolsSummary" },
+    inputZod: mcpAerodromeFetchPoolsInputSchema,
+    outputZod: mcpAerodromeFetchPoolsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_fetch_positions",
+    actionId: "aerodrome.fetch-positions",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "KeyGen Aerodrome positions (same picker as the Multi-Sign Rewards tab). Each row has label, kind (vAMM/sAMM/CL), gauge, stakedInGauge, claimFees.pool, and claimEmissions (gauge + tokenId/cl, or null). Dust v2 rows omitted. Read-only.",
+    prerequisites: ["chainId 8453", "account or keyGenId"],
+    followUp: [
+      "ctm_aerodrome_build_claim_fees_multisign",
+      "ctm_aerodrome_build_claim_emissions_multisign",
+      "ctm_aerodrome_build_cl_collect_fees_multisign"
+    ],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeFetchPositionsSummary" },
+    inputZod: mcpAerodromeFetchPositionsInputSchema,
+    outputZod: mcpAerodromeFetchPositionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_quote",
+    actionId: "aerodrome.quote",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Quote an Aerodrome swap on Base. tokenIn/tokenOut accept tickers (AAPLc, USDC, ETH, WETH, AERO) or 0x addresses. Coinbase B20 stocks are 8 decimals and route via Slipstream 3 (usually a USDC hop). Returns amountOutHuman and priceImpactPercent (0\u2013100 vs a tiny same-route probe). Call this directly \u2014 do not fetch_pools or ask the user for a stock address. Does NOT create a sign request.",
+    prerequisites: ["chainId 8453", "tokenIn + tokenOut + amountHuman (tickers OK)"],
+    followUp: ["ctm_aerodrome_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeQuote" },
+    inputZod: mcpAerodromeQuoteInputSchema,
+    outputZod: mcpAerodromeQuoteOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_swap_multisign",
+    actionId: "aerodrome.swap",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for an Aerodrome swap (optional ERC-20 approve + Router / Slipstream SwapRouter). Default deadline 30 minutes \u2014 ask the user to confirm that window and useCustomGas (via get_multi_sign_gas_options) before calling. Activate aerodrome:swap first.",
+    prerequisites: [
+      "ctm_aerodrome_quote",
+      "get_multi_sign_gas_options + user confirms useCustomGas and 30-minute deadline",
+      "keyGenId + chainId 8453 + purposeText + slippagePercent"
+    ],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeSwapBatch" },
+    inputZod: mcpAerodromeBuildSwapMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_quote_add_liquidity",
+    actionId: "aerodrome.quote-add-liquidity",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Quote an Aerodrome deposit on Base (same as the Liquidity tab). One-sided: pass amountAHuman or amountBHuman; the other side comes from the current vAMM/sAMM reserves or Slipstream slot0. Tickers OK (AAPLc, USDC, ETH). B20 stocks are 8 decimals. ETH/stock has no pool \u2014 seedable:false and hint says pair vs USDC. Do not first-deposit an empty vAMM. Read-only.",
+    prerequisites: ["chainId 8453", "tokenA + tokenB + amountAHuman or amountBHuman (tickers OK)"],
+    followUp: ["ctm_aerodrome_build_add_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeQuoteAddLiquidity" },
+    inputZod: mcpAerodromeQuoteAddLiquidityInputSchema,
+    outputZod: mcpAerodromeQuoteAddLiquidityOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_quote_cl_deposit",
+    actionId: "aerodrome.quote-cl-deposit",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Quote a Slipstream CL deposit (SugarHelper estimate when one side is omitted). token0/token1 accept tickers (AAPLc, USDC, ETH). Use when quote_add_liquidity returns kind:cl. Read-only.",
+    prerequisites: ["chainId 8453", "ticks + sqrtPriceX96"],
+    followUp: ["ctm_aerodrome_build_cl_mint_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeQuoteClDeposit" },
+    inputZod: mcpAerodromeQuoteClDepositInputSchema,
+    outputZod: mcpAerodromeQuoteClDepositOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_add_liquidity_multisign",
+    actionId: "aerodrome.add-liquidity",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to add basic vAMM/sAMM liquidity (approve + addLiquidity / addLiquidityETH). One-sided amounts OK. Refuses empty/unseedable pairs (ETH/AAPLc) and Slipstream-only quotes (use CL mint). Activate aerodrome:lp first.",
+    prerequisites: [
+      "ctm_aerodrome_quote_add_liquidity",
+      "get_multi_sign_gas_options + user confirms useCustomGas and 30-minute deadline",
+      "keyGenId + purposeText + slippagePercent"
+    ],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeAddLiquidityBatch" },
+    inputZod: mcpAerodromeBuildAddLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_remove_liquidity_multisign",
+    actionId: "aerodrome.remove-liquidity",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to remove basic-pool liquidity.",
+    prerequisites: ["keyGenId", "lpToken + liquidityHuman"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeRemoveLiquidityBatch" },
+    inputZod: mcpAerodromeBuildRemoveLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_mint_multisign",
+    actionId: "aerodrome.cl-mint",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to mint a Slipstream concentrated liquidity NFT.",
+    prerequisites: ["ctm_aerodrome_quote_cl_deposit", "keyGenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClMintBatch" },
+    inputZod: mcpAerodromeBuildClMintMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_increase_multisign",
+    actionId: "aerodrome.cl-increase",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to increase Slipstream liquidity.",
+    prerequisites: ["keyGenId", "tokenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClIncreaseBatch" },
+    inputZod: mcpAerodromeBuildClIncreaseMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_decrease_multisign",
+    actionId: "aerodrome.cl-decrease",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to decrease Slipstream liquidity.",
+    prerequisites: ["keyGenId", "tokenId + liquidity"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClDecreaseBatch" },
+    inputZod: mcpAerodromeBuildClDecreaseMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_burn_multisign",
+    actionId: "aerodrome.cl-burn",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to burn an empty Slipstream position NFT.",
+    prerequisites: ["keyGenId", "tokenId (liquidity withdrawn, fees collected)"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClBurnBatch" },
+    inputZod: mcpAerodromeBuildClBurnMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_gauge_stake_multisign",
+    actionId: "aerodrome.gauge-stake",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to stake basic LP tokens or a Slipstream NFT in a gauge.",
+    prerequisites: ["keyGenId", "gauge + lpToken or tokenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeGaugeStakeBatch" },
+    inputZod: mcpAerodromeBuildGaugeStakeMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_gauge_unstake_multisign",
+    actionId: "aerodrome.gauge-unstake",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to unstake from an Aerodrome gauge.",
+    prerequisites: ["keyGenId", "gauge"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeGaugeUnstakeBatch" },
+    inputZod: mcpAerodromeBuildGaugeUnstakeMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_claim_fees_multisign",
+    actionId: "aerodrome.claim-fees",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Claim unstaked fees from the pool (dialog: \u201CFees from the pool\u201D). Pass claimFees.pool from ctm_aerodrome_fetch_positions \u2014 not the gauge. Activate aerodrome:rewards first.",
+    prerequisites: ["ctm_aerodrome_fetch_positions", "keyGenId + purposeText + pool=claimFees.pool"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClaimFeesBatch" },
+    inputZod: mcpAerodromeBuildClaimFeesMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_collect_fees_multisign",
+    actionId: "aerodrome.cl-collect-fees",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Collect Slipstream NFT fees via NFPM.collect. Pass the position id from fetch_positions (kind:cl). Activate aerodrome:rewards first.",
+    prerequisites: ["ctm_aerodrome_fetch_positions", "keyGenId + tokenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClCollectBatch" },
+    inputZod: mcpAerodromeBuildClCollectFeesMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_claim_emissions_multisign",
+    actionId: "aerodrome.claim-emissions",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Claim gauge emissions in AERO (dialog: \u201CEmissions from the gauge in AERO\u201D). Pass claimEmissions from ctm_aerodrome_fetch_positions (gauge; CL staked also needs tokenId + cl:true). Skip when claimEmissions is null. Activate aerodrome:rewards first.",
+    prerequisites: ["ctm_aerodrome_fetch_positions", "keyGenId + purposeText + gauge=claimEmissions.gauge"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClaimEmissionsBatch" },
+    inputZod: mcpAerodromeBuildClaimEmissionsMultisignInputSchema
+  }),
   defineMcpTool({
     name: "ctm_gmx_fetch_markets",
     actionId: "gmx.fetch-markets",
@@ -5445,6 +6127,7 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     followUp: [
       "ctm_morpho_fetch_midnight_quote",
       "ctm_morpho_build_midnight_lend_multisign",
+      "ctm_morpho_build_midnight_lend_offer_multisign",
       "ctm_morpho_build_midnight_borrow_multisign"
     ],
     handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightBooksSummary" },
@@ -5458,7 +6141,11 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     chainCategory: "evm",
     description: "Quote a Morpho Midnight book fill. side asks = lend, bids = borrow. assets is raw loan-token units.",
     prerequisites: ["marketId from ctm_morpho_fetch_midnight_books", "assets raw amount"],
-    followUp: ["ctm_morpho_build_midnight_lend_multisign", "ctm_morpho_build_midnight_borrow_multisign"],
+    followUp: [
+      "ctm_morpho_build_midnight_lend_multisign",
+      "ctm_morpho_build_midnight_lend_offer_multisign",
+      "ctm_morpho_build_midnight_borrow_multisign"
+    ],
     handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightQuoteSummary" },
     inputZod: mcpMorphoFetchMidnightQuoteInputSchema,
     outputZod: mcpMorphoFetchMidnightQuoteOutputSchema
@@ -5475,6 +6162,18 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpMorphoFetchMidnightPositionsInputSchema,
     outputZod: mcpMorphoFetchMidnightPositionsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_morpho_fetch_midnight_offers",
+    actionId: "morpho.fetch-midnight-offers",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Open Morpho Midnight maker lend offers for a user. Use group/callback/callbackData to cancel and withdraw unused Blue park.",
+    prerequisites: ["user address"],
+    followUp: ["ctm_morpho_build_midnight_cancel_lend_offer_multisign"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightMakerOffersSummary" },
+    inputZod: mcpMorphoFetchMidnightOffersInputSchema,
+    outputZod: mcpMorphoFetchMidnightOffersOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_euler_v2_fetch_lend_vaults",
     actionId: "euler-v2.fetch-lend-vaults",
@@ -5937,6 +6636,47 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumSections" },
     inputZod: mcpContinuumDaoForumSectionsInputSchema,
     outputZod: mcpContinuumDaoForumSectionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_compound_v3_fetch_markets",
+    actionId: "compound-v3.fetch-markets",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "List Compound III Comet markets on a chain. Each market has one borrowable base and a collateral list \u2014 use this (not web search) to answer what you can borrow against an asset or which collaterals a Comet accepts. Copy comet for fetch_market / fetch_account / build_*_multisign.",
+    prerequisites: ["chainId", "get_defi_protocol_supported_chains"],
+    followUp: ["ctm_compound_v3_fetch_market", "ctm_compound_v3_fetch_account"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchMarketsSummary" },
+    inputZod: mcpCompoundV3FetchMarketsInputSchema,
+    outputZod: mcpCompoundV3FetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_compound_v3_fetch_market",
+    actionId: "compound-v3.fetch-market",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "One Comet: collateral list (what backs a borrow), collateral factors, prices, utilization, supply/borrow APR. Base is the only borrowable asset. Always uses the Comet proxy + CometInterface.",
+    prerequisites: ["comet from ctm_compound_v3_fetch_markets", "rpcUrl from chain registry"],
+    followUp: ["ctm_compound_v3_fetch_account", "ctm_compound_v3_build_supply_multisign"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchMarketSummary" },
+    inputZod: mcpCompoundV3FetchMarketInputSchema,
+    outputZod: mcpCompoundV3FetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_compound_v3_fetch_account",
+    actionId: "compound-v3.fetch-account",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "User position on a Comet: base supplied, base borrowed, each collateral, isBorrowCollateralized, isLiquidatable, claimable rewards.",
+    prerequisites: ["comet from ctm_compound_v3_fetch_markets", "account", "rpcUrl from chain registry"],
+    followUp: [
+      "ctm_compound_v3_build_supply_multisign",
+      "ctm_compound_v3_build_withdraw_multisign",
+      "ctm_compound_v3_build_repay_multisign",
+      "ctm_compound_v3_build_claim_rewards_multisign"
+    ],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchAccountSummary" },
+    inputZod: mcpCompoundV3FetchAccountInputSchema,
+    outputZod: mcpCompoundV3FetchAccountOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -7085,6 +7825,8 @@ var morphoProtocolModule = {
     { id: "morpho.fetch-midnight-quote", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Quote Morpho Midnight lend/borrow fill", commonParams: [], params: {} },
     { id: "morpho.fetch-midnight-positions", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "List Morpho Midnight user positions", commonParams: [], params: {} },
     { id: "morpho.midnight-lend", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate lend (take asks)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-lend-offer", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight lend limit offer parked in Blue until filled", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-cancel-lend-offer", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Cancel a Morpho Midnight lend offer and withdraw unused Blue park", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (supply collateral + take bids)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.midnight-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight repay debt and withdraw collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
   ]
@@ -7360,6 +8102,141 @@ var veniceProtocolModule = {
   ]
 };
 registerProtocolModule(veniceProtocolModule);
+var AERODROME_PROTOCOL_ID = "aerodrome";
+var AERODROME_CHAIN_ID = 8453;
+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;
+}
+var AERODROME_BASE_ADDRESSES_FALLBACK = {
+  aero: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"};
+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;
+
+// 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);
 var CONTINUUM_DAO_PROTOCOL_ID = "continuum-dao";
 var CONTINUUM_DAO_ETHEREUM_CHAIN_ID = 1;
 var CONTINUUM_DAO_LINEA_CHAIN_ID = 59144;
@@ -7492,6 +8369,617 @@ var continuumDaoProtocolModule = {
   ]
 };
 registerProtocolModule(continuumDaoProtocolModule);
+var COMPOUND_V3_PROTOCOL_ID = "compound-v3";
+var COMPOUND_V3_CHAIN_IDS = [1, 8453, 42161, 10, 137, 5e3, 130, 59144];
+var COMPOUND_V3_WRAPPED_NATIVE = {
+  1: viem.getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  8453: viem.getAddress("0x4200000000000000000000000000000000000006"),
+  42161: viem.getAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+  10: viem.getAddress("0x4200000000000000000000000000000000000006"),
+  137: viem.getAddress("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+  5e3: viem.getAddress("0x78c1b0C915c4CD0f08633e2ec3d4961Ab0237669"),
+  130: viem.getAddress("0x4200000000000000000000000000000000000006"),
+  59144: viem.getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f")
+};
+function isCompoundV3ChainSupported(chainId) {
+  return COMPOUND_V3_CHAIN_IDS.includes(chainId);
+}
+function compoundV3WrappedNative(chainId) {
+  return COMPOUND_V3_WRAPPED_NATIVE[chainId] ?? null;
+}
+var COMPOUND_V3_MARKETS = [
+  // Ethereum
+  {
+    chainId: 1,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0xc3d688B66703497DAA19211EEdff47f25384cdc3"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "usds",
+    symbol: "cUSDSv3",
+    comet: viem.getAddress("0x5D409e56D886231aDAf00c8775665AD0f9897b56"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xdC035D45d973E3EC169d2276DDab16f1e407384F"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0x3Afdc9BCA9213A35503b077a6072F3D0d5AB0840"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "wbtc",
+    symbol: "cWBTCv3",
+    comet: viem.getAddress("0xe85Dc543813B8c2CFEaAc371517b925a166a9293"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0xA17581A9E3356d9A858b789D68B4d866e593aE94"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "wsteth",
+    symbol: "cWstETHv3",
+    comet: viem.getAddress("0x3D0bb1ccaB520A66e607822fC55BC921738fAFE3"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0x2c776041CCFe903071AF44aa147368a9c8EEA518"),
+    baseToken: viem.getAddress("0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"),
+    source: "comet-deployments"
+  },
+  // Base
+  {
+    chainId: 8453,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0xb125E6687d4313864e53df431d5425969c15Eb2F"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "usdbc",
+    symbol: "cUSDbCv3",
+    comet: viem.getAddress("0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "usds",
+    symbol: "cUSDSv3",
+    comet: viem.getAddress("0x2c776041CCFe903071AF44aa147368a9c8EEA518"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x820C137fa70C8691f0e44Dc420a5e53c168921Dc"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x46e6b214b524310239732D51387075E0e70970bf"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x4200000000000000000000000000000000000006"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "aero",
+    symbol: "cAEROv3",
+    comet: viem.getAddress("0x784efeB622244d2348d4F2522f8860B96fbEcE89"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x940181a94A35A4569E4529A3CDfB74e38FD98631"),
+    source: "comet-deployments"
+  },
+  // Arbitrum
+  {
+    chainId: 42161,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 42161,
+    slug: "usdc.e",
+    symbol: "cUSDC.ev3",
+    comet: viem.getAddress("0xA5EDBDD9646f8dFF606d7448e414884C7d905dCA"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 42161,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0xd98Be00b5D27fc98112BdE293e487f8D4cA57d07"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 42161,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+    source: "comet-deployments"
+  },
+  // Optimism
+  {
+    chainId: 10,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x2e44e174f7D53F0212823acC11C01A11d58c5bCB"),
+    rewards: viem.getAddress("0x443EA0340cb75a160F31A440722dec7b5bc3C2E9"),
+    bulker: viem.getAddress("0xcb3643CC8294B23171272845473dEc49739d4Ba3"),
+    baseToken: viem.getAddress("0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 10,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0x995E394b8B2437aC8Ce61Ee0bC610D617962B214"),
+    rewards: viem.getAddress("0x443EA0340cb75a160F31A440722dec7b5bc3C2E9"),
+    bulker: viem.getAddress("0xcb3643CC8294B23171272845473dEc49739d4Ba3"),
+    baseToken: viem.getAddress("0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 10,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0xE36A30D249f7761327fd973001A32010b521b6Fd"),
+    rewards: viem.getAddress("0x443EA0340cb75a160F31A440722dec7b5bc3C2E9"),
+    bulker: viem.getAddress("0xcb3643CC8294B23171272845473dEc49739d4Ba3"),
+    baseToken: viem.getAddress("0x4200000000000000000000000000000000000006"),
+    source: "comet-deployments"
+  },
+  // Polygon
+  {
+    chainId: 137,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0xF25212E676D1F7F89Cd72fFEe66158f541246445"),
+    rewards: viem.getAddress("0x45939657d1CA34A8FA39A924B71D28Fe8431e581"),
+    bulker: viem.getAddress("0x59e242D352ae13166B4987aE5c990C232f7f7CD6"),
+    baseToken: viem.getAddress("0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 137,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0xaeB318360f27748Acb200CE616E389A6C9409a07"),
+    rewards: viem.getAddress("0x45939657d1CA34A8FA39A924B71D28Fe8431e581"),
+    bulker: viem.getAddress("0x59e242D352ae13166B4987aE5c990C232f7f7CD6"),
+    baseToken: viem.getAddress("0xc2132D05D31c914a87C6611C10748AEb04B58e8F"),
+    source: "comet-deployments"
+  },
+  // Mantle
+  {
+    chainId: 5e3,
+    slug: "usde",
+    symbol: "cUSDev3",
+    comet: viem.getAddress("0x606174f62cd968d8e684c645080fa694c1D7786E"),
+    rewards: viem.getAddress("0xCd83CbBFCE149d141A5171C3D6a0F0fCCeE225Ab"),
+    bulker: viem.getAddress("0x67DFCa85CcEEFA2C5B1dB4DEe3BEa716A28B9baa"),
+    source: "comet-deployments"
+  },
+  // Unichain
+  {
+    chainId: 130,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x2c7118c4C88B9841FCF839074c26Ae8f035f2921"),
+    rewards: viem.getAddress("0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"),
+    bulker: viem.getAddress("0x58EbB8Db8b4FdF2dCbbB16E04c2F5b952963B514"),
+    baseToken: viem.getAddress("0x078D782b760474a361dDA0AF3839290b0EF57AD6"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 130,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x6C987dDE50dB1dcDd32Cd4175778C2a291978E2a"),
+    rewards: viem.getAddress("0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"),
+    bulker: viem.getAddress("0x58EbB8Db8b4FdF2dCbbB16E04c2F5b952963B514"),
+    baseToken: viem.getAddress("0x4200000000000000000000000000000000000006"),
+    source: "comet-deployments"
+  },
+  // Linea
+  {
+    chainId: 59144,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x8D38A3d6B3c3B7d96D6536DA7Eef94A9d7dbC991"),
+    rewards: viem.getAddress("0x2c7118c4C88B9841FCF839074c26Ae8f035f2921"),
+    bulker: viem.getAddress("0x023ee795361B28cDbB94e302983578486A0A5f1B"),
+    baseToken: viem.getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 59144,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x60F2058379716A64a7A5d29219397e79bC552194"),
+    rewards: viem.getAddress("0x2c7118c4C88B9841FCF839074c26Ae8f035f2921"),
+    bulker: viem.getAddress("0x023ee795361B28cDbB94e302983578486A0A5f1B"),
+    baseToken: viem.getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f"),
+    source: "comet-deployments"
+  }
+];
+function listCompoundV3SupportedChainIds() {
+  return [...COMPOUND_V3_CHAIN_IDS];
+}
+function listCompoundV3MarketsForChain(chainId) {
+  if (!isCompoundV3ChainSupported(chainId)) return [];
+  return COMPOUND_V3_MARKETS.filter((m) => m.chainId === chainId);
+}
+var cometInterfaceAbi = viem.parseAbi([
+  "function supply(address asset, uint256 amount)",
+  "function supplyTo(address dst, address asset, uint256 amount)",
+  "function withdraw(address asset, uint256 amount)",
+  "function withdrawTo(address to, address asset, uint256 amount)",
+  "function allow(address manager, bool isAllowed)",
+  "function hasPermission(address owner, address manager) view returns (bool)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function borrowBalanceOf(address account) view returns (uint256)",
+  "function collateralBalanceOf(address account, address asset) view returns (uint128)",
+  "function baseToken() view returns (address)",
+  "function baseTokenPriceFeed() view returns (address)",
+  "function decimals() view returns (uint8)",
+  "function numAssets() view returns (uint8)",
+  "function getUtilization() view returns (uint256)",
+  "function getSupplyRate(uint256 utilization) view returns (uint64)",
+  "function getBorrowRate(uint256 utilization) view returns (uint64)",
+  "function getPrice(address priceFeed) view returns (uint256)",
+  "function isBorrowCollateralized(address account) view returns (bool)",
+  "function isLiquidatable(address account) view returns (bool)",
+  "function getAssetInfo(uint8 i) view returns ((uint8 offset, address asset, address priceFeed, uint64 scale, uint64 borrowCollateralFactor, uint64 liquidateCollateralFactor, uint64 liquidationFactor, uint128 supplyCap))",
+  "function getAssetInfoByAddress(address asset) view returns ((uint8 offset, address asset, address priceFeed, uint64 scale, uint64 borrowCollateralFactor, uint64 liquidateCollateralFactor, uint64 liquidationFactor, uint128 supplyCap))"
+]);
+viem.parseAbi([
+  "function getRewardOwed(address comet, address account) view returns ((address token, uint256 owed))",
+  "function claim(address comet, address src, bool shouldAccrue)"
+]);
+viem.parseAbi([
+  "function invoke(bytes32[] actions, bytes[] data) payable"
+]);
+var erc20ReadAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)",
+  "function name() view returns (string)"
+]);
+viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+viem.parseAbi(["function deposit() payable", "function withdraw(uint256 wad)"]);
+function bulkerActionId(name) {
+  return viem.stringToHex(name, { size: 32 });
+}
+bulkerActionId("ACTION_SUPPLY_ASSET");
+bulkerActionId("ACTION_SUPPLY_NATIVE_TOKEN");
+bulkerActionId("ACTION_WITHDRAW_ASSET");
+bulkerActionId("ACTION_WITHDRAW_NATIVE_TOKEN");
+bulkerActionId("ACTION_CLAIM_REWARD");
+bulkerActionId("ACTION_TRANSFER_ASSET");
+
+// src/protocols/evm/compound-v3/apr.ts
+var COMPOUND_V3_SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+function compoundV3RatePerSecondToAprDecimal(ratePerSecond) {
+  if (ratePerSecond <= 0n) return 0;
+  return Number(ratePerSecond) / 1e18 * COMPOUND_V3_SECONDS_PER_YEAR;
+}
+function compoundV3AprToPercentLabel(aprDecimal) {
+  if (!Number.isFinite(aprDecimal)) return "\u2014";
+  const pct = aprDecimal * 100;
+  if (Math.abs(pct) < 1e-3) return "0.00%";
+  return `${pct.toFixed(2)}%`;
+}
+function compoundV3UtilizationToDecimal(utilization) {
+  if (utilization <= 0n) return 0;
+  return Number(utilization) / 1e18;
+}
+function compoundV3FactorToPercent(factor) {
+  return Number(factor) / 1e16;
+}
+
+// src/protocols/evm/compound-v3/subgraph.ts
+var COMPOUND_V3_SUBGRAPH_BY_CHAIN = {
+  1: "5nwMCSHaTqG3Kd2gHznbTXEnZ9QNWsssQfbHhDqQSQFp",
+  137: "AaFtUWKfFdj2x8nnE3RxTSJkHwGHvawH3VWFBykCGzLs",
+  42161: "Ff7ha9ELmpmg81D6nYxy4t8aGP26dPztqD1LDJNPqjLS",
+  8453: "2hcXhs36pTBDVUmk5K2Zkr6N4UYGwaHuco2a6jyTsijo",
+  10: "FhHNkfh5z6Z2WCEBxB6V3s8RPxnJfWZ9zAfM5bVvbvbb"
+};
+function compoundV3SubgraphIdForChain(chainId) {
+  return COMPOUND_V3_SUBGRAPH_BY_CHAIN[chainId] ?? null;
+}
+async function fetchCompoundV3SubgraphMarkets(args) {
+  const id = compoundV3SubgraphIdForChain(args.chainId);
+  const apiKey = (args.apiKey ?? process.env.THE_GRAPH_API_KEY ?? "").trim();
+  if (!id || !apiKey) return null;
+  const url = `https://gateway.thegraph.com/api/${apiKey}/subgraphs/id/${id}`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        query: `query CompoundV3Markets { markets(first: 50) { id } }`
+      })
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const markets = json.data?.markets;
+    if (!markets) return null;
+    return markets.map((m) => ({ id: m.id, comet: m.id }));
+  } catch {
+    return null;
+  }
+}
+function publicClient(rpcUrl, chainId) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+}
+async function readTokenMeta(client, asset) {
+  const [symbol, decimals] = await Promise.all([
+    client.readContract({ address: asset, abi: erc20ReadAbi, functionName: "symbol" }).catch(() => "TOKEN"),
+    client.readContract({ address: asset, abi: erc20ReadAbi, functionName: "decimals" }).catch(() => 18)
+  ]);
+  return { symbol: String(symbol), decimals: Number(decimals) };
+}
+async function enrichMarketOnChain(client, market) {
+  const comet = market.comet;
+  const [baseToken, utilization, numAssets, decimals] = await Promise.all([
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseToken" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getUtilization" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "numAssets" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "decimals" })
+  ]);
+  const [supplyRate, borrowRate, baseMeta, baseFeed] = await Promise.all([
+    client.readContract({
+      address: comet,
+      abi: cometInterfaceAbi,
+      functionName: "getSupplyRate",
+      args: [utilization]
+    }),
+    client.readContract({
+      address: comet,
+      abi: cometInterfaceAbi,
+      functionName: "getBorrowRate",
+      args: [utilization]
+    }),
+    readTokenMeta(client, viem.getAddress(baseToken)),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseTokenPriceFeed" })
+  ]);
+  const basePrice = await client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getPrice", args: [baseFeed] }).catch(() => 0n);
+  const assets = [
+    {
+      asset: viem.getAddress(baseToken),
+      symbol: baseMeta.symbol,
+      decimals: Number(decimals) || baseMeta.decimals,
+      borrowCollateralFactorPercent: 0,
+      liquidateCollateralFactorPercent: 0,
+      priceRaw: basePrice.toString(),
+      role: "base"
+    }
+  ];
+  const n = Number(numAssets);
+  for (let i = 0; i < n; i++) {
+    const info = await client.readContract({
+      address: comet,
+      abi: cometInterfaceAbi,
+      functionName: "getAssetInfo",
+      args: [i]
+    });
+    const token = viem.getAddress(info.asset);
+    const meta = await readTokenMeta(client, token);
+    const price = await client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getPrice", args: [info.priceFeed] }).catch(() => 0n);
+    assets.push({
+      asset: token,
+      symbol: meta.symbol,
+      decimals: meta.decimals,
+      borrowCollateralFactorPercent: compoundV3FactorToPercent(info.borrowCollateralFactor),
+      liquidateCollateralFactorPercent: compoundV3FactorToPercent(info.liquidateCollateralFactor),
+      priceRaw: price.toString(),
+      role: "collateral"
+    });
+  }
+  return {
+    chainId: market.chainId,
+    slug: market.slug,
+    symbol: market.symbol,
+    comet: market.comet,
+    rewards: market.rewards,
+    bulker: market.bulker,
+    baseToken: viem.getAddress(baseToken),
+    utilization: compoundV3UtilizationToDecimal(utilization),
+    supplyAprPercent: compoundV3AprToPercentLabel(compoundV3RatePerSecondToAprDecimal(supplyRate)),
+    borrowAprPercent: compoundV3AprToPercentLabel(compoundV3RatePerSecondToAprDecimal(borrowRate)),
+    assets
+  };
+}
+function registryMarketRow(market) {
+  return {
+    chainId: market.chainId,
+    slug: market.slug,
+    symbol: market.symbol,
+    comet: market.comet,
+    rewards: market.rewards,
+    bulker: market.bulker,
+    baseToken: market.baseToken ?? null,
+    utilization: null,
+    supplyAprPercent: null,
+    borrowAprPercent: null,
+    assets: market.baseToken ? [
+      {
+        asset: market.baseToken,
+        symbol: market.slug.toUpperCase(),
+        decimals: 18,
+        borrowCollateralFactorPercent: 0,
+        liquidateCollateralFactorPercent: 0,
+        priceRaw: "0",
+        role: "base"
+      }
+    ] : []
+  };
+}
+async function compoundV3FetchMarketsSummary(args) {
+  if (!isCompoundV3ChainSupported(args.chainId)) {
+    return { markets: [], notes: `Compound III is not deployed on chain ${args.chainId}.` };
+  }
+  const registry = listCompoundV3MarketsForChain(args.chainId);
+  let subgraphNote = "";
+  const subgraph = await fetchCompoundV3SubgraphMarkets({ chainId: args.chainId });
+  if (subgraph) {
+    subgraphNote = ` Subgraph listed ${subgraph.length} market id(s); official comet deployments are the address source.`;
+  }
+  if (!args.rpcUrl?.trim()) {
+    return {
+      markets: registry.map(registryMarketRow),
+      notes: "Registry from official comet deployments. Pass rpcUrl (MCP server injects it) to enrich APRs and collaterals." + subgraphNote
+    };
+  }
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const markets = [];
+  for (const row of registry) {
+    try {
+      markets.push(await enrichMarketOnChain(client, row));
+    } catch {
+      markets.push(registryMarketRow(row));
+    }
+  }
+  return {
+    markets,
+    notes: "Comet proxy addresses from official deployments; rates and collaterals from on-chain CometInterface." + subgraphNote
+  };
+}
+var chainAssetCache2 = /* @__PURE__ */ new Map();
+async function ensureCompoundV3ChainAssetCache(args) {
+  const existing = chainAssetCache2.get(args.chainId);
+  if (existing && existing.size > 0 && !args.rpcUrl) return existing;
+  const map = /* @__PURE__ */ new Map();
+  const add = (address, role) => {
+    const key = viem.getAddress(address).toLowerCase();
+    const cur = map.get(key) ?? { base: false, collateral: false };
+    cur[role] = true;
+    map.set(key, cur);
+  };
+  if (args.rpcUrl?.trim()) {
+    try {
+      const { markets } = await compoundV3FetchMarketsSummary({ chainId: args.chainId, rpcUrl: args.rpcUrl });
+      for (const m of markets) {
+        for (const a of m.assets) add(a.asset, a.role === "base" ? "base" : "collateral");
+      }
+      chainAssetCache2.set(args.chainId, map);
+      return map;
+    } catch {
+    }
+  }
+  for (const m of listCompoundV3MarketsForChain(args.chainId)) {
+    if (m.baseToken) add(m.baseToken, "base");
+  }
+  chainAssetCache2.set(args.chainId, map);
+  return map;
+}
+
+// src/protocols/evm/compound-v3/index.ts
+var compoundV3ProtocolModule = {
+  id: COMPOUND_V3_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    const id = typeof ctx.chainId === "string" ? Number(ctx.chainId) : ctx.chainId;
+    return ctx.chainCategory === "evm" && isCompoundV3ChainSupported(id);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    {
+      id: "compound-v3.supply",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Supply base (earn/repay) or collateral to a Comet proxy",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.withdraw",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw collateral or base (withdraw of base while undercollateralized = borrow)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.repay",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Repay base debt by supplying base",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.claim-rewards",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim COMP / reward token from CometRewards",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.bulker",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Combined Bulker.invoke (optional)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(compoundV3ProtocolModule);
 var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('catalog.cjs', document.baseURI).href)))), "skills");
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
@@ -7507,7 +8995,9 @@ var SKILL_PROTOCOL_IDS = [
   "arcus",
   "morpho",
   "circle-cctp",
-  "continuum-dao"
+  "aerodrome",
+  "continuum-dao",
+  "compound-v3"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -7573,6 +9063,41 @@ var EULER_V2_SUBGRAPH_CHAIN_IDS = [
 function advisor(protocolId, tokenFilter, impl) {
   return { protocolId, tokenFilter, ...impl };
 }
+function aerodromeAdvisorPriorityTokens() {
+  return [
+    {
+      address: "0x0000000000000000000000000000000000000000",
+      symbol: "ETH",
+      decimals: 18,
+      roles: ["native"]
+    },
+    {
+      address: AERODROME_WETH_BASE,
+      symbol: "WETH",
+      decimals: 18,
+      roles: ["native_wrapped"]
+    },
+    {
+      address: AERODROME_USDC_BASE,
+      symbol: "USDC",
+      decimals: 6,
+      roles: ["swappable", "listed"]
+    },
+    {
+      address: AERODROME_BASE_ADDRESSES_FALLBACK.aero,
+      symbol: "AERO",
+      decimals: 18,
+      roles: ["swappable"]
+    },
+    ...AERODROME_COINBASE_STOCK_TOKENS.map((t) => ({
+      address: t.address,
+      symbol: t.symbol,
+      name: t.name,
+      decimals: AERODROME_COINBASE_STOCK_DECIMALS,
+      roles: ["swappable", "listed", "coinbase_b20"]
+    }))
+  ];
+}
 var PROTOCOL_SUPPORT_ADVISORS = {
   "aave-v4": advisor("aave-v4", "api_underlyings", {
     async supportedChainIds() {
@@ -7839,6 +9364,21 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       };
     }
   }),
+  [AERODROME_PROTOCOL_ID]: advisor(AERODROME_PROTOCOL_ID, "pool_graph", {
+    async supportedChainIds() {
+      return [AERODROME_CHAIN_ID];
+    },
+    async supportedTokens(chainId) {
+      if (chainId !== AERODROME_CHAIN_ID) {
+        return { tokens: [], notes: "Aerodrome is Base-only (chainId 8453)." };
+      }
+      return {
+        tokens: aerodromeAdvisorPriorityTokens(),
+        nativeWrapped: AERODROME_WETH_BASE,
+        notes: "Slim directory: ETH, WETH, USDC, AERO, and Coinbase B20 stocks (AAPLc, \u2026). For a price call ctm_aerodrome_quote with tickers. To see pools for one token call ctm_aerodrome_discover_pools. Do not dump LpSugar."
+      };
+    }
+  }),
   [VENICE_PROTOCOL_ID]: advisor(VENICE_PROTOCOL_ID, "fixed_addresses", {
     async supportedChainIds() {
       return [VENICE_BASE_CHAIN_ID];
@@ -7877,6 +9417,54 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       };
     }
   }),
+  [COMPOUND_V3_PROTOCOL_ID]: advisor(COMPOUND_V3_PROTOCOL_ID, "api_underlyings", {
+    async supportedChainIds() {
+      return listCompoundV3SupportedChainIds();
+    },
+    async supportedTokens(chainId, ctx) {
+      const cache = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
+      const nativeWrapped = compoundV3WrappedNative(chainId);
+      const tokens = [];
+      if (nativeWrapped) {
+        tokens.push({
+          address: "0x0000000000000000000000000000000000000000",
+          symbol: "ETH",
+          decimals: 18,
+          roles: ["native"]
+        });
+        tokens.push({
+          address: nativeWrapped,
+          symbol: "WETH",
+          roles: ["native_wrapped"]
+        });
+      }
+      for (const [address, modes] of cache) {
+        if (nativeWrapped && address === nativeWrapped.toLowerCase()) continue;
+        tokens.push({
+          address,
+          roles: [...modes.base ? ["base"] : [], ...modes.collateral ? ["collateral"] : []]
+        });
+      }
+      return {
+        tokens,
+        nativeWrapped: nativeWrapped ?? void 0,
+        notes: "Compound III Comet base and collateral tokens. Native ETH uses wrapped native (automatic wrap/unwrap). Pass comet from ctm_compound_v3_fetch_markets."
+      };
+    },
+    async isTokenSupported(chainId, address, ctx) {
+      const cache = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      if (normalized === "0x0000000000000000000000000000000000000000") return true;
+      const wrapped = compoundV3WrappedNative(chainId);
+      if (wrapped && wrapped.toLowerCase() === normalized) return true;
+      return cache.has(normalized);
+    }
+  }),
   arcus: advisor("arcus", "api_underlyings", {
     async supportedChainIds() {
       return [...ARCUS_SUPPORTED_CHAIN_IDS];
@@ -7911,7 +9499,9 @@ registerProtocolModule(arcusProtocolModule);
 registerProtocolModule(morphoProtocolModule);
 registerProtocolModule(circleCctpProtocolModule);
 registerProtocolModule(veniceProtocolModule);
+registerProtocolModule(aerodromeProtocolModule);
 registerProtocolModule(continuumDaoProtocolModule);
+registerProtocolModule(compoundV3ProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -7934,7 +9524,9 @@ function getAgentCatalog() {
     morpho: morphoProtocolModule,
     circleCctp: circleCctpProtocolModule,
     venice: veniceProtocolModule,
+    aerodrome: aerodromeProtocolModule,
     continuumDao: continuumDaoProtocolModule,
+    compoundV3: compoundV3ProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -7972,6 +9564,30 @@ exports.mcpAaveV4BorrowInputSchema = mcpAaveV4BorrowInputSchema;
 exports.mcpAaveV4DepositInputSchema = mcpAaveV4DepositInputSchema;
 exports.mcpAaveV4RepayInputSchema = mcpAaveV4RepayInputSchema;
 exports.mcpAaveV4WithdrawInputSchema = mcpAaveV4WithdrawInputSchema;
+exports.mcpAerodromeBuildAddLiquidityMultisignInputSchema = mcpAerodromeBuildAddLiquidityMultisignInputSchema;
+exports.mcpAerodromeBuildClBurnMultisignInputSchema = mcpAerodromeBuildClBurnMultisignInputSchema;
+exports.mcpAerodromeBuildClCollectFeesMultisignInputSchema = mcpAerodromeBuildClCollectFeesMultisignInputSchema;
+exports.mcpAerodromeBuildClDecreaseMultisignInputSchema = mcpAerodromeBuildClDecreaseMultisignInputSchema;
+exports.mcpAerodromeBuildClIncreaseMultisignInputSchema = mcpAerodromeBuildClIncreaseMultisignInputSchema;
+exports.mcpAerodromeBuildClMintMultisignInputSchema = mcpAerodromeBuildClMintMultisignInputSchema;
+exports.mcpAerodromeBuildClaimEmissionsMultisignInputSchema = mcpAerodromeBuildClaimEmissionsMultisignInputSchema;
+exports.mcpAerodromeBuildClaimFeesMultisignInputSchema = mcpAerodromeBuildClaimFeesMultisignInputSchema;
+exports.mcpAerodromeBuildGaugeStakeMultisignInputSchema = mcpAerodromeBuildGaugeStakeMultisignInputSchema;
+exports.mcpAerodromeBuildGaugeUnstakeMultisignInputSchema = mcpAerodromeBuildGaugeUnstakeMultisignInputSchema;
+exports.mcpAerodromeBuildRemoveLiquidityMultisignInputSchema = mcpAerodromeBuildRemoveLiquidityMultisignInputSchema;
+exports.mcpAerodromeBuildSwapMultisignInputSchema = mcpAerodromeBuildSwapMultisignInputSchema;
+exports.mcpAerodromeDiscoverPoolsInputSchema = mcpAerodromeDiscoverPoolsInputSchema;
+exports.mcpAerodromeDiscoverPoolsOutputSchema = mcpAerodromeDiscoverPoolsOutputSchema;
+exports.mcpAerodromeFetchPoolsInputSchema = mcpAerodromeFetchPoolsInputSchema;
+exports.mcpAerodromeFetchPoolsOutputSchema = mcpAerodromeFetchPoolsOutputSchema;
+exports.mcpAerodromeFetchPositionsInputSchema = mcpAerodromeFetchPositionsInputSchema;
+exports.mcpAerodromeFetchPositionsOutputSchema = mcpAerodromeFetchPositionsOutputSchema;
+exports.mcpAerodromeQuoteAddLiquidityInputSchema = mcpAerodromeQuoteAddLiquidityInputSchema;
+exports.mcpAerodromeQuoteAddLiquidityOutputSchema = mcpAerodromeQuoteAddLiquidityOutputSchema;
+exports.mcpAerodromeQuoteClDepositInputSchema = mcpAerodromeQuoteClDepositInputSchema;
+exports.mcpAerodromeQuoteClDepositOutputSchema = mcpAerodromeQuoteClDepositOutputSchema;
+exports.mcpAerodromeQuoteInputSchema = mcpAerodromeQuoteInputSchema;
+exports.mcpAerodromeQuoteOutputSchema = mcpAerodromeQuoteOutputSchema;
 exports.mcpArcusBuildCancelOrderMultisignInputSchema = mcpArcusBuildCancelOrderMultisignInputSchema;
 exports.mcpArcusBuildCloseMultisignInputSchema = mcpArcusBuildCloseMultisignInputSchema;
 exports.mcpArcusBuildCreateApiKeyMultisignInputSchema = mcpArcusBuildCreateApiKeyMultisignInputSchema;
@@ -8002,6 +9618,17 @@ exports.mcpArcusSpotFetchMarketsInputSchema = mcpArcusSpotFetchMarketsInputSchem
 exports.mcpArcusSpotFetchMarketsOutputSchema = mcpArcusSpotFetchMarketsOutputSchema;
 exports.mcpArcusSpotFetchOhlcvInputSchema = mcpArcusSpotFetchOhlcvInputSchema;
 exports.mcpArcusSpotFetchOhlcvOutputSchema = mcpArcusSpotFetchOhlcvOutputSchema;
+exports.mcpCompoundV3BulkerInputSchema = mcpCompoundV3BulkerInputSchema;
+exports.mcpCompoundV3ClaimRewardsInputSchema = mcpCompoundV3ClaimRewardsInputSchema;
+exports.mcpCompoundV3FetchAccountInputSchema = mcpCompoundV3FetchAccountInputSchema;
+exports.mcpCompoundV3FetchAccountOutputSchema = mcpCompoundV3FetchAccountOutputSchema;
+exports.mcpCompoundV3FetchMarketInputSchema = mcpCompoundV3FetchMarketInputSchema;
+exports.mcpCompoundV3FetchMarketOutputSchema = mcpCompoundV3FetchMarketOutputSchema;
+exports.mcpCompoundV3FetchMarketsInputSchema = mcpCompoundV3FetchMarketsInputSchema;
+exports.mcpCompoundV3FetchMarketsOutputSchema = mcpCompoundV3FetchMarketsOutputSchema;
+exports.mcpCompoundV3RepayInputSchema = mcpCompoundV3RepayInputSchema;
+exports.mcpCompoundV3SupplyInputSchema = mcpCompoundV3SupplyInputSchema;
+exports.mcpCompoundV3WithdrawInputSchema = mcpCompoundV3WithdrawInputSchema;
 exports.mcpContinuumDaoAttachInputSchema = mcpContinuumDaoAttachInputSchema;
 exports.mcpContinuumDaoCastVoteBravoInputSchema = mcpContinuumDaoCastVoteBravoInputSchema;
 exports.mcpContinuumDaoCastVoteDeltaInputSchema = mcpContinuumDaoCastVoteDeltaInputSchema;
@@ -8166,13 +9793,17 @@ exports.mcpMorphoFetchEarnVaultsInputSchema = mcpMorphoFetchEarnVaultsInputSchem
 exports.mcpMorphoFetchEarnVaultsOutputSchema = mcpMorphoFetchEarnVaultsOutputSchema;
 exports.mcpMorphoFetchMidnightBooksInputSchema = mcpMorphoFetchMidnightBooksInputSchema;
 exports.mcpMorphoFetchMidnightBooksOutputSchema = mcpMorphoFetchMidnightBooksOutputSchema;
+exports.mcpMorphoFetchMidnightOffersInputSchema = mcpMorphoFetchMidnightOffersInputSchema;
+exports.mcpMorphoFetchMidnightOffersOutputSchema = mcpMorphoFetchMidnightOffersOutputSchema;
 exports.mcpMorphoFetchMidnightPositionsInputSchema = mcpMorphoFetchMidnightPositionsInputSchema;
 exports.mcpMorphoFetchMidnightPositionsOutputSchema = mcpMorphoFetchMidnightPositionsOutputSchema;
 exports.mcpMorphoFetchMidnightQuoteInputSchema = mcpMorphoFetchMidnightQuoteInputSchema;
 exports.mcpMorphoFetchMidnightQuoteOutputSchema = mcpMorphoFetchMidnightQuoteOutputSchema;
 exports.mcpMorphoMerklClaimInputSchema = mcpMorphoMerklClaimInputSchema;
 exports.mcpMorphoMidnightBorrowInputSchema = mcpMorphoMidnightBorrowInputSchema;
+exports.mcpMorphoMidnightCancelLendOfferInputSchema = mcpMorphoMidnightCancelLendOfferInputSchema;
 exports.mcpMorphoMidnightLendInputSchema = mcpMorphoMidnightLendInputSchema;
+exports.mcpMorphoMidnightLendOfferInputSchema = mcpMorphoMidnightLendOfferInputSchema;
 exports.mcpMorphoMidnightRepayInputSchema = mcpMorphoMidnightRepayInputSchema;
 exports.mcpMorphoVaultDepositInputSchema = mcpMorphoVaultDepositInputSchema;
 exports.mcpMorphoVaultWithdrawInputSchema = mcpMorphoVaultWithdrawInputSchema;