@agether/sdk 1.5.0 → 1.5.2

package/dist/index.mjs

@@ -1,207 +1,26 @@
-// 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: "0xeB72f248Ad9F4bf4024e8D9da75cf7AAD37B58f5",
-    validationRegistry: "0x8842f2383A86134Dd80c3Ecf6Bbae2e38396A5ec",
-    agentReputation: "0xF1bed094D4E33E47CC8C72E086FFFde09e2211b4",
-    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
-    }
-  };
-}
+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";
 var AgetherClient = class _AgetherClient {
   constructor(options) {
     this.config = options.config;
@@ -379,889 +198,12 @@ var AgetherClient = class _AgetherClient {
   }
 };
 
-// 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.provider);
-    this.identityRegistry = new Contract2(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this.provider);
-  }
-  // ════════════════════════════════════════════════════════
-  //  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;
-  }
-  /**
-   * 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 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
+import axios from "axios";
 var ScoringClient = class {
   constructor(config) {
     this.endpoint = config.endpoint;
-    this.client = axios2.create({
+    this.client = axios.create({
       baseURL: config.endpoint,
       headers: { "Content-Type": "application/json" },
       timeout: 3e4
@@ -1348,7 +290,7 @@ var ScoringClient = class {
 };
 
 // src/clients/AgentIdentityClient.ts
-import { ethers as ethers4 } from "ethers";
+import { ethers as ethers2 } from "ethers";
 var ERC8004_IDENTITY_ABI = [
   // Registration
   "function register() returns (uint256)",
@@ -1390,8 +332,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 ethers4.Contract(identityAddr, ERC8004_IDENTITY_ABI, this.signer);
-    this.reputationRegistry = new ethers4.Contract(reputationAddr, ERC8004_REPUTATION_ABI, this.signer);
+    this.identityRegistry = new ethers2.Contract(identityAddr, ERC8004_IDENTITY_ABI, this.signer);
+    this.reputationRegistry = new ethers2.Contract(reputationAddr, ERC8004_REPUTATION_ABI, this.signer);
   }
   // ============ Identity Functions ============
   /**
@@ -1458,7 +400,7 @@ var AgentIdentityClient = class {
   async registerWithMetadata(agentURI, metadata) {
     const metadataEntries = metadata.map((m) => ({
       key: m.key,
-      value: ethers4.toUtf8Bytes(m.value)
+      value: ethers2.toUtf8Bytes(m.value)
     }));
     const tx = await this.identityRegistry["register(string,tuple(string,bytes)[])"](
       agentURI,
@@ -1495,7 +437,7 @@ var AgentIdentityClient = class {
     const tx = await this.identityRegistry.setMetadata(
       agentId,
       key,
-      ethers4.toUtf8Bytes(value)
+      ethers2.toUtf8Bytes(value)
     );
     const receipt = await tx.wait();
     return receipt.hash;
@@ -1505,7 +447,7 @@ var AgentIdentityClient = class {
    */
   async getMetadata(agentId, key) {
     const value = await this.identityRegistry.getMetadata(agentId, key);
-    return ethers4.toUtf8String(value);
+    return ethers2.toUtf8String(value);
   }
   /**
    * Transfer agent to new owner
@@ -1539,8 +481,8 @@ var AgentIdentityClient = class {
    * Give feedback to an agent
    */
   async giveFeedback(input) {
-    const feedbackHash = ethers4.keccak256(
-      ethers4.AbiCoder.defaultAbiCoder().encode(
+    const feedbackHash = ethers2.keccak256(
+      ethers2.AbiCoder.defaultAbiCoder().encode(
         ["uint256", "int128", "uint256"],
         [input.agentId, input.value, Date.now()]
       )