@agether/sdk 1.6.1 → 1.6.3

package/dist/clients/MorphoClient.js

@@ -0,0 +1,951 @@
+/**
+ * MorphoClient — Direct Morpho Blue lending via AgentAccount.executeBatch
+ *
+ * Architecture (no intermediary contract):
+ *   EOA → AgentAccount.executeBatch → Morpho Blue (direct)
+ *
+ * Batched operations:
+ *   - depositAndBorrow: [ERC20.approve, Morpho.supplyCollateral, Morpho.borrow]
+ *   - repay:            [ERC20.approve, Morpho.repay]
+ *   - supplyCollateral:  [ERC20.approve, Morpho.supplyCollateral]
+ *
+ * Market discovery via Morpho GraphQL API (https://api.morpho.org/graphql)
+ */
+import { ethers, Contract } from 'ethers';
+import axios from 'axios';
+import { AgetherError, ChainId, } from '../types';
+import { ACCOUNT_FACTORY_ABI, AGENT_ACCOUNT_ABI, AGENT_REPUTATION_ABI, IDENTITY_REGISTRY_ABI, MORPHO_BLUE_ABI, ERC20_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';
+// ── 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.provider = new ethers.JsonRpcProvider(config.rpcUrl || defaultCfg.rpcUrl);
+        this.wallet = new ethers.Wallet(config.privateKey, this.provider);
+        const addrs = { ...defaultCfg.contracts, ...config.contracts };
+        this.accountFactory = new Contract(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this.wallet);
+        this.morphoBlue = new Contract(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
+        this.agentReputation = new Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this.wallet);
+        this.identityRegistry = new Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this.wallet);
+    }
+    // ════════════════════════════════════════════════════════
+    //  Account Management
+    // ════════════════════════════════════════════════════════
+    /** Resolve the AgentAccount address (cached). */
+    async getAccountAddress() {
+        if (this._accountAddress)
+            return this._accountAddress;
+        if (!this.agentId)
+            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
+        const addr = await this.accountFactory.getAccount(BigInt(this.agentId));
+        if (addr === ethers.ZeroAddress) {
+            throw new AgetherError('No AgentAccount found. Call register() first.', 'NO_ACCOUNT');
+        }
+        this._accountAddress = addr;
+        return addr;
+    }
+    getAgentId() {
+        if (!this.agentId)
+            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
+        return this.agentId;
+    }
+    getWalletAddress() {
+        return this.wallet.address;
+    }
+    /** Mint a new ERC-8004 identity and return the agentId. */
+    async _mintNewIdentity() {
+        const regTx = await this.identityRegistry.register();
+        const regReceipt = await regTx.wait();
+        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 {
+                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 = this.wallet.address;
+        // Check if we already have an agentId
+        if (this.agentId) {
+            const exists = await this.accountFactory.accountExists(BigInt(this.agentId));
+            if (exists) {
+                const acct = await this.accountFactory.getAccount(BigInt(this.agentId));
+                this._accountAddress = acct;
+                return { agentId: this.agentId, address: eoaAddr, agentAccount: acct, alreadyRegistered: true };
+            }
+        }
+        // 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 on-chain 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.accountFactory.accountExists(agentId);
+        let txHash;
+        if (!acctExists) {
+            const tx = await this.accountFactory.createAccount(agentId);
+            const receipt = await tx.wait();
+            txHash = receipt.hash;
+        }
+        const acctAddr = await this.accountFactory.getAccount(agentId);
+        this._accountAddress = acctAddr;
+        return {
+            agentId: this.agentId,
+            address: eoaAddr,
+            agentAccount: acctAddr,
+            alreadyRegistered: acctExists,
+            tx: txHash,
+        };
+    }
+    /** Get ETH / USDC / collateral balances for EOA and AgentAccount. */
+    async getBalances() {
+        const eoaAddr = this.wallet.address;
+        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 {
+                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 {
+                    acctCollateral[symbol] = '0';
+                }
+            }
+            result.agentAccount = {
+                address: acctAddr,
+                eth: ethers.formatEther(acctEth),
+                usdc: ethers.formatUnits(acctUsdc, 6),
+                collateral: acctCollateral,
+            };
+        }
+        catch { /* no account yet */ }
+        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.wallet);
+        const amount = ethers.parseUnits(usdcAmount, 6);
+        const tx = await usdc.transfer(acctAddr, amount);
+        const receipt = await tx.wait();
+        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 {
+            // Fallback: return cached or empty
+            return this._discoveredMarkets ?? [];
+        }
+    }
+    /**
+     * Get MarketParams for a collateral token.
+     * Tries cache → API → on-chain 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 on-chain 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 on-chain 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
+                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
+                            : 0n;
+                        totalDebt += debt;
+                    }
+                    catch { /* skip */ }
+                }
+                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 {
+                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
+                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
+                    : 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 {
+                    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 {
+                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 {
+            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 {
+                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.',
+        };
+    }
+    // ════════════════════════════════════════════════════════
+    //  Lending Operations (all via AgentAccount.executeBatch)
+    // ════════════════════════════════════════════════════════
+    /**
+     * 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
+        const colToken = new Contract(colInfo.address, ERC20_ABI, this.wallet);
+        const transferTx = await colToken.transfer(acctAddr, weiAmount);
+        await transferTx.wait();
+        // 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;
+        }
+        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;
+        // Step 1: Transfer collateral from EOA → AgentAccount
+        const colToken = new Contract(colInfo.address, ERC20_ABI, this.wallet);
+        const transferTx = await colToken.transfer(acctAddr, colWei);
+        await transferTx.wait();
+        // 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 on-chain 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;
+            // Check if this covers the full debt — if so, switch to shares-based
+            try {
+                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);
+                    const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
+                    const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+                    const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+                    const currentDebt = totalBorrowShares > 0n
+                        ? (BigInt(pos.borrowShares) * totalBorrowAssets) / totalBorrowShares
+                        : 0n;
+                    // If repaying >= debt, use shares to clear dust
+                    if (repayAssets >= currentDebt && BigInt(pos.borrowShares) > 0n) {
+                        repayShares = BigInt(pos.borrowShares);
+                        repayAssets = 0n;
+                        approveAmount = currentDebt + 10n; // small buffer for rounding
+                    }
+                }
+            }
+            catch { /* fall through to asset-based repay */ }
+        }
+        // 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 { /* ignore */ }
+        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 dest = receiver || this.wallet.address;
+        // Handle 'all' — withdraw full collateral
+        let weiAmount;
+        if (amount === 'all') {
+            const markets = await this.getMarkets();
+            const market = markets.find((m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase());
+            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);
+        }
+        const data = morphoIface.encodeFunctionData('withdrawCollateral', [
+            this._toTuple(params), weiAmount, acctAddr, dest,
+        ]);
+        const receipt = await this.exec(morphoAddr, data);
+        // Read remaining collateral
+        let remainingCollateral = '0';
+        try {
+            const markets = await this.getMarkets();
+            const market = markets.find((m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase());
+            if (market) {
+                const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
+                remainingCollateral = ethers.formatUnits(pos.collateral, colInfo.decimals);
+            }
+        }
+        catch { /* ignore */ }
+        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.accountFactory.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.wallet);
+        const tx = await colToken.transfer(targetAddr, weiAmount);
+        const receipt = await tx.wait();
+        return { tx: receipt.hash, targetAccount: targetAddr, targetAgentId: target.agentId };
+    }
+    // ════════════════════════════════════════════════════════
+    //  Reputation (AgentReputation contract)
+    // ════════════════════════════════════════════════════════
+    async getCreditScore() {
+        if (!this.agentId)
+            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
+        return this.agentReputation.getCreditScore(BigInt(this.agentId));
+    }
+    async getAttestation() {
+        if (!this.agentId)
+            throw new AgetherError('agentId not set', 'NO_AGENT_ID');
+        const att = await this.agentReputation.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.agentReputation.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.agentReputation.isScoreFresh(BigInt(this.agentId));
+        return { fresh, age };
+    }
+    // ════════════════════════════════════════════════════════
+    //  Internal Helpers
+    // ════════════════════════════════════════════════════════
+    /**
+     * Execute a single call via AgentAccount.execute.
+     */
+    async exec(target, data, value = 0n) {
+        const acctAddr = await this.getAccountAddress();
+        const account = new Contract(acctAddr, AGENT_ACCOUNT_ABI, this.wallet);
+        // Estimate gas with buffer
+        let gasLimit;
+        try {
+            const estimate = await account.execute.estimateGas(target, value, data);
+            gasLimit = (estimate * 130n) / 100n; // 30% buffer
+        }
+        catch {
+            gasLimit = 500000n;
+        }
+        const tx = await account.execute(target, value, data, { gasLimit });
+        return tx.wait();
+    }
+    /**
+     * Execute multiple calls via AgentAccount.executeBatch.
+     */
+    async batch(targets, values, datas) {
+        const acctAddr = await this.getAccountAddress();
+        const account = new Contract(acctAddr, AGENT_ACCOUNT_ABI, this.wallet);
+        // Estimate gas with buffer
+        let gasLimit;
+        try {
+            const estimate = await account.executeBatch.estimateGas(targets, values, datas);
+            gasLimit = (estimate * 130n) / 100n;
+        }
+        catch {
+            gasLimit = 800000n;
+        }
+        const tx = await account.executeBatch(targets, values, datas, { gasLimit });
+        return tx.wait();
+    }
+    /** 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 {
+                continue;
+            }
+        }
+        // Default to WETH
+        const params = await this.findMarketForCollateral('WETH');
+        return { params, symbol: 'WETH' };
+    }
+}