@agether/sdk 2.14.0 → 2.15.0

package/dist/cli.js

@@ -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,
@@ -532,9 +533,22 @@ var init_MorphoClient = __esm({
         }
         if (!collateralSymbolOrAddress.startsWith("0x")) {
           const searched = await this.searchMarkets(collateralSymbolOrAddress, { asCollateral: true });
-          for (const m of searched) {
+          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 (loanTokenSymbolOrAddress && !loanTokenSymbolOrAddress.startsWith("0x") && m.loanToken.toUpperCase() !== loanTokenSymbolOrAddress.toUpperCase()) continue;
+            if (!loanAddr && loanTokenSymbolOrAddress && m.loanToken.toUpperCase() !== loanTokenSymbolOrAddress.toUpperCase()) continue;
             return this.getMarketParams(m.marketId);
           }
         }
@@ -568,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);
@@ -597,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 {
@@ -1891,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;
@@ -1919,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;
@@ -2082,16 +2236,18 @@ var AgetherClient_exports = {};
 __export(AgetherClient_exports, {
   AgetherClient: () => AgetherClient
 });
-var import_ethers2, MODE_SINGLE2, erc20Iface2, KNOWN_TOKENS, AgetherClient;
+var import_ethers2, import_axios2, MODE_SINGLE2, erc20Iface2, MORPHO_API_URL2, KNOWN_TOKENS, AgetherClient;
 var init_AgetherClient = __esm({
   "src/clients/AgetherClient.ts"() {
     "use strict";
     import_ethers2 = require("ethers");
+    import_axios2 = __toESM(require("axios"));
     init_types();
     init_abis();
     init_config();
     MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
     erc20Iface2 = new import_ethers2.ethers.Interface(ERC20_ABI);
+    MORPHO_API_URL2 = "https://api.morpho.org/graphql";
     KNOWN_TOKENS = {
       [8453 /* Base */]: {
         WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
@@ -2106,6 +2262,17 @@ var init_AgetherClient = __esm({
     };
     AgetherClient = class _AgetherClient {
       constructor(options) {
+        /**
+         * Resolve a token symbol or address to { address, symbol, decimals }.
+         *
+         * Resolution order:
+         * 1. `'USDC'` → from chain config (instant)
+         * 2. Well-known symbols (`'WETH'`, `'wstETH'`, `'cbETH'`) → built-in per-chain registry (instant)
+         * 3. Dynamic cache populated by previous Morpho API lookups (instant)
+         * 4. `'0x...'` address → reads decimals and symbol onchain
+         * 5. Morpho GraphQL `search` API → discovers any token across all Morpho markets
+         */
+        this._dynamicTokenCache = /* @__PURE__ */ new Map();
         this.config = options.config;
         this.signer = options.signer;
         this.agentId = options.agentId;
@@ -2390,21 +2557,10 @@ var init_AgetherClient = __esm({
       }
       /**
        * Fund the Safe account with USDC from EOA.
-       * This is a simple ERC-20 transfer (does NOT require a UserOp).
+       * @deprecated Use `fundAccountToken('USDC', amount)` instead.
        */
       async fundAccount(usdcAmount) {
-        const acctAddr = await this.getAccountAddress();
-        const usdc = new import_ethers2.Contract(this.config.contracts.usdc, ERC20_ABI, this.signer);
-        const amount = import_ethers2.ethers.parseUnits(usdcAmount, 6);
-        const tx = await usdc.transfer(acctAddr, amount);
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        return {
-          txHash: receipt.hash,
-          blockNumber: receipt.blockNumber,
-          status: receipt.status === 1 ? "success" : "failed",
-          gasUsed: receipt.gasUsed
-        };
+        return this.fundAccountToken("USDC", usdcAmount);
       }
       // ════════════════════════════════════════════════════════
       //  Withdrawals (Safe → EOA via UserOps)
@@ -2456,6 +2612,138 @@ var init_AgetherClient = __esm({
         return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: eoaAddr };
       }
       // ════════════════════════════════════════════════════════
+      //  Token Transfers & Approvals (AgentAccount → any address)
+      // ════════════════════════════════════════════════════════
+      /**
+       * Fund the AgentAccount with any ERC-20 token from EOA.
+       * Simple ERC-20 transfer (does NOT require a UserOp).
+       *
+       * @param tokenSymbol - Token symbol (e.g. 'USDC', 'WETH') or 0x address
+       * @param amount - Amount to send (human-readable, e.g. '100')
+       */
+      async fundAccountToken(tokenSymbol, amount) {
+        const acctAddr = await this.getAccountAddress();
+        const tokenInfo = await this._resolveToken(tokenSymbol);
+        const tokenContract = new import_ethers2.Contract(tokenInfo.address, ERC20_ABI, this.signer);
+        const weiAmount = import_ethers2.ethers.parseUnits(amount, tokenInfo.decimals);
+        const eoaBalance = await tokenContract.balanceOf(await this._getSignerAddress());
+        if (eoaBalance < weiAmount) {
+          throw new AgetherError(
+            `Insufficient ${tokenInfo.symbol}. EOA has ${import_ethers2.ethers.formatUnits(eoaBalance, tokenInfo.decimals)}, need ${amount}.`,
+            "INSUFFICIENT_BALANCE"
+          );
+        }
+        const tx = await tokenContract.transfer(acctAddr, weiAmount);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        return {
+          txHash: receipt.hash,
+          blockNumber: receipt.blockNumber,
+          status: receipt.status === 1 ? "success" : "failed",
+          gasUsed: receipt.gasUsed
+        };
+      }
+      /**
+       * Transfer any ERC-20 token from AgentAccount to any address or agent.
+       * Executes via Safe UserOp (ERC-7579 single execution).
+       *
+       * @param tokenSymbol - Token symbol (e.g. 'USDC', 'WETH') or 0x address
+       * @param amount - Amount to send (e.g. '100' or 'all')
+       * @param to - Destination: `{ address: '0x...' }` or `{ agentId: '42' }`
+       */
+      async transferToken(tokenSymbol, amount, to) {
+        const acctAddr = await this.getAccountAddress();
+        const tokenInfo = await this._resolveToken(tokenSymbol);
+        const tokenContract = new import_ethers2.Contract(tokenInfo.address, ERC20_ABI, this.signer.provider);
+        let toAddr;
+        if (to.address) {
+          toAddr = to.address;
+        } else if (to.agentId) {
+          toAddr = await this.agether4337Factory.getAccount(BigInt(to.agentId));
+          if (toAddr === import_ethers2.ethers.ZeroAddress) {
+            throw new AgetherError(`Agent ${to.agentId} has no account`, "NO_ACCOUNT");
+          }
+        } else {
+          throw new AgetherError("Provide address or agentId as destination", "INVALID_TARGET");
+        }
+        let weiAmount;
+        if (amount === "all") {
+          weiAmount = await tokenContract.balanceOf(acctAddr);
+          if (weiAmount === 0n) {
+            throw new AgetherError(`No ${tokenInfo.symbol} in AgentAccount`, "INSUFFICIENT_BALANCE");
+          }
+        } else {
+          weiAmount = import_ethers2.ethers.parseUnits(amount, tokenInfo.decimals);
+        }
+        const data = erc20Iface2.encodeFunctionData("transfer", [toAddr, weiAmount]);
+        const receipt = await this._exec(tokenInfo.address, data);
+        const actualAmount = amount === "all" ? import_ethers2.ethers.formatUnits(weiAmount, tokenInfo.decimals) : amount;
+        return { tx: receipt.hash, token: tokenInfo.symbol, amount: actualAmount, destination: toAddr };
+      }
+      /**
+       * Transfer ETH from AgentAccount to any address or agent.
+       * Executes via Safe UserOp.
+       *
+       * @param amount - ETH amount (e.g. '0.01' or 'all')
+       * @param to - Destination: `{ address: '0x...' }` or `{ agentId: '42' }`
+       */
+      async transferEth(amount, to) {
+        const acctAddr = await this.getAccountAddress();
+        let toAddr;
+        if (to.address) {
+          toAddr = to.address;
+        } else if (to.agentId) {
+          toAddr = await this.agether4337Factory.getAccount(BigInt(to.agentId));
+          if (toAddr === import_ethers2.ethers.ZeroAddress) {
+            throw new AgetherError(`Agent ${to.agentId} has no account`, "NO_ACCOUNT");
+          }
+        } else {
+          throw new AgetherError("Provide address or agentId as destination", "INVALID_TARGET");
+        }
+        let weiAmount;
+        if (amount === "all") {
+          weiAmount = await this.signer.provider.getBalance(acctAddr);
+          if (weiAmount === 0n) throw new AgetherError("No ETH in AgentAccount", "INSUFFICIENT_BALANCE");
+        } else {
+          weiAmount = import_ethers2.ethers.parseEther(amount);
+        }
+        const receipt = await this._exec(toAddr, "0x", weiAmount);
+        const actualAmount = amount === "all" ? import_ethers2.ethers.formatEther(weiAmount) : amount;
+        return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: toAddr };
+      }
+      /**
+       * Approve a spender to use ERC-20 tokens from the AgentAccount.
+       * Executes via Safe UserOp (ERC-7579 single execution).
+       *
+       * @param tokenSymbol - Token symbol (e.g. 'USDC', 'WETH') or 0x address
+       * @param amount - Allowance amount (e.g. '1000' or 'max' for uint256 max)
+       * @param spender - Spender: `{ address: '0x...' }` or `{ agentId: '42' }`
+       */
+      async approveToken(tokenSymbol, amount, spender) {
+        const tokenInfo = await this._resolveToken(tokenSymbol);
+        let spenderAddr;
+        if (spender.address) {
+          spenderAddr = spender.address;
+        } else if (spender.agentId) {
+          spenderAddr = await this.agether4337Factory.getAccount(BigInt(spender.agentId));
+          if (spenderAddr === import_ethers2.ethers.ZeroAddress) {
+            throw new AgetherError(`Agent ${spender.agentId} has no account`, "NO_ACCOUNT");
+          }
+        } else {
+          throw new AgetherError("Provide address or agentId as spender", "INVALID_TARGET");
+        }
+        let weiAmount;
+        if (amount === "max") {
+          weiAmount = import_ethers2.ethers.MaxUint256;
+        } else {
+          weiAmount = import_ethers2.ethers.parseUnits(amount, tokenInfo.decimals);
+        }
+        const data = erc20Iface2.encodeFunctionData("approve", [spenderAddr, weiAmount]);
+        const receipt = await this._exec(tokenInfo.address, data);
+        const actualAmount = amount === "max" ? "unlimited" : amount;
+        return { tx: receipt.hash, token: tokenInfo.symbol, amount: actualAmount, spender: spenderAddr };
+      }
+      // ════════════════════════════════════════════════════════
       //  Sponsorship
       // ════════════════════════════════════════════════════════
       /**
@@ -2584,14 +2872,6 @@ var init_AgetherClient = __esm({
         }
         return this._eoaAddress;
       }
-      /**
-       * Resolve a token symbol or address to { address, symbol, decimals }.
-       *
-       * Supports:
-       * - `'USDC'` → from chain config
-       * - Well-known symbols (`'WETH'`, `'wstETH'`, `'cbETH'`) → built-in per-chain registry
-       * - `'0x...'` address → reads decimals and symbol onchain
-       */
       async _resolveToken(symbolOrAddress) {
         if (symbolOrAddress.toUpperCase() === "USDC") {
           return { address: this.config.contracts.usdc, symbol: "USDC", decimals: 6 };
@@ -2599,6 +2879,9 @@ var init_AgetherClient = __esm({
         const chainTokens = KNOWN_TOKENS[this.config.chainId] ?? {};
         const bySymbol = chainTokens[symbolOrAddress] || chainTokens[symbolOrAddress.toUpperCase()];
         if (bySymbol) return bySymbol;
+        const cacheKey = symbolOrAddress.startsWith("0x") ? symbolOrAddress.toLowerCase() : symbolOrAddress.toUpperCase();
+        const cached = this._dynamicTokenCache.get(cacheKey);
+        if (cached) return cached;
         if (symbolOrAddress.startsWith("0x") && symbolOrAddress.length === 42) {
           try {
             const token = new import_ethers2.Contract(
@@ -2607,7 +2890,10 @@ var init_AgetherClient = __esm({
               this.signer.provider
             );
             const [decimals, symbol] = await Promise.all([token.decimals(), token.symbol()]);
-            return { address: symbolOrAddress, symbol, decimals: Number(decimals) };
+            const info = { address: symbolOrAddress, symbol, decimals: Number(decimals) };
+            this._dynamicTokenCache.set(symbolOrAddress.toLowerCase(), info);
+            this._dynamicTokenCache.set(symbol.toUpperCase(), info);
+            return info;
           } catch (e) {
             throw new AgetherError(
               `Failed to read token at ${symbolOrAddress}: ${e instanceof Error ? e.message : e}`,
@@ -2615,8 +2901,53 @@ var init_AgetherClient = __esm({
             );
           }
         }
+        try {
+          const chainId = this.config.chainId;
+          const query = `{
+        markets(
+          first: 20
+          where: { chainId_in: [${chainId}], search: "${symbolOrAddress}" }
+        ) {
+          items {
+            loanAsset { address symbol decimals }
+            collateralAsset { address symbol decimals }
+          }
+        }
+      }`;
+          const resp = await import_axios2.default.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
+          const items = resp.data?.data?.markets?.items ?? [];
+          const sym = symbolOrAddress.toUpperCase();
+          for (const m of items) {
+            if (m.loanAsset?.symbol?.toUpperCase() === sym) {
+              const info = { address: m.loanAsset.address, symbol: m.loanAsset.symbol, decimals: m.loanAsset.decimals };
+              this._dynamicTokenCache.set(sym, info);
+              this._dynamicTokenCache.set(m.loanAsset.address.toLowerCase(), info);
+              return info;
+            }
+            if (m.collateralAsset?.symbol?.toUpperCase() === sym) {
+              const info = { address: m.collateralAsset.address, symbol: m.collateralAsset.symbol, decimals: m.collateralAsset.decimals };
+              this._dynamicTokenCache.set(sym, info);
+              this._dynamicTokenCache.set(m.collateralAsset.address.toLowerCase(), info);
+              return info;
+            }
+          }
+          for (const m of items) {
+            if (m.loanAsset?.symbol) {
+              const info = { address: m.loanAsset.address, symbol: m.loanAsset.symbol, decimals: m.loanAsset.decimals };
+              this._dynamicTokenCache.set(m.loanAsset.symbol.toUpperCase(), info);
+              this._dynamicTokenCache.set(m.loanAsset.address.toLowerCase(), info);
+            }
+            if (m.collateralAsset?.symbol) {
+              const info = { address: m.collateralAsset.address, symbol: m.collateralAsset.symbol, decimals: m.collateralAsset.decimals };
+              this._dynamicTokenCache.set(m.collateralAsset.symbol.toUpperCase(), info);
+              this._dynamicTokenCache.set(m.collateralAsset.address.toLowerCase(), info);
+            }
+          }
+        } catch (e) {
+          console.warn("[agether] Morpho token search failed:", e instanceof Error ? e.message : e);
+        }
         throw new AgetherError(
-          `Unknown token: ${symbolOrAddress}. Use a known symbol (USDC, WETH, wstETH, cbETH) or a 0x address.`,
+          `Unknown token: ${symbolOrAddress}. No Morpho market found with this token.`,
           "UNKNOWN_TOKEN"
         );
       }

package/dist/index.d.mts

@@ -252,7 +252,7 @@ declare class AgetherClient {
     getBalances(): Promise<BalancesResult>;
     /**
      * Fund the Safe account with USDC from EOA.
-     * This is a simple ERC-20 transfer (does NOT require a UserOp).
+     * @deprecated Use `fundAccountToken('USDC', amount)` instead.
      */
     fundAccount(usdcAmount: string): Promise<TransactionResult>;
     /**
@@ -270,6 +270,54 @@ declare class AgetherClient {
      * @param amount - ETH amount (e.g. '0.01' or 'all')
      */
     withdrawEth(amount: string): Promise<WithdrawFromAccountResult>;
+    /**
+     * Fund the AgentAccount with any ERC-20 token from EOA.
+     * Simple ERC-20 transfer (does NOT require a UserOp).
+     *
+     * @param tokenSymbol - Token symbol (e.g. 'USDC', 'WETH') or 0x address
+     * @param amount - Amount to send (human-readable, e.g. '100')
+     */
+    fundAccountToken(tokenSymbol: string, amount: string): Promise<TransactionResult>;
+    /**
+     * Transfer any ERC-20 token from AgentAccount to any address or agent.
+     * Executes via Safe UserOp (ERC-7579 single execution).
+     *
+     * @param tokenSymbol - Token symbol (e.g. 'USDC', 'WETH') or 0x address
+     * @param amount - Amount to send (e.g. '100' or 'all')
+     * @param to - Destination: `{ address: '0x...' }` or `{ agentId: '42' }`
+     */
+    transferToken(tokenSymbol: string, amount: string, to: {
+        address?: string;
+        agentId?: string;
+    }): Promise<WithdrawFromAccountResult>;
+    /**
+     * Transfer ETH from AgentAccount to any address or agent.
+     * Executes via Safe UserOp.
+     *
+     * @param amount - ETH amount (e.g. '0.01' or 'all')
+     * @param to - Destination: `{ address: '0x...' }` or `{ agentId: '42' }`
+     */
+    transferEth(amount: string, to: {
+        address?: string;
+        agentId?: string;
+    }): Promise<WithdrawFromAccountResult>;
+    /**
+     * Approve a spender to use ERC-20 tokens from the AgentAccount.
+     * Executes via Safe UserOp (ERC-7579 single execution).
+     *
+     * @param tokenSymbol - Token symbol (e.g. 'USDC', 'WETH') or 0x address
+     * @param amount - Allowance amount (e.g. '1000' or 'max' for uint256 max)
+     * @param spender - Spender: `{ address: '0x...' }` or `{ agentId: '42' }`
+     */
+    approveToken(tokenSymbol: string, amount: string, spender: {
+        address?: string;
+        agentId?: string;
+    }): Promise<{
+        tx: string;
+        token: string;
+        amount: string;
+        spender: string;
+    }>;
     /**
      * Send tokens to another agent's Safe account (or any address).
      * Transfers from EOA (does NOT require a UserOp).
@@ -324,11 +372,14 @@ declare class AgetherClient {
     /**
      * Resolve a token symbol or address to { address, symbol, decimals }.
      *
-     * Supports:
-     * - `'USDC'` → from chain config
-     * - Well-known symbols (`'WETH'`, `'wstETH'`, `'cbETH'`) → built-in per-chain registry
-     * - `'0x...'` address → reads decimals and symbol onchain
+     * Resolution order:
+     * 1. `'USDC'` → from chain config (instant)
+     * 2. Well-known symbols (`'WETH'`, `'wstETH'`, `'cbETH'`) → built-in per-chain registry (instant)
+     * 3. Dynamic cache populated by previous Morpho API lookups (instant)
+     * 4. `'0x...'` address → reads decimals and symbol onchain
+     * 5. Morpho GraphQL `search` API → discovers any token across all Morpho markets
      */
+    private _dynamicTokenCache;
     private _resolveToken;
     /**
      * Refresh signer and rebind contracts for fresh nonce.
@@ -575,7 +626,10 @@ declare class MorphoClient {
     /** Read onchain position for a specific market. */
     getPosition(marketId: string): Promise<MorphoPosition>;
     /**
-     * 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.
      */
     getStatus(): Promise<StatusResult>;
     /**