@agether/sdk 2.15.1 → 2.16.1

package/dist/clients/MorphoClient.js

@@ -1,1974 +0,0 @@
-/**
- * MorphoClient — Morpho Blue lending only (supply, borrow, repay, withdraw collateral)
- *
- * For registration, identity, balances, withdrawals, and sponsorship, use AgetherClient.
- *
- * Architecture (v2 — Safe + Safe7579):
- *   EOA signs UserOp → EntryPoint.handleOps() → Safe → Safe7579 → execute → Morpho Blue
- *
- * ERC-7579 execution modes (same encoding, submitted via UserOp):
- *   - Single: execute(MODE_SINGLE, abi.encode(target, value, callData))
- *   - Batch:  execute(MODE_BATCH, abi.encode(Execution[]))
- *
- * The Safe account has a sentinel owner (no execTransaction).
- * All state-changing operations go through ERC-4337 EntryPoint v0.7.
- *
- * Market discovery via Morpho GraphQL API (https://api.morpho.org/graphql)
- *
- * Supports two signing modes:
- *   - `privateKey`: SDK manages wallet lifecycle (existing behavior)
- *   - `signer`: external signer (Bankr, Privy, Turnkey, MetaMask, etc.)
- */
-import { ethers, Contract } from 'ethers';
-import axios from 'axios';
-import { AgetherError, ChainId, } from '../types';
-import { ACCOUNT_FACTORY_ABI, SAFE7579_ACCOUNT_ABI, MORPHO_BLUE_ABI, ERC20_ABI, ENTRYPOINT_V07_ABI, } from '../utils/abis';
-import { getDefaultConfig } from '../utils/config';
-const MORPHO_API_URL = 'https://api.morpho.org/graphql';
-// ── ERC-7579 Execution Mode Constants ──
-/** Single call: callType=0x00, execType=0x00, rest zero-padded to 32 bytes */
-const MODE_SINGLE = '0x0000000000000000000000000000000000000000000000000000000000000000';
-/** Batch call: callType=0x01, execType=0x00, rest zero-padded to 32 bytes */
-const MODE_BATCH = '0x0100000000000000000000000000000000000000000000000000000000000000';
-// ── Morpho ABI interfaces for encoding ──
-const morphoIface = new ethers.Interface(MORPHO_BLUE_ABI);
-const erc20Iface = new ethers.Interface(ERC20_ABI);
-// ── Client ──
-export class MorphoClient {
-    constructor(config) {
-        /** Market params cache: keyed by market uniqueKey (bytes32 hash) */
-        this._marketCache = new Map();
-        /** Dynamic token registry: symbol (uppercase) or address (lowercase) → { address, symbol, decimals } */
-        this._tokenCache = new Map();
-        this._discoveredAt = 0;
-        if (!config.agentId) {
-            throw new AgetherError('agentId is required. Use AgetherClient.register() first to get an agentId.', 'NO_AGENT_ID');
-        }
-        const chainId = config.chainId ?? ChainId.Ethereum;
-        const defaultCfg = getDefaultConfig(chainId);
-        this.config = defaultCfg;
-        this.agentId = config.agentId;
-        this._rpcUrl = config.rpcUrl || defaultCfg.rpcUrl;
-        if ('signer' in config && config.signer) {
-            // ── External signer path ──
-            this._useExternalSigner = true;
-            const signerProvider = config.signer.provider;
-            if (signerProvider) {
-                // Signer already has a provider — use it
-                this.provider = signerProvider;
-                this._signer = config.signer;
-            }
-            else {
-                // Signer has no provider — create one from rpcUrl and connect
-                this.provider = new ethers.JsonRpcProvider(this._rpcUrl);
-                this._signer = config.signer.connect(this.provider);
-            }
-            // Try to cache address synchronously (works for ethers.Wallet and similar)
-            if ('address' in config.signer && typeof config.signer.address === 'string') {
-                this._eoaAddress = config.signer.address;
-            }
-        }
-        else {
-            // ── Private key path (existing behavior) ──
-            this._privateKey = config.privateKey;
-            this._useExternalSigner = false;
-            this.provider = new ethers.JsonRpcProvider(this._rpcUrl);
-            const wallet = new ethers.Wallet(this._privateKey, this.provider);
-            this._signer = wallet;
-            this._eoaAddress = wallet.address;
-        }
-        const addrs = { ...defaultCfg.contracts, ...config.contracts };
-        this.agether4337Factory = new Contract(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
-        this.morphoBlue = new Contract(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
-        this.entryPoint = new Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-    }
-    // ════════════════════════════════════════════════════════
-    //  Account Management
-    // ════════════════════════════════════════════════════════
-    /** Resolve the AgentAccount address (cached, with retry for flaky RPCs). */
-    async getAccountAddress() {
-        if (this._accountAddress)
-            return this._accountAddress;
-        const MAX_RETRIES = 3;
-        let lastErr;
-        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-            try {
-                const addr = await this.agether4337Factory.getAccount(BigInt(this.agentId));
-                if (addr === ethers.ZeroAddress) {
-                    throw new AgetherError('No AgentAccount found. Call register() first.', 'NO_ACCOUNT');
-                }
-                this._accountAddress = addr;
-                return addr;
-            }
-            catch (err) {
-                // Don't retry application-level errors (NO_ACCOUNT)
-                if (err instanceof AgetherError)
-                    throw err;
-                lastErr = err;
-                if (attempt < MAX_RETRIES) {
-                    await new Promise((r) => setTimeout(r, 500 * attempt)); // backoff
-                }
-            }
-        }
-        throw lastErr;
-    }
-    getAgentId() {
-        return this.agentId;
-    }
-    /**
-     * Get the EOA wallet address (synchronous, best-effort).
-     *
-     * For the `privateKey` path this always works. For the `signer` path
-     * it works if the signer exposes `.address` synchronously (e.g. ethers.Wallet).
-     * If the address has not been resolved yet, throws — call `getSignerAddress()` first.
-     */
-    getWalletAddress() {
-        if (this._eoaAddress)
-            return this._eoaAddress;
-        // Try sync access for Wallet-like signers
-        const signer = this._signer;
-        if (signer.address && typeof signer.address === 'string') {
-            const addr = signer.address;
-            this._eoaAddress = addr;
-            return addr;
-        }
-        throw new AgetherError('EOA address not yet resolved. Call getSignerAddress() (async) first, or use a signer that exposes .address synchronously.', 'ADDRESS_NOT_RESOLVED');
-    }
-    /**
-     * Resolve the EOA signer address (async, works with all signer types).
-     * Result is cached after the first call.
-     */
-    async getSignerAddress() {
-        if (!this._eoaAddress) {
-            this._eoaAddress = await this._signer.getAddress();
-        }
-        return this._eoaAddress;
-    }
-    // ════════════════════════════════════════════════════════
-    //  Market Discovery (Morpho GraphQL API)
-    // ════════════════════════════════════════════════════════
-    /**
-     * Fetch available markets on the current chain from Morpho API.
-     * Caches results for 5 minutes. Supports all loan tokens (not just USDC).
-     *
-     * @param forceRefresh - bypass cache TTL
-     * @param filter - optional filter by loan token and/or collateral token
-     */
-    async getMarkets(forceRefresh = false, filter) {
-        if (!forceRefresh && this._discoveredMarkets && Date.now() - this._discoveredAt < 300000) {
-            return filter ? this._applyMarketFilter(this._discoveredMarkets, filter) : this._discoveredMarkets;
-        }
-        const chainId = this.config.chainId;
-        const query = `{
-      markets(
-        first: 500
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}] }
-      ) {
-        items {
-          uniqueKey
-          lltv
-          oracleAddress
-          irmAddress
-          loanAsset { address symbol decimals }
-          collateralAsset { address symbol decimals }
-          state {
-            borrowAssets
-            supplyAssets
-            utilization
-          }
-        }
-      }
-    }`;
-        try {
-            const resp = await axios.post(MORPHO_API_URL, { query }, { timeout: 10000 });
-            const items = resp.data?.data?.markets?.items ?? [];
-            this._discoveredMarkets = items.map((m) => ({
-                uniqueKey: m.uniqueKey,
-                loanAsset: m.loanAsset,
-                collateralAsset: m.collateralAsset ?? { address: ethers.ZeroAddress, symbol: 'N/A', decimals: 0 },
-                oracle: m.oracleAddress,
-                irm: m.irmAddress,
-                lltv: BigInt(m.lltv),
-                totalSupplyAssets: BigInt(m.state?.supplyAssets ?? '0'),
-                totalBorrowAssets: BigInt(m.state?.borrowAssets ?? '0'),
-                utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
-            }));
-            this._discoveredAt = Date.now();
-            // Warm the params cache (keyed by uniqueKey) and token cache
-            for (const mi of this._discoveredMarkets) {
-                // Cache market params by uniqueKey
-                this._marketCache.set(mi.uniqueKey.toLowerCase(), {
-                    loanToken: mi.loanAsset.address,
-                    collateralToken: mi.collateralAsset.address,
-                    oracle: mi.oracle,
-                    irm: mi.irm,
-                    lltv: mi.lltv,
-                });
-                if (mi.collateralAsset.address !== ethers.ZeroAddress) {
-                    // Register collateral token (keyed by uppercase symbol)
-                    this._tokenCache.set(mi.collateralAsset.symbol.toUpperCase(), {
-                        address: mi.collateralAsset.address,
-                        symbol: mi.collateralAsset.symbol,
-                        decimals: mi.collateralAsset.decimals,
-                    });
-                    // Also register by lowercase address for reverse lookups
-                    this._tokenCache.set(mi.collateralAsset.address.toLowerCase(), {
-                        address: mi.collateralAsset.address,
-                        symbol: mi.collateralAsset.symbol,
-                        decimals: mi.collateralAsset.decimals,
-                    });
-                }
-                // Register loan token too
-                if (mi.loanAsset.address !== ethers.ZeroAddress) {
-                    this._tokenCache.set(mi.loanAsset.symbol.toUpperCase(), {
-                        address: mi.loanAsset.address,
-                        symbol: mi.loanAsset.symbol,
-                        decimals: mi.loanAsset.decimals,
-                    });
-                    this._tokenCache.set(mi.loanAsset.address.toLowerCase(), {
-                        address: mi.loanAsset.address,
-                        symbol: mi.loanAsset.symbol,
-                        decimals: mi.loanAsset.decimals,
-                    });
-                }
-            }
-            return filter ? this._applyMarketFilter(this._discoveredMarkets, filter) : this._discoveredMarkets;
-        }
-        catch (e) {
-            console.warn('[agether] getMarkets failed, using cache:', e instanceof Error ? e.message : e);
-            // Fallback: return cached or empty
-            const cached = this._discoveredMarkets ?? [];
-            return filter ? this._applyMarketFilter(cached, filter) : cached;
-        }
-    }
-    /**
-     * Get MarketParams for a collateral token (and optionally a specific loan token).
-     * Tries cache → API discovery.
-     *
-     * When `loanTokenSymbolOrAddress` is omitted, returns the most liquid market
-     * for that collateral (sorted by supply, typically the USDC market).
-     *
-     * @param collateralSymbolOrAddress - e.g. 'WETH', 'wstETH', or '0x4200...'
-     * @param loanTokenSymbolOrAddress - e.g. 'USDC', 'WETH', or '0x833589...' (optional)
-     */
-    async findMarketForCollateral(collateralSymbolOrAddress, loanTokenSymbolOrAddress) {
-        // Resolve collateral symbol → address
-        let colAddr;
-        if (collateralSymbolOrAddress.startsWith('0x')) {
-            colAddr = collateralSymbolOrAddress.toLowerCase();
-        }
-        else {
-            try {
-                const resolved = await this._resolveToken(collateralSymbolOrAddress);
-                colAddr = resolved.address.toLowerCase();
-            }
-            catch {
-                colAddr = collateralSymbolOrAddress.toLowerCase();
-            }
-        }
-        // Resolve loan token symbol → address (if provided)
-        let loanAddr;
-        if (loanTokenSymbolOrAddress) {
-            if (loanTokenSymbolOrAddress.startsWith('0x')) {
-                loanAddr = loanTokenSymbolOrAddress.toLowerCase();
-            }
-            else {
-                try {
-                    const resolved = await this._resolveToken(loanTokenSymbolOrAddress);
-                    loanAddr = resolved.address.toLowerCase();
-                }
-                catch {
-                    loanAddr = loanTokenSymbolOrAddress.toLowerCase();
-                }
-            }
-        }
-        // Ensure markets are loaded
-        if (!this._discoveredMarkets)
-            await this.getMarkets();
-        // Search through discovered markets (already sorted by supply descending)
-        for (const m of this._discoveredMarkets ?? []) {
-            if (m.collateralAsset.address.toLowerCase() !== colAddr)
-                continue;
-            if (loanAddr && m.loanAsset.address.toLowerCase() !== loanAddr)
-                continue;
-            return {
-                loanToken: m.loanAsset.address,
-                collateralToken: m.collateralAsset.address,
-                oracle: m.oracle,
-                irm: m.irm,
-                lltv: m.lltv,
-            };
-        }
-        // Fallback: use Morpho search API to find the market (handles tokens
-        // outside the top-500 cache). Resolves the full MarketParams onchain.
-        if (!collateralSymbolOrAddress.startsWith('0x')) {
-            const searched = await this.searchMarkets(collateralSymbolOrAddress, { asCollateral: true });
-            for (const m of searched) {
-                if (loanAddr && m.loanAddress.toLowerCase() !== loanAddr)
-                    continue;
-                if (loanTokenSymbolOrAddress && !loanTokenSymbolOrAddress.startsWith('0x')
-                    && m.loanToken.toUpperCase() !== loanTokenSymbolOrAddress.toUpperCase())
-                    continue;
-                // Resolve full params onchain
-                return this.getMarketParams(m.marketId);
-            }
-        }
-        throw new AgetherError(`No Morpho market found for collateral ${collateralSymbolOrAddress}` +
-            (loanTokenSymbolOrAddress ? ` with loan token ${loanTokenSymbolOrAddress}` : ''), 'MARKET_NOT_FOUND');
-    }
-    /** Read MarketParams onchain by market ID (bytes32). */
-    async getMarketParams(marketId) {
-        const result = await this.morphoBlue.idToMarketParams(marketId);
-        return {
-            loanToken: result.loanToken,
-            collateralToken: result.collateralToken,
-            oracle: result.oracle,
-            irm: result.irm,
-            lltv: result.lltv,
-        };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Position Reads
-    // ════════════════════════════════════════════════════════
-    /** Read onchain position for a specific market. */
-    async getPosition(marketId) {
-        const acctAddr = await this.getAccountAddress();
-        const pos = await this.morphoBlue.position(marketId, acctAddr);
-        return {
-            supplyShares: pos.supplyShares,
-            borrowShares: pos.borrowShares,
-            collateral: pos.collateral,
-        };
-    }
-    /**
-     * Full status: positions across all discovered markets.
-     */
-    async getStatus() {
-        const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
-        const positions = [];
-        let totalDebtFloat = 0;
-        for (const m of markets) {
-            if (!m.collateralAsset || m.collateralAsset.address === 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;
-                // Estimate debt from shares (ceil division — shows actual amount owed, never hides dust)
-                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(ethers.formatUnits(debt, loanDecimals));
-                    }
-                    catch (e) {
-                        console.warn(`[agether] debt calc failed for market ${m.uniqueKey}:`, e instanceof Error ? e.message : e);
-                    }
-                }
-                positions.push({
-                    marketId: m.uniqueKey,
-                    collateralToken: m.collateralAsset.symbol,
-                    loanToken: m.loanAsset.symbol,
-                    collateral: ethers.formatUnits(pos.collateral, m.collateralAsset.decimals),
-                    borrowShares: pos.borrowShares.toString(),
-                    supplyShares: pos.supplyShares.toString(),
-                    debt: ethers.formatUnits(debt, loanDecimals),
-                });
-            }
-            catch (e) {
-                console.warn(`[agether] position read failed for market:`, e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        return {
-            agentId: this.agentId,
-            agentAccount: acctAddr,
-            totalDebt: totalDebtFloat.toFixed(6),
-            positions,
-        };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Balance & Borrowing Capacity
-    // ════════════════════════════════════════════════════════
-    /**
-     * Get the balance of any ERC-20 token in the AgentAccount.
-     * @param symbolOrAddress - token symbol (e.g. 'USDC', 'WETH') or address
-     * @returns balance in raw units
-     */
-    async getTokenBalance(symbolOrAddress) {
-        const acctAddr = await this.getAccountAddress();
-        const tokenInfo = await this._resolveToken(symbolOrAddress);
-        const token = new Contract(tokenInfo.address, ERC20_ABI, this.provider);
-        return token.balanceOf(acctAddr);
-    }
-    /**
-     * Get the USDC balance of the AgentAccount.
-     * @returns USDC balance in raw units (6 decimals)
-     * @deprecated Use `getTokenBalance('USDC')` instead.
-     */
-    async getUsdcBalance() {
-        const acctAddr = await this.getAccountAddress();
-        const usdc = new Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
-        return usdc.balanceOf(acctAddr);
-    }
-    /**
-     * Calculate the maximum additional loan token that can be borrowed
-     * given the agent's current collateral and debt across all markets.
-     *
-     * For each market with collateral deposited:
-     *   maxBorrow = (collateralValue * LLTV) - currentDebt
-     *
-     * Uses the Morpho oracle to price collateral → loan token.
-     *
-     * @returns Maximum additional borrowable per market (raw units in each market's loan token)
-     */
-    async getMaxBorrowable() {
-        const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
-        let totalAdditional = 0n;
-        const byMarket = [];
-        for (const m of markets) {
-            if (!m.collateralAsset || m.collateralAsset.address === ethers.ZeroAddress)
-                continue;
-            try {
-                const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-                if (pos.collateral === 0n)
-                    continue;
-                // Get market state for debt calculation (ceil division for accurate debt)
-                const mktState = await this.morphoBlue.market(m.uniqueKey);
-                const totalBorrowShares = BigInt(mktState.totalBorrowShares);
-                const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
-                const currentDebt = totalBorrowShares > 0n
-                    ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares
-                    : 0n;
-                // Get oracle price for collateral → loan token conversion
-                // Morpho oracle returns price scaled to 36 + loanDecimals - collateralDecimals
-                // price = collateral * oraclePrice / 10^36
-                let collateralValueInLoan;
-                try {
-                    const oracleContract = new Contract(m.oracle, [
-                        'function price() view returns (uint256)',
-                    ], this.provider);
-                    const oraclePrice = await oracleContract.price();
-                    const ORACLE_PRICE_SCALE = 10n ** 36n;
-                    collateralValueInLoan = (BigInt(pos.collateral) * oraclePrice) / ORACLE_PRICE_SCALE;
-                }
-                catch (e) {
-                    console.warn(`[agether] oracle price fetch failed:`, e instanceof Error ? e.message : e);
-                    continue;
-                }
-                // maxBorrow = collateralValue * LLTV / 1e18 - currentDebt
-                const maxBorrowTotal = (collateralValueInLoan * m.lltv) / (10n ** 18n);
-                const maxAdditional = maxBorrowTotal > currentDebt ? maxBorrowTotal - currentDebt : 0n;
-                totalAdditional += maxAdditional;
-                byMarket.push({
-                    collateralToken: m.collateralAsset.symbol,
-                    loanToken: m.loanAsset.symbol,
-                    loanDecimals: m.loanAsset.decimals,
-                    maxAdditional,
-                    currentDebt,
-                    collateralValue: collateralValueInLoan,
-                });
-            }
-            catch (e) {
-                console.warn(`[agether] maxBorrow calc failed:`, e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        return { total: totalAdditional, byMarket };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Market Rates & Yield Estimation
-    // ════════════════════════════════════════════════════════
-    /**
-     * Fetch current supply/borrow APY for markets from Morpho GraphQL API.
-     *
-     * Note: On Morpho Blue, collateral does NOT earn yield directly. Supply APY
-     * is what lenders earn; borrow APY is what borrowers pay.
-     *
-     * @param collateralSymbolOrAddress - filter by collateral token (optional)
-     * @param loanTokenSymbolOrAddress - filter by loan token (optional). Omit for all loan tokens.
-     */
-    async getMarketRates(collateralSymbolOrAddress, loanTokenSymbolOrAddress) {
-        const chainId = this.config.chainId;
-        // Resolve address filters. For symbols, try _resolveToken first, then
-        // fall back to using Morpho GraphQL `search` field (fuzzy match on name).
-        let collateralFilter = '';
-        let loanFilter = '';
-        let searchTerm = '';
-        if (collateralSymbolOrAddress) {
-            if (collateralSymbolOrAddress.startsWith('0x')) {
-                collateralFilter = `, collateralAssetAddress_in: ["${collateralSymbolOrAddress.toLowerCase()}"]`;
-            }
-            else {
-                // Try token cache first
-                const cached = this._tokenCache.get(collateralSymbolOrAddress.toUpperCase());
-                if (cached) {
-                    collateralFilter = `, collateralAssetAddress_in: ["${cached.address.toLowerCase()}"]`;
-                }
-                else {
-                    // Use Morpho's built-in search — no hardcoded addresses needed
-                    searchTerm = collateralSymbolOrAddress;
-                }
-            }
-        }
-        if (loanTokenSymbolOrAddress) {
-            if (loanTokenSymbolOrAddress.startsWith('0x')) {
-                loanFilter = `, loanAssetAddress_in: ["${loanTokenSymbolOrAddress.toLowerCase()}"]`;
-            }
-            else {
-                const cached = this._tokenCache.get(loanTokenSymbolOrAddress.toUpperCase());
-                if (cached) {
-                    loanFilter = `, loanAssetAddress_in: ["${cached.address.toLowerCase()}"]`;
-                }
-                else {
-                    searchTerm = searchTerm || loanTokenSymbolOrAddress;
-                }
-            }
-        }
-        const searchClause = searchTerm ? `, search: "${searchTerm}"` : '';
-        const query = `{
-      markets(
-        first: 100
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}]${loanFilter}${collateralFilter}${searchClause} }
-      ) {
-        items {
-          uniqueKey
-          lltv
-          loanAsset { address symbol decimals }
-          collateralAsset { address symbol decimals }
-          state {
-            borrowAssets
-            supplyAssets
-            utilization
-            supplyApy
-            borrowApy
-          }
-        }
-      }
-    }`;
-        try {
-            const resp = await axios.post(MORPHO_API_URL, { query }, { timeout: 10000 });
-            let items = resp.data?.data?.markets?.items ?? [];
-            // Post-filter: when we used `search` (fuzzy), verify the token actually
-            // matches the requested position (collateral vs loan).
-            if (searchTerm && collateralSymbolOrAddress && !collateralSymbolOrAddress.startsWith('0x')) {
-                const sym = collateralSymbolOrAddress.toUpperCase();
-                items = items.filter((m) => m.collateralAsset?.symbol?.toUpperCase() === sym);
-            }
-            if (searchTerm && loanTokenSymbolOrAddress && !loanTokenSymbolOrAddress.startsWith('0x')) {
-                const sym = loanTokenSymbolOrAddress.toUpperCase();
-                items = items.filter((m) => m.loanAsset?.symbol?.toUpperCase() === sym);
-            }
-            return items
-                .filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== ethers.ZeroAddress)
-                .map((m) => {
-                const loanDecimals = m.loanAsset?.decimals ?? 18;
-                return {
-                    collateralToken: m.collateralAsset.symbol,
-                    loanToken: m.loanAsset.symbol,
-                    loanDecimals,
-                    supplyApy: m.state?.supplyApy ? Number(m.state.supplyApy) : 0,
-                    borrowApy: m.state?.borrowApy ? Number(m.state.borrowApy) : 0,
-                    utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
-                    totalSupplyUsd: m.state?.supplyAssets ? Number(m.state.supplyAssets) / (10 ** loanDecimals) : 0,
-                    totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / (10 ** loanDecimals) : 0,
-                    lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
-                    marketId: m.uniqueKey,
-                };
-            });
-        }
-        catch (e) {
-            console.warn('[agether] getMarketRates failed:', e instanceof Error ? e.message : e);
-            return [];
-        }
-    }
-    // ════════════════════════════════════════════════════════
-    //  Market Search & Wallet Discovery
-    // ════════════════════════════════════════════════════════
-    /**
-     * Search Morpho markets by token name using the Morpho GraphQL API `search` field.
-     * No hardcoded token lists — uses Morpho's built-in fuzzy search.
-     *
-     * @param search - token name or symbol (e.g. 'WETH', 'staked ETH', 'ezETH')
-     * @param options.asCollateral - only return markets where the searched token is collateral
-     * @param options.asLoanToken - only return markets where the searched token is the loan asset
-     */
-    async searchMarkets(search, options) {
-        const chainId = this.config.chainId;
-        const query = `{
-      markets(
-        first: 100
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}], search: "${search}" }
-      ) {
-        items {
-          uniqueKey
-          lltv
-          loanAsset { address symbol decimals }
-          collateralAsset { address symbol decimals }
-          state {
-            borrowAssets
-            supplyAssets
-            utilization
-            supplyApy
-            borrowApy
-          }
-        }
-      }
-    }`;
-        try {
-            const resp = await axios.post(MORPHO_API_URL, { query }, { timeout: 10000 });
-            let items = resp.data?.data?.markets?.items ?? [];
-            // Filter out markets with no collateral (supply-only idle markets)
-            items = items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== ethers.ZeroAddress);
-            // Post-filter by position if requested
-            const searchUpper = search.toUpperCase();
-            if (options?.asCollateral) {
-                items = items.filter((m) => m.collateralAsset?.symbol?.toUpperCase() === searchUpper);
-            }
-            if (options?.asLoanToken) {
-                items = items.filter((m) => m.loanAsset?.symbol?.toUpperCase() === searchUpper);
-            }
-            return items.map((m) => {
-                const loanDecimals = m.loanAsset?.decimals ?? 18;
-                const collateralDecimals = m.collateralAsset?.decimals ?? 18;
-                return {
-                    collateralToken: m.collateralAsset.symbol,
-                    loanToken: m.loanAsset.symbol,
-                    loanDecimals,
-                    collateralDecimals,
-                    supplyApy: m.state?.supplyApy ? Number(m.state.supplyApy) : 0,
-                    borrowApy: m.state?.borrowApy ? Number(m.state.borrowApy) : 0,
-                    utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
-                    totalSupplyUsd: m.state?.supplyAssets ? Number(m.state.supplyAssets) / (10 ** loanDecimals) : 0,
-                    totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / (10 ** loanDecimals) : 0,
-                    lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
-                    marketId: m.uniqueKey,
-                    collateralAddress: m.collateralAsset.address,
-                    loanAddress: m.loanAsset.address,
-                };
-            });
-        }
-        catch (e) {
-            console.warn('[agether] searchMarkets failed:', e instanceof Error ? e.message : e);
-            return [];
-        }
-    }
-    /**
-     * Scan the AgentAccount wallet for all ERC-20 tokens that appear in Morpho
-     * markets on the current chain. Returns tokens where balance > 0.
-     *
-     * Uses the full market list (500 markets) to discover all relevant tokens,
-     * then checks on-chain balance for each unique token address.
-     *
-     * @returns Array of tokens with non-zero balance, sorted by balance descending.
-     */
-    async getWalletTokenBalances() {
-        const acctAddr = await this.getAccountAddress();
-        // Ensure full market set is loaded (populates _tokenCache with all tokens)
-        await this.getMarkets();
-        // Collect unique token addresses from cache
-        const uniqueTokens = new Map();
-        for (const [key, info] of this._tokenCache.entries()) {
-            if (key.startsWith('0x') && !uniqueTokens.has(key)) {
-                uniqueTokens.set(key, info);
-            }
-        }
-        // Also always check ETH balance
-        const results = [];
-        // Check ETH
-        try {
-            const ethBalance = await this.provider.getBalance(acctAddr);
-            if (ethBalance > 0n) {
-                results.push({
-                    symbol: 'ETH',
-                    address: ethers.ZeroAddress,
-                    decimals: 18,
-                    balance: ethBalance,
-                    balanceFormatted: ethers.formatEther(ethBalance),
-                });
-            }
-        }
-        catch { /* ignore */ }
-        // Batch-check ERC-20 balances (parallel, 20 at a time to avoid rate limits)
-        const tokenEntries = Array.from(uniqueTokens.values());
-        const batchSize = 20;
-        for (let i = 0; i < tokenEntries.length; i += batchSize) {
-            const batch = tokenEntries.slice(i, i + batchSize);
-            const checks = batch.map(async (info) => {
-                try {
-                    const token = new Contract(info.address, ERC20_ABI, this.provider);
-                    const balance = await token.balanceOf(acctAddr);
-                    if (balance > 0n) {
-                        return {
-                            symbol: info.symbol,
-                            address: info.address,
-                            decimals: info.decimals,
-                            balance,
-                            balanceFormatted: ethers.formatUnits(balance, info.decimals),
-                        };
-                    }
-                }
-                catch { /* token call failed — skip */ }
-                return null;
-            });
-            const batchResults = await Promise.all(checks);
-            for (const r of batchResults) {
-                if (r)
-                    results.push(r);
-            }
-        }
-        // Sort by balance descending (normalized to avoid cross-decimal comparison issues)
-        results.sort((a, b) => (b.balance > a.balance ? 1 : b.balance < a.balance ? -1 : 0));
-        return results;
-    }
-    /**
-     * Find borrowing opportunities for the agent.
-     *
-     * - If `collateralSymbol` is provided: find all markets where that token is collateral.
-     * - If omitted: scan wallet balances and find markets for each token the agent holds.
-     *
-     * Returns markets grouped by collateral token with APY, liquidity, and balance info.
-     *
-     * @param collateralSymbol - optional, e.g. 'WETH'. If omitted, scans wallet.
-     */
-    async findBorrowingOptions(collateralSymbol) {
-        let tokensToCheck;
-        if (collateralSymbol) {
-            // Single token mode — use search to find markets
-            tokensToCheck = [{ symbol: collateralSymbol, balanceFormatted: 'N/A' }];
-            // Try to get actual balance if possible
-            try {
-                const balance = await this.getTokenBalance(collateralSymbol);
-                const info = await this._resolveToken(collateralSymbol);
-                tokensToCheck = [{ symbol: collateralSymbol, balanceFormatted: ethers.formatUnits(balance, info.decimals) }];
-            }
-            catch { /* use N/A */ }
-        }
-        else {
-            // Wallet scan mode — find all tokens with balance > 0
-            const walletTokens = await this.getWalletTokenBalances();
-            tokensToCheck = walletTokens
-                .filter(t => t.symbol !== 'ETH') // ETH can't be used directly as collateral (need WETH)
-                .map(t => ({ symbol: t.symbol, balanceFormatted: t.balanceFormatted }));
-            if (tokensToCheck.length === 0) {
-                return [];
-            }
-        }
-        const results = [];
-        for (const token of tokensToCheck) {
-            // Use searchMarkets to find markets where this token is collateral
-            const markets = await this.searchMarkets(token.symbol, { asCollateral: true });
-            if (markets.length === 0)
-                continue;
-            results.push({
-                collateralToken: token.symbol,
-                collateralBalance: token.balanceFormatted,
-                markets: markets.map(m => ({
-                    loanToken: m.loanToken,
-                    borrowApy: `${(m.borrowApy * 100).toFixed(2)}%`,
-                    supplyApy: `${(m.supplyApy * 100).toFixed(2)}%`,
-                    lltv: m.lltv,
-                    utilization: `${(m.utilization * 100).toFixed(1)}%`,
-                    availableLiquidity: `$${(m.totalSupplyUsd - m.totalBorrowUsd).toFixed(0)}`,
-                    marketId: m.marketId,
-                })),
-            });
-        }
-        return results;
-    }
-    /**
-     * Find supply/lending opportunities for a specific loan token.
-     *
-     * "What can I supply to earn WETH?" → shows all markets where WETH is the loan token
-     * (user supplies WETH to earn yield from borrowers).
-     *
-     * @param loanTokenSymbol - e.g. 'USDC', 'WETH'
-     */
-    async findSupplyOptions(loanTokenSymbol) {
-        const markets = await this.searchMarkets(loanTokenSymbol, { asLoanToken: true });
-        return markets.map(m => ({
-            collateralToken: m.collateralToken,
-            loanToken: m.loanToken,
-            supplyApy: `${(m.supplyApy * 100).toFixed(2)}%`,
-            borrowApy: `${(m.borrowApy * 100).toFixed(2)}%`,
-            lltv: m.lltv,
-            utilization: `${(m.utilization * 100).toFixed(1)}%`,
-            totalSupply: `$${m.totalSupplyUsd.toFixed(0)}`,
-            marketId: m.marketId,
-        }));
-    }
-    /**
-     * Estimate theoretical yield for a given collateral amount over a period.
-     *
-     * ⚠️ IMPORTANT: On Morpho Blue, collateral does NOT earn yield directly.
-     * This estimates what the collateral WOULD earn if it were instead supplied
-     * as a lender (not used as collateral). This is a theoretical upper bound
-     * useful for setting spending caps.
-     *
-     * @param collateralSymbol - e.g. 'WETH'
-     * @param amount - collateral amount in human-readable (e.g. '1.5')
-     * @param periodDays - estimation period in days (default: 1)
-     * @param ethPriceUsd - ETH price in USD for value conversion (if not provided, uses oracle)
-     * @returns Estimated yield in USD for the period
-     */
-    async getYieldEstimate(collateralSymbol, amount, periodDays = 1, ethPriceUsd) {
-        const colInfo = await this._resolveToken(collateralSymbol);
-        // Get market rates for this collateral
-        const rates = await this.getMarketRates(collateralSymbol);
-        if (rates.length === 0) {
-            throw new AgetherError(`No market found for ${collateralSymbol}`, 'MARKET_NOT_FOUND');
-        }
-        // Use the most liquid market (first one, sorted by supply)
-        const market = rates[0];
-        const supplyApy = market.supplyApy;
-        // Determine collateral value in loan token units (then approximate as USD)
-        let collateralValueUsd;
-        if (ethPriceUsd) {
-            collateralValueUsd = parseFloat(amount) * ethPriceUsd;
-        }
-        else {
-            try {
-                const params = await this.findMarketForCollateral(collateralSymbol);
-                const loanDecimals = await this._getLoanTokenDecimals(params);
-                const oracleContract = new Contract(params.oracle, [
-                    'function price() view returns (uint256)',
-                ], this.provider);
-                const oraclePrice = await oracleContract.price();
-                const ORACLE_PRICE_SCALE = 10n ** 36n;
-                const amountWei = ethers.parseUnits(amount, colInfo.decimals);
-                const valueInLoan = (amountWei * oraclePrice) / ORACLE_PRICE_SCALE;
-                collateralValueUsd = Number(valueInLoan) / (10 ** loanDecimals);
-            }
-            catch (e) {
-                console.warn('[agether] oracle price fetch for yield estimation failed:', e instanceof Error ? e.message : e);
-                throw new AgetherError('Cannot determine collateral value. Provide ethPriceUsd.', 'PRICE_UNAVAILABLE');
-            }
-        }
-        // Calculate yield: value * APY * (days / 365)
-        const estimatedYieldUsd = collateralValueUsd * supplyApy * (periodDays / 365);
-        return {
-            collateralToken: collateralSymbol,
-            amount,
-            periodDays,
-            theoreticalSupplyApy: supplyApy,
-            estimatedYieldUsd,
-            collateralValueUsd,
-            disclaimer: 'Collateral on Morpho Blue does NOT earn yield directly. This estimates what it WOULD earn if supplied as a lender instead. Use as a theoretical spending cap.',
-        };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Supply-Side (Lending) — earn yield by supplying USDC
-    // ════════════════════════════════════════════════════════
-    /**
-     * Supply loan token to a Morpho Blue market as a lender (earn yield).
-     *
-     * Unlike `supplyCollateral` (borrower-side), this is the **lender-side**:
-     * you deposit the loanToken into the market's supply pool and earn
-     * interest paid by borrowers.
-     *
-     * @param amount - Amount of loan token to supply (e.g. '500' for 500 USDC, '0.5' for 0.5 WETH)
-     * @param collateralSymbol - Market collateral token to identify which market (e.g. 'WETH')
-     *                           Optional — defaults to highest-APY market
-     * @param loanTokenSymbol - Loan token to filter market (e.g. 'USDC', 'WETH'). Optional.
-     */
-    async supplyAsset(amount, collateralSymbol, loanTokenSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        // Find market
-        let params;
-        let usedCollateral;
-        if (collateralSymbol) {
-            params = await this.findMarketForCollateral(collateralSymbol, loanTokenSymbol);
-            usedCollateral = collateralSymbol;
-        }
-        else {
-            // Auto-pick highest APY market (optionally filtered by loan token)
-            const rates = await this.getMarketRates(undefined, loanTokenSymbol);
-            if (rates.length === 0)
-                throw new AgetherError('No markets available', 'NO_MARKETS');
-            const best = rates.reduce((a, b) => a.supplyApy > b.supplyApy ? a : b);
-            params = await this.findMarketForCollateral(best.collateralToken, loanTokenSymbol);
-            usedCollateral = best.collateralToken;
-        }
-        // Resolve loan token decimals
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        const loanTokenAddr = params.loanToken;
-        const parsedAmount = ethers.parseUnits(amount, loanDecimals);
-        // Compute marketId for result
-        const marketId = ethers.keccak256(ethers.AbiCoder.defaultAbiCoder().encode(['address', 'address', 'address', 'address', 'uint256'], [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]));
-        // Ensure AgentAccount has enough loan token (transfer shortfall from EOA)
-        const loanContract = new Contract(loanTokenAddr, ERC20_ABI, this._signer);
-        const acctBalance = await loanContract.balanceOf(acctAddr);
-        if (acctBalance < parsedAmount) {
-            const shortfall = parsedAmount - acctBalance;
-            const eoaBalance = await loanContract.balanceOf(await this.getSignerAddress());
-            if (eoaBalance < shortfall) {
-                const loanInfo = this._tokenCache.get(loanTokenAddr.toLowerCase());
-                const loanSymbol = loanInfo?.symbol ?? 'loan token';
-                throw new AgetherError(`Insufficient ${loanSymbol}. Need ${amount}, AgentAccount has ${ethers.formatUnits(acctBalance, loanDecimals)}, EOA has ${ethers.formatUnits(eoaBalance, loanDecimals)}.`, 'INSUFFICIENT_BALANCE');
-            }
-            const transferTx = await loanContract.transfer(acctAddr, shortfall);
-            await transferTx.wait();
-            this._refreshSigner();
-        }
-        // Batch: approve loan token → supply(marketParams, assets, 0, onBehalf, "0x")
-        const targets = [loanTokenAddr, morphoAddr];
-        const values = [0n, 0n];
-        const datas = [
-            erc20Iface.encodeFunctionData('approve', [morphoAddr, parsedAmount]),
-            morphoIface.encodeFunctionData('supply', [
-                this._toTuple(params), parsedAmount, 0n, acctAddr, '0x',
-            ]),
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        return {
-            tx: receipt.hash,
-            amount,
-            marketId,
-            collateralToken: usedCollateral,
-            agentAccount: acctAddr,
-        };
-    }
-    /**
-     * Withdraw supplied USDC (+ earned interest) from a Morpho Blue market.
-     *
-     * @param usdcAmount - Amount to withdraw (e.g. '100' or 'all' for full position)
-     * @param collateralSymbol - Market collateral to identify which market
-     * @param receiver - Destination address (defaults to EOA)
-     */
-    /**
-     * Withdraw supplied loan token (+ earned interest) from a Morpho Blue market.
-     *
-     * @param amount - Amount to withdraw (e.g. '100' or 'all' for full position)
-     * @param collateralSymbol - Market collateral to identify which market
-     * @param receiver - Destination address (defaults to EOA)
-     * @param loanTokenSymbol - Loan token to filter market (optional)
-     */
-    async withdrawSupply(amount, collateralSymbol, receiver, loanTokenSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const dest = receiver || await this.getSignerAddress();
-        // Find market
-        let params;
-        if (collateralSymbol) {
-            params = await this.findMarketForCollateral(collateralSymbol, loanTokenSymbol);
-        }
-        else {
-            // Find first market with supply position
-            const { params: p } = await this._findActiveSupplyMarket();
-            params = p;
-        }
-        // Resolve loan token decimals
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        const marketId = ethers.keccak256(ethers.AbiCoder.defaultAbiCoder().encode(['address', 'address', 'address', 'address', 'uint256'], [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]));
-        let withdrawAssets;
-        let withdrawShares;
-        if (amount === 'all') {
-            // Shares-based withdraw to avoid dust
-            const pos = await this.morphoBlue.position(marketId, acctAddr);
-            withdrawShares = BigInt(pos.supplyShares);
-            withdrawAssets = 0n;
-            if (withdrawShares === 0n)
-                throw new AgetherError('No supply position to withdraw', 'NO_SUPPLY');
-        }
-        else {
-            withdrawAssets = ethers.parseUnits(amount, loanDecimals);
-            withdrawShares = 0n;
-        }
-        // withdraw(marketParams, assets, shares, onBehalf, receiver)
-        const data = morphoIface.encodeFunctionData('withdraw', [
-            this._toTuple(params), withdrawAssets, withdrawShares, acctAddr, dest,
-        ]);
-        const receipt = await this.exec(morphoAddr, data);
-        // Read remaining supply
-        let remainingSupply = '0';
-        try {
-            const pos = await this.morphoBlue.position(marketId, acctAddr);
-            const mkt = await this.morphoBlue.market(marketId);
-            const totalSupplyAssets = BigInt(mkt.totalSupplyAssets);
-            const totalSupplyShares = BigInt(mkt.totalSupplyShares);
-            const currentAssets = totalSupplyShares > 0n
-                ? (BigInt(pos.supplyShares) * totalSupplyAssets) / totalSupplyShares
-                : 0n;
-            remainingSupply = ethers.formatUnits(currentAssets, loanDecimals);
-        }
-        catch (e) {
-            console.warn('[agether] failed to read remaining supply:', e instanceof Error ? e.message : e);
-        }
-        return {
-            tx: receipt.hash,
-            amount,
-            remainingSupply,
-            destination: dest,
-        };
-    }
-    /**
-     * Get supply (lending) positions with yield tracking.
-     *
-     * Uses Morpho GraphQL API (no eth_getLogs / no DB / no indexer):
-     *   1. `userByAddress` → all market positions with current supplyAssets, supplyApy
-     *   2. `transactions` → all MarketSupply/MarketWithdraw history for net deposited
-     *   3. earnedYield = currentSupplyAssets − netDeposited
-     *
-     * @param collateralSymbol - Market collateral token (optional, returns all if omitted)
-     */
-    async getSupplyPositions(collateralSymbol) {
-        const acctAddr = (await this.getAccountAddress()).toLowerCase();
-        const chainId = this.config.chainId;
-        // ── 1. Fetch all positions from Morpho API ──
-        const positionsQuery = `{
-      userByAddress(address: "${acctAddr}", chainId: ${chainId}) {
-        marketPositions {
-          market {
-            uniqueKey
-            loanAsset { symbol address decimals }
-            collateralAsset { symbol address }
-            state { supplyApy }
-          }
-          state {
-            supplyShares
-            supplyAssets
-            supplyAssetsUsd
-          }
-        }
-      }
-    }`;
-        const posResp = await axios.post(MORPHO_API_URL, { query: positionsQuery }, { timeout: 15000 });
-        const user = posResp.data?.data?.userByAddress;
-        if (!user?.marketPositions)
-            return [];
-        const activePositions = user.marketPositions.filter((p) => p.state && BigInt(p.state.supplyShares ?? '0') > 0n);
-        if (activePositions.length === 0)
-            return [];
-        // Apply collateral filter if specified
-        const filtered = collateralSymbol
-            ? activePositions.filter((p) => {
-                const sym = p.market.collateralAsset?.symbol;
-                return sym && sym.toUpperCase() === collateralSymbol.toUpperCase();
-            })
-            : activePositions;
-        if (filtered.length === 0)
-            return [];
-        // ── 2. Fetch supply/withdraw transaction history from Morpho API ──
-        const netDepositedMap = await this._computeNetDepositedAll(acctAddr, chainId);
-        // ── 3. Build results ──
-        const results = [];
-        for (const p of filtered) {
-            const currentAssets = BigInt(p.state.supplyAssets ?? '0');
-            const marketKey = p.market.uniqueKey.toLowerCase();
-            const netDeposited = netDepositedMap.get(marketKey) ?? 0n;
-            const earnedYield = currentAssets > netDeposited ? currentAssets - netDeposited : 0n;
-            results.push({
-                marketId: p.market.uniqueKey,
-                loanToken: p.market.loanAsset.symbol,
-                collateralToken: p.market.collateralAsset?.symbol ?? 'none',
-                supplyShares: p.state.supplyShares,
-                suppliedAssets: ethers.formatUnits(currentAssets, p.market.loanAsset.decimals),
-                netDeposited: ethers.formatUnits(netDeposited, p.market.loanAsset.decimals),
-                earnedYield: ethers.formatUnits(earnedYield, p.market.loanAsset.decimals),
-                supplyApy: p.market.state?.supplyApy ?? 0,
-            });
-        }
-        return results;
-    }
-    /**
-     * Pay a recipient using ONLY earned yield from a supply position.
-     *
-     * Computes available yield, verifies the requested amount doesn't exceed it,
-     * then withdraws from the supply position and sends directly to the recipient.
-     *
-     * @param recipient - Address to receive the loan token
-     * @param amount - Amount to pay from yield (e.g. '5.50')
-     * @param collateralSymbol - Market collateral to identify which supply position
-     */
-    async payFromYield(recipient, amount, collateralSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        // Get supply position and compute yield
-        const positions = await this.getSupplyPositions(collateralSymbol);
-        if (positions.length === 0) {
-            throw new AgetherError('No supply position found', 'NO_SUPPLY');
-        }
-        // Use the position with the most yield
-        const pos = positions.reduce((a, b) => parseFloat(a.earnedYield) > parseFloat(b.earnedYield) ? a : b);
-        // Find market params to get loan token decimals
-        const params = await this.findMarketForCollateral(pos.collateralToken, pos.loanToken);
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        const parsedAmount = ethers.parseUnits(amount, loanDecimals);
-        const availableYield = ethers.parseUnits(pos.earnedYield, loanDecimals);
-        if (parsedAmount > availableYield) {
-            const loanSymbol = pos.loanToken;
-            throw new AgetherError(`Requested ${amount} ${loanSymbol} exceeds available yield of ${pos.earnedYield} ${loanSymbol}. ` +
-                `Use withdrawSupply to withdraw principal.`, 'EXCEEDS_YIELD');
-        }
-        // Withdraw directly to recipient: withdraw(params, amount, 0, onBehalf, receiver)
-        const data = morphoIface.encodeFunctionData('withdraw', [
-            this._toTuple(params), parsedAmount, 0n, acctAddr, recipient,
-        ]);
-        const receipt = await this.exec(morphoAddr, data);
-        // Read remaining position
-        let remainingYield = '0';
-        let remainingSupply = '0';
-        try {
-            const updatedPositions = await this.getSupplyPositions(pos.collateralToken);
-            if (updatedPositions.length > 0) {
-                remainingYield = updatedPositions[0].earnedYield;
-                remainingSupply = updatedPositions[0].suppliedAssets;
-            }
-        }
-        catch (e) {
-            console.warn('[agether] failed to read remaining yield:', e instanceof Error ? e.message : e);
-        }
-        return {
-            tx: receipt.hash,
-            yieldWithdrawn: amount,
-            recipient,
-            remainingYield,
-            remainingSupply,
-        };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Collateral & Borrowing Operations (all via AgentAccount)
-    // ════════════════════════════════════════════════════════
-    /**
-     * Deposit collateral into Morpho Blue.
-     *
-     * Flow:
-     * 1. EOA transfers collateral to AgentAccount
-     * 2. AgentAccount.executeBatch:
-     *    [collateral.approve(MorphoBlue), Morpho.supplyCollateral(params)]
-     */
-    async supplyCollateral(tokenSymbol, amount, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = await this._resolveToken(tokenSymbol);
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const weiAmount = ethers.parseUnits(amount, colInfo.decimals);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        // Step 1: Transfer collateral from EOA → AgentAccount (only the shortfall)
-        const colToken = new Contract(colInfo.address, ERC20_ABI, this._signer);
-        const acctBalance = await colToken.balanceOf(acctAddr);
-        if (acctBalance < weiAmount) {
-            const shortfall = weiAmount - acctBalance;
-            const eoaBalance = await colToken.balanceOf(await this.getSignerAddress());
-            if (eoaBalance < shortfall) {
-                throw new AgetherError(`Insufficient ${tokenSymbol}. Need ${amount}, AgentAccount has ${ethers.formatUnits(acctBalance, colInfo.decimals)}, EOA has ${ethers.formatUnits(eoaBalance, colInfo.decimals)}.`, 'INSUFFICIENT_BALANCE');
-            }
-            const transferTx = await colToken.transfer(acctAddr, shortfall);
-            await transferTx.wait();
-            this._refreshSigner();
-        }
-        // Step 2: AgentAccount batch: approve + supplyCollateral
-        const targets = [colInfo.address, morphoAddr];
-        const values = [0n, 0n];
-        const datas = [
-            erc20Iface.encodeFunctionData('approve', [morphoAddr, weiAmount]),
-            morphoIface.encodeFunctionData('supplyCollateral', [
-                this._toTuple(params), weiAmount, acctAddr, '0x',
-            ]),
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        return {
-            tx: receipt.hash,
-            collateralToken: tokenSymbol,
-            amount,
-            agentAccount: acctAddr,
-        };
-    }
-    /**
-     * Borrow loan token against existing collateral.
-     *
-     * AgentAccount.execute: Morpho.borrow(params, amount, 0, account, account)
-     *
-     * @param amount - Loan token amount (e.g. '100' for 100 USDC, '0.5' for 0.5 WETH)
-     * @param tokenSymbol - collateral symbol to identify which market (default: first with collateral)
-     * @param marketParams - explicit market params (optional)
-     * @param loanTokenSymbol - loan token to filter market (optional, e.g. 'USDC', 'WETH')
-     */
-    async borrow(amount, tokenSymbol, marketParams, loanTokenSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        // Find market
-        let params;
-        let usedToken = tokenSymbol || 'WETH';
-        if (marketParams) {
-            params = marketParams;
-        }
-        else if (tokenSymbol) {
-            params = await this.findMarketForCollateral(tokenSymbol, loanTokenSymbol);
-        }
-        else {
-            // Auto-detect: find first market with collateral
-            const { params: p, symbol } = await this._findActiveMarket();
-            params = p;
-            usedToken = symbol;
-        }
-        // Resolve loan token decimals
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        const parsedAmount = ethers.parseUnits(amount, loanDecimals);
-        // ── Pre-check: verify collateral is sufficient for the borrow amount ──
-        // Avoids wasting gas on a UserOp that will revert with "insufficient collateral".
-        try {
-            const marketId = ethers.keccak256(ethers.AbiCoder.defaultAbiCoder().encode(['address', 'address', 'address', 'address', 'uint256'], [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]));
-            const pos = await this.morphoBlue.position(marketId, acctAddr);
-            if (pos.collateral === 0n) {
-                throw new AgetherError(`No collateral deposited for ${usedToken}. Deposit collateral first.`, 'NO_COLLATERAL');
-            }
-            // Compute max borrowable: collateral × oraclePrice / 1e36 × LLTV / 1e18 − debt
-            const oracleContract = new Contract(params.oracle, ['function price() view returns (uint256)'], this.provider);
-            const oraclePrice = await oracleContract.price();
-            const collateralValueInLoan = (BigInt(pos.collateral) * oraclePrice) / (10n ** 36n);
-            const maxBorrowTotal = (collateralValueInLoan * params.lltv) / (10n ** 18n);
-            // Compute current debt from shares
-            const mktState = await this.morphoBlue.market(marketId);
-            const totalBorrowShares = BigInt(mktState.totalBorrowShares);
-            const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
-            const currentDebt = totalBorrowShares > 0n
-                ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares
-                : 0n;
-            const maxAdditional = maxBorrowTotal > currentDebt ? maxBorrowTotal - currentDebt : 0n;
-            if (parsedAmount > maxAdditional) {
-                const loanInfo = this._tokenCache.get(params.loanToken.toLowerCase());
-                const loanSymbol = loanInfo?.symbol ?? 'loan token';
-                const colInfo = await this._resolveToken(usedToken);
-                const maxFormatted = ethers.formatUnits(maxAdditional, loanDecimals);
-                const colFormatted = ethers.formatUnits(pos.collateral, colInfo.decimals);
-                throw new AgetherError(`Borrow of ${amount} ${loanSymbol} exceeds max borrowable ${maxFormatted} ${loanSymbol} ` +
-                    `(collateral: ${colFormatted} ${usedToken}, LLTV: ${Number(params.lltv) / 1e18 * 100}%). ` +
-                    `Deposit more collateral or reduce borrow amount.`, 'EXCEEDS_MAX_LTV');
-            }
-        }
-        catch (e) {
-            if (e instanceof AgetherError)
-                throw e;
-            console.warn('[agether] borrow pre-check failed (proceeding anyway):', e instanceof Error ? e.message : e);
-        }
-        const data = morphoIface.encodeFunctionData('borrow', [
-            this._toTuple(params), parsedAmount, 0n, acctAddr, acctAddr,
-        ]);
-        const receipt = await this.exec(morphoAddr, data);
-        return {
-            tx: receipt.hash,
-            amount,
-            collateralToken: usedToken,
-            agentAccount: acctAddr,
-        };
-    }
-    /**
-     * Deposit collateral AND borrow USDC in one batched transaction.
-     *
-    /**
-     * Deposit collateral AND borrow loan token in one batched transaction.
-     *
-     * AgentAccount.executeBatch:
-     *   [collateral.approve, Morpho.supplyCollateral, Morpho.borrow]
-     *
-     * The collateral must be transferred to AgentAccount first.
-     *
-     * @param tokenSymbol - collateral token symbol (e.g. 'WETH')
-     * @param collateralAmount - amount of collateral (e.g. '0.05')
-     * @param borrowAmount - amount of loan token to borrow (e.g. '100')
-     * @param marketParams - explicit market params (optional)
-     * @param loanTokenSymbol - loan token to filter market (optional)
-     */
-    async depositAndBorrow(tokenSymbol, collateralAmount, borrowAmount, marketParams, loanTokenSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = await this._resolveToken(tokenSymbol);
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol, loanTokenSymbol);
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        const colWei = ethers.parseUnits(collateralAmount, colInfo.decimals);
-        const borrowWei = ethers.parseUnits(borrowAmount, loanDecimals);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        // ── Pre-check: will the new total collateral support the borrow? ──
-        try {
-            const marketId = ethers.keccak256(ethers.AbiCoder.defaultAbiCoder().encode(['address', 'address', 'address', 'address', 'uint256'], [params.loanToken, params.collateralToken, params.oracle, params.irm, params.lltv]));
-            const pos = await this.morphoBlue.position(marketId, acctAddr);
-            const totalCollateral = BigInt(pos.collateral) + colWei; // existing + new deposit
-            const oracleContract = new Contract(params.oracle, ['function price() view returns (uint256)'], this.provider);
-            const oraclePrice = await oracleContract.price();
-            const collateralValueInLoan = (totalCollateral * oraclePrice) / (10n ** 36n);
-            const maxBorrowTotal = (collateralValueInLoan * params.lltv) / (10n ** 18n);
-            const mktState = await this.morphoBlue.market(marketId);
-            const totalBorrowShares = BigInt(mktState.totalBorrowShares);
-            const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
-            const currentDebt = totalBorrowShares > 0n
-                ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares
-                : 0n;
-            const maxAdditional = maxBorrowTotal > currentDebt ? maxBorrowTotal - currentDebt : 0n;
-            if (borrowWei > maxAdditional) {
-                const loanInfo = this._tokenCache.get(params.loanToken.toLowerCase());
-                const loanSymbol = loanInfo?.symbol ?? 'loan token';
-                const maxFormatted = ethers.formatUnits(maxAdditional, loanDecimals);
-                throw new AgetherError(`Borrow of ${borrowAmount} ${loanSymbol} exceeds max borrowable ${maxFormatted} ${loanSymbol} ` +
-                    `(total collateral: ${ethers.formatUnits(totalCollateral, colInfo.decimals)} ${tokenSymbol}, ` +
-                    `LLTV: ${Number(params.lltv) / 1e18 * 100}%). Reduce borrow or increase collateral.`, 'EXCEEDS_MAX_LTV');
-            }
-        }
-        catch (e) {
-            if (e instanceof AgetherError)
-                throw e;
-            console.warn('[agether] depositAndBorrow pre-check failed (proceeding anyway):', e instanceof Error ? e.message : e);
-        }
-        // Step 1: Transfer collateral from EOA → AgentAccount (only the shortfall)
-        const colToken = new Contract(colInfo.address, ERC20_ABI, this._signer);
-        const acctBalance = await colToken.balanceOf(acctAddr);
-        if (acctBalance < colWei) {
-            const shortfall = colWei - acctBalance;
-            const eoaBalance = await colToken.balanceOf(await this.getSignerAddress());
-            if (eoaBalance < shortfall) {
-                throw new AgetherError(`Insufficient ${tokenSymbol}. Need ${collateralAmount}, AgentAccount has ${ethers.formatUnits(acctBalance, colInfo.decimals)}, EOA has ${ethers.formatUnits(eoaBalance, colInfo.decimals)}.`, 'INSUFFICIENT_BALANCE');
-            }
-            const transferTx = await colToken.transfer(acctAddr, shortfall);
-            await transferTx.wait();
-            this._refreshSigner();
-        }
-        // Step 2: Batched — approve + supplyCollateral + borrow
-        const targets = [colInfo.address, morphoAddr, morphoAddr];
-        const values = [0n, 0n, 0n];
-        const datas = [
-            erc20Iface.encodeFunctionData('approve', [morphoAddr, colWei]),
-            morphoIface.encodeFunctionData('supplyCollateral', [
-                this._toTuple(params), colWei, acctAddr, '0x',
-            ]),
-            morphoIface.encodeFunctionData('borrow', [
-                this._toTuple(params), borrowWei, 0n, acctAddr, acctAddr,
-            ]),
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        return {
-            tx: receipt.hash,
-            collateralToken: tokenSymbol,
-            collateralAmount,
-            borrowAmount,
-            agentAccount: acctAddr,
-        };
-    }
-    /**
-     * Repay borrowed loan token from AgentAccount.
-     *
-     * AgentAccount.executeBatch:
-     *   [loanToken.approve(MorphoBlue), Morpho.repay(params)]
-     *
-     * @param amount - loan token amount to repay (e.g. '50' or 'all' for full repayment)
-     * @param tokenSymbol - collateral symbol to identify which market (optional)
-     * @param marketParams - explicit market params (optional)
-     * @param loanTokenSymbol - loan token to filter market (optional)
-     */
-    async repay(amount, tokenSymbol, marketParams, loanTokenSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        let params;
-        if (marketParams) {
-            params = marketParams;
-        }
-        else if (tokenSymbol) {
-            params = await this.findMarketForCollateral(tokenSymbol, loanTokenSymbol);
-        }
-        else {
-            const { params: p } = await this._findActiveMarket();
-            params = p;
-        }
-        // Resolve loan token address and decimals
-        const loanTokenAddr = params.loanToken;
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        // Determine whether to repay by shares (full repay) or by assets (partial).
-        // Using shares-based repay prevents dust borrow shares from remaining.
-        let repayAssets;
-        let repayShares;
-        let approveAmount;
-        if (amount === 'all') {
-            // Full repay: use shares to ensure no dust remains
-            const markets = await this.getMarkets();
-            const mkt = markets.find((m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase()
-                && m.loanAsset?.address.toLowerCase() === params.loanToken.toLowerCase());
-            if (mkt) {
-                const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
-                repayShares = BigInt(pos.borrowShares);
-                repayAssets = 0n;
-                // Read onchain market state for accurate share→asset conversion
-                const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
-                const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
-                const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
-                const estimated = totalBorrowShares > 0n
-                    ? (repayShares * totalBorrowAssets) / totalBorrowShares + 10n
-                    : 0n;
-                approveAmount = estimated > 0n ? estimated : ethers.parseUnits('1', loanDecimals);
-            }
-            else {
-                // Fallback: large asset repay
-                repayAssets = ethers.parseUnits('999999', loanDecimals);
-                repayShares = 0n;
-                approveAmount = repayAssets;
-            }
-        }
-        else {
-            repayAssets = ethers.parseUnits(amount, loanDecimals);
-            repayShares = 0n;
-            approveAmount = repayAssets;
-            // Specific amount: always use asset-based repay (no shares conversion).
-            // This avoids rounding issues where shares→assets needs slightly more
-            // than the AgentAccount holds. Use 'all' for full debt clearance.
-        }
-        // Ensure AgentAccount has enough loan token to cover the repay.
-        // If not, transfer the shortfall from EOA → AgentAccount first.
-        const loanContract = new Contract(loanTokenAddr, ERC20_ABI, this._signer);
-        const acctBalance = await loanContract.balanceOf(acctAddr);
-        if (acctBalance < approveAmount) {
-            const shortfall = approveAmount - acctBalance;
-            const eoaBalance = await loanContract.balanceOf(await this.getSignerAddress());
-            if (eoaBalance < shortfall) {
-                const loanInfo = this._tokenCache.get(loanTokenAddr.toLowerCase());
-                const loanSymbol = loanInfo?.symbol ?? 'loan token';
-                throw new AgetherError(`Insufficient ${loanSymbol} for repay. Need ${ethers.formatUnits(approveAmount, loanDecimals)}, ` +
-                    `AgentAccount has ${ethers.formatUnits(acctBalance, loanDecimals)}, EOA has ${ethers.formatUnits(eoaBalance, loanDecimals)}.`, 'INSUFFICIENT_BALANCE');
-            }
-            const transferTx = await loanContract.transfer(acctAddr, shortfall);
-            await transferTx.wait();
-            this._refreshSigner();
-        }
-        // Batch: approve + repay
-        const targets = [loanTokenAddr, morphoAddr];
-        const values = [0n, 0n];
-        const datas = [
-            erc20Iface.encodeFunctionData('approve', [morphoAddr, approveAmount]),
-            morphoIface.encodeFunctionData('repay', [
-                this._toTuple(params), repayAssets, repayShares, acctAddr, '0x',
-            ]),
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        // Read remaining debt
-        let remainingDebt = '0';
-        try {
-            const status = await this.getStatus();
-            remainingDebt = status.totalDebt;
-        }
-        catch (e) {
-            console.warn('[agether] failed to read remaining debt after repay:', e instanceof Error ? e.message : e);
-        }
-        return { tx: receipt.hash, amount, remainingDebt };
-    }
-    /**
-     * Withdraw collateral from Morpho Blue.
-     *
-     * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
-     *
-     * @param receiver - defaults to EOA wallet
-     */
-    async withdrawCollateral(tokenSymbol, amount, marketParams, receiver) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = await this._resolveToken(tokenSymbol);
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const loanTokenAddr = params.loanToken;
-        const loanDecimals = await this._getLoanTokenDecimals(params);
-        const dest = receiver || await this.getSignerAddress();
-        // Handle 'all' — withdraw full collateral
-        let weiAmount;
-        const markets = await this.getMarkets();
-        const market = markets.find((m) => m.collateralAsset?.address.toLowerCase() === colInfo.address.toLowerCase()
-            && m.loanAsset?.address.toLowerCase() === loanTokenAddr.toLowerCase());
-        if (amount === 'all') {
-            if (!market)
-                throw new AgetherError('Market not found', 'MARKET_NOT_FOUND');
-            const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
-            weiAmount = pos.collateral;
-            if (weiAmount === 0n)
-                throw new AgetherError('No collateral to withdraw', 'NO_COLLATERAL');
-        }
-        else {
-            weiAmount = ethers.parseUnits(amount, colInfo.decimals);
-        }
-        // ── Check for dust borrow shares ──────────────────────
-        // If any borrow shares remain (even dust), Morpho will reject a full
-        // collateral withdrawal because LTV would become infinite.
-        // Auto-repay dust debt before withdrawing.
-        let hasDustDebt = false;
-        let dustBorrowShares = 0n;
-        let dustApproveAmount = 0n;
-        if (market) {
-            try {
-                const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
-                dustBorrowShares = BigInt(pos.borrowShares);
-                if (dustBorrowShares > 0n) {
-                    hasDustDebt = true;
-                    // Convert shares → assets to know how much loan token to approve
-                    const onChainMkt = await this.morphoBlue.market(market.uniqueKey);
-                    const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
-                    const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
-                    const estimated = totalBorrowShares > 0n
-                        ? (dustBorrowShares * totalBorrowAssets) / totalBorrowShares + 10n
-                        : 0n;
-                    dustApproveAmount = estimated > 0n ? estimated : ethers.parseUnits('1', loanDecimals);
-                    const loanInfo = this._tokenCache.get(loanTokenAddr.toLowerCase());
-                    const loanSymbol = loanInfo?.symbol ?? 'loan token';
-                    console.log(`[agether] dust borrow shares detected: ${dustBorrowShares} shares ≈ ${ethers.formatUnits(dustApproveAmount, loanDecimals)} ${loanSymbol} — auto-repaying before withdraw`);
-                }
-            }
-            catch (e) {
-                console.warn('[agether] failed to check borrow shares before withdraw:', e instanceof Error ? e.message : e);
-            }
-        }
-        const withdrawData = morphoIface.encodeFunctionData('withdrawCollateral', [
-            this._toTuple(params), weiAmount, acctAddr, dest,
-        ]);
-        let receipt;
-        if (hasDustDebt) {
-            // Ensure AgentAccount has enough loan token to cover the dust repay
-            const loanContract = new Contract(loanTokenAddr, ERC20_ABI, this._signer);
-            const acctBalance = await loanContract.balanceOf(acctAddr);
-            if (acctBalance < dustApproveAmount) {
-                const shortfall = dustApproveAmount - acctBalance;
-                const eoaBalance = await loanContract.balanceOf(await this.getSignerAddress());
-                if (eoaBalance >= shortfall) {
-                    const loanInfo = this._tokenCache.get(loanTokenAddr.toLowerCase());
-                    const loanSymbol = loanInfo?.symbol ?? 'loan token';
-                    console.log(`[agether] transferring ${ethers.formatUnits(shortfall, loanDecimals)} ${loanSymbol} from EOA → AgentAccount for dust repay`);
-                    const transferTx = await loanContract.transfer(acctAddr, shortfall);
-                    await transferTx.wait();
-                    this._refreshSigner();
-                }
-                // If EOA doesn't have enough either, still try — the tx will revert with a clear error
-            }
-            // Batch: approve loan token → repay dust shares → withdraw collateral
-            const targets = [loanTokenAddr, morphoAddr, morphoAddr];
-            const values = [0n, 0n, 0n];
-            const datas = [
-                erc20Iface.encodeFunctionData('approve', [morphoAddr, dustApproveAmount]),
-                morphoIface.encodeFunctionData('repay', [
-                    this._toTuple(params), 0n, dustBorrowShares, acctAddr, '0x',
-                ]),
-                withdrawData,
-            ];
-            receipt = await this.batch(targets, values, datas);
-        }
-        else {
-            receipt = await this.exec(morphoAddr, withdrawData);
-        }
-        // Read remaining collateral
-        let remainingCollateral = '0';
-        try {
-            if (market) {
-                const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
-                remainingCollateral = ethers.formatUnits(pos.collateral, colInfo.decimals);
-            }
-        }
-        catch (e) {
-            console.warn('[agether] failed to read remaining collateral after withdraw:', e instanceof Error ? e.message : e);
-        }
-        return {
-            tx: receipt.hash,
-            token: tokenSymbol,
-            amount: amount === 'all' ? ethers.formatUnits(weiAmount, colInfo.decimals) : amount,
-            remainingCollateral,
-            destination: dest,
-        };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Internal Helpers
-    // ════════════════════════════════════════════════════════
-    /**
-     * Refresh the signer and re-bind contract instances.
-     *
-     * For the **privateKey** path: recreates provider + wallet so the next tx
-     * fetches a fresh nonce from chain. Anvil (and some RPC providers) return a
-     * stale `eth_getTransactionCount` right after a block is mined, causing
-     * "nonce too low" on the follow-up tx.
-     *
-     * For the **external signer** path: the signer is immutable and owned by the
-     * caller (e.g. custody provider). We only re-bind contract instances to
-     * ensure they reference the current signer. Nonce management is the caller's
-     * responsibility.
-     */
-    _refreshSigner() {
-        if (this._useExternalSigner) {
-            // External signer: re-bind contracts only (signer is immutable)
-            const addrs = this.config.contracts;
-            this.agether4337Factory = new Contract(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
-            this.entryPoint = new Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-        }
-        else {
-            // Private key path: recreate provider + wallet for fresh nonce
-            this.provider = new ethers.JsonRpcProvider(this._rpcUrl);
-            const wallet = new ethers.Wallet(this._privateKey, this.provider);
-            this._signer = wallet;
-            this._eoaAddress = wallet.address;
-            // Re-bind contract instances that use the wallet as signer
-            const addrs = this.config.contracts;
-            this.agether4337Factory = new Contract(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
-            this.entryPoint = new Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-            // morphoBlue stays on provider (read-only) — no need to refresh
-        }
-    }
-    // ────────────────────────────────────────────────────────────
-    //  ERC-4337 UserOp helpers (Safe + Safe7579 + EntryPoint v0.7)
-    // ────────────────────────────────────────────────────────────
-    /**
-     * Pack two uint128 values into a single bytes32:
-     *   bytes32 = (hi << 128) | lo
-     */
-    _packUint128(hi, lo) {
-        return ethers.zeroPadValue(ethers.toBeHex((hi << 128n) | lo), 32);
-    }
-    /**
-     * Build, sign and submit a PackedUserOperation through EntryPoint.handleOps.
-     *
-     * @param callData – the ABI-encoded calldata for the Safe7579 account
-     *   (e.g. `execute(mode, executionCalldata)`)
-     * @returns the transaction receipt of the handleOps call
-     */
-    async _submitUserOp(callData) {
-        const sender = await this.getAccountAddress();
-        // ── Nonce key = validator module address ──
-        // Safe7579 extracts the validator from the nonce: `validator := shr(96, nonce)`.
-        // The EntryPoint's getNonce(sender, key) returns `(key << 64) | seq`.
-        // Safe7579's own getNonce computes the key as:
-        //   uint192(bytes24(bytes20(address(validator)))) = address << 32
-        // so that shr(96, (addr<<32)<<64 | seq) = shr(96, addr<<96 | seq) = addr.
-        const validatorAddr = this.config.contracts.erc8004ValidationModule;
-        const nonceKey = BigInt(validatorAddr) << 32n;
-        const nonce = await this.entryPoint.getNonce(sender, nonceKey);
-        // Gas prices from the network
-        const feeData = await this.provider.getFeeData();
-        const maxFeePerGas = feeData.maxFeePerGas ?? ethers.parseUnits('0.5', 'gwei');
-        const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? ethers.parseUnits('0.1', 'gwei');
-        // Default gas limits — generous for DeFi interactions
-        const verificationGasLimit = 500000n;
-        const callGasLimit = 800000n;
-        const preVerificationGas = 100000n;
-        const accountGasLimits = this._packUint128(verificationGasLimit, callGasLimit);
-        const gasFees = this._packUint128(maxPriorityFeePerGas, maxFeePerGas);
-        // ── Auto-fund the Safe account for gas ──
-        // The account must pay `missingAccountFunds` to EntryPoint during validateUserOp.
-        // Required prefund ≈ (verificationGasLimit + callGasLimit + preVerificationGas) × maxFeePerGas.
-        // If the account has insufficient ETH, top it up from the EOA.
-        const requiredPrefund = (verificationGasLimit + callGasLimit + preVerificationGas) * maxFeePerGas;
-        const accountBalance = await this.provider.getBalance(sender);
-        if (accountBalance < requiredPrefund) {
-            const topUp = requiredPrefund - accountBalance;
-            // Add 20 % buffer to avoid marginal shortfalls
-            const topUpWithBuffer = (topUp * 120n) / 100n;
-            const fundTx = await this._signer.sendTransaction({
-                to: sender,
-                value: topUpWithBuffer,
-            });
-            await fundTx.wait();
-            this._refreshSigner();
-        }
-        // Build the PackedUserOperation (no paymaster, no initCode for existing accounts)
-        const userOp = {
-            sender,
-            nonce,
-            initCode: '0x',
-            callData,
-            accountGasLimits,
-            preVerificationGas,
-            gasFees,
-            paymasterAndData: '0x',
-            signature: '0x', // placeholder — replaced after signing
-        };
-        // Get the hash and sign it
-        const userOpHash = await this.entryPoint.getUserOpHash(userOp);
-        const signature = await this._signer.signMessage(ethers.getBytes(userOpHash));
-        userOp.signature = signature;
-        // Submit via handleOps — the EOA pays for gas as the bundler
-        const tx = await this.entryPoint.handleOps([userOp], await this.getSignerAddress());
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        // ── Verify inner UserOp execution succeeded ──
-        // EntryPoint's outer tx always succeeds (status=1) even if the inner UserOp
-        // execution reverts. We MUST check the UserOperationEvent.success field.
-        const epIface = new ethers.Interface(ENTRYPOINT_V07_ABI);
-        for (const log of receipt.logs) {
-            try {
-                const parsed = epIface.parseLog({ topics: log.topics, data: log.data });
-                if (parsed?.name === 'UserOperationEvent' && !parsed.args.success) {
-                    // Inner execution failed — try to extract the revert reason
-                    let revertMsg = 'UserOp inner execution reverted';
-                    for (const rLog of receipt.logs) {
-                        try {
-                            const rParsed = epIface.parseLog({ topics: rLog.topics, data: rLog.data });
-                            if (rParsed?.name === 'UserOperationRevertReason') {
-                                const reason = rParsed.args.revertReason;
-                                try {
-                                    // Try to decode as Error(string) — selector 0x08c379a0
-                                    if (reason.length >= 10 && reason.slice(0, 10) === '0x08c379a0') {
-                                        const decoded = ethers.AbiCoder.defaultAbiCoder().decode(['string'], '0x' + reason.slice(10));
-                                        revertMsg = `UserOp reverted: ${decoded[0]}`;
-                                    }
-                                    else {
-                                        revertMsg = `UserOp reverted with data: ${reason}`;
-                                    }
-                                }
-                                catch {
-                                    revertMsg = `UserOp reverted with data: ${reason}`;
-                                }
-                                break;
-                            }
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                    throw new AgetherError(revertMsg, 'USEROP_EXECUTION_FAILED');
-                }
-            }
-            catch (e) {
-                if (e instanceof AgetherError)
-                    throw e;
-                continue; // skip logs that don't match EntryPoint events
-            }
-        }
-        return receipt;
-    }
-    /**
-     * Execute a single call via Safe7579 account (ERC-7579 single mode)
-     * through an ERC-4337 UserOperation.
-     */
-    async exec(target, data, value = 0n) {
-        // ERC-7579 single execution uses PACKED encoding (not abi.encode!):
-        //   bytes[0:20]  = target address (20 bytes, no left-padding)
-        //   bytes[20:52] = value (uint256, 32 bytes)
-        //   bytes[52:]   = callData (raw, no length prefix)
-        // This matches Safe7579's ExecutionLib.decodeSingle().
-        const valueHex = ethers.zeroPadValue(ethers.toBeHex(value), 32);
-        const executionCalldata = ethers.concat([target, valueHex, data]);
-        // Build the Safe7579 account calldata: execute(bytes32 mode, bytes executionCalldata)
-        const safe7579Iface = new ethers.Interface(SAFE7579_ACCOUNT_ABI);
-        const callData = safe7579Iface.encodeFunctionData('execute', [MODE_SINGLE, executionCalldata]);
-        return this._submitUserOp(callData);
-    }
-    /**
-     * Execute multiple calls via Safe7579 account (ERC-7579 batch mode)
-     * through an ERC-4337 UserOperation.
-     */
-    async batch(targets, values, datas) {
-        // ERC-7579: encode batch execution = abi.encode(Execution[])
-        // where Execution = (address target, uint256 value, bytes callData)
-        const executions = targets.map((t, i) => [t, values[i], datas[i]]);
-        const executionCalldata = ethers.AbiCoder.defaultAbiCoder().encode(['(address,uint256,bytes)[]'], [executions]);
-        // Build the Safe7579 account calldata: execute(bytes32 mode, bytes executionCalldata)
-        const safe7579Iface = new ethers.Interface(SAFE7579_ACCOUNT_ABI);
-        const callData = safe7579Iface.encodeFunctionData('execute', [MODE_BATCH, executionCalldata]);
-        return this._submitUserOp(callData);
-    }
-    /** Convert MorphoMarketParams to Solidity tuple. */
-    _toTuple(p) {
-        return [p.loanToken, p.collateralToken, p.oracle, p.irm, p.lltv];
-    }
-    /** Find the first market where the agent has collateral deposited. */
-    async _findActiveMarket() {
-        const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
-        for (const m of markets) {
-            if (!m.collateralAsset || m.collateralAsset.address === ethers.ZeroAddress)
-                continue;
-            try {
-                const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-                if (pos.collateral > 0n) {
-                    return {
-                        params: {
-                            loanToken: m.loanAsset.address,
-                            collateralToken: m.collateralAsset.address,
-                            oracle: m.oracle,
-                            irm: m.irm,
-                            lltv: m.lltv,
-                        },
-                        symbol: m.collateralAsset.symbol,
-                    };
-                }
-            }
-            catch (e) {
-                console.warn('[agether] _findActiveMarket position check failed:', e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        // Default to WETH
-        const params = await this.findMarketForCollateral('WETH');
-        return { params, symbol: 'WETH' };
-    }
-    /** Find the first market where the agent has a supply (lending) position. */
-    async _findActiveSupplyMarket() {
-        const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
-        for (const m of markets) {
-            if (!m.collateralAsset || m.collateralAsset.address === ethers.ZeroAddress)
-                continue;
-            try {
-                const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-                if (BigInt(pos.supplyShares) > 0n) {
-                    return {
-                        params: {
-                            loanToken: m.loanAsset.address,
-                            collateralToken: m.collateralAsset.address,
-                            oracle: m.oracle,
-                            irm: m.irm,
-                            lltv: m.lltv,
-                        },
-                        symbol: m.collateralAsset.symbol,
-                    };
-                }
-            }
-            catch (e) {
-                console.warn('[agether] _findActiveSupplyMarket position check failed:', e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        throw new AgetherError('No active supply position found', 'NO_SUPPLY');
-    }
-    /**
-     * Resolve loan token decimals from market params.
-     * Uses the `_tokenCache` populated by `getMarkets()`.
-     */
-    async _getLoanTokenDecimals(params) {
-        const tokenInfo = this._tokenCache.get(params.loanToken.toLowerCase());
-        if (tokenInfo)
-            return tokenInfo.decimals;
-        // If not cached, ensure markets are loaded
-        await this.getMarkets();
-        const fromApi = this._tokenCache.get(params.loanToken.toLowerCase());
-        return fromApi?.decimals ?? 18; // fallback to 18 (ETH-like)
-    }
-    /**
-     * Apply client-side filter to discovered markets.
-     */
-    _applyMarketFilter(markets, filter) {
-        return markets.filter((m) => {
-            if (filter.loanToken) {
-                const loanAddr = filter.loanToken.toLowerCase();
-                if (m.loanAsset.address.toLowerCase() !== loanAddr
-                    && m.loanAsset.symbol.toUpperCase() !== filter.loanToken.toUpperCase()) {
-                    return false;
-                }
-            }
-            if (filter.collateralToken) {
-                const colAddr = filter.collateralToken.toLowerCase();
-                if (m.collateralAsset.address.toLowerCase() !== colAddr
-                    && m.collateralAsset.symbol.toUpperCase() !== filter.collateralToken.toUpperCase()) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-    /**
-     * Resolve a token symbol or address to { address, symbol, decimals }.
-     *
-     * Uses the dynamic `_tokenCache` populated by `getMarkets()` from the
-     * Morpho GraphQL API — no hardcoded token list needed.
-     *
-     * @param symbolOrAddress - e.g. 'WETH', 'wstETH', or '0x4200...'
-     */
-    async _resolveToken(symbolOrAddress) {
-        // Try cache first (by uppercase symbol or lowercase address)
-        const key = symbolOrAddress.startsWith('0x')
-            ? symbolOrAddress.toLowerCase()
-            : symbolOrAddress.toUpperCase();
-        const cached = this._tokenCache.get(key);
-        if (cached)
-            return cached;
-        // Cache cold — warm it from Morpho API (fetches up to 500 markets)
-        await this.getMarkets();
-        const fromApi = this._tokenCache.get(key);
-        if (fromApi)
-            return fromApi;
-        // Last resort: use Morpho's `search` to find the token across all markets.
-        // This handles tokens that didn't appear in the top-500 by supply.
-        if (!symbolOrAddress.startsWith('0x')) {
-            const searchResults = await this.searchMarkets(symbolOrAddress);
-            const sym = symbolOrAddress.toUpperCase();
-            for (const m of searchResults) {
-                if (m.collateralToken.toUpperCase() === sym) {
-                    const info = { address: m.collateralAddress, symbol: m.collateralToken, decimals: m.collateralDecimals };
-                    this._tokenCache.set(sym, info);
-                    this._tokenCache.set(m.collateralAddress.toLowerCase(), info);
-                    return info;
-                }
-                if (m.loanToken.toUpperCase() === sym) {
-                    const info = { address: m.loanAddress, symbol: m.loanToken, decimals: m.loanDecimals };
-                    this._tokenCache.set(sym, info);
-                    this._tokenCache.set(m.loanAddress.toLowerCase(), info);
-                    return info;
-                }
-            }
-        }
-        throw new AgetherError(`Unknown token: ${symbolOrAddress}. No Morpho market found with this token.`, 'UNKNOWN_TOKEN');
-    }
-    /**
-     * Compute net deposited amounts per market using Morpho GraphQL API.
-     *
-     * Fetches all MarketSupply and MarketWithdraw transactions for the account,
-     * then computes: netDeposited[marketId] = Σ Supply.assets − Σ Withdraw.assets
-     *
-     * Returns a Map<marketId (lowercase), bigint>.
-     *
-     * Uses pagination (100 per page) for completeness, though agent accounts
-     * typically have single-digit transaction counts.
-     */
-    async _computeNetDepositedAll(accountAddr, chainId) {
-        const result = new Map();
-        let skip = 0;
-        const pageSize = 100;
-        let hasMore = true;
-        while (hasMore) {
-            const txQuery = `{
-        transactions(
-          first: ${pageSize}
-          skip: ${skip}
-          where: {
-            userAddress_in: ["${accountAddr}"]
-            type_in: [MarketSupply, MarketWithdraw]
-            chainId_in: [${chainId}]
-          }
-        ) {
-          pageInfo { count countTotal }
-          items {
-            type
-            data {
-              ... on MarketTransferTransactionData {
-                assets
-                market { uniqueKey }
-              }
-            }
-          }
-        }
-      }`;
-            const resp = await axios.post(MORPHO_API_URL, { query: txQuery }, { timeout: 15000 });
-            const txData = resp.data?.data?.transactions;
-            if (!txData?.items)
-                break;
-            for (const tx of txData.items) {
-                const marketKey = tx.data?.market?.uniqueKey?.toLowerCase();
-                if (!marketKey || !tx.data?.assets)
-                    continue;
-                const assets = BigInt(tx.data.assets);
-                const current = result.get(marketKey) ?? 0n;
-                if (tx.type === 'MarketSupply') {
-                    result.set(marketKey, current + assets);
-                }
-                else if (tx.type === 'MarketWithdraw') {
-                    const newVal = current - assets;
-                    result.set(marketKey, newVal > 0n ? newVal : 0n);
-                }
-            }
-            // Check if there are more pages
-            const fetched = skip + txData.items.length;
-            const total = txData.pageInfo?.countTotal ?? 0;
-            hasMore = fetched < total;
-            skip += pageSize;
-        }
-        return result;
-    }
-}