@hypurrquant/defi-cli 0.4.1 → 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({
@@ -5324,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" })]
@@ -7469,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