@agether/sdk 2.13.0 → 2.14.1

package/dist/cli.d.ts

@@ -0,0 +1,29 @@
+#!/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
+ *
+ * Supported chains: Ethereum (1, default), Base (8453), Base Sepolia (84532)
+ *
+ * Usage:
+ *   agether init <private-key> [--agent-id <id>] [--chain <chainId>]
+ *   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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}

package/dist/cli.js

@@ -408,7 +408,7 @@ var init_MorphoClient = __esm({
         const chainId = this.config.chainId;
         const query = `{
       markets(
-        first: 50
+        first: 500
         orderBy: SupplyAssetsUsd
         orderDirection: Desc
         where: { chainId_in: [${chainId}] }
@@ -514,7 +514,7 @@ var init_MorphoClient = __esm({
               const resolved = await this._resolveToken(loanTokenSymbolOrAddress);
               loanAddr = resolved.address.toLowerCase();
             } catch {
-              loanAddr = loanTokenSymbolOrAddress.toLowerCase();
+              loanAddr = void 0;
             }
           }
         }
@@ -522,6 +522,7 @@ var init_MorphoClient = __esm({
         for (const m of this._discoveredMarkets ?? []) {
           if (m.collateralAsset.address.toLowerCase() !== colAddr) continue;
           if (loanAddr && m.loanAsset.address.toLowerCase() !== loanAddr) continue;
+          if (!loanAddr && loanTokenSymbolOrAddress && m.loanAsset.symbol.toUpperCase() !== loanTokenSymbolOrAddress.toUpperCase()) continue;
           return {
             loanToken: m.loanAsset.address,
             collateralToken: m.collateralAsset.address,
@@ -530,6 +531,27 @@ var init_MorphoClient = __esm({
             lltv: m.lltv
           };
         }
+        if (!collateralSymbolOrAddress.startsWith("0x")) {
+          const searched = await this.searchMarkets(collateralSymbolOrAddress, { asCollateral: true });
+          const allResults = [...searched];
+          if (loanTokenSymbolOrAddress && !loanTokenSymbolOrAddress.startsWith("0x")) {
+            const loanSearched = await this.searchMarkets(loanTokenSymbolOrAddress, { asLoanToken: true });
+            const seen = new Set(allResults.map((r) => r.marketId));
+            for (const m of loanSearched) {
+              if (!seen.has(m.marketId)) allResults.push(m);
+            }
+          }
+          for (const m of allResults) {
+            if (colAddr.startsWith("0x") && m.collateralAddress.toLowerCase() !== colAddr) {
+              if (m.collateralToken.toUpperCase() !== collateralSymbolOrAddress.toUpperCase()) continue;
+            } else if (m.collateralToken.toUpperCase() !== collateralSymbolOrAddress.toUpperCase()) {
+              continue;
+            }
+            if (loanAddr && m.loanAddress.toLowerCase() !== loanAddr) continue;
+            if (!loanAddr && loanTokenSymbolOrAddress && m.loanToken.toUpperCase() !== loanTokenSymbolOrAddress.toUpperCase()) continue;
+            return this.getMarketParams(m.marketId);
+          }
+        }
         throw new AgetherError(
           `No Morpho market found for collateral ${collateralSymbolOrAddress}` + (loanTokenSymbolOrAddress ? ` with loan token ${loanTokenSymbolOrAddress}` : ""),
           "MARKET_NOT_FOUND"
@@ -560,26 +582,54 @@ var init_MorphoClient = __esm({
         };
       }
       /**
-       * Full status: positions across all discovered markets.
+       * Full status: positions across all markets the user has interacted with.
+       *
+       * Uses Morpho GraphQL `marketPositions` to find ALL positions (not limited
+       * to the top-500 markets), then reads onchain data for accurate debt.
        */
       async getStatus() {
         const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
+        const chainId = this.config.chainId;
         const positions = [];
         let totalDebtFloat = 0;
-        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 (pos.collateral === 0n && pos.borrowShares === 0n && pos.supplyShares === 0n) continue;
+        try {
+          const posQuery = `{
+        marketPositions(
+          where: {
+            userAddress_in: ["${acctAddr}"]
+            chainId_in: [${chainId}]
+          }
+          first: 100
+        ) {
+          items {
+            supplyShares
+            borrowShares
+            collateral
+            market {
+              uniqueKey
+              loanAsset { symbol address decimals }
+              collateralAsset { symbol address decimals }
+            }
+          }
+        }
+      }`;
+          const resp = await import_axios.default.post(MORPHO_API_URL, { query: posQuery }, { timeout: 15e3 });
+          const items = resp.data?.data?.marketPositions?.items ?? [];
+          for (const item of items) {
+            const supplyShares = BigInt(item.supplyShares ?? "0");
+            const borrowShares = BigInt(item.borrowShares ?? "0");
+            const collateral = BigInt(item.collateral ?? "0");
+            if (collateral === 0n && borrowShares === 0n && supplyShares === 0n) continue;
+            const m = item.market;
+            if (!m?.collateralAsset || !m?.loanAsset) continue;
             const loanDecimals = m.loanAsset.decimals;
             let debt = 0n;
-            if (pos.borrowShares > 0n) {
+            if (borrowShares > 0n) {
               try {
                 const mkt = await this.morphoBlue.market(m.uniqueKey);
                 const totalBorrowShares = BigInt(mkt.totalBorrowShares);
                 const totalBorrowAssets = BigInt(mkt.totalBorrowAssets);
-                debt = totalBorrowShares > 0n ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares : 0n;
+                debt = totalBorrowShares > 0n ? (borrowShares * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares : 0n;
                 totalDebtFloat += parseFloat(import_ethers.ethers.formatUnits(debt, loanDecimals));
               } catch (e) {
                 console.warn(`[agether] debt calc failed for market ${m.uniqueKey}:`, e instanceof Error ? e.message : e);
@@ -589,14 +639,46 @@ var init_MorphoClient = __esm({
               marketId: m.uniqueKey,
               collateralToken: m.collateralAsset.symbol,
               loanToken: m.loanAsset.symbol,
-              collateral: import_ethers.ethers.formatUnits(pos.collateral, m.collateralAsset.decimals),
-              borrowShares: pos.borrowShares.toString(),
-              supplyShares: pos.supplyShares.toString(),
+              collateral: import_ethers.ethers.formatUnits(collateral, m.collateralAsset.decimals),
+              borrowShares: borrowShares.toString(),
+              supplyShares: supplyShares.toString(),
               debt: import_ethers.ethers.formatUnits(debt, loanDecimals)
             });
-          } catch (e) {
-            console.warn(`[agether] position read failed for market:`, e instanceof Error ? e.message : e);
-            continue;
+          }
+        } catch (e) {
+          console.warn("[agether] marketPositions API failed, falling back to market scan:", e instanceof Error ? e.message : e);
+          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 (pos.collateral === 0n && pos.borrowShares === 0n && pos.supplyShares === 0n) continue;
+              const loanDecimals = m.loanAsset.decimals;
+              let debt = 0n;
+              if (pos.borrowShares > 0n) {
+                try {
+                  const mkt = await this.morphoBlue.market(m.uniqueKey);
+                  const totalBorrowShares = BigInt(mkt.totalBorrowShares);
+                  const totalBorrowAssets = BigInt(mkt.totalBorrowAssets);
+                  debt = totalBorrowShares > 0n ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares : 0n;
+                  totalDebtFloat += parseFloat(import_ethers.ethers.formatUnits(debt, loanDecimals));
+                } catch (e2) {
+                  console.warn(`[agether] debt calc failed:`, e2 instanceof Error ? e2.message : e2);
+                }
+              }
+              positions.push({
+                marketId: m.uniqueKey,
+                collateralToken: m.collateralAsset.symbol,
+                loanToken: m.loanAsset.symbol,
+                collateral: import_ethers.ethers.formatUnits(pos.collateral, m.collateralAsset.decimals),
+                borrowShares: pos.borrowShares.toString(),
+                supplyShares: pos.supplyShares.toString(),
+                debt: import_ethers.ethers.formatUnits(debt, loanDecimals)
+              });
+            } catch (e2) {
+              console.warn(`[agether] position read failed:`, e2 instanceof Error ? e2.message : e2);
+              continue;
+            }
           }
         }
         return {
@@ -700,41 +782,39 @@ var init_MorphoClient = __esm({
       async getMarketRates(collateralSymbolOrAddress, loanTokenSymbolOrAddress) {
         const chainId = this.config.chainId;
         let collateralFilter = "";
+        let loanFilter = "";
+        let searchTerm = "";
         if (collateralSymbolOrAddress) {
-          let colAddr;
           if (collateralSymbolOrAddress.startsWith("0x")) {
-            colAddr = collateralSymbolOrAddress.toLowerCase();
+            collateralFilter = `, collateralAssetAddress_in: ["${collateralSymbolOrAddress.toLowerCase()}"]`;
           } else {
-            try {
-              const resolved = await this._resolveToken(collateralSymbolOrAddress);
-              colAddr = resolved.address.toLowerCase();
-            } catch {
-              colAddr = collateralSymbolOrAddress.toLowerCase();
+            const cached = this._tokenCache.get(collateralSymbolOrAddress.toUpperCase());
+            if (cached) {
+              collateralFilter = `, collateralAssetAddress_in: ["${cached.address.toLowerCase()}"]`;
+            } else {
+              searchTerm = collateralSymbolOrAddress;
             }
           }
-          collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
         }
-        let loanFilter = "";
         if (loanTokenSymbolOrAddress) {
-          let loanAddr;
           if (loanTokenSymbolOrAddress.startsWith("0x")) {
-            loanAddr = loanTokenSymbolOrAddress.toLowerCase();
+            loanFilter = `, loanAssetAddress_in: ["${loanTokenSymbolOrAddress.toLowerCase()}"]`;
           } else {
-            try {
-              const resolved = await this._resolveToken(loanTokenSymbolOrAddress);
-              loanAddr = resolved.address.toLowerCase();
-            } catch {
-              loanAddr = loanTokenSymbolOrAddress.toLowerCase();
+            const cached = this._tokenCache.get(loanTokenSymbolOrAddress.toUpperCase());
+            if (cached) {
+              loanFilter = `, loanAssetAddress_in: ["${cached.address.toLowerCase()}"]`;
+            } else {
+              searchTerm = searchTerm || loanTokenSymbolOrAddress;
             }
           }
-          loanFilter = `, loanAssetAddress_in: ["${loanAddr}"]`;
         }
+        const searchClause = searchTerm ? `, search: "${searchTerm}"` : "";
         const query = `{
       markets(
-        first: 50
+        first: 100
         orderBy: SupplyAssetsUsd
         orderDirection: Desc
-        where: { chainId_in: [${chainId}]${loanFilter}${collateralFilter} }
+        where: { chainId_in: [${chainId}]${loanFilter}${collateralFilter}${searchClause} }
       ) {
         items {
           uniqueKey
@@ -753,7 +833,15 @@ var init_MorphoClient = __esm({
     }`;
         try {
           const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
-          const items = resp.data?.data?.markets?.items ?? [];
+          let items = resp.data?.data?.markets?.items ?? [];
+          if (searchTerm && collateralSymbolOrAddress && !collateralSymbolOrAddress.startsWith("0x")) {
+            const sym = collateralSymbolOrAddress.toUpperCase();
+            items = items.filter((m) => m.collateralAsset?.symbol?.toUpperCase() === sym);
+          }
+          if (searchTerm && loanTokenSymbolOrAddress && !loanTokenSymbolOrAddress.startsWith("0x")) {
+            const sym = loanTokenSymbolOrAddress.toUpperCase();
+            items = items.filter((m) => m.loanAsset?.symbol?.toUpperCase() === sym);
+          }
           return items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== import_ethers.ethers.ZeroAddress).map((m) => {
             const loanDecimals = m.loanAsset?.decimals ?? 18;
             return {
@@ -774,6 +862,205 @@ var init_MorphoClient = __esm({
           return [];
         }
       }
+      // ════════════════════════════════════════════════════════
+      //  Market Search & Wallet Discovery
+      // ════════════════════════════════════════════════════════
+      /**
+       * Search Morpho markets by token name using the Morpho GraphQL API `search` field.
+       * No hardcoded token lists — uses Morpho's built-in fuzzy search.
+       *
+       * @param search - token name or symbol (e.g. 'WETH', 'staked ETH', 'ezETH')
+       * @param options.asCollateral - only return markets where the searched token is collateral
+       * @param options.asLoanToken - only return markets where the searched token is the loan asset
+       */
+      async searchMarkets(search, options) {
+        const chainId = this.config.chainId;
+        const query = `{
+      markets(
+        first: 100
+        orderBy: SupplyAssetsUsd
+        orderDirection: Desc
+        where: { chainId_in: [${chainId}], search: "${search}" }
+      ) {
+        items {
+          uniqueKey
+          lltv
+          loanAsset { address symbol decimals }
+          collateralAsset { address symbol decimals }
+          state {
+            borrowAssets
+            supplyAssets
+            utilization
+            supplyApy
+            borrowApy
+          }
+        }
+      }
+    }`;
+        try {
+          const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+          let items = resp.data?.data?.markets?.items ?? [];
+          items = items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== import_ethers.ethers.ZeroAddress);
+          const searchUpper = search.toUpperCase();
+          if (options?.asCollateral) {
+            items = items.filter((m) => m.collateralAsset?.symbol?.toUpperCase() === searchUpper);
+          }
+          if (options?.asLoanToken) {
+            items = items.filter((m) => m.loanAsset?.symbol?.toUpperCase() === searchUpper);
+          }
+          return items.map((m) => {
+            const loanDecimals = m.loanAsset?.decimals ?? 18;
+            const collateralDecimals = m.collateralAsset?.decimals ?? 18;
+            return {
+              collateralToken: m.collateralAsset.symbol,
+              loanToken: m.loanAsset.symbol,
+              loanDecimals,
+              collateralDecimals,
+              supplyApy: m.state?.supplyApy ? Number(m.state.supplyApy) : 0,
+              borrowApy: m.state?.borrowApy ? Number(m.state.borrowApy) : 0,
+              utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
+              totalSupplyUsd: m.state?.supplyAssets ? Number(m.state.supplyAssets) / 10 ** loanDecimals : 0,
+              totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / 10 ** loanDecimals : 0,
+              lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
+              marketId: m.uniqueKey,
+              collateralAddress: m.collateralAsset.address,
+              loanAddress: m.loanAsset.address
+            };
+          });
+        } catch (e) {
+          console.warn("[agether] searchMarkets failed:", e instanceof Error ? e.message : e);
+          return [];
+        }
+      }
+      /**
+       * Scan the AgentAccount wallet for all ERC-20 tokens that appear in Morpho
+       * markets on the current chain. Returns tokens where balance > 0.
+       *
+       * Uses the full market list (500 markets) to discover all relevant tokens,
+       * then checks on-chain balance for each unique token address.
+       *
+       * @returns Array of tokens with non-zero balance, sorted by balance descending.
+       */
+      async getWalletTokenBalances() {
+        const acctAddr = await this.getAccountAddress();
+        await this.getMarkets();
+        const uniqueTokens = /* @__PURE__ */ new Map();
+        for (const [key, info] of this._tokenCache.entries()) {
+          if (key.startsWith("0x") && !uniqueTokens.has(key)) {
+            uniqueTokens.set(key, info);
+          }
+        }
+        const results = [];
+        try {
+          const ethBalance = await this.provider.getBalance(acctAddr);
+          if (ethBalance > 0n) {
+            results.push({
+              symbol: "ETH",
+              address: import_ethers.ethers.ZeroAddress,
+              decimals: 18,
+              balance: ethBalance,
+              balanceFormatted: import_ethers.ethers.formatEther(ethBalance)
+            });
+          }
+        } catch {
+        }
+        const tokenEntries = Array.from(uniqueTokens.values());
+        const batchSize = 20;
+        for (let i = 0; i < tokenEntries.length; i += batchSize) {
+          const batch = tokenEntries.slice(i, i + batchSize);
+          const checks = batch.map(async (info) => {
+            try {
+              const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
+              const balance = await token.balanceOf(acctAddr);
+              if (balance > 0n) {
+                return {
+                  symbol: info.symbol,
+                  address: info.address,
+                  decimals: info.decimals,
+                  balance,
+                  balanceFormatted: import_ethers.ethers.formatUnits(balance, info.decimals)
+                };
+              }
+            } catch {
+            }
+            return null;
+          });
+          const batchResults = await Promise.all(checks);
+          for (const r of batchResults) {
+            if (r) results.push(r);
+          }
+        }
+        results.sort((a, b) => b.balance > a.balance ? 1 : b.balance < a.balance ? -1 : 0);
+        return results;
+      }
+      /**
+       * Find borrowing opportunities for the agent.
+       *
+       * - If `collateralSymbol` is provided: find all markets where that token is collateral.
+       * - If omitted: scan wallet balances and find markets for each token the agent holds.
+       *
+       * Returns markets grouped by collateral token with APY, liquidity, and balance info.
+       *
+       * @param collateralSymbol - optional, e.g. 'WETH'. If omitted, scans wallet.
+       */
+      async findBorrowingOptions(collateralSymbol) {
+        let tokensToCheck;
+        if (collateralSymbol) {
+          tokensToCheck = [{ symbol: collateralSymbol, balanceFormatted: "N/A" }];
+          try {
+            const balance = await this.getTokenBalance(collateralSymbol);
+            const info = await this._resolveToken(collateralSymbol);
+            tokensToCheck = [{ symbol: collateralSymbol, balanceFormatted: import_ethers.ethers.formatUnits(balance, info.decimals) }];
+          } catch {
+          }
+        } else {
+          const walletTokens = await this.getWalletTokenBalances();
+          tokensToCheck = walletTokens.filter((t) => t.symbol !== "ETH").map((t) => ({ symbol: t.symbol, balanceFormatted: t.balanceFormatted }));
+          if (tokensToCheck.length === 0) {
+            return [];
+          }
+        }
+        const results = [];
+        for (const token of tokensToCheck) {
+          const markets = await this.searchMarkets(token.symbol, { asCollateral: true });
+          if (markets.length === 0) continue;
+          results.push({
+            collateralToken: token.symbol,
+            collateralBalance: token.balanceFormatted,
+            markets: markets.map((m) => ({
+              loanToken: m.loanToken,
+              borrowApy: `${(m.borrowApy * 100).toFixed(2)}%`,
+              supplyApy: `${(m.supplyApy * 100).toFixed(2)}%`,
+              lltv: m.lltv,
+              utilization: `${(m.utilization * 100).toFixed(1)}%`,
+              availableLiquidity: `$${(m.totalSupplyUsd - m.totalBorrowUsd).toFixed(0)}`,
+              marketId: m.marketId
+            }))
+          });
+        }
+        return results;
+      }
+      /**
+       * Find supply/lending opportunities for a specific loan token.
+       *
+       * "What can I supply to earn WETH?" → shows all markets where WETH is the loan token
+       * (user supplies WETH to earn yield from borrowers).
+       *
+       * @param loanTokenSymbol - e.g. 'USDC', 'WETH'
+       */
+      async findSupplyOptions(loanTokenSymbol) {
+        const markets = await this.searchMarkets(loanTokenSymbol, { asLoanToken: true });
+        return markets.map((m) => ({
+          collateralToken: m.collateralToken,
+          loanToken: m.loanToken,
+          supplyApy: `${(m.supplyApy * 100).toFixed(2)}%`,
+          borrowApy: `${(m.borrowApy * 100).toFixed(2)}%`,
+          lltv: m.lltv,
+          utilization: `${(m.utilization * 100).toFixed(1)}%`,
+          totalSupply: `$${m.totalSupplyUsd.toFixed(0)}`,
+          marketId: m.marketId
+        }));
+      }
       /**
        * Estimate theoretical yield for a given collateral amount over a period.
        *
@@ -1678,6 +1965,46 @@ var init_MorphoClient = __esm({
       /** Find the first market where the agent has collateral deposited. */
       async _findActiveMarket() {
         const acctAddr = await this.getAccountAddress();
+        const chainId = this.config.chainId;
+        try {
+          const posQuery = `{
+        marketPositions(
+          where: { userAddress_in: ["${acctAddr}"], chainId_in: [${chainId}] }
+          first: 50
+        ) {
+          items {
+            collateral
+            market {
+              uniqueKey
+              oracleAddress
+              irmAddress
+              lltv
+              loanAsset { address symbol decimals }
+              collateralAsset { address symbol decimals }
+            }
+          }
+        }
+      }`;
+          const resp = await import_axios.default.post(MORPHO_API_URL, { query: posQuery }, { timeout: 1e4 });
+          const items = resp.data?.data?.marketPositions?.items ?? [];
+          for (const item of items) {
+            if (BigInt(item.collateral ?? "0") > 0n && item.market?.collateralAsset) {
+              const m = item.market;
+              return {
+                params: {
+                  loanToken: m.loanAsset.address,
+                  collateralToken: m.collateralAsset.address,
+                  oracle: m.oracleAddress,
+                  irm: m.irmAddress,
+                  lltv: BigInt(m.lltv)
+                },
+                symbol: m.collateralAsset.symbol
+              };
+            }
+          }
+        } catch (e) {
+          console.warn("[agether] _findActiveMarket GraphQL failed, falling back:", e instanceof Error ? e.message : e);
+        }
         const markets = await this.getMarkets();
         for (const m of markets) {
           if (!m.collateralAsset || m.collateralAsset.address === import_ethers.ethers.ZeroAddress) continue;
@@ -1706,6 +2033,46 @@ var init_MorphoClient = __esm({
       /** Find the first market where the agent has a supply (lending) position. */
       async _findActiveSupplyMarket() {
         const acctAddr = await this.getAccountAddress();
+        const chainId = this.config.chainId;
+        try {
+          const posQuery = `{
+        marketPositions(
+          where: { userAddress_in: ["${acctAddr}"], chainId_in: [${chainId}] }
+          first: 50
+        ) {
+          items {
+            supplyShares
+            market {
+              uniqueKey
+              oracleAddress
+              irmAddress
+              lltv
+              loanAsset { address symbol decimals }
+              collateralAsset { address symbol decimals }
+            }
+          }
+        }
+      }`;
+          const resp = await import_axios.default.post(MORPHO_API_URL, { query: posQuery }, { timeout: 1e4 });
+          const items = resp.data?.data?.marketPositions?.items ?? [];
+          for (const item of items) {
+            if (BigInt(item.supplyShares ?? "0") > 0n && item.market?.collateralAsset) {
+              const m = item.market;
+              return {
+                params: {
+                  loanToken: m.loanAsset.address,
+                  collateralToken: m.collateralAsset.address,
+                  oracle: m.oracleAddress,
+                  irm: m.irmAddress,
+                  lltv: BigInt(m.lltv)
+                },
+                symbol: m.collateralAsset.symbol
+              };
+            }
+          }
+        } catch (e) {
+          console.warn("[agether] _findActiveSupplyMarket GraphQL failed, falling back:", e instanceof Error ? e.message : e);
+        }
         const markets = await this.getMarkets();
         for (const m of markets) {
           if (!m.collateralAsset || m.collateralAsset.address === import_ethers.ethers.ZeroAddress) continue;
@@ -1776,6 +2143,24 @@ var init_MorphoClient = __esm({
         await this.getMarkets();
         const fromApi = this._tokenCache.get(key);
         if (fromApi) return fromApi;
+        if (!symbolOrAddress.startsWith("0x")) {
+          const searchResults = await this.searchMarkets(symbolOrAddress);
+          const sym = symbolOrAddress.toUpperCase();
+          for (const m of searchResults) {
+            if (m.collateralToken.toUpperCase() === sym) {
+              const info = { address: m.collateralAddress, symbol: m.collateralToken, decimals: m.collateralDecimals };
+              this._tokenCache.set(sym, info);
+              this._tokenCache.set(m.collateralAddress.toLowerCase(), info);
+              return info;
+            }
+            if (m.loanToken.toUpperCase() === sym) {
+              const info = { address: m.loanAddress, symbol: m.loanToken, decimals: m.loanDecimals };
+              this._tokenCache.set(sym, info);
+              this._tokenCache.set(m.loanAddress.toLowerCase(), info);
+              return info;
+            }
+          }
+        }
         throw new AgetherError(
           `Unknown token: ${symbolOrAddress}. No Morpho market found with this token.`,
           "UNKNOWN_TOKEN"