web3-tools-mcp 3.1.0 → 3.2.0

package/src/chains.ts

@@ -1,16 +1,23 @@
 import type { Chain } from 'viem'
 import {
   arbitrum,
+  arc,
   avalanche,
   base,
   bsc,
+  celo,
   gnosis,
+  hyperEvm,
+  ink,
   linea,
   localhost,
   mainnet,
+  mantle,
+  monad,
   optimism,
+  plasma,
   polygon,
-  sonic,
+  robinhood,
   unichain,
   zksync
 } from 'viem/chains'
@@ -25,39 +32,41 @@ interface ChainInfo {
   chain: Chain
   /** Subdomain under g.alchemy.com; absent where Alchemy has no endpoint. */
   alchemy?: string
-  /** Subdomain under infura.io; absent where Infura has no endpoint. */
-  infura?: string
-  /** Used when no provider key is configured. */
+  /** False where Alchemy serves the RPC but not its token API, which `get_portfolio` needs. */
+  alchemyTokenApi?: false
+  /** Used when no Alchemy key is configured, or Alchemy has no endpoint. */
   fallback: string
   /** Block explorer domain, for links. Absent where there is nothing to link to. */
   explorer?: string
   hypersync?: string
+  /** DefiLlama's two names for the chain: the prefix of a coin id, and the `chain` of a yield pool. */
+  llama?: { coins: string; yields: string }
 }
 
 const TABLE = {
   mainnet: {
     chain: mainnet,
     alchemy: 'eth-mainnet',
-    infura: 'mainnet',
     fallback: 'https://ethereum-rpc.publicnode.com',
     explorer: 'etherscan.io',
-    hypersync: 'https://eth.hypersync.xyz'
+    hypersync: 'https://eth.hypersync.xyz',
+    llama: { coins: 'ethereum', yields: 'Ethereum' }
   },
   arbitrum: {
     chain: arbitrum,
     alchemy: 'arb-mainnet',
-    infura: 'arbitrum-mainnet',
     fallback: 'https://arb1.arbitrum.io/rpc',
     explorer: 'arbiscan.io',
-    hypersync: 'https://arbitrum.hypersync.xyz'
+    hypersync: 'https://arbitrum.hypersync.xyz',
+    llama: { coins: 'arbitrum', yields: 'Arbitrum' }
   },
   avalanche: {
     chain: avalanche,
     alchemy: 'avax-mainnet',
-    infura: 'avalanche-mainnet',
     fallback: 'https://api.avax.network/ext/bc/C/rpc',
     explorer: 'snowtrace.io',
-    hypersync: 'https://avalanche.hypersync.xyz'
+    hypersync: 'https://avalanche.hypersync.xyz',
+    llama: { coins: 'avax', yields: 'Avalanche' }
   },
   base: {
     chain: base,
@@ -65,70 +74,131 @@ const TABLE = {
     // publicnode refuses receipts and anything else it calls an archive request
     fallback: 'https://mainnet.base.org',
     explorer: 'basescan.org',
-    hypersync: 'https://base.hypersync.xyz'
+    hypersync: 'https://base.hypersync.xyz',
+    llama: { coins: 'base', yields: 'Base' }
   },
   bnb: {
     chain: bsc,
     alchemy: 'bnb-mainnet',
-    infura: 'bsc-mainnet',
     fallback: 'https://bsc-dataseed.bnbchain.org',
     explorer: 'bscscan.com',
-    hypersync: 'https://bsc.hypersync.xyz'
+    hypersync: 'https://bsc.hypersync.xyz',
+    llama: { coins: 'bsc', yields: 'BSC' }
   },
   gnosis: {
     chain: gnosis,
     alchemy: 'gnosis-mainnet',
     fallback: 'https://rpc.gnosischain.com',
     explorer: 'gnosisscan.io',
-    hypersync: 'https://gnosis.hypersync.xyz'
-  },
-  sonic: {
-    chain: sonic,
-    alchemy: 'sonic-mainnet',
-    fallback: 'https://rpc.soniclabs.com',
-    explorer: 'sonicscan.org',
-    hypersync: 'https://sonic.hypersync.xyz'
+    hypersync: 'https://gnosis.hypersync.xyz',
+    llama: { coins: 'xdai', yields: 'Gnosis' }
   },
   optimism: {
     chain: optimism,
     alchemy: 'opt-mainnet',
-    infura: 'optimism-mainnet',
     fallback: 'https://mainnet.optimism.io',
     explorer: 'optimistic.etherscan.io',
-    hypersync: 'https://optimism.hypersync.xyz'
+    hypersync: 'https://optimism.hypersync.xyz',
+    llama: { coins: 'optimism', yields: 'OP Mainnet' }
   },
   polygon: {
     chain: polygon,
     alchemy: 'polygon-mainnet',
-    infura: 'polygon-mainnet',
     // polygon-rpc.com now answers 401 "API key disabled" to anonymous callers
     fallback: 'https://polygon-bor-rpc.publicnode.com',
     explorer: 'polygonscan.com',
-    hypersync: 'https://polygon.hypersync.xyz'
+    hypersync: 'https://polygon.hypersync.xyz',
+    llama: { coins: 'polygon', yields: 'Polygon' }
   },
   zksync: {
     chain: zksync,
     alchemy: 'zksync-mainnet',
-    infura: 'zksync-mainnet',
     fallback: 'https://mainnet.era.zksync.io',
     explorer: 'era.zksync.network',
-    hypersync: 'https://zksync.hypersync.xyz'
+    hypersync: 'https://zksync.hypersync.xyz',
+    llama: { coins: 'era', yields: 'ZKsync Era' }
   },
   linea: {
     chain: linea,
     alchemy: 'linea-mainnet',
-    infura: 'linea-mainnet',
     fallback: 'https://rpc.linea.build',
     explorer: 'lineascan.build',
-    hypersync: 'https://linea.hypersync.xyz'
+    hypersync: 'https://linea.hypersync.xyz',
+    llama: { coins: 'linea', yields: 'Linea' }
   },
   unichain: {
     chain: unichain,
     alchemy: 'unichain-mainnet',
-    infura: 'unichain-mainnet',
     fallback: 'https://mainnet.unichain.org',
     explorer: 'uniscan.xyz',
-    hypersync: 'https://unichain.hypersync.xyz'
+    hypersync: 'https://unichain.hypersync.xyz',
+    llama: { coins: 'unichain', yields: 'Unichain' }
+  },
+  monad: {
+    chain: monad,
+    alchemy: 'monad-mainnet',
+    fallback: 'https://rpc.monad.xyz',
+    explorer: 'monadscan.com',
+    hypersync: 'https://monad.hypersync.xyz',
+    llama: { coins: 'monad', yields: 'Monad' }
+  },
+  robinhood: {
+    chain: robinhood,
+    alchemy: 'robinhood-mainnet',
+    fallback: 'https://rpc.mainnet.chain.robinhood.com',
+    explorer: 'robinhoodchain.blockscout.com',
+    hypersync: 'https://robinhood.hypersync.xyz',
+    llama: { coins: 'robinhood', yields: 'Robinhood Chain' }
+  },
+  arc: {
+    chain: arc,
+    alchemy: 'arc-mainnet',
+    fallback: 'https://rpc.mainnet.arc.io',
+    explorer: 'explorer.arc.io',
+    hypersync: 'https://arc.hypersync.xyz',
+    llama: { coins: 'arc', yields: 'Arc' }
+  },
+  plasma: {
+    chain: plasma,
+    alchemy: 'plasma-mainnet',
+    alchemyTokenApi: false,
+    fallback: 'https://rpc.plasma.to',
+    explorer: 'plasmascan.to',
+    hypersync: 'https://plasma.hypersync.xyz',
+    llama: { coins: 'plasma', yields: 'Plasma' }
+  },
+  ink: {
+    chain: ink,
+    alchemy: 'ink-mainnet',
+    fallback: 'https://rpc-gel.inkonchain.com',
+    explorer: 'explorer.inkonchain.com',
+    hypersync: 'https://ink.hypersync.xyz',
+    llama: { coins: 'ink', yields: 'Ink' }
+  },
+  mantle: {
+    chain: mantle,
+    alchemy: 'mantle-mainnet',
+    alchemyTokenApi: false,
+    fallback: 'https://rpc.mantle.xyz',
+    explorer: 'mantlescan.xyz',
+    hypersync: 'https://mantle.hypersync.xyz',
+    llama: { coins: 'mantle', yields: 'Mantle' }
+  },
+  celo: {
+    chain: celo,
+    alchemy: 'celo-mainnet',
+    fallback: 'https://forno.celo.org',
+    explorer: 'celoscan.io',
+    hypersync: 'https://celo.hypersync.xyz',
+    llama: { coins: 'celo', yields: 'Celo' }
+  },
+  hyperevm: {
+    chain: hyperEvm,
+    alchemy: 'hyperliquid-mainnet',
+    fallback: 'https://rpc.hyperliquid.xyz/evm',
+    explorer: 'hyperevmscan.io',
+    hypersync: 'https://hyperliquid.hypersync.xyz',
+    llama: { coins: 'hyperliquid', yields: 'Hyperliquid L1' }
   },
   localhost: {
     chain: localhost,

package/src/client.ts

@@ -4,14 +4,13 @@ import type { Config } from './types.js'
 
 export { SUPPORTED_CHAINS } from './chains.js'
 
-/** Custom URL first, then whichever provider key is configured, then the public endpoint. */
+/** Custom URL first, then Alchemy when a key is configured, then the public endpoint. */
 function getRpcUrl(chainName: ChainName, config: Config): string {
   const custom = config.customRpcUrls?.[chainName]
   if (custom) return custom
 
-  const { alchemy, infura, fallback } = CHAINS[chainName]
+  const { alchemy, fallback } = CHAINS[chainName]
   if (alchemy && config.alchemyApiKey) return `https://${alchemy}.g.alchemy.com/v2/${config.alchemyApiKey}`
-  if (infura && config.infuraApiKey) return `https://${infura}.infura.io/v3/${config.infuraApiKey}`
   return fallback
 }
 

package/src/http-server.ts

@@ -4,7 +4,7 @@ import { getOAuthProtectedResourceMetadataUrl, mcpAuthRouter } from '@modelconte
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
 import express, { type Express } from 'express'
-import type { WalletRelay } from 'web3-wallet-relay'
+import { SIGN_PATH, type WalletRelay } from 'web3-wallet-relay'
 import { HOSTED } from './hosted.js'
 import { SingleUserOAuthProvider } from './oauth.js'
 
@@ -136,11 +136,11 @@ export async function startHttpServer(options: HttpServerOptions): Promise<{ url
   // The signing page rides on this same server, so a hosted deployment can offer browser
   // signing without a second service: one platform port serves both /mcp and the page.
   // Mounted last, so the routes above keep their paths — the relay only claims what is
-  // left, which is the static page at the root.
+  // left, which is the static page at /sign/.
   let walletUrl: string | undefined
   if (options.walletRelay) {
     options.walletRelay.attach(server, (relayApp) => app.use(relayApp))
-    walletUrl = `${publicUrl.replace(/\/$/, '')}/#t=${options.walletRelay.signerToken}`
+    walletUrl = `${publicUrl.replace(/\/$/, '')}${SIGN_PATH}#t=${options.walletRelay.signerToken}`
   }
 
   return { url: `${publicUrl.replace(/\/$/, '')}/mcp`, port: (server.address() as { port: number }).port, walletUrl }

package/src/index.ts

@@ -27,7 +27,6 @@ OPTIONS:
   --help, -h                    Show this help message
   --etherscan-api-key <key>     Etherscan API key (for contract ABI retrieval)
   --alchemy-api-key <key>       Alchemy API key (for enhanced RPC)
-  --infura-api-key <key>        Infura API key (for alternative RPC)
   --hypersync-api-key <key>     Hypersync API key (for fast event queries)
   --walletconnect-project-id <id>
                                 WalletConnect project id, to sign from a phone
@@ -37,7 +36,6 @@ OPTIONS:
 ENVIRONMENT VARIABLES:
   ETHERSCAN_API_KEY             Alternative to --etherscan-api-key
   ALCHEMY_API_KEY               Alternative to --alchemy-api-key
-  INFURA_API_KEY                Alternative to --infura-api-key
   HYPERSYNC_API_KEY             Alternative to --hypersync-api-key
   WALLETCONNECT_PROJECT_ID      Alternative to --walletconnect-project-id
   CUSTOM_RPC                    Alternative to --custom-rpc
@@ -84,9 +82,6 @@ if (config.etherscanApiKey) {
 if (config.alchemyApiKey) {
   console.error('[MCP] Alchemy API key configured')
 }
-if (config.infuraApiKey) {
-  console.error('[MCP] Infura API key configured')
-}
 if (config.walletConnectProjectId) {
   console.error('[MCP] WalletConnect project id configured — phone signing available')
 }

package/src/tools/index.ts

@@ -9,6 +9,7 @@ import advancedTools from './read/advanced.js'
 import balanceTools from './read/balance.js'
 import contractTools from './read/contract.js'
 import contractInfoTools from './read/contract-info.js'
+import defiTools from './read/defi.js'
 import ensTools from './read/ens.js'
 import gasTools from './read/gas.js'
 import logTools from './read/logs.js'
@@ -36,6 +37,7 @@ const readTools = {
   ...advancedTools,
   ...ensTools,
   ...gasTools,
+  ...defiTools,
   // A signature already asked for and paid for; collecting it is not a second request.
   ...signingRequestTools
 } as const

package/src/tools/read/defi.ts

@@ -0,0 +1,287 @@
+import { type Address, formatUnits, type Hex, isAddress, zeroAddress } from 'viem'
+import { z } from 'zod'
+import { CHAINS, type ChainName, SUPPORTED_CHAINS } from '../../chains.js'
+import { getClientManager } from '../../client.js'
+import { createTool, formatResponse, MAX_BATCH, rpcReason } from '../../utils.js'
+
+/** Token ids per DefiLlama price request, to keep the URL short. */
+const PRICE_BATCH = 50
+const MAX_TOKEN_PAGES = 10
+
+interface LlamaPrice {
+  symbol: string
+  price: number
+  decimals?: number
+  confidence?: number
+  timestamp: number
+}
+
+interface LlamaPool {
+  pool: string
+  chain: string
+  project: string
+  symbol: string
+  poolMeta: string | null
+  tvlUsd: number
+  apy: number | null
+  apyBase: number | null
+  apyReward: number | null
+  apyMean30d: number | null
+  stablecoin: boolean
+  ilRisk: string
+  exposure: string
+  outlier: boolean
+  underlyingTokens: string[] | null
+}
+
+/** DefiLlama's public API: free, keyless, and the same for every caller. */
+async function llama<T>(url: string): Promise<T> {
+  const response = await fetch(url, { headers: { Accept: 'application/json' }, signal: AbortSignal.timeout(30_000) })
+  if (!response.ok) throw new Error(`DefiLlama answered ${response.status} for ${url}`)
+  return (await response.json()) as T
+}
+
+function llamaNames(chain: ChainName) {
+  const names = CHAINS[chain].llama
+  if (!names) throw new Error(`DefiLlama has no data for ${chain}`)
+  return names
+}
+
+/** Prices by lowercased token address; a token DefiLlama cannot price is absent. */
+async function llamaPrices(chain: ChainName, tokens: string[], timestamp?: number): Promise<Map<string, LlamaPrice>> {
+  const prefix = llamaNames(chain).coins
+  const when = timestamp ? `historical/${timestamp}` : 'current'
+  const batches = Array.from({ length: Math.ceil(tokens.length / PRICE_BATCH) }, (_, index) =>
+    tokens.slice(index * PRICE_BATCH, (index + 1) * PRICE_BATCH)
+  )
+
+  const answers = await Promise.all(
+    batches.map((batch) =>
+      llama<{ coins: Record<string, LlamaPrice> }>(
+        `https://coins.llama.fi/prices/${when}/${batch.map((token) => `${prefix}:${token}`).join(',')}`
+      )
+    )
+  )
+  // DefiLlama keys its answer by the id as sent, but not reliably in the same case.
+  return new Map(
+    answers.flatMap(({ coins }) => Object.entries(coins).map(([id, price]) => [id.slice(prefix.length + 1).toLowerCase(), price]))
+  )
+}
+
+/**
+ * Every ERC20 the address holds a non-zero balance of, as Alchemy indexes them.
+ *
+ * ponytail: stops after MAX_TOKEN_PAGES pages; past that a wallet is nearly all spam, but a
+ * real token beyond the cut is missed. `truncated` says when that happened.
+ */
+async function erc20Balances(chain: ChainName, address: Address) {
+  const client = getClientManager().getClient(chain)
+  const balances: [string, bigint][] = []
+  let pageKey: string | undefined
+
+  for (let page = 0; page < MAX_TOKEN_PAGES; page++) {
+    const result = (await client.request({
+      method: 'alchemy_getTokenBalances',
+      params: [address, 'erc20', { maxCount: 100, ...(pageKey && { pageKey }) }]
+    } as never)) as { tokenBalances: { contractAddress: string; tokenBalance: Hex | null }[]; pageKey?: string }
+
+    for (const { contractAddress, tokenBalance } of result.tokenBalances) {
+      if (tokenBalance && BigInt(tokenBalance) > 0n) balances.push([contractAddress, BigInt(tokenBalance)])
+    }
+    pageKey = result.pageKey
+    if (!pageKey) break
+  }
+
+  return { balances, truncated: Boolean(pageKey) }
+}
+
+async function holdingsOn(chain: ChainName, address: Address, minValueUsd: number) {
+  const [native, erc20] = await Promise.all([
+    getClientManager().getClient(chain).getBalance({ address }),
+    erc20Balances(chain, address)
+  ])
+  const held = native > 0n ? [[zeroAddress, native] as [string, bigint], ...erc20.balances] : erc20.balances
+  const prices = await llamaPrices(
+    chain,
+    held.map(([token]) => token)
+  )
+
+  const holdings = []
+  let unpriced = 0
+  let belowMinValue = 0
+  for (const [token, raw] of held) {
+    const price = prices.get(token.toLowerCase())
+    if (!price || price.decimals === undefined) {
+      unpriced++
+      continue
+    }
+    const amount = formatUnits(raw, price.decimals)
+    const valueUsd = Number(amount) * price.price
+    if (valueUsd < minValueUsd) {
+      belowMinValue++
+      continue
+    }
+    holdings.push({
+      chain,
+      token: token === zeroAddress ? 'native' : token,
+      symbol: price.symbol,
+      amount,
+      priceUsd: price.price,
+      valueUsd: Math.round(valueUsd * 100) / 100
+    })
+  }
+
+  return { chain, holdings, unpriced, belowMinValue, truncated: erc20.truncated }
+}
+
+export default {
+  get_token_prices: createTool(
+    'Get Token Prices',
+    "USD prices from DefiLlama for tokens on one chain, now or at a past timestamp. Use the zero address for the chain's native token. " +
+      'Tokens DefiLlama cannot price are listed as unpriced — usually spam or illiquid.',
+    z.object({
+      chain: z.enum(SUPPORTED_CHAINS).describe('Blockchain network'),
+      tokens: z
+        .array(z.string())
+        .min(1)
+        .max(MAX_BATCH)
+        .describe(`Token contract addresses (up to ${MAX_BATCH}); ${zeroAddress} for the native token`),
+      timestamp: z.number().int().positive().optional().describe('Unix time in seconds for a past price (defaults to now)')
+    }),
+    async (args) => {
+      const invalid = args.tokens.find((token) => !isAddress(token))
+      if (invalid) throw new Error(`Invalid token address: ${invalid}`)
+
+      const byToken = await llamaPrices(args.chain as ChainName, args.tokens, args.timestamp)
+
+      const prices = args.tokens.map((token) => {
+        const price = byToken.get(token.toLowerCase())
+        if (!price) return { token, priced: false }
+        return {
+          token,
+          priced: true,
+          symbol: price.symbol,
+          priceUsd: price.price,
+          decimals: price.decimals,
+          confidence: price.confidence,
+          updatedAt: new Date(price.timestamp * 1000).toISOString()
+        }
+      })
+
+      return formatResponse({ chain: args.chain, source: 'DefiLlama', prices })
+    }
+  ),
+
+  get_portfolio: createTool(
+    'Get Portfolio',
+    'What a wallet holds across chains, valued in USD: native and ERC20 balances found through Alchemy, priced by ' +
+      'DefiLlama, largest first. Tokens DefiLlama cannot price are left out — that drops the spam airdrops most ' +
+      'wallets collect. Positions inside DeFi protocols appear only as the receipt tokens DefiLlama happens to price.',
+    z.object({
+      address: z.string().describe('Wallet address'),
+      chains: z
+        .array(z.enum(SUPPORTED_CHAINS))
+        .optional()
+        .describe('Chains to look at (defaults to every chain where both the Alchemy token API and DefiLlama are available)'),
+      minValueUsd: z.number().optional().default(1).describe('Leave out holdings worth less than this, in USD (default 1)')
+    }),
+    async (args) => {
+      if (!isAddress(args.address)) throw new Error(`Invalid address: ${args.address}`)
+      const address = args.address
+      const chains = ((args.chains ?? SUPPORTED_CHAINS) as ChainName[]).filter(
+        (chain) => CHAINS[chain].alchemy && CHAINS[chain].alchemyTokenApi !== false && CHAINS[chain].llama
+      )
+
+      const scanned: Awaited<ReturnType<typeof holdingsOn>>[] = []
+      const failedChains: { chain: ChainName; error: string }[] = []
+      await Promise.all(
+        chains.map(async (chain) => {
+          try {
+            scanned.push(await holdingsOn(chain, address, args.minValueUsd))
+          } catch (error) {
+            failedChains.push({ chain, error: rpcReason(error) })
+          }
+        })
+      )
+      const holdings = scanned.flatMap((result) => result.holdings).sort((a, b) => b.valueUsd - a.valueUsd)
+      const truncatedChains = scanned.filter((result) => result.truncated).map((result) => result.chain)
+
+      return formatResponse({
+        address,
+        totalUsd: Math.round(holdings.reduce((sum, holding) => sum + holding.valueUsd, 0) * 100) / 100,
+        holdings,
+        hidden: {
+          unpriced: scanned.reduce((sum, result) => sum + result.unpriced, 0),
+          belowMinValue: scanned.reduce((sum, result) => sum + result.belowMinValue, 0)
+        },
+        ...(truncatedChains.length > 0 && { truncatedChains }),
+        ...(failedChains.length > 0 && { failedChains })
+      })
+    },
+    // alchemy_getTokenBalances is what finds the tokens; no other RPC here indexes them.
+    () => Boolean(getClientManager().getConfig().alchemyApiKey)
+  ),
+
+  get_yield_pools: createTool(
+    'Get Yield Pools',
+    'DeFi lending, staking and liquidity pools from DefiLlama, highest APY first — e.g. where USDC earns most on ' +
+      'Arbitrum, or what Aave pays on Base. Pools DefiLlama flags as APY outliers are left out. APY is a percentage.',
+    z.object({
+      chain: z
+        .enum(SUPPORTED_CHAINS)
+        .optional()
+        .describe('Only pools on this chain (defaults to every chain this server supports)'),
+      symbol: z.string().optional().describe('Only pools holding this token, e.g. "USDC" (matches "USDC" and "USDC-WETH")'),
+      project: z.string().optional().describe('Only this protocol, as DefiLlama names it — "aave" matches aave-v3 and aave-v2'),
+      stablecoinOnly: z.boolean().optional().default(false).describe('Only pools of stablecoins'),
+      minTvlUsd: z.number().optional().default(1_000_000).describe('Leave out pools smaller than this, in USD (default 1M)'),
+      limit: z.number().int().min(1).max(100).optional().default(20).describe('How many pools to return (default 20)')
+    }),
+    async (args) => {
+      const chains = new Map<string, ChainName>(
+        (args.chain ? [args.chain as ChainName] : SUPPORTED_CHAINS)
+          .filter((chain) => CHAINS[chain].llama)
+          .map((chain) => [llamaNames(chain).yields, chain])
+      )
+      const symbol = args.symbol?.toUpperCase()
+      const project = args.project?.toLowerCase()
+
+      // ponytail: fetches DefiLlama's whole pool list (~12 MB) per call; cache it for a few minutes if calls pile up.
+      const { data } = await llama<{ data: LlamaPool[] }>('https://yields.llama.fi/pools')
+
+      const matching = data
+        .filter(
+          (pool) =>
+            chains.has(pool.chain) &&
+            !pool.outlier &&
+            pool.apy !== null &&
+            pool.tvlUsd >= args.minTvlUsd &&
+            (!args.stablecoinOnly || pool.stablecoin) &&
+            (!project || pool.project.includes(project)) &&
+            (!symbol || pool.symbol.toUpperCase().split('-').includes(symbol))
+        )
+        .sort((a, b) => (b.apy ?? 0) - (a.apy ?? 0))
+
+      return formatResponse({
+        source: 'DefiLlama',
+        matched: matching.length,
+        pools: matching.slice(0, args.limit).map((pool) => ({
+          chain: chains.get(pool.chain),
+          project: pool.project,
+          symbol: pool.symbol,
+          ...(pool.poolMeta && { meta: pool.poolMeta }),
+          apy: pool.apy,
+          apyBase: pool.apyBase,
+          apyReward: pool.apyReward,
+          apyMean30d: pool.apyMean30d,
+          tvlUsd: Math.round(pool.tvlUsd),
+          stablecoin: pool.stablecoin,
+          ilRisk: pool.ilRisk,
+          exposure: pool.exposure,
+          underlyingTokens: pool.underlyingTokens,
+          url: `https://defillama.com/yields/pool/${pool.pool}`
+        }))
+      })
+    }
+  )
+}

package/src/types.ts

@@ -11,7 +11,6 @@ export interface AbiError {
 export interface Config {
   etherscanApiKey?: string
   alchemyApiKey?: string
-  infuraApiKey?: string
   customRpcUrls?: Record<string, string>
   hypersyncApiKey?: string
   walletConnectProjectId?: string

package/src/utils.ts

@@ -211,7 +211,7 @@ export function rpcReason(error: unknown): string {
 
 /** Every configured key blanked out of `text`: RPC URLs carry them, and errors quote the URL. */
 export function redactSecrets(text: string, config: Config): string {
-  return [config.alchemyApiKey, config.infuraApiKey, config.etherscanApiKey, config.hypersyncApiKey].reduce<string>(
+  return [config.alchemyApiKey, config.etherscanApiKey, config.hypersyncApiKey].reduce<string>(
     (out, secret) => (secret ? out.replaceAll(secret, '[redacted]') : out),
     text
   )
@@ -277,7 +277,6 @@ export function parseCommandLineArgs(): Config & { showHelp?: boolean } {
   // Parse environment variables and command line arguments
   config.etherscanApiKey = process.env.ETHERSCAN_API_KEY || getArgValue('--etherscan-api-key')
   config.alchemyApiKey = process.env.ALCHEMY_API_KEY || getArgValue('--alchemy-api-key')
-  config.infuraApiKey = process.env.INFURA_API_KEY || getArgValue('--infura-api-key')
   config.hypersyncApiKey = process.env.HYPERSYNC_API_KEY || getArgValue('--hypersync-api-key')
   config.walletConnectProjectId = process.env.WALLETCONNECT_PROJECT_ID || getArgValue('--walletconnect-project-id')
 

package/src/wallet-client.ts

@@ -3,7 +3,14 @@ import { randomBytes } from 'node:crypto'
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { LOCAL_PORT_ATTEMPTS, roomToken, type TransactionRequest, type TransactionResponse, WalletRelay } from 'web3-wallet-relay'
+import {
+  LOCAL_PORT_ATTEMPTS,
+  roomToken,
+  SIGN_PATH,
+  type TransactionRequest,
+  type TransactionResponse,
+  WalletRelay
+} from 'web3-wallet-relay'
 import { WebSocket } from 'ws'
 import { HOSTED } from './hosted.js'
 
@@ -26,7 +33,7 @@ const IDLE_TIMEOUT = 10 * 60_000
 /** Always the signer token: this URL goes to a browser, which may not act as a requester. */
 function pairingUrlFor(port: number, secret: string, identity: string): string {
   const base = HOSTED ? (process.env.MCP_PUBLIC_URL ?? `http://localhost:${port}`) : `http://127.0.0.1:${port}`
-  return `${base.replace(/\/$/, '')}/#t=${roomToken(secret, identity, 'signer')}`
+  return `${base.replace(/\/$/, '')}${SIGN_PATH}#t=${roomToken(secret, identity, 'signer')}`
 }
 const SIGNER_WAIT_TIMEOUT = 30_000
 const CONNECT_ATTEMPTS = 8