@continuumdao/ctm-mpc-defi 0.2.57 → 0.2.58

package/dist/agent/catalog.cjs

@@ -288,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");
@@ -1028,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');
@@ -4572,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();
@@ -6314,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."
   )
@@ -6351,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."
@@ -7929,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 = {
@@ -10959,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 = [
@@ -11075,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";
@@ -11467,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
@@ -12260,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
@@ -13760,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({
@@ -14300,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",
@@ -14419,9 +14789,9 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return [...set].sort((a, b) => a - b);
     },
     async supportedTokens(chainId) {
-      const cache = await ensureAaveV4ChainTokenCache(chainId);
+      const cache2 = await ensureAaveV4ChainTokenCache(chainId);
       await ensureCoinbaseB20StockCatalog().catch(() => []);
-      const tokens = [...cache.supportedUnderlying].map((address) => {
+      const tokens = [...cache2.supportedUnderlying].map((address) => {
         const known = lookupCoinbaseB20StockToken(address);
         if (!known) return { address, roles: ["underlying"] };
         return {
@@ -14432,31 +14802,31 @@ var PROTOCOL_SUPPORT_ADVISORS = {
           roles: ["underlying", "coinbase_b20", "collateral"]
         };
       });
-      if (cache.nativeWrapped) {
+      if (cache2.nativeWrapped) {
         tokens.unshift({
-          address: cache.nativeWrapped,
+          address: cache2.nativeWrapped,
           symbol: "WETH",
           roles: ["native_wrapped"]
         });
       }
       return {
         tokens,
-        nativeWrapped: cache.nativeWrapped ?? void 0,
+        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", {
@@ -14589,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"] : [],
@@ -14604,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", {
@@ -14620,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"] : [],
@@ -14631,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", {
@@ -14793,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) {
@@ -14809,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,
@@ -14823,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();
@@ -14833,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", {
@@ -14961,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) {
@@ -14982,6 +15378,7 @@ function getAgentCatalog() {
     uniswapV4: uniswapV4ProtocolModule,
     curveDao: curveDaoProtocolModule,
     lido: lidoProtocolModule,
+    railgun: railgunProtocolModule,
     ethena: ethenaProtocolModule,
     maple: mapleProtocolModule,
     sky: skyProtocolModule,
@@ -15428,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;