@continuumdao/ctm-mpc-defi 0.2.33 → 0.2.35

package/dist/agent/catalog.cjs

@@ -379,6 +379,98 @@ var init_midnightApi = __esm({
     init_midnightConstants();
   }
 });
+function isAerodromeChainSupported(chainId) {
+  const n = typeof chainId === "number" ? chainId : Number.parseInt(String(chainId), 10);
+  return n === AERODROME_CHAIN_ID;
+}
+var AERODROME_PROTOCOL_ID, AERODROME_CHAIN_ID, AERODROME_WETH_BASE, AERODROME_USDC_BASE;
+var init_support2 = __esm({
+  "src/protocols/evm/aerodrome/support.ts"() {
+    AERODROME_PROTOCOL_ID = "aerodrome";
+    AERODROME_CHAIN_ID = 8453;
+    AERODROME_WETH_BASE = "0x4200000000000000000000000000000000000006";
+    AERODROME_USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+  }
+});
+var AERODROME_BASE_ADDRESSES_FALLBACK;
+var init_addresses = __esm({
+  "src/protocols/evm/aerodrome/addresses.ts"() {
+    init_support2();
+    AERODROME_BASE_ADDRESSES_FALLBACK = {
+      chainId: AERODROME_CHAIN_ID,
+      aero: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+      router: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+      poolFactory: "0x420DD381b31aEf6683db6B902084cB0FFECe40Da",
+      factoryRegistry: "0x5C3F18F06CC09CA1910767A34a20F771039E37C0",
+      voter: "0x16613524e02ad97eDfeF371bC883F2F5d6C480A5",
+      votingEscrow: "0xeBf418Fe2512e7E6bd9b87a8F0f294aCDC67e6B4",
+      rewardsDistributor: "0x227f65131A261548b057215bB1D5Ab2997964C7d",
+      mixedQuoter: "0x0A5aA5D3a4d28014f967Bf0f29EAA3FF9807D5c6",
+      /** MixedRouteQuoterV3 — v2 + all three CL factories (bitmask path encoding). */
+      mixedQuoterV3: "0xCd2A7D98e82D6107eac1828ce8DeAA6acB65b555",
+      nfpm: "0x827922686190790b37229fd06084350E74485b72",
+      /** Oldest Slipstream CL factory (Gauges V1). Path bit 1<<20. */
+      clFactory: "0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A",
+      /** Slipstream CL factory 2 (gauge caps). Raw tickSpacing in MixedQuoterV3. */
+      clFactory2: "0xaDe65c38CD4849aDBA595a4323a8C7DdfE89716a",
+      /** Newest Slipstream CL factory (Gauges V3) — Coinbase B20 stock pools. Path bit 1<<19. */
+      clFactory3: "0xf8f2eB4940CFE7d13603DDDD87f123820Fc061Ef",
+      universalRouter: "0x6Cb442acF35158D5eDa88fe602221b67B400Be3E",
+      swapRouter: "0xBE6D8f0d05cC4be24d5167a3eF062215bE6D18a5",
+      swapRouter2: "0xcbBb8035cAc7D4B3Ca7aBb74cF7BdF900215Ce0D",
+      swapRouter3: "0x698Cb2b6dd822994581fEa6eA4Fc755d1363A92F",
+      pricesOracle: "0xee717411f6E44F9feE011835C8E6FAaC5dEfF166",
+      slipstreamHelper: "0x0AD09A66af0154a84e86F761313d02d0abB6edd5",
+      lpSugar: "0x69dD9db6d8f8E7d83887A704f447b1a584b599A1",
+      sugarSlipstreamHelper: "0x9c62ab10577fB3C20A22E231b7703Ed6D456CC7a",
+      swapper: "0x91616a7B9CF6D23f8C17845581051EBdC4BcB916",
+      weth: AERODROME_WETH_BASE
+    };
+  }
+});
+var AERODROME_COINBASE_STOCK_TOKENS, AERODROME_COINBASE_STOCK_DECIMALS;
+var init_stockTokens = __esm({
+  "src/protocols/evm/aerodrome/stockTokens.ts"() {
+    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" }
+    ];
+    AERODROME_COINBASE_STOCK_DECIMALS = 8;
+  }
+});
+var init_discover = __esm({
+  "src/protocols/evm/aerodrome/discover.ts"() {
+  }
+});
+var init_yields = __esm({
+  "src/protocols/evm/aerodrome/yields.ts"() {
+    init_addresses();
+    init_support2();
+    new Set(
+      [
+        AERODROME_WETH_BASE,
+        AERODROME_USDC_BASE,
+        AERODROME_BASE_ADDRESSES_FALLBACK.aero,
+        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+        "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+        "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34",
+        "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+        "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452"
+      ].map((a) => a.toLowerCase())
+    );
+  }
+});
 
 // src/core/registry.ts
 var modules = [];
@@ -746,6 +838,22 @@ var curveDaoProtocolModule = {
         amountHuman: { type: "string", required: true, description: "Human-readable input amount" },
         slippagePercent: { type: "number", required: true, description: "Slippage percent (0\u2013100 exclusive)" }
       }
+    },
+    {
+      id: "curve-dao.add-liquidity",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Add liquidity to an important Curve pool (optional gauge stake)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "curve-dao.remove-liquidity",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Remove liquidity from an important Curve pool",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
     }
   ]
 };
@@ -1726,6 +1834,54 @@ var mcpCurveDaoBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
     })
   )
 );
+var mcpCurveDaoFetchImportantPoolsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  query: zod.z.string().trim().min(1).optional().describe("Optional shrink filter on name, address, or coin symbol.")
+});
+var mcpCurveDaoFetchImportantPoolsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, pools[] (id, address, name, coins, tvlUsd, baseApy, gaugeCrvApy, gaugeAddress), notes }. Hard cap ~100. Not a factory dump."
+);
+var mcpCurveDaoFetchLpYieldsInputSchema = mcpCurveDaoFetchImportantPoolsInputSchema.extend({
+  pool: zod.z.string().trim().min(1).optional().describe("Optional pool address or id to shrink the set.")
+});
+var mcpCurveDaoFetchLpYieldsOutputSchema = mcpCurveDaoFetchImportantPoolsOutputSchema;
+var mcpCurveDaoQuoteAddLiquidityInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  pool: zod.z.string().min(1).describe("Pool address or id from ctm_curve_dao_fetch_important_pools"),
+  amountsHuman: zod.z.array(zod.z.string().min(1)).min(1).describe("Human amounts per underlying coin, same order as coins[]"),
+  stakeInGauge: zod.z.boolean().optional().describe("If true, quote assumes LP is staked for gauge_crv_apy")
+});
+var mcpCurveDaoQuoteAddLiquidityOutputSchema = jsonObjectSchema;
+var mcpCurveDaoQuoteRemoveLiquidityInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  pool: zod.z.string().min(1),
+  lpAmountHuman: zod.z.string().min(1)
+});
+var mcpCurveDaoQuoteRemoveLiquidityOutputSchema = jsonObjectSchema;
+var mcpCurveDaoBuildAddLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pool: zod.z.string().min(1),
+    amountsHuman: zod.z.array(zod.z.string()).min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    stakeInGauge: zod.z.boolean().optional()
+  })
+);
+var mcpCurveDaoBuildRemoveLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pool: zod.z.string().min(1),
+    lpAmountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  })
+);
+var mcpCurveDaoBuildGaugeDepositMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pool: zod.z.string().min(1),
+    lpAmountHuman: zod.z.string().min(1),
+    withdraw: zod.z.boolean().optional().describe("If true, withdraw LP from the gauge instead of deposit")
+  })
+);
 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({
@@ -1740,10 +1896,23 @@ var mcpAerodromeDiscoverPoolsOutputSchema = jsonObjectSchema.describe(
 var mcpAerodromeFetchPoolsInputSchema = zod.z.object({
   chainId: chain8453,
   rpcUrl: rpcUrlOptional,
-  limit: zod.z.number().int().positive().max(200).optional(),
+  query: zod.z.string().trim().min(1).optional().describe("Optional shrink filter. Does not expand beyond the ~100 important pools."),
+  limit: zod.z.number().int().positive().max(100).optional(),
   offset: zod.z.number().int().min(0).optional()
 });
-var mcpAerodromeFetchPoolsOutputSchema = jsonObjectSchema.describe("{ chainId, pools[] }");
+var mcpAerodromeFetchPoolsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, pools[], notes }. At most ~100 important Base pairs \u2014 not an LpSugar.all dump."
+);
+var mcpAerodromeFetchLpYieldsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  query: zod.z.string().trim().min(1).optional()
+});
+var mcpAerodromeFetchLpYieldsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, pools[] (lp, feeApr, emissionsApr, totalApr, gauge, kind, tvlUsd), notes }"
+);
+var mcpAerodromeFetchStockLpYieldsInputSchema = mcpAerodromeFetchLpYieldsInputSchema;
+var mcpAerodromeFetchStockLpYieldsOutputSchema = mcpAerodromeFetchLpYieldsOutputSchema;
 var mcpAerodromeFetchPositionsInputSchema = zod.z.object({
   chainId: chain8453,
   rpcUrl: rpcUrlOptional,
@@ -2021,7 +2190,13 @@ var mcpMorphoFetchEarnVaultsOutputSchema = zod.z.object({
       managementFee: zod.z.string().nullable(),
       totalDepositsUsd: zod.z.string(),
       liquidityUsd: zod.z.string(),
-      exposure: zod.z.array(morphoExposureRowSchema)
+      exposure: zod.z.array(morphoExposureRowSchema),
+      rewards: zod.z.array(
+        zod.z.object({
+          symbol: zod.z.string(),
+          supplyAprLabel: zod.z.string()
+        })
+      ).describe("Extra vault incentive APR from Morpho GraphQL allRewards (variable).")
     })
   )
 });
@@ -2045,7 +2220,14 @@ var mcpMorphoFetchBlueMarketsOutputSchema = zod.z.object({
       loanTokenSymbol: zod.z.string(),
       loanTokenDecimals: zod.z.number().int(),
       borrowApyLabel: zod.z.string(),
-      supplyApyLabel: zod.z.string()
+      supplyApyLabel: zod.z.string(),
+      netSupplyApyLabel: zod.z.string().describe("Blue net supply APY including incentives when Morpho publishes it."),
+      rewards: zod.z.array(
+        zod.z.object({
+          symbol: zod.z.string(),
+          supplyAprLabel: zod.z.string()
+        })
+      )
     })
   )
 });
@@ -3091,6 +3273,70 @@ var mcpContinuumDaoForumSignInInputSchema = mcpMultisignInput({
   username: zod.z.string().min(2).max(16).optional().describe("Required on first login when there is no node key (2\u201316 letters, numbers, . _ -)."),
   forumUrl: zod.z.string().optional()
 });
+var mcpMapleSyrupMarketSummarySchema = zod.z.object({
+  chainId: zod.z.number(),
+  name: zod.z.string(),
+  pool: zod.z.string().describe("Copy as pool for ctm_maple_build_*_multisign"),
+  syrupRouter: zod.z.string().describe("Copy as syrupRouter for ctm_maple_build_deposit_multisign"),
+  asset: zod.z.string().describe("Copy as asset for ctm_maple_build_deposit_multisign"),
+  assetSymbol: zod.z.string(),
+  assetDecimals: zod.z.number(),
+  weeklyApyPercent: zod.z.string(),
+  monthlyApyPercent: zod.z.string(),
+  totalAssets: zod.z.string()
+});
+var mcpMapleFetchMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  underlying: zod.z.string().trim().min(1).optional().describe("Optional filter: ERC-20 address or ticker (USDT, USDC). Omit to list all Syrup pools.")
+});
+var mcpMapleFetchMarketsOutputSchema = zod.z.object({
+  chainId: zod.z.number(),
+  markets: zod.z.array(mcpMapleSyrupMarketSummarySchema),
+  notes: zod.z.string()
+});
+var mcpMapleFetchMarketInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  pool: evmAddressSchema.optional().describe("Syrup PoolV2 / share token from fetch_markets."),
+  underlying: zod.z.string().trim().min(1).optional().describe("Deposit asset address or ticker (USDC, USDT, USDG).")
+});
+var mcpMapleFetchMarketOutputSchema = mcpMapleFetchMarketsOutputSchema;
+var mcpAaveV4UiMarketIdSchema = zod.z.enum(["main", "core", "bluechip"]).optional().describe("UI market segment: main (Plus), core, or bluechip (Prime). Omit to list all hubs.");
+var mcpAaveV4MarketSummarySchema = zod.z.object({
+  chainId: zod.z.number(),
+  hubName: zod.z.string(),
+  marketId: zod.z.enum(["main", "core", "bluechip"]),
+  hubAddress: zod.z.string(),
+  symbol: zod.z.string(),
+  name: zod.z.string(),
+  underlying: zod.z.string().describe("Copy as underlying for ctm_aave_v4_build_*_multisign"),
+  spoke: zod.z.string().nullable(),
+  canSupply: zod.z.boolean(),
+  canBorrow: zod.z.boolean(),
+  canUseAsCollateral: zod.z.boolean(),
+  supplyApyPercent: zod.z.string(),
+  borrowApyPercent: zod.z.string(),
+  supplied: zod.z.string(),
+  borrowed: zod.z.string(),
+  availableLiquidity: zod.z.string(),
+  utilizationPercent: zod.z.string().nullable(),
+  collateralFactorPercent: zod.z.string()
+});
+var mcpAaveV4FetchMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  marketId: mcpAaveV4UiMarketIdSchema,
+  underlying: zod.z.string().trim().min(1).optional().describe("Optional filter: ERC-20 address or ticker (USDT, USDC). Omit to list all reserves.")
+});
+var mcpAaveV4FetchMarketsOutputSchema = zod.z.object({
+  chainId: zod.z.number(),
+  markets: zod.z.array(mcpAaveV4MarketSummarySchema),
+  notes: zod.z.string()
+});
+var mcpAaveV4FetchMarketInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  underlying: zod.z.string().trim().min(1).describe("Reserve underlying address or ticker (e.g. USDT). Prefer fetch_markets when listing rates."),
+  marketId: mcpAaveV4UiMarketIdSchema
+});
+var mcpAaveV4FetchMarketOutputSchema = mcpAaveV4FetchMarketsOutputSchema;
 var mcpEulerV2FetchLendVaultsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   underlyingAddress: evmAddressSchema.describe(
@@ -3113,6 +3359,64 @@ var mcpEulerV2FetchLendVaultsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpEulerV2FetchEarnVaultsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  underlyingAddress: evmAddressSchema.describe(
+    "Underlying asset address from get_defi_protocol_supported_tokens."
+  ),
+  limit: agentCoercedOptionalIntSchema(zod.z.number().int().min(1).max(100)).describe("Max vault rows (default 30).")
+});
+var mcpEulerV2FetchEarnVaultsOutputSchema = zod.z.object({
+  vaults: zod.z.array(
+    zod.z.object({
+      evaultAddress: zod.z.string().describe("Copy as vault for earn deposit multisign"),
+      vaultName: zod.z.string(),
+      curatorDisplayName: zod.z.string(),
+      supplyApyPercentLabel: zod.z.string(),
+      totalAssetsHumanLabel: zod.z.string(),
+      availableLiquidityHumanLabel: zod.z.string(),
+      performanceFeePercentLabel: zod.z.string(),
+      underlyingAddress: zod.z.string(),
+      strategyCount: zod.z.number().int()
+    })
+  )
+});
+var mcpLidoFetchStethAprInputSchema = zod.z.object({}).strict();
+var mcpLidoFetchStethAprOutputSchema = zod.z.object({
+  aprPercent: zod.z.string(),
+  apr: zod.z.number().nullable(),
+  asset: zod.z.string(),
+  source: zod.z.string(),
+  notes: zod.z.string()
+});
+var mcpSkyFetchSusdsRateInputSchema = zod.z.object({
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+}).strict();
+var mcpSkyFetchSusdsRateOutputSchema = zod.z.object({
+  chainId: zod.z.number(),
+  vault: zod.z.string(),
+  asset: zod.z.string(),
+  assetSymbol: zod.z.string(),
+  apyPercent: zod.z.string(),
+  apy: zod.z.number().nullable(),
+  usdsPerSusdsShare: zod.z.string(),
+  notes: zod.z.string()
+});
+var mcpEthenaFetchSusdeApyInputSchema = zod.z.object({
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+}).strict();
+var mcpEthenaFetchSusdeApyOutputSchema = zod.z.object({
+  chainId: zod.z.number(),
+  product: zod.z.string(),
+  asset: zod.z.string(),
+  assetSymbol: zod.z.string(),
+  share: zod.z.string(),
+  apyPercent: zod.z.string(),
+  apy: zod.z.number().nullable(),
+  usdePerSusde: zod.z.string(),
+  cooldownDurationSec: zod.z.number().nullable(),
+  notes: zod.z.string()
+});
 var mcpCompoundV3FetchMarketsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
