@agether/sdk 2.3.4 → 2.5.0

package/dist/index.mjs

@@ -460,11 +460,6 @@ var AgetherClient = class _AgetherClient {
 // src/clients/MorphoClient.ts
 import { ethers as ethers2, Contract as Contract2 } from "ethers";
 import axios from "axios";
-var BASE_COLLATERALS = {
-  WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
-  wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
-  cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
-};
 var MORPHO_API_URL = "https://api.morpho.org/graphql";
 var MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
@@ -473,6 +468,8 @@ var erc20Iface = new ethers2.Interface(ERC20_ABI);
 var MorphoClient = class {
   constructor(config) {
     this._marketCache = /* @__PURE__ */ new Map();
+    /** Dynamic token registry: symbol (uppercase) → { address, symbol, decimals } */
+    this._tokenCache = /* @__PURE__ */ new Map();
     this._discoveredAt = 0;
     const chainId = config.chainId ?? 8453 /* Base */;
     const defaultCfg = getDefaultConfig(chainId);
@@ -659,15 +656,16 @@ var MorphoClient = class {
     const usdc = new Contract2(this.config.contracts.usdc, ERC20_ABI, this.provider);
     const ethBal = await this.provider.getBalance(eoaAddr);
     const usdcBal = await usdc.balanceOf(eoaAddr);
+    const discoveredTokens = await this._getDiscoveredTokens();
     const eoaCollateral = {};
-    for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
+    for (const info of discoveredTokens) {
       try {
         const token = new Contract2(info.address, ERC20_ABI, this.provider);
         const bal = await token.balanceOf(eoaAddr);
-        eoaCollateral[symbol] = ethers2.formatUnits(bal, info.decimals);
+        eoaCollateral[info.symbol] = ethers2.formatUnits(bal, info.decimals);
       } catch (e) {
-        console.warn(`[agether] EOA collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-        eoaCollateral[symbol] = "0";
+        console.warn(`[agether] EOA collateral fetch failed for ${info.symbol}:`, e instanceof Error ? e.message : e);
+        eoaCollateral[info.symbol] = "0";
       }
     }
     const result = {
@@ -682,14 +680,14 @@ var MorphoClient = class {
       const acctEth = await this.provider.getBalance(acctAddr);
       const acctUsdc = await usdc.balanceOf(acctAddr);
       const acctCollateral = {};
-      for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
+      for (const info of discoveredTokens) {
         try {
           const token = new Contract2(info.address, ERC20_ABI, this.provider);
           const bal = await token.balanceOf(acctAddr);
-          acctCollateral[symbol] = ethers2.formatUnits(bal, info.decimals);
+          acctCollateral[info.symbol] = ethers2.formatUnits(bal, info.decimals);
         } catch (e) {
-          console.warn(`[agether] AgentAccount collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-          acctCollateral[symbol] = "0";
+          console.warn(`[agether] AgentAccount collateral fetch failed for ${info.symbol}:`, e instanceof Error ? e.message : e);
+          acctCollateral[info.symbol] = "0";
         }
       }
       result.agentAccount = {
@@ -775,6 +773,28 @@ var MorphoClient = class {
             irm: mi.irm,
             lltv: mi.lltv
           });
+          this._tokenCache.set(mi.collateralAsset.symbol.toUpperCase(), {
+            address: mi.collateralAsset.address,
+            symbol: mi.collateralAsset.symbol,
+            decimals: mi.collateralAsset.decimals
+          });
+          this._tokenCache.set(mi.collateralAsset.address.toLowerCase(), {
+            address: mi.collateralAsset.address,
+            symbol: mi.collateralAsset.symbol,
+            decimals: mi.collateralAsset.decimals
+          });
+        }
+        if (mi.loanAsset.address !== ethers2.ZeroAddress) {
+          this._tokenCache.set(mi.loanAsset.symbol.toUpperCase(), {
+            address: mi.loanAsset.address,
+            symbol: mi.loanAsset.symbol,
+            decimals: mi.loanAsset.decimals
+          });
+          this._tokenCache.set(mi.loanAsset.address.toLowerCase(), {
+            address: mi.loanAsset.address,
+            symbol: mi.loanAsset.symbol,
+            decimals: mi.loanAsset.decimals
+          });
         }
       }
       return this._discoveredMarkets;
@@ -788,8 +808,17 @@ var MorphoClient = class {
    * Tries cache → API → onchain idToMarketParams.
    */
   async findMarketForCollateral(collateralSymbolOrAddress) {
-    const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-    const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+    let colAddr;
+    if (collateralSymbolOrAddress.startsWith("0x")) {
+      colAddr = collateralSymbolOrAddress.toLowerCase();
+    } else {
+      try {
+        const resolved = await this._resolveToken(collateralSymbolOrAddress);
+        colAddr = resolved.address.toLowerCase();
+      } catch {
+        colAddr = collateralSymbolOrAddress.toLowerCase();
+      }
+    }
     const cached = this._marketCache.get(colAddr);
     if (cached) return cached;
     await this.getMarkets();
@@ -948,8 +977,17 @@ var MorphoClient = class {
     const usdcAddr = this.config.contracts.usdc.toLowerCase();
     let collateralFilter = "";
     if (collateralSymbolOrAddress) {
-      const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-      const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+      let colAddr;
+      if (collateralSymbolOrAddress.startsWith("0x")) {
+        colAddr = collateralSymbolOrAddress.toLowerCase();
+      } else {
+        try {
+          const resolved = await this._resolveToken(collateralSymbolOrAddress);
+          colAddr = resolved.address.toLowerCase();
+        } catch {
+          colAddr = collateralSymbolOrAddress.toLowerCase();
+        }
+      }
       collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
     }
     const query = `{
@@ -1008,8 +1046,7 @@ var MorphoClient = class {
    * @returns Estimated yield in USD for the period
    */
   async getYieldEstimate(collateralSymbol, amount, periodDays = 1, ethPriceUsd) {
-    const colInfo = BASE_COLLATERALS[collateralSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${collateralSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(collateralSymbol);
     const rates = await this.getMarketRates(collateralSymbol);
     if (rates.length === 0) {
       throw new AgetherError(`No market found for ${collateralSymbol}`, "MARKET_NOT_FOUND");
@@ -1047,7 +1084,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 = ethers2.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 = ethers2.keccak256(
+      ethers2.AbiCoder.defaultAbiCoder().encode(
+        ["address", "address", "address", "address", "uint256"],
+        [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]
+      )
+    );
+    const usdcContract = new Contract2(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 ${ethers2.formatUnits(acctBalance, 6)}, EOA has ${ethers2.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 = ethers2.keccak256(
+      ethers2.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 = ethers2.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 = ethers2.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 axios.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: ethers2.formatUnits(currentAssets, p.market.loanAsset.decimals),
+        netDeposited: ethers2.formatUnits(netDeposited, p.market.loanAsset.decimals),
+        earnedYield: ethers2.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 = ethers2.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 = ethers2.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.
@@ -1059,8 +1348,7 @@ var MorphoClient = class {
    */
   async supplyCollateral(tokenSymbol, amount, marketParams) {
     const acctAddr = await this.getAccountAddress();
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const weiAmount = ethers2.parseUnits(amount, colInfo.decimals);
     const morphoAddr = this.config.contracts.morphoBlue;
@@ -1181,8 +1469,7 @@ var MorphoClient = class {
    */
   async depositAndBorrow(tokenSymbol, collateralAmount, borrowUsdcAmount, marketParams) {
     const acctAddr = await this.getAccountAddress();
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const colWei = ethers2.parseUnits(collateralAmount, colInfo.decimals);
     const borrowWei = ethers2.parseUnits(borrowUsdcAmount, 6);
@@ -1350,8 +1637,7 @@ var MorphoClient = class {
    */
   async withdrawCollateral(tokenSymbol, amount, marketParams, receiver) {
     const acctAddr = await this.getAccountAddress();
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const morphoAddr = this.config.contracts.morphoBlue;
     const usdcAddr = this.config.contracts.usdc;
@@ -1448,8 +1734,7 @@ var MorphoClient = class {
    * (The agent must then supplyCollateral themselves via their own account.)
    */
   async sponsor(target, tokenSymbol, amount) {
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     let targetAddr;
     if (target.address) {
       targetAddr = target.address;
@@ -1678,6 +1963,131 @@ 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 === ethers2.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");
+  }
+  /**
+   * Resolve a token symbol or address to { address, symbol, decimals }.
+   *
+   * Uses the dynamic `_tokenCache` populated by `getMarkets()` from the
+   * Morpho GraphQL API — no hardcoded token list needed.
+   *
+   * @param symbolOrAddress - e.g. 'WETH', 'wstETH', or '0x4200...'
+   */
+  async _resolveToken(symbolOrAddress) {
+    const key = symbolOrAddress.startsWith("0x") ? symbolOrAddress.toLowerCase() : symbolOrAddress.toUpperCase();
+    const cached = this._tokenCache.get(key);
+    if (cached) return cached;
+    await this.getMarkets();
+    const fromApi = this._tokenCache.get(key);
+    if (fromApi) return fromApi;
+    throw new AgetherError(
+      `Unknown token: ${symbolOrAddress}. No Morpho market found with this collateral.`,
+      "UNKNOWN_COLLATERAL"
+    );
+  }
+  /**
+   * Get all discovered collateral tokens (for balance iteration, etc.).
+   * Returns unique tokens from the Morpho API market discovery.
+   */
+  async _getDiscoveredTokens() {
+    await this.getMarkets();
+    const seen = /* @__PURE__ */ new Set();
+    const tokens = [];
+    for (const [key, info] of this._tokenCache) {
+      if (key.startsWith("0x")) continue;
+      if (seen.has(info.address.toLowerCase())) continue;
+      seen.add(info.address.toLowerCase());
+      if (info.symbol === "USDC" || info.symbol === "USDbC") continue;
+      tokens.push(info);
+    }
+    return tokens;
+  }
+  /**
+   * 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 axios.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