@agether/sdk 2.3.4 → 2.5.0

package/dist/cli.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Agether CLI — Direct Morpho Blue Credit for AI Agents
+ *
+ * Architecture (v2 — Safe + Safe7579):
+ * - All commands sign transactions directly with the agent's private key
+ * - Uses MorphoClient for lending (ERC-4337 UserOps through Safe account)
+ * - Uses X402Client for paid API calls
+ *
+ * Usage:
+ *   agether init <private-key> [--agent-id <id>]   Initialize
+ *   agether register [--name <n>]                   Register ERC-8004 + Safe account
+ *   agether balance                                 Check balances
+ *   agether status                                  Show Morpho positions
+ *   agether score                                   Get credit score (x402-gated)
+ *   agether markets                                 List Morpho markets
+ *   agether deposit --amount 0.05 --token WETH      Deposit collateral
+ *   agether borrow --amount 100                     Borrow USDC
+ *   agether deposit-and-borrow --amount 0.05 --token WETH --borrow 100
+ *   agether repay --amount 50                       Repay USDC
+ *   agether withdraw --amount 0.05 --token WETH     Withdraw collateral
+ *   agether sponsor --amount 0.05 --token WETH --agent-id 123
+ *   agether fund --amount 50                        Fund Safe account with USDC
+ *   agether x402 <url> [--method GET|POST] [--body <json>]
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;GAuBG"}

package/dist/cli.js

@@ -274,7 +274,7 @@ var MorphoClient_exports = {};
 __export(MorphoClient_exports, {
   MorphoClient: () => MorphoClient
 });
-var import_ethers, import_axios, BASE_COLLATERALS, MORPHO_API_URL, MODE_SINGLE, MODE_BATCH, morphoIface, erc20Iface, MorphoClient;
+var import_ethers, import_axios, MORPHO_API_URL, MODE_SINGLE, MODE_BATCH, morphoIface, erc20Iface, MorphoClient;
 var init_MorphoClient = __esm({
   "src/clients/MorphoClient.ts"() {
     "use strict";
@@ -283,11 +283,6 @@ var init_MorphoClient = __esm({
     init_types();
     init_abis();
     init_config();
-    BASE_COLLATERALS = {
-      WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
-      wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
-      cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
-    };
     MORPHO_API_URL = "https://api.morpho.org/graphql";
     MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
     MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
@@ -296,6 +291,8 @@ var init_MorphoClient = __esm({
     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);
@@ -482,15 +479,16 @@ var init_MorphoClient = __esm({
         const usdc = new import_ethers.Contract(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 import_ethers.Contract(info.address, ERC20_ABI, this.provider);
             const bal = await token.balanceOf(eoaAddr);
-            eoaCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
+            eoaCollateral[info.symbol] = import_ethers.ethers.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 = {
@@ -505,14 +503,14 @@ var init_MorphoClient = __esm({
           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 import_ethers.Contract(info.address, ERC20_ABI, this.provider);
               const bal = await token.balanceOf(acctAddr);
-              acctCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
+              acctCollateral[info.symbol] = import_ethers.ethers.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 = {
@@ -598,6 +596,28 @@ var init_MorphoClient = __esm({
                 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 !== import_ethers.ethers.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;
@@ -611,8 +631,17 @@ var init_MorphoClient = __esm({
        * 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();
@@ -771,8 +800,17 @@ var init_MorphoClient = __esm({
         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 = `{
@@ -831,8 +869,7 @@ var init_MorphoClient = __esm({
        * @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");
@@ -870,7 +907,259 @@ var init_MorphoClient = __esm({
         };
       }
       // ════════════════════════════════════════════════════════
-      //  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_ethers.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_ethers.ethers.keccak256(
+          import_ethers.ethers.AbiCoder.defaultAbiCoder().encode(
+            ["address", "address", "address", "address", "uint256"],
+            [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]
+          )
+        );
+        const usdcContract = new import_ethers.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_ethers.ethers.formatUnits(acctBalance, 6)}, EOA has ${import_ethers.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_ethers.ethers.keccak256(
+          import_ethers.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_ethers.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_ethers.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_ethers.ethers.formatUnits(currentAssets, p.market.loanAsset.decimals),
+            netDeposited: import_ethers.ethers.formatUnits(netDeposited, p.market.loanAsset.decimals),
+            earnedYield: import_ethers.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_ethers.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_ethers.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.
@@ -882,8 +1171,7 @@ var init_MorphoClient = __esm({
        */
       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 = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
         const morphoAddr = this.config.contracts.morphoBlue;
@@ -1004,8 +1292,7 @@ var init_MorphoClient = __esm({
        */
       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 = import_ethers.ethers.parseUnits(collateralAmount, colInfo.decimals);
         const borrowWei = import_ethers.ethers.parseUnits(borrowUsdcAmount, 6);
@@ -1173,8 +1460,7 @@ var init_MorphoClient = __esm({
        */
       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;
@@ -1271,8 +1557,7 @@ var init_MorphoClient = __esm({
        * (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;
@@ -1501,6 +1786,131 @@ var init_MorphoClient = __esm({
         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_ethers.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");
+      }
+      /**
+       * 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 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;
+      }
     };
   }
 });