@hypurrquant/defi-cli 1.0.7 → 1.0.9

package/dist/mcp-server.js

@@ -4189,6 +4189,79 @@ var init_dist2 = __esm({
           gas_estimate: 3e5
         };
       }
+      /**
+       * List every LB pair from the factory with basic pair info (no rewarder /
+       * APR enrichment). Useful when the factory has pools but none have hooks
+       * deployed yet (e.g. early-stage Monad TraderJoe).
+       *
+       * Three multicall batches: pair addresses, token addresses, token symbols.
+       */
+      async discoverAllPools() {
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const pairCount = await client.readContract({
+          address: this.lbFactory,
+          abi: lbFactoryAbi,
+          functionName: "getNumberOfLBPairs"
+        });
+        const count = Number(pairCount);
+        if (count === 0) return [];
+        const indexCalls = Array.from({ length: count }, (_, i) => [
+          this.lbFactory,
+          encodeFunctionData12({ abi: lbFactoryAbi, functionName: "getLBPairAtIndex", args: [BigInt(i)] })
+        ]);
+        const indexResults = await multicallRead(rpcUrl, indexCalls);
+        const pairs = indexResults.map((r) => decodeAddressResult(r)).filter((a) => a !== null);
+        if (pairs.length === 0) return [];
+        const tokenCalls = [];
+        for (const pool of pairs) {
+          tokenCalls.push([pool, encodeFunctionData12({ abi: lbPairAbi, functionName: "getTokenX" })]);
+          tokenCalls.push([pool, encodeFunctionData12({ abi: lbPairAbi, functionName: "getTokenY" })]);
+        }
+        const tokenResults = await multicallRead(rpcUrl, tokenCalls);
+        const tokensX = [];
+        const tokensY = [];
+        for (let i = 0; i < pairs.length; i++) {
+          tokensX.push(decodeAddressResult(tokenResults[i * 2] ?? null));
+          tokensY.push(decodeAddressResult(tokenResults[i * 2 + 1] ?? null));
+        }
+        const uniqueTokens = Array.from(
+          new Set([...tokensX, ...tokensY].filter((a) => a !== null))
+        );
+        const symbolCalls = uniqueTokens.map((t) => [
+          t,
+          encodeFunctionData12({ abi: erc20Abi2, functionName: "symbol" })
+        ]);
+        const symbolResults = await multicallRead(rpcUrl, symbolCalls);
+        const symbolMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < uniqueTokens.length; i++) {
+          const raw = symbolResults[i];
+          if (!raw) continue;
+          try {
+            const sym = decodeFunctionResult4({
+              abi: parseAbi12(["function f() external view returns (string)"]),
+              functionName: "f",
+              data: raw
+            });
+            symbolMap.set(uniqueTokens[i].toLowerCase(), sym);
+          } catch {
+          }
+        }
+        const out = [];
+        for (let i = 0; i < pairs.length; i++) {
+          const tx = tokensX[i];
+          const ty = tokensY[i];
+          if (!tx || !ty) continue;
+          out.push({
+            pool: pairs[i],
+            tokenX: tx,
+            tokenY: ty,
+            symbolX: symbolMap.get(tx.toLowerCase()) ?? "?",
+            symbolY: symbolMap.get(ty.toLowerCase()) ?? "?"
+          });
+        }
+        return out;
+      }
       /**
        * Discover all active rewarded LB pools by iterating the factory.
        * Uses 7 multicall batches to minimise RPC round-trips and avoid 429s.
@@ -5169,6 +5242,7 @@ var init_dist2 = __esm({
       "function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf) external returns (uint256)",
       "function withdraw(address asset, uint256 amount, address to) external returns (uint256)",
       "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)",
+      "function getReservesList() external view returns (address[])",
       "function getReserveData(address asset) external view returns (uint256 configuration, uint128 liquidityIndex, uint128 currentLiquidityRate, uint128 variableBorrowIndex, uint128 currentVariableBorrowRate, uint128 currentStableBorrowRate, uint40 lastUpdateTimestamp, uint16 id, address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress, address interestRateStrategyAddress, uint128 accruedToTreasury, uint128 unbacked, uint128 isolationModeTotalDebt)"
     ]);
     ERC20_ABI = parseAbi14([
@@ -5255,13 +5329,37 @@ var init_dist2 = __esm({
         };
       }
       async buildWithdraw(params) {
+        let withdrawAmount = params.amount;
+        if (this.rpcUrl) {
+          try {
+            const client = createPublicClient10({ transport: http10(this.rpcUrl) });
+            const reserveData = await client.readContract({
+              address: this.pool,
+              abi: POOL_ABI,
+              functionName: "getReserveData",
+              args: [params.asset]
+            });
+            const aToken = reserveData[8];
+            const aBal = await client.readContract({
+              address: aToken,
+              abi: parseAbi14(["function balanceOf(address) view returns (uint256)"]),
+              functionName: "balanceOf",
+              args: [params.to]
+            });
+            if (aBal > 0n && params.amount >= aBal) {
+              withdrawAmount = (1n << 256n) - 1n;
+            }
+          } catch {
+          }
+        }
         const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "withdraw",
-          args: [params.asset, params.amount, params.to]
+          args: [params.asset, withdrawAmount, params.to]
         });
+        const isMax = withdrawAmount === (1n << 256n) - 1n;
         return {
-          description: `[${this.protocolName}] Withdraw ${params.amount} from pool`,
+          description: `[${this.protocolName}] Withdraw ${isMax ? "all (auto-max)" : withdrawAmount} from pool`,
           to: this.pool,
           data,
           value: 0n,
@@ -5455,7 +5553,7 @@ var init_dist2 = __esm({
       async getUserPosition(user) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
         const client = createPublicClient10({ transport: http10(this.rpcUrl) });
-        const result = await client.readContract({
+        const accountData = await client.readContract({
           address: this.pool,
           abi: POOL_ABI,
           functionName: "getUserAccountData",
@@ -5463,21 +5561,63 @@ var init_dist2 = __esm({
         }).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] getUserAccountData failed: ${e}`);
         });
-        const [totalCollateralBase, totalDebtBase, , , ltv, healthFactor] = result;
+        const [totalCollateralBase, totalDebtBase, , , ltv, healthFactor] = accountData;
         const MAX_UINT2562 = 2n ** 256n - 1n;
-        const hf = healthFactor >= MAX_UINT2562 ? Infinity : Number(healthFactor) / 1e18;
+        const hf = healthFactor >= MAX_UINT2562 ? null : Number(healthFactor) / 1e18;
         const collateralUsd = u256ToF64(totalCollateralBase) / 1e8;
         const debtUsd = u256ToF64(totalDebtBase) / 1e8;
-        const ltvBps = u256ToF64(ltv);
-        const supplies = collateralUsd > 0 ? [{ asset: zeroAddress8, symbol: "Total Collateral", amount: totalCollateralBase, value_usd: collateralUsd }] : [];
-        const borrows = debtUsd > 0 ? [{ asset: zeroAddress8, symbol: "Total Debt", amount: totalDebtBase, value_usd: debtUsd }] : [];
+        const ltvPct = u256ToF64(ltv) / 100;
+        const supplies = [];
+        const borrows = [];
+        try {
+          const reserves = await client.readContract({
+            address: this.pool,
+            abi: POOL_ABI,
+            functionName: "getReservesList"
+          });
+          const reserveData = await Promise.allSettled(reserves.map(async (asset) => {
+            const data = await client.readContract({
+              address: this.pool,
+              abi: POOL_ABI,
+              functionName: "getReserveData",
+              args: [asset]
+            });
+            const aToken = data[8];
+            const debtToken = data[10];
+            return { asset, aToken, debtToken };
+          }));
+          const ERC20_ABI42 = parseAbi14([
+            "function balanceOf(address) view returns (uint256)",
+            "function symbol() view returns (string)"
+          ]);
+          const positions = await Promise.allSettled(reserveData.map(async (r) => {
+            if (r.status !== "fulfilled") return null;
+            const { asset, aToken, debtToken } = r.value;
+            const [aBal, dBal, sym] = await Promise.all([
+              client.readContract({ address: aToken, abi: ERC20_ABI42, functionName: "balanceOf", args: [user] }),
+              client.readContract({ address: debtToken, abi: ERC20_ABI42, functionName: "balanceOf", args: [user] }),
+              client.readContract({ address: asset, abi: ERC20_ABI42, functionName: "symbol" }).catch(() => "?")
+            ]);
+            return { asset, symbol: sym, supply: aBal, borrow: dBal };
+          }));
+          for (const p of positions) {
+            if (p.status !== "fulfilled" || !p.value) continue;
+            if (p.value.supply > 0n) supplies.push({ asset: p.value.asset, symbol: p.value.symbol, amount: p.value.supply });
+            if (p.value.borrow > 0n) borrows.push({ asset: p.value.asset, symbol: p.value.symbol, amount: p.value.borrow });
+          }
+        } catch {
+          if (collateralUsd > 0) supplies.push({ asset: zeroAddress8, symbol: "Total Collateral (per-asset breakdown unavailable)", amount: totalCollateralBase });
+          if (debtUsd > 0) borrows.push({ asset: zeroAddress8, symbol: "Total Debt (per-asset breakdown unavailable)", amount: totalDebtBase });
+        }
         return {
           protocol: this.protocolName,
           user,
           supplies,
           borrows,
           health_factor: hf,
-          net_apy: ltvBps / 100
+          ltv_pct: ltvPct,
+          total_collateral_usd: collateralUsd,
+          total_debt_usd: debtUsd
         };
       }
     };
@@ -5734,6 +5874,7 @@ var init_dist2 = __esm({
       "function borrowBalanceStored(address account) external view returns (uint256)",
       "function mint(uint256 mintAmount) external returns (uint256)",
       "function redeem(uint256 redeemTokens) external returns (uint256)",
+      "function redeemUnderlying(uint256 redeemAmount) external returns (uint256)",
       "function borrow(uint256 borrowAmount) external returns (uint256)",
       "function repayBorrow(uint256 repayAmount) external returns (uint256)"
     ]);
@@ -5776,57 +5917,55 @@ var init_dist2 = __esm({
       name() {
         return this.protocolName;
       }
+      // Resolve the vToken whose underlying() matches params.asset. Compound V2 has
+      // a separate vToken per asset, so all builders must dispatch on the request
+      // asset. Returns the resolved vToken or throws if no candidate matches.
+      async vtokenFor(asset) {
+        const v = await this.resolveVtoken(asset);
+        if (!v) throw DefiError.contractError(`[${this.protocolName}] no vToken for asset ${asset}`);
+        return v;
+      }
       async buildSupply(params) {
-        const data = encodeFunctionData16({
-          abi: CTOKEN_ABI,
-          functionName: "mint",
-          args: [params.amount]
-        });
+        const vtoken = await this.vtokenFor(params.asset);
+        const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "mint", args: [params.amount] });
         return {
-          description: `[${this.protocolName}] Supply ${params.amount} to Venus`,
-          to: this.defaultVtoken,
+          description: `[${this.protocolName}] Supply ${params.amount} of ${params.asset} to Venus`,
+          to: vtoken,
           data,
           value: 0n,
-          gas_estimate: 3e5
+          gas_estimate: 3e5,
+          approvals: [{ token: params.asset, spender: vtoken, amount: params.amount }]
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData16({
-          abi: CTOKEN_ABI,
-          functionName: "borrow",
-          args: [params.amount]
-        });
+        const vtoken = await this.vtokenFor(params.asset);
+        const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "borrow", args: [params.amount] });
         return {
-          description: `[${this.protocolName}] Borrow ${params.amount} from Venus`,
-          to: this.defaultVtoken,
+          description: `[${this.protocolName}] Borrow ${params.amount} of ${params.asset} from Venus`,
+          to: vtoken,
           data,
           value: 0n,
           gas_estimate: 35e4
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData16({
-          abi: CTOKEN_ABI,
-          functionName: "repayBorrow",
-          args: [params.amount]
-        });
+        const vtoken = await this.vtokenFor(params.asset);
+        const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "repayBorrow", args: [params.amount] });
         return {
-          description: `[${this.protocolName}] Repay ${params.amount} to Venus`,
-          to: this.defaultVtoken,
+          description: `[${this.protocolName}] Repay ${params.amount} of ${params.asset} to Venus`,
+          to: vtoken,
           data,
           value: 0n,
-          gas_estimate: 3e5
+          gas_estimate: 3e5,
+          approvals: [{ token: params.asset, spender: vtoken, amount: params.amount }]
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData16({
-          abi: CTOKEN_ABI,
-          functionName: "redeem",
-          args: [params.amount]
-        });
+        const vtoken = await this.vtokenFor(params.asset);
+        const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "redeemUnderlying", args: [params.amount] });
         return {
-          description: `[${this.protocolName}] Withdraw from Venus`,
-          to: this.defaultVtoken,
+          description: `[${this.protocolName}] Withdraw ${params.amount} of ${params.asset} from Venus`,
+          to: vtoken,
           data,
           value: 0n,
           gas_estimate: 25e4
@@ -7361,24 +7500,69 @@ var Executor = class _Executor {
 `);
     if (approveTxUrl) process.stderr.write(`  Explorer: ${approveTxUrl}
 `);
-    await publicClient.waitForTransactionReceipt({ hash: approveTxHash });
+    const approveReceipt = await _Executor.waitForReceiptWithRetry(publicClient, approveTxHash);
+    if (approveReceipt.status !== "success") {
+      throw new Error(`Approve tx ${approveTxHash} reverted on-chain (status=${approveReceipt.status}). Aborting downstream tx.`);
+    }
     process.stderr.write(
       `  Approved ${amount} of ${token} for ${spender}
 `
     );
   }
-  /** Fetch EIP-1559 fee params from the network. Returns [maxFeePerGas, maxPriorityFeePerGas]. */
+  /**
+   * Wait for a tx receipt with bounded retries. Some L2 RPCs (notably Mantle)
+   * occasionally fail to surface a receipt even after the tx is mined; viem's
+   * default `waitForTransactionReceipt` errors out instead of polling longer.
+   * We retry up to `attempts` times with exponential backoff before giving up.
+   */
+  static async waitForReceiptWithRetry(client, hash, attempts = 6) {
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await client.waitForTransactionReceipt({
+          hash,
+          timeout: 6e4,
+          retryCount: 8
+        });
+      } catch (e) {
+        lastErr = e;
+        const backoffMs = Math.min(2e3 * Math.pow(2, i), 6e4);
+        await new Promise((resolve2) => setTimeout(resolve2, backoffMs));
+      }
+    }
+    throw new Error(`waitForReceiptWithRetry: gave up after ${attempts} attempts. Last error: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
+  }
+  /**
+   * Fetch EIP-1559 fee params. Returns [maxFeePerGas, maxPriorityFeePerGas].
+   *
+   * Strategy: read the latest block's `baseFeePerGas` and use the canonical
+   * EIP-1559 formula `maxFee = baseFee * 2 + priorityFee` (1 block of head-room
+   * after a 12.5% bump). Falls back to `getGasPrice() + priorityFee` only when
+   * the chain doesn't expose `baseFeePerGas` (pre-1559).
+   *
+   * Why not gasPrice * 2: `getGasPrice()` returns `baseFee + priorityFee`, so
+   * doubling double-counts the priority component and produces nonsense on
+   * chains where baseFee is already high (e.g., Mantle 50 gwei → 100 gwei,
+   * which can drain MNT before the actual tx settles).
+   */
   async fetchEip1559Fees(rpcUrl) {
     try {
       const client = createPublicClient23({ transport: http23(rpcUrl) });
-      const gasPrice = await client.getGasPrice();
       let priorityFee = DEFAULT_PRIORITY_FEE_WEI;
       try {
         priorityFee = await client.estimateMaxPriorityFeePerGas();
       } catch {
       }
-      const maxFee = gasPrice * 2n + priorityFee;
-      return [maxFee, priorityFee];
+      try {
+        const block = await client.getBlock({ blockTag: "latest" });
+        if (block.baseFeePerGas !== null && block.baseFeePerGas !== void 0) {
+          const maxFee = block.baseFeePerGas * 2n + priorityFee;
+          return [maxFee, priorityFee];
+        }
+      } catch {
+      }
+      const gasPrice = await client.getGasPrice();
+      return [gasPrice + priorityFee, priorityFee];
     } catch {
       return [0n, 0n];
     }
@@ -7542,8 +7726,8 @@ var Executor = class _Executor {
 `);
         if (preTxUrl) process.stderr.write(`  Explorer: ${preTxUrl}
 `);
-        const preReceipt = await publicClient.waitForTransactionReceipt({ hash: preTxHash });
-        if (preReceipt.status !== "success") {
+        const preReceiptResult = await _Executor.waitForReceiptWithRetry(publicClient, preTxHash);
+        if (preReceiptResult.status !== "success") {
           throw new DefiError("TX_FAILED", `Pre-transaction failed: ${preTx.description}`);
         }
         process.stderr.write(`  Pre-tx confirmed
@@ -7585,7 +7769,7 @@ var Executor = class _Executor {
     if (txUrl) process.stderr.write(`Explorer: ${txUrl}
 `);
     process.stderr.write("Waiting for confirmation...\n");
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    const receipt = await _Executor.waitForReceiptWithRetry(publicClient, txHash);
     const status = receipt.status === "success" ? TxStatus.Confirmed : TxStatus.Failed;
     let mintedTokenId;
     if (receipt.status === "success" && receipt.logs) {