@agether/sdk 2.14.0 → 2.15.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
 // src/clients/AgetherClient.ts
 import { ethers, Contract } from "ethers";
+import axios from "axios";
 
 // src/types/index.ts
 var ChainId = /* @__PURE__ */ ((ChainId3) => {
@@ -296,6 +297,7 @@ function getContractAddresses(chainId) {
 // src/clients/AgetherClient.ts
 var MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var erc20Iface = new ethers.Interface(ERC20_ABI);
+var MORPHO_API_URL = "https://api.morpho.org/graphql";
 var KNOWN_TOKENS = {
   [8453 /* Base */]: {
     WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
@@ -310,6 +312,17 @@ var KNOWN_TOKENS = {
 };
 var 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;
@@ -594,21 +607,10 @@ var AgetherClient = class _AgetherClient {
   }
   /**
    * 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 Contract(this.config.contracts.usdc, ERC20_ABI, this.signer);
-    const amount = 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)
@@ -660,6 +662,138 @@ var AgetherClient = class _AgetherClient {
     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 Contract(tokenInfo.address, ERC20_ABI, this.signer);
+    const weiAmount = ethers.parseUnits(amount, tokenInfo.decimals);
+    const eoaBalance = await tokenContract.balanceOf(await this._getSignerAddress());
+    if (eoaBalance < weiAmount) {
+      throw new AgetherError(
+        `Insufficient ${tokenInfo.symbol}. EOA has ${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 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 === 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 = ethers.parseUnits(amount, tokenInfo.decimals);
+    }
+    const data = erc20Iface.encodeFunctionData("transfer", [toAddr, weiAmount]);
+    const receipt = await this._exec(tokenInfo.address, data);
+    const actualAmount = amount === "all" ? 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 === 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 = ethers.parseEther(amount);
+    }
+    const receipt = await this._exec(toAddr, "0x", weiAmount);
+    const actualAmount = amount === "all" ? 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 === 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 = ethers.MaxUint256;
+    } else {
+      weiAmount = ethers.parseUnits(amount, tokenInfo.decimals);
+    }
+    const data = erc20Iface.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
   // ════════════════════════════════════════════════════════
   /**
@@ -788,14 +922,6 @@ var AgetherClient = class _AgetherClient {
     }
     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 };
@@ -803,6 +929,9 @@ var AgetherClient = class _AgetherClient {
     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 Contract(
@@ -811,7 +940,10 @@ var AgetherClient = class _AgetherClient {
           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}`,
@@ -819,8 +951,53 @@ var AgetherClient = class _AgetherClient {
         );
       }
     }
+    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 axios.post(MORPHO_API_URL, { 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"
     );
   }
@@ -954,8 +1131,8 @@ var AgetherClient = class _AgetherClient {
 
 // src/clients/MorphoClient.ts
 import { ethers as ethers2, Contract as Contract2 } from "ethers";
-import axios from "axios";
-var MORPHO_API_URL = "https://api.morpho.org/graphql";
+import axios2 from "axios";
+var MORPHO_API_URL2 = "https://api.morpho.org/graphql";
 var MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
 var morphoIface = new ethers2.Interface(MORPHO_BLUE_ABI);
@@ -1101,7 +1278,7 @@ var MorphoClient = class {
       }
     }`;
     try {
-      const resp = await axios.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const resp = await axios2.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
       const items = resp.data?.data?.markets?.items ?? [];
       this._discoveredMarkets = items.map((m) => ({
         uniqueKey: m.uniqueKey,
@@ -1186,7 +1363,7 @@ var MorphoClient = class {
           const resolved = await this._resolveToken(loanTokenSymbolOrAddress);
           loanAddr = resolved.address.toLowerCase();
         } catch {
-          loanAddr = loanTokenSymbolOrAddress.toLowerCase();
+          loanAddr = void 0;
         }
       }
     }
@@ -1194,6 +1371,7 @@ var MorphoClient = class {
     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,
@@ -1204,9 +1382,22 @@ var MorphoClient = class {
     }
     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);
       }
     }
@@ -1240,26 +1431,54 @@ var MorphoClient = class {
     };
   }
   /**
-   * 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 === ethers2.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 axios2.post(MORPHO_API_URL2, { 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(ethers2.formatUnits(debt, loanDecimals));
           } catch (e) {
             console.warn(`[agether] debt calc failed for market ${m.uniqueKey}:`, e instanceof Error ? e.message : e);
@@ -1269,14 +1488,46 @@ var MorphoClient = class {
           marketId: m.uniqueKey,
           collateralToken: m.collateralAsset.symbol,
           loanToken: m.loanAsset.symbol,
-          collateral: ethers2.formatUnits(pos.collateral, m.collateralAsset.decimals),
-          borrowShares: pos.borrowShares.toString(),
-          supplyShares: pos.supplyShares.toString(),
+          collateral: ethers2.formatUnits(collateral, m.collateralAsset.decimals),
+          borrowShares: borrowShares.toString(),
+          supplyShares: supplyShares.toString(),
           debt: ethers2.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 === ethers2.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(ethers2.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: ethers2.formatUnits(pos.collateral, m.collateralAsset.decimals),
+            borrowShares: pos.borrowShares.toString(),
+            supplyShares: pos.supplyShares.toString(),
+            debt: ethers2.formatUnits(debt, loanDecimals)
+          });
+        } catch (e2) {
+          console.warn(`[agether] position read failed:`, e2 instanceof Error ? e2.message : e2);
+          continue;
+        }
       }
     }
     return {
@@ -1430,7 +1681,7 @@ var MorphoClient = class {
       }
     }`;
     try {
-      const resp = await axios.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const resp = await axios2.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
       let items = resp.data?.data?.markets?.items ?? [];
       if (searchTerm && collateralSymbolOrAddress && !collateralSymbolOrAddress.startsWith("0x")) {
         const sym = collateralSymbolOrAddress.toUpperCase();
@@ -1496,7 +1747,7 @@ var MorphoClient = class {
       }
     }`;
     try {
-      const resp = await axios.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const resp = await axios2.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
       let items = resp.data?.data?.markets?.items ?? [];
       items = items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== ethers2.ZeroAddress);
       const searchUpper = search.toUpperCase();
@@ -1889,7 +2140,7 @@ var MorphoClient = class {
         }
       }
     }`;
-    const posResp = await axios.post(MORPHO_API_URL, { query: positionsQuery }, { timeout: 15e3 });
+    const posResp = await axios2.post(MORPHO_API_URL2, { query: positionsQuery }, { timeout: 15e3 });
     const user = posResp.data?.data?.userByAddress;
     if (!user?.marketPositions) return [];
     const activePositions = user.marketPositions.filter(
@@ -2563,6 +2814,46 @@ var MorphoClient = class {
   /** 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 axios2.post(MORPHO_API_URL2, { 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 === ethers2.ZeroAddress) continue;
@@ -2591,6 +2882,46 @@ var MorphoClient = class {
   /** 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 axios2.post(MORPHO_API_URL2, { 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 === ethers2.ZeroAddress) continue;
@@ -2723,7 +3054,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await axios.post(MORPHO_API_URL, { query: txQuery }, { timeout: 15e3 });
+      const resp = await axios2.post(MORPHO_API_URL2, { query: txQuery }, { timeout: 15e3 });
       const txData = resp.data?.data?.transactions;
       if (!txData?.items) break;
       for (const tx of txData.items) {
@@ -2748,7 +3079,7 @@ var MorphoClient = class {
 };
 
 // src/clients/ScoringClient.ts
-import axios2 from "axios";
+import axios3 from "axios";
 
 // src/clients/X402Client.ts
 import { wrapFetchWithPayment } from "@x402/fetch";
@@ -3110,7 +3441,7 @@ var ScoringClient = class {
   constructor(config) {
     this.endpoint = config.endpoint;
     this.defaultChainId = config.chainId;
-    this.client = axios2.create({
+    this.client = axios3.create({
       baseURL: config.endpoint,
       headers: { "Content-Type": "application/json" },
       timeout: 3e4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/sdk",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "TypeScript SDK for Agether - autonomous credit for AI agents on Ethereum & Base",
   "main": "dist/index.js",
   "module": "dist/index.mjs",