@@ -3137,6 +3441,8 @@ var mcpCompoundV3MarketSummarySchema = zod.z.object({
   utilization: zod.z.number().nullable(),
   supplyAprPercent: zod.z.string().nullable(),
   borrowAprPercent: zod.z.string().nullable(),
+  supplyRewardAprPercent: zod.z.string().nullable().describe("Forward COMP (or reward-token) supply incentive APR. Extra and variable; null if unpriced."),
+  borrowRewardAprPercent: zod.z.string().nullable().describe("Forward COMP (or reward-token) borrow incentive APR. Extra and variable; null if unpriced."),
   assets: zod.z.array(mcpCompoundV3MarketAssetSchema)
 });
 var mcpCompoundV3FetchMarketsOutputSchema = zod.z.object({
@@ -3381,7 +3687,15 @@ var mcpGmxFetchMarketPricesOutputSchema = zod.z.object({
   indexMarkUsd: zod.z.string().nullable(),
   collateralUsd: zod.z.string().nullable(),
   indexPerCollateral: zod.z.string().nullable(),
-  fetchedAtMs: zod.z.number()
+  fetchedAtMs: zod.z.number(),
+  fundingFactorPerSecond: zod.z.string().nullable(),
+  longsPayShorts: zod.z.boolean().nullable(),
+  fundingHourlyPercentLabel: zod.z.string().nullable(),
+  fundingAprPercentLabel: zod.z.string().nullable(),
+  borrowingFactorPerSecondForLongs: zod.z.string().nullable(),
+  borrowingFactorPerSecondForShorts: zod.z.string().nullable(),
+  borrowingHourlyPercentLongLabel: zod.z.string().nullable(),
+  borrowingHourlyPercentShortLabel: zod.z.string().nullable()
 });
 var mcpGmxFetchOhlcvInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
@@ -3452,6 +3766,28 @@ var hyperliquidAccountSummarySchema = zod.z.object({
 var mcpHyperliquidFetchMarketsInputSchema = hyperliquidFetchChainInputSchema.extend({
   dex: zod.z.string().optional()
 });
+var mcpHyperliquidFetchStockMarketsInputSchema = hyperliquidFetchChainInputSchema;
+var mcpHyperliquidFetchStockMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(
+    zod.z.object({
+      name: zod.z.string().describe("HIP-3 coin, e.g. xyz:AAPL"),
+      asset: zod.z.number(),
+      szDecimals: zod.z.number(),
+      maxLeverage: zod.z.number(),
+      onlyIsolated: zod.z.boolean().optional(),
+      dex: zod.z.string().optional(),
+      displayName: zod.z.string().optional(),
+      category: zod.z.string().optional(),
+      keywords: zod.z.array(zod.z.string()).optional()
+    })
+  ),
+  dexes: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      fullName: zod.z.string()
+    })
+  )
+});
 var mcpHyperliquidFetchMarketsOutputSchema = zod.z.object({
   markets: zod.z.array(
     zod.z.object({
@@ -3556,6 +3892,7 @@ var mcpHyperliquidFetchMarketSnapshotOutputSchema = zod.z.object({
     dex: zod.z.string().nullable(),
     livePrice: hyperliquidLivePriceSchema,
     midUsd: zod.z.string(),
+    funding: zod.z.string().nullable().describe("Official HyperCore hourly funding from metaAndAssetCtxs"),
     fetchedAtMs: zod.z.number(),
     interval: hyperliquidOhlcvIntervalSchema,
     latestCandle: hyperliquidOhlcvCandleSchema.nullable(),
@@ -3612,6 +3949,10 @@ var mcpHyperliquidFetchVaultsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpHyperliquidFetchVaultApysInputSchema = mcpHyperliquidFetchVaultsInputSchema;
+var mcpHyperliquidFetchVaultApysOutputSchema = mcpHyperliquidFetchVaultsOutputSchema.extend({
+  notes: zod.z.string()
+});
 var mcpHyperliquidFetchUserVaultEquitiesInputSchema = hyperliquidFetchChainInputSchema.extend({
   executorAddress: evmAddressSchema
 });
@@ -5506,6 +5847,84 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveDaoBatch" },
     inputZod: mcpCurveDaoBuildSwapMultisignInputSchema
   }),
+  defineMcpTool({
+    name: "ctm_curve_dao_fetch_important_pools",
+    actionId: "curve-dao.fetch-important-pools",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Official api.curve.fi catalog of ~100 important pools (TVL-ranked, dead/zero-TVL dropped). The only Curve list tool \u2014 do not dump factories or call fetchAllCurvePools. Optional query shrinks the set.",
+    prerequisites: ["chainId"],
+    followUp: ["ctm_curve_dao_fetch_lp_yields", "ctm_curve_dao_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "curveDaoFetchImportantPools" },
+    inputZod: mcpCurveDaoFetchImportantPoolsInputSchema,
+    outputZod: mcpCurveDaoFetchImportantPoolsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_curve_dao_fetch_lp_yields",
+    actionId: "curve-dao.fetch-lp-yields",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "LP yields for the same ~100 important Curve pools (baseApy + gauge_crv_apy + TVL). gauge_crv_apy requires staking LP in the gauge.",
+    prerequisites: ["chainId"],
+    followUp: ["ctm_curve_dao_quote_add_liquidity", "ctm_curve_dao_build_gauge_deposit_multisign"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "curveDaoFetchLpYields" },
+    inputZod: mcpCurveDaoFetchLpYieldsInputSchema,
+    outputZod: mcpCurveDaoFetchLpYieldsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_curve_dao_quote_add_liquidity",
+    actionId: "curve-dao.quote-add-liquidity",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Quote Curve add_liquidity for an important pool. Copy pool + amountsHuman onto the build tool.",
+    prerequisites: ["pool from ctm_curve_dao_fetch_important_pools"],
+    followUp: ["ctm_curve_dao_build_add_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "curveDaoQuoteAddLiquidity" },
+    inputZod: mcpCurveDaoQuoteAddLiquidityInputSchema,
+    outputZod: mcpCurveDaoQuoteAddLiquidityOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_curve_dao_quote_remove_liquidity",
+    actionId: "curve-dao.quote-remove-liquidity",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Quote balanced Curve remove_liquidity for an important pool.",
+    prerequisites: ["pool from ctm_curve_dao_fetch_important_pools"],
+    followUp: ["ctm_curve_dao_build_remove_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "curveDaoQuoteRemoveLiquidity" },
+    inputZod: mcpCurveDaoQuoteRemoveLiquidityInputSchema,
+    outputZod: mcpCurveDaoQuoteRemoveLiquidityOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_curve_dao_build_add_liquidity_multisign",
+    actionId: "curve-dao.add-liquidity",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Create mpc-auth multiSignRequest for Curve add_liquidity (optional gauge.deposit when stakeInGauge). Pool must be from fetch_important_pools.",
+    prerequisites: ["ctm_curve_dao_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveAddLiquidity" },
+    inputZod: mcpCurveDaoBuildAddLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_curve_dao_build_remove_liquidity_multisign",
+    actionId: "curve-dao.remove-liquidity",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Create mpc-auth multiSignRequest for Curve remove_liquidity. Unstake from the gauge first if LP is staked.",
+    prerequisites: ["ctm_curve_dao_quote_remove_liquidity"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveRemoveLiquidity" },
+    inputZod: mcpCurveDaoBuildRemoveLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_curve_dao_build_gauge_deposit_multisign",
+    actionId: "curve-dao.gauge-deposit",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Stake or unstake Curve LP in the gauge (required for advertised gauge_crv_apy). Set withdraw:true to unstake.",
+    prerequisites: ["pool with gaugeAddress from fetch_important_pools"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveGaugeDeposit" },
+    inputZod: mcpCurveDaoBuildGaugeDepositMultisignInputSchema
+  }),
   defineMcpTool({
     name: "ctm_aerodrome_discover_pools",
     actionId: "aerodrome.discover-pools",
@@ -5523,13 +5942,37 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     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.",
+    description: "At most ~100 important Aerodrome pools on Base (ETH/WETH, USDC, AERO, major stables; TVL-ranked). Not an LpSugar.all dump. Optional query only shrinks the set. For B20 stock LPs use ctm_aerodrome_fetch_stock_lp_yields.",
     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_lp_yields",
+    actionId: "aerodrome.fetch-lp-yields",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Fee tier + AERO emissions APR for the same ~100 important Aerodrome pairs. feeApr is null (Sugar has no volume). Not a factory dump. B20 stocks: ctm_aerodrome_fetch_stock_lp_yields.",
+    prerequisites: ["chainId 8453"],
+    followUp: ["ctm_aerodrome_quote_add_liquidity", "ctm_aerodrome_build_gauge_stake_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeFetchLpYieldsSummary" },
+    inputZod: mcpAerodromeFetchLpYieldsInputSchema,
+    outputZod: mcpAerodromeFetchLpYieldsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_fetch_stock_lp_yields",
+    actionId: "aerodrome.fetch-stock-lp-yields",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Coinbase B20 stock LP yields only (AAPLc/USDC, \u2026). Separate from main-pair fetch_lp_yields. Trading stocks is not this list.",
+    prerequisites: ["chainId 8453"],
+    followUp: ["ctm_aerodrome_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeFetchStockLpYieldsSummary" },
+    inputZod: mcpAerodromeFetchStockLpYieldsInputSchema,
+    outputZod: mcpAerodromeFetchStockLpYieldsOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_aerodrome_fetch_positions",
     actionId: "aerodrome.fetch-positions",
@@ -5751,7 +6194,7 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "gmx.fetch-market-prices",
     protocolId: "gmx",
     chainCategory: "evm",
-    description: "Latest GMX index mark and collateral USD prices for a perp market. Read-only via GMX HTTP API.",
+    description: "Latest GMX index mark, collateral USD, and official funding (fundingFactorPerSecond, longsPayShorts, hourly/APR labels). Borrow-per-second is a cost caveat, not a second yield. Read-only via GMX HTTP API + MarketInfo.",
     prerequisites: ["chainId", "symbol from ctm_gmx_fetch_markets", "collateralSymbol e.g. USDC"],
     followUp: ["ctm_gmx_fetch_ohlcv", "ctm_gmx_build_increase_multisign"],
     handler: { importPath: "protocols/evm/gmx", exportName: "gmxFetchMarketPrices" },
@@ -5811,13 +6254,25 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "hyperliquid.fetch-markets",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "List Hyperliquid perp markets (native + all HIP-3 dexes when dex omitted). Each market has coin name, maxLeverage, szDecimals, and optional dex (e.g. xyz for xyz:AAPL). chainId 999 mainnet or 998 testnet.",
+    description: "List native Hyperliquid crypto perp markets. HIP-3 stocks (xyz:AAPL) are ctm_hyperliquid_fetch_stock_markets. Pass dex to list one builder. chainId 999 mainnet or 998 testnet.",
     prerequisites: ["chainId 999 or 998"],
     followUp: ["ctm_hyperliquid_fetch_open_context", "ctm_hyperliquid_build_limit_order_multisign", "ctm_hyperliquid_build_update_leverage_multisign"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchMarketsSummary" },
     inputZod: mcpHyperliquidFetchMarketsInputSchema,
     outputZod: mcpHyperliquidFetchMarketsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_stock_markets",
+    actionId: "hyperliquid.fetch-stock-markets",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "HIP-3 / equity stock perps (xyz:AAPL, TSLA, \u2026) with dex, displayName, and category. Trading only \u2014 not a savings APR. Native crypto: ctm_hyperliquid_fetch_markets.",
+    prerequisites: ["chainId 999 or 998"],
+    followUp: ["ctm_hyperliquid_search_markets", "ctm_hyperliquid_build_limit_order_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchStockMarketsSummary" },
+    inputZod: mcpHyperliquidFetchStockMarketsInputSchema,
+    outputZod: mcpHyperliquidFetchStockMarketsOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_hyperliquid_search_markets",
     actionId: "hyperliquid.search-markets",
@@ -5871,7 +6326,7 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "hyperliquid.fetch-market-snapshot",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "Live mark/mid price plus recent OHLCV candles for a Hyperliquid perp. Uses metaAndAssetCtxs for live prices (not stale candle close). Default interval 15m, 48 bars. Throws if live price unavailable.",
+    description: "Live mark/mid price, official hourly funding, plus recent OHLCV candles for a Hyperliquid perp. Uses metaAndAssetCtxs for live prices and funding (not stale candle close). Default interval 15m, 48 bars. Throws if live price unavailable.",
     prerequisites: ["chainId", "coin"],
     followUp: ["ctm_hyperliquid_fetch_open_context", "ctm_hyperliquid_build_limit_order_multisign", "ctm_hyperliquid_build_update_leverage_multisign"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchMarketSnapshotSummary" },
@@ -5914,6 +6369,18 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpHyperliquidFetchVaultsInputSchema,
     outputZod: mcpHyperliquidFetchVaultsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_vault_apys",
+    actionId: "hyperliquid.fetch-vault-apys",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Hyperliquid vault APRs sorted descending (HLP first). Use this for idle USDC yield compare \u2014 not HIP-3 stocks. Same catalog cap as fetch_vaults.",
+    prerequisites: ["chainId 999 for catalog"],
+    followUp: ["ctm_hyperliquid_build_vault_deposit_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchVaultApysSummary" },
+    inputZod: mcpHyperliquidFetchVaultApysInputSchema,
+    outputZod: mcpHyperliquidFetchVaultApysOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_hyperliquid_fetch_user_vault_equities",
     actionId: "hyperliquid.fetch-user-vault-equities",
@@ -6187,6 +6654,18 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpEulerV2FetchLendVaultsInputSchema,
     outputZod: mcpEulerV2FetchLendVaultsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_euler_v2_fetch_earn_vaults",
+    actionId: "euler-v2.fetch-earn-vaults",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    description: "Euler Earn vaults (curated, not isolated lend) for an underlying with live supply APY. Use this (not web search) for Euler earn rates. Copy evaultAddress for deposit.",
+    prerequisites: ["chainId", "underlyingAddress from get_defi_protocol_supported_tokens"],
+    followUp: ["ctm_euler_v2_build_isolated_lend_multisign"],
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "eulerV2FetchEarnVaultsSummary" },
+    inputZod: mcpEulerV2FetchEarnVaultsInputSchema,
+    outputZod: mcpEulerV2FetchEarnVaultsOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_cctp_fetch_supported_routes",
     actionId: "circle-cctp.fetch-routes",
@@ -6638,6 +7117,103 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpContinuumDaoForumSectionsInputSchema,
     outputZod: mcpContinuumDaoForumSectionsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_maple_fetch_markets",
+    actionId: "maple-syrup.fetch-markets",
+    protocolId: "maple-syrup",
+    chainCategory: "evm",
+    description: "List Maple Syrup pools on a chain with live weekly/monthly APY and TVL. Use this (not web search) for Maple lending rates. Copy pool + syrupRouter + asset for build_deposit_multisign / build_request_redeem_multisign. Optional underlying filter.",
+    prerequisites: ["chainId", "get_defi_protocol_supported_chains"],
+    followUp: [
+      "ctm_maple_fetch_market",
+      "ctm_maple_build_deposit_multisign",
+      "ctm_maple_build_request_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/maple", exportName: "mapleSyrupFetchMarketsSummary" },
+    inputZod: mcpMapleFetchMarketsInputSchema,
+    outputZod: mcpMapleFetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_maple_fetch_market",
+    actionId: "maple-syrup.fetch-market",
+    protocolId: "maple-syrup",
+    chainCategory: "evm",
+    description: "One Maple Syrup pool (by pool address or underlying) with weekly/monthly APY and TVL. Copy pool + syrupRouter + asset for deposit/redeem. Do not web-search Maple rates.",
+    prerequisites: ["chainId", "pool or underlying from ctm_maple_fetch_markets"],
+    followUp: ["ctm_maple_build_deposit_multisign", "ctm_maple_build_request_redeem_multisign"],
+    handler: { importPath: "protocols/evm/maple", exportName: "mapleSyrupFetchMarketSummary" },
+    inputZod: mcpMapleFetchMarketInputSchema,
+    outputZod: mcpMapleFetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aave_v4_fetch_markets",
+    actionId: "aave-v4.fetch-markets",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "List Aave v4 hub reserves on a chain with live supply/borrow APY, liquidity, and collateral factor. Use this (not web search) to compare lending rates or pick an underlying + marketId for build_*_multisign. Optional marketId (main/core/bluechip) or underlying filter.",
+    prerequisites: ["chainId", "get_defi_protocol_supported_chains"],
+    followUp: [
+      "ctm_aave_v4_fetch_market",
+      "ctm_aave_v4_build_deposit_multisign",
+      "ctm_aave_v4_build_borrow_multisign"
+    ],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "aaveV4FetchMarketsSummary" },
+    inputZod: mcpAaveV4FetchMarketsInputSchema,
+    outputZod: mcpAaveV4FetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aave_v4_fetch_market",
+    actionId: "aave-v4.fetch-market",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "One Aave v4 reserve (or the same underlying across hubs) with supply/borrow APY and liquidity. Copy underlying + marketId for deposit/borrow/repay. Do not web-search Aave rates.",
+    prerequisites: ["chainId", "underlying from ctm_aave_v4_fetch_markets or get_defi_protocol_supported_tokens"],
+    followUp: [
+      "ctm_aave_v4_build_deposit_multisign",
+      "ctm_aave_v4_build_withdraw_multisign",
+      "ctm_aave_v4_build_borrow_multisign",
+      "ctm_aave_v4_build_repay_multisign"
+    ],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "aaveV4FetchMarketSummary" },
+    inputZod: mcpAaveV4FetchMarketInputSchema,
+    outputZod: mcpAaveV4FetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_lido_fetch_steth_apr",
+    actionId: "lido.fetch-steth-apr",
+    protocolId: "lido",
+    chainCategory: "evm",
+    description: "Recent stETH staking APR from the official Lido API. Use this (not web search) when comparing ETH staking vs lending. Ethereum mainnet.",
+    prerequisites: ["load_defi_protocol lido"],
+    followUp: ["ctm_lido_build_submit_multisign"],
+    handler: { importPath: "protocols/evm/lido", exportName: "lidoFetchStethAprSummary" },
+    inputZod: mcpLidoFetchStethAprInputSchema,
+    outputZod: mcpLidoFetchStethAprOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_sky_fetch_susds_rate",
+    actionId: "sky.fetch-susds-rate",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Sky Savings Rate (sUSDS APY) from on-chain ssr(). Use this (not web search) for USDS savings. Ethereum mainnet. rpcUrl is injected.",
+    prerequisites: ["chainId 1", "get_chain_registry rpcGateway"],
+    followUp: ["ctm_sky_build_susds_deposit_multisign"],
+    handler: { importPath: "protocols/evm/sky", exportName: "skyFetchSusdsRateSummary" },
+    inputZod: mcpSkyFetchSusdsRateInputSchema,
+    outputZod: mcpSkyFetchSusdsRateOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_ethena_fetch_susde_apy",
+    actionId: "ethena.fetch-susde-apy",
+    protocolId: "ethena",
+    chainCategory: "evm",
+    description: "sUSDe staking APY plus USDe-per-share from the vault. Use this (not web search) for USDe yield. Ethereum mainnet. rpcUrl is injected.",
+    prerequisites: ["chainId 1", "get_chain_registry rpcGateway"],
+    followUp: ["ctm_ethena_build_stake_multisign"],
+    handler: { importPath: "protocols/evm/ethena", exportName: "ethenaFetchSusdeApySummary" },
+    inputZod: mcpEthenaFetchSusdeApyInputSchema,
+    outputZod: mcpEthenaFetchSusdeApyOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_compound_v3_fetch_markets",
     actionId: "compound-v3.fetch-markets",
@@ -8295,34 +8871,14 @@ 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
+init_support2();
+init_support2();
+init_addresses();
+init_stockTokens();
+init_discover();
+init_yields();
 var aerodromeProtocolModule = {
   id: AERODROME_PROTOCOL_ID,
   chainCategory: "evm",
@@ -8867,11 +9423,18 @@ var cometInterfaceAbi = viem.parseAbi([
   "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))"
+  "function getAssetInfoByAddress(address asset) view returns ((uint8 offset, address asset, address priceFeed, uint64 scale, uint64 borrowCollateralFactor, uint64 liquidateCollateralFactor, uint64 liquidationFactor, uint128 supplyCap))",
+  "function baseTrackingSupplySpeed() view returns (uint256)",
+  "function baseTrackingBorrowSpeed() view returns (uint256)",
+  "function baseIndexScale() view returns (uint64)",
+  "function trackingIndexScale() view returns (uint256)",
+  "function totalSupply() view returns (uint256)",
+  "function totalBorrow() view returns (uint256)"
 ]);
-viem.parseAbi([
+var cometRewardsAbi = viem.parseAbi([
   "function getRewardOwed(address comet, address account) view returns ((address token, uint256 owed))",
-  "function claim(address comet, address src, bool shouldAccrue)"
+  "function claim(address comet, address src, bool shouldAccrue)",
+  "function rewardConfig(address comet) view returns ((address token, uint64 rescaleFactor, bool shouldUpscale))"
 ]);
 viem.parseAbi([
   "function invoke(bytes32[] actions, bytes[] data) payable"
@@ -8913,6 +9476,22 @@ function compoundV3UtilizationToDecimal(utilization) {
 function compoundV3FactorToPercent(factor) {
   return Number(factor) / 1e16;
 }
+var COMPOUND_V3_PRICE_SCALE = 1e8;
+var COMPOUND_V3_TRACKING_INDEX_SCALE = 1e15;
+function compoundV3TrackingSpeedToRewardAprPercent(args) {
+  if (args.trackingSpeed <= 0n || args.totalBase <= 0n || args.basePrice <= 0n || args.rewardPrice <= 0n) {
+    return null;
+  }
+  const scale = Number(args.trackingIndexScale > 0n ? args.trackingIndexScale : BigInt(COMPOUND_V3_TRACKING_INDEX_SCALE));
+  if (!Number.isFinite(scale) || scale <= 0) return null;
+  const tokensPerYear = Number(args.trackingSpeed) / scale * COMPOUND_V3_SECONDS_PER_YEAR;
+  const rewardUsdPerYear = tokensPerYear * (Number(args.rewardPrice) / COMPOUND_V3_PRICE_SCALE);
+  const totalUsd = Number(args.totalBase) / 10 ** args.baseDecimals * (Number(args.basePrice) / COMPOUND_V3_PRICE_SCALE);
+  if (!Number.isFinite(rewardUsdPerYear) || !Number.isFinite(totalUsd) || totalUsd <= 0) return null;
+  const pct = rewardUsdPerYear / totalUsd * 100;
+  if (!Number.isFinite(pct) || pct < 0) return null;
+  return pct;
+}
 
 // src/protocols/evm/compound-v3/subgraph.ts
 var COMPOUND_V3_SUBGRAPH_BY_CHAIN = {
@@ -8971,7 +9550,7 @@ async function enrichMarketOnChain(client, market) {
     client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "numAssets" }),
     client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "decimals" })
   ]);
-  const [supplyRate, borrowRate, baseMeta, baseFeed] = await Promise.all([
+  const [supplyRate, borrowRate, baseMeta, baseFeed, supplySpeed, borrowSpeed, totalSupply, totalBorrow, trackingScale] = await Promise.all([
     client.readContract({
       address: comet,
       abi: cometInterfaceAbi,
@@ -8985,7 +9564,12 @@ async function enrichMarketOnChain(client, market) {
       args: [utilization]
     }),
     readTokenMeta(client, viem.getAddress(baseToken)),
-    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseTokenPriceFeed" })
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseTokenPriceFeed" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseTrackingSupplySpeed" }).catch(() => 0n),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseTrackingBorrowSpeed" }).catch(() => 0n),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "totalSupply" }).catch(() => 0n),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "totalBorrow" }).catch(() => 0n),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "trackingIndexScale" }).catch(() => BigInt(COMPOUND_V3_TRACKING_INDEX_SCALE))
   ]);
   const basePrice = await client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getPrice", args: [baseFeed] }).catch(() => 0n);
   const assets = [
@@ -9020,6 +9604,47 @@ async function enrichMarketOnChain(client, market) {
       role: "collateral"
     });
   }
+  let rewardPrice = 0n;
+  try {
+    const cfg = await client.readContract({
+      address: viem.getAddress(market.rewards),
+      abi: cometRewardsAbi,
+      functionName: "rewardConfig",
+      args: [comet]
+    });
+    const rewardToken = viem.getAddress(cfg.token);
+    const listed = assets.find((a) => a.asset.toLowerCase() === rewardToken.toLowerCase());
+    if (listed && listed.priceRaw !== "0") {
+      rewardPrice = BigInt(listed.priceRaw);
+    } else {
+      const info = await client.readContract({
+        address: comet,
+        abi: cometInterfaceAbi,
+        functionName: "getAssetInfoByAddress",
+        args: [rewardToken]
+      });
+      rewardPrice = await client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getPrice", args: [info.priceFeed] }).catch(() => 0n);
+    }
+  } catch {
+    rewardPrice = 0n;
+  }
+  const baseDecimals = Number(decimals) || baseMeta.decimals;
+  const supplyRewardApr = compoundV3TrackingSpeedToRewardAprPercent({
+    trackingSpeed: supplySpeed,
+    trackingIndexScale: trackingScale,
+    totalBase: totalSupply,
+    baseDecimals,
+    basePrice,
+    rewardPrice
+  });
+  const borrowRewardApr = compoundV3TrackingSpeedToRewardAprPercent({
+    trackingSpeed: borrowSpeed,
+    trackingIndexScale: trackingScale,
+    totalBase: totalBorrow,
+    baseDecimals,
+    basePrice,
+    rewardPrice
+  });
   return {
     chainId: market.chainId,
     slug: market.slug,
@@ -9031,6 +9656,8 @@ async function enrichMarketOnChain(client, market) {
     utilization: compoundV3UtilizationToDecimal(utilization),
     supplyAprPercent: compoundV3AprToPercentLabel(compoundV3RatePerSecondToAprDecimal(supplyRate)),
     borrowAprPercent: compoundV3AprToPercentLabel(compoundV3RatePerSecondToAprDecimal(borrowRate)),
+    supplyRewardAprPercent: supplyRewardApr == null ? null : compoundV3AprToPercentLabel(supplyRewardApr / 100),
+    borrowRewardAprPercent: borrowRewardApr == null ? null : compoundV3AprToPercentLabel(borrowRewardApr / 100),
     assets
   };
 }
@@ -9046,6 +9673,8 @@ function registryMarketRow(market) {
     utilization: null,
     supplyAprPercent: null,
     borrowAprPercent: null,
+    supplyRewardAprPercent: null,
+    borrowRewardAprPercent: null,
     assets: market.baseToken ? [
       {
         asset: market.baseToken,
@@ -9072,7 +9701,7 @@ async function compoundV3FetchMarketsSummary(args) {
   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
+      notes: "Registry from official comet deployments. Pass rpcUrl (MCP server injects it) to enrich APRs, reward APRs, and collaterals." + subgraphNote
     };
   }
   const client = publicClient(args.rpcUrl, args.chainId);
@@ -9086,7 +9715,7 @@ async function compoundV3FetchMarketsSummary(args) {
   }
   return {
     markets,
-    notes: "Comet proxy addresses from official deployments; rates and collaterals from on-chain CometInterface." + subgraphNote
+    notes: "Comet proxy addresses from official deployments; base supply/borrow APR and COMP incentive APR from on-chain CometInterface. Incentive APR is extra and variable; null when the reward token has no on-chain price feed." + subgraphNote
   };
 }
 var chainAssetCache2 = /* @__PURE__ */ new Map();
@@ -9190,7 +9819,8 @@ var SKILL_PROTOCOL_IDS = [
   "circle-cctp",
   "aerodrome",
   "continuum-dao",
-  "compound-v3"
+  "compound-v3",
+  "yield-compare"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -9239,6 +9869,9 @@ function getProtocolDiscoverySummary(protocolId) {
   };
 }
 init_support();
+init_support2();
+init_addresses();
+init_stockTokens();
 function advisor(protocolId, tokenFilter, impl) {
   return { protocolId, tokenFilter, ...impl };
 }
@@ -9509,7 +10142,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
     async supportedTokens() {
       return {
         tokens: [],
-        notes: "Maple Syrup pools are discovered via GraphQL; pass syrupRouter, pool, and asset from Maple UI."
+        notes: "Maple Syrup pools and APYs come from ctm_maple_fetch_markets. Copy syrupRouter, pool, and asset from the fetch row."
       };
     }
   }),
@@ -9762,6 +10395,10 @@ exports.listProtocolSupportAdvisorIds = listProtocolSupportAdvisorIds;
 exports.listProtocolsWithSkills = listProtocolsWithSkills;
 exports.mcpAaveV4BorrowInputSchema = mcpAaveV4BorrowInputSchema;
 exports.mcpAaveV4DepositInputSchema = mcpAaveV4DepositInputSchema;
+exports.mcpAaveV4FetchMarketInputSchema = mcpAaveV4FetchMarketInputSchema;
+exports.mcpAaveV4FetchMarketOutputSchema = mcpAaveV4FetchMarketOutputSchema;
+exports.mcpAaveV4FetchMarketsInputSchema = mcpAaveV4FetchMarketsInputSchema;
+exports.mcpAaveV4FetchMarketsOutputSchema = mcpAaveV4FetchMarketsOutputSchema;
 exports.mcpAaveV4RepayInputSchema = mcpAaveV4RepayInputSchema;
 exports.mcpAaveV4WithdrawInputSchema = mcpAaveV4WithdrawInputSchema;
 exports.mcpAerodromeBuildAddLiquidityMultisignInputSchema = mcpAerodromeBuildAddLiquidityMultisignInputSchema;
@@ -9778,10 +10415,14 @@ exports.mcpAerodromeBuildRemoveLiquidityMultisignInputSchema = mcpAerodromeBuild
 exports.mcpAerodromeBuildSwapMultisignInputSchema = mcpAerodromeBuildSwapMultisignInputSchema;
 exports.mcpAerodromeDiscoverPoolsInputSchema = mcpAerodromeDiscoverPoolsInputSchema;
 exports.mcpAerodromeDiscoverPoolsOutputSchema = mcpAerodromeDiscoverPoolsOutputSchema;
+exports.mcpAerodromeFetchLpYieldsInputSchema = mcpAerodromeFetchLpYieldsInputSchema;
+exports.mcpAerodromeFetchLpYieldsOutputSchema = mcpAerodromeFetchLpYieldsOutputSchema;
 exports.mcpAerodromeFetchPoolsInputSchema = mcpAerodromeFetchPoolsInputSchema;
 exports.mcpAerodromeFetchPoolsOutputSchema = mcpAerodromeFetchPoolsOutputSchema;
 exports.mcpAerodromeFetchPositionsInputSchema = mcpAerodromeFetchPositionsInputSchema;
 exports.mcpAerodromeFetchPositionsOutputSchema = mcpAerodromeFetchPositionsOutputSchema;
+exports.mcpAerodromeFetchStockLpYieldsInputSchema = mcpAerodromeFetchStockLpYieldsInputSchema;
+exports.mcpAerodromeFetchStockLpYieldsOutputSchema = mcpAerodromeFetchStockLpYieldsOutputSchema;
 exports.mcpAerodromeQuoteAddLiquidityInputSchema = mcpAerodromeQuoteAddLiquidityInputSchema;
 exports.mcpAerodromeQuoteAddLiquidityOutputSchema = mcpAerodromeQuoteAddLiquidityOutputSchema;
 exports.mcpAerodromeQuoteClDepositInputSchema = mcpAerodromeQuoteClDepositInputSchema;
@@ -9900,16 +10541,31 @@ exports.mcpContinuumDaoSplitInputSchema = mcpContinuumDaoSplitInputSchema;
 exports.mcpContinuumDaoTokenIdInputSchema = mcpContinuumDaoTokenIdInputSchema;
 exports.mcpContinuumDaoTransferInputSchema = mcpContinuumDaoTransferInputSchema;
 exports.mcpContinuumDaoUndelegateInputSchema = mcpContinuumDaoUndelegateInputSchema;
+exports.mcpCurveDaoBuildAddLiquidityMultisignInputSchema = mcpCurveDaoBuildAddLiquidityMultisignInputSchema;
+exports.mcpCurveDaoBuildGaugeDepositMultisignInputSchema = mcpCurveDaoBuildGaugeDepositMultisignInputSchema;
+exports.mcpCurveDaoBuildRemoveLiquidityMultisignInputSchema = mcpCurveDaoBuildRemoveLiquidityMultisignInputSchema;
 exports.mcpCurveDaoBuildSwapMultisignInputSchema = mcpCurveDaoBuildSwapMultisignInputSchema;
+exports.mcpCurveDaoFetchImportantPoolsInputSchema = mcpCurveDaoFetchImportantPoolsInputSchema;
+exports.mcpCurveDaoFetchImportantPoolsOutputSchema = mcpCurveDaoFetchImportantPoolsOutputSchema;
+exports.mcpCurveDaoFetchLpYieldsInputSchema = mcpCurveDaoFetchLpYieldsInputSchema;
+exports.mcpCurveDaoFetchLpYieldsOutputSchema = mcpCurveDaoFetchLpYieldsOutputSchema;
+exports.mcpCurveDaoQuoteAddLiquidityInputSchema = mcpCurveDaoQuoteAddLiquidityInputSchema;
+exports.mcpCurveDaoQuoteAddLiquidityOutputSchema = mcpCurveDaoQuoteAddLiquidityOutputSchema;
 exports.mcpCurveDaoQuoteInputSchema = mcpCurveDaoQuoteInputSchema;
 exports.mcpCurveDaoQuoteOutputSchema = mcpCurveDaoQuoteOutputSchema;
+exports.mcpCurveDaoQuoteRemoveLiquidityInputSchema = mcpCurveDaoQuoteRemoveLiquidityInputSchema;
+exports.mcpCurveDaoQuoteRemoveLiquidityOutputSchema = mcpCurveDaoQuoteRemoveLiquidityOutputSchema;
 exports.mcpEthenaClaimInputSchema = mcpEthenaClaimInputSchema;
 exports.mcpEthenaCooldownInputSchema = mcpEthenaCooldownInputSchema;
+exports.mcpEthenaFetchSusdeApyInputSchema = mcpEthenaFetchSusdeApyInputSchema;
+exports.mcpEthenaFetchSusdeApyOutputSchema = mcpEthenaFetchSusdeApyOutputSchema;
 exports.mcpEthenaRedeemInputSchema = mcpEthenaRedeemInputSchema;
 exports.mcpEthenaStakeInputSchema = mcpEthenaStakeInputSchema;
 exports.mcpEulerV2BorrowRepayInputSchema = mcpEulerV2BorrowRepayInputSchema;
 exports.mcpEulerV2CollateralDepositInputSchema = mcpEulerV2CollateralDepositInputSchema;
 exports.mcpEulerV2CollateralWithdrawInputSchema = mcpEulerV2CollateralWithdrawInputSchema;
+exports.mcpEulerV2FetchEarnVaultsInputSchema = mcpEulerV2FetchEarnVaultsInputSchema;
+exports.mcpEulerV2FetchEarnVaultsOutputSchema = mcpEulerV2FetchEarnVaultsOutputSchema;
 exports.mcpEulerV2FetchLendVaultsInputSchema = mcpEulerV2FetchLendVaultsInputSchema;
 exports.mcpEulerV2FetchLendVaultsOutputSchema = mcpEulerV2FetchLendVaultsOutputSchema;
 exports.mcpEulerV2IsolatedBorrowInputSchema = mcpEulerV2IsolatedBorrowInputSchema;
@@ -9960,10 +10616,14 @@ exports.mcpHyperliquidFetchPositionsInputSchema = mcpHyperliquidFetchPositionsIn
 exports.mcpHyperliquidFetchPositionsOutputSchema = mcpHyperliquidFetchPositionsOutputSchema;
 exports.mcpHyperliquidFetchStakingSummaryInputSchema = mcpHyperliquidFetchStakingSummaryInputSchema;
 exports.mcpHyperliquidFetchStakingSummaryOutputSchema = mcpHyperliquidFetchStakingSummaryOutputSchema;
+exports.mcpHyperliquidFetchStockMarketsInputSchema = mcpHyperliquidFetchStockMarketsInputSchema;
+exports.mcpHyperliquidFetchStockMarketsOutputSchema = mcpHyperliquidFetchStockMarketsOutputSchema;
 exports.mcpHyperliquidFetchUsdClassBalancesInputSchema = mcpHyperliquidFetchUsdClassBalancesInputSchema;
 exports.mcpHyperliquidFetchUsdClassBalancesOutputSchema = mcpHyperliquidFetchUsdClassBalancesOutputSchema;
 exports.mcpHyperliquidFetchUserVaultEquitiesInputSchema = mcpHyperliquidFetchUserVaultEquitiesInputSchema;
 exports.mcpHyperliquidFetchUserVaultEquitiesOutputSchema = mcpHyperliquidFetchUserVaultEquitiesOutputSchema;
+exports.mcpHyperliquidFetchVaultApysInputSchema = mcpHyperliquidFetchVaultApysInputSchema;
+exports.mcpHyperliquidFetchVaultApysOutputSchema = mcpHyperliquidFetchVaultApysOutputSchema;
 exports.mcpHyperliquidFetchVaultsInputSchema = mcpHyperliquidFetchVaultsInputSchema;
 exports.mcpHyperliquidFetchVaultsOutputSchema = mcpHyperliquidFetchVaultsOutputSchema;
 exports.mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidLimitOrderInputSchema;
@@ -9977,11 +10637,17 @@ exports.mcpHyperliquidUsdTransferInputSchema = mcpHyperliquidUsdTransferInputSch
 exports.mcpHyperliquidVaultDepositInputSchema = mcpHyperliquidVaultDepositInputSchema;
 exports.mcpHyperliquidVaultWithdrawInputSchema = mcpHyperliquidVaultWithdrawInputSchema;
 exports.mcpLidoClaimWithdrawalInputSchema = mcpLidoClaimWithdrawalInputSchema;
+exports.mcpLidoFetchStethAprInputSchema = mcpLidoFetchStethAprInputSchema;
+exports.mcpLidoFetchStethAprOutputSchema = mcpLidoFetchStethAprOutputSchema;
 exports.mcpLidoRequestWithdrawalsInputSchema = mcpLidoRequestWithdrawalsInputSchema;
 exports.mcpLidoSubmitInputSchema = mcpLidoSubmitInputSchema;
 exports.mcpLidoUnwrapWstEthInputSchema = mcpLidoUnwrapWstEthInputSchema;
 exports.mcpLidoWrapStEthInputSchema = mcpLidoWrapStEthInputSchema;
 exports.mcpMapleDepositInputSchema = mcpMapleDepositInputSchema;
+exports.mcpMapleFetchMarketInputSchema = mcpMapleFetchMarketInputSchema;
+exports.mcpMapleFetchMarketOutputSchema = mcpMapleFetchMarketOutputSchema;
+exports.mcpMapleFetchMarketsInputSchema = mcpMapleFetchMarketsInputSchema;
+exports.mcpMapleFetchMarketsOutputSchema = mcpMapleFetchMarketsOutputSchema;
 exports.mcpMapleRequestRedeemInputSchema = mcpMapleRequestRedeemInputSchema;
 exports.mcpMorphoBlueBorrowInputSchema = mcpMorphoBlueBorrowInputSchema;
 exports.mcpMorphoBlueCollateralDepositInputSchema = mcpMorphoBlueCollateralDepositInputSchema;
@@ -10013,6 +10679,8 @@ exports.mcpMultisignSubmitOutputSchema = mcpServerSubmitOutputSchema;
 exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;
 exports.mcpServerMultisignInput = mcpServerMultisignInput;
 exports.mcpServerSubmitOutputSchema = mcpServerSubmitOutputSchema;
+exports.mcpSkyFetchSusdsRateInputSchema = mcpSkyFetchSusdsRateInputSchema;
+exports.mcpSkyFetchSusdsRateOutputSchema = mcpSkyFetchSusdsRateOutputSchema;
 exports.mcpSkyLockstakeCloseInputSchema = mcpSkyLockstakeCloseInputSchema;
 exports.mcpSkyLockstakeDrawInputSchema = mcpSkyLockstakeDrawInputSchema;
 exports.mcpSkyLockstakeGetRewardInputSchema = mcpSkyLockstakeGetRewardInputSchema;