@continuumdao/ctm-mpc-defi 0.2.34 → 0.2.36

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: {}
     }
   ]
 };
@@ -990,7 +1098,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, Curve DAO, and Aerodrome 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, Aerodrome, and Pendle default to 30 minutes when omitted; other protocols use the node default (7 days)."
   )
 });
 function withMultisignKeySourceRefine(schema) {
@@ -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,251 @@ 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 mcpPendleFetchMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  query: zod.z.string().trim().min(1).optional().describe("Optional shrink filter on name, PT/YT/underlying symbol or address."),
+  pointsOnly: zod.z.boolean().optional().describe("If true, only markets with point campaigns.")
+});
+var mcpPendleFetchMarketsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, markets[] (address, pt, yt, sy, underlying, expiry, impliedApy, tvlUsd, points), notes }. Live markets only, hard cap 100 TVL-ranked."
+);
+var mcpPendleFetchPricesInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  ids: zod.z.array(zod.z.string().min(1)).optional().describe("Asset ids (chainId-0x\u2026). Omit to price the current live listing."),
+  query: zod.z.string().trim().min(1).optional()
+});
+var mcpPendleFetchPricesOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, prices[] ({ id, usd }), notes }"
+);
+var mcpPendleSearchAssetsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  query: zod.z.string().trim().min(1).describe("Ticker, name, 0x address, or chainId-0x asset id.")
+});
+var mcpPendleSearchAssetsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, results[] (live PT/YT/SY/market + expiry, liquidity, points), notes }"
+);
+var mcpPendleFetchPositionsInputSchema = zod.z.object({
+  user: evmAddressSchema.describe("KeyGen / wallet to list Pendle LP for."),
+  chainId: agentEvmChainIdSchema.optional().describe("If set, only this chain. Omit for all Core chains."),
+  filterUsd: zod.z.number().min(0).optional().describe("Drop holdings below this USD valuation. Omit to keep dust.")
+});
+var mcpPendleFetchPositionsOutputSchema = jsonObjectSchema.describe(
+  "{ user, chainId, lp[] (market, name, expiry, matured, lpAmountHuman, lpUsd), notes }. Includes matured. Not the node token list."
+);
+var mcpPendleFetchMerkleRewardsInputSchema = zod.z.object({
+  user: evmAddressSchema.describe("Wallet to list off-chain airdrop rows for (informational; no claim).")
+});
+var mcpPendleFetchMerkleRewardsOutputSchema = jsonObjectSchema.describe(
+  "{ user, claimableRewards[], claimedRewards[], notes }. List only \u2014 cannot build a claim from these rows."
+);
+var mcpPendleQuoteSwapInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokenIn: zod.z.string().min(1).describe("Underlying, PT, or YT (0xeeee / 0x0 = native)."),
+  tokenOut: zod.z.string().min(1),
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional(),
+  enableAggregator: zod.z.boolean().optional(),
+  tokenInDecimals: zod.z.number().int().min(0).max(18).optional()
+});
+var mcpPendleQuoteOutputSchema = jsonObjectSchema.describe(
+  "Hosted SDK convert quote: action, outputs, priceImpact, impliedApy, requiredApprovals, tx (do not hardcode tx.to)."
+);
+var mcpPendleQuoteMintPyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokenIn: zod.z.string().min(1),
+  pt: evmAddressSchema,
+  yt: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteRedeemPyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  pt: evmAddressSchema,
+  yt: evmAddressSchema,
+  tokenOut: zod.z.string().min(1),
+  amountPtHuman: zod.z.string().min(1),
+  amountYtHuman: zod.z.string().min(1).optional(),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteMintSyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokenIn: zod.z.string().min(1),
+  sy: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteRedeemSyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  sy: evmAddressSchema,
+  tokenOut: zod.z.string().min(1),
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteAddLiquidityInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokensIn: zod.z.array(zod.z.object({ token: zod.z.string().min(1), amountHuman: zod.z.string().min(1) })).min(1),
+  market: evmAddressSchema,
+  keepYt: zod.z.boolean().optional(),
+  yt: evmAddressSchema.optional(),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteRemoveLiquidityInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  market: evmAddressSchema,
+  lpAmountHuman: zod.z.string().min(1),
+  tokensOut: zod.z.array(zod.z.string().min(1)).min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  enableAggregator: zod.z.boolean().optional(),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1),
+    tokenOut: zod.z.string().min(1),
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    enableAggregator: zod.z.boolean().optional(),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildMintPyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1),
+    pt: evmAddressSchema,
+    yt: evmAddressSchema,
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRedeemPyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pt: evmAddressSchema,
+    yt: evmAddressSchema,
+    tokenOut: zod.z.string().min(1),
+    amountPtHuman: zod.z.string().min(1),
+    amountYtHuman: zod.z.string().min(1).optional(),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildMintSyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1),
+    sy: evmAddressSchema,
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRedeemSyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    sy: evmAddressSchema,
+    tokenOut: zod.z.string().min(1),
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildAddLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokensIn: zod.z.array(zod.z.object({ token: zod.z.string().min(1), amountHuman: zod.z.string().min(1) })).min(1),
+    market: evmAddressSchema,
+    keepYt: zod.z.boolean().optional(),
+    yt: evmAddressSchema.optional(),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRemoveLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    market: evmAddressSchema,
+    lpAmountHuman: zod.z.string().min(1),
+    tokensOut: zod.z.array(zod.z.string().min(1)).min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    enableAggregator: zod.z.boolean().optional(),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRedeemRewardsMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    sys: zod.z.array(evmAddressSchema).optional(),
+    yts: zod.z.array(evmAddressSchema).optional(),
+    markets: zod.z.array(evmAddressSchema).optional(),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
 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 +3628,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 +3874,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 +3953,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 +4079,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 +4136,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 +6034,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 +6129,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 +6381,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 +6441,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 +6513,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 +6556,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 +6841,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 +7304,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",
