@hypurrquant/defi-cli 0.4.0 → 0.5.0

package/dist/mcp-server.js

@@ -436,9 +436,9 @@ var init_dist = __esm({
       getProtocolsByCategory(category) {
         return this.protocols.filter((p) => p.category === category);
       }
-      getProtocolsForChain(chain) {
+      getProtocolsForChain(chain, includeUnverified = false) {
         return this.protocols.filter(
-          (p) => p.chain.toLowerCase() === chain.toLowerCase()
+          (p) => p.chain.toLowerCase() === chain.toLowerCase() && (includeUnverified || p.verified !== false)
         );
       }
       resolveToken(chain, symbol) {
@@ -932,7 +932,7 @@ function createLiquidStaking(entry, rpcUrl) {
       return new GenericLstAdapter(entry, rpcUrl);
   }
 }
-function createGauge(entry, rpcUrl) {
+function createGauge(entry, rpcUrl, tokens) {
   if (entry.interface === "hybra" || entry.contracts?.["gauge_manager"]) {
     return new HybraGaugeAdapter(entry, rpcUrl);
   }
@@ -940,7 +940,11 @@ function createGauge(entry, rpcUrl) {
     case "solidly_v2":
     case "solidly_cl":
     case "algebra_v3":
-      return new SolidlyGaugeAdapter(entry, rpcUrl);
+      return new SolidlyGaugeAdapter(entry, rpcUrl, tokens);
+    // uniswap_v3 with voter = ve(3,3) CL (e.g., Aerodrome Slipstream, Ramses CL)
+    case "uniswap_v3":
+      if (entry.contracts?.["voter"]) return new SolidlyGaugeAdapter(entry, rpcUrl, tokens);
+      throw DefiError.unsupported(`Gauge interface '${entry.interface}' not supported (no voter contract)`);
     default:
       throw DefiError.unsupported(`Gauge interface '${entry.interface}' not supported`);
   }
@@ -2295,6 +2299,8 @@ var init_dist2 = __esm({
             gauge,
             token0: t0 ? symbolMap.get(t0) ?? t0.slice(0, 10) : "?",
             token1: t1 ? symbolMap.get(t1) ?? t1.slice(0, 10) : "?",
+            token0Addr: t0 ?? void 0,
+            token1Addr: t1 ?? void 0,
             type: "CL"
           });
         }
@@ -2500,6 +2506,7 @@ var init_dist2 = __esm({
       "function getReward(address account, address[] tokens) external",
       "function getReward(uint256 tokenId) external",
       "function earned(address account) external view returns (uint256)",
+      "function earned(address account, uint256 tokenId) external view returns (uint256)",
       "function earned(address token, address account) external view returns (uint256)",
       "function earned(uint256 tokenId) external view returns (uint256)",
       "function rewardRate() external view returns (uint256)",
@@ -2550,7 +2557,8 @@ var init_dist2 = __esm({
       rpcUrl;
       clFactory;
       v2Factory;
-      constructor(entry, rpcUrl) {
+      tokens;
+      constructor(entry, rpcUrl, tokens) {
         this.protocolName = entry.name;
         const voter = entry.contracts?.["voter"];
         if (!voter) {
@@ -2563,6 +2571,7 @@ var init_dist2 = __esm({
         this.voter = voter;
         this.veToken = veToken;
         this.rpcUrl = rpcUrl;
+        this.tokens = tokens;
         this.clFactory = entry.contracts?.["cl_factory"] ?? entry.contracts?.["factory"];
         this.v2Factory = entry.contracts?.["pair_factory"] ?? entry.contracts?.["factory"];
       }
@@ -2577,57 +2586,148 @@ var init_dist2 = __esm({
           this._discoverV2GaugedPools(results),
           this._discoverCLGaugedPools(results)
         ]);
+        await this._enrichGaugeMetrics(results);
         return results;
       }
+      /**
+       * Batch query rewardRate, totalSupply, rewardToken for all discovered gauges.
+       * Handles both single-token (rewardRate) and multi-token (rewardData) gauges.
+       */
+      async _enrichGaugeMetrics(pools) {
+        if (!this.rpcUrl || pools.length === 0) return;
+        const _u256Abi = parseAbi10(["function f() view returns (uint256)"]);
+        const calls = [];
+        for (const p of pools) {
+          calls.push([p.gauge, encodeFunctionData10({ abi: gaugeAbi, functionName: "rewardRate" })]);
+          calls.push([p.gauge, encodeFunctionData10({ abi: gaugeAbi, functionName: "totalSupply" })]);
+          calls.push([p.gauge, encodeFunctionData10({ abi: gaugeAbi, functionName: "rewardToken" })]);
+        }
+        const results = await multicallRead(this.rpcUrl, calls).catch(() => []);
+        for (let i = 0; i < pools.length; i++) {
+          const base = i * 3;
+          try {
+            pools[i].rewardRate = results[base] ? decodeFunctionResult3({ abi: _u256Abi, functionName: "f", data: results[base] }) : 0n;
+          } catch {
+            pools[i].rewardRate = 0n;
+          }
+          try {
+            pools[i].totalStaked = results[base + 1] ? decodeFunctionResult3({ abi: _u256Abi, functionName: "f", data: results[base + 1] }) : 0n;
+          } catch {
+            pools[i].totalStaked = 0n;
+          }
+          try {
+            pools[i].rewardToken = results[base + 2] ? decodeAddress2(results[base + 2]) ?? void 0 : void 0;
+          } catch {
+          }
+        }
+        const KNOWN_REWARD_TOKENS = [
+          "0x555570a286F15EbDFE42B66eDE2f724Aa1AB5555",
+          // xRAM
+          "0x5555555555555555555555555555555555555555",
+          // WHYPE
+          "0x067b0C72aa4C6Bd3BFEFfF443c536DCd6a25a9C8",
+          // HYBR
+          "0x07c57E32a3C29D5659bda1d3EFC2E7BF004E3035"
+          // NEST
+        ];
+        const needsFallback = pools.filter((p) => (p.rewardRate ?? 0n) === 0n && (p.totalStaked ?? 0n) > 0n);
+        if (needsFallback.length === 0) return;
+        const rdCalls = [];
+        const rdMeta = [];
+        for (const p of needsFallback) {
+          const poolIdx = pools.indexOf(p);
+          for (const token of KNOWN_REWARD_TOKENS) {
+            rdCalls.push([p.gauge, encodeFunctionData10({ abi: gaugeAbi, functionName: "rewardData", args: [token] })]);
+            rdMeta.push({ poolIdx, token });
+          }
+        }
+        const rdResults = await multicallRead(this.rpcUrl, rdCalls).catch(() => []);
+        const _rdAbi = parseAbi10(["function f() view returns (uint256, uint256, uint256, uint256)"]);
+        for (let i = 0; i < rdMeta.length; i++) {
+          const { poolIdx, token } = rdMeta[i];
+          const pool = pools[poolIdx];
+          if ((pool.rewardRate ?? 0n) > 0n) continue;
+          try {
+            if (!rdResults[i]) continue;
+            const decoded = decodeFunctionResult3({ abi: _rdAbi, functionName: "f", data: rdResults[i] });
+            const [periodFinish, rewardRate] = decoded;
+            const now = BigInt(Math.floor(Date.now() / 1e3));
+            if (rewardRate > 0n && periodFinish > now) {
+              pool.rewardRate = rewardRate;
+              pool.rewardToken = token;
+            }
+          } catch {
+          }
+        }
+      }
       async _discoverV2GaugedPools(out) {
         if (!this.rpcUrl || !this.v2Factory) return;
-        const v2FactoryAbi = parseAbi10([
-          "function allPairsLength() external view returns (uint256)",
-          "function allPairs(uint256) external view returns (address)"
-        ]);
         const pairAbi = parseAbi10([
           "function token0() external view returns (address)",
           "function token1() external view returns (address)",
           "function stable() external view returns (bool)"
         ]);
         const erc20SymbolAbi = parseAbi10(["function symbol() external view returns (string)"]);
+        const voterLengthAbi = parseAbi10(["function length() external view returns (uint256)"]);
+        const voterPoolsAbi = parseAbi10(["function pools(uint256) external view returns (address)"]);
+        const gaugeForPoolAbi = parseAbi10(["function gaugeForPool(address) external view returns (address)"]);
+        const poolToGaugeAbi = parseAbi10(["function poolToGauge(address) external view returns (address)"]);
+        const gaugesAbi = parseAbi10(["function gauges(address) external view returns (address)"]);
         const client = createPublicClient6({ transport: http6(this.rpcUrl) });
-        let pairCount;
+        let pairs = [];
+        let voterPoolCount = 0;
         try {
-          pairCount = await client.readContract({
-            address: this.v2Factory,
-            abi: v2FactoryAbi,
-            functionName: "allPairsLength"
-          });
+          const len = await client.readContract({ address: this.voter, abi: voterLengthAbi, functionName: "length" });
+          voterPoolCount = Number(len);
         } catch {
-          return;
         }
-        const count = Number(pairCount);
-        if (count === 0) return;
-        const pairAddressCalls = [];
-        for (let i = 0; i < count; i++) {
-          pairAddressCalls.push([
-            this.v2Factory,
-            encodeFunctionData10({ abi: v2FactoryAbi, functionName: "allPairs", args: [BigInt(i)] })
-          ]);
+        if (voterPoolCount > 0) {
+          const MAX_SCAN = 500;
+          const startIdx = Math.max(0, voterPoolCount - MAX_SCAN);
+          const poolCalls = [];
+          for (let i = startIdx; i < voterPoolCount; i++) {
+            poolCalls.push([this.voter, encodeFunctionData10({ abi: voterPoolsAbi, functionName: "pools", args: [BigInt(i)] })]);
+          }
+          const poolResults = await multicallRead(this.rpcUrl, poolCalls);
+          pairs = poolResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress6);
+        } else {
+          const v2FactoryAbi = parseAbi10(["function allPairsLength() view returns (uint256)", "function allPairs(uint256) view returns (address)"]);
+          const solidlyFactoryAbi = parseAbi10(["function allPoolsLength() view returns (uint256)", "function allPools(uint256) view returns (address)"]);
+          let pairCount = 0n;
+          let useSolidly = false;
+          try {
+            pairCount = await client.readContract({ address: this.v2Factory, abi: v2FactoryAbi, functionName: "allPairsLength" });
+          } catch {
+            try {
+              pairCount = await client.readContract({ address: this.v2Factory, abi: solidlyFactoryAbi, functionName: "allPoolsLength" });
+              useSolidly = true;
+            } catch {
+              return;
+            }
+          }
+          const count = Number(pairCount);
+          if (count === 0) return;
+          const MAX_SCAN = 500;
+          const startIdx = Math.max(0, count - MAX_SCAN);
+          const fetchAbi = useSolidly ? solidlyFactoryAbi : v2FactoryAbi;
+          const fetchFn = useSolidly ? "allPools" : "allPairs";
+          const pairCalls = [];
+          for (let i = startIdx; i < count; i++) pairCalls.push([this.v2Factory, encodeFunctionData10({ abi: fetchAbi, functionName: fetchFn, args: [BigInt(i)] })]);
+          const pairResults = await multicallRead(this.rpcUrl, pairCalls);
+          pairs = pairResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress6);
         }
-        const pairAddressResults = await multicallRead(this.rpcUrl, pairAddressCalls);
-        const pairs = pairAddressResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress6);
         if (pairs.length === 0) return;
-        const gaugeForPoolAbi = parseAbi10(["function gaugeForPool(address) external view returns (address)"]);
-        const poolToGaugeAbi = parseAbi10(["function poolToGauge(address) external view returns (address)"]);
-        const gaugeCalls = pairs.map((pair) => [
-          this.voter,
-          encodeFunctionData10({ abi: gaugeForPoolAbi, functionName: "gaugeForPool", args: [pair] })
-        ]);
+        const gaugeCalls = pairs.map((p) => [this.voter, encodeFunctionData10({ abi: gaugeForPoolAbi, functionName: "gaugeForPool", args: [p] })]);
         let gaugeResults = await multicallRead(this.rpcUrl, gaugeCalls);
-        const allNullV2 = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
-        if (allNullV2) {
-          const fallbackCalls = pairs.map((pair) => [
-            this.voter,
-            encodeFunctionData10({ abi: poolToGaugeAbi, functionName: "poolToGauge", args: [pair] })
-          ]);
-          gaugeResults = await multicallRead(this.rpcUrl, fallbackCalls);
+        const allNull = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
+        if (allNull) {
+          const fb1 = pairs.map((p) => [this.voter, encodeFunctionData10({ abi: poolToGaugeAbi, functionName: "poolToGauge", args: [p] })]);
+          gaugeResults = await multicallRead(this.rpcUrl, fb1);
+        }
+        const allNull2 = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
+        if (allNull2) {
+          const fb2 = pairs.map((p) => [this.voter, encodeFunctionData10({ abi: gaugesAbi, functionName: "gauges", args: [p] })]);
+          gaugeResults = await multicallRead(this.rpcUrl, fb2);
         }
         const gaugedPairs = [];
         for (let i = 0; i < pairs.length; i++) {
@@ -2672,6 +2772,8 @@ var init_dist2 = __esm({
             gauge,
             token0: t0 ? symbolMap.get(t0) ?? t0.slice(0, 10) : "?",
             token1: t1 ? symbolMap.get(t1) ?? t1.slice(0, 10) : "?",
+            token0Addr: t0 ?? void 0,
+            token1Addr: t1 ?? void 0,
             type: "V2",
             stable
           });
@@ -2692,8 +2794,7 @@ var init_dist2 = __esm({
         const erc20SymbolAbi = parseAbi10(["function symbol() external view returns (string)"]);
         const gaugeForPoolAbi = parseAbi10(["function gaugeForPool(address) external view returns (address)"]);
         const poolToGaugeAbi = parseAbi10(["function poolToGauge(address) external view returns (address)"]);
-        const tokenEntries = Object.entries(HYPEREVM_TOKENS);
-        const tokenAddresses = tokenEntries.map(([, addr]) => addr);
+        const tokenAddresses = this.tokens ?? Object.values(HYPEREVM_TOKENS);
         const pairs = [];
         for (let i = 0; i < tokenAddresses.length; i++) {
           for (let j = i + 1; j < tokenAddresses.length; j++) {
@@ -2798,6 +2899,8 @@ var init_dist2 = __esm({
             gauge,
             token0: symbolMap.get(t0) ?? t0.slice(0, 10),
             token1: symbolMap.get(t1) ?? t1.slice(0, 10),
+            token0Addr: t0,
+            token1Addr: t1,
             type: "CL",
             tickSpacing
           });
@@ -3032,6 +3135,21 @@ var init_dist2 = __esm({
           args: [tokenId]
         });
       }
+      /**
+       * Get pending rewards for an Aerodrome Slipstream CL gauge NFT position.
+       * Uses the earned(address account, uint256 tokenId) overload, which is required
+       * for CL gauges — the single-param earned(address) reverts on these contracts.
+       */
+      async getPendingRewardsByCLTokenId(gauge, user, tokenId) {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
+        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+        return await client.readContract({
+          address: gauge,
+          abi: gaugeAbi,
+          functionName: "earned",
+          args: [user, tokenId]
+        });
+      }
       // IVoteEscrow
       async buildCreateLock(amount, lockDuration) {
         const data = encodeFunctionData10({
@@ -3312,7 +3430,8 @@ var init_dist2 = __esm({
       "function findBestPathFromAmountIn(address[] calldata route, uint128 amountIn) external view returns ((address[] route, address[] pairs, uint256[] binSteps, uint256[] versions, uint128[] amounts, uint128[] virtualAmountsWithoutSlippage, uint128[] fees))"
     ]);
     erc20Abi2 = parseAbi12([
-      "function symbol() external view returns (string)"
+      "function symbol() external view returns (string)",
+      "function balanceOf(address account) external view returns (uint256)"
     ]);
     _addressAbi = parseAbi12(["function f() external view returns (address)"]);
     _uint256Abi = parseAbi12(["function f() external view returns (uint256)"]);
@@ -3729,6 +3848,74 @@ var init_dist2 = __esm({
           } catch {
           }
         }
+        const stableSymbols = /* @__PURE__ */ new Set(["USDT", "USDC", "USDT0", "MUSD", "AUSD", "USDY", "FDUSD", "USDe", "sUSDe"]);
+        const mntSymbols = /* @__PURE__ */ new Set(["WMNT", "MNT"]);
+        const moeSymbols = /* @__PURE__ */ new Set(["MOE"]);
+        const sixDecimalStables = /* @__PURE__ */ new Set(["USDT", "USDC", "USDT0", "FDUSD"]);
+        const tokenPriceMap = /* @__PURE__ */ new Map();
+        const tokenDecimalsMap = /* @__PURE__ */ new Map();
+        for (const [addr, sym] of symbolMap) {
+          const key = addr.toLowerCase();
+          if (stableSymbols.has(sym)) {
+            tokenPriceMap.set(key, 1);
+            tokenDecimalsMap.set(key, sixDecimalStables.has(sym) ? 6 : 18);
+          } else if (mntSymbols.has(sym)) {
+            tokenPriceMap.set(key, wmntPriceUsd);
+            tokenDecimalsMap.set(key, 18);
+          } else if (moeSymbols.has(sym)) {
+            tokenPriceMap.set(key, moePriceUsd);
+            tokenDecimalsMap.set(key, 18);
+          }
+        }
+        const unknownTokenAddrs = [];
+        for (let i = 0; i < rewardedPairs.length; i++) {
+          for (const addr of [tokenXAddresses[i], tokenYAddresses[i]]) {
+            if (addr && !tokenPriceMap.has(addr.toLowerCase())) {
+              if (!unknownTokenAddrs.some((a) => a.toLowerCase() === addr.toLowerCase())) {
+                unknownTokenAddrs.push(addr);
+              }
+            }
+          }
+        }
+        if (unknownTokenAddrs.length > 0 && this.lbQuoter && this.wmnt && wmntPriceUsd > 0) {
+          const erc20DecimalsAbi = parseAbi12(["function decimals() external view returns (uint8)"]);
+          const decCalls = unknownTokenAddrs.map((addr) => [
+            addr,
+            encodeFunctionData12({ abi: erc20DecimalsAbi, functionName: "decimals" })
+          ]);
+          const decResults = await multicallRead(rpcUrl, decCalls).catch(() => []);
+          for (let i = 0; i < unknownTokenAddrs.length; i++) {
+            const dec = decResults[i] ? Number(decodeUint256Result(decResults[i]) ?? 18n) : 18;
+            tokenDecimalsMap.set(unknownTokenAddrs[i].toLowerCase(), dec);
+          }
+          const quotePromises = unknownTokenAddrs.map(async (tokenAddr) => {
+            try {
+              const dec = tokenDecimalsMap.get(tokenAddr.toLowerCase()) ?? 18;
+              const quoteUnit = 10n ** BigInt(Math.max(dec - 2, 0));
+              const quote = await client.readContract({
+                address: this.lbQuoter,
+                abi: lbQuoterAbi2,
+                functionName: "findBestPathFromAmountIn",
+                args: [[tokenAddr, this.wmnt], quoteUnit]
+              });
+              const amountOut = quote.amounts?.at(-1) ?? 0n;
+              const priceInWmnt = Number(amountOut) / 1e18 * (10 ** dec / Number(quoteUnit));
+              return { addr: tokenAddr, price: priceInWmnt * wmntPriceUsd };
+            } catch {
+              return { addr: tokenAddr, price: 0 };
+            }
+          });
+          const priceResults = await Promise.all(quotePromises);
+          for (const { addr, price } of priceResults) {
+            if (price > 0) tokenPriceMap.set(addr.toLowerCase(), price);
+          }
+        }
+        const getTokenPriceUsd = (_sym, addr) => {
+          return tokenPriceMap.get(addr.toLowerCase()) ?? 0;
+        };
+        const getTokenDecimals = (_sym, addr) => {
+          return tokenDecimalsMap.get(addr.toLowerCase()) ?? 18;
+        };
         const binRequests = [];
         for (let i = 0; i < rewardedPairs.length; i++) {
           const range = poolData[i].range;
@@ -3759,19 +3946,23 @@ var init_dist2 = __esm({
             binReservesY.get(poolIdx).set(binId, decoded[1]);
           }
         }
-        const stableSymbols = /* @__PURE__ */ new Set(["USDT", "USDC", "MUSD", "AUSD", "USDY", "FDUSD"]);
-        const mntSymbols = /* @__PURE__ */ new Set(["WMNT", "MNT"]);
-        const moeSymbols = /* @__PURE__ */ new Set(["MOE"]);
-        const sixDecimalStables = /* @__PURE__ */ new Set(["USDT", "USDC", "FDUSD"]);
-        const getTokenPriceUsd = (sym) => {
-          if (stableSymbols.has(sym)) return 1;
-          if (mntSymbols.has(sym)) return wmntPriceUsd;
-          if (moeSymbols.has(sym)) return moePriceUsd;
-          return 0;
-        };
-        const getTokenDecimals = (sym) => {
-          return sixDecimalStables.has(sym) ? 6 : 18;
-        };
+        const poolBalanceX = /* @__PURE__ */ new Map();
+        const poolBalanceY = /* @__PURE__ */ new Map();
+        {
+          const balCalls = [];
+          for (let i = 0; i < rewardedPairs.length; i++) {
+            const tx = tokenXAddresses[i];
+            const ty = tokenYAddresses[i];
+            const pool = rewardedPairs[i].pool;
+            balCalls.push([tx ?? "0x0000000000000000000000000000000000000000", encodeFunctionData12({ abi: erc20Abi2, functionName: "balanceOf", args: [pool] })]);
+            balCalls.push([ty ?? "0x0000000000000000000000000000000000000000", encodeFunctionData12({ abi: erc20Abi2, functionName: "balanceOf", args: [pool] })]);
+          }
+          const balResults = await multicallRead(rpcUrl, balCalls).catch(() => []);
+          for (let i = 0; i < rewardedPairs.length; i++) {
+            poolBalanceX.set(i, decodeUint256Result(balResults[i * 2] ?? null) ?? 0n);
+            poolBalanceY.set(i, decodeUint256Result(balResults[i * 2 + 1] ?? null) ?? 0n);
+          }
+        }
         const results = [];
         for (let i = 0; i < rewardedPairs.length; i++) {
           const { pool, rewarder } = rewardedPairs[i];
@@ -3796,18 +3987,25 @@ var init_dist2 = __esm({
             const maxBin = Number(range[1]);
             rewardedBins = maxBin - minBin + 1;
             if (rxMap && ryMap) {
-              const priceX = getTokenPriceUsd(symX);
-              const priceY = getTokenPriceUsd(symY);
-              const decX = getTokenDecimals(symX);
-              const decY = getTokenDecimals(symY);
+              const priceX2 = getTokenPriceUsd(symX, tokenX);
+              const priceY2 = getTokenPriceUsd(symY, tokenY);
+              const decX2 = getTokenDecimals(symX, tokenX);
+              const decY2 = getTokenDecimals(symY, tokenY);
               for (let b = minBin; b <= maxBin; b++) {
                 const rx = rxMap.get(b) ?? 0n;
                 const ry = ryMap.get(b) ?? 0n;
-                rangeTvlUsd += Number(rx) / 10 ** decX * priceX;
-                rangeTvlUsd += Number(ry) / 10 ** decY * priceY;
+                rangeTvlUsd += Number(rx) / 10 ** decX2 * priceX2;
+                rangeTvlUsd += Number(ry) / 10 ** decY2 * priceY2;
               }
             }
           }
+          const priceX = getTokenPriceUsd(symX, tokenX);
+          const priceY = getTokenPriceUsd(symY, tokenY);
+          const decX = getTokenDecimals(symX, tokenX);
+          const decY = getTokenDecimals(symY, tokenY);
+          const fullBalX = poolBalanceX.get(i) ?? 0n;
+          const fullBalY = poolBalanceY.get(i) ?? 0n;
+          const poolTvlUsd = Number(fullBalX) / 10 ** decX * priceX + Number(fullBalY) / 10 ** decY * priceY;
           const aprPercent = rangeTvlUsd > 0 && moePriceUsd > 0 ? poolMoePerDay * moePriceUsd * 365 / rangeTvlUsd * 100 : 0;
           results.push({
             pool,
@@ -3824,8 +4022,11 @@ var init_dist2 = __esm({
             isTopPool,
             moePerDay: poolMoePerDay,
             rangeTvlUsd,
+            poolTvlUsd,
             aprPercent,
-            rewardedBins
+            rewardedBins,
+            totalMoePerDay: moePerDay,
+            moePriceUsd
           });
         }
         return results;
@@ -5241,7 +5442,7 @@ var init_dist2 = __esm({
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
         if (!this.defaultVault) {
-          throw DefiError.contractError(`[${this.protocolName}] No MetaMorpho vault configured for rate query`);
+          return { protocol: this.protocolName, asset, supply_apy: 0, borrow_variable_apy: 0, borrow_stable_apy: 0, utilization: 0, total_supply: 0n, total_borrow: 0n };
         }
         const [queueLenRaw] = await multicallRead(this.rpcUrl, [
           [this.defaultVault, encodeFunctionData19({ abi: META_MORPHO_ABI, functionName: "supplyQueueLength" })]
@@ -7386,6 +7587,52 @@ server.tool(
     }
   }
 );
+server.tool(
+  "defi_yield_scan",
+  "Scan all configured chains for the best lending yield opportunities for a given asset. Compares supply APY across Aave V3, Compound, Venus, Morpho, etc. Returns ranked results with chain, protocol, supply_apy, borrow_apy, utilization.",
+  {
+    asset: z.string().optional().describe("Token symbol to scan (default: USDC)")
+  },
+  async ({ asset }) => {
+    const registry = Registry.loadEmbedded();
+    const symbol = asset ?? "USDC";
+    const results = [];
+    const chains = Array.from(registry.chains.keys());
+    await Promise.allSettled(
+      chains.map(async (chainName) => {
+        const chain = registry.getChain(chainName);
+        const rpcUrl = chain.effectiveRpcUrl();
+        const lendingProtos = registry.getProtocolsForChain(chainName).filter((p) => p.category === "lending");
+        for (const proto of lendingProtos) {
+          try {
+            const adapter = createLending(proto, rpcUrl);
+            const tokens = registry.tokens.get(chainName);
+            const token = tokens?.find((t) => t.symbol.toUpperCase() === symbol.toUpperCase());
+            if (!token) continue;
+            const rates = await adapter.getRates(token.address);
+            results.push({
+              chain: chainName,
+              protocol: proto.name,
+              slug: proto.slug,
+              asset: token.symbol,
+              asset_address: token.address,
+              supply_apy: rates.supply_apy,
+              borrow_variable_apy: rates.borrow_variable_apy,
+              utilization: rates.utilization,
+              total_supply: rates.total_supply?.toString(),
+              total_borrow: rates.total_borrow?.toString()
+            });
+          } catch {
+          }
+        }
+      })
+    );
+    results.sort((a, b) => b.supply_apy - a.supply_apy);
+    return {
+      content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+    };
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);
 //# sourceMappingURL=mcp-server.js.map