@agether/sdk 2.14.1 → 2.15.0

package/dist/cli.js

@@ -2236,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 },
@@ -2260,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;
@@ -2544,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)
@@ -2610,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
       // ════════════════════════════════════════════════════════
       /**
@@ -2738,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 };
@@ -2753,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(
@@ -2761,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}`,
@@ -2769,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.

package/dist/index.d.ts

@@ -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.

package/dist/index.js

@@ -75,6 +75,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/clients/AgetherClient.ts
 var import_ethers = require("ethers");
+var import_axios = __toESM(require("axios"));
 
 // src/types/index.ts
 var ChainId = /* @__PURE__ */ ((ChainId3) => {
@@ -371,6 +372,7 @@ function getContractAddresses(chainId) {
 // src/clients/AgetherClient.ts
 var MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var erc20Iface = new import_ethers.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 },
@@ -385,6 +387,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;
@@ -669,21 +682,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 import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this.signer);
-    const amount = import_ethers.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)
@@ -735,6 +737,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 import_ethers.Contract(tokenInfo.address, ERC20_ABI, this.signer);
+    const weiAmount = import_ethers.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_ethers.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_ethers.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_ethers.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_ethers.ethers.parseUnits(amount, tokenInfo.decimals);
+    }
+    const data = erc20Iface.encodeFunctionData("transfer", [toAddr, weiAmount]);
+    const receipt = await this._exec(tokenInfo.address, data);
+    const actualAmount = amount === "all" ? import_ethers.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_ethers.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_ethers.ethers.parseEther(amount);
+    }
+    const receipt = await this._exec(toAddr, "0x", weiAmount);
+    const actualAmount = amount === "all" ? import_ethers.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_ethers.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_ethers.ethers.MaxUint256;
+    } else {
+      weiAmount = import_ethers.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
   // ════════════════════════════════════════════════════════
   /**
@@ -863,14 +997,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 };
@@ -878,6 +1004,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 import_ethers.Contract(
@@ -886,7 +1015,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}`,
@@ -894,8 +1026,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 import_axios.default.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"
     );
   }
@@ -1029,8 +1206,8 @@ var AgetherClient = class _AgetherClient {
 
 // src/clients/MorphoClient.ts
 var import_ethers2 = require("ethers");
-var import_axios = __toESM(require("axios"));
-var MORPHO_API_URL = "https://api.morpho.org/graphql";
+var import_axios2 = __toESM(require("axios"));
+var MORPHO_API_URL2 = "https://api.morpho.org/graphql";
 var MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
 var morphoIface = new import_ethers2.ethers.Interface(MORPHO_BLUE_ABI);
@@ -1176,7 +1353,7 @@ var MorphoClient = class {
       }
     }`;
     try {
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const resp = await import_axios2.default.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
       const items = resp.data?.data?.markets?.items ?? [];
       this._discoveredMarkets = items.map((m) => ({
         uniqueKey: m.uniqueKey,
@@ -1360,7 +1537,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query: posQuery }, { timeout: 15e3 });
+      const resp = await import_axios2.default.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");
@@ -1579,7 +1756,7 @@ var MorphoClient = class {
       }
     }`;
     try {
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const resp = await import_axios2.default.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
       let items = resp.data?.data?.markets?.items ?? [];
       if (searchTerm && collateralSymbolOrAddress && !collateralSymbolOrAddress.startsWith("0x")) {
         const sym = collateralSymbolOrAddress.toUpperCase();
@@ -1645,7 +1822,7 @@ var MorphoClient = class {
       }
     }`;
     try {
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const resp = await import_axios2.default.post(MORPHO_API_URL2, { query }, { timeout: 1e4 });
       let items = resp.data?.data?.markets?.items ?? [];
       items = items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== import_ethers2.ethers.ZeroAddress);
       const searchUpper = search.toUpperCase();
@@ -2038,7 +2215,7 @@ var MorphoClient = class {
         }
       }
     }`;
-    const posResp = await import_axios.default.post(MORPHO_API_URL, { query: positionsQuery }, { timeout: 15e3 });
+    const posResp = await import_axios2.default.post(MORPHO_API_URL2, { query: positionsQuery }, { timeout: 15e3 });
     const user = posResp.data?.data?.userByAddress;
     if (!user?.marketPositions) return [];
     const activePositions = user.marketPositions.filter(
@@ -2732,7 +2909,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query: posQuery }, { timeout: 1e4 });
+      const resp = await import_axios2.default.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) {
@@ -2800,7 +2977,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query: posQuery }, { timeout: 1e4 });
+      const resp = await import_axios2.default.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) {
@@ -2952,7 +3129,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await import_axios.default.post(MORPHO_API_URL, { query: txQuery }, { timeout: 15e3 });
+      const resp = await import_axios2.default.post(MORPHO_API_URL2, { query: txQuery }, { timeout: 15e3 });
       const txData = resp.data?.data?.transactions;
       if (!txData?.items) break;
       for (const tx of txData.items) {
@@ -2977,7 +3154,7 @@ var MorphoClient = class {
 };
 
 // src/clients/ScoringClient.ts
-var import_axios2 = __toESM(require("axios"));
+var import_axios3 = __toESM(require("axios"));
 
 // src/clients/X402Client.ts
 var import_fetch = require("@x402/fetch");
@@ -3339,7 +3516,7 @@ var ScoringClient = class {
   constructor(config) {
     this.endpoint = config.endpoint;
     this.defaultChainId = config.chainId;
-    this.client = import_axios2.default.create({
+    this.client = import_axios3.default.create({
       baseURL: config.endpoint,
       headers: { "Content-Type": "application/json" },
       timeout: 3e4

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,
@@ -1285,7 +1462,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await axios.post(MORPHO_API_URL, { query: posQuery }, { timeout: 15e3 });
+      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");
@@ -1504,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();
@@ -1570,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();
@@ -1963,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(
@@ -2657,7 +2834,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await axios.post(MORPHO_API_URL, { query: posQuery }, { timeout: 1e4 });
+      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) {
@@ -2725,7 +2902,7 @@ var MorphoClient = class {
           }
         }
       }`;
-      const resp = await axios.post(MORPHO_API_URL, { query: posQuery }, { timeout: 1e4 });
+      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) {
@@ -2877,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) {
@@ -2902,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";
@@ -3264,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.1",
+  "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",