@agether/sdk 2.6.1 → 2.8.0

package/dist/clients/MorphoClient.js

@@ -1,1717 +0,0 @@
-/**
- * MorphoClient — Direct Morpho Blue lending via Safe account (ERC-4337 UserOps)
- *
- * 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, AGENT_REPUTATION_ABI, IDENTITY_REGISTRY_ABI, MORPHO_BLUE_ABI, ERC20_ABI, ERC8004_VALIDATION_MODULE_ABI, ENTRYPOINT_V07_ABI, } from '../utils/abis';
-import { getDefaultConfig } from '../utils/config';
-// ── Well-known collateral tokens on Base ──
-const BASE_COLLATERALS = {
-    WETH: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH', decimals: 18 },
-    wstETH: { address: '0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452', symbol: 'wstETH', decimals: 18 },
-    cbETH: { address: '0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22', symbol: 'cbETH', decimals: 18 },
-};
-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) {
-        this._marketCache = new Map();
-        this._discoveredAt = 0;
-        const chainId = config.chainId ?? ChainId.Base;
-        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.agether8004Scorer = new Contract(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-        this.identityRegistry = new Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
-        this.entryPoint = new Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-        this.validationModule = new Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-    }
-    // ════════════════════════════════════════════════════════
-    //  KYA Gate Check
-    // ════════════════════════════════════════════════════════
-    /**
-     * Check whether the KYA (Know Your Agent) code verification gate is active.
-     * Reads the ERC8004ValidationModule's validationRegistry — when set to
-     * a non-zero address, the module enforces KYA code approval.
-     */
-    async isKyaRequired() {
-        try {
-            const registryAddr = await this.validationModule.validationRegistry();
-            return registryAddr !== ethers.ZeroAddress;
-        }
-        catch {
-            return false;
-        }
-    }
-    // ════════════════════════════════════════════════════════
-    //  Account Management
-    // ════════════════════════════════════════════════════════
-    /** Resolve the AgentAccount address (cached, with retry for flaky RPCs). */
-    async getAccountAddress() {
-        if (this._accountAddress)
-            return this._accountAddress;
-        if (!this.agentId)
-            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
-        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() {
-        if (!this.agentId)
-            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
-        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;
-    }
-    /** Mint a new ERC-8004 identity and return the agentId. */
-    async _mintNewIdentity() {
-        const regTx = await this.identityRegistry.register();
-        const regReceipt = await regTx.wait();
-        this._refreshSigner();
-        let agentId = 0n;
-        for (const log of regReceipt.logs) {
-            try {
-                const parsed = this.identityRegistry.interface.parseLog({ topics: log.topics, data: log.data });
-                if (parsed?.name === 'Transfer') {
-                    agentId = parsed.args[2];
-                    break;
-                }
-            }
-            catch (e) {
-                console.warn('[agether] parseLog skip:', e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        if (agentId === 0n)
-            throw new AgetherError('Failed to parse agentId from registration', 'PARSE_ERROR');
-        return agentId;
-    }
-    /**
-     * Register: create ERC-8004 identity + AgentAccount in one flow.
-     * If already registered, returns existing state.
-     */
-    async register(_name) {
-        const eoaAddr = await this.getSignerAddress();
-        // Check if we already have an agentId
-        if (this.agentId) {
-            const exists = await this.agether4337Factory.accountExists(BigInt(this.agentId));
-            if (exists) {
-                const acct = await this.agether4337Factory.getAccount(BigInt(this.agentId));
-                this._accountAddress = acct;
-                const kyaRequired = await this.isKyaRequired();
-                return { agentId: this.agentId, address: eoaAddr, agentAccount: acct, alreadyRegistered: true, kyaRequired };
-            }
-        }
-        // Check if wallet already has an identity AND we know the agentId
-        let agentId;
-        if (this.agentId) {
-            // We have an agentId in config — reuse it
-            const balance = await this.identityRegistry.balanceOf(eoaAddr);
-            if (balance > 0n) {
-                agentId = BigInt(this.agentId);
-            }
-            else {
-                // agentId in config but no onchain identity — register fresh
-                agentId = await this._mintNewIdentity();
-            }
-        }
-        else {
-            // No agentId — always register a new identity (wallets can have multiple ERC-8004 tokens)
-            agentId = await this._mintNewIdentity();
-        }
-        this.agentId = agentId.toString();
-        // Create AgentAccount if needed
-        const acctExists = await this.agether4337Factory.accountExists(agentId);
-        let txHash;
-        if (!acctExists) {
-            const tx = await this.agether4337Factory.createAccount(agentId);
-            const receipt = await tx.wait();
-            this._refreshSigner();
-            txHash = receipt.hash;
-        }
-        const acctAddr = await this.agether4337Factory.getAccount(agentId);
-        this._accountAddress = acctAddr;
-        const kyaRequired = await this.isKyaRequired();
-        return {
-            agentId: this.agentId,
-            address: eoaAddr,
-            agentAccount: acctAddr,
-            alreadyRegistered: acctExists,
-            kyaRequired,
-            tx: txHash,
-        };
-    }
-    /** Get ETH / USDC / collateral balances for EOA and AgentAccount. */
-    async getBalances() {
-        const eoaAddr = await this.getSignerAddress();
-        const usdc = new Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
-        const ethBal = await this.provider.getBalance(eoaAddr);
-        const usdcBal = await usdc.balanceOf(eoaAddr);
-        // Fetch collateral token balances for EOA
-        const eoaCollateral = {};
-        for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
-            try {
-                const token = new Contract(info.address, ERC20_ABI, this.provider);
-                const bal = await token.balanceOf(eoaAddr);
-                eoaCollateral[symbol] = ethers.formatUnits(bal, info.decimals);
-            }
-            catch (e) {
-                console.warn(`[agether] EOA collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-                eoaCollateral[symbol] = '0';
-            }
-        }
-        const result = {
-            agentId: this.agentId || '?',
-            address: eoaAddr,
-            eth: ethers.formatEther(ethBal),
-            usdc: ethers.formatUnits(usdcBal, 6),
-            collateral: eoaCollateral,
-        };
-        try {
-            const acctAddr = await this.getAccountAddress();
-            const acctEth = await this.provider.getBalance(acctAddr);
-            const acctUsdc = await usdc.balanceOf(acctAddr);
-            // Fetch collateral token balances for AgentAccount
-            const acctCollateral = {};
-            for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
-                try {
-                    const token = new Contract(info.address, ERC20_ABI, this.provider);
-                    const bal = await token.balanceOf(acctAddr);
-                    acctCollateral[symbol] = ethers.formatUnits(bal, info.decimals);
-                }
-                catch (e) {
-                    console.warn(`[agether] AgentAccount collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-                    acctCollateral[symbol] = '0';
-                }
-            }
-            result.agentAccount = {
-                address: acctAddr,
-                eth: ethers.formatEther(acctEth),
-                usdc: ethers.formatUnits(acctUsdc, 6),
-                collateral: acctCollateral,
-            };
-        }
-        catch (err) {
-            // Only swallow NO_ACCOUNT (not registered); rethrow RPC / other errors
-            if (err instanceof AgetherError && err.code === 'NO_ACCOUNT') {
-                // genuinely no account — leave agentAccount undefined
-            }
-            else {
-                // Unexpected error (likely RPC flake) — still surface it so callers know
-                console.warn('[agether] getBalances: failed to fetch AgentAccount data:', err.message ?? err);
-            }
-        }
-        return result;
-    }
-    /** Transfer USDC from EOA to AgentAccount. */
-    async fundAccount(usdcAmount) {
-        const acctAddr = await this.getAccountAddress();
-        const usdc = new Contract(this.config.contracts.usdc, ERC20_ABI, this._signer);
-        const amount = ethers.parseUnits(usdcAmount, 6);
-        const tx = await usdc.transfer(acctAddr, amount);
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        return { tx: receipt.hash, amount: usdcAmount, agentAccount: acctAddr };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Market Discovery (Morpho GraphQL API)
-    // ════════════════════════════════════════════════════════
-    /**
-     * Fetch USDC borrow markets on Base from Morpho API.
-     * Caches results for 5 minutes.
-     */
-    async getMarkets(forceRefresh = false) {
-        if (!forceRefresh && this._discoveredMarkets && Date.now() - this._discoveredAt < 300000) {
-            return this._discoveredMarkets;
-        }
-        const chainId = this.config.chainId;
-        const usdcAddr = this.config.contracts.usdc.toLowerCase();
-        const query = `{
-      markets(
-        first: 50
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"] }
-      ) {
-        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
-            for (const mi of this._discoveredMarkets) {
-                if (mi.collateralAsset.address !== ethers.ZeroAddress) {
-                    this._marketCache.set(mi.collateralAsset.address.toLowerCase(), {
-                        loanToken: mi.loanAsset.address,
-                        collateralToken: mi.collateralAsset.address,
-                        oracle: mi.oracle,
-                        irm: mi.irm,
-                        lltv: mi.lltv,
-                    });
-                }
-            }
-            return this._discoveredMarkets;
-        }
-        catch (e) {
-            console.warn('[agether] getMarkets failed, using cache:', e instanceof Error ? e.message : e);
-            // Fallback: return cached or empty
-            return this._discoveredMarkets ?? [];
-        }
-    }
-    /**
-     * Get MarketParams for a collateral token.
-     * Tries cache → API → onchain idToMarketParams.
-     */
-    async findMarketForCollateral(collateralSymbolOrAddress) {
-        // Resolve symbol → address
-        const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-        const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
-        // Check cache
-        const cached = this._marketCache.get(colAddr);
-        if (cached)
-            return cached;
-        // Try API discovery
-        await this.getMarkets();
-        const fromApi = this._marketCache.get(colAddr);
-        if (fromApi)
-            return fromApi;
-        throw new AgetherError(`No Morpho market found for collateral ${collateralSymbolOrAddress}`, '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 totalDebt = 0n;
-        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;
-                // 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;
-                        totalDebt += debt;
-                    }
-                    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,
-                    collateral: ethers.formatUnits(pos.collateral, m.collateralAsset.decimals),
-                    borrowShares: pos.borrowShares.toString(),
-                    supplyShares: pos.supplyShares.toString(),
-                    debt: ethers.formatUnits(debt, 6),
-                });
-            }
-            catch (e) {
-                console.warn(`[agether] position read failed for market:`, e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        return {
-            agentId: this.agentId || '?',
-            agentAccount: acctAddr,
-            totalDebt: ethers.formatUnits(totalDebt, 6),
-            positions,
-        };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Balance & Borrowing Capacity
-    // ════════════════════════════════════════════════════════
-    /**
-     * Get the USDC balance of the AgentAccount.
-     * @returns USDC balance in raw units (6 decimals)
-     */
-    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 USDC 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 USDC borrowable (6 decimals)
-     */
-    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 → USDC 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,
-                    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 a collateral market 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.
-     */
-    async getMarketRates(collateralSymbolOrAddress) {
-        const chainId = this.config.chainId;
-        const usdcAddr = this.config.contracts.usdc.toLowerCase();
-        // Optionally filter by collateral
-        let collateralFilter = '';
-        if (collateralSymbolOrAddress) {
-            const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-            const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
-            collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
-        }
-        const query = `{
-      markets(
-        first: 50
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"]${collateralFilter} }
-      ) {
-        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 });
-            const items = resp.data?.data?.markets?.items ?? [];
-            return items
-                .filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== ethers.ZeroAddress)
-                .map((m) => ({
-                collateralToken: m.collateralAsset.symbol,
-                loanToken: m.loanAsset.symbol,
-                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) / 1e6 : 0,
-                totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / 1e6 : 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 [];
-        }
-    }
-    /**
-     * 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 = BASE_COLLATERALS[collateralSymbol];
-        if (!colInfo)
-            throw new AgetherError(`Unknown collateral: ${collateralSymbol}`, 'UNKNOWN_COLLATERAL');
-        // 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 USD
-        let collateralValueUsd;
-        if (ethPriceUsd) {
-            collateralValueUsd = parseFloat(amount) * ethPriceUsd;
-        }
-        else {
-            try {
-                const params = await this.findMarketForCollateral(collateralSymbol);
-                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 valueInUsdc = (amountWei * oraclePrice) / ORACLE_PRICE_SCALE;
-                collateralValueUsd = Number(valueInUsdc) / 1e6;
-            }
-            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 USDC to a Morpho Blue market as a lender (earn yield).
-     *
-     * Unlike `supplyCollateral` (borrower-side), this is the **lender-side**:
-     * you deposit the loanToken (USDC) into the market's supply pool and earn
-     * interest paid by borrowers.
-     *
-     * @param usdcAmount - Amount of USDC to supply (e.g. '500')
-     * @param collateralSymbol - Market collateral token to identify which market (e.g. 'WETH')
-     *                           Optional — defaults to highest-APY market
-     */
-    async supplyAsset(usdcAmount, collateralSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const amount = ethers.parseUnits(usdcAmount, 6);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const usdcAddr = this.config.contracts.usdc;
-        // Find market
-        let params;
-        let usedCollateral;
-        if (collateralSymbol) {
-            params = await this.findMarketForCollateral(collateralSymbol);
-            usedCollateral = collateralSymbol;
-        }
-        else {
-            // Auto-pick highest APY market
-            const rates = await this.getMarketRates();
-            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);
-            usedCollateral = best.collateralToken;
-        }
-        // 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 USDC (transfer shortfall from EOA)
-        const usdcContract = new Contract(usdcAddr, ERC20_ABI, this._signer);
-        const acctBalance = await usdcContract.balanceOf(acctAddr);
-        if (acctBalance < amount) {
-            const shortfall = amount - acctBalance;
-            const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
-            if (eoaBalance < shortfall) {
-                throw new AgetherError(`Insufficient USDC. Need ${usdcAmount}, AgentAccount has ${ethers.formatUnits(acctBalance, 6)}, EOA has ${ethers.formatUnits(eoaBalance, 6)}.`, 'INSUFFICIENT_BALANCE');
-            }
-            const transferTx = await usdcContract.transfer(acctAddr, shortfall);
-            await transferTx.wait();
-            this._refreshSigner();
-        }
-        // Batch: approve USDC → supply(marketParams, assets, 0, onBehalf, "0x")
-        const targets = [usdcAddr, morphoAddr];
-        const values = [0n, 0n];
-        const datas = [
-            erc20Iface.encodeFunctionData('approve', [morphoAddr, amount]),
-            morphoIface.encodeFunctionData('supply', [
-                this._toTuple(params), amount, 0n, acctAddr, '0x',
-            ]),
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        return {
-            tx: receipt.hash,
-            amount: usdcAmount,
-            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)
-     */
-    async withdrawSupply(usdcAmount, collateralSymbol, receiver) {
-        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);
-        }
-        else {
-            // Find first market with supply position
-            const { params: p } = await this._findActiveSupplyMarket();
-            params = p;
-        }
-        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 (usdcAmount === '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(usdcAmount, 6);
-            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, 6);
-        }
-        catch (e) {
-            console.warn('[agether] failed to read remaining supply:', e instanceof Error ? e.message : e);
-        }
-        return {
-            tx: receipt.hash,
-            amount: usdcAmount,
-            remainingSupply,
-            destination: dest,
-        };
-    }
-    /**
-     * Get supply (lending) position with yield tracking.
-     *
-     * Yield is computed WITHOUT an indexer/DB:
-     *   1. Read current supplyShares → convert to USDC value
-     *   2. Read historical Morpho Supply/Withdraw events via eth_getLogs
-     *   3. netDeposited = Σ(Supply.assets) − Σ(Withdraw.assets)
-     *   4. earnedYield = currentValue − netDeposited
-     *
-     * @param collateralSymbol - Market collateral token (optional, returns all if omitted)
-     */
-    async getSupplyPositions(collateralSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const markets = await this.getMarkets();
-        const rates = await this.getMarketRates(collateralSymbol);
-        const results = [];
-        for (const m of markets) {
-            if (!m.collateralAsset || m.collateralAsset.address === ethers.ZeroAddress)
-                continue;
-            if (collateralSymbol) {
-                const colInfo = BASE_COLLATERALS[collateralSymbol];
-                const filterAddr = (colInfo?.address ?? collateralSymbol).toLowerCase();
-                if (m.collateralAsset.address.toLowerCase() !== filterAddr)
-                    continue;
-            }
-            try {
-                const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-                const supplyShares = BigInt(pos.supplyShares);
-                if (supplyShares === 0n)
-                    continue;
-                // Convert shares → current asset value
-                const mkt = await this.morphoBlue.market(m.uniqueKey);
-                const totalSupplyAssets = BigInt(mkt.totalSupplyAssets);
-                const totalSupplyShares = BigInt(mkt.totalSupplyShares);
-                const currentAssets = totalSupplyShares > 0n
-                    ? (supplyShares * totalSupplyAssets) / totalSupplyShares
-                    : 0n;
-                // Compute net deposited from events (no DB needed)
-                const netDeposited = await this._computeNetDeposited(m.uniqueKey, acctAddr, morphoAddr);
-                const earnedYield = currentAssets > netDeposited ? currentAssets - netDeposited : 0n;
-                // Find APY from rates
-                const rateInfo = rates.find((r) => r.collateralToken === m.collateralAsset.symbol);
-                const supplyApy = rateInfo?.supplyApy ?? 0;
-                results.push({
-                    marketId: m.uniqueKey,
-                    loanToken: m.loanAsset.symbol,
-                    collateralToken: m.collateralAsset.symbol,
-                    supplyShares: supplyShares.toString(),
-                    suppliedAssets: ethers.formatUnits(currentAssets, 6),
-                    netDeposited: ethers.formatUnits(netDeposited, 6),
-                    earnedYield: ethers.formatUnits(earnedYield, 6),
-                    supplyApy,
-                });
-            }
-            catch (e) {
-                console.warn(`[agether] getSupplyPositions failed for market:`, e instanceof Error ? e.message : e);
-                continue;
-            }
-        }
-        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 USDC
-     * @param usdcAmount - Amount to pay from yield (e.g. '5.50')
-     * @param collateralSymbol - Market collateral to identify which supply position
-     */
-    async payFromYield(recipient, usdcAmount, collateralSymbol) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const amount = ethers.parseUnits(usdcAmount, 6);
-        // 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);
-        const availableYield = ethers.parseUnits(pos.earnedYield, 6);
-        if (amount > availableYield) {
-            throw new AgetherError(`Requested ${usdcAmount} USDC exceeds available yield of ${pos.earnedYield} USDC. ` +
-                `Use withdrawSupply to withdraw principal.`, 'EXCEEDS_YIELD');
-        }
-        // Find market params
-        const params = await this.findMarketForCollateral(pos.collateralToken);
-        // Withdraw directly to recipient: withdraw(params, amount, 0, onBehalf, receiver)
-        const data = morphoIface.encodeFunctionData('withdraw', [
-            this._toTuple(params), amount, 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: usdcAmount,
-            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 = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo)
-            throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, 'UNKNOWN_COLLATERAL');
-        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 USDC against existing collateral.
-     *
-     * AgentAccount.execute: Morpho.borrow(params, amount, 0, account, account)
-     *
-     * @param usdcAmount - USDC amount (e.g. '100')
-     * @param tokenSymbol - collateral symbol to identify which market (default: first with collateral)
-     */
-    async borrow(usdcAmount, tokenSymbol, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const amount = ethers.parseUnits(usdcAmount, 6);
-        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);
-        }
-        else {
-            // Auto-detect: find first market with collateral
-            const { params: p, symbol } = await this._findActiveMarket();
-            params = p;
-            usedToken = symbol;
-        }
-        // ── 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 (amount > maxAdditional) {
-                const maxUsd = ethers.formatUnits(maxAdditional, 6);
-                const colFormatted = ethers.formatUnits(pos.collateral, 18);
-                throw new AgetherError(`Borrow of $${usdcAmount} USDC exceeds max borrowable $${maxUsd} USDC ` +
-                    `(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), amount, 0n, acctAddr, acctAddr,
-        ]);
-        const receipt = await this.exec(morphoAddr, data);
-        return {
-            tx: receipt.hash,
-            amount: usdcAmount,
-            collateralToken: usedToken,
-            agentAccount: acctAddr,
-        };
-    }
-    /**
-     * Deposit collateral AND borrow USDC in one batched transaction.
-     *
-     * AgentAccount.executeBatch:
-     *   [collateral.approve, Morpho.supplyCollateral, Morpho.borrow]
-     *
-     * The collateral must be transferred to AgentAccount first.
-     */
-    async depositAndBorrow(tokenSymbol, collateralAmount, borrowUsdcAmount, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo)
-            throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, 'UNKNOWN_COLLATERAL');
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const colWei = ethers.parseUnits(collateralAmount, colInfo.decimals);
-        const borrowWei = ethers.parseUnits(borrowUsdcAmount, 6);
-        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 maxUsd = ethers.formatUnits(maxAdditional, 6);
-                throw new AgetherError(`Borrow of $${borrowUsdcAmount} USDC exceeds max borrowable $${maxUsd} USDC ` +
-                    `(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: borrowUsdcAmount,
-            agentAccount: acctAddr,
-        };
-    }
-    /**
-     * Repay borrowed USDC from AgentAccount.
-     *
-     * AgentAccount.executeBatch:
-     *   [USDC.approve(MorphoBlue), Morpho.repay(params)]
-     */
-    async repay(usdcAmount, tokenSymbol, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const usdcAddr = this.config.contracts.usdc;
-        let params;
-        if (marketParams) {
-            params = marketParams;
-        }
-        else if (tokenSymbol) {
-            params = await this.findMarketForCollateral(tokenSymbol);
-        }
-        else {
-            const { params: p } = await this._findActiveMarket();
-            params = p;
-        }
-        // 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 (usdcAmount === '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());
-            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', 6);
-            }
-            else {
-                // Fallback: large asset repay
-                repayAssets = ethers.parseUnits('999999', 6);
-                repayShares = 0n;
-                approveAmount = repayAssets;
-            }
-        }
-        else {
-            repayAssets = ethers.parseUnits(usdcAmount, 6);
-            repayShares = 0n;
-            approveAmount = repayAssets;
-            // Specific amount: always use asset-based repay (no shares conversion).
-            // This avoids rounding issues where shares→assets needs slightly more
-            // USDC than the AgentAccount holds. Use 'all' for full debt clearance.
-        }
-        // Ensure AgentAccount has enough USDC to cover the repay.
-        // If not, transfer the shortfall from EOA → AgentAccount first.
-        const usdcContract = new Contract(usdcAddr, ERC20_ABI, this._signer);
-        const acctBalance = await usdcContract.balanceOf(acctAddr);
-        if (acctBalance < approveAmount) {
-            const shortfall = approveAmount - acctBalance;
-            const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
-            if (eoaBalance < shortfall) {
-                throw new AgetherError(`Insufficient USDC for repay. Need ${ethers.formatUnits(approveAmount, 6)} USDC, ` +
-                    `AgentAccount has ${ethers.formatUnits(acctBalance, 6)}, EOA has ${ethers.formatUnits(eoaBalance, 6)}.`, 'INSUFFICIENT_BALANCE');
-            }
-            const transferTx = await usdcContract.transfer(acctAddr, shortfall);
-            await transferTx.wait();
-            this._refreshSigner();
-        }
-        // Batch: approve + repay
-        const targets = [usdcAddr, 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: usdcAmount, 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 = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo)
-            throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, 'UNKNOWN_COLLATERAL');
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const usdcAddr = this.config.contracts.usdc;
-        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());
-        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 USDC 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', 6);
-                    console.log(`[agether] dust borrow shares detected: ${dustBorrowShares} shares ≈ ${ethers.formatUnits(dustApproveAmount, 6)} USDC — 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 USDC to cover the dust repay
-            const usdcContract = new Contract(usdcAddr, ERC20_ABI, this._signer);
-            const acctBalance = await usdcContract.balanceOf(acctAddr);
-            if (acctBalance < dustApproveAmount) {
-                const shortfall = dustApproveAmount - acctBalance;
-                const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
-                if (eoaBalance >= shortfall) {
-                    console.log(`[agether] transferring ${ethers.formatUnits(shortfall, 6)} USDC from EOA → AgentAccount for dust repay`);
-                    const transferTx = await usdcContract.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 USDC → repay dust shares → withdraw collateral
-            const targets = [usdcAddr, 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,
-        };
-    }
-    /**
-     * Sponsor: transfer collateral to another agent's AgentAccount.
-     * (The agent must then supplyCollateral themselves via their own account.)
-     */
-    async sponsor(target, tokenSymbol, amount) {
-        const colInfo = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo)
-            throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, 'UNKNOWN_COLLATERAL');
-        let targetAddr;
-        if (target.address) {
-            targetAddr = target.address;
-        }
-        else if (target.agentId) {
-            targetAddr = await this.agether4337Factory.getAccount(BigInt(target.agentId));
-            if (targetAddr === ethers.ZeroAddress)
-                throw new AgetherError('Target agent has no account', 'NO_ACCOUNT');
-        }
-        else {
-            throw new AgetherError('Provide agentId or address', 'INVALID_TARGET');
-        }
-        const weiAmount = ethers.parseUnits(amount, colInfo.decimals);
-        const colToken = new Contract(colInfo.address, ERC20_ABI, this._signer);
-        const tx = await colToken.transfer(targetAddr, weiAmount);
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        return { tx: receipt.hash, targetAccount: targetAddr, targetAgentId: target.agentId };
-    }
-    // ════════════════════════════════════════════════════════
-    //  Reputation (Agether8004Scorer contract)
-    // ════════════════════════════════════════════════════════
-    async getCreditScore() {
-        if (!this.agentId)
-            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
-        return this.agether8004Scorer.getCreditScore(BigInt(this.agentId));
-    }
-    async getAttestation() {
-        if (!this.agentId)
-            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
-        const att = await this.agether8004Scorer.getAttestation(BigInt(this.agentId));
-        return { score: att.score, timestamp: att.timestamp, signer: att.signer };
-    }
-    async isEligible(minScore = 500n) {
-        if (!this.agentId)
-            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
-        const [eligible, currentScore] = await this.agether8004Scorer.isEligible(BigInt(this.agentId), minScore);
-        return { eligible, currentScore };
-    }
-    async isScoreFresh() {
-        if (!this.agentId)
-            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
-        const [fresh, age] = await this.agether8004Scorer.isScoreFresh(BigInt(this.agentId));
-        return { fresh, age };
-    }
-    // ════════════════════════════════════════════════════════
-    //  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);
-            this.validationModule = new Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-            this.agether8004Scorer = new Contract(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-            this.identityRegistry = new Contract(addrs.identityRegistry, IDENTITY_REGISTRY_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);
-            this.validationModule = new Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-            this.agether8004Scorer = new Contract(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-            this.identityRegistry = new Contract(addrs.identityRegistry, IDENTITY_REGISTRY_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');
-    }
-    /**
-     * Compute net deposited amount from Morpho Blue events (no DB/indexer).
-     *
-     * Reads Supply and Withdraw events for the lending side (supply/withdraw, NOT
-     * supplyCollateral/withdrawCollateral) filtered by our account address.
-     *
-     * netDeposited = Σ Supply.assets − Σ Withdraw.assets
-     *
-     * Uses eth_getLogs with topic filtering — free, fast, no infrastructure needed.
-     */
-    async _computeNetDeposited(marketId, accountAddr, morphoAddr) {
-        const morphoContract = new Contract(morphoAddr, MORPHO_BLUE_ABI, this.provider);
-        // Morpho event signatures:
-        //   Supply(bytes32 indexed id, address indexed caller, address indexed onBehalf, uint256 assets, uint256 shares)
-        //   Withdraw(bytes32 indexed id, address caller, address indexed onBehalf, address indexed receiver, uint256 assets, uint256 shares)
-        const paddedAccount = ethers.zeroPadValue(accountAddr, 32);
-        // Supply events: topic0=Supply, topic1=marketId, topic3=onBehalf (our account)
-        // Note: topic2=caller (indexed), topic3=onBehalf (indexed)
-        const supplyFilter = {
-            address: morphoAddr,
-            topics: [
-                morphoContract.interface.getEvent('Supply').topicHash,
-                marketId, // topic1: indexed id
-                null, // topic2: indexed caller (any)
-                paddedAccount, // topic3: indexed onBehalf
-            ],
-            fromBlock: 0,
-            toBlock: 'latest',
-        };
-        // Withdraw events: topic0=Withdraw, topic1=marketId, topic2=onBehalf (our account)
-        // In Withdraw event: id indexed, caller NOT indexed, onBehalf indexed, receiver indexed
-        // So indexed topics: [Withdraw.sig, id, onBehalf, receiver]
-        const withdrawFilter = {
-            address: morphoAddr,
-            topics: [
-                morphoContract.interface.getEvent('Withdraw').topicHash,
-                marketId, // topic1: indexed id
-                paddedAccount, // topic2: indexed onBehalf
-                null, // topic3: indexed receiver (any)
-            ],
-            fromBlock: 0,
-            toBlock: 'latest',
-        };
-        let totalSupplied = 0n;
-        let totalWithdrawn = 0n;
-        try {
-            const supplyLogs = await this.provider.getLogs(supplyFilter);
-            for (const log of supplyLogs) {
-                // Non-indexed data: (uint256 assets, uint256 shares)
-                const decoded = ethers.AbiCoder.defaultAbiCoder().decode(['uint256', 'uint256'], log.data);
-                totalSupplied += decoded[0];
-            }
-        }
-        catch (e) {
-            console.warn('[agether] _computeNetDeposited: Supply logs fetch failed:', e instanceof Error ? e.message : e);
-        }
-        try {
-            const withdrawLogs = await this.provider.getLogs(withdrawFilter);
-            for (const log of withdrawLogs) {
-                // Non-indexed data for Withdraw: (address caller, uint256 assets, uint256 shares)
-                // Because `caller` is NOT indexed in Withdraw, it appears in data
-                const decoded = ethers.AbiCoder.defaultAbiCoder().decode(['address', 'uint256', 'uint256'], log.data);
-                totalWithdrawn += decoded[1]; // assets is second field
-            }
-        }
-        catch (e) {
-            console.warn('[agether] _computeNetDeposited: Withdraw logs fetch failed:', e instanceof Error ? e.message : e);
-        }
-        return totalSupplied > totalWithdrawn ? totalSupplied - totalWithdrawn : 0n;
-    }
-}