@agether/sdk 1.5.5 → 1.6.1

package/dist/chunk-OMCWZ3VN.mjs

@@ -1,840 +0,0 @@
-// src/clients/MorphoClient.ts
-import { ethers, Contract } from "ethers";
-import axios from "axios";
-
-// src/types/index.ts
-var ChainId = /* @__PURE__ */ ((ChainId2) => {
-  ChainId2[ChainId2["Ethereum"] = 1] = "Ethereum";
-  ChainId2[ChainId2["Base"] = 8453] = "Base";
-  ChainId2[ChainId2["BaseSepolia"] = 84532] = "BaseSepolia";
-  ChainId2[ChainId2["Sepolia"] = 11155111] = "Sepolia";
-  ChainId2[ChainId2["Hardhat"] = 31337] = "Hardhat";
-  return ChainId2;
-})(ChainId || {});
-var AgetherError = class extends Error {
-  constructor(message, code, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "AgetherError";
-  }
-};
-var InsufficientBalanceError = class extends AgetherError {
-  constructor(available, required) {
-    super(
-      `Insufficient balance: available ${available}, required ${required}`,
-      "INSUFFICIENT_BALANCE",
-      { available: available.toString(), required: required.toString() }
-    );
-  }
-};
-var ScoringRejectedError = class extends AgetherError {
-  constructor(riskScore, reason) {
-    super(
-      `Scoring rejected: risk score ${riskScore}${reason ? `, ${reason}` : ""}`,
-      "SCORING_REJECTED",
-      { riskScore, reason }
-    );
-  }
-};
-var AgentNotApprovedError = class extends AgetherError {
-  constructor(agentId) {
-    super(
-      `Agent ${agentId} is not KYA-approved. Submit code for validation first.`,
-      "AGENT_NOT_APPROVED",
-      { agentId: agentId.toString() }
-    );
-  }
-};
-
-// src/utils/abis.ts
-var IDENTITY_REGISTRY_ABI = [
-  "function ownerOf(uint256 agentId) view returns (address)",
-  "function balanceOf(address owner) view returns (uint256)",
-  "function totalSupply() view returns (uint256)",
-  "function exists(uint256 agentId) view returns (bool)",
-  "function register() returns (uint256 agentId)",
-  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
-];
-var ACCOUNT_FACTORY_ABI = [
-  "function getAccount(uint256 agentId) view returns (address)",
-  "function accountExists(uint256 agentId) view returns (bool)",
-  "function predictAddress(uint256 agentId) view returns (address)",
-  "function totalAccounts() view returns (uint256)",
-  "function getAgentId(address account) view returns (uint256)",
-  "function createAccount(uint256 agentId) returns (address account)",
-  "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
-];
-var AGENT_ACCOUNT_ABI = [
-  "function agentId() view returns (uint256)",
-  "function owner() view returns (address)",
-  "function factory() view returns (address)",
-  "function validationRegistry() view returns (address)",
-  "function identityRegistry() view returns (address)",
-  "function balanceOf(address token) view returns (uint256)",
-  "function ethBalance() view returns (uint256)",
-  "function execute(address target, uint256 value, bytes data) payable returns (bytes)",
-  "function executeBatch(address[] targets, uint256[] values, bytes[] datas) payable returns (bytes[])",
-  "function fund(address token, uint256 amount)",
-  "function withdraw(address token, uint256 amount, address to)",
-  "function withdrawETH(uint256 amount, address to)",
-  "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
-];
-var AGENT_REPUTATION_ABI = [
-  "function getCreditScore(uint256 agentId) view returns (uint256)",
-  "function getAttestation(uint256 agentId) view returns (tuple(uint256 score, uint256 timestamp, address signer))",
-  "function isScoreFresh(uint256 agentId) view returns (bool fresh, uint256 age)",
-  "function isEligible(uint256 agentId, uint256 minScore) view returns (bool eligible, uint256 currentScore)",
-  "function oracleSigner() view returns (address)",
-  "function submitScore(uint256 agentId, uint256 score_, uint256 timestamp_, bytes signature)",
-  "function setOracleSigner(address signer_)",
-  "event ScoreUpdated(uint256 indexed agentId, uint256 score, uint256 timestamp, address signer)"
-];
-var VALIDATION_REGISTRY_ABI = [
-  "function isAgentCodeApproved(uint256 agentId) view returns (bool)",
-  "function isAgentCodeApprovedForTag(uint256 agentId, string tag) view returns (bool)",
-  "function getAgentValidations(uint256 agentId) view returns (bytes32[])",
-  "function getValidation(bytes32 requestHash) view returns (tuple(address validatorAddress, uint256 agentId, string requestURI, uint8 response, string responseURI, bytes32 responseHash, string tag, uint256 requestedAt, uint256 respondedAt, bool hasResponse))"
-];
-var MORPHO_BLUE_ABI = [
-  // Supply & Withdraw (lending side)
-  "function supply(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) returns (uint256 assetsSupplied, uint256 sharesSupplied)",
-  "function withdraw(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn)",
-  // Collateral
-  "function supplyCollateral(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, address onBehalf, bytes data)",
-  "function withdrawCollateral(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, address onBehalf, address receiver)",
-  // Borrow & Repay
-  "function borrow(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) returns (uint256 assetsBorrowed, uint256 sharesBorrowed)",
-  "function repay(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) returns (uint256 assetsRepaid, uint256 sharesRepaid)",
-  // Authorization
-  "function setAuthorization(address authorized, bool newIsAuthorized)",
-  "function isAuthorized(address authorizer, address authorized) view returns (bool)",
-  // Views
-  "function position(bytes32 id, address user) view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral)",
-  "function market(bytes32 id) view returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
-  "function idToMarketParams(bytes32 id) view returns (tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv))"
-];
-var ERC20_ABI = [
-  "function balanceOf(address account) view returns (uint256)",
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "function approve(address spender, uint256 amount) returns (bool)",
-  "function transfer(address to, uint256 amount) returns (bool)",
-  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-  "function decimals() view returns (uint8)",
-  "function symbol() view returns (string)",
-  "function name() view returns (string)"
-];
-
-// src/utils/config.ts
-var CONTRACT_ADDRESSES = {
-  [1 /* Ethereum */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
-  },
-  [8453 /* Base */]: {
-    accountFactory: "0x7D5D56416bAEA06a9DCBe3092eF335724C6320a0",
-    validationRegistry: "0xd196C32D2149270F56E209ba7aEE67CE9ceD2001",
-    agentReputation: "0x65c9cA1211809D3CF3A2707558198eb2b2bE623c",
-    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
-  },
-  [84532 /* BaseSepolia */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    morphoBlue: "0x0000000000000000000000000000000000000000"
-  },
-  [11155111 /* Sepolia */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    morphoBlue: "0x0000000000000000000000000000000000000000"
-  },
-  [31337 /* Hardhat */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    morphoBlue: "0x0000000000000000000000000000000000000000"
-  }
-};
-var RPC_URLS = {
-  [1 /* Ethereum */]: "https://ethereum-rpc.publicnode.com",
-  [8453 /* Base */]: "https://base-rpc.publicnode.com",
-  [84532 /* BaseSepolia */]: "https://sepolia.base.org",
-  [11155111 /* Sepolia */]: "https://rpc.sepolia.org",
-  [31337 /* Hardhat */]: "http://127.0.0.1:8545"
-};
-var SCORING_ENDPOINTS = {
-  [1 /* Ethereum */]: "https://scoring.agether.ai/v1",
-  [8453 /* Base */]: "http://95.179.189.214:3001",
-  [84532 /* BaseSepolia */]: "http://95.179.189.214:3001",
-  [11155111 /* Sepolia */]: "https://scoring-testnet.agether.ai/v1",
-  [31337 /* Hardhat */]: "http://127.0.0.1:3001"
-};
-function getDefaultConfig(chainId) {
-  return {
-    chainId,
-    rpcUrl: RPC_URLS[chainId],
-    contracts: CONTRACT_ADDRESSES[chainId],
-    scoringEndpoint: SCORING_ENDPOINTS[chainId]
-  };
-}
-function createConfig(chainId, options) {
-  const defaultConfig = getDefaultConfig(chainId);
-  return {
-    ...defaultConfig,
-    ...options,
-    contracts: {
-      ...defaultConfig.contracts,
-      ...options?.contracts
-    }
-  };
-}
-
-// src/clients/MorphoClient.ts
-var BASE_COLLATERALS = {
-  WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
-  wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
-  cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
-};
-var MORPHO_API_URL = "https://api.morpho.org/graphql";
-var morphoIface = new ethers.Interface(MORPHO_BLUE_ABI);
-var erc20Iface = new ethers.Interface(ERC20_ABI);
-var MorphoClient = class {
-  constructor(config) {
-    this._marketCache = /* @__PURE__ */ new Map();
-    this._discoveredAt = 0;
-    const chainId = config.chainId ?? 8453 /* 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;
-  }
-  /**
-   * Register: create ERC-8004 identity + AgentAccount in one flow.
-   * If already registered, returns existing state.
-   */
-  async register(_name) {
-    const eoaAddr = this.wallet.address;
-    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 };
-      }
-    }
-    const balance = await this.identityRegistry.balanceOf(eoaAddr);
-    let agentId;
-    if (balance > 0n && this.agentId) {
-      agentId = BigInt(this.agentId);
-    } else if (balance > 0n) {
-      throw new AgetherError(
-        "Wallet already has an ERC-8004 identity but agentId is unknown. Pass agentId in config.",
-        "AGENT_ID_UNKNOWN"
-      );
-    } else {
-      const regTx = await this.identityRegistry.register();
-      const regReceipt = await regTx.wait();
-      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");
-    }
-    this.agentId = agentId.toString();
-    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 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);
-    const result = {
-      agentId: this.agentId || "?",
-      address: eoaAddr,
-      eth: ethers.formatEther(ethBal),
-      usdc: ethers.formatUnits(usdcBal, 6)
-    };
-    try {
-      const acctAddr = await this.getAccountAddress();
-      const acctEth = await this.provider.getBalance(acctAddr);
-      const acctUsdc = await usdc.balanceOf(acctAddr);
-      result.agentAccount = {
-        address: acctAddr,
-        eth: ethers.formatEther(acctEth),
-        usdc: ethers.formatUnits(acctUsdc, 6)
-      };
-    } catch {
-    }
-    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 < 3e5) {
-      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: 1e4 });
-      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();
-      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 {
-      return this._discoveredMarkets ?? [];
-    }
-  }
-  /**
-   * Get MarketParams for a collateral token.
-   * Tries cache → API → on-chain idToMarketParams.
-   */
-  async findMarketForCollateral(collateralSymbolOrAddress) {
-    const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-    const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
-    const cached = this._marketCache.get(colAddr);
-    if (cached) return cached;
-    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;
-        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 {
-          }
-        }
-        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
-    };
-  }
-  // ════════════════════════════════════════════════════════
-  //  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;
-    const colToken = new Contract(colInfo.address, ERC20_ABI, this.wallet);
-    const transferTx = await colToken.transfer(acctAddr, weiAmount);
-    await transferTx.wait();
-    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;
-    let params;
-    let usedToken = tokenSymbol || "WETH";
-    if (marketParams) {
-      params = marketParams;
-    } else if (tokenSymbol) {
-      params = await this.findMarketForCollateral(tokenSymbol);
-    } else {
-      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;
-    const colToken = new Contract(colInfo.address, ERC20_ABI, this.wallet);
-    const transferTx = await colToken.transfer(acctAddr, colWei);
-    await transferTx.wait();
-    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 amount = ethers.parseUnits(usdcAmount, 6);
-    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;
-    }
-    const targets = [usdcAddr, morphoAddr];
-    const values = [0n, 0n];
-    const datas = [
-      erc20Iface.encodeFunctionData("approve", [morphoAddr, amount]),
-      morphoIface.encodeFunctionData("repay", [
-        this._toTuple(params),
-        amount,
-        0n,
-        acctAddr,
-        "0x"
-      ])
-    ];
-    const receipt = await this.batch(targets, values, datas);
-    let remainingDebt = "0";
-    try {
-      const status = await this.getStatus();
-      remainingDebt = status.totalDebt;
-    } catch {
-    }
-    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;
-    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);
-    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 {
-    }
-    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);
-    let gasLimit;
-    try {
-      const estimate = await account.execute.estimateGas(target, value, data);
-      gasLimit = estimate * 130n / 100n;
-    } 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);
-    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;
-      }
-    }
-    const params = await this.findMarketForCollateral("WETH");
-    return { params, symbol: "WETH" };
-  }
-};
-
-export {
-  ChainId,
-  AgetherError,
-  InsufficientBalanceError,
-  ScoringRejectedError,
-  AgentNotApprovedError,
-  IDENTITY_REGISTRY_ABI,
-  ACCOUNT_FACTORY_ABI,
-  AGENT_ACCOUNT_ABI,
-  AGENT_REPUTATION_ABI,
-  VALIDATION_REGISTRY_ABI,
-  MORPHO_BLUE_ABI,
-  ERC20_ABI,
-  getDefaultConfig,
-  createConfig,
-  MorphoClient
-};