@agether/sdk 2.16.0 → 2.17.1

package/dist/index.d.ts

@@ -244,10 +244,18 @@ declare class AgetherClient {
     /** Check whether the Safe account has been deployed. */
     accountExists(): Promise<boolean>;
     /**
-     * Get ETH, USDC, and collateral token balances for EOA and Safe account.
+     * 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.
+     */
+    private _discoverPositionTokens;
+    /**
+     * 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.
      */
     getBalances(): Promise<BalancesResult>;
     /**
@@ -561,6 +569,42 @@ interface PayFromYieldResult {
     remainingYield: string;
     remainingSupply: string;
 }
+/** Yield spread analysis result for a single market. */
+interface YieldSpreadResult {
+    collateralToken: string;
+    loanToken: string;
+    collateralYield: number;
+    borrowRate: number;
+    netSpread: number;
+    profitable: boolean;
+    lltv: number;
+    maxSafeLeverage: number;
+    leveragedNetApy: number;
+    liquidity: number;
+    marketId: string;
+}
+/** Single iteration in a leverage loop. */
+interface LeverageIteration {
+    iteration: number;
+    deposit: number;
+    borrow: number;
+    swapOutput: number;
+}
+/** Result of a leverage loop simulation. */
+interface LeverageResult {
+    strategy: string;
+    collateralToken: string;
+    loanToken: string;
+    initialDeposit: string;
+    targetLeverage: number;
+    achievedLeverage: number;
+    totalCollateral: number;
+    totalDebt: number;
+    iterations: LeverageIteration[];
+    estimatedNetApy: number;
+    healthFactor: number;
+    warning: string;
+}
 declare class MorphoClient {
     private _signer;
     private provider;
@@ -890,12 +934,48 @@ declare class MorphoClient {
      */
     repay(amount: string, tokenSymbol?: string, marketParams?: MorphoMarketParams, loanTokenSymbol?: string): Promise<RepayResult>;
     /**
-     * Withdraw collateral from Morpho Blue.
+     * 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.
+     */
+    private static readonly LST_PROJECT_MAP;
+    /** Cache for LST yields fetched from DeFi Llama. TTL: 30 minutes. */
+    private static _lstYieldCache;
+    private static readonly LST_CACHE_TTL;
+    /**
+     * Fetch native staking/restaking yields for all known LST/LRT tokens
+     * from the DeFi Llama Yields API. Results are cached for 30 minutes.
      *
-     * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
+     * @returns Map of token symbol → APY (e.g. { wstETH: 4.56, cbETH: 3.61 })
+     */
+    private _getLstYields;
+    /**
+     * Analyze yield spread between LST/LRT collateral yield and Morpho borrow rates.
+     * Positive spread = profitable carry trade (collateral earns more than debt costs).
      *
-     * @param receiver - defaults to EOA wallet
+     * @returns Array of markets with yield analysis, sorted by net spread descending.
      */
+    getYieldSpread(): Promise<YieldSpreadResult[]>;
+    /**
+     * Execute a leverage loop: deposit collateral → borrow → swap to collateral → deposit again.
+     * Repeats N times to achieve target leverage.
+     *
+     * 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 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)
+     */
+    leverageLoop(collateralToken: string, amount: string, targetLeverage: number, loanToken?: string, maxIterations?: number): Promise<LeverageResult>;
+    /**
+   * Withdraw collateral from Morpho Blue.
+   *
+   * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
+   *
+   * @param receiver - defaults to EOA wallet
+   */
     withdrawCollateral(tokenSymbol: string, amount: string, marketParams?: MorphoMarketParams, receiver?: string): Promise<WithdrawResult>;
     /**
      * Refresh the signer and re-bind contract instances.
@@ -1589,4 +1669,4 @@ interface RetryOptions {
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 
-export { ACCOUNT_FACTORY_ABI, AGENT_REPUTATION_ABI, AGETHER_4337_FACTORY_ABI, AGETHER_8004_SCORER_ABI, AGETHER_8004_VALIDATION_MODULE_ABI, AGETHER_HOOK_MULTIPLEXER_ABI, AgentIdentityClient, type AgentIdentityClientOptions, AgentNotApprovedError, AgetherClient, type AgetherClientOptions, type AgetherConfig, AgetherError, type AgetherSigner, type AgetherViemWallet, type BalancesResult, type BorrowResult, ChainId, type ContractAddresses, type DepositAndBorrowResult, type DepositResult, ENTRYPOINT_V07_ABI, ERC20_ABI, ERC8004_VALIDATION_MODULE_ABI, HOOK_MULTIPLEXER_ABI, IDENTITY_REGISTRY_ABI, InsufficientBalanceError, MORPHO_BLUE_ABI, type MarketFilter, MorphoClient, type MorphoClientConfig, type MorphoMarketInfo, type MorphoMarketParams, type MorphoPosition, type PayFromYieldResult, type PaymentRequirements, type PositionResult, type RegisterResult, type RepayResult, type RetryOptions, SAFE7579_ACCOUNT_ABI, SAFE_AGENT_FACTORY_ABI, type ScoreAttestation, type ScoreResult, ScoringClient, type ScoringClientConfig, ScoringRejectedError, type SpendingTracker, type StatusResult, type SupplyAssetResult, type SupplyPositionResult, type TransactionResult, VALIDATION_REGISTRY_ABI, type WithdrawFromAccountResult, type WithdrawResult, type WithdrawSupplyResult, X402Client, type X402Config, type X402PaymentRequest, type X402PaymentResult, type X402Response, bpsToRate, createConfig, formatAPR, formatAddress, formatHealthFactor, formatPercent, formatTimestamp, formatUSD, formatUnits, getContractAddresses, getDefaultConfig, getMorphoBlueAddress, getUSDCAddress, parseUnits, rateToBps, withRetry };
+export { ACCOUNT_FACTORY_ABI, AGENT_REPUTATION_ABI, AGETHER_4337_FACTORY_ABI, AGETHER_8004_SCORER_ABI, AGETHER_8004_VALIDATION_MODULE_ABI, AGETHER_HOOK_MULTIPLEXER_ABI, AgentIdentityClient, type AgentIdentityClientOptions, AgentNotApprovedError, AgetherClient, type AgetherClientOptions, type AgetherConfig, AgetherError, type AgetherSigner, type AgetherViemWallet, type BalancesResult, type BorrowResult, ChainId, type ContractAddresses, type DepositAndBorrowResult, type DepositResult, ENTRYPOINT_V07_ABI, ERC20_ABI, ERC8004_VALIDATION_MODULE_ABI, HOOK_MULTIPLEXER_ABI, IDENTITY_REGISTRY_ABI, InsufficientBalanceError, type LeverageIteration, type LeverageResult, MORPHO_BLUE_ABI, type MarketFilter, MorphoClient, type MorphoClientConfig, type MorphoMarketInfo, type MorphoMarketParams, type MorphoPosition, type PayFromYieldResult, type PaymentRequirements, type PositionResult, type RegisterResult, type RepayResult, type RetryOptions, SAFE7579_ACCOUNT_ABI, SAFE_AGENT_FACTORY_ABI, type ScoreAttestation, type ScoreResult, ScoringClient, type ScoringClientConfig, ScoringRejectedError, type SpendingTracker, type StatusResult, type SupplyAssetResult, type SupplyPositionResult, type TransactionResult, VALIDATION_REGISTRY_ABI, type WithdrawFromAccountResult, type WithdrawResult, type WithdrawSupplyResult, X402Client, type X402Config, type X402PaymentRequest, type X402PaymentResult, type X402Response, type YieldSpreadResult, bpsToRate, createConfig, formatAPR, formatAddress, formatHealthFactor, formatPercent, formatTimestamp, formatUSD, formatUnits, getContractAddresses, getDefaultConfig, getMorphoBlueAddress, getUSDCAddress, parseUnits, rateToBps, withRetry };

package/dist/index.js

@@ -619,13 +619,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;
@@ -633,7 +684,18 @@ var AgetherClient = class _AgetherClient {
     const usdc = new import_ethers.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 {
@@ -1253,7 +1315,7 @@ var MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
 var morphoIface = new import_ethers2.ethers.Interface(MORPHO_BLUE_ABI);
 var erc20Iface2 = new import_ethers2.ethers.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();
@@ -2629,9 +2691,17 @@ var MorphoClient = class {
         const estimated = totalBorrowShares > 0n ? repayShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
         approveAmount = estimated > 0n ? estimated : import_ethers2.ethers.parseUnits("1", loanDecimals);
       } else {
-        repayAssets = import_ethers2.ethers.parseUnits("999999", loanDecimals);
-        repayShares = 0n;
-        approveAmount = repayAssets;
+        const marketId = import_ethers2.ethers.keccak256(import_ethers2.ethers.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 : import_ethers2.ethers.parseUnits("1", loanDecimals);
       }
     } else {
       repayAssets = import_ethers2.ethers.parseUnits(amount, loanDecimals);
@@ -2640,20 +2710,32 @@ var MorphoClient = class {
     }
     const loanContract = new import_ethers2.Contract(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 ${import_ethers2.ethers.formatUnits(approveAmount, loanDecimals)}, AgentAccount has ${import_ethers2.ethers.formatUnits(acctBalance, loanDecimals)}, EOA has ${import_ethers2.ethers.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 ~${import_ethers2.ethers.formatUnits(checkAmount, loanDecimals)}, AgentAccount has ${import_ethers2.ethers.formatUnits(acctBalance, loanDecimals)}, EOA has ${import_ethers2.ethers.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];
@@ -2670,20 +2752,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 = import_ethers2.ethers.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);
@@ -3205,6 +3487,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
 var import_axios3 = __toESM(require("axios"));