@agether/sdk 2.3.4 → 2.4.0

package/dist/index.js

@@ -1119,7 +1119,259 @@ var MorphoClient = class {
     };
   }
   // ════════════════════════════════════════════════════════
-  //  Lending Operations (all via AgentAccount.executeBatch)
+  //  Supply-Side (Lending) — earn yield by supplying USDC
+  // ════════════════════════════════════════════════════════
+  /**
+   * Supply USDC to a Morpho Blue market as a lender (earn yield).
+   *
+   * Unlike `supplyCollateral` (borrower-side), this is the **lender-side**:
+   * you deposit the loanToken (USDC) into the market's supply pool and earn
+   * interest paid by borrowers.
+   *
+   * @param usdcAmount - Amount of USDC to supply (e.g. '500')
+   * @param collateralSymbol - Market collateral token to identify which market (e.g. 'WETH')
+   *                           Optional — defaults to highest-APY market
+   */
+  async supplyAsset(usdcAmount, collateralSymbol) {
+    const acctAddr = await this.getAccountAddress();
+    const amount = import_ethers2.ethers.parseUnits(usdcAmount, 6);
+    const morphoAddr = this.config.contracts.morphoBlue;
+    const usdcAddr = this.config.contracts.usdc;
+    let params;
+    let usedCollateral;
+    if (collateralSymbol) {
+      params = await this.findMarketForCollateral(collateralSymbol);
+      usedCollateral = collateralSymbol;
+    } else {
+      const rates = await this.getMarketRates();
+      if (rates.length === 0) throw new AgetherError("No markets available", "NO_MARKETS");
+      const best = rates.reduce((a, b) => a.supplyApy > b.supplyApy ? a : b);
+      params = await this.findMarketForCollateral(best.collateralToken);
+      usedCollateral = best.collateralToken;
+    }
+    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 usdcContract = new import_ethers2.Contract(usdcAddr, ERC20_ABI, this._signer);
+    const acctBalance = await usdcContract.balanceOf(acctAddr);
+    if (acctBalance < amount) {
+      const shortfall = amount - acctBalance;
+      const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
+      if (eoaBalance < shortfall) {
+        throw new AgetherError(
+          `Insufficient USDC. Need ${usdcAmount}, AgentAccount has ${import_ethers2.ethers.formatUnits(acctBalance, 6)}, EOA has ${import_ethers2.ethers.formatUnits(eoaBalance, 6)}.`,
+          "INSUFFICIENT_BALANCE"
+        );
+      }
+      const transferTx = await usdcContract.transfer(acctAddr, shortfall);
+      await transferTx.wait();
+      this._refreshSigner();
+    }
+    const targets = [usdcAddr, morphoAddr];
+    const values = [0n, 0n];
+    const datas = [
+      erc20Iface.encodeFunctionData("approve", [morphoAddr, amount]),
+      morphoIface.encodeFunctionData("supply", [
+        this._toTuple(params),
+        amount,
+        0n,
+        acctAddr,
+        "0x"
+      ])
+    ];
+    const receipt = await this.batch(targets, values, datas);
+    return {
+      tx: receipt.hash,
+      amount: usdcAmount,
+      marketId,
+      collateralToken: usedCollateral,
+      agentAccount: acctAddr
+    };
+  }
+  /**
+   * Withdraw supplied USDC (+ earned interest) from a Morpho Blue market.
+   *
+   * @param usdcAmount - Amount to withdraw (e.g. '100' or 'all' for full position)
+   * @param collateralSymbol - Market collateral to identify which market
+   * @param receiver - Destination address (defaults to EOA)
+   */
+  async withdrawSupply(usdcAmount, collateralSymbol, receiver) {
+    const acctAddr = await this.getAccountAddress();
+    const morphoAddr = this.config.contracts.morphoBlue;
+    const dest = receiver || await this.getSignerAddress();
+    let params;
+    if (collateralSymbol) {
+      params = await this.findMarketForCollateral(collateralSymbol);
+    } else {
+      const { params: p } = await this._findActiveSupplyMarket();
+      params = p;
+    }
+    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]
+      )
+    );
+    let withdrawAssets;
+    let withdrawShares;
+    if (usdcAmount === "all") {
+      const pos = await this.morphoBlue.position(marketId, acctAddr);
+      withdrawShares = BigInt(pos.supplyShares);
+      withdrawAssets = 0n;
+      if (withdrawShares === 0n) throw new AgetherError("No supply position to withdraw", "NO_SUPPLY");
+    } else {
+      withdrawAssets = import_ethers2.ethers.parseUnits(usdcAmount, 6);
+      withdrawShares = 0n;
+    }
+    const data = morphoIface.encodeFunctionData("withdraw", [
+      this._toTuple(params),
+      withdrawAssets,
+      withdrawShares,
+      acctAddr,
+      dest
+    ]);
+    const receipt = await this.exec(morphoAddr, data);
+    let remainingSupply = "0";
+    try {
+      const pos = await this.morphoBlue.position(marketId, acctAddr);
+      const mkt = await this.morphoBlue.market(marketId);
+      const totalSupplyAssets = BigInt(mkt.totalSupplyAssets);
+      const totalSupplyShares = BigInt(mkt.totalSupplyShares);
+      const currentAssets = totalSupplyShares > 0n ? BigInt(pos.supplyShares) * totalSupplyAssets / totalSupplyShares : 0n;
+      remainingSupply = import_ethers2.ethers.formatUnits(currentAssets, 6);
+    } catch (e) {
+      console.warn("[agether] failed to read remaining supply:", e instanceof Error ? e.message : e);
+    }
+    return {
+      tx: receipt.hash,
+      amount: usdcAmount,
+      remainingSupply,
+      destination: dest
+    };
+  }
+  /**
+   * Get supply (lending) positions with yield tracking.
+   *
+   * Uses Morpho GraphQL API (no eth_getLogs / no DB / no indexer):
+   *   1. `userByAddress` → all market positions with current supplyAssets, supplyApy
+   *   2. `transactions` → all MarketSupply/MarketWithdraw history for net deposited
+   *   3. earnedYield = currentSupplyAssets − netDeposited
+   *
+   * @param collateralSymbol - Market collateral token (optional, returns all if omitted)
+   */
+  async getSupplyPositions(collateralSymbol) {
+    const acctAddr = (await this.getAccountAddress()).toLowerCase();
+    const chainId = this.config.chainId;
+    const positionsQuery = `{
+      userByAddress(address: "${acctAddr}", chainId: ${chainId}) {
+        marketPositions {
+          market {
+            uniqueKey
+            loanAsset { symbol address decimals }
+            collateralAsset { symbol address }
+            state { supplyApy }
+          }
+          state {
+            supplyShares
+            supplyAssets
+            supplyAssetsUsd
+          }
+        }
+      }
+    }`;
+    const posResp = await import_axios.default.post(MORPHO_API_URL, { query: positionsQuery }, { timeout: 15e3 });
+    const user = posResp.data?.data?.userByAddress;
+    if (!user?.marketPositions) return [];
+    const activePositions = user.marketPositions.filter(
+      (p) => p.state && BigInt(p.state.supplyShares ?? "0") > 0n
+    );
+    if (activePositions.length === 0) return [];
+    const filtered = collateralSymbol ? activePositions.filter((p) => {
+      const sym = p.market.collateralAsset?.symbol;
+      return sym && sym.toUpperCase() === collateralSymbol.toUpperCase();
+    }) : activePositions;
+    if (filtered.length === 0) return [];
+    const netDepositedMap = await this._computeNetDepositedAll(acctAddr, chainId);
+    const results = [];
+    for (const p of filtered) {
+      const currentAssets = BigInt(p.state.supplyAssets ?? "0");
+      const marketKey = p.market.uniqueKey.toLowerCase();
+      const netDeposited = netDepositedMap.get(marketKey) ?? 0n;
+      const earnedYield = currentAssets > netDeposited ? currentAssets - netDeposited : 0n;
+      results.push({
+        marketId: p.market.uniqueKey,
+        loanToken: p.market.loanAsset.symbol,
+        collateralToken: p.market.collateralAsset?.symbol ?? "none",
+        supplyShares: p.state.supplyShares,
+        suppliedAssets: import_ethers2.ethers.formatUnits(currentAssets, p.market.loanAsset.decimals),
+        netDeposited: import_ethers2.ethers.formatUnits(netDeposited, p.market.loanAsset.decimals),
+        earnedYield: import_ethers2.ethers.formatUnits(earnedYield, p.market.loanAsset.decimals),
+        supplyApy: p.market.state?.supplyApy ?? 0
+      });
+    }
+    return results;
+  }
+  /**
+   * Pay a recipient using ONLY earned yield from a supply position.
+   *
+   * Computes available yield, verifies the requested amount doesn't exceed it,
+   * then withdraws from the supply position and sends directly to the recipient.
+   *
+   * @param recipient - Address to receive the USDC
+   * @param usdcAmount - Amount to pay from yield (e.g. '5.50')
+   * @param collateralSymbol - Market collateral to identify which supply position
+   */
+  async payFromYield(recipient, usdcAmount, collateralSymbol) {
+    const acctAddr = await this.getAccountAddress();
+    const morphoAddr = this.config.contracts.morphoBlue;
+    const amount = import_ethers2.ethers.parseUnits(usdcAmount, 6);
+    const positions = await this.getSupplyPositions(collateralSymbol);
+    if (positions.length === 0) {
+      throw new AgetherError("No supply position found", "NO_SUPPLY");
+    }
+    const pos = positions.reduce(
+      (a, b) => parseFloat(a.earnedYield) > parseFloat(b.earnedYield) ? a : b
+    );
+    const availableYield = import_ethers2.ethers.parseUnits(pos.earnedYield, 6);
+    if (amount > availableYield) {
+      throw new AgetherError(
+        `Requested ${usdcAmount} USDC exceeds available yield of ${pos.earnedYield} USDC. Use withdrawSupply to withdraw principal.`,
+        "EXCEEDS_YIELD"
+      );
+    }
+    const params = await this.findMarketForCollateral(pos.collateralToken);
+    const data = morphoIface.encodeFunctionData("withdraw", [
+      this._toTuple(params),
+      amount,
+      0n,
+      acctAddr,
+      recipient
+    ]);
+    const receipt = await this.exec(morphoAddr, data);
+    let remainingYield = "0";
+    let remainingSupply = "0";
+    try {
+      const updatedPositions = await this.getSupplyPositions(pos.collateralToken);
+      if (updatedPositions.length > 0) {
+        remainingYield = updatedPositions[0].earnedYield;
+        remainingSupply = updatedPositions[0].suppliedAssets;
+      }
+    } catch (e) {
+      console.warn("[agether] failed to read remaining yield:", e instanceof Error ? e.message : e);
+    }
+    return {
+      tx: receipt.hash,
+      yieldWithdrawn: usdcAmount,
+      recipient,
+      remainingYield,
+      remainingSupply
+    };
+  }
+  // ════════════════════════════════════════════════════════
+  //  Collateral & Borrowing Operations (all via AgentAccount)
   // ════════════════════════════════════════════════════════
   /**
    * Deposit collateral into Morpho Blue.
@@ -1750,6 +2002,94 @@ var MorphoClient = class {
     const params = await this.findMarketForCollateral("WETH");
     return { params, symbol: "WETH" };
   }
+  /** Find the first market where the agent has a supply (lending) position. */
+  async _findActiveSupplyMarket() {
+    const acctAddr = await this.getAccountAddress();
+    const markets = await this.getMarkets();
+    for (const m of markets) {
+      if (!m.collateralAsset || m.collateralAsset.address === import_ethers2.ethers.ZeroAddress) continue;
+      try {
+        const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
+        if (BigInt(pos.supplyShares) > 0n) {
+          return {
+            params: {
+              loanToken: m.loanAsset.address,
+              collateralToken: m.collateralAsset.address,
+              oracle: m.oracle,
+              irm: m.irm,
+              lltv: m.lltv
+            },
+            symbol: m.collateralAsset.symbol
+          };
+        }
+      } catch (e) {
+        console.warn("[agether] _findActiveSupplyMarket position check failed:", e instanceof Error ? e.message : e);
+        continue;
+      }
+    }
+    throw new AgetherError("No active supply position found", "NO_SUPPLY");
+  }
+  /**
+   * Compute net deposited amounts per market using Morpho GraphQL API.
+   *
+   * Fetches all MarketSupply and MarketWithdraw transactions for the account,
+   * then computes: netDeposited[marketId] = Σ Supply.assets − Σ Withdraw.assets
+   *
+   * Returns a Map<marketId (lowercase), bigint>.
+   *
+   * Uses pagination (100 per page) for completeness, though agent accounts
+   * typically have single-digit transaction counts.
+   */
+  async _computeNetDepositedAll(accountAddr, chainId) {
+    const result = /* @__PURE__ */ new Map();
+    let skip = 0;
+    const pageSize = 100;
+    let hasMore = true;
+    while (hasMore) {
+      const txQuery = `{
+        transactions(
+          first: ${pageSize}
+          skip: ${skip}
+          where: {
+            userAddress_in: ["${accountAddr}"]
+            type_in: [MarketSupply, MarketWithdraw]
+            chainId_in: [${chainId}]
+          }
+        ) {
+          pageInfo { count countTotal }
+          items {
+            type
+            data {
+              ... on MarketTransferTransactionData {
+                assets
+                market { uniqueKey }
+              }
+            }
+          }
+        }
+      }`;
+      const resp = await import_axios.default.post(MORPHO_API_URL, { query: txQuery }, { timeout: 15e3 });
+      const txData = resp.data?.data?.transactions;
+      if (!txData?.items) break;
+      for (const tx of txData.items) {
+        const marketKey = tx.data?.market?.uniqueKey?.toLowerCase();
+        if (!marketKey || !tx.data?.assets) continue;
+        const assets = BigInt(tx.data.assets);
+        const current = result.get(marketKey) ?? 0n;
+        if (tx.type === "MarketSupply") {
+          result.set(marketKey, current + assets);
+        } else if (tx.type === "MarketWithdraw") {
+          const newVal = current - assets;
+          result.set(marketKey, newVal > 0n ? newVal : 0n);
+        }
+      }
+      const fetched = skip + txData.items.length;
+      const total = txData.pageInfo?.countTotal ?? 0;
+      hasMore = fetched < total;
+      skip += pageSize;
+    }
+    return result;
+  }
 };
 
 // src/clients/ScoringClient.ts