@agether/sdk 2.16.0 → 2.17.1

package/dist/index.mjs

@@ -543,13 +543,64 @@ var AgetherClient = class _AgetherClient {
     return this.agether4337Factory.accountExists(id);
   }
   // ════════════════════════════════════════════════════════
+  //  Token Discovery (for dynamic balance queries)
+  // ════════════════════════════════════════════════════════
+  /**
+   * Discover token addresses from active Morpho Blue positions.
+   * Queries the Morpho GraphQL API for markets involving this agent's account,
+   * then extracts collateral and loan token info.
+   */
+  async _discoverPositionTokens() {
+    const tokens = {};
+    try {
+      const acctAddr = await this.getAccountAddress();
+      const chainId = this.config.chainId;
+      const query = `{
+        marketPositions(
+          where: { userAddress_in: ["${acctAddr.toLowerCase()}"], chainId_in: [${chainId}] }
+          first: 20
+        ) {
+          items {
+            market {
+              collateralAsset { address symbol decimals }
+              loanAsset { address symbol decimals }
+            }
+          }
+        }
+      }`;
+      const resp = await fetch("https://blue-api.morpho.org/graphql", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!resp.ok) return tokens;
+      const data = await resp.json();
+      const items = data?.data?.marketPositions?.items ?? [];
+      for (const item of items) {
+        const col = item?.market?.collateralAsset;
+        const loan = item?.market?.loanAsset;
+        if (col?.symbol && col?.address) {
+          tokens[col.symbol] = { address: col.address, symbol: col.symbol, decimals: col.decimals ?? 18 };
+        }
+        if (loan?.symbol && loan?.address) {
+          tokens[loan.symbol] = { address: loan.address, symbol: loan.symbol, decimals: loan.decimals ?? 18 };
+        }
+      }
+    } catch {
+    }
+    return tokens;
+  }
+  // ════════════════════════════════════════════════════════
   //  Balances
   // ════════════════════════════════════════════════════════
   /**
-   * Get ETH, USDC, and collateral token balances for EOA and Safe account.
+   * Get ETH, USDC, and all token balances for EOA and Safe account.
    *
-   * Collateral tokens are resolved from a built-in registry of well-known
-   * tokens per chain (WETH, wstETH, cbETH).
+   * Tokens are resolved from:
+   * 1. Built-in registry of well-known tokens (WETH, wstETH, cbETH)
+   * 2. Dynamic discovery from active Morpho positions (loan + collateral tokens)
+   * This ensures tokens like LCAP or any new Morpho market tokens appear in balances.
    */
   async getBalances() {
     const provider = this.signer.provider;
@@ -557,7 +608,18 @@ var AgetherClient = class _AgetherClient {
     const usdc = new Contract(this.config.contracts.usdc, ERC20_ABI, provider);
     const ethBal = await provider.getBalance(eoaAddr);
     const usdcBal = await usdc.balanceOf(eoaAddr);
-    const knownTokens = KNOWN_TOKENS[this.config.chainId] ?? {};
+    const knownTokens = {
+      ...KNOWN_TOKENS[this.config.chainId] ?? {}
+    };
+    try {
+      const positions = await this._discoverPositionTokens();
+      for (const [symbol, info] of Object.entries(positions)) {
+        if (!knownTokens[symbol]) {
+          knownTokens[symbol] = info;
+        }
+      }
+    } catch {
+    }
     const eoaCollateral = {};
     for (const [symbol, info] of Object.entries(knownTokens)) {
       try {
@@ -1177,7 +1239,7 @@ var MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
 var morphoIface = new ethers2.Interface(MORPHO_BLUE_ABI);
 var erc20Iface2 = new ethers2.Interface(ERC20_ABI);
-var MorphoClient = class {
+var _MorphoClient = class _MorphoClient {
   constructor(config) {
     /** Market params cache: keyed by market uniqueKey (bytes32 hash) */
     this._marketCache = /* @__PURE__ */ new Map();
@@ -2553,9 +2615,17 @@ var MorphoClient = class {
         const estimated = totalBorrowShares > 0n ? repayShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
         approveAmount = estimated > 0n ? estimated : ethers2.parseUnits("1", loanDecimals);
       } else {
-        repayAssets = ethers2.parseUnits("999999", loanDecimals);
-        repayShares = 0n;
-        approveAmount = repayAssets;
+        const marketId = ethers2.keccak256(ethers2.AbiCoder.defaultAbiCoder().encode(
+          ["address", "address", "address", "address", "uint256"],
+          [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]
+        ));
+        const pos = await this.morphoBlue.position(marketId, acctAddr);
+        repayShares = BigInt(pos.borrowShares);
+        repayAssets = 0n;
+        const onChainMkt = await this.morphoBlue.market(marketId);
+        const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+        const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+        approveAmount = totalBorrowShares > 0n ? repayShares * totalBorrowAssets / totalBorrowShares + 10n : ethers2.parseUnits("1", loanDecimals);
       }
     } else {
       repayAssets = ethers2.parseUnits(amount, loanDecimals);
@@ -2564,20 +2634,32 @@ var MorphoClient = class {
     }
     const loanContract = new Contract2(loanTokenAddr, ERC20_ABI, this._signer);
     const acctBalance = await loanContract.balanceOf(acctAddr);
-    if (acctBalance < approveAmount) {
-      const shortfall = approveAmount - acctBalance;
+    const checkAmount = repayShares > 0n && repayAssets === 0n ? approveAmount * 1005n / 1000n : approveAmount;
+    if (acctBalance < checkAmount) {
+      const shortfall = checkAmount - acctBalance;
       const eoaBalance = await loanContract.balanceOf(await this.getSignerAddress());
       if (eoaBalance < shortfall) {
-        const loanInfo = this._tokenCache.get(loanTokenAddr.toLowerCase());
-        const loanSymbol = loanInfo?.symbol ?? "loan token";
-        throw new AgetherError(
-          `Insufficient ${loanSymbol} for repay. Need ${ethers2.formatUnits(approveAmount, loanDecimals)}, AgentAccount has ${ethers2.formatUnits(acctBalance, loanDecimals)}, EOA has ${ethers2.formatUnits(eoaBalance, loanDecimals)}.`,
-          "INSUFFICIENT_BALANCE"
-        );
+        if (repayShares > 0n && acctBalance + eoaBalance > 0n) {
+          if (eoaBalance > 0n) {
+            const transferTx = await loanContract.transfer(acctAddr, eoaBalance);
+            await transferTx.wait();
+            this._refreshSigner();
+          }
+          const newBalance = await loanContract.balanceOf(acctAddr);
+          approveAmount = newBalance;
+        } else {
+          const loanInfo = this._tokenCache.get(loanTokenAddr.toLowerCase());
+          const loanSymbol = loanInfo?.symbol ?? "loan token";
+          throw new AgetherError(
+            `Insufficient ${loanSymbol} for repay. Need ~${ethers2.formatUnits(checkAmount, loanDecimals)}, AgentAccount has ${ethers2.formatUnits(acctBalance, loanDecimals)}, EOA has ${ethers2.formatUnits(eoaBalance, loanDecimals)}.`,
+            "INSUFFICIENT_BALANCE"
+          );
+        }
+      } else {
+        const transferTx = await loanContract.transfer(acctAddr, shortfall);
+        await transferTx.wait();
+        this._refreshSigner();
       }
-      const transferTx = await loanContract.transfer(acctAddr, shortfall);
-      await transferTx.wait();
-      this._refreshSigner();
     }
     const targets = [loanTokenAddr, morphoAddr];
     const values = [0n, 0n];
@@ -2594,20 +2676,220 @@ var MorphoClient = class {
     const receipt = await this.batch(targets, values, datas);
     let remainingDebt = "0";
     try {
-      const status = await this.getStatus();
-      remainingDebt = status.totalDebt;
+      const markets = await this.getMarkets(true);
+      const mkt = markets.find(
+        (m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase() && m.loanAsset?.address.toLowerCase() === params.loanToken.toLowerCase()
+      );
+      if (mkt) {
+        const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
+        const shares = BigInt(pos.borrowShares);
+        if (shares > 0n) {
+          const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
+          const totalAssets = BigInt(onChainMkt.totalBorrowAssets);
+          const totalShares = BigInt(onChainMkt.totalBorrowShares);
+          const debtWei = totalShares > 0n ? shares * totalAssets / totalShares : 0n;
+          remainingDebt = ethers2.formatUnits(debtWei, loanDecimals);
+        }
+      }
     } catch (e) {
       console.warn("[agether] failed to read remaining debt after repay:", e instanceof Error ? e.message : e);
     }
     return { tx: receipt.hash, amount, remainingDebt };
   }
+  // 30 min
+  /**
+   * Fetch native staking/restaking yields for all known LST/LRT tokens
+   * from the DeFi Llama Yields API. Results are cached for 30 minutes.
+   *
+   * @returns Map of token symbol → APY (e.g. { wstETH: 4.56, cbETH: 3.61 })
+   */
+  async _getLstYields() {
+    if (_MorphoClient._lstYieldCache && Date.now() - _MorphoClient._lstYieldCache.ts < _MorphoClient.LST_CACHE_TTL) {
+      return _MorphoClient._lstYieldCache.data;
+    }
+    const yields = {};
+    try {
+      const resp = await fetch("https://yields.llama.fi/pools", {
+        headers: { "User-Agent": "agether-sdk/1.0" },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!resp.ok) {
+        console.warn("[agether] DeFi Llama API returned", resp.status);
+        return yields;
+      }
+      const data = await resp.json();
+      const pools = data?.data ?? [];
+      for (const [morphoSymbol, mapping] of Object.entries(_MorphoClient.LST_PROJECT_MAP)) {
+        const matchingPools = pools.filter(
+          (p) => p.project === mapping.project && p.symbol?.toUpperCase() === mapping.symbol && ["Ethereum", "Base"].includes(p.chain)
+        );
+        if (matchingPools.length > 0) {
+          const best = matchingPools.reduce(
+            (a, b) => (b.tvlUsd ?? 0) > (a.tvlUsd ?? 0) ? b : a
+          );
+          if (best.apy !== void 0 && best.apy > 0) {
+            yields[morphoSymbol] = parseFloat(best.apy.toFixed(4));
+          }
+        }
+      }
+      const knownProjects = new Set(Object.values(_MorphoClient.LST_PROJECT_MAP).map((m) => m.project));
+      const stakingProjects = pools.filter(
+        (p) => p.symbol?.match(/^(ST|WST|CB|R|WE|EZ|RS|SW|M|OS|SFR|O|W?B)ETH$/i) && !knownProjects.has(p.project) && p.tvlUsd > 1e7 && p.apy > 0.5 && ["Ethereum", "Base"].includes(p.chain)
+      );
+      for (const p of stakingProjects) {
+        const sym = p.symbol;
+        if (!yields[sym]) {
+          yields[sym] = parseFloat(p.apy.toFixed(4));
+        }
+      }
+    } catch (e) {
+      console.warn("[agether] Failed to fetch LST yields:", e instanceof Error ? e.message : e);
+    }
+    _MorphoClient._lstYieldCache = { data: yields, ts: Date.now() };
+    return yields;
+  }
+  /**
+   * Analyze yield spread between LST/LRT collateral yield and Morpho borrow rates.
+   * Positive spread = profitable carry trade (collateral earns more than debt costs).
+   *
+   * @returns Array of markets with yield analysis, sorted by net spread descending.
+   */
+  async getYieldSpread() {
+    const lstYields = await this._getLstYields();
+    if (Object.keys(lstYields).length === 0) {
+      console.warn("[agether] No LST yield data available \u2014 DeFi Llama may be unreachable");
+      return [];
+    }
+    const lstTokens = Object.keys(lstYields);
+    const allMarkets = [];
+    for (const token of lstTokens) {
+      try {
+        const markets2 = await this.getMarketRates(token);
+        allMarkets.push(...markets2);
+      } catch {
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const markets = allMarkets.filter((m) => {
+      if (seen.has(m.marketId)) return false;
+      seen.add(m.marketId);
+      return true;
+    });
+    const results = [];
+    for (const mkt of markets) {
+      const collateralYield = lstYields[mkt.collateralToken];
+      if (collateralYield === void 0) continue;
+      const borrowRate = mkt.borrowApy;
+      const netSpread = collateralYield - borrowRate;
+      const lltv = parseFloat(mkt.lltv) / 100;
+      const safeLtv = lltv * 0.8;
+      const maxLeverage = 1 / (1 - safeLtv);
+      const leveragedNetApy = collateralYield * maxLeverage - borrowRate * (maxLeverage - 1);
+      results.push({
+        collateralToken: mkt.collateralToken,
+        loanToken: mkt.loanToken,
+        collateralYield,
+        borrowRate,
+        netSpread,
+        profitable: netSpread > 0,
+        lltv,
+        maxSafeLeverage: parseFloat(maxLeverage.toFixed(2)),
+        leveragedNetApy: parseFloat(leveragedNetApy.toFixed(2)),
+        liquidity: mkt.totalSupplyUsd - mkt.totalBorrowUsd,
+        marketId: mkt.marketId
+      });
+    }
+    return results.sort((a, b) => b.netSpread - a.netSpread);
+  }
   /**
-   * Withdraw collateral from Morpho Blue.
+   * Execute a leverage loop: deposit collateral → borrow → swap to collateral → deposit again.
+   * Repeats N times to achieve target leverage.
    *
-   * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
+   * Example: 1 wstETH at 3x leverage = deposit 1 → borrow → swap to ~0.77 wstETH → deposit →
+   * borrow → swap to ~0.6 wstETH → deposit. Total exposure: ~2.37 wstETH, debt: ~1.37 ETH worth.
    *
-   * @param receiver - defaults to EOA wallet
+   * @param collateralToken - LST token to deposit (e.g. 'wstETH')
+   * @param amount - Initial deposit amount
+   * @param targetLeverage - Target leverage multiplier (e.g. 2.0 for 2x)
+   * @param loanToken - Token to borrow (default: inferred from market)
+   * @param maxIterations - Max loop iterations (default: 5, safety cap)
    */
+  async leverageLoop(collateralToken, amount, targetLeverage, loanToken, maxIterations = 5) {
+    if (targetLeverage < 1.1 || targetLeverage > 10) {
+      throw new AgetherError(
+        "Target leverage must be between 1.1x and 10x",
+        "INVALID_LEVERAGE"
+      );
+    }
+    const spreads = await this.getYieldSpread();
+    const matchingMarket = spreads.find(
+      (s) => s.collateralToken.toLowerCase() === collateralToken.toLowerCase() && (!loanToken || s.loanToken.toLowerCase() === loanToken.toLowerCase())
+    );
+    if (!matchingMarket) {
+      throw new AgetherError(
+        `No LST market found for ${collateralToken}`,
+        "MARKET_NOT_FOUND"
+      );
+    }
+    if (!matchingMarket) {
+      throw new AgetherError(
+        `No yield data available for ${collateralToken}. Ensure DeFi Llama API is reachable.`,
+        "NO_YIELD_DATA"
+      );
+    }
+    if (targetLeverage > matchingMarket.maxSafeLeverage) {
+      throw new AgetherError(
+        `Target leverage ${targetLeverage}x exceeds max safe leverage ${matchingMarket.maxSafeLeverage}x for ${collateralToken}. Max LLTV is ${(matchingMarket.lltv * 100).toFixed(0)}%.`,
+        "LEVERAGE_TOO_HIGH"
+      );
+    }
+    const initialAmount = parseFloat(amount);
+    const iterations = [];
+    let totalCollateral = initialAmount;
+    let totalDebt = 0;
+    let currentAmount = initialAmount;
+    for (let i = 0; i < maxIterations; i++) {
+      const currentLeverage = totalDebt > 0 ? totalCollateral / (totalCollateral - totalDebt) : 1;
+      if (currentLeverage >= targetLeverage * 0.98) break;
+      const borrowAmount = currentAmount * matchingMarket.lltv * 0.8;
+      const swapOutput = borrowAmount * 0.997;
+      iterations.push({
+        iteration: i + 1,
+        deposit: currentAmount,
+        borrow: borrowAmount,
+        swapOutput
+      });
+      totalDebt += borrowAmount;
+      totalCollateral += swapOutput;
+      currentAmount = swapOutput;
+    }
+    const finalLeverage = totalDebt > 0 ? totalCollateral / (totalCollateral - totalDebt) : 1;
+    return {
+      strategy: "leverage_loop",
+      collateralToken: matchingMarket.collateralToken,
+      loanToken: matchingMarket.loanToken,
+      initialDeposit: amount,
+      targetLeverage,
+      achievedLeverage: parseFloat(finalLeverage.toFixed(2)),
+      totalCollateral: parseFloat(totalCollateral.toFixed(6)),
+      totalDebt: parseFloat(totalDebt.toFixed(6)),
+      iterations,
+      estimatedNetApy: parseFloat(
+        (matchingMarket.collateralYield * finalLeverage - matchingMarket.borrowRate * (finalLeverage - 1)).toFixed(2)
+      ),
+      healthFactor: parseFloat(
+        (totalCollateral * matchingMarket.lltv / totalDebt).toFixed(2)
+      ),
+      warning: "This is a simulation. Actual execution requires DEX swap integration. Real results may differ due to slippage and price movements."
+    };
+  }
+  /**
+  * Withdraw collateral from Morpho Blue.
+  *
+  * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
+  *
+  * @param receiver - defaults to EOA wallet
+  */
   async withdrawCollateral(tokenSymbol, amount, marketParams, receiver) {
     const acctAddr = await this.getAccountAddress();
     const colInfo = await this._resolveToken(tokenSymbol);
@@ -3129,6 +3411,31 @@ var MorphoClient = class {
     return result;
   }
 };
+// ════════════════════════════════════════════════════════
+//  Yield Spread Analysis & Leverage
+// ════════════════════════════════════════════════════════
+/**
+ * Mapping from Morpho collateral token symbols to DeFi Llama project IDs.
+ * Used to look up native staking/restaking yields from the DeFi Llama Yields API.
+ */
+_MorphoClient.LST_PROJECT_MAP = {
+  "wstETH": { project: "lido", symbol: "STETH" },
+  "cbETH": { project: "coinbase-wrapped-staked-eth", symbol: "CBETH" },
+  "rETH": { project: "rocket-pool", symbol: "RETH" },
+  "weETH": { project: "ether.fi-stake", symbol: "WEETH" },
+  "ezETH": { project: "renzo", symbol: "EZETH" },
+  "rsETH": { project: "kelp", symbol: "RSETH" },
+  "swETH": { project: "swell-liquid-staking", symbol: "SWETH" },
+  "mETH": { project: "meth-protocol", symbol: "METH" },
+  "sfrxETH": { project: "frax-ether", symbol: "SFRXETH" },
+  "oETH": { project: "origin-ether", symbol: "OETH" },
+  "ETHx": { project: "stader", symbol: "ETHX" },
+  "wBETH": { project: "binance-staked-eth", symbol: "WBETH" }
+};
+/** Cache for LST yields fetched from DeFi Llama. TTL: 30 minutes. */
+_MorphoClient._lstYieldCache = null;
+_MorphoClient.LST_CACHE_TTL = 30 * 60 * 1e3;
+var MorphoClient = _MorphoClient;
 
 // src/clients/ScoringClient.ts
 import axios3 from "axios";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/sdk",
-  "version": "2.16.0",
+  "version": "2.17.1",
   "description": "TypeScript SDK for Agether - autonomous credit for AI agents on Ethereum & Base",
   "main": "dist/index.js",
   "module": "dist/index.mjs",