@agether/sdk 1.5.2 → 1.5.4

package/dist/index.mjs

@@ -1,26 +1,207 @@
-import {
-  ACCOUNT_FACTORY_ABI,
-  AGENT_ACCOUNT_ABI,
-  AGENT_REPUTATION_ABI,
-  AgentNotApprovedError,
-  AgetherError,
-  ChainId,
-  ERC20_ABI,
-  IDENTITY_REGISTRY_ABI,
-  InsufficientBalanceError,
-  MORPHO_BLUE_ABI,
-  MorphoClient,
-  ScoringRejectedError,
-  VALIDATION_REGISTRY_ABI,
-  createConfig,
-  getDefaultConfig
-} from "./chunk-GAFDBPDW.mjs";
-import {
-  X402Client
-} from "./chunk-PTXYOTCG.mjs";
-
 // src/clients/AgetherClient.ts
 import { ethers, Contract } from "ethers";
+
+// src/types/index.ts
+var ChainId = /* @__PURE__ */ ((ChainId3) => {
+  ChainId3[ChainId3["Ethereum"] = 1] = "Ethereum";
+  ChainId3[ChainId3["Base"] = 8453] = "Base";
+  ChainId3[ChainId3["BaseSepolia"] = 84532] = "BaseSepolia";
+  ChainId3[ChainId3["Sepolia"] = 11155111] = "Sepolia";
+  ChainId3[ChainId3["Hardhat"] = 31337] = "Hardhat";
+  return ChainId3;
+})(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/AgetherClient.ts
 var AgetherClient = class _AgetherClient {
   constructor(options) {
     this.config = options.config;
@@ -198,12 +379,893 @@ var AgetherClient = class _AgetherClient {
   }
 };
 
-// src/clients/ScoringClient.ts
+// src/clients/MorphoClient.ts
+import { ethers as ethers2, Contract as Contract2 } from "ethers";
 import axios from "axios";
+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 ethers2.Interface(MORPHO_BLUE_ABI);
+var erc20Iface = new ethers2.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 ethers2.JsonRpcProvider(config.rpcUrl || defaultCfg.rpcUrl);
+    this.wallet = new ethers2.Wallet(config.privateKey, this.provider);
+    const addrs = { ...defaultCfg.contracts, ...config.contracts };
+    this.accountFactory = new Contract2(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this.wallet);
+    this.morphoBlue = new Contract2(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
+    this.agentReputation = new Contract2(addrs.agentReputation, AGENT_REPUTATION_ABI, this.wallet);
+    this.identityRegistry = new Contract2(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 === ethers2.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;
+    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 };
+      }
+    }
+    let agentId;
+    if (this.agentId) {
+      const balance = await this.identityRegistry.balanceOf(eoaAddr);
+      if (balance > 0n) {
+        agentId = BigInt(this.agentId);
+      } else {
+        agentId = await this._mintNewIdentity();
+      }
+    } else {
+      agentId = await this._mintNewIdentity();
+    }
+    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 Contract2(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: ethers2.formatEther(ethBal),
+      usdc: ethers2.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: ethers2.formatEther(acctEth),
+        usdc: ethers2.formatUnits(acctUsdc, 6)
+      };
+    } catch {
+    }
+    return result;
+  }
+  /** Transfer USDC from EOA to AgentAccount. */
+  async fundAccount(usdcAmount) {
+    const acctAddr = await this.getAccountAddress();
+    const usdc = new Contract2(this.config.contracts.usdc, ERC20_ABI, this.wallet);
+    const amount = ethers2.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: ethers2.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 !== ethers2.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 === ethers2.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: ethers2.formatUnits(pos.collateral, m.collateralAsset.decimals),
+          borrowShares: pos.borrowShares.toString(),
+          supplyShares: pos.supplyShares.toString(),
+          debt: ethers2.formatUnits(debt, 6)
+        });
+      } catch {
+        continue;
+      }
+    }
+    return {
+      agentId: this.agentId || "?",
+      agentAccount: acctAddr,
+      totalDebt: ethers2.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 = ethers2.parseUnits(amount, colInfo.decimals);
+    const morphoAddr = this.config.contracts.morphoBlue;
+    const colToken = new Contract2(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 = ethers2.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 = ethers2.parseUnits(collateralAmount, colInfo.decimals);
+    const borrowWei = ethers2.parseUnits(borrowUsdcAmount, 6);
+    const morphoAddr = this.config.contracts.morphoBlue;
+    const colToken = new Contract2(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 = ethers2.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 = ethers2.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 = ethers2.formatUnits(pos.collateral, colInfo.decimals);
+      }
+    } catch {
+    }
+    return {
+      tx: receipt.hash,
+      token: tokenSymbol,
+      amount: amount === "all" ? ethers2.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 === ethers2.ZeroAddress) throw new AgetherError("Target agent has no account", "NO_ACCOUNT");
+    } else {
+      throw new AgetherError("Provide agentId or address", "INVALID_TARGET");
+    }
+    const weiAmount = ethers2.parseUnits(amount, colInfo.decimals);
+    const colToken = new Contract2(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 Contract2(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 Contract2(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 === ethers2.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" };
+  }
+};
+
+// src/clients/ScoringClient.ts
+import axios2 from "axios";
+
+// src/clients/X402Client.ts
+import { ethers as ethers3 } from "ethers";
+var USDC_DOMAINS = {
+  "eip155:1": { name: "USD Coin", version: "2", address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" },
+  "eip155:8453": { name: "USD Coin", version: "2", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" },
+  "eip155:84532": { name: "USD Coin", version: "2", address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e" },
+  "eip155:42161": { name: "USD Coin", version: "2", address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" },
+  "eip155:10": { name: "USD Coin", version: "2", address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" }
+};
+function chainIdFromNetwork(network) {
+  const m = network.match(/^eip155:(\d+)$/);
+  return m ? Number(m[1]) : 1;
+}
+var X402Client = class {
+  constructor(config) {
+    this.config = config;
+    const provider = new ethers3.JsonRpcProvider(config.rpcUrl);
+    this.wallet = new ethers3.Wallet(config.privateKey, provider);
+  }
+  async get(url, opts) {
+    return this.request(url, { ...opts, method: "GET" });
+  }
+  async post(url, body, opts) {
+    return this.request(url, {
+      ...opts,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0,
+      headers: { "Content-Type": "application/json", ...opts?.headers }
+    });
+  }
+  getAddress() {
+    return this.wallet.address;
+  }
+  // ──────────── Core request / 402-retry loop ────────────
+  async request(url, options) {
+    try {
+      console.log("   [1/4] Calling resource server\u2026");
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...options?.headers,
+          "X-Agent-Id": this.config.agentId || ""
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        return { success: true, data };
+      }
+      if (response.status !== 402) {
+        return { success: false, error: `HTTP ${response.status}: ${await response.text()}` };
+      }
+      console.log("   [2/4] 402 received \u2014 parsing payment requirements\u2026");
+      const parsed = await this.parsePaymentRequired(response);
+      if (!parsed) {
+        return { success: false, error: "Could not parse payment requirements from 402 response" };
+      }
+      const { requirements, resource } = parsed;
+      console.log(`         scheme  : ${requirements.scheme}`);
+      console.log(`         network : ${requirements.network}`);
+      console.log(`         amount  : ${requirements.amount} (atomic)`);
+      console.log(`         asset   : ${requirements.asset}`);
+      console.log(`         payTo   : ${requirements.payTo}`);
+      console.log("   [3/4] Signing EIP-3009 transferWithAuthorization\u2026");
+      const paymentPayload = await this.buildPaymentPayload(requirements, resource, url);
+      const paymentB64 = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
+      await this.riskCheck(paymentPayload, requirements);
+      console.log("   [4/4] Retrying with PAYMENT-SIGNATURE header\u2026");
+      const paidResponse = await fetch(url, {
+        ...options,
+        headers: {
+          ...options?.headers,
+          "X-Agent-Id": this.config.agentId || "",
+          // v2 header
+          "PAYMENT-SIGNATURE": paymentB64,
+          // v1 compat header (some servers still use this)
+          "X-PAYMENT": paymentB64
+        }
+      });
+      if (paidResponse.ok) {
+        const data = await paidResponse.json();
+        const settlementHeader = paidResponse.headers.get("PAYMENT-RESPONSE") || paidResponse.headers.get("X-PAYMENT-RESPONSE");
+        let txHash;
+        if (settlementHeader) {
+          try {
+            const settlement = JSON.parse(Buffer.from(settlementHeader, "base64").toString("utf-8"));
+            txHash = settlement.transaction;
+          } catch {
+          }
+        }
+        return {
+          success: true,
+          data,
+          paymentInfo: {
+            amount: requirements.amount,
+            asset: requirements.extra?.name || "USDC",
+            network: requirements.network,
+            txHash
+          }
+        };
+      }
+      const errBody = await paidResponse.text();
+      return { success: false, error: `Payment rejected (HTTP ${paidResponse.status}): ${errBody}` };
+    } catch (error) {
+      return { success: false, error: `Request failed: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
+  // ──────────── Parse 402 response ────────────
+  async parsePaymentRequired(response) {
+    const prHeader = response.headers.get("PAYMENT-REQUIRED") || response.headers.get("x-payment-required");
+    if (prHeader) {
+      try {
+        const decoded = JSON.parse(Buffer.from(prHeader, "base64").toString("utf-8"));
+        if (decoded.accepts?.length) {
+          return { requirements: decoded.accepts[0], resource: decoded.resource };
+        }
+      } catch {
+      }
+    }
+    try {
+      const body = await response.json();
+      if (body.accepts && Array.isArray(body.accepts) && body.accepts.length > 0) {
+        return { requirements: body.accepts[0], resource: body.resource };
+      }
+      if (body.paymentRequirements) {
+        const pr = Array.isArray(body.paymentRequirements) ? body.paymentRequirements[0] : body.paymentRequirements;
+        return { requirements: pr, resource: body.resource };
+      }
+      if (body.scheme && body.network) {
+        return { requirements: body, resource: body.resource };
+      }
+    } catch {
+    }
+    const wwwAuth = response.headers.get("WWW-Authenticate");
+    if (wwwAuth) {
+      const m = wwwAuth.match(/x402[^"]*"([^"]+)"/);
+      if (m) {
+        try {
+          const decoded = JSON.parse(Buffer.from(m[1], "base64").toString("utf-8"));
+          const reqs = Array.isArray(decoded) ? decoded[0] : decoded;
+          return { requirements: reqs };
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  // ──────────── Build x402 v2 PaymentPayload with EIP-3009 ────────────
+  //
+  // If an AgentAccount is configured, we use it as the `from` address
+  // (smart wallet pays directly). The AgentAccount implements EIP-1271
+  // so USDC's transferWithAuthorization will call isValidSignature()
+  // to verify the owner's ECDSA signature. The facilitator detects
+  // the >65-byte or smart-wallet case and uses the bytes overload.
+  async buildPaymentPayload(reqs, resource, url) {
+    const now = Math.floor(Date.now() / 1e3);
+    const validAfter = String(now - 60);
+    const validBefore = String(now + (reqs.maxTimeoutSeconds || 300));
+    const nonce = ethers3.hexlify(ethers3.randomBytes(32));
+    const chainId = chainIdFromNetwork(reqs.network);
+    const usdcDomain = USDC_DOMAINS[reqs.network] || USDC_DOMAINS["eip155:1"];
+    const payerAddress = this.config.accountAddress || this.wallet.address;
+    const isSmartWallet = !!this.config.accountAddress;
+    const domain = {
+      name: usdcDomain.name,
+      version: usdcDomain.version,
+      chainId,
+      verifyingContract: reqs.asset || usdcDomain.address
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const value = {
+      from: payerAddress,
+      // AgentAccount or EOA
+      to: reqs.payTo,
+      value: reqs.amount,
+      validAfter,
+      validBefore,
+      nonce
+    };
+    let signature = await this.wallet.signTypedData(domain, types, value);
+    if (isSmartWallet) {
+      signature = signature + "00";
+    }
+    if (isSmartWallet) {
+      console.log(`         \u2713 Signed for AgentAccount ${payerAddress.slice(0, 10)}\u2026 (EIP-1271, chain=${chainId})`);
+    } else {
+      console.log(`         \u2713 Signed (from=${payerAddress.slice(0, 10)}\u2026, chain=${chainId})`);
+    }
+    return {
+      x402Version: 2,
+      resource: resource || { url, description: "", mimeType: "application/json" },
+      accepted: {
+        scheme: reqs.scheme,
+        network: reqs.network,
+        amount: reqs.amount,
+        asset: reqs.asset,
+        payTo: reqs.payTo,
+        maxTimeoutSeconds: reqs.maxTimeoutSeconds,
+        extra: reqs.extra || {}
+      },
+      payload: {
+        signature,
+        authorization: {
+          from: payerAddress,
+          // AgentAccount address — facilitator checks balance here
+          to: reqs.payTo,
+          value: reqs.amount,
+          validAfter,
+          validBefore,
+          nonce
+        }
+      }
+    };
+  }
+  // ──────────── Risk check via our backend ────────────
+  async riskCheck(paymentPayload, reqs) {
+    try {
+      const verifyUrl = `${this.config.backendUrl}/x402/verify`;
+      const resp = await fetch(verifyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Agent-Id": this.config.agentId || "",
+          ...this.config.accountAddress ? { "X-Agent-Account": this.config.accountAddress } : {}
+        },
+        body: JSON.stringify({
+          x402Version: 2,
+          paymentPayload,
+          paymentRequirements: reqs
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (resp.ok) {
+        const result = await resp.json();
+        const decision = resp.headers.get("X-Risk-Decision") || (result.isValid ? "allow" : "unknown");
+        const score = resp.headers.get("X-Risk-Score") || "?";
+        console.log(`         \u2713 Risk check: ${decision} (score=${score})`);
+      } else {
+        console.log(`         \u26A0 Risk check failed (HTTP ${resp.status}) \u2014 continuing anyway`);
+      }
+    } catch {
+      console.log("         \u26A0 Risk check unavailable \u2014 continuing");
+    }
+  }
+};
+
+// src/clients/ScoringClient.ts
 var ScoringClient = class {
   constructor(config) {
     this.endpoint = config.endpoint;
-    this.client = axios.create({
+    this.client = axios2.create({
       baseURL: config.endpoint,
       headers: { "Content-Type": "application/json" },
       timeout: 3e4
@@ -290,7 +1352,7 @@ var ScoringClient = class {
 };
 
 // src/clients/AgentIdentityClient.ts
-import { ethers as ethers2 } from "ethers";
+import { ethers as ethers4 } from "ethers";
 var ERC8004_IDENTITY_ABI = [
   // Registration
   "function register() returns (uint256)",
@@ -332,8 +1394,8 @@ var AgentIdentityClient = class {
     this.signer = options.signer;
     const identityAddr = options.config.contracts?.identityRegistry || ERC8004_SEPOLIA.identityRegistry;
     const reputationAddr = options.config.contracts?.reputationRegistry || ERC8004_SEPOLIA.reputationRegistry;
-    this.identityRegistry = new ethers2.Contract(identityAddr, ERC8004_IDENTITY_ABI, this.signer);
-    this.reputationRegistry = new ethers2.Contract(reputationAddr, ERC8004_REPUTATION_ABI, this.signer);
+    this.identityRegistry = new ethers4.Contract(identityAddr, ERC8004_IDENTITY_ABI, this.signer);
+    this.reputationRegistry = new ethers4.Contract(reputationAddr, ERC8004_REPUTATION_ABI, this.signer);
   }
   // ============ Identity Functions ============
   /**
@@ -400,7 +1462,7 @@ var AgentIdentityClient = class {
   async registerWithMetadata(agentURI, metadata) {
     const metadataEntries = metadata.map((m) => ({
       key: m.key,
-      value: ethers2.toUtf8Bytes(m.value)
+      value: ethers4.toUtf8Bytes(m.value)
     }));
     const tx = await this.identityRegistry["register(string,tuple(string,bytes)[])"](
       agentURI,
@@ -437,7 +1499,7 @@ var AgentIdentityClient = class {
     const tx = await this.identityRegistry.setMetadata(
       agentId,
       key,
-      ethers2.toUtf8Bytes(value)
+      ethers4.toUtf8Bytes(value)
     );
     const receipt = await tx.wait();
     return receipt.hash;
@@ -447,7 +1509,7 @@ var AgentIdentityClient = class {
    */
   async getMetadata(agentId, key) {
     const value = await this.identityRegistry.getMetadata(agentId, key);
-    return ethers2.toUtf8String(value);
+    return ethers4.toUtf8String(value);
   }
   /**
    * Transfer agent to new owner
@@ -481,8 +1543,8 @@ var AgentIdentityClient = class {
    * Give feedback to an agent
    */
   async giveFeedback(input) {
-    const feedbackHash = ethers2.keccak256(
-      ethers2.AbiCoder.defaultAbiCoder().encode(
+    const feedbackHash = ethers4.keccak256(
+      ethers4.AbiCoder.defaultAbiCoder().encode(
         ["uint256", "int128", "uint256"],
         [input.agentId, input.value, Date.now()]
       )