@@ -6678,6 +7441,238 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchAccountSummary" },
     inputZod: mcpCompoundV3FetchAccountInputSchema,
     outputZod: mcpCompoundV3FetchAccountOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_markets",
+    actionId: "pendle.fetch-markets",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: live (unexpired) markets on chainId, scanned from Core, TVL-ranked, hard cap 100. Matured YT markets are omitted. Includes points[] campaigns. Use ctm_pendle_search_assets for long-tail or a specific expired market (PT redeem / remove LP). Never Convert. load_defi_protocol pendle activates this pack.",
+    prerequisites: ["chainId in get_chain_registry \u2229 Pendle GET /v1/chains"],
+    followUp: ["ctm_pendle_search_assets", "ctm_pendle_fetch_prices", "ctm_pendle_quote_swap"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchMarketsSummary" },
+    inputZod: mcpPendleFetchMarketsInputSchema,
+    outputZod: mcpPendleFetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_prices",
+    actionId: "pendle.fetch-prices",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: USD prices for listed or searched asset ids (GET /v1/prices/assets). Do not use Convert as a ticker.",
+    prerequisites: ["chainId", "ids from fetch_markets / search_assets (or omit to price the current live listing)"],
+    followUp: ["ctm_pendle_quote_swap"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchPricesSummary" },
+    inputZod: mcpPendleFetchPricesInputSchema,
+    outputZod: mcpPendleFetchPricesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_search_assets",
+    actionId: "pendle.search-assets",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: search live markets by ticker, 0x, or chainId-0x. Prefers unexpired hits; returns a matured market only if nothing live matched or you looked up that address (PT redeem / remove LP). Returns expiry, APY, TVL, points.",
+    prerequisites: ["chainId", "query (ticker, 0x, or chainId-0x)"],
+    followUp: ["ctm_pendle_quote_swap", "ctm_pendle_quote_mint_py", "ctm_pendle_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleSearchAssets" },
+    inputZod: mcpPendleSearchAssetsInputSchema,
+    outputZod: mcpPendleSearchAssetsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_swap",
+    actionId: "pendle.quote-swap",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Hosted SDK Convert quote: token \u2194 PT or YT (this is also how you trade points). Fresh calldata; do not cache as a price ticker.",
+    prerequisites: ["ctm_pendle_fetch_markets or ctm_pendle_search_assets", "activate_tool_group pendle:swap"],
+    followUp: ["ctm_pendle_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteSwap" },
+    inputZod: mcpPendleQuoteSwapInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_mint_py",
+    actionId: "pendle.quote-mint-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: mint PT+YT from an underlying or SY.",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_mint_py_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteMintPy" },
+    inputZod: mcpPendleQuoteMintPyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_redeem_py",
+    actionId: "pendle.quote-redeem-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: redeem PT+YT to underlying or SY. After expiry, pass amountYtHuman 0 (PT only).",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_redeem_py_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteRedeemPy" },
+    inputZod: mcpPendleQuoteRedeemPyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_mint_sy",
+    actionId: "pendle.quote-mint-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: wrap underlying into SY.",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_mint_sy_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteMintSy" },
+    inputZod: mcpPendleQuoteMintSyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_redeem_sy",
+    actionId: "pendle.quote-redeem-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: unwrap SY to underlying.",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_redeem_sy_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteRedeemSy" },
+    inputZod: mcpPendleQuoteRedeemSyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_add_liquidity",
+    actionId: "pendle.quote-add-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: add LP. keepYt+yt = zero-price-impact (keep YT in the wallet instead of selling it into the AMM).",
+    prerequisites: ["activate_tool_group pendle:lp"],
+    followUp: ["ctm_pendle_build_add_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteAddLiquidity" },
+    inputZod: mcpPendleQuoteAddLiquidityInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_remove_liquidity",
+    actionId: "pendle.quote-remove-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: remove LP to tokensOut (use underlying). After expiry still works. Copy market + lpAmountHuman from ctm_pendle_fetch_positions.",
+    prerequisites: ["activate_tool_group pendle:lp", "market + lpAmountHuman from fetch_positions or the user"],
+    followUp: ["ctm_pendle_build_remove_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteRemoveLiquidity" },
+    inputZod: mcpPendleQuoteRemoveLiquidityInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_positions",
+    actionId: "pendle.fetch-positions",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: this wallet\u2019s LP holdings from official Core dashboard (including matured). Not the node token list. Use before remove LP. ~4 CU. Do not treat claimable amounts here as a live redeem quote.",
+    prerequisites: ["activate_tool_group pendle:lp", "user address", "optional chainId"],
+    followUp: ["ctm_pendle_quote_remove_liquidity"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchPositions" },
+    inputZod: mcpPendleFetchPositionsInputSchema,
+    outputZod: mcpPendleFetchPositionsOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_swap_multisign",
+    actionId: "pendle.swap",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: approve Convert tx.to then swap token \u2194 PT/YT. 30-min multiSign expiry unless expiryDate is set. Fresh Convert at build time.",
+    prerequisites: [
+      "ctm_pendle_quote_swap",
+      "get_multi_sign_gas_options + user confirms useCustomGas and 30-minute deadline",
+      "keyGenId + chainId + purposeText + slippagePercent"
+    ],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleSwapBatch" },
+    inputZod: mcpPendleBuildSwapMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_mint_py_multisign",
+    actionId: "pendle.mint-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: mint PT+YT multiSign (approve + Convert). 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_mint_py", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleMintPyBatch" },
+    inputZod: mcpPendleBuildMintPyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_redeem_py_multisign",
+    actionId: "pendle.redeem-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: redeem PT+YT multiSign. After expiry, pass amountYtHuman 0 (PT only). 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_redeem_py", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemPyBatch" },
+    inputZod: mcpPendleBuildRedeemPyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_mint_sy_multisign",
+    actionId: "pendle.mint-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: mint SY multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_mint_sy", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleMintSyBatch" },
+    inputZod: mcpPendleBuildMintSyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_redeem_sy_multisign",
+    actionId: "pendle.redeem-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: redeem SY multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_redeem_sy", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemSyBatch" },
+    inputZod: mcpPendleBuildRedeemSyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_add_liquidity_multisign",
+    actionId: "pendle.add-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: add LP multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_add_liquidity", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleAddLiquidityBatch" },
+    inputZod: mcpPendleBuildAddLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_remove_liquidity_multisign",
+    actionId: "pendle.remove-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: remove LP multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_remove_liquidity", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRemoveLiquidityBatch" },
+    inputZod: mcpPendleBuildRemoveLiquidityMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_merkle_rewards",
+    actionId: "pendle.fetch-merkle-rewards",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: list off-chain airdrop rows for a wallet (token, amount). Informational only \u2014 Core has no claim proofs. Tell the user to claim airdrops on app.pendle.finance. Do not invent a claim tx. On-chain SY/YT/LP incentives use ctm_pendle_build_redeem_rewards_multisign.",
+    prerequisites: ["activate_tool_group pendle:rewards", "user address"],
+    followUp: [],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchMerkleRewards" },
+    inputZod: mcpPendleFetchMerkleRewardsInputSchema,
+    outputZod: mcpPendleFetchMerkleRewardsOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_redeem_rewards_multisign",
+    actionId: "pendle.redeem-rewards",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: redeem on-chain interest and incentives from SY, YT, and LP (usually PENDLE) via Hosted SDK. Not merkle airdrops. 30-min expiry default.",
+    prerequisites: [
+      "activate_tool_group pendle:rewards",
+      "sys / yts / markets from fetch_markets or search",
+      "keyGenId + purposeText"
+    ],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemRewardsBatch" },
+    inputZod: mcpPendleBuildRedeemRewardsMultisignInputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -6928,6 +7923,17 @@ registerProtocolModule(ethenaProtocolModule);
 function isMapleSyrupSupportedChain(chainId) {
   return chainId === 1 || chainId === 11155111;
 }
+function matchesAssetFilter(opts) {
+  const f = (opts.filter ?? "").trim();
+  if (!f) return true;
+  const addr = (opts.address ?? "").trim();
+  if (viem.isAddress(f) && viem.isAddress(addr)) {
+    return viem.getAddress(addr) === viem.getAddress(f);
+  }
+  const sym = (opts.symbol ?? "").trim();
+  if (!sym) return false;
+  return sym.toLowerCase() === f.toLowerCase();
+}
 
 // src/protocols/evm/maple/index.ts
 var MAPLE_PROTOCOL_ID = "maple-syrup";
@@ -8295,34 +9301,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 +9853,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 +9906,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 +9980,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 +9994,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 +10034,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 +10086,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 +10103,8 @@ function registryMarketRow(market) {
     utilization: null,
     supplyAprPercent: null,
     borrowAprPercent: null,
+    supplyRewardAprPercent: null,
+    borrowRewardAprPercent: null,
     assets: market.baseToken ? [
       {
         asset: market.baseToken,
@@ -9072,7 +10131,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 +10145,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();
@@ -9173,6 +10232,347 @@ var compoundV3ProtocolModule = {
   ]
 };
 registerProtocolModule(compoundV3ProtocolModule);
+
+// src/protocols/evm/pendle/support.ts
+var PENDLE_PROTOCOL_ID = "pendle";
+var PENDLE_CORE_API_BASE = "https://api-v2.pendle.finance/core";
+var PENDLE_LISTING_CAP = 100;
+var PENDLE_LISTING_MAX_PAGES = 8;
+var PENDLE_ICON_CACHE_MS = 12 * 60 * 1e3;
+var PENDLE_CHAIN_CACHE_MS = 30 * 60 * 1e3;
+function parsePendleAssetId(id) {
+  const raw = (id ?? "").trim();
+  const dash = raw.indexOf("-");
+  if (dash <= 0) return null;
+  const chainId = Number.parseInt(raw.slice(0, dash), 10);
+  const address = raw.slice(dash + 1).trim();
+  if (!Number.isFinite(chainId) || chainId <= 0 || !address) return null;
+  return { chainId, address };
+}
+
+// src/protocols/evm/pendle/api.ts
+var FETCH_TIMEOUT_MS = 12e4;
+var PendleApiError = class extends Error {
+  status;
+  path;
+  constructor(message, status, path) {
+    super(message);
+    this.name = "PendleApiError";
+    this.status = status;
+    this.path = path;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function queryString(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === "") continue;
+    q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+async function pendleCoreFetch(args) {
+  const path = args.path.startsWith("/") ? args.path : `/${args.path}`;
+  const url = `${PENDLE_CORE_API_BASE}${path}${queryString(args.query ?? {})}`;
+  const headers = { Accept: "application/json" };
+  if (args.apiKey?.trim()) headers.Authorization = `Bearer ${args.apiKey.trim()}`;
+  if (args.body !== void 0) headers["Content-Type"] = "application/json";
+  let lastError;
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const res = await fetch(url, {
+        method: args.method ?? "GET",
+        headers,
+        body: args.body === void 0 ? void 0 : JSON.stringify(args.body),
+        signal: ac.signal
+      });
+      if (res.status === 429) {
+        const wait = Math.min(8e3, 500 * 2 ** attempt);
+        await sleep(wait);
+        lastError = new PendleApiError(`Pendle API rate limited (429) on ${path}`, 429, path);
+        continue;
+      }
+      const text = await res.text();
+      if (!res.ok) {
+        throw new PendleApiError(
+          `Pendle API ${res.status} ${path}: ${text.slice(0, 400)}`,
+          res.status,
+          path
+        );
+      }
+      if (!text.trim()) return {};
+      return JSON.parse(text);
+    } catch (err) {
+      lastError = err;
+      if (err instanceof PendleApiError && err.status !== 429) throw err;
+      if (attempt < 3 && (err instanceof PendleApiError || err?.name === "AbortError")) {
+        await sleep(Math.min(8e3, 400 * 2 ** attempt));
+        continue;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+// src/protocols/evm/pendle/discover.ts
+var marketsCacheByChain = /* @__PURE__ */ new Map();
+var chainIdsCache = null;
+function asRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function asNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number.parseFloat(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function asString(v) {
+  if (typeof v === "string" && v.trim()) return v.trim();
+  return null;
+}
+function asExpiry(v) {
+  const s = asString(v);
+  if (s) return s;
+  const n = asNumber(v);
+  if (n == null) return null;
+  const ms = n < 1e12 ? n * 1e3 : n;
+  return new Date(ms).toISOString();
+}
+function pendleMarketExpiryMs(expiry) {
+  const raw = (expiry ?? "").trim();
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) {
+    const n = Number(raw);
+    return n < 1e12 ? n * 1e3 : n;
+  }
+  const t = Date.parse(raw);
+  return Number.isFinite(t) ? t : null;
+}
+function isPendleMarketExpired(row, nowMs = Date.now()) {
+  const t = pendleMarketExpiryMs(row.expiry);
+  if (t == null) return false;
+  return t <= nowMs;
+}
+function marketMatchesPin(row, address) {
+  const a = address.trim().toLowerCase();
+  if (!a) return false;
+  return [row.address, row.pt, row.yt, row.sy].some((x) => x.toLowerCase() === a);
+}
+function selectPendleListingMarkets(rows, args = {}) {
+  const nowMs = args.nowMs ?? Date.now();
+  const cap = args.cap ?? PENDLE_LISTING_CAP;
+  const pins = (args.includeAddresses ?? []).map((a) => a.trim().toLowerCase()).filter(Boolean);
+  const q = (args.query ?? "").trim();
+  let out = rows.filter((r) => {
+    const pinned = pins.some((p) => marketMatchesPin(r, p));
+    if (!args.includeExpired && !pinned && isPendleMarketExpired(r, nowMs)) return false;
+    if (args.pointsOnly && r.points.length === 0) return false;
+    if (q && !marketMatchesQuery(r, q)) return false;
+    return true;
+  });
+  out.sort(sortPendleMarketsByTvl);
+  return out.slice(0, cap);
+}
+function addressFromAssetIdOrHex(raw, fallbackChainId) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const parsed = parsePendleAssetId(raw);
+  if (parsed) {
+    try {
+      return viem.getAddress(parsed.address);
+    } catch {
+      return parsed.address.toLowerCase();
+    }
+  }
+  if (viem.isAddress(raw)) return viem.getAddress(raw);
+  if (raw.startsWith(`${fallbackChainId}-`)) {
+    const rest = raw.slice(String(fallbackChainId).length + 1);
+    if (viem.isAddress(rest)) return viem.getAddress(rest);
+  }
+  return null;
+}
+function parsePoints(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    const o = asRecord(item);
+    if (!o) continue;
+    const name = asString(o.name) ?? asString(o.key) ?? asString(o.pointName);
+    if (!name) continue;
+    out.push({
+      name,
+      type: asString(o.type),
+      pendleAsset: asString(o.pendleAsset),
+      value: asNumber(o.value)
+    });
+  }
+  return out;
+}
+function marketTvlUsd(row) {
+  return row.tvlUsd ?? row.liquidityUsd ?? 0;
+}
+function sortPendleMarketsByTvl(a, b) {
+  const d = marketTvlUsd(b) - marketTvlUsd(a);
+  if (d !== 0) return d;
+  return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+function parsePendleMarket(raw) {
+  const o = asRecord(raw);
+  if (!o) return null;
+  const chainId = asNumber(o.chainId);
+  const address = addressFromAssetIdOrHex(o.address, chainId ?? 0);
+  if (chainId == null || !address) return null;
+  const details = asRecord(o.details);
+  const tvl = asNumber(o.tvl) ?? asNumber(details?.tvl) ?? asNumber(details?.totalTvl) ?? asNumber(asRecord(details?.liquidity)?.usd);
+  const liquidity = asNumber(o.liquidity) ?? asNumber(details?.liquidity) ?? asNumber(asRecord(details?.liquidity)?.usd);
+  const impliedApy = asNumber(o.impliedApy) ?? asNumber(details?.impliedApy) ?? asNumber(asRecord(o.pt)?.impliedApy);
+  const pt = addressFromAssetIdOrHex(o.pt ?? asRecord(o.pt)?.address ?? asRecord(o.pt)?.id, chainId);
+  const yt = addressFromAssetIdOrHex(o.yt ?? asRecord(o.yt)?.address ?? asRecord(o.yt)?.id, chainId);
+  const sy = addressFromAssetIdOrHex(o.sy ?? asRecord(o.sy)?.address ?? asRecord(o.sy)?.id, chainId);
+  const underlying = addressFromAssetIdOrHex(
+    o.underlyingAsset ?? o.underlying ?? asRecord(o.underlyingAsset)?.address,
+    chainId
+  );
+  if (!pt || !yt || !sy || !underlying) return null;
+  const expired = asExpiry(o.expiry) ?? asExpiry(details?.expiry);
+  return {
+    chainId,
+    name: asString(o.name) ?? asString(o.proSymbol) ?? `${address.slice(0, 8)}\u2026`,
+    address,
+    expiry: expired,
+    pt,
+    yt,
+    sy,
+    underlying,
+    underlyingSymbol: asString(asRecord(o.underlyingAsset)?.symbol) ?? asString(o.underlyingSymbol),
+    ptSymbol: asString(asRecord(o.pt)?.symbol) ?? asString(o.ptSymbol),
+    ytSymbol: asString(asRecord(o.yt)?.symbol) ?? asString(o.ytSymbol),
+    impliedApy,
+    tvlUsd: tvl,
+    liquidityUsd: liquidity,
+    points: parsePoints(o.points ?? details?.points)
+  };
+}
+async function pendleFetchSupportedChainIds() {
+  const now = Date.now();
+  if (chainIdsCache && now - chainIdsCache.at < PENDLE_CHAIN_CACHE_MS) return chainIdsCache.chainIds;
+  const json = await pendleCoreFetch({ path: "/v1/chains" });
+  const ids = Array.isArray(json.chainIds) ? json.chainIds.map((n) => Number(n)).filter((n) => Number.isFinite(n) && n > 0) : [];
+  chainIdsCache = { at: now, chainIds: ids };
+  return ids;
+}
+async function isPendleChainSupported(chainId) {
+  try {
+    const ids = await pendleFetchSupportedChainIds();
+    if (ids.length === 0) return true;
+    return ids.includes(chainId);
+  } catch {
+    return true;
+  }
+}
+async function pendleFetchMarketsPage(args) {
+  const limit = Math.min(PENDLE_LISTING_CAP, Math.max(1, args.limit));
+  const json = await pendleCoreFetch({
+    path: "/v2/markets/all",
+    query: {
+      skip: args.skip ?? 0,
+      limit,
+      ...args.chainId != null ? { chainId: args.chainId } : {}
+    }
+  });
+  const raw = Array.isArray(json.markets) ? json.markets : Array.isArray(json.results) ? json.results : [];
+  const rows = [];
+  for (const item of raw) {
+    const row = parsePendleMarket(item);
+    if (row) rows.push(row);
+  }
+  return rows;
+}
+async function pendleFetchMarketsForChain(chainId) {
+  const now = Date.now();
+  const cached2 = marketsCacheByChain.get(chainId);
+  if (cached2 && now - cached2.at < PENDLE_ICON_CACHE_MS) return cached2.rows;
+  const rows = [];
+  for (let page = 0; page < PENDLE_LISTING_MAX_PAGES; page++) {
+    const batch = await pendleFetchMarketsPage({
+      skip: page * PENDLE_LISTING_CAP,
+      limit: PENDLE_LISTING_CAP,
+      chainId
+    });
+    const onChain = batch.filter((r) => r.chainId === chainId);
+    rows.push(...onChain);
+    if (batch.length < PENDLE_LISTING_CAP || onChain.length === 0) break;
+  }
+  marketsCacheByChain.set(chainId, { at: now, rows });
+  return rows;
+}
+function marketMatchesQuery(row, query) {
+  const q = query.trim();
+  if (!q) return true;
+  if (matchesAssetFilter({ address: row.address, symbol: row.name, filter: q }) || matchesAssetFilter({ address: row.pt, symbol: row.ptSymbol ?? void 0, filter: q }) || matchesAssetFilter({ address: row.yt, symbol: row.ytSymbol ?? void 0, filter: q }) || matchesAssetFilter({ address: row.sy, filter: q }) || matchesAssetFilter({ address: row.underlying, symbol: row.underlyingSymbol ?? void 0, filter: q })) {
+    return true;
+  }
+  const hay = `${row.name} ${row.ptSymbol ?? ""} ${row.ytSymbol ?? ""} ${row.underlyingSymbol ?? ""}`.toLowerCase();
+  return hay.includes(q.toLowerCase());
+}
+async function pendleFetchMarketsSummary(args) {
+  if (!await isPendleChainSupported(args.chainId)) {
+    return {
+      chainId: args.chainId,
+      markets: [],
+      notes: `Pendle Core API does not list chain ${args.chainId}.`
+    };
+  }
+  const scanned = await pendleFetchMarketsForChain(args.chainId);
+  const rows = selectPendleListingMarkets(scanned, {
+    query: args.query,
+    pointsOnly: args.pointsOnly,
+    includeAddresses: args.includeAddresses
+  });
+  const expiredOmitted = scanned.filter((r) => isPendleMarketExpired(r)).length;
+  return {
+    chainId: args.chainId,
+    markets: rows,
+    notes: `Top ${rows.length} active Pendle markets on chain ${args.chainId} by TVL/liquidity (scanned ${scanned.length}, omitted ${expiredOmitted} matured). Use ctm_pendle_search_assets for long-tail or expired markets (PT redeem / remove LP). Do not web-search Pendle APYs.`
+  };
+}
+
+// src/protocols/evm/pendle/index.ts
+var pendleProtocolModule = {
+  id: PENDLE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    if (!Number.isFinite(n)) return false;
+    return isPendleChainSupported(n);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    { id: "pendle.fetch-markets", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "List live Pendle markets (TVL-ranked, cap 100, matured omitted)", commonParams: [], params: {} },
+    { id: "pendle.search-assets", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Search live PT/YT/SY/underlying (matured only if address-pinned)", commonParams: [], params: {} },
+    { id: "pendle.swap", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Swap token \u2194 PT/YT via Hosted SDK convert", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.mint-py", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Mint PT + YT", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.redeem-py", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Redeem PT + YT (PT only after expiry)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.add-liquidity", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Add Pendle AMM liquidity", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.fetch-positions", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "List this wallet\u2019s Pendle LP (including matured)", commonParams: [], params: {} },
+    { id: "pendle.remove-liquidity", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Remove Pendle AMM liquidity", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.redeem-rewards", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Redeem on-chain SY/YT/LP interest and incentives (not merkle airdrops)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(pendleProtocolModule);
 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",
@@ -9189,8 +10589,10 @@ var SKILL_PROTOCOL_IDS = [
   "morpho",
   "circle-cctp",
   "aerodrome",
+  "pendle",
   "continuum-dao",
-  "compound-v3"
+  "compound-v3",
+  "yield-compare"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -9239,6 +10641,9 @@ function getProtocolDiscoverySummary(protocolId) {
   };
 }
 init_support();
+init_support2();
+init_addresses();
+init_stockTokens();
 function advisor(protocolId, tokenFilter, impl) {
   return { protocolId, tokenFilter, ...impl };
 }
@@ -9509,7 +10914,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."
       };
     }
   }),
@@ -9665,6 +11070,55 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return cache.has(normalized);
     }
   }),
+  [PENDLE_PROTOCOL_ID]: advisor(PENDLE_PROTOCOL_ID, "api_underlyings", {
+    async supportedChainIds() {
+      try {
+        return [...await pendleFetchSupportedChainIds()].sort((a, b) => a - b);
+      } catch {
+        return [];
+      }
+    },
+    async supportedTokens(chainId) {
+      if (!await isPendleChainSupported(chainId)) {
+        return { tokens: [], notes: `Pendle Core API does not list chain ${chainId}.` };
+      }
+      const listed = await pendleFetchMarketsSummary({ chainId });
+      const byAddr = /* @__PURE__ */ new Map();
+      const add = (address, symbol, roles) => {
+        const key = address.toLowerCase();
+        const prev = byAddr.get(key);
+        byAddr.set(key, {
+          address,
+          symbol: symbol ?? prev?.symbol,
+          roles: [.../* @__PURE__ */ new Set([...prev?.roles ?? [], ...roles])]
+        });
+      };
+      for (const m of listed.markets) {
+        add(m.underlying, m.underlyingSymbol, ["underlying"]);
+        add(m.pt, m.ptSymbol, ["pt"]);
+        add(m.yt, m.ytSymbol, ["yt"]);
+        add(m.sy, null, ["sy"]);
+        add(m.address, m.name, ["lp", "market"]);
+      }
+      return {
+        tokens: [...byAddr.values()],
+        notes: "Official Pendle live (unexpired) TVL-ranked markets on this chain, cap 100 (PT/YT/SY/LP + underlyings). Use ctm_pendle_search_assets for long-tail or matured markets. Use ctm_pendle_fetch_positions for this wallet\u2019s LP (including matured). Do not hardcode routers."
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      if (!await isPendleChainSupported(chainId)) return false;
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      const listed = await pendleFetchMarketsSummary({ chainId });
+      return listed.markets.some(
+        (m) => m.address.toLowerCase() === normalized || m.pt.toLowerCase() === normalized || m.yt.toLowerCase() === normalized || m.sy.toLowerCase() === normalized || m.underlying.toLowerCase() === normalized
+      );
+    }
+  }),
   arcus: advisor("arcus", "api_underlyings", {
     async supportedChainIds() {
       return [...ARCUS_SUPPORTED_CHAIN_IDS];
@@ -9702,6 +11156,7 @@ registerProtocolModule(veniceProtocolModule);
 registerProtocolModule(aerodromeProtocolModule);
 registerProtocolModule(continuumDaoProtocolModule);
 registerProtocolModule(compoundV3ProtocolModule);
+registerProtocolModule(pendleProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -9727,6 +11182,7 @@ function getAgentCatalog() {
     aerodrome: aerodromeProtocolModule,
     continuumDao: continuumDaoProtocolModule,
     compoundV3: compoundV3ProtocolModule,
+    pendle: pendleProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -9762,6 +11218,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 +11238,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 +11364,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 +11439,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 +11460,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;
@@ -10010,9 +11499,37 @@ exports.mcpMorphoVaultWithdrawInputSchema = mcpMorphoVaultWithdrawInputSchema;
 exports.mcpMultisignInput = mcpMultisignInput;
 exports.mcpMultisignOutputSchema = multisignOutputSchema;
 exports.mcpMultisignSubmitOutputSchema = mcpServerSubmitOutputSchema;
+exports.mcpPendleBuildAddLiquidityMultisignInputSchema = mcpPendleBuildAddLiquidityMultisignInputSchema;
+exports.mcpPendleBuildMintPyMultisignInputSchema = mcpPendleBuildMintPyMultisignInputSchema;
+exports.mcpPendleBuildMintSyMultisignInputSchema = mcpPendleBuildMintSyMultisignInputSchema;
+exports.mcpPendleBuildRedeemPyMultisignInputSchema = mcpPendleBuildRedeemPyMultisignInputSchema;
+exports.mcpPendleBuildRedeemRewardsMultisignInputSchema = mcpPendleBuildRedeemRewardsMultisignInputSchema;
+exports.mcpPendleBuildRedeemSyMultisignInputSchema = mcpPendleBuildRedeemSyMultisignInputSchema;
+exports.mcpPendleBuildRemoveLiquidityMultisignInputSchema = mcpPendleBuildRemoveLiquidityMultisignInputSchema;
+exports.mcpPendleBuildSwapMultisignInputSchema = mcpPendleBuildSwapMultisignInputSchema;
+exports.mcpPendleFetchMarketsInputSchema = mcpPendleFetchMarketsInputSchema;
+exports.mcpPendleFetchMarketsOutputSchema = mcpPendleFetchMarketsOutputSchema;
+exports.mcpPendleFetchMerkleRewardsInputSchema = mcpPendleFetchMerkleRewardsInputSchema;
+exports.mcpPendleFetchMerkleRewardsOutputSchema = mcpPendleFetchMerkleRewardsOutputSchema;
+exports.mcpPendleFetchPositionsInputSchema = mcpPendleFetchPositionsInputSchema;
+exports.mcpPendleFetchPositionsOutputSchema = mcpPendleFetchPositionsOutputSchema;
+exports.mcpPendleFetchPricesInputSchema = mcpPendleFetchPricesInputSchema;
+exports.mcpPendleFetchPricesOutputSchema = mcpPendleFetchPricesOutputSchema;
+exports.mcpPendleQuoteAddLiquidityInputSchema = mcpPendleQuoteAddLiquidityInputSchema;
+exports.mcpPendleQuoteMintPyInputSchema = mcpPendleQuoteMintPyInputSchema;
+exports.mcpPendleQuoteMintSyInputSchema = mcpPendleQuoteMintSyInputSchema;
+exports.mcpPendleQuoteOutputSchema = mcpPendleQuoteOutputSchema;
+exports.mcpPendleQuoteRedeemPyInputSchema = mcpPendleQuoteRedeemPyInputSchema;
+exports.mcpPendleQuoteRedeemSyInputSchema = mcpPendleQuoteRedeemSyInputSchema;
+exports.mcpPendleQuoteRemoveLiquidityInputSchema = mcpPendleQuoteRemoveLiquidityInputSchema;
+exports.mcpPendleQuoteSwapInputSchema = mcpPendleQuoteSwapInputSchema;
+exports.mcpPendleSearchAssetsInputSchema = mcpPendleSearchAssetsInputSchema;
+exports.mcpPendleSearchAssetsOutputSchema = mcpPendleSearchAssetsOutputSchema;
 exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;
 exports.mcpServerMultisignInput = mcpServerMultisignInput;
 exports.mcpServerSubmitOutputSchema = mcpServerSubmitOutputSchema;
+exports.mcpSkyFetchSusdsRateInputSchema = mcpSkyFetchSusdsRateInputSchema;
+exports.mcpSkyFetchSusdsRateOutputSchema = mcpSkyFetchSusdsRateOutputSchema;
 exports.mcpSkyLockstakeCloseInputSchema = mcpSkyLockstakeCloseInputSchema;
 exports.mcpSkyLockstakeDrawInputSchema = mcpSkyLockstakeDrawInputSchema;
 exports.mcpSkyLockstakeGetRewardInputSchema = mcpSkyLockstakeGetRewardInputSchema;