@continuumdao/ctm-mpc-defi 0.2.56 → 0.2.58

package/dist/agent/catalog.cjs

@@ -48,6 +48,111 @@ var init_chainIdParse = __esm({
   "src/chains/evm/chainIdParse.ts"() {
   }
 });
+function isCoinbaseB20AssetToken(address) {
+  try {
+    return viem.getAddress(address).toLowerCase().startsWith(COINBASE_B20_ASSET_PREFIX);
+  } catch {
+    return false;
+  }
+}
+function looksLikeCoinbaseStockSymbol(symbol) {
+  return /^[A-Za-z][A-Za-z0-9]{0,8}(?:\.[A-Za-z][A-Za-z0-9]{0,4})?c$/.test((symbol ?? "").trim());
+}
+function indexCatalog(rows) {
+  catalogRows = rows;
+  catalogAt = Date.now();
+  catalogBySymbol.clear();
+  catalogByAddress.clear();
+  for (const row of rows) {
+    catalogBySymbol.set(row.symbol.toLowerCase(), row);
+    catalogByAddress.set(row.address.toLowerCase(), row);
+  }
+}
+function parseCoinbaseTokenizedStocksPayload(payload) {
+  const tokens = Array.isArray(payload) ? payload : payload && typeof payload === "object" && Array.isArray(payload.tokens) ? payload.tokens : [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of tokens) {
+    if (!row || typeof row !== "object") continue;
+    const rec = row;
+    const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
+    const addressRaw = typeof rec.contract_address === "string" ? rec.contract_address.trim() : "";
+    if (!looksLikeCoinbaseStockSymbol(symbol) || !isCoinbaseB20AssetToken(addressRaw)) continue;
+    const address = viem.getAddress(addressRaw);
+    const key = address.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const name = typeof rec.name === "string" && rec.name.trim() ? rec.name.trim() : symbol;
+    const iconUrl = typeof rec.icon_url === "string" && rec.icon_url.trim() ? rec.icon_url.trim() : void 0;
+    const decimals = typeof rec.decimals === "number" && Number.isInteger(rec.decimals) && rec.decimals >= 0 && rec.decimals <= 18 ? rec.decimals : COINBASE_B20_STOCK_DECIMALS;
+    out.push({ address, symbol, name, decimals, iconUrl });
+    if (out.length >= CATALOG_MAX) break;
+  }
+  return out;
+}
+async function fetchCoinbaseB20StockCatalog() {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  let pageToken = "";
+  for (let page = 0; page < 4; page++) {
+    const url = new URL(COINBASE_TOKENIZED_STOCKS_API_URL);
+    url.searchParams.set("page_size", "500");
+    if (pageToken) url.searchParams.set("page_token", pageToken);
+    const res = await fetch(url, { cache: "no-store", signal: AbortSignal.timeout(8e3) });
+    if (!res.ok) break;
+    const json = await res.json();
+    for (const row of parseCoinbaseTokenizedStocksPayload(json)) {
+      const key = row.address.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      merged.push(row);
+      if (merged.length >= CATALOG_MAX) break;
+    }
+    pageToken = typeof json.next_page_token === "string" ? json.next_page_token.trim() : "";
+    if (!pageToken || merged.length >= CATALOG_MAX) break;
+  }
+  if (merged.length > 0) indexCatalog(merged);
+  return catalogRows ?? [];
+}
+async function ensureCoinbaseB20StockCatalog() {
+  if (catalogRows && catalogRows.length > 0 && Date.now() - catalogAt < CATALOG_TTL_MS) return catalogRows;
+  if (!catalogInflight) {
+    catalogInflight = fetchCoinbaseB20StockCatalog().finally(() => {
+      catalogInflight = null;
+    });
+  }
+  try {
+    return await catalogInflight;
+  } catch {
+    return catalogRows ?? [];
+  }
+}
+function lookupCoinbaseB20StockToken(token) {
+  const key = (token ?? "").trim();
+  if (!key) return null;
+  const fromCatalog = catalogBySymbol.get(key.toLowerCase());
+  if (fromCatalog) return fromCatalog;
+  try {
+    return catalogByAddress.get(viem.getAddress(key).toLowerCase()) ?? null;
+  } catch {
+    return null;
+  }
+}
+var COINBASE_B20_STOCK_DECIMALS, COINBASE_B20_ASSET_PREFIX, COINBASE_TOKENIZED_STOCKS_API_URL, CATALOG_TTL_MS, CATALOG_MAX, catalogRows, catalogAt, catalogInflight, catalogBySymbol, catalogByAddress;
+var init_coinbaseB20 = __esm({
+  "src/protocols/evm/shared/coinbaseB20.ts"() {
+    COINBASE_B20_STOCK_DECIMALS = 8;
+    COINBASE_B20_ASSET_PREFIX = "0xb200000000000000000000";
+    COINBASE_TOKENIZED_STOCKS_API_URL = "https://api.coinbase.com/v1/tokenized-stocks";
+    CATALOG_TTL_MS = 15 * 60 * 1e3;
+    CATALOG_MAX = 500;
+    catalogRows = null;
+    catalogAt = 0;
+    catalogInflight = null;
+    catalogBySymbol = /* @__PURE__ */ new Map();
+    catalogByAddress = /* @__PURE__ */ new Map();
+  }
+});
 function defiEvmTransport(rpcUrl, opts) {
   const url = rpcUrl.trim();
   return viem.http(url, opts);
@@ -183,7 +288,7 @@ var init_constants = __esm({
       rewards: viem.zeroAddress,
       governor: viem.zeroAddress
     };
-    CTM_TOKEN_ADDRESS = viem.getAddress("0x2026027054F5beBCEB650aBD62dC623e327658e7");
+    CTM_TOKEN_ADDRESS = viem.getAddress("0x7581696b0ED142f6534E5797baaABBb9a1b27086");
     VOTING_ESCROW_LINEA_ADDRESS = viem.getAddress("0x221EC90B3B083A8501A37bdeb7035CeaedF3C31f");
     viem.getAddress("0x4ebd7cCBe32a51d1638cFE90E8eD1c4BdF42f729");
     VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS = viem.getAddress("0x92557d38beAe4658d3c03A02F349FFB60c3bfFA5");
@@ -520,27 +625,6 @@ var init_midnightApi = __esm({
     init_midnightConstants();
   }
 });
-var COINBASE_B20_STOCK_TOKENS, COINBASE_B20_STOCK_DECIMALS;
-var init_coinbaseB20 = __esm({
-  "src/protocols/evm/shared/coinbaseB20.ts"() {
-    COINBASE_B20_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" }
-    ];
-    COINBASE_B20_STOCK_DECIMALS = 8;
-  }
-});
 function isAerodromeChainSupported(chainId) {
   const n = typeof chainId === "number" ? chainId : Number.parseInt(String(chainId), 10);
   return n === AERODROME_CHAIN_ID;
@@ -944,9 +1028,9 @@ async function loadFullCurveSessionForRpc(rpcUrl) {
   if (!url) {
     throw new Error("rpcUrl is required.");
   }
-  const cached2 = curveSessionCache.get(url);
-  if (cached2 && cached2.expiresAt > Date.now()) {
-    return cached2.session;
+  const cached3 = curveSessionCache.get(url);
+  if (cached3 && cached3.expiresAt > Date.now()) {
+    return cached3.session;
   }
   try {
     const { default: curve } = await import('@curvefi/api');
@@ -1309,7 +1393,108 @@ function parseMultisignBuilderOutput(data) {
   return multisignOutputSchema.parse(data);
 }
 
+// src/protocols/evm/aave-v4/api.ts
+init_defiProxy();
+init_coinbaseB20();
+var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
+async function aaveV4Gql(query, variables) {
+  const body = { query, variables: variables ?? {} };
+  const j = await postJsonViaOptionalProxy({
+    directUrl: AAVE_V4_GRAPHQL_URL,
+    body,
+    proxyUrl: getAaveGraphqlProxyUrl(),
+    proxyEnvelope: body
+  });
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
+    throw new Error(msg);
+  }
+  if (j.data == null) {
+    throw new Error("Aave V4 API: empty response");
+  }
+  return j.data;
+}
+async function fetchAaveV4Chains() {
+  const d = await aaveV4Gql(`
+    query C($c: ChainsRequest!) { chains(request: $c) { chainId name nativeWrappedToken } }
+  `, { c: { query: { filter: "ALL" } } });
+  return d.chains ?? [];
+}
+async function loadAaveV4SupportedChainIdsFromV4Api() {
+  const rows = await fetchAaveV4Chains();
+  const s = /* @__PURE__ */ new Set();
+  for (const c of rows) s.add(c.chainId);
+  return s;
+}
+var RESERVES_ADDRESS_FRAGMENT = `
+  asset { underlying { address } }
+`;
+async function fetchAaveV4NativeWrappedToken(chainId) {
+  const all = await fetchAaveV4Chains();
+  const c = all.find((x) => x.chainId === chainId);
+  const t = (c?.nativeWrappedToken ?? "").trim();
+  if (t && viem.isAddress(t)) return viem.getAddress(t);
+  return null;
+}
+async function fetchAaveV4SupportedUnderlyingAddressSet(chainId) {
+  const d = await aaveV4Gql(
+    `
+    query A($r: ReservesRequest!) { reserves(request: $r) { ${RESERVES_ADDRESS_FRAGMENT} } }
+  `,
+    {
+      r: {
+        query: { chainIds: [chainId] },
+        filter: "ALL",
+        orderBy: { supplyApy: "DESC" }
+      }
+    }
+  );
+  const s = /* @__PURE__ */ new Set();
+  for (const r of d.reserves ?? []) {
+    const a = (r.asset?.underlying?.address ?? "").trim();
+    if (a && viem.isAddress(a)) s.add(a.toLowerCase());
+  }
+  return s;
+}
+var aaveV4ChainTokenCache = /* @__PURE__ */ new Map();
+function ensureAaveV4ChainTokenCache(chainId) {
+  const hit = aaveV4ChainTokenCache.get(chainId);
+  if (hit) return hit;
+  const p = (async () => {
+    const [nativeWrapped, supportedUnderlying] = await Promise.all([
+      fetchAaveV4NativeWrappedToken(chainId),
+      fetchAaveV4SupportedUnderlyingAddressSet(chainId)
+    ]);
+    return { supportedUnderlying, nativeWrapped };
+  })();
+  aaveV4ChainTokenCache.set(chainId, p);
+  return p;
+}
+function parseAaveV4UiMarketId(raw) {
+  const t = (raw ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+  if (!t) return void 0;
+  if (t === "core") return "core";
+  if (t === "bluechip" || t === "prime" || t === "institutional") return "bluechip";
+  if (t === "main" || t === "plus" || t === "default") return "main";
+  if (t === "bstocks" || t === "bstock" || t === "b stocks" || t === "stocks" || t === "stock" || t === "equities" || t === "equity" || t === "coinbase stocks" || t === "tokenized stocks" || t === "tokenised stocks") {
+    return "bstocks";
+  }
+  return void 0;
+}
+function resolveAaveV4UnderlyingAddress(token) {
+  const raw = (token ?? "").trim();
+  if (!raw) return null;
+  if (viem.isAddress(raw)) return viem.getAddress(raw);
+  return lookupCoinbaseB20StockToken(raw)?.address ?? null;
+}
+
 // src/agent/schemas/chainPreprocess.ts
+function rewriteAaveV4AssetField(o, key) {
+  const raw = String(o[key] ?? "").trim();
+  if (!raw || viem.isAddress(raw)) return;
+  const resolved = resolveAaveV4UnderlyingAddress(raw);
+  if (resolved) o[key] = resolved;
+}
 function preprocessObject(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   return { ...raw };
@@ -1651,6 +1836,12 @@ function preprocessAaveMultisignInput(action) {
   return (raw) => {
     const o = preprocessObject(raw);
     if (!o) return raw;
+    rewriteAaveV4AssetField(o, "underlying");
+    rewriteAaveV4AssetField(o, "collateralUnderlying");
+    if (typeof o.marketId === "string") {
+      const id = parseAaveV4UiMarketId(o.marketId);
+      if (id) o.marketId = id;
+    }
     derivePurposeIfMissing(o, (x) => {
       const amt = String(x.amountHuman ?? "").trim();
       const asset = String(x.underlying ?? "").trim();
@@ -1667,8 +1858,8 @@ var uniswapQuoteTradeTypeSchema = zod.z.enum(["EXACT_INPUT", "EXACT_OUTPUT"]);
 var mcpUniswapV4QuoteInputSchema = zod.z.object({
   type: uniswapQuoteTradeTypeSchema.describe("EXACT_INPUT or EXACT_OUTPUT"),
   amount: zod.z.string().min(1).describe("Amount in token-in base units (wei string for ERC-20)"),
-  tokenIn: zod.z.string().min(1).describe("Input token; 0x0 for native ETH"),
-  tokenOut: zod.z.string().min(1).describe("Output token address"),
+  tokenIn: zod.z.string().min(1).describe("Input token address or Coinbase stock ticker (AAPLc); 0x0 for native ETH"),
+  tokenOut: zod.z.string().min(1).describe("Output token address or Coinbase stock ticker (AAPLc)"),
   chainId: agentEvmChainIdSchema.describe("tokenInChainId / same-chain default"),
   uniswapApiKey: zod.z.string().min(1).describe("Uniswap Trade API x-api-key"),
   swapper: evmAddressSchema.optional().describe("MPC executor; omit if keyGen + managementNodeUrl provided"),
@@ -1704,7 +1895,9 @@ var mcpUniswapV4BuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
   zod.z.preprocess(
     preprocessUniswapBuildSwapInput,
     evmMultisignCommonInputSchema.extend({
-      tokenIn: evmAddressSchema.describe("Token in; 0x0 for native ETH"),
+      tokenIn: evmAddressSchema.describe(
+        "Token in address or Coinbase stock ticker (AAPLc); 0x0 for native ETH"
+      ),
       swap: swapTxRequestSchema,
       createSwapResponse: zod.z.object({
         swap: swapTxRequestSchema,
@@ -1721,8 +1914,8 @@ var mcpUniswapV4LimitOrderQuoteInputSchema = zod.z.object({
   type: uniswapQuoteTradeTypeSchema.describe("EXACT_INPUT or EXACT_OUTPUT"),
   amount: zod.z.string().min(1).describe("Amount in token-in base units (wei string for ERC-20)"),
   limitPrice: zod.z.string().min(1).describe("Limit price string from Trade API (pair exchange rate)"),
-  tokenIn: zod.z.string().min(1).describe("Input token; 0x0 for native ETH"),
-  tokenOut: zod.z.string().min(1).describe("Output token address"),
+  tokenIn: zod.z.string().min(1).describe("Input token address or Coinbase stock ticker (AAPLc); 0x0 for native ETH"),
+  tokenOut: zod.z.string().min(1).describe("Output token address or Coinbase stock ticker (AAPLc)"),
   chainId: agentEvmChainIdSchema.describe("Must be 1 (Ethereum mainnet) for limit orders"),
   orderDeadline: agentCoercedIntSchema(zod.z.number().int().positive()).describe("Unix seconds when unfilled order expires"),
   uniswapApiKey: zod.z.string().min(1).describe("Uniswap Trade API x-api-key"),
@@ -2069,8 +2262,8 @@ var mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema = withMultisignKeySou
 var mcpCurveDaoQuoteInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema.describe("EVM chain id (rpcUrl resolved from get_chain_registry rpcGateway)"),
   rpcUrl: 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"),
-  tokenIn: zod.z.string().min(1).describe("Input token address, or 0xeeee\u2026 / 0x0 / eth for native"),
-  tokenOut: zod.z.string().min(1).describe("Output token address or 0xeeee\u2026 native placeholder"),
+  tokenIn: zod.z.string().min(1).describe("Input token address, Coinbase stock ticker (AAPLc), or 0xeeee\u2026 / 0x0 / eth for native"),
+  tokenOut: zod.z.string().min(1).describe("Output token address, Coinbase stock ticker (AAPLc), or 0xeeee\u2026 native placeholder"),
   amountHuman: zod.z.string().min(1).describe("Human-readable amount of tokenIn"),
   tokenInDecimals: zod.z.number().int().min(0).max(18).optional().describe("Token-in decimals; omit to read on-chain (native uses 18)")
 });
@@ -2081,8 +2274,10 @@ var mcpCurveDaoBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
   zod.z.preprocess(
     preprocessCurveBuildSwapInput,
     evmMultisignCommonInputSchema.extend({
-      tokenIn: evmAddressSchema.describe("ERC-20 sold (native in uses WETH path in UI)"),
-      tokenOut: zod.z.string().min(1).describe("Output token or 0xeeee\u2026 native placeholder"),
+      tokenIn: evmAddressSchema.describe(
+        "ERC-20 sold, or a Coinbase stock ticker (AAPLc). Native in uses the WETH path in the UI."
+      ),
+      tokenOut: zod.z.string().min(1).describe("Output token, Coinbase stock ticker (AAPLc), or 0xeeee\u2026 native placeholder"),
       amountHuman: zod.z.string().min(1).describe("Human-readable amount of tokenIn"),
       slippagePercent: zod.z.number().gt(0).lt(100).describe("Slippage 0\u2013100 exclusive"),
       quoteSnapshot: jsonObjectSchema.optional().describe("Optional quote row from ctm_curve_dao_quote \u2014 aliases tokenIn/tokenOut/amountHuman")
@@ -3033,7 +3228,9 @@ var mcpSkySusdsDepositInputSchema = mcpMultisignInput({
 var mcpSkySusdsRedeemInputSchema = mcpMultisignInput({
   sharesHuman: zod.z.string().min(1)
 });
-var mcpAaveV4MarketIdSchema = zod.z.string().min(1).optional().describe("UI market segment: main (Plus), core, or bluechip (Prime). Default main.");
+var mcpAaveV4MarketIdSchema = zod.z.string().min(1).optional().describe(
+  "UI market segment: main (Plus), core, bluechip (Prime), or bstocks (Base Coinbase tokenized stocks). Aliases: stocks, equities. Default main."
+);
 function mcpAaveV4MultisignInput(fields, action) {
   return withMultisignKeySourceRefine(
     zod.z.preprocess(preprocessAaveMultisignInput(action), evmMultisignCommonInputSchema.extend(fields))
@@ -3051,7 +3248,7 @@ var mcpAaveV4DepositInputSchema = mcpAaveV4MultisignInput(
   {
     spoke: evmAddressSchema.optional().describe("Omit \u2014 continuum-mcp-server resolves spoke from Aave v4 API."),
     underlying: evmAddressSchema.describe(
-      "Asset to supply. Native ETH: 0x0 or wrapped native with isNativeIn true."
+      "Asset to supply. Address, or a Base bStock ticker (AAPLc). Native ETH: 0x0 or wrapped native with isNativeIn true."
     ),
     amountHuman: zod.z.string().min(1),
     marketId: mcpAaveV4MarketIdSchema,
@@ -3067,7 +3264,7 @@ var mcpAaveV4DepositInputSchema = mcpAaveV4MultisignInput(
 var mcpAaveV4WithdrawInputSchema = mcpAaveV4MultisignInput(
   {
     spoke: evmAddressSchema.optional().describe("Omit \u2014 server resolves from Aave v4 API."),
-    underlying: evmAddressSchema.describe("Supplied asset to withdraw."),
+    underlying: evmAddressSchema.describe("Supplied asset to withdraw. Address or bStock ticker (AAPLc)."),
     amountHuman: zod.z.string().min(1),
     marketId: mcpAaveV4MarketIdSchema,
     ...mcpAaveV4HealthPreviewFields
@@ -3077,10 +3274,14 @@ var mcpAaveV4WithdrawInputSchema = mcpAaveV4MultisignInput(
 var mcpAaveV4BorrowInputSchema = mcpAaveV4MultisignInput(
   {
     spoke: evmAddressSchema.optional().describe("Omit \u2014 server resolves from Aave v4 API."),
-    underlying: evmAddressSchema.describe("Debt asset to borrow (e.g. USDC), not collateral."),
+    underlying: evmAddressSchema.describe(
+      "Debt asset to borrow (e.g. USDC), not collateral. On bstocks the equities are not borrowable."
+    ),
     amountHuman: zod.z.string().min(1),
     marketId: mcpAaveV4MarketIdSchema,
-    collateralUnderlying: evmAddressSchema.optional().describe("Collateral token already supplied; helps pick hub when debt exists on multiple hubs."),
+    collateralUnderlying: evmAddressSchema.optional().describe(
+      "Collateral token already supplied (address or bStock ticker such as AAPLc). Helps pick the hub when debt exists on multiple hubs."
+    ),
     ...mcpAaveV4HealthPreviewFields
   },
   "borrow"
@@ -3088,7 +3289,7 @@ var mcpAaveV4BorrowInputSchema = mcpAaveV4MultisignInput(
 var mcpAaveV4RepayInputSchema = mcpAaveV4MultisignInput(
   {
     spoke: evmAddressSchema.optional().describe("Omit \u2014 server resolves from Aave v4 API."),
-    underlying: evmAddressSchema.describe("Debt token to repay."),
+    underlying: evmAddressSchema.describe("Debt token to repay. On bstocks this is USDC."),
     amountHuman: zod.z.string().min(1),
     marketId: mcpAaveV4MarketIdSchema,
     ...mcpAaveV4HealthPreviewFields
@@ -4266,11 +4467,18 @@ var mcpMapleFetchMarketInputSchema = zod.z.object({
   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 aaveV4UiMarketIdEnum = zod.z.enum(["main", "core", "bluechip", "bstocks"]);
+function preprocessAaveV4MarketId(value) {
+  if (typeof value !== "string") return value;
+  return parseAaveV4UiMarketId(value) ?? value;
+}
+var mcpAaveV4UiMarketIdSchema = zod.z.preprocess(preprocessAaveV4MarketId, aaveV4UiMarketIdEnum.optional()).describe(
+  "UI market segment: main (Plus), core, bluechip (Prime), or bstocks (Base Coinbase tokenized stocks). Aliases: stocks, equities. 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"]),
+  marketId: aaveV4UiMarketIdEnum,
   hubAddress: zod.z.string(),
   symbol: zod.z.string(),
   name: zod.z.string(),
@@ -4290,7 +4498,9 @@ var mcpAaveV4MarketSummarySchema = zod.z.object({
 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.")
+  underlying: zod.z.string().trim().min(1).optional().describe(
+    'Optional filter: ERC-20 address or ticker (USDT, USDC, AAPLc). "stock" lists bStock collateral. Omit to list all reserves.'
+  )
 });
 var mcpAaveV4FetchMarketsOutputSchema = zod.z.object({
   chainId: zod.z.number(),
@@ -4299,14 +4509,21 @@ var mcpAaveV4FetchMarketsOutputSchema = zod.z.object({
 });
 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."),
+  underlying: zod.z.string().trim().min(1).describe(
+    "Reserve underlying address or ticker (USDT, AAPLc). Prefer fetch_markets or fetch_stock_markets when listing rates."
+  ),
   marketId: mcpAaveV4UiMarketIdSchema
 });
 var mcpAaveV4FetchMarketOutputSchema = mcpAaveV4FetchMarketsOutputSchema;
+var mcpAaveV4FetchStockMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema.optional().describe("Defaults to Base 8453 (Coinbase Stocks hub)."),
+  underlying: zod.z.string().trim().min(1).optional().describe("B20 ticker or address (AAPLc), or USDC. Omit to list the whole Coinbase Stocks hub.")
+});
+var mcpAaveV4FetchStockMarketsOutputSchema = mcpAaveV4FetchMarketsOutputSchema;
 var mcpEulerV2FetchLendVaultsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   underlyingAddress: evmAddressSchema.describe(
-    "Underlying asset address from get_defi_protocol_supported_tokens."
+    "Underlying asset address, or a Coinbase stock ticker (AAPLc) from the live catalog."
   ),
   limit: agentCoercedOptionalIntSchema(zod.z.number().int().min(1).max(100)).describe("Max vault rows (default 30).")
 });
@@ -4328,7 +4545,7 @@ var mcpEulerV2FetchLendVaultsOutputSchema = zod.z.object({
 var mcpEulerV2FetchEarnVaultsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   underlyingAddress: evmAddressSchema.describe(
-    "Underlying asset address from get_defi_protocol_supported_tokens."
+    "Underlying asset address, or a Coinbase stock ticker (AAPLc) from the live catalog."
   ),
   limit: agentCoercedOptionalIntSchema(zod.z.number().int().min(1).max(100)).describe("Max vault rows (default 30).")
 });
@@ -4355,6 +4572,77 @@ var mcpLidoFetchStethAprOutputSchema = zod.z.object({
   source: zod.z.string(),
   notes: zod.z.string()
 });
+var mcpRailgunFetchPopularAssetsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from the chain registry. Agents should omit.")
+}).strict();
+var mcpRailgunFetchPopularAssetsOutputSchema = zod.z.object({
+  chainId: zod.z.number(),
+  tokens: zod.z.array(zod.z.object({ address: zod.z.string() }).strict()),
+  nativeWrapped: zod.z.string().optional(),
+  notes: zod.z.string()
+}).strict();
+var mcpRailgunFetchPrivateBalancesInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1).describe("KeyGen request id. The shielded wallet is stored on that KeyGen record."),
+  chainId: agentEvmChainIdSchema,
+  refresh: zod.z.boolean().optional().describe("Scan again and write the KeyGen record. Default reads the stored scan, and scans when none is stored.")
+}).strict();
+var mcpRailgunPrivateBalanceSchema = zod.z.object({
+  tokenAddress: zod.z.string(),
+  spendable: zod.z.string(),
+  pending: zod.z.string(),
+  symbol: zod.z.string().optional()
+}).strict();
+var mcpRailgunFetchPrivateBalancesOutputSchema = zod.z.object({
+  railgunAddress: zod.z.string(),
+  walletConfigured: zod.z.boolean(),
+  chainId: zod.z.number(),
+  scanned: zod.z.boolean(),
+  scanStatus: zod.z.enum(["scanning", "ready", "empty", "error", "unscanned"]),
+  balances: zod.z.array(mcpRailgunPrivateBalanceSchema),
+  notes: zod.z.string()
+}).strict();
+var mcpRailgunEnsureWalletInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1),
+  chainId: agentEvmChainIdSchema.optional()
+}).strict();
+var mcpRailgunEnsureWalletOutputSchema = zod.z.object({
+  railgunAddress: zod.z.string(),
+  created: zod.z.boolean()
+}).strict();
+var mcpRailgunShieldInputSchema = mcpMultisignInput({
+  tokenAddress: evmAddressSchema.describe("ERC-20 contract to shield"),
+  amountWei: zod.z.string().min(1).describe("Amount in wei"),
+  railgunAddress: zod.z.string().min(1).describe("Recipient 0zk address"),
+  shieldSignature: zod.z.string().min(1).optional().describe("personal_sign result from the first shield call. Omit on the first call.")
+});
+var mcpRailgunPrivateTransferInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1),
+  chainId: agentEvmChainIdSchema,
+  tokenAddress: evmAddressSchema,
+  amountWei: zod.z.string().min(1),
+  recipientAddress: zod.z.string().min(1).describe("Recipient 0zk address"),
+  memoText: zod.z.string().optional()
+}).strict();
+var mcpRailgunUnshieldInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1),
+  chainId: agentEvmChainIdSchema,
+  tokenAddress: evmAddressSchema,
+  amountWei: zod.z.string().min(1),
+  recipientAddress: evmAddressSchema.optional().describe("Public recipient. Defaults to this KeyGen Ethereum address.")
+}).strict();
+var mcpRailgunAgreeSpendInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1),
+  spendId: zod.z.string().min(1)
+}).strict();
+var mcpRailgunPrivateActionOutputSchema = zod.z.object({
+  status: zod.z.enum(["pending", "submitted", "failed"]),
+  spendId: zod.z.string(),
+  approvals: zod.z.number().int().nonnegative(),
+  quorum: zod.z.number().int().positive(),
+  txHash: zod.z.string().optional(),
+  error: zod.z.string().optional()
+}).strict();
 var mcpSkyFetchSusdsRateInputSchema = zod.z.object({
   rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
 }).strict();
@@ -4423,7 +4711,7 @@ var mcpPendleFetchMerkleRewardsOutputSchema = jsonObjectSchema.describe(
 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)."),
+  tokenIn: zod.z.string().min(1).describe("Underlying, PT, YT, or Coinbase stock ticker (AAPLc). 0xeeee / 0x0 = native."),
   tokenOut: zod.z.string().min(1),
   amountHuman: zod.z.string().min(1),
   slippagePercent: zod.z.number().gt(0).lt(100),
@@ -6097,7 +6385,7 @@ var mcpCctpFetchBurnFeesInputSchema = zod.z.object({
   transferAmountHuman: zod.z.string().min(1).optional().describe(
     "Human USDC amount the recipient receives (6 decimals). Required for a maxFee that includes the fast-transfer protocol fee and for totalBurn. Omit only to inspect raw forwarding tiers."
   ),
-  feeTier: zod.z.enum(["low", "med", "high"]).optional().describe("Iris forwardFee tier; default med"),
+  feeTier: zod.z.enum(["low", "med", "high"]).optional().describe("Iris forwardFee tier; default high"),
   minFinalityThreshold: agentCoercedOptionalIntSchema(zod.z.number().int().positive()).describe(
     "Iris fee row. 1000 (default) is fast transfer and includes minimumFee bps. 2000 is standard transfer."
   )
@@ -6134,7 +6422,7 @@ var mcpCctpBuildBurnMultisignInputSchema = mcpMultisignInput({
   destChainId: agentEvmChainIdSchema.describe("Destination chain EIP-155 id (mint chain)"),
   transferAmountHuman: zod.z.string().min(1).describe("Human USDC amount recipient receives"),
   mintRecipient: evmAddressSchema.optional().describe("Recipient on destination chain; defaults to MPC executor address"),
-  feeTier: zod.z.enum(["low", "med", "high"]).optional(),
+  feeTier: zod.z.enum(["low", "med", "high"]).optional().describe("Iris forwardFee tier; default high"),
   minFinalityThreshold: agentCoercedOptionalIntSchema(zod.z.number().int().positive()),
   feeSnapshot: jsonObjectSchema.optional().describe(
     "Optional output from ctm_cctp_fetch_burn_fees. Build re-quotes Iris. A snapshot maxFee below the live forward+protocol total is ignored; a higher snapshot is kept as a cap."
@@ -6558,7 +6846,7 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     actionId: "aave-v4.deposit",
     protocolId: "aave-v4",
     chainCategory: "evm",
-    description: "Build Aave v4 Spoke supply/deposit batch (wrap native, approve, supply).",
+    description: "Build Aave v4 Spoke supply/deposit batch (wrap native, approve, supply). Base bStocks: marketId bstocks and underlying ticker (AAPLc) or address.",
     prerequisites: ["keyGenId", "chainId", "underlying", "amountHuman", "get_defi_protocol_skill for hubs/spokes"],
     handler: { importPath: "protocols/evm/aave-v4", exportName: "buildEvmMultisignBodyAaveV4DepositBatch" },
     inputZod: mcpAaveV4DepositInputSchema
@@ -6578,7 +6866,7 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     actionId: "aave-v4.borrow",
     protocolId: "aave-v4",
     chainCategory: "evm",
-    description: "Build Aave v4 Spoke borrow; underlying is debt asset; collateral must be supplied first.",
+    description: "Build Aave v4 Spoke borrow; underlying is the debt asset (USDC on bstocks). Equities are collateral-only. collateralUnderlying may be a bStock ticker (AAPLc).",
     prerequisites: [
       "keyGenId",
       "chainId",
@@ -7712,6 +8000,16 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     prerequisites: ["keyGenId", "chainId 999", "question", "outcome", "amountHuman", "purposeText"],
     handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "buildEvmMultisignBodyHyperliquidOutcomeNegate" },
     inputZod: mcpHyperliquidOutcomeNegateInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_railgun_build_shield_multisign",
+    actionId: "railgun.shield",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Shield an ERC-20 into a Railgun 0zk address. The first call omits shieldSignature and returns a personal_sign. Submit it, then call again with shieldSignature to build the approve-and-shield transaction.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL", "0zk recipient"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "buildEvmMultisignBodyRailgunShield" },
+    inputZod: mcpRailgunShieldInputSchema
   })
 ];
 var catalogQuery = {
@@ -10012,10 +10310,11 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     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.",
+    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/bstocks) or underlying filter. Base tokenized stocks: marketId bstocks or ctm_aave_v4_fetch_stock_markets. Tickers (AAPLc) OK.",
     prerequisites: ["chainId", "get_defi_protocol_supported_chains"],
     followUp: [
       "ctm_aave_v4_fetch_market",
+      "ctm_aave_v4_fetch_stock_markets",
       "ctm_aave_v4_build_deposit_multisign",
       "ctm_aave_v4_build_borrow_multisign"
     ],
@@ -10028,7 +10327,7 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     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.",
+    description: "One Aave v4 reserve (or the same underlying across hubs) with supply/borrow APY and liquidity. Copy underlying + marketId for deposit/borrow/repay. Tickers OK (USDT, AAPLc). 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",
@@ -10040,6 +10339,23 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpAaveV4FetchMarketInputSchema,
     outputZod: mcpAaveV4FetchMarketOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_aave_v4_fetch_stock_markets",
+    actionId: "aave-v4.fetch-stock-markets",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "Coinbase tokenized stocks (bStocks) on the Aave v4 Coinbase Stocks hub, Base chainId 8453 by default. Equities (AAPLc, NVDAc, \u2026) are collateral-only; USDC is the borrow asset. Tickers OK. Same rows as ctm_aave_v4_fetch_markets with marketId bstocks. Chainlink feeds are 24/5. Not for U.S. persons.",
+    prerequisites: ["chainId 8453 or omit"],
+    followUp: [
+      "ctm_aave_v4_build_deposit_multisign",
+      "ctm_aave_v4_build_borrow_multisign",
+      "ctm_aave_v4_build_repay_multisign",
+      "ctm_aave_v4_build_withdraw_multisign"
+    ],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "aaveV4FetchStockMarketsSummary" },
+    inputZod: mcpAaveV4FetchStockMarketsInputSchema,
+    outputZod: mcpAaveV4FetchStockMarketsOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_aave_v4_fetch_merkl_rewards",
     actionId: "aave-v4.fetch-merkl-rewards",
@@ -10724,6 +11040,78 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchOrderbookSummary" },
     inputZod: mcpTrueoFetchOrderbookInputSchema,
     outputZod: mcpTrueoFetchOrderbookOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_railgun_fetch_popular_assets",
+    actionId: "railgun.fetch-popular-assets",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Top 5 public ERC-20s on a Railgun chain by recent shield count. This is the asset-row icon list, not the user shielded holdings. rpcUrl is injected.",
+    prerequisites: ["chainId", "get_defi_protocol_supported_chains"],
+    followUp: ["ctm_railgun_build_shield_multisign"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "railgunFetchPopularAssets" },
+    inputZod: mcpRailgunFetchPopularAssetsInputSchema,
+    outputZod: mcpRailgunFetchPopularAssetsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_railgun_ensure_wallet",
+    actionId: "railgun.ensure-wallet",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Create the Railgun wallet on this KeyGen if it does not exist yet, and return its 0zk address. The spending key is split across the KeyGen nodes. No node receives a key it can spend alone. Does not return a mnemonic. Use this from the node agent and from Telegram before shield, unshield, or private transfer.",
+    prerequisites: ["keyGenId"],
+    followUp: ["ctm_railgun_fetch_private_balances", "ctm_railgun_build_shield_multisign"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "railgunFetchPrivateBalancesSummary" },
+    inputZod: mcpRailgunEnsureWalletInputSchema,
+    outputZod: mcpRailgunEnsureWalletOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_railgun_fetch_private_balances",
+    actionId: "railgun.fetch-private-balances",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Shielded balances stored on the KeyGen record for this chain. Scans on the node when no scan is stored, or when refresh is true, then writes the result back to the KeyGen. Does not return a mnemonic or viewing key. Works from the node agent and from Telegram.",
+    prerequisites: ["keyGenId", "chainId", "ctm_railgun_ensure_wallet"],
+    followUp: ["ctm_railgun_private_transfer", "ctm_railgun_unshield"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "railgunFetchPrivateBalancesSummary" },
+    inputZod: mcpRailgunFetchPrivateBalancesInputSchema,
+    outputZod: mcpRailgunFetchPrivateBalancesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_railgun_private_transfer",
+    actionId: "railgun.private-transfer",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Start a private Railgun transfer. It stays pending until the KeyGen signing quorum agrees with ctm_railgun_agree_spend. No single node can spend. Do not pass a mnemonic.",
+    prerequisites: ["keyGenId", "chainId", "0zk recipient", "ctm_railgun_ensure_wallet"],
+    followUp: ["ctm_railgun_fetch_private_balances"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "railgunPrivateTransfer" },
+    inputZod: mcpRailgunPrivateTransferInputSchema,
+    outputZod: mcpRailgunPrivateActionOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_railgun_unshield",
+    actionId: "railgun.unshield",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Start an unshield to a public address. It stays pending until the KeyGen signing quorum agrees with ctm_railgun_agree_spend. Recipient defaults to the KeyGen Ethereum address. No single node can spend. Do not pass a mnemonic.",
+    prerequisites: ["keyGenId", "chainId", "ctm_railgun_ensure_wallet"],
+    followUp: ["ctm_railgun_fetch_private_balances"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "railgunUnshield" },
+    inputZod: mcpRailgunUnshieldInputSchema,
+    outputZod: mcpRailgunPrivateActionOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_railgun_agree_spend",
+    actionId: "railgun.agree-spend",
+    protocolId: "railgun",
+    chainCategory: "evm",
+    description: "Agree this node\u2019s Railgun spending share for a pending spendId. Read the pending spend on the KeyGen record before agreeing. One share cannot spend the 0zk wallet.",
+    prerequisites: ["keyGenId", "spendId"],
+    followUp: ["ctm_railgun_fetch_private_balances"],
+    handler: { importPath: "protocols/evm/railgun", exportName: "railgunFetchPrivateBalancesSummary" },
+    inputZod: mcpRailgunAgreeSpendInputSchema,
+    outputZod: mcpRailgunPrivateActionOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -10840,6 +11228,222 @@ var lidoProtocolModule = {
   ]
 };
 registerProtocolModule(lidoProtocolModule);
+
+// src/protocols/evm/railgun/networks.ts
+function selectRailgunNetworks(config) {
+  const rows = [];
+  for (const entry of Object.values(config)) {
+    if (!entry || entry.deprecated || entry.isDevOnlyNetwork) continue;
+    const chainId = Number(entry.chain?.id);
+    const proxyContract = String(entry.proxyContract ?? "").trim();
+    const wrappedAddress = String(entry.baseToken?.wrappedAddress ?? "").trim();
+    if (!Number.isFinite(chainId) || chainId <= 0 || !proxyContract || !wrappedAddress) continue;
+    rows.push({
+      chainId,
+      networkName: String(entry.name ?? ""),
+      publicName: String(entry.publicName ?? entry.name ?? ""),
+      proxyContract,
+      deploymentBlock: Number(entry.deploymentBlock ?? 0),
+      wrappedAddress,
+      wrappedSymbol: String(entry.baseToken?.wrappedSymbol ?? entry.baseToken?.symbol ?? ""),
+      wrappedDecimals: Number(entry.baseToken?.decimals ?? 18),
+      isTestnet: Boolean(entry.isTestnet)
+    });
+  }
+  rows.sort((a, b) => a.chainId - b.chainId);
+  return rows;
+}
+var cached = null;
+async function loadRailgunNetworks() {
+  if (cached) return cached;
+  const mod = await import('@railgun-community/shared-models');
+  cached = selectRailgunNetworks(mod.NETWORK_CONFIG);
+  return cached;
+}
+async function loadRailgunSupportedChainIds() {
+  const rows = await loadRailgunNetworks();
+  return new Set(rows.map((row) => row.chainId));
+}
+async function railgunNetworkByChainId(chainId) {
+  const rows = await loadRailgunNetworks();
+  return rows.find((row) => row.chainId === chainId);
+}
+
+// src/protocols/evm/railgun/popular-assets.ts
+init_constants();
+var RAILGUN_POPULAR_ASSET_LIMIT = 5;
+var POPULAR_ASSET_CACHE_MS = 10 * 60 * 1e3;
+var RECENT_SHIELD_LIMIT = 200;
+var SHIELD_INDEX_BY_NETWORK_NAME = {
+  Ethereum: "https://rail-squid.squids.live/squid-railgun-ethereum-v2/graphql",
+  BNB_Chain: "https://rail-squid.squids.live/squid-railgun-bsc-v2/graphql",
+  Polygon: "https://rail-squid.squids.live/squid-railgun-polygon-v2/graphql",
+  Arbitrum: "https://rail-squid.squids.live/squid-railgun-arbitrum-v2/graphql"
+};
+var RECENT_SHIELDS_QUERY = `query RecentShields($limit: Int!) {
+  shieldCommitments(orderBy: [blockNumber_DESC], limit: $limit) {
+    preimage { token { tokenType tokenAddress } }
+  }
+}`;
+var cache = /* @__PURE__ */ new Map();
+function rankPopularShieldTokens(rows, limit = RAILGUN_POPULAR_ASSET_LIMIT) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (Number(row.tokenType) !== 0) continue;
+    let address;
+    try {
+      address = viem.getAddress(row.tokenAddress);
+    } catch {
+      continue;
+    }
+    if (address === viem.zeroAddress) continue;
+    const key = address.toLowerCase();
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, limit).map(([address]) => viem.getAddress(address));
+}
+function shieldIndexEndpoint(networkName) {
+  return SHIELD_INDEX_BY_NETWORK_NAME[networkName] ?? null;
+}
+function commitmentsFromShieldIndex(payload) {
+  const rows = payload?.data?.shieldCommitments;
+  if (!Array.isArray(rows)) return [];
+  return rows.map((row) => {
+    const token = row?.preimage?.token;
+    const tokenType = token?.tokenType === "ERC20" || token?.tokenType === 0 ? 0 : Number(token?.tokenType ?? -1);
+    return {
+      tokenAddress: String(token?.tokenAddress ?? ""),
+      tokenType: Number.isFinite(tokenType) ? tokenType : -1
+    };
+  });
+}
+var shieldLogReaderOverride = null;
+async function readShieldCommitments(args) {
+  const endpoint = shieldIndexEndpoint(args.networkName);
+  if (!endpoint) return [];
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      query: RECENT_SHIELDS_QUERY,
+      variables: { limit: RECENT_SHIELD_LIMIT }
+    })
+  });
+  if (!response.ok) throw new Error(`Railgun shield index returned ${response.status}`);
+  return commitmentsFromShieldIndex(await response.json());
+}
+function applyContinuumToken(chainId, result) {
+  const ctm = ctmTokenAddressOnEvmChain(chainId);
+  if (!ctm) return result;
+  const present = result.tokens.some((token) => token.address.toLowerCase() === ctm.toLowerCase());
+  {
+    if (!present) return result;
+    return {
+      ...result,
+      tokens: result.tokens.filter((token) => token.address.toLowerCase() !== ctm.toLowerCase())
+    };
+  }
+}
+async function loadRailgunPopularAssets(args) {
+  const network = await railgunNetworkByChainId(args.chainId);
+  if (!network) {
+    return { tokens: [], notes: "Railgun is not deployed on this chain." };
+  }
+  const cached3 = cache.get(args.chainId);
+  if (cached3 && Date.now() - cached3.at < POPULAR_ASSET_CACHE_MS) {
+    return applyContinuumToken(args.chainId, {
+      tokens: cached3.tokens,
+      nativeWrapped: cached3.nativeWrapped,
+      notes: cached3.notes
+    });
+  }
+  const rpcUrl = args.rpcUrl?.trim() ?? "";
+  if (!shieldIndexEndpoint(network.networkName) && !shieldLogReaderOverride) {
+    return applyContinuumToken(args.chainId, {
+      tokens: [],
+      nativeWrapped: network.wrappedAddress,
+      notes: "This chain has no indexed Railgun shield feed."
+    });
+  }
+  try {
+    const commitments = await (shieldLogReaderOverride ?? readShieldCommitments)({
+      rpcUrl,
+      chainId: args.chainId,
+      proxy: viem.getAddress(network.proxyContract),
+      deploymentBlock: network.deploymentBlock,
+      networkName: network.networkName
+    });
+    const tokens = rankPopularShieldTokens(commitments).map((address) => ({ address }));
+    const notes = tokens.length === 0 ? "No recent ERC-20 shields were returned for this chain." : `Top ${tokens.length} ERC-20s by recent indexed shield count.`;
+    const entry = {
+      at: Date.now(),
+      tokens,
+      nativeWrapped: network.wrappedAddress,
+      notes
+    };
+    cache.set(args.chainId, entry);
+    return applyContinuumToken(args.chainId, { tokens, nativeWrapped: network.wrappedAddress, notes });
+  } catch {
+    return applyContinuumToken(args.chainId, {
+      tokens: [],
+      nativeWrapped: network.wrappedAddress,
+      notes: "The Railgun shield index could not be read."
+    });
+  }
+}
+
+// src/protocols/evm/railgun/index.ts
+var RAILGUN_PROTOCOL_ID = "railgun";
+var railgunProtocolModule = {
+  id: RAILGUN_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return loadRailgunSupportedChainIds().then((ids) => ids.has(Number(ctx.chainId)));
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    {
+      id: "railgun.shield",
+      protocolId: RAILGUN_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Shield an ERC-20 into a Railgun 0zk address",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenAddress: { type: "string", required: true, description: "ERC-20 to shield" },
+        amountWei: { type: "string", required: true, description: "Amount in wei" },
+        railgunAddress: { type: "string", required: true, description: "Recipient 0zk address" }
+      }
+    },
+    {
+      id: "railgun.private-transfer",
+      protocolId: RAILGUN_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Private transfer from the unlocked Railgun wallet",
+      commonParams: ["purposeText"],
+      params: {
+        tokenAddress: { type: "string", required: true, description: "Shielded ERC-20" },
+        amountWei: { type: "string", required: true, description: "Amount in wei" },
+        recipientAddress: { type: "string", required: true, description: "Recipient 0zk address" }
+      }
+    },
+    {
+      id: "railgun.unshield",
+      protocolId: RAILGUN_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Unshield from the unlocked Railgun wallet to a public address",
+      commonParams: ["purposeText"],
+      params: {
+        tokenAddress: { type: "string", required: true, description: "Shielded ERC-20" },
+        amountWei: { type: "string", required: true, description: "Amount in wei" },
+        recipientAddress: { type: "string", required: true, description: "Public recipient" }
+      }
+    }
+  ]
+};
+registerProtocolModule(railgunProtocolModule);
 var USDE_ETHEREUM_MAINNET = "0x4c9edd5852cd905f086c759e8383e09bff1e68b3";
 var SUSDE_ETHEREUM_MAINNET = "0x9d39a5de30e57443bff2a8307a4256c8797a3497";
 var USDE_MOST_L2S = "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34";
@@ -11033,83 +11637,6 @@ var skyProtocolModule = {
 };
 registerProtocolModule(skyProtocolModule);
 
-// src/protocols/evm/aave-v4/api.ts
-init_defiProxy();
-var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
-async function aaveV4Gql(query, variables) {
-  const body = { query, variables: variables ?? {} };
-  const j = await postJsonViaOptionalProxy({
-    directUrl: AAVE_V4_GRAPHQL_URL,
-    body,
-    proxyUrl: getAaveGraphqlProxyUrl(),
-    proxyEnvelope: body
-  });
-  if (j.errors?.length) {
-    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
-    throw new Error(msg);
-  }
-  if (j.data == null) {
-    throw new Error("Aave V4 API: empty response");
-  }
-  return j.data;
-}
-async function fetchAaveV4Chains() {
-  const d = await aaveV4Gql(`
-    query C($c: ChainsRequest!) { chains(request: $c) { chainId name nativeWrappedToken } }
-  `, { c: { query: { filter: "ALL" } } });
-  return d.chains ?? [];
-}
-async function loadAaveV4SupportedChainIdsFromV4Api() {
-  const rows = await fetchAaveV4Chains();
-  const s = /* @__PURE__ */ new Set();
-  for (const c of rows) s.add(c.chainId);
-  return s;
-}
-var RESERVES_ADDRESS_FRAGMENT = `
-  asset { underlying { address } }
-`;
-async function fetchAaveV4NativeWrappedToken(chainId) {
-  const all = await fetchAaveV4Chains();
-  const c = all.find((x) => x.chainId === chainId);
-  const t = (c?.nativeWrappedToken ?? "").trim();
-  if (t && viem.isAddress(t)) return viem.getAddress(t);
-  return null;
-}
-async function fetchAaveV4SupportedUnderlyingAddressSet(chainId) {
-  const d = await aaveV4Gql(
-    `
-    query A($r: ReservesRequest!) { reserves(request: $r) { ${RESERVES_ADDRESS_FRAGMENT} } }
-  `,
-    {
-      r: {
-        query: { chainIds: [chainId] },
-        filter: "ALL",
-        orderBy: { supplyApy: "DESC" }
-      }
-    }
-  );
-  const s = /* @__PURE__ */ new Set();
-  for (const r of d.reserves ?? []) {
-    const a = (r.asset?.underlying?.address ?? "").trim();
-    if (a && viem.isAddress(a)) s.add(a.toLowerCase());
-  }
-  return s;
-}
-var aaveV4ChainTokenCache = /* @__PURE__ */ new Map();
-function ensureAaveV4ChainTokenCache(chainId) {
-  const hit = aaveV4ChainTokenCache.get(chainId);
-  if (hit) return hit;
-  const p = (async () => {
-    const [nativeWrapped, supportedUnderlying] = await Promise.all([
-      fetchAaveV4NativeWrappedToken(chainId),
-      fetchAaveV4SupportedUnderlyingAddressSet(chainId)
-    ]);
-    return { supportedUnderlying, nativeWrapped };
-  })();
-  aaveV4ChainTokenCache.set(chainId, p);
-  return p;
-}
-
 // src/protocols/evm/aave-v4/index.ts
 var AAVE_V4_PROTOCOL_ID = "aave-v4";
 var aaveV4ProtocolModule = {
@@ -11309,19 +11836,19 @@ function ensureEulerV2ChainAssetCache(chainId) {
 }
 
 // src/protocols/evm/euler-v2/loadEulerV2SupportedChainIds.ts
-var cached = null;
+var cached2 = null;
 async function loadEulerV2SupportedChainIds() {
-  if (cached) return cached;
+  if (cached2) return cached2;
   try {
     const ids = await fetchEulerV3ActiveChainIds();
     if (ids.length) {
-      cached = new Set(ids);
-      return cached;
+      cached2 = new Set(ids);
+      return cached2;
     }
   } catch {
   }
-  cached = new Set(Object.keys(EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID).map((k) => Number(k)));
-  return cached;
+  cached2 = new Set(Object.keys(EULER_V2_GOLDSKY_SUBGRAPH_URL_BY_CHAIN_ID).map((k) => Number(k)));
+  return cached2;
 }
 
 // src/protocols/evm/euler-v2/index.ts
@@ -12102,9 +12629,9 @@ async function ensureMorphoChainAssetCache(chainId) {
     }
   } catch {
   }
-  const cache = { modesByUnderlying: modes, nativeWrapped: null };
-  chainAssetCache.set(chainId, cache);
-  return cache;
+  const cache2 = { modesByUnderlying: modes, nativeWrapped: null };
+  chainAssetCache.set(chainId, cache2);
+  return cache2;
 }
 
 // src/protocols/evm/morpho/index.ts
@@ -13602,8 +14129,8 @@ async function pendleFetchMarketsPage(args) {
 }
 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 cached3 = marketsCacheByChain.get(chainId);
+  if (cached3 && now - cached3.at < PENDLE_ICON_CACHE_MS) return cached3.rows;
   const rows = [];
   for (let page = 0; page < PENDLE_LISTING_MAX_PAGES; page++) {
     const batch = await pendleFetchMarketsPage({
@@ -14142,6 +14669,7 @@ var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'u
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
   "lido",
+  "railgun",
   "uniswap-v4",
   "curve-dao",
   "ethena",
@@ -14209,6 +14737,7 @@ function getProtocolDiscoverySummary(protocolId) {
     }))
   };
 }
+init_coinbaseB20();
 init_support();
 init_support2();
 init_addresses();
@@ -14217,7 +14746,8 @@ init_constants();
 function advisor(protocolId, tokenFilter, impl) {
   return { protocolId, tokenFilter, ...impl };
 }
-function aerodromeAdvisorPriorityTokens() {
+async function aerodromeAdvisorPriorityTokens() {
+  const stocks = await ensureCoinbaseB20StockCatalog().catch(() => []);
   return [
     {
       address: "0x0000000000000000000000000000000000000000",
@@ -14243,11 +14773,11 @@ function aerodromeAdvisorPriorityTokens() {
       decimals: 18,
       roles: ["swappable"]
     },
-    ...COINBASE_B20_STOCK_TOKENS.map((t) => ({
+    ...stocks.map((t) => ({
       address: t.address,
       symbol: t.symbol,
       name: t.name,
-      decimals: COINBASE_B20_STOCK_DECIMALS,
+      decimals: t.decimals || COINBASE_B20_STOCK_DECIMALS,
       roles: ["swappable", "listed", "coinbase_b20"]
     }))
   ];
@@ -14259,36 +14789,44 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return [...set].sort((a, b) => a - b);
     },
     async supportedTokens(chainId) {
-      const cache = await ensureAaveV4ChainTokenCache(chainId);
-      const tokens = [...cache.supportedUnderlying].map((address) => ({
-        address,
-        roles: ["underlying"]
-      }));
-      if (cache.nativeWrapped) {
+      const cache2 = await ensureAaveV4ChainTokenCache(chainId);
+      await ensureCoinbaseB20StockCatalog().catch(() => []);
+      const tokens = [...cache2.supportedUnderlying].map((address) => {
+        const known = lookupCoinbaseB20StockToken(address);
+        if (!known) return { address, roles: ["underlying"] };
+        return {
+          address,
+          symbol: known.symbol,
+          name: "name" in known ? known.name : void 0,
+          decimals: COINBASE_B20_STOCK_DECIMALS,
+          roles: ["underlying", "coinbase_b20", "collateral"]
+        };
+      });
+      if (cache2.nativeWrapped) {
         tokens.unshift({
-          address: cache.nativeWrapped,
+          address: cache2.nativeWrapped,
           symbol: "WETH",
           roles: ["native_wrapped"]
         });
       }
       return {
         tokens,
-        nativeWrapped: cache.nativeWrapped ?? void 0,
-        notes: "Native ETH deposits use wrapped native token address from Aave v4 API."
+        nativeWrapped: cache2.nativeWrapped ?? void 0,
+        notes: "Native ETH deposits use wrapped native token address from Aave v4 API. Base chainId 8453 Coinbase Stocks hub is marketId bstocks. Listed equities come from the Aave v4 API; tickers resolve from the live Coinbase catalog. Equities are collateral-only; USDC is the borrow asset."
       };
     },
     async isTokenSupported(chainId, address) {
-      const cache = await ensureAaveV4ChainTokenCache(chainId);
+      const cache2 = await ensureAaveV4ChainTokenCache(chainId);
       let normalized;
       try {
         normalized = viem.getAddress(address).toLowerCase();
       } catch {
         return false;
       }
-      if (cache.nativeWrapped && viem.getAddress(cache.nativeWrapped).toLowerCase() === normalized) {
+      if (cache2.nativeWrapped && viem.getAddress(cache2.nativeWrapped).toLowerCase() === normalized) {
         return true;
       }
-      return cache.supportedUnderlying.has(normalized);
+      return cache2.supportedUnderlying.has(normalized);
     }
   }),
   "uniswap-v4": advisor("uniswap-v4", "any_erc20_on_chain", {
@@ -14421,8 +14959,8 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return [...set].sort((a, b) => a - b);
     },
     async supportedTokens(chainId) {
-      const cache = await ensureMorphoChainAssetCache(chainId);
-      const tokens = [...cache.modesByUnderlying.entries()].map(([address, modes]) => ({
+      const cache2 = await ensureMorphoChainAssetCache(chainId);
+      const tokens = [...cache2.modesByUnderlying.entries()].map(([address, modes]) => ({
         address,
         roles: [
           ...modes.earn ? ["vault_underlying"] : [],
@@ -14436,14 +14974,14 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       };
     },
     async isTokenSupported(chainId, address) {
-      const cache = await ensureMorphoChainAssetCache(chainId);
+      const cache2 = await ensureMorphoChainAssetCache(chainId);
       let normalized;
       try {
         normalized = viem.getAddress(address).toLowerCase();
       } catch {
         return false;
       }
-      return cache.modesByUnderlying.has(normalized);
+      return cache2.modesByUnderlying.has(normalized);
     }
   }),
   "euler-v2": advisor("euler-v2", "subgraph_vaults", {
@@ -14452,8 +14990,8 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return [...set].sort((a, b) => a - b);
     },
     async supportedTokens(chainId) {
-      const cache = await ensureEulerV2ChainAssetCache(chainId);
-      const tokens = [...cache.modesByUnderlying.entries()].map(([address, modes]) => ({
+      const cache2 = await ensureEulerV2ChainAssetCache(chainId);
+      const tokens = [...cache2.modesByUnderlying.entries()].map(([address, modes]) => ({
         address,
         roles: [
           ...modes.lend ? ["vault_underlying"] : [],
@@ -14463,19 +15001,19 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       }));
       return {
         tokens,
-        nativeWrapped: cache.nativeWrapped ?? void 0,
+        nativeWrapped: cache2.nativeWrapped ?? void 0,
         notes: "Euler EVK vault underlyings and Earn vault assets from the Euler V3 API. Use address as underlyingAddress for ctm_euler_v2_fetch_lend_vaults."
       };
     },
     async isTokenSupported(chainId, address) {
-      const cache = await ensureEulerV2ChainAssetCache(chainId);
+      const cache2 = await ensureEulerV2ChainAssetCache(chainId);
       let normalized;
       try {
         normalized = viem.getAddress(address).toLowerCase();
       } catch {
         return false;
       }
-      return cache.modesByUnderlying.has(normalized);
+      return cache2.modesByUnderlying.has(normalized);
     }
   }),
   [MAPLE_PROTOCOL_ID]: advisor(MAPLE_PROTOCOL_ID, "fixed_addresses", {
@@ -14560,9 +15098,9 @@ var PROTOCOL_SUPPORT_ADVISORS = {
         return { tokens: [], notes: "Aerodrome is Base-only (chainId 8453)." };
       }
       return {
-        tokens: aerodromeAdvisorPriorityTokens(),
+        tokens: await aerodromeAdvisorPriorityTokens(),
         nativeWrapped: AERODROME_WETH_BASE,
-        notes: "Slim directory: ETH, WETH, USDC, AERO, and Coinbase B20 stocks (AAPLc, \u2026). For a price call ctm_aerodrome_quote with tickers. To see pools for one token call ctm_aerodrome_discover_pools. Do not dump LpSugar."
+        notes: "ETH, WETH, USDC, AERO, plus the live Coinbase B20 catalog. For a price call ctm_aerodrome_quote with a ticker. To see pools for one token call ctm_aerodrome_discover_pools. Do not dump LpSugar."
       };
     }
   }),
@@ -14625,7 +15163,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return listCompoundV3SupportedChainIds();
     },
     async supportedTokens(chainId, ctx) {
-      const cache = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
+      const cache2 = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
       const nativeWrapped = compoundV3WrappedNative(chainId);
       const tokens = [];
       if (nativeWrapped) {
@@ -14641,7 +15179,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
           roles: ["native_wrapped"]
         });
       }
-      for (const [address, modes] of cache) {
+      for (const [address, modes] of cache2) {
         if (nativeWrapped && address === nativeWrapped.toLowerCase()) continue;
         tokens.push({
           address,
@@ -14655,7 +15193,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       };
     },
     async isTokenSupported(chainId, address, ctx) {
-      const cache = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
+      const cache2 = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
       let normalized;
       try {
         normalized = viem.getAddress(address).toLowerCase();
@@ -14665,7 +15203,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       if (normalized === "0x0000000000000000000000000000000000000000") return true;
       const wrapped = compoundV3WrappedNative(chainId);
       if (wrapped && wrapped.toLowerCase() === normalized) return true;
-      return cache.has(normalized);
+      return cache2.has(normalized);
     }
   }),
   [PENDLE_PROTOCOL_ID]: advisor(PENDLE_PROTOCOL_ID, "api_underlyings", {
@@ -14793,6 +15331,32 @@ var PROTOCOL_SUPPORT_ADVISORS = {
         return false;
       }
     }
+  }),
+  railgun: advisor("railgun", "api_underlyings", {
+    async supportedChainIds() {
+      return [...await loadRailgunSupportedChainIds()];
+    },
+    async supportedTokens(chainId, ctx) {
+      const result = await loadRailgunPopularAssets({ chainId, rpcUrl: ctx?.rpcUrl });
+      return {
+        tokens: result.tokens.map((token) => ({ address: token.address, roles: ["shield"] })),
+        nativeWrapped: result.nativeWrapped,
+        notes: result.notes
+      };
+    },
+    async isTokenSupported(chainId, address, ctx) {
+      const result = await loadRailgunPopularAssets({ chainId, rpcUrl: ctx?.rpcUrl });
+      const listed = new Set(result.tokens.map((token) => token.address.toLowerCase()));
+      try {
+        const normalized = viem.getAddress(address);
+        if (normalized === viem.zeroAddress) {
+          return Boolean(result.nativeWrapped && listed.has(result.nativeWrapped.toLowerCase()));
+        }
+        return listed.has(normalized.toLowerCase());
+      } catch {
+        return false;
+      }
+    }
   })
 };
 function getProtocolSupportAdvisor(protocolId) {
@@ -14814,6 +15378,7 @@ function getAgentCatalog() {
     uniswapV4: uniswapV4ProtocolModule,
     curveDao: curveDaoProtocolModule,
     lido: lidoProtocolModule,
+    railgun: railgunProtocolModule,
     ethena: ethenaProtocolModule,
     maple: mapleProtocolModule,
     sky: skyProtocolModule,
@@ -14872,6 +15437,8 @@ exports.mcpAaveV4FetchMarketInputSchema = mcpAaveV4FetchMarketInputSchema;
 exports.mcpAaveV4FetchMarketOutputSchema = mcpAaveV4FetchMarketOutputSchema;
 exports.mcpAaveV4FetchMarketsInputSchema = mcpAaveV4FetchMarketsInputSchema;
 exports.mcpAaveV4FetchMarketsOutputSchema = mcpAaveV4FetchMarketsOutputSchema;
+exports.mcpAaveV4FetchStockMarketsInputSchema = mcpAaveV4FetchStockMarketsInputSchema;
+exports.mcpAaveV4FetchStockMarketsOutputSchema = mcpAaveV4FetchStockMarketsOutputSchema;
 exports.mcpAaveV4MerklClaimInputSchema = mcpAaveV4MerklClaimInputSchema;
 exports.mcpAaveV4RepayInputSchema = mcpAaveV4RepayInputSchema;
 exports.mcpAaveV4WithdrawInputSchema = mcpAaveV4WithdrawInputSchema;
@@ -15258,6 +15825,17 @@ exports.mcpPendleQuoteSwapInputSchema = mcpPendleQuoteSwapInputSchema;
 exports.mcpPendleSearchAssetsInputSchema = mcpPendleSearchAssetsInputSchema;
 exports.mcpPendleSearchAssetsOutputSchema = mcpPendleSearchAssetsOutputSchema;
 exports.mcpPredictionMarketRowSchema = mcpPredictionMarketRowSchema;
+exports.mcpRailgunAgreeSpendInputSchema = mcpRailgunAgreeSpendInputSchema;
+exports.mcpRailgunEnsureWalletInputSchema = mcpRailgunEnsureWalletInputSchema;
+exports.mcpRailgunEnsureWalletOutputSchema = mcpRailgunEnsureWalletOutputSchema;
+exports.mcpRailgunFetchPopularAssetsInputSchema = mcpRailgunFetchPopularAssetsInputSchema;
+exports.mcpRailgunFetchPopularAssetsOutputSchema = mcpRailgunFetchPopularAssetsOutputSchema;
+exports.mcpRailgunFetchPrivateBalancesInputSchema = mcpRailgunFetchPrivateBalancesInputSchema;
+exports.mcpRailgunFetchPrivateBalancesOutputSchema = mcpRailgunFetchPrivateBalancesOutputSchema;
+exports.mcpRailgunPrivateActionOutputSchema = mcpRailgunPrivateActionOutputSchema;
+exports.mcpRailgunPrivateTransferInputSchema = mcpRailgunPrivateTransferInputSchema;
+exports.mcpRailgunShieldInputSchema = mcpRailgunShieldInputSchema;
+exports.mcpRailgunUnshieldInputSchema = mcpRailgunUnshieldInputSchema;
 exports.mcpSearchPredictionMarketsInputSchema = mcpSearchPredictionMarketsInputSchema;
 exports.mcpSearchPredictionMarketsOutputSchema = mcpSearchPredictionMarketsOutputSchema;
 exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;