@agether/sdk 1.4.1 → 1.5.1

package/dist/index.mjs

@@ -2,15 +2,6 @@
 import { ethers, Contract } from "ethers";
 
 // src/types/index.ts
-var CreditStatus = /* @__PURE__ */ ((CreditStatus3) => {
-  CreditStatus3[CreditStatus3["None"] = 0] = "None";
-  CreditStatus3[CreditStatus3["Pending"] = 1] = "Pending";
-  CreditStatus3[CreditStatus3["Active"] = 2] = "Active";
-  CreditStatus3[CreditStatus3["Frozen"] = 3] = "Frozen";
-  CreditStatus3[CreditStatus3["Closed"] = 4] = "Closed";
-  CreditStatus3[CreditStatus3["Defaulted"] = 5] = "Defaulted";
-  return CreditStatus3;
-})(CreditStatus || {});
 var ChainId = /* @__PURE__ */ ((ChainId3) => {
   ChainId3[ChainId3["Ethereum"] = 1] = "Ethereum";
   ChainId3[ChainId3["Base"] = 8453] = "Base";
@@ -27,12 +18,12 @@ var AgetherError = class extends Error {
     this.name = "AgetherError";
   }
 };
-var InsufficientCreditError = class extends AgetherError {
-  constructor(available, requested) {
+var InsufficientBalanceError = class extends AgetherError {
+  constructor(available, required) {
     super(
-      `Insufficient credit: available ${available}, requested ${requested}`,
-      "INSUFFICIENT_CREDIT",
-      { available: available.toString(), requested: requested.toString() }
+      `Insufficient balance: available ${available}, required ${required}`,
+      "INSUFFICIENT_BALANCE",
+      { available: available.toString(), required: required.toString() }
     );
   }
 };
@@ -45,12 +36,12 @@ var ScoringRejectedError = class extends AgetherError {
     );
   }
 };
-var CreditNotActiveError = class extends AgetherError {
-  constructor(account, status) {
+var AgentNotApprovedError = class extends AgetherError {
+  constructor(agentId) {
     super(
-      `Credit line for ${account} is not active (status: ${CreditStatus[status]})`,
-      "CREDIT_NOT_ACTIVE",
-      { account, status: CreditStatus[status] }
+      `Agent ${agentId} is not KYA-approved. Submit code for validation first.`,
+      "AGENT_NOT_APPROVED",
+      { agentId: agentId.toString() }
     );
   }
 };
@@ -76,103 +67,51 @@ var ACCOUNT_FACTORY_ABI = [
 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 drawCredit(address creditProvider, uint256 amount)",
-  "function repayCredit(address creditProvider, uint256 amount)",
   "function fund(address token, uint256 amount)",
   "function withdraw(address token, uint256 amount, address to)",
-  "function approveCreditProvider(address creditProvider)"
-];
-var CREDIT_PROVIDER_ABI = [
-  "function asset() view returns (address)",
-  "function isEligible(address account) view returns (bool)",
-  "function getCreditInfo(address account) view returns (tuple(uint256 limit, uint256 used, uint256 available, uint256 accruedInterest, uint256 aprBps, bool isActive, bool requiresCollateral))",
-  "function getTotalDebt(address account) view returns (uint256)",
-  "function maxDrawable(address account) view returns (uint256)",
-  "function draw(address account, uint256 amount)",
-  "function repay(address account, uint256 amount)",
-  "event CreditDrawn(address indexed account, uint256 amount, uint256 totalUsed)",
-  "event CreditRepaid(address indexed account, uint256 amount, uint256 totalUsed)",
-  "event CreditLineOpened(address indexed account, uint256 limit, uint256 aprBps)",
-  "event CreditLineClosed(address indexed account)"
-];
-var REPUTATION_CREDIT_ABI = [
-  ...CREDIT_PROVIDER_ABI,
-  // Application / Approval flow
-  "function applyForCredit(address account, uint256 requestedLimit)",
-  "function approveCreditLine(address account, uint256 limit, uint256 aprBps)",
-  "function rejectCreditLine(address account, string reason)",
-  "function requestLimitIncrease(address account, uint256 newRequestedLimit)",
-  "function approveLimitIncrease(address account, uint256 newLimit)",
-  "function freezeCreditLine(address account)",
-  "function unfreezeCreditLine(address account)",
-  // Admin
-  "function setCreditLine(address account, uint256 limit, uint256 aprBps)",
-  "function openScoredCreditLine(address account)",
-  "function closeCreditLine(address account)",
-  "function declareDefault(address account)",
-  // View
-  "function getCreditLineStatus(address account) view returns (uint8)",
-  "function getCreditLineDetails(address account) view returns (uint256 agentId, uint256 limit, uint256 used, uint256 aprBps, uint256 accruedInterest, uint256 requestedLimit, uint256 createdAt, uint256 lastActivityAt, uint8 status)",
-  "function getAgentAccount(uint256 agentId) view returns (address)",
-  "function previewScoredLimit(uint256 agentId) view returns (uint256 limit, uint256 score, bool eligible)",
-  "function dailyDrawLimit() view returns (uint256)",
-  "function totalBorrowed() view returns (uint256)",
-  // Events
-  "event CreditApplied(uint256 indexed creditLineId, uint256 indexed agentId, uint256 requestedLimit)",
-  "event CreditApproved(uint256 indexed creditLineId, uint256 limit, uint256 aprBps)",
-  "event CreditRejected(uint256 indexed creditLineId, string reason)",
-  "event CreditFrozen(uint256 indexed creditLineId)",
-  "event CreditUnfrozen(uint256 indexed creditLineId)",
-  "event DefaultDeclared(address indexed account, uint256 amount)"
-];
-var LP_VAULT_ABI = [
-  "function asset() view returns (address)",
-  "function totalAssets() view returns (uint256)",
-  "function totalSupply() view returns (uint256)",
-  "function balanceOf(address account) view returns (uint256)",
-  "function convertToShares(uint256 assets) view returns (uint256)",
-  "function convertToAssets(uint256 shares) view returns (uint256)",
-  "function previewDeposit(uint256 assets) view returns (uint256)",
-  "function previewRedeem(uint256 shares) view returns (uint256)",
-  "function deposit(uint256 assets, address receiver) returns (uint256)",
-  "function withdraw(uint256 assets, address receiver, address owner) returns (uint256)",
-  "function redeem(uint256 shares, address receiver, address owner) returns (uint256)",
-  "function totalBorrowed() view returns (uint256)",
-  "function availableLiquidity() view returns (uint256)",
-  "event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares)",
-  "event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares)"
+  "function withdrawETH(uint256 amount, address to)",
+  "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
 ];
 var AGENT_REPUTATION_ABI = [
-  "function getReputation(uint256 agentId) view returns (tuple(uint256 totalBorrowed, uint256 totalRepaid, uint256 totalInterestPaid, uint256 onTimePayments, uint256 latePayments, uint256 missedPayments, uint256 peakUtilization, uint256 avgUtilization, uint256 utilizationSamples, uint256 firstActivityAt, uint256 lastActivityAt, uint256 lastScoreUpdate, uint256 creditScore, uint256 creditLinesOpened, uint256 lastCreditOpenedAt, uint256 currentOutstanding, uint256 currentLimit, uint256 totalDeposits, uint256 totalWithdrawals))",
   "function getCreditScore(uint256 agentId) view returns (uint256)",
-  "function getBayesianScore(uint256 agentId) view returns (uint256 combinedScore, uint256 confidence)",
-  "function getRecommendedLimit(uint256 agentId, uint256 baseLimit) 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 getDecayedScore(uint256 agentId) view returns (uint256)",
-  "function getScoreExplanation(uint256 agentId) view returns (uint256 historical, uint256 currentRisk, uint256 utilization, uint256 onChainTx, uint256 newCredit, uint256 rawScore, uint256 decayedScore)",
-  "function getLoanPositions(uint256 agentId) view returns (tuple(uint256 amount, uint256 collateral, uint256 ltvBps, uint256 timestamp, bool liquidated, bool repaid, bool active)[])",
-  "function stressMultiplier() view returns (uint256)",
-  "function decayPeriod() view returns (uint256)"
+  "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 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_CREDIT_ABI = [
-  ...CREDIT_PROVIDER_ABI,
-  "function depositCollateral(address collateralToken, uint256 amount)",
-  "function depositCollateralFor(address onBehalf, address collateralToken, uint256 amount)",
-  "function withdrawCollateral(address collateralToken, uint256 amount)",
-  "function drawWithCollateral(address collateralToken, uint256 amount)",
-  "function repayWithCollateral(address collateralToken, uint256 amount)",
-  "function getPosition(address account, address collateralToken) view returns (tuple(uint256 collateralAmount, uint256 borrowedAmount, uint256 borrowShares, bool isActive))",
-  "function getSupportedCollaterals() view returns (address[])",
-  "function markets(address collateralToken) view returns (tuple(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) params, bytes32 marketId, uint256 maxLtvBps, bool active))"
+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)",
@@ -181,57 +120,51 @@ var ERC20_ABI = [
   "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 symbol() view returns (string)",
+  "function name() view returns (string)"
 ];
 
 // src/utils/config.ts
 var CONTRACT_ADDRESSES = {
   [1 /* Ethereum */]: {
     accountFactory: "0x0000000000000000000000000000000000000000",
-    reputationCredit: "0x0000000000000000000000000000000000000000",
-    lpVault: "0x0000000000000000000000000000000000000000",
     validationRegistry: "0x0000000000000000000000000000000000000000",
+    agentReputation: "0x0000000000000000000000000000000000000000",
     usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
     identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    agentReputation: "0x0000000000000000000000000000000000000000"
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
   },
   [8453 /* Base */]: {
-    accountFactory: "0xeB72f248Ad9F4bf4024e8D9da75cf7AAD37B58f5",
-    reputationCredit: "0x57B2B4ef3e7B8BE5FC86c6369602125d240F552A",
-    lpVault: "0x612A80D6c3175F8283e9C7EE71d5177fE9acc338",
-    validationRegistry: "0x8842f2383A86134Dd80c3Ecf6Bbae2e38396A5ec",
+    accountFactory: "0x7D5D56416bAEA06a9DCBe3092eF335724C6320a0",
+    validationRegistry: "0xd196C32D2149270F56E209ba7aEE67CE9ceD2001",
+    agentReputation: "0x65c9cA1211809D3CF3A2707558198eb2b2bE623c",
     usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
     identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    agentReputation: "0xF1bed094D4E33E47CC8C72E086FFFde09e2211b4",
-    morphoCredit: "0x7dFfa40E17471F7f26F5662D0F07a31977F47BeB"
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
   },
   [84532 /* BaseSepolia */]: {
     accountFactory: "0x0000000000000000000000000000000000000000",
-    reputationCredit: "0x0000000000000000000000000000000000000000",
-    lpVault: "0x0000000000000000000000000000000000000000",
     validationRegistry: "0x0000000000000000000000000000000000000000",
+    agentReputation: "0x0000000000000000000000000000000000000000",
     usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
     identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    agentReputation: "0x0000000000000000000000000000000000000000"
+    morphoBlue: "0x0000000000000000000000000000000000000000"
   },
   [11155111 /* Sepolia */]: {
     accountFactory: "0x0000000000000000000000000000000000000000",
-    reputationCredit: "0x0000000000000000000000000000000000000000",
-    lpVault: "0x0000000000000000000000000000000000000000",
     validationRegistry: "0x0000000000000000000000000000000000000000",
+    agentReputation: "0x0000000000000000000000000000000000000000",
     usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
     identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    agentReputation: "0x0000000000000000000000000000000000000000"
+    morphoBlue: "0x0000000000000000000000000000000000000000"
   },
   [31337 /* Hardhat */]: {
     accountFactory: "0x0000000000000000000000000000000000000000",
-    reputationCredit: "0x0000000000000000000000000000000000000000",
-    lpVault: "0x0000000000000000000000000000000000000000",
     validationRegistry: "0x0000000000000000000000000000000000000000",
+    agentReputation: "0x0000000000000000000000000000000000000000",
     usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
     identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    morphoCredit: "0x0000000000000000000000000000000000000000"
+    morphoBlue: "0x0000000000000000000000000000000000000000"
   }
 };
 var RPC_URLS = {
@@ -267,61 +200,44 @@ function createConfig(chainId, options) {
     }
   };
 }
-function getUSDCAddress(chainId) {
-  return CONTRACT_ADDRESSES[chainId].usdc;
-}
 
 // src/clients/AgetherClient.ts
 var AgetherClient = class _AgetherClient {
-  /**
-   * Undercollateralized credit is disabled for now.
-   * All credit operations go through MorphoCredit (overcollateralized).
-   */
-  _requireUndercollateralizedEnabled() {
-    throw new AgetherError(
-      "Undercollateralized credit is not available yet. Use MorphoCredit for overcollateralized lending via the CLI: agether morpho-deposit / morpho-draw / morpho-repay",
-      "UNDERCOLLATERALIZED_NOT_AVAILABLE"
-    );
-  }
   constructor(options) {
     this.config = options.config;
     this.signer = options.signer;
     this.agentId = options.agentId;
     const provider = options.signer.provider;
-    if (!provider) {
-      throw new AgetherError("Signer must have a provider", "NO_PROVIDER");
-    }
+    if (!provider) throw new AgetherError("Signer must have a provider", "NO_PROVIDER");
     this.accountFactory = new Contract(
       options.config.contracts.accountFactory,
       ACCOUNT_FACTORY_ABI,
       options.signer
     );
-    this.reputationCredit = new Contract(
-      options.config.contracts.reputationCredit,
-      REPUTATION_CREDIT_ABI,
-      options.signer
+    this.identityRegistry = new Contract(
+      options.config.contracts.identityRegistry,
+      IDENTITY_REGISTRY_ABI,
+      provider
+    );
+    this.validationRegistry = new Contract(
+      options.config.contracts.validationRegistry,
+      VALIDATION_REGISTRY_ABI,
+      provider
+    );
+    this.agentReputation = new Contract(
+      options.config.contracts.agentReputation,
+      AGENT_REPUTATION_ABI,
+      provider
     );
   }
-  // ============ Static Factory ============
-  /**
-   * Create client from private key.
-   *
-   * Simplest usage — only needs key, agentId, and chainId:
-   *   AgetherClient.fromPrivateKey(key, 42n, ChainId.Sepolia)
-   *
-   * All contract addresses and RPC URLs are resolved automatically.
-   */
+  // Static Factory
   static fromPrivateKey(privateKey, agentId, chainIdOrConfig) {
     const config = typeof chainIdOrConfig === "number" ? getDefaultConfig(chainIdOrConfig) : chainIdOrConfig;
     const provider = new ethers.JsonRpcProvider(config.rpcUrl);
     const signer = new ethers.Wallet(privateKey, provider);
     return new _AgetherClient({ config, signer, agentId });
   }
-  // ============ Account Management ============
-  /**
-   * Create an AgentAccount (smart wallet) for this agent.
-   * Returns the account address.
-   */
+  // Account Management
   async createAccount() {
     const tx = await this.accountFactory.createAccount(this.agentId);
     const receipt = await tx.wait();
@@ -339,138 +255,113 @@ var AgetherClient = class _AgetherClient {
     }
     return this.accountAddress;
   }
-  /**
-   * Get the AgentAccount address for this agent.
-   */
   async getAccountAddress() {
     if (this.accountAddress) return this.accountAddress;
     const addr = await this.accountFactory.getAccount(this.agentId);
     if (addr === ethers.ZeroAddress) {
-      throw new AgetherError(
-        "No account found. Create one first with createAccount().",
-        "NO_ACCOUNT"
-      );
+      throw new AgetherError("No account found. Create one with createAccount().", "NO_ACCOUNT");
     }
     this.accountAddress = addr;
     return addr;
   }
-  /**
-   * Check if an account already exists.
-   */
   async accountExists() {
     return this.accountFactory.accountExists(this.agentId);
   }
-  // ============ Credit Application ============
-  /**
-   * Apply for a credit line.
-   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
-   */
-  async apply(_limitOrApplication) {
-    this._requireUndercollateralizedEnabled();
+  async predictAddress() {
+    return this.accountFactory.predictAddress(this.agentId);
   }
-  // ============ Credit Line Info ============
-  /**
-   * Get full credit line details from ReputationCredit.
-   */
-  async getCreditLine() {
-    const account = await this.getAccountAddress();
-    const data = await this.reputationCredit.getCreditLineDetails(account);
-    return {
-      agentId: data[0],
-      limit: data[1],
-      used: data[2],
-      aprBps: data[3],
-      accruedInterest: data[4],
-      requestedLimit: data[5],
-      createdAt: data[6],
-      lastActivityAt: data[7],
-      status: Number(data[8])
+  // Balances
+  async getBalances() {
+    const provider = this.signer.provider;
+    const eoaAddr = await this.signer.getAddress();
+    const usdc = new Contract(this.config.contracts.usdc, ERC20_ABI, provider);
+    const ethBal = await provider.getBalance(eoaAddr);
+    const usdcBal = await usdc.balanceOf(eoaAddr);
+    const result = {
+      eoa: { eth: ethers.formatEther(ethBal), usdc: ethers.formatUnits(usdcBal, 6) }
     };
+    try {
+      const acctAddr = await this.getAccountAddress();
+      const acctEth = await provider.getBalance(acctAddr);
+      const acctUsdc = await usdc.balanceOf(acctAddr);
+      result.account = {
+        address: acctAddr,
+        eth: ethers.formatEther(acctEth),
+        usdc: ethers.formatUnits(acctUsdc, 6)
+      };
+    } catch {
+    }
+    return result;
   }
-  /**
-   * Get ICreditProvider.CreditInfo view.
-   */
-  async getCreditInfo() {
-    const account = await this.getAccountAddress();
-    const info = await this.reputationCredit.getCreditInfo(account);
+  async fundAccount(usdcAmount) {
+    const acctAddr = await this.getAccountAddress();
+    const usdc = new Contract(this.config.contracts.usdc, ERC20_ABI, this.signer);
+    const amount = ethers.parseUnits(usdcAmount, 6);
+    const tx = await usdc.transfer(acctAddr, amount);
+    const receipt = await tx.wait();
     return {
-      limit: info.limit,
-      used: info.used,
-      available: info.available,
-      accruedInterest: info.accruedInterest,
-      aprBps: info.aprBps,
-      isActive: info.isActive,
-      requiresCollateral: info.requiresCollateral
+      txHash: receipt.hash,
+      blockNumber: receipt.blockNumber,
+      status: receipt.status === 1 ? "success" : "failed",
+      gasUsed: receipt.gasUsed
     };
   }
-  /**
-   * Get credit line status.
-   */
-  async getStatus() {
-    const account = await this.getAccountAddress();
-    const status = await this.reputationCredit.getCreditLineStatus(account);
-    return Number(status);
-  }
-  /**
-   * Get available credit.
-   */
-  async getAvailableCredit() {
-    const account = await this.getAccountAddress();
-    return this.reputationCredit.maxDrawable(account);
+  async withdrawUsdc(usdcAmount) {
+    const acctAddr = await this.getAccountAddress();
+    const account = new Contract(acctAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const amount = ethers.parseUnits(usdcAmount, 6);
+    const eoaAddr = await this.signer.getAddress();
+    const tx = await account.withdraw(this.config.contracts.usdc, amount, eoaAddr);
+    const receipt = await tx.wait();
+    return {
+      txHash: receipt.hash,
+      blockNumber: receipt.blockNumber,
+      status: receipt.status === 1 ? "success" : "failed",
+      gasUsed: receipt.gasUsed
+    };
   }
-  /**
-   * Get total debt (principal + interest).
-   */
-  async getTotalDebt() {
-    const account = await this.getAccountAddress();
-    return this.reputationCredit.getTotalDebt(account);
+  async withdrawEth(ethAmount) {
+    const acctAddr = await this.getAccountAddress();
+    const account = new Contract(acctAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const amount = ethers.parseEther(ethAmount);
+    const eoaAddr = await this.signer.getAddress();
+    const tx = await account.withdrawETH(amount, eoaAddr);
+    const receipt = await tx.wait();
+    return {
+      txHash: receipt.hash,
+      blockNumber: receipt.blockNumber,
+      status: receipt.status === 1 ? "success" : "failed",
+      gasUsed: receipt.gasUsed
+    };
   }
-  /**
-   * Check if agent is eligible for credit.
-   */
-  async isEligible() {
-    const account = await this.getAccountAddress();
-    return this.reputationCredit.isEligible(account);
+  // Identity & Validation
+  async isKyaApproved() {
+    return this.validationRegistry.isAgentCodeApproved(this.agentId);
   }
-  // ============ Draw & Repay ============
-  /**
-   * Draw funds from credit line via AgentAccount.
-   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
-   */
-  async draw(_amountOrRequest) {
-    this._requireUndercollateralizedEnabled();
+  async identityExists() {
+    try {
+      await this.identityRegistry.ownerOf(this.agentId);
+      return true;
+    } catch {
+      return false;
+    }
   }
-  /**
-   * Repay credit line debt via AgentAccount.
-   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
-   */
-  async repay(_amountOrRequest) {
-    this._requireUndercollateralizedEnabled();
+  async getIdentityOwner() {
+    return this.identityRegistry.ownerOf(this.agentId);
   }
-  /**
-   * Repay full debt.
-   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
-   */
-  async repayFull() {
-    this._requireUndercollateralizedEnabled();
+  // Reputation
+  async getCreditScore() {
+    return this.agentReputation.getCreditScore(this.agentId);
   }
-  // ============ Limit Increase ============
-  /**
-   * Request a limit increase on-chain.
-   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
-   */
-  async requestLimitIncrease(_newLimit) {
-    this._requireUndercollateralizedEnabled();
+  async isScoreFresh() {
+    const [fresh, age] = await this.agentReputation.isScoreFresh(this.agentId);
+    return { fresh, age };
   }
-  // ============ x402 Payments ============
-  /**
-   * Pay for a service using credit line.
-   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
-   */
-  async pay(_service, _amount, _asset = "USDC") {
-    this._requireUndercollateralizedEnabled();
+  async isEligible(minScore = 500n) {
+    const [eligible, currentScore] = await this.agentReputation.isEligible(this.agentId, minScore);
+    return { eligible, currentScore };
   }
-  // ============ Getters ============
+  // Getters
   get chainId() {
     return this.config.chainId;
   }
@@ -480,641 +371,638 @@ var AgetherClient = class _AgetherClient {
   get currentAccountAddress() {
     return this.accountAddress;
   }
-  /** Get the underlying signer */
   getSigner() {
     return this.signer;
   }
+  getAgentId() {
+    return this.agentId;
+  }
 };
 
-// src/clients/ScoringClient.ts
+// src/clients/MorphoClient.ts
+import { ethers as ethers2, Contract as Contract2 } from "ethers";
 import axios from "axios";
-var ScoringClient = class {
-  constructor(endpoint, apiKey) {
-    this.client = axios.create({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/json",
-        ...apiKey && { Authorization: `Bearer ${apiKey}` }
-      },
-      timeout: 3e4
-    });
+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;
   }
   /**
-   * Evaluate a credit application (does not submit on-chain)
-   * Backend endpoint: POST /credit/evaluate
+   * Register: create ERC-8004 identity + AgentAccount in one flow.
+   * If already registered, returns existing state.
    */
-  async evaluateCredit(request) {
-    try {
-      const response = await this.client.post("/credit/evaluate", {
-        agentId: request.agentId.toString(),
-        requestedLimit: request.requestedLimit.toString(),
-        codeHash: request.codeHash
-      });
-      const data = response.data;
-      if (!data.approved) {
-        throw new ScoringRejectedError(data.riskScore, data.reason);
-      }
-      return {
-        approved: data.approved,
-        limit: BigInt(data.limit),
-        aprBps: data.aprBps,
-        riskScore: data.riskScore,
-        bayesianScore: data.bayesianScore ?? 0,
-        confidence: data.confidence ?? 0,
-        reason: data.reason
-      };
-    } catch (error) {
-      if (error instanceof ScoringRejectedError) {
-        throw error;
+  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 };
       }
-      if (axios.isAxiosError(error)) {
-        throw new AgetherError(
-          `Scoring request failed: ${error.message}`,
-          "SCORING_REQUEST_FAILED",
-          { status: error.response?.status }
-        );
-      }
-      throw error;
     }
-  }
-  /**
-   * Process a credit application (evaluate + on-chain approve/reject)
-   * Backend endpoint: POST /admin/credit/process
-   *
-   * Requires the credit application to be in Pending status on-chain
-   * (agent must have called applyForCredit first).
-   */
-  async processApplication(agentId, requestedLimit, codeHash) {
-    try {
-      const response = await this.client.post("/admin/credit/process", {
-        agentId: agentId.toString(),
-        requestedLimit: requestedLimit.toString(),
-        codeHash
-      });
-      return response.data;
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.response?.status === 400) {
-          return error.response.data;
+    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;
         }
-        throw new AgetherError(
-          `Process application failed: ${error.message}`,
-          "PROCESS_APPLICATION_FAILED",
-          { status: error.response?.status }
-        );
       }
-      throw error;
+      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 credit score for an agent
-   * Backend endpoint: GET /credit/score/:agentId
-   */
-  async getCreditScore(agentId) {
-    const response = await this.client.get(
-      `/credit/score/${agentId.toString()}`
-    );
-    return response.data;
-  }
-  /**
-   * Preview scored limit for an agent
-   * Backend endpoint: GET /credit/preview/:agentId
-   */
-  async previewScoredLimit(agentId) {
-    const response = await this.client.get(
-      `/credit/preview/${agentId.toString()}`
-    );
-    return response.data;
-  }
-  /**
-   * Get credit line info for an agent
-   * Backend endpoint: GET /credit/agent/:agentId
-   */
-  async getAgentCredit(agentId) {
-    const response = await this.client.get(
-      `/credit/agent/${agentId.toString()}`
-    );
-    return response.data;
+  /** 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;
   }
-  /**
-   * Get protocol info
-   * Backend endpoint: GET /credit/protocol-info
-   */
-  async getProtocolInfo() {
-    const response = await this.client.get("/credit/protocol-info");
-    return response.data;
+  /** 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)
+  // ════════════════════════════════════════════════════════
   /**
-   * Get backend service status
-   * Backend endpoint: GET /status
+   * Fetch USDC borrow markets on Base from Morpho API.
+   * Caches results for 5 minutes.
    */
-  async getStatus() {
-    const response = await this.client.get("/status");
-    return response.data;
+  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 full OCCR score explanation with subscores, decay, and loan positions
-   * Backend endpoint: GET /agents/:agentId/score-explanation
+   * Get MarketParams for a collateral token.
+   * Tries cache → API → on-chain idToMarketParams.
    */
-  async getScoreExplanation(agentId) {
-    const response = await this.client.get(
-      `/agents/${agentId.toString()}/score-explanation`
+  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"
     );
-    return response.data;
   }
-};
-
-// src/clients/VaultClient.ts
-import { Contract as Contract2 } from "ethers";
-var VaultClient = class {
-  constructor(options) {
-    this.config = options.config;
-    this.signer = options.signer;
-    this.vault = new Contract2(
-      options.config.contracts.lpVault,
-      LP_VAULT_ABI,
-      options.signer
-    );
+  /** 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
+    };
   }
-  // ============ LP Operations ============
-  /**
-   * Deposit assets to vault
-   */
-  async deposit(amount) {
-    const asset = await this.getAsset();
-    const allowance = await asset.allowance(
-      await this.signer.getAddress(),
-      this.config.contracts.lpVault
-    );
-    if (allowance < amount) {
-      const approveTx = await asset.approve(
-        this.config.contracts.lpVault,
-        amount
-      );
-      await approveTx.wait();
-    }
-    const receiver = await this.signer.getAddress();
-    const tx = await this.vault.deposit(amount, receiver);
-    const receipt = await tx.wait();
+  // ════════════════════════════════════════════════════════
+  //  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 {
-      txHash: receipt.hash,
-      blockNumber: receipt.blockNumber,
-      status: receipt.status === 1 ? "success" : "failed",
-      gasUsed: receipt.gasUsed
+      supplyShares: pos.supplyShares,
+      borrowShares: pos.borrowShares,
+      collateral: pos.collateral
     };
   }
   /**
-   * Withdraw assets from vault
+   * Full status: positions across all discovered markets.
    */
-  async withdraw(amount) {
-    const receiver = await this.signer.getAddress();
-    const owner = receiver;
-    const tx = await this.vault.withdraw(amount, receiver, owner);
-    const receipt = await tx.wait();
+  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 {
-      txHash: receipt.hash,
-      blockNumber: receipt.blockNumber,
-      status: receipt.status === 1 ? "success" : "failed",
-      gasUsed: receipt.gasUsed
+      agentId: this.agentId || "?",
+      agentAccount: acctAddr,
+      totalDebt: ethers2.formatUnits(totalDebt, 6),
+      positions
     };
   }
+  // ════════════════════════════════════════════════════════
+  //  Lending Operations (all via AgentAccount.executeBatch)
+  // ════════════════════════════════════════════════════════
   /**
-   * Redeem shares for assets
-   */
-  async redeem(shares) {
-    const receiver = await this.signer.getAddress();
-    const owner = receiver;
-    const tx = await this.vault.redeem(shares, receiver, owner);
-    const receipt = await tx.wait();
+   * 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 {
-      txHash: receipt.hash,
-      blockNumber: receipt.blockNumber,
-      status: receipt.status === 1 ? "success" : "failed",
-      gasUsed: receipt.gasUsed
+      tx: receipt.hash,
+      collateralToken: tokenSymbol,
+      amount,
+      agentAccount: acctAddr
     };
   }
-  // ============ View Functions ============
   /**
-   * Get vault statistics
-   */
-  async getStats() {
-    const [totalAssets, totalBorrowed, availableLiquidity] = await Promise.all([
-      this.vault.totalAssets(),
-      this.vault.totalBorrowed(),
-      this.vault.availableLiquidity()
+   * 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 utilizationRate = totalAssets > 0n ? Number(totalBorrowed * 10000n / totalAssets) / 100 : 0;
-    const totalSupply = await this.vault.totalSupply();
-    const sharePrice = totalSupply > 0n ? totalAssets * BigInt(1e18) / totalSupply : BigInt(1e18);
+    const receipt = await this.exec(morphoAddr, data);
     return {
-      totalAssets,
-      totalBorrowed,
-      availableLiquidity,
-      utilizationRate,
-      sharePrice
+      tx: receipt.hash,
+      amount: usdcAmount,
+      collateralToken: usedToken,
+      agentAccount: acctAddr
     };
   }
   /**
-   * Get LP position
-   */
-  async getPosition(address) {
-    const owner = address || await this.signer.getAddress();
-    const shares = await this.vault.balanceOf(owner);
-    const assets = await this.vault.convertToAssets(shares);
-    const pendingYield = 0n;
+   * 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 {
-      shares,
-      assets,
-      pendingYield
+      tx: receipt.hash,
+      collateralToken: tokenSymbol,
+      collateralAmount,
+      borrowAmount: borrowUsdcAmount,
+      agentAccount: acctAddr
     };
   }
   /**
-   * Preview deposit (how many shares for assets)
-   */
-  async previewDeposit(assets) {
-    return await this.vault.previewDeposit(assets);
-  }
-  /**
-   * Preview withdraw (how many assets for shares)
-   */
-  async previewRedeem(shares) {
-    return await this.vault.previewRedeem(shares);
+   * 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 };
   }
   /**
-   * Check if withdrawal is allowed (sufficient liquidity)
-   */
-  async canWithdraw(assets) {
-    const liquidity = await this.vault.availableLiquidity();
-    return liquidity >= assets;
+   * 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
+    };
   }
   /**
-   * Get current APY estimate
+   * Sponsor: transfer collateral to another agent's AgentAccount.
+   * (The agent must then supplyCollateral themselves via their own account.)
    */
-  async estimateAPY() {
-    const stats = await this.getStats();
-    const avgAPR = 1200;
-    const protocolFee = 1e3;
-    const lpYield = avgAPR * (1e4 - protocolFee) / 1e4;
-    const effectiveYield = lpYield * stats.utilizationRate / 100;
-    return effectiveYield / 100;
-  }
-  // ============ Utility ============
-  async getAsset() {
-    if (!this.asset) {
-      const assetAddress = await this.vault.asset();
-      this.asset = new Contract2(assetAddress, ERC20_ABI, this.signer);
+  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;
     }
-    return this.asset;
+    const tx = await account.execute(target, value, data, { gasLimit });
+    return tx.wait();
   }
   /**
-   * Get underlying asset address
+   * Execute multiple calls via AgentAccount.executeBatch.
    */
-  async getAssetAddress() {
-    return await this.vault.asset();
-  }
-  /**
-   * Get vault share token address
-   */
-  getVaultAddress() {
-    return this.config.contracts.lpVault;
-  }
-};
-
-// src/clients/AgentIdentityClient.ts
-import { ethers as ethers2 } from "ethers";
-var ERC8004_IDENTITY_ABI = [
-  // Registration
-  "function register() returns (uint256)",
-  "function register(string agentURI) returns (uint256)",
-  "function register(string agentURI, tuple(string key, bytes value)[] metadata) returns (uint256)",
-  // Management
-  "function setAgentURI(uint256 agentId, string newURI)",
-  "function setMetadata(uint256 agentId, string metadataKey, bytes metadataValue)",
-  "function getMetadata(uint256 agentId, string metadataKey) view returns (bytes)",
-  // ERC-721 standard
-  "function ownerOf(uint256 tokenId) view returns (address)",
-  "function balanceOf(address owner) view returns (uint256)",
-  "function tokenURI(uint256 tokenId) view returns (string)",
-  "function transferFrom(address from, address to, uint256 tokenId)",
-  "function approve(address to, uint256 tokenId)",
-  "function getApproved(uint256 tokenId) view returns (address)",
-  // Events
-  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
-];
-var ERC8004_REPUTATION_ABI = [
-  // Feedback
-  "function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string tag1, string tag2, string endpoint, string feedbackURI, bytes32 feedbackHash)",
-  "function revokeFeedback(uint256 agentId, uint64 feedbackIndex)",
-  // Queries
-  "function readFeedback(uint256 agentId, address clientAddress, uint64 feedbackIndex) view returns (int128 value, uint8 valueDecimals, string tag1, string tag2, bool isRevoked)",
-  "function getSummary(uint256 agentId, address[] clientAddresses, string tag1, string tag2) view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)",
-  "function getClients(uint256 agentId) view returns (address[])",
-  "function getLastIndex(uint256 agentId, address clientAddress) view returns (uint64)",
-  // Registry
-  "function getIdentityRegistry() view returns (address)"
-];
-var ERC8004_SEPOLIA = {
-  identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-  reputationRegistry: "0x8004B663056A597Dffe9eCcC1965A193B7388713"
-};
-var AgentIdentityClient = class {
-  constructor(options) {
-    this.config = options.config;
-    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);
-  }
-  // ============ Identity Functions ============
-  /**
-   * Register a new agent (minimal - no metadata)
-   */
-  async register() {
-    const tx = await this.identityRegistry["register()"]();
-    const receipt = await tx.wait();
-    const agentId = this.parseAgentIdFromReceipt(receipt);
-    return { agentId, txHash: receipt.hash };
-  }
-  /**
-   * Register agent with IPFS/HTTP URI to metadata JSON
-   * @param agentURI URI pointing to agent metadata (ipfs:// or https://)
-   */
-  async registerWithURI(agentURI) {
-    const tx = await this.identityRegistry["register(string)"](agentURI);
-    const receipt = await tx.wait();
-    const agentId = this.parseAgentIdFromReceipt(receipt);
-    return { agentId, txHash: receipt.hash };
-  }
-  /**
-   * Check if the signer already owns an ERC-8004 identity token.
-   * Returns true if balanceOf > 0, false otherwise.
-   * Note: Cannot determine the specific agentId without enumeration —
-   * use agether init <pk> --agent-id <id> if you know your agentId.
-   */
-  async hasExistingIdentity() {
+  async batch(targets, values, datas) {
+    const acctAddr = await this.getAccountAddress();
+    const account = new Contract2(acctAddr, AGENT_ACCOUNT_ABI, this.wallet);
+    let gasLimit;
     try {
-      const address = await this.signer.getAddress();
-      const balance = await this.identityRegistry.balanceOf(address);
-      return balance > 0n;
+      const estimate = await account.executeBatch.estimateGas(targets, values, datas);
+      gasLimit = estimate * 130n / 100n;
     } catch {
-      return false;
-    }
-  }
-  /**
-   * Register only if no identity exists; otherwise throw.
-   * Prevents accidental double-registration.
-   */
-  async registerOrGet() {
-    const hasIdentity = await this.hasExistingIdentity();
-    if (hasIdentity) {
-      throw new Error("Wallet already owns an ERC-8004 identity. Use agether init <pk> --agent-id <id> to set it.");
-    }
-    const result = await this.register();
-    return { ...result, existing: false };
-  }
-  /**
-   * Register with URI only if no identity exists; otherwise throw.
-   * Prevents accidental double-registration.
-   */
-  async registerOrGetWithURI(agentURI) {
-    const hasIdentity = await this.hasExistingIdentity();
-    if (hasIdentity) {
-      throw new Error("Wallet already owns an ERC-8004 identity. Use agether init <pk> --agent-id <id> to set it.");
+      gasLimit = 800000n;
     }
-    const result = await this.registerWithURI(agentURI);
-    return { ...result, existing: false };
-  }
-  /**
-   * Register agent with URI and on-chain metadata
-   */
-  async registerWithMetadata(agentURI, metadata) {
-    const metadataEntries = metadata.map((m) => ({
-      key: m.key,
-      value: ethers2.toUtf8Bytes(m.value)
-    }));
-    const tx = await this.identityRegistry["register(string,tuple(string,bytes)[])"](
-      agentURI,
-      metadataEntries
-    );
-    const receipt = await tx.wait();
-    const agentId = this.parseAgentIdFromReceipt(receipt);
-    return { agentId, txHash: receipt.hash };
-  }
-  /**
-   * Get agent owner address
-   */
-  async getOwner(agentId) {
-    return await this.identityRegistry.ownerOf(agentId);
-  }
-  /**
-   * Get agent URI (metadata JSON location)
-   */
-  async getAgentURI(agentId) {
-    return await this.identityRegistry.tokenURI(agentId);
-  }
-  /**
-   * Update agent URI
-   */
-  async setAgentURI(agentId, newURI) {
-    const tx = await this.identityRegistry.setAgentURI(agentId, newURI);
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  /**
-   * Set on-chain metadata (key-value)
-   */
-  async setMetadata(agentId, key, value) {
-    const tx = await this.identityRegistry.setMetadata(
-      agentId,
-      key,
-      ethers2.toUtf8Bytes(value)
-    );
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  /**
-   * Get on-chain metadata
-   */
-  async getMetadata(agentId, key) {
-    const value = await this.identityRegistry.getMetadata(agentId, key);
-    return ethers2.toUtf8String(value);
-  }
-  /**
-   * Transfer agent to new owner
-   */
-  async transfer(agentId, to) {
-    const from = await this.signer.getAddress();
-    const tx = await this.identityRegistry.transferFrom(from, to, agentId);
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  /**
-   * Fetch and parse agent metadata from URI
-   */
-  async fetchAgentMetadata(agentId) {
-    try {
-      const uri = await this.getAgentURI(agentId);
-      let fetchUrl = uri;
-      if (uri.startsWith("ipfs://")) {
-        const cid = uri.replace("ipfs://", "");
-        fetchUrl = `https://ipfs.io/ipfs/${cid}`;
-      }
-      const response = await fetch(fetchUrl);
-      if (!response.ok) return null;
-      return await response.json();
-    } catch {
-      return null;
-    }
-  }
-  // ============ Reputation Functions ============
-  /**
-   * Give feedback to an agent
-   */
-  async giveFeedback(input) {
-    const feedbackHash = ethers2.keccak256(
-      ethers2.AbiCoder.defaultAbiCoder().encode(
-        ["uint256", "int128", "uint256"],
-        [input.agentId, input.value, Date.now()]
-      )
-    );
-    const tx = await this.reputationRegistry.giveFeedback(
-      input.agentId,
-      input.value,
-      input.decimals || 0,
-      input.tag1 || "",
-      input.tag2 || "",
-      input.endpoint || "",
-      input.feedbackURI || "",
-      feedbackHash
-    );
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  /**
-   * Give positive feedback (shorthand)
-   */
-  async givePosisitiveFeedback(agentId, value = 100, tags = {}) {
-    return this.giveFeedback({
-      agentId,
-      value: Math.abs(value),
-      ...tags
-    });
-  }
-  /**
-   * Give negative feedback (e.g., for defaults)
-   */
-  async giveNegativeFeedback(agentId, value = -100, tags = {}) {
-    return this.giveFeedback({
-      agentId,
-      value: -Math.abs(value),
-      ...tags
-    });
-  }
-  /**
-   * Record credit default in reputation system
-   */
-  async recordCreditDefault(agentId, creditLineId) {
-    return this.giveFeedback({
-      agentId,
-      value: -100,
-      tag1: "credit",
-      tag2: "default",
-      feedbackURI: `agether://default/${creditLineId}`
-    });
-  }
-  /**
-   * Get reputation summary for an agent
-   */
-  async getReputation(agentId, tag1 = "", tag2 = "") {
-    const clients = await this.reputationRegistry.getClients(agentId);
-    if (clients.length === 0) {
-      return {
-        count: 0,
-        totalValue: 0,
-        averageValue: 0,
-        clients: []
-      };
-    }
-    const [count, summaryValue, decimals] = await this.reputationRegistry.getSummary(
-      agentId,
-      clients,
-      tag1,
-      tag2
-    );
-    const divisor = 10 ** Number(decimals);
-    const total = Number(summaryValue) / divisor;
-    return {
-      count: Number(count),
-      totalValue: total,
-      averageValue: Number(count) > 0 ? total / Number(count) : 0,
-      clients: clients.map((c) => c)
-    };
-  }
-  /**
-   * Check if agent has negative credit reputation
-   */
-  async hasNegativeCreditReputation(agentId) {
-    const rep = await this.getReputation(agentId, "credit", "");
-    return rep.count > 0 && rep.averageValue < 0;
-  }
-  // ============ Agether Integration ============
-  /**
-   * Verify agent is eligible for Agether credit
-   * Checks:
-   * 1. Agent exists in ERC-8004 registry
-   * 2. Agent has no negative credit reputation
-   */
-  async verifyForCredit(agentId) {
-    let owner;
-    try {
-      owner = await this.getOwner(agentId);
-    } catch {
-      return { eligible: false, reason: "Agent not found in ERC-8004 registry" };
-    }
-    const reputation = await this.getReputation(agentId, "credit", "");
-    if (reputation.count > 0 && reputation.averageValue < 0) {
-      return {
-        eligible: false,
-        reason: "Agent has negative credit reputation",
-        owner,
-        reputation
-      };
-    }
-    return {
-      eligible: true,
-      owner,
-      reputation
-    };
-  }
-  // ============ Helpers ============
-  parseAgentIdFromReceipt(receipt) {
-    for (const log of receipt.logs) {
+    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 parsed = this.identityRegistry.interface.parseLog({
-          topics: log.topics,
-          data: log.data
-        });
-        if (parsed?.name === "Transfer") {
-          return parsed.args[2];
+        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;
       }
     }
-    return 0n;
-  }
-  /**
-   * Get contract addresses
-   */
-  getContractAddresses() {
-    return {
-      identity: this.identityRegistry.target,
-      reputation: this.reputationRegistry.target
-    };
+    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 = {
@@ -1128,7 +1016,7 @@ function chainIdFromNetwork(network) {
   const m = network.match(/^eip155:(\d+)$/);
   return m ? Number(m[1]) : 1;
 }
-var _X402Client = class _X402Client {
+var X402Client = class {
   constructor(config) {
     this.config = config;
     const provider = new ethers3.JsonRpcProvider(config.rpcUrl);
@@ -1177,9 +1065,6 @@ var _X402Client = class _X402Client {
       console.log(`         amount  : ${requirements.amount} (atomic)`);
       console.log(`         asset   : ${requirements.asset}`);
       console.log(`         payTo   : ${requirements.payTo}`);
-      if (this.config.autoDraw && this.config.accountAddress && this.config.morphoCreditAddress) {
-        await this.ensureBalance(BigInt(requirements.amount));
-      }
       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");
@@ -1340,43 +1225,6 @@ var _X402Client = class _X402Client {
       }
     };
   }
-  async ensureBalance(requiredAmount) {
-    const accountAddr = this.config.accountAddress;
-    const morphoAddr = this.config.morphoCreditAddress;
-    const provider = this.wallet.provider;
-    const usdcAddr = USDC_DOMAINS["eip155:8453"]?.address || USDC_DOMAINS["eip155:1"].address;
-    const usdc = new ethers3.Contract(usdcAddr, _X402Client.ERC20_BALANCE_ABI, provider);
-    const balance = await usdc.balanceOf(accountAddr);
-    const needed = requiredAmount + requiredAmount / 10n;
-    if (balance >= needed) return;
-    const deficit = needed - balance;
-    const minDraw = ethers3.parseUnits("10", 6);
-    const drawAmount = deficit > minDraw ? deficit : minDraw;
-    console.log(`   [auto-draw] USDC balance $${ethers3.formatUnits(balance, 6)} < needed $${ethers3.formatUnits(needed, 6)}`);
-    const morpho = new ethers3.Contract(morphoAddr, _X402Client.MORPHO_DRAW_ABI, provider);
-    let collateralAddr = null;
-    for (const addr of _X402Client.AUTO_DRAW_COLLATERALS) {
-      try {
-        const pos = await morpho.getPosition(accountAddr, addr);
-        if (pos.collateralAmount > 0n) {
-          collateralAddr = addr;
-          break;
-        }
-      } catch {
-        continue;
-      }
-    }
-    if (!collateralAddr) {
-      throw new Error("autoDraw failed: no collateral deposited in Morpho. Deposit collateral first.");
-    }
-    const account = new ethers3.Contract(accountAddr, _X402Client.AGENT_ACCOUNT_EXEC_ABI, this.wallet);
-    const morphoIface = new ethers3.Interface(_X402Client.MORPHO_DRAW_ABI);
-    const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, drawAmount]);
-    console.log(`   [auto-draw] Borrowing $${ethers3.formatUnits(drawAmount, 6)} from Morpho...`);
-    const tx = await account.execute(morphoAddr, 0, calldata);
-    await tx.wait();
-    console.log(`   [auto-draw] \u2713 Borrowed (tx: ${tx.hash.slice(0, 14)}\u2026)`);
-  }
   // ──────────── Risk check via our backend ────────────
   async riskCheck(paymentPayload, reqs) {
     try {
@@ -1408,787 +1256,429 @@ var _X402Client = class _X402Client {
     }
   }
 };
-// ──────────── Auto-draw (Flow 9) ────────────
-//
-// When autoDraw is enabled and the AgentAccount has insufficient USDC,
-// automatically borrow from Morpho credit line to cover the payment.
-_X402Client.MORPHO_DRAW_ABI = [
-  "function drawWithCollateral(address collateralToken, uint256 amount)",
-  "function getPosition(address account, address collateralToken) view returns (tuple(uint256 collateralAmount, uint256 borrowedAmount, uint256 borrowShares, bool isActive))"
-];
-_X402Client.AGENT_ACCOUNT_EXEC_ABI = [
-  "function execute(address target, uint256 value, bytes data) payable returns (bytes)"
-];
-_X402Client.ERC20_BALANCE_ABI = [
-  "function balanceOf(address) view returns (uint256)"
-];
-_X402Client.AUTO_DRAW_COLLATERALS = [
-  "0x4200000000000000000000000000000000000006",
-  // WETH
-  "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
-  // wstETH
-  "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22"
-  // cbETH
-];
-var X402Client = _X402Client;
 
-// src/clients/MorphoCreditClient.ts
-import { ethers as ethers4, Contract as Contract3 } from "ethers";
-var BASE_COLLATERALS = {
-  WETH: { symbol: "WETH", address: "0x4200000000000000000000000000000000000006", decimals: 18 },
-  wstETH: { symbol: "wstETH", address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", decimals: 18 },
-  cbETH: { symbol: "cbETH", address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", decimals: 18 }
-};
-var _MorphoCreditClient = class _MorphoCreditClient {
-  constructor(config, collaterals) {
-    // ── Batch helper ──
-    this.morphoIface = new ethers4.Interface(MORPHO_CREDIT_ABI);
-    this.erc20Iface = new ethers4.Interface(ERC20_ABI);
-    this.config = config;
-    const provider = new ethers4.JsonRpcProvider(config.rpcUrl);
-    this.signer = new ethers4.Wallet(config.privateKey, provider);
-    this.morpho = new Contract3(config.contracts.morphoCredit, MORPHO_CREDIT_ABI, this.signer);
-    this.factory = new Contract3(config.contracts.accountFactory, ACCOUNT_FACTORY_ABI, this.signer);
-    this.collaterals = collaterals || BASE_COLLATERALS;
-    if (config.agentId) this.resolvedAgentId = config.agentId.toString();
-  }
-  // ── Helpers ──
-  resolveToken(tokenSymbol) {
-    const token = this.collaterals[tokenSymbol];
-    if (!token) {
-      throw new Error(`Unsupported collateral token: ${tokenSymbol}. Supported: ${Object.keys(this.collaterals).join(", ")}`);
+// src/clients/ScoringClient.ts
+var ScoringClient = class {
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.client = axios2.create({
+      baseURL: config.endpoint,
+      headers: { "Content-Type": "application/json" },
+      timeout: 3e4
+    });
+    if (config.x402) {
+      this.x402Client = new X402Client(config.x402);
     }
-    return token;
   }
+  // ════════════════════════════════════════════════════════
+  //  Score (x402-gated — computes & submits on-chain)
+  // ════════════════════════════════════════════════════════
   /**
-   * Get agentId from config or cache. Call register() first if not set.
+   * Request a fresh score computation.
+   *
+   * This is x402-gated: the backend returns 402, the X402Client
+   * signs an EIP-3009 payment, and the backend computes + submits
+   * the score on-chain via AgentReputation.submitScore().
+   *
+   * Returns the ScoreResult with breakdown and txHash.
    */
-  async getAgentId() {
-    if (this.resolvedAgentId) return this.resolvedAgentId;
-    throw new Error("No agentId. Pass agentId in config or call register() first.");
+  async requestScore(agentId) {
+    const id = agentId.toString();
+    if (!this.x402Client) {
+      throw new AgetherError(
+        "x402 config required for paid scoring. Provide x402 in ScoringClientConfig.",
+        "X402_NOT_CONFIGURED"
+      );
+    }
+    const result = await this.x402Client.get(
+      `${this.endpoint}/score/${id}`
+    );
+    if (!result.success || !result.data) {
+      throw new AgetherError(
+        `Scoring request failed: ${result.error || "unknown error"}`,
+        "SCORING_FAILED"
+      );
+    }
+    return result.data;
   }
+  // ════════════════════════════════════════════════════════
+  //  Current Score (free — reads on-chain)
+  // ════════════════════════════════════════════════════════
   /**
-   * Get the AgentAccount address for the configured agentId.
+   * Get the current on-chain score (free, no payment required).
    */
-  async getAccountAddress() {
-    if (this.accountAddress) return this.accountAddress;
-    const agentId = await this.getAgentId();
-    const addr = await this.factory.getAccount(agentId);
-    if (addr === ethers4.ZeroAddress) {
-      throw new Error("No AgentAccount found. Register first.");
-    }
-    this.accountAddress = addr;
-    return addr;
+  async getCurrentScore(agentId) {
+    const response = await this.client.get(`/score/${agentId.toString()}/current`);
+    return response.data;
   }
+  // ════════════════════════════════════════════════════════
+  //  Agent Details
+  // ════════════════════════════════════════════════════════
   /**
-   * Get the AgentAccount address for any agentId.
+   * Get detailed agent info from backend.
    */
-  async getAccountForAgent(agentId) {
-    const addr = await this.factory.getAccount(agentId.toString());
-    if (addr === ethers4.ZeroAddress) {
-      throw new Error(`No AgentAccount for agent #${agentId}`);
-    }
-    return addr;
+  async getAgentDetails(agentId) {
+    const response = await this.client.get(`/agents/${agentId.toString()}/details`);
+    return response.data;
   }
-  async ensureCreditProvider(accountAddr) {
-    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
-    try {
-      const tx = await account.approveCreditProvider(this.config.contracts.morphoCredit);
-      await tx.wait();
-    } catch {
-    }
+  // ════════════════════════════════════════════════════════
+  //  Service Status
+  // ════════════════════════════════════════════════════════
+  /**
+   * Health check.
+   */
+  async getHealth() {
+    const response = await this.client.get("/health");
+    return response.data;
   }
   /**
-   * Approve ERC-20 token from EOA → MorphoCredit, then deposit for account.
-   * This is 2 EOA txs (approve + depositCollateralFor) — cannot be batched
-   * because both are called from EOA, not from AgentAccount.
+   * Detailed status (contracts, signer, chain).
    */
-  async approveAndDeposit(accountAddr, tokenInfo, amount) {
-    const token = new Contract3(tokenInfo.address, ERC20_ABI, this.signer);
-    const balance = await token.balanceOf(this.signer.address);
-    if (balance < amount) {
-      throw new Error(
-        `Insufficient ${tokenInfo.symbol}: have ${ethers4.formatUnits(balance, tokenInfo.decimals)}, need ${ethers4.formatUnits(amount, tokenInfo.decimals)}`
-      );
-    }
-    const approveTx = await token.approve(this.config.contracts.morphoCredit, amount);
-    await approveTx.wait();
-    const depositTx = await this.morpho.depositCollateralFor(accountAddr, tokenInfo.address, amount);
-    await depositTx.wait();
-    return depositTx.hash;
+  async getStatus() {
+    const response = await this.client.get("/status");
+    return response.data;
   }
   /**
-   * Execute multiple calls via AgentAccount.executeBatch() in a single tx.
-   * Each call is { target, value, data }.
+   * Agent count and list.
    */
-  async batch(accountAddr, calls) {
-    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
-    const tx = await account.executeBatch(
-      calls.map((c) => c.target),
-      calls.map((c) => c.value),
-      calls.map((c) => c.data)
-    );
-    await tx.wait();
-    return tx.hash;
+  async getAgentCount() {
+    const response = await this.client.get("/agents/count");
+    return response.data;
+  }
+};
+
+// src/clients/AgentIdentityClient.ts
+import { ethers as ethers4 } from "ethers";
+var ERC8004_IDENTITY_ABI = [
+  // Registration
+  "function register() returns (uint256)",
+  "function register(string agentURI) returns (uint256)",
+  "function register(string agentURI, tuple(string key, bytes value)[] metadata) returns (uint256)",
+  // Management
+  "function setAgentURI(uint256 agentId, string newURI)",
+  "function setMetadata(uint256 agentId, string metadataKey, bytes metadataValue)",
+  "function getMetadata(uint256 agentId, string metadataKey) view returns (bytes)",
+  // ERC-721 standard
+  "function ownerOf(uint256 tokenId) view returns (address)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function tokenURI(uint256 tokenId) view returns (string)",
+  "function transferFrom(address from, address to, uint256 tokenId)",
+  "function approve(address to, uint256 tokenId)",
+  "function getApproved(uint256 tokenId) view returns (address)",
+  // Events
+  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+];
+var ERC8004_REPUTATION_ABI = [
+  // Feedback
+  "function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string tag1, string tag2, string endpoint, string feedbackURI, bytes32 feedbackHash)",
+  "function revokeFeedback(uint256 agentId, uint64 feedbackIndex)",
+  // Queries
+  "function readFeedback(uint256 agentId, address clientAddress, uint64 feedbackIndex) view returns (int128 value, uint8 valueDecimals, string tag1, string tag2, bool isRevoked)",
+  "function getSummary(uint256 agentId, address[] clientAddresses, string tag1, string tag2) view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)",
+  "function getClients(uint256 agentId) view returns (address[])",
+  "function getLastIndex(uint256 agentId, address clientAddress) view returns (uint64)",
+  // Registry
+  "function getIdentityRegistry() view returns (address)"
+];
+var ERC8004_SEPOLIA = {
+  identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+  reputationRegistry: "0x8004B663056A597Dffe9eCcC1965A193B7388713"
+};
+var AgentIdentityClient = class {
+  constructor(options) {
+    this.config = options.config;
+    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);
   }
-  // ══════════════════════════════════════════
-  //  Register
-  // ══════════════════════════════════════════
+  // ============ Identity Functions ============
   /**
-   * Register a new ERC-8004 agent identity and create an AgentAccount.
-   * If already registered (agentId in config or on-chain), returns existing info.
-   *
-   * @param name - Agent display name
+   * Register a new agent (minimal - no metadata)
    */
-  async register(name) {
-    if (!this.config.contracts.agentRegistry) {
-      throw new Error("agentRegistry address required for register()");
-    }
-    const registry = new Contract3(
-      this.config.contracts.agentRegistry,
-      _MorphoCreditClient.ERC8004_ABI,
-      this.signer
-    );
-    if (this.resolvedAgentId) {
-      const agentId2 = BigInt(this.resolvedAgentId);
-      const owner = await registry.ownerOf(agentId2);
-      if (owner.toLowerCase() !== this.signer.address.toLowerCase()) {
-        throw new Error("agentId in config does not belong to this wallet");
-      }
-      const exists2 = await this.factory.accountExists(agentId2);
-      if (!exists2) {
-        const tx2 = await this.factory.createAccount(agentId2);
-        await tx2.wait();
-      }
-      const accountAddr2 = await this.factory.getAccount(this.resolvedAgentId);
-      return {
-        tx: "",
-        agentId: this.resolvedAgentId,
-        address: this.signer.address,
-        agentAccount: accountAddr2,
-        alreadyRegistered: true
-      };
-    }
-    const registrationFile = JSON.stringify({
-      type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
-      name,
-      description: "AI agent registered via @agether/sdk",
-      active: true,
-      registrations: [{
-        agentId: 0,
-        agentRegistry: `eip155:8453:${this.config.contracts.agentRegistry}`
-      }]
-    });
-    const agentURI = `data:application/json;base64,${Buffer.from(registrationFile).toString("base64")}`;
-    const tx = await registry["register(string)"](agentURI);
+  async register() {
+    const tx = await this.identityRegistry["register()"]();
     const receipt = await tx.wait();
-    const transferTopic = ethers4.id("Transfer(address,address,uint256)");
-    const transferLog = receipt.logs.find((l) => l.topics[0] === transferTopic);
-    if (!transferLog?.topics?.[3]) {
-      throw new Error("Could not parse agentId from receipt");
-    }
-    const agentId = BigInt(transferLog.topics[3]);
-    this.resolvedAgentId = agentId.toString();
-    const exists = await this.factory.accountExists(agentId);
-    if (!exists) {
-      const accTx = await this.factory.createAccount(agentId);
-      await accTx.wait();
-    }
-    const accountAddr = await this.factory.getAccount(this.resolvedAgentId);
-    this.accountAddress = accountAddr;
-    return {
-      tx: tx.hash,
-      agentId: this.resolvedAgentId,
-      address: this.signer.address,
-      agentAccount: accountAddr,
-      alreadyRegistered: false
-    };
+    const agentId = this.parseAgentIdFromReceipt(receipt);
+    return { agentId, txHash: receipt.hash };
   }
-  // ══════════════════════════════════════════
-  //  Balances & Status
-  // ══════════════════════════════════════════
   /**
-   * Get ETH and USDC balances for EOA wallet and AgentAccount.
+   * Register agent with IPFS/HTTP URI to metadata JSON
+   * @param agentURI URI pointing to agent metadata (ipfs:// or https://)
    */
-  async getBalances() {
-    const provider = this.signer.provider;
-    const ethBal = await provider.getBalance(this.signer.address);
-    const usdc = new Contract3(this.config.contracts.usdc, ERC20_ABI, provider);
-    const usdcBal = await usdc.balanceOf(this.signer.address);
-    const result = {
-      address: this.signer.address,
-      agentId: this.resolvedAgentId || "not registered",
-      eth: ethers4.formatEther(ethBal),
-      usdc: ethers4.formatUnits(usdcBal, 6)
-    };
+  async registerWithURI(agentURI) {
+    const tx = await this.identityRegistry["register(string)"](agentURI);
+    const receipt = await tx.wait();
+    const agentId = this.parseAgentIdFromReceipt(receipt);
+    return { agentId, txHash: receipt.hash };
+  }
+  /**
+   * Check if the signer already owns an ERC-8004 identity token.
+   * Returns true if balanceOf > 0, false otherwise.
+   * Note: Cannot determine the specific agentId without enumeration —
+   * use agether init <pk> --agent-id <id> if you know your agentId.
+   */
+  async hasExistingIdentity() {
     try {
-      const accountAddr = await this.getAccountAddress();
-      const accEth = await provider.getBalance(accountAddr);
-      const accUsdc = await usdc.balanceOf(accountAddr);
-      result.agentAccount = {
-        address: accountAddr,
-        eth: ethers4.formatEther(accEth),
-        usdc: ethers4.formatUnits(accUsdc, 6)
-      };
+      const address = await this.signer.getAddress();
+      const balance = await this.identityRegistry.balanceOf(address);
+      return balance > 0n;
     } catch {
+      return false;
     }
-    return result;
   }
   /**
-   * Get full Morpho credit status — all positions + total debt.
+   * Register only if no identity exists; otherwise throw.
+   * Prevents accidental double-registration.
    */
-  async getStatus() {
-    const accountAddr = await this.getAccountAddress();
-    const positions = [];
-    for (const [symbol, info] of Object.entries(this.collaterals)) {
-      const pos = await this.morpho.getPosition(accountAddr, info.address);
-      if (pos.isActive || pos.collateralAmount > 0n || pos.borrowedAmount > 0n) {
-        positions.push({
-          token: symbol,
-          collateral: ethers4.formatUnits(pos.collateralAmount, info.decimals),
-          debt: `$${ethers4.formatUnits(pos.borrowedAmount, 6)}`,
-          active: pos.isActive
-        });
-      }
+  async registerOrGet() {
+    const hasIdentity = await this.hasExistingIdentity();
+    if (hasIdentity) {
+      throw new Error("Wallet already owns an ERC-8004 identity. Use agether init <pk> --agent-id <id> to set it.");
     }
-    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
-    return {
-      agentAccount: accountAddr,
-      totalDebt: `$${ethers4.formatUnits(totalDebt, 6)}`,
-      positions
-    };
+    const result = await this.register();
+    return { ...result, existing: false };
+  }
+  /**
+   * Register with URI only if no identity exists; otherwise throw.
+   * Prevents accidental double-registration.
+   */
+  async registerOrGetWithURI(agentURI) {
+    const hasIdentity = await this.hasExistingIdentity();
+    if (hasIdentity) {
+      throw new Error("Wallet already owns an ERC-8004 identity. Use agether init <pk> --agent-id <id> to set it.");
+    }
+    const result = await this.registerWithURI(agentURI);
+    return { ...result, existing: false };
+  }
+  /**
+   * Register agent with URI and on-chain metadata
+   */
+  async registerWithMetadata(agentURI, metadata) {
+    const metadataEntries = metadata.map((m) => ({
+      key: m.key,
+      value: ethers4.toUtf8Bytes(m.value)
+    }));
+    const tx = await this.identityRegistry["register(string,tuple(string,bytes)[])"](
+      agentURI,
+      metadataEntries
+    );
+    const receipt = await tx.wait();
+    const agentId = this.parseAgentIdFromReceipt(receipt);
+    return { agentId, txHash: receipt.hash };
+  }
+  /**
+   * Get agent owner address
+   */
+  async getOwner(agentId) {
+    return await this.identityRegistry.ownerOf(agentId);
   }
-  // ══════════════════════════════════════════
-  //  Fund AgentAccount
-  // ══════════════════════════════════════════
   /**
-   * Transfer USDC from EOA wallet into AgentAccount.
-   *
-   * @param amount - Human-readable USDC amount (e.g. "50")
+   * Get agent URI (metadata JSON location)
    */
-  async fundAccount(amount) {
-    const amountWei = ethers4.parseUnits(amount, 6);
-    const accountAddr = await this.getAccountAddress();
-    const usdc = new Contract3(this.config.contracts.usdc, ERC20_ABI, this.signer);
-    const balance = await usdc.balanceOf(this.signer.address);
-    if (balance < amountWei) {
-      throw new Error(`Insufficient USDC: have $${ethers4.formatUnits(balance, 6)}, need $${amount}`);
-    }
-    const tx = await usdc.transfer(accountAddr, amountWei);
-    await tx.wait();
-    return { tx: tx.hash, amount, agentAccount: accountAddr };
+  async getAgentURI(agentId) {
+    return await this.identityRegistry.tokenURI(agentId);
   }
   /**
-   * Check whether a borrow would exceed max LTV.
-   * Call before borrow() or depositAndBorrow() to get a clear error instead of on-chain revert.
-   *
-   * @param tokenSymbol - Collateral token
-   * @param additionalCollateral - Additional collateral being deposited ("0" if just borrowing)
-   * @param borrowAmount - USDC to borrow
+   * Update agent URI
    */
-  async checkLtv(tokenSymbol, additionalCollateral, borrowAmount) {
-    const tokenInfo = this.resolveToken(tokenSymbol);
-    const accountAddr = await this.getAccountAddress();
-    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
-    const marketInfo = await this.morpho.markets(tokenInfo.address);
-    const oracle = new Contract3(marketInfo.params.oracle, _MorphoCreditClient.ORACLE_ABI, this.signer.provider);
-    const oraclePrice = await oracle.price();
-    const addCollateralWei = ethers4.parseUnits(additionalCollateral, tokenInfo.decimals);
-    const borrowWei = ethers4.parseUnits(borrowAmount, 6);
-    const totalCollateral = pos.collateralAmount + addCollateralWei;
-    const totalDebt = pos.borrowedAmount + borrowWei;
-    const collateralValue = totalCollateral * oraclePrice / BigInt("1000000000000000000000000000000000000");
-    const collateralUsd = Number(collateralValue) / 1e6;
-    const currentDebtUsd = Number(pos.borrowedAmount) / 1e6;
-    const maxLtvBps = Number(marketInfo.maxLtvBps);
-    const currentLtv = collateralValue > 0n ? Number(pos.borrowedAmount * 10000n / collateralValue) / 100 : 0;
-    const newLtv = collateralValue > 0n ? Number(totalDebt * 10000n / collateralValue) / 100 : totalDebt > 0n ? Infinity : 0;
-    const maxLtv = maxLtvBps / 100;
-    const maxBorrow = collateralUsd * maxLtvBps / 1e4;
-    const ok = newLtv <= maxLtv;
-    return {
-      ok,
-      currentLtv,
-      newLtv,
-      maxLtv,
-      collateralUsd,
-      currentDebt: currentDebtUsd,
-      maxBorrow,
-      message: ok ? void 0 : `ExceedsMaxLtv: borrowing $${borrowAmount} would push LTV to ${newLtv.toFixed(1)}% (max ${maxLtv}%). Collateral: $${collateralUsd.toFixed(2)}. Current debt: $${currentDebtUsd.toFixed(3)}. Max additional borrow: $${(maxBorrow - currentDebtUsd).toFixed(2)}. Deposit more collateral or borrow less.`
-    };
+  async setAgentURI(agentId, newURI) {
+    const tx = await this.identityRegistry.setAgentURI(agentId, newURI);
+    const receipt = await tx.wait();
+    return receipt.hash;
   }
-  // ══════════════════════════════════════════
-  //  Flow 3: Deposit collateral only
-  // ══════════════════════════════════════════
   /**
-   * Deposit collateral from EOA into Morpho for own AgentAccount.
-   * Does NOT borrow — use `borrow()` or `depositAndBorrow()` for that.
-   *
-   * @param tokenSymbol - Collateral token (WETH, wstETH, cbETH)
-   * @param amount - Human-readable amount (e.g. "0.05")
+   * Set on-chain metadata (key-value)
    */
-  async deposit(tokenSymbol, amount) {
-    const tokenInfo = this.resolveToken(tokenSymbol);
-    const amountWei = ethers4.parseUnits(amount, tokenInfo.decimals);
-    const accountAddr = await this.getAccountAddress();
-    const txHash = await this.approveAndDeposit(accountAddr, tokenInfo, amountWei);
-    await this.ensureCreditProvider(accountAddr);
-    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
-    return {
-      tx: txHash,
-      amount: amountWei,
-      token: tokenSymbol,
-      agentAccount: accountAddr,
-      totalCollateral: pos.collateralAmount
-    };
+  async setMetadata(agentId, key, value) {
+    const tx = await this.identityRegistry.setMetadata(
+      agentId,
+      key,
+      ethers4.toUtf8Bytes(value)
+    );
+    const receipt = await tx.wait();
+    return receipt.hash;
   }
-  // ══════════════════════════════════════════
-  //  Flow 2: Deposit + borrow in one call
-  // ══════════════════════════════════════════
   /**
-   * Deposit collateral AND borrow USDC in a single SDK call.
-   * USDC lands in the AgentAccount.
-   *
-   * @param tokenSymbol - Collateral token (WETH, wstETH, cbETH)
-   * @param collateralAmount - Human-readable collateral amount (e.g. "0.05")
-   * @param borrowAmount - Human-readable USDC amount to borrow (e.g. "50")
+   * Get on-chain metadata
    */
-  async depositAndBorrow(tokenSymbol, collateralAmount, borrowAmount) {
-    const tokenInfo = this.resolveToken(tokenSymbol);
-    const collateralWei = ethers4.parseUnits(collateralAmount, tokenInfo.decimals);
-    const borrowWei = ethers4.parseUnits(borrowAmount, 6);
-    const accountAddr = await this.getAccountAddress();
-    const ltvCheck = await this.checkLtv(tokenSymbol, collateralAmount, borrowAmount);
-    if (!ltvCheck.ok) throw new Error(ltvCheck.message);
-    const depositTxHash = await this.approveAndDeposit(accountAddr, tokenInfo, collateralWei);
-    await this.ensureCreditProvider(accountAddr);
-    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
-    const calldata = this.morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
-    const borrowTx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
-    await borrowTx.wait();
-    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
-    return {
-      depositTx: depositTxHash,
-      borrowTx: borrowTx.hash,
-      collateral: { amount: collateralWei, token: tokenSymbol },
-      borrowed: borrowWei,
-      agentAccount: accountAddr,
-      totalDebt
-    };
+  async getMetadata(agentId, key) {
+    const value = await this.identityRegistry.getMetadata(agentId, key);
+    return ethers4.toUtf8String(value);
   }
-  // ══════════════════════════════════════════
-  //  Flow 8: Borrow against existing collateral
-  // ══════════════════════════════════════════
   /**
-   * Borrow USDC against already-deposited collateral.
-   * Auto-detects which collateral token has a position.
-   * USDC lands in AgentAccount — ready for x402 payments.
-   *
-   * @param amount - Human-readable USDC amount (e.g. "100")
+   * Transfer agent to new owner
    */
-  async borrow(amount) {
-    const borrowWei = ethers4.parseUnits(amount, 6);
-    const accountAddr = await this.getAccountAddress();
-    let activeToken = null;
-    for (const info of Object.values(this.collaterals)) {
-      const pos = await this.morpho.getPosition(accountAddr, info.address);
-      if (pos.collateralAmount > 0n) {
-        activeToken = info;
-        break;
-      }
-    }
-    if (!activeToken) {
-      throw new Error("No collateral deposited. Use deposit() or depositAndBorrow() first.");
-    }
-    const ltvCheck = await this.checkLtv(activeToken.symbol, "0", amount);
-    if (!ltvCheck.ok) throw new Error(ltvCheck.message);
-    await this.ensureCreditProvider(accountAddr);
-    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
-    const calldata = this.morphoIface.encodeFunctionData("drawWithCollateral", [activeToken.address, borrowWei]);
-    const tx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
-    await tx.wait();
-    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
-    return {
-      tx: tx.hash,
-      amount: borrowWei,
-      agentAccount: accountAddr,
-      totalDebt,
-      collateralToken: activeToken.symbol
-    };
+  async transfer(agentId, to) {
+    const from = await this.signer.getAddress();
+    const tx = await this.identityRegistry.transferFrom(from, to, agentId);
+    const receipt = await tx.wait();
+    return receipt.hash;
   }
-  // ══════════════════════════════════════════
-  //  Flows 4-7: Sponsor (deposit for another agent)
-  // ══════════════════════════════════════════
   /**
-   * Deposit collateral for another agent. Caller pays from their wallet.
-   * Optionally borrow USDC for the agent (only works if caller owns the AgentAccount).
-   *
-   * Supports both agentId lookup and direct address.
-   *
-   * @param target - `{ agentId: "17676" }` or `{ address: "0x..." }`
-   * @param tokenSymbol - Collateral token
-   * @param amount - Human-readable collateral amount
-   * @param borrowAmount - Optional: USDC to borrow (only if caller is owner)
+   * Fetch and parse agent metadata from URI
    */
-  async sponsor(target, tokenSymbol, amount, borrowAmount) {
-    const tokenInfo = this.resolveToken(tokenSymbol);
-    const collateralWei = ethers4.parseUnits(amount, tokenInfo.decimals);
-    let accountAddr;
-    let targetAgentId;
-    if ("agentId" in target) {
-      targetAgentId = target.agentId.toString();
-      accountAddr = await this.getAccountForAgent(target.agentId);
-    } else {
-      accountAddr = target.address;
-    }
-    const depositTxHash = await this.approveAndDeposit(accountAddr, tokenInfo, collateralWei);
-    const result = {
-      depositTx: depositTxHash,
-      targetAccount: accountAddr,
-      targetAgentId,
-      collateral: { amount: collateralWei, token: tokenSymbol },
-      totalCollateral: 0n,
-      totalDebt: 0n
-    };
-    if (borrowAmount) {
-      const borrowWei = ethers4.parseUnits(borrowAmount, 6);
-      try {
-        await this.ensureCreditProvider(accountAddr);
-        const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
-        const calldata = this.morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
-        const tx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
-        await tx.wait();
-        result.borrowTx = tx.hash;
-        result.borrowed = borrowWei;
-      } catch (e) {
-        throw new Error(`Borrow failed (caller may not own this AgentAccount): ${e.message}`);
+  async fetchAgentMetadata(agentId) {
+    try {
+      const uri = await this.getAgentURI(agentId);
+      let fetchUrl = uri;
+      if (uri.startsWith("ipfs://")) {
+        const cid = uri.replace("ipfs://", "");
+        fetchUrl = `https://ipfs.io/ipfs/${cid}`;
       }
+      const response = await fetch(fetchUrl);
+      if (!response.ok) return null;
+      return await response.json();
+    } catch {
+      return null;
     }
-    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
-    result.totalCollateral = pos.collateralAmount;
-    result.totalDebt = pos.borrowedAmount;
-    return result;
   }
-  // ══════════════════════════════════════════
-  //  Repay & Withdraw
-  // ══════════════════════════════════════════
+  // ============ Reputation Functions ============
   /**
-   * Repay borrowed USDC from AgentAccount back to Morpho.
-   *
-   * @param amount - Human-readable USDC amount (e.g. "50")
+   * Give feedback to an agent
    */
-  async repay(amount) {
-    const amountWei = ethers4.parseUnits(amount, 6);
-    const accountAddr = await this.getAccountAddress();
-    let collateralAddr = null;
-    for (const info of Object.values(this.collaterals)) {
-      const pos = await this.morpho.getPosition(accountAddr, info.address);
-      if (pos.borrowedAmount > 0n) {
-        collateralAddr = info.address;
-        break;
-      }
-    }
-    if (!collateralAddr) throw new Error("No Morpho debt to repay.");
-    const usdc = new Contract3(this.config.contracts.usdc, ERC20_ABI, this.signer.provider);
-    const balance = await usdc.balanceOf(accountAddr);
-    if (balance < amountWei) {
-      throw new Error(`Insufficient USDC in AgentAccount: $${ethers4.formatUnits(balance, 6)}`);
-    }
-    const txHash = await this.batch(accountAddr, [
-      {
-        target: this.config.contracts.usdc,
-        value: 0n,
-        data: this.erc20Iface.encodeFunctionData("approve", [this.config.contracts.morphoCredit, amountWei])
-      },
-      {
-        target: this.config.contracts.morphoCredit,
-        value: 0n,
-        data: this.morphoIface.encodeFunctionData("repayWithCollateral", [collateralAddr, amountWei])
-      }
-    ]);
-    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
-    return { tx: txHash, amount: amountWei, remainingDebt: totalDebt };
+  async giveFeedback(input) {
+    const feedbackHash = ethers4.keccak256(
+      ethers4.AbiCoder.defaultAbiCoder().encode(
+        ["uint256", "int128", "uint256"],
+        [input.agentId, input.value, Date.now()]
+      )
+    );
+    const tx = await this.reputationRegistry.giveFeedback(
+      input.agentId,
+      input.value,
+      input.decimals || 0,
+      input.tag1 || "",
+      input.tag2 || "",
+      input.endpoint || "",
+      input.feedbackURI || "",
+      feedbackHash
+    );
+    const receipt = await tx.wait();
+    return receipt.hash;
   }
   /**
-   * Withdraw collateral from Morpho back to EOA.
-   *
-   * @param tokenSymbol - Collateral token
-   * @param amount - Human-readable amount or "all"
+   * Give positive feedback (shorthand)
    */
-  async withdraw(tokenSymbol, amount) {
-    const tokenInfo = this.resolveToken(tokenSymbol);
-    const accountAddr = await this.getAccountAddress();
-    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
-    if (pos.collateralAmount === 0n) {
-      throw new Error(`No ${tokenSymbol} collateral deposited.`);
-    }
-    const withdrawAmount = amount.toLowerCase() === "all" ? pos.collateralAmount : ethers4.parseUnits(amount, tokenInfo.decimals);
-    if (withdrawAmount > pos.collateralAmount) {
-      throw new Error(
-        `Cannot withdraw more than deposited: max ${ethers4.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`
-      );
-    }
-    const txHash = await this.batch(accountAddr, [
-      {
-        target: this.config.contracts.morphoCredit,
-        value: 0n,
-        data: this.morphoIface.encodeFunctionData("withdrawCollateral", [tokenInfo.address, withdrawAmount])
-      },
-      {
-        target: tokenInfo.address,
-        value: 0n,
-        data: this.erc20Iface.encodeFunctionData("transfer", [this.signer.address, withdrawAmount])
-      }
-    ]);
-    const newPos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
-    return {
-      tx: txHash,
-      amount: withdrawAmount,
-      token: tokenSymbol,
-      destination: this.signer.address,
-      remainingCollateral: newPos.collateralAmount
-    };
+  async givePosisitiveFeedback(agentId, value = 100, tags = {}) {
+    return this.giveFeedback({
+      agentId,
+      value: Math.abs(value),
+      ...tags
+    });
   }
-  // ══════════════════════════════════════════
-  //  View methods
-  // ══════════════════════════════════════════
   /**
-   * Get position for a specific collateral token.
+   * Give negative feedback (e.g., for defaults)
    */
-  async getPosition(tokenSymbol) {
-    const tokenInfo = this.resolveToken(tokenSymbol);
-    const accountAddr = await this.getAccountAddress();
-    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
-    return {
-      token: tokenSymbol,
-      collateralAmount: pos.collateralAmount,
-      borrowedAmount: pos.borrowedAmount,
-      borrowShares: pos.borrowShares,
-      isActive: pos.isActive
-    };
+  async giveNegativeFeedback(agentId, value = -100, tags = {}) {
+    return this.giveFeedback({
+      agentId,
+      value: -Math.abs(value),
+      ...tags
+    });
   }
   /**
-   * Get all active positions across all collateral tokens.
+   * Record credit default in reputation system
    */
-  async getAllPositions() {
-    const accountAddr = await this.getAccountAddress();
-    const positions = [];
-    for (const [symbol, info] of Object.entries(this.collaterals)) {
-      const pos = await this.morpho.getPosition(accountAddr, info.address);
-      if (pos.isActive || pos.collateralAmount > 0n || pos.borrowedAmount > 0n) {
-        positions.push({
-          token: symbol,
-          collateralAmount: pos.collateralAmount,
-          borrowedAmount: pos.borrowedAmount,
-          borrowShares: pos.borrowShares,
-          isActive: pos.isActive
-        });
-      }
-    }
-    return positions;
+  async recordCreditDefault(agentId, creditLineId) {
+    return this.giveFeedback({
+      agentId,
+      value: -100,
+      tag1: "credit",
+      tag2: "default",
+      feedbackURI: `agether://default/${creditLineId}`
+    });
   }
   /**
-   * Get total debt across all positions.
+   * Get reputation summary for an agent
    */
-  async getTotalDebt() {
-    const accountAddr = await this.getAccountAddress();
-    return this.morpho.getTotalDebt(accountAddr);
+  async getReputation(agentId, tag1 = "", tag2 = "") {
+    const clients = await this.reputationRegistry.getClients(agentId);
+    if (clients.length === 0) {
+      return {
+        count: 0,
+        totalValue: 0,
+        averageValue: 0,
+        clients: []
+      };
+    }
+    const [count, summaryValue, decimals] = await this.reputationRegistry.getSummary(
+      agentId,
+      clients,
+      tag1,
+      tag2
+    );
+    const divisor = 10 ** Number(decimals);
+    const total = Number(summaryValue) / divisor;
+    return {
+      count: Number(count),
+      totalValue: total,
+      averageValue: Number(count) > 0 ? total / Number(count) : 0,
+      clients: clients.map((c) => c)
+    };
   }
   /**
-   * Get USDC balance in the AgentAccount.
+   * Check if agent has negative credit reputation
    */
-  async getAccountUSDC() {
-    const accountAddr = await this.getAccountAddress();
-    const usdc = new Contract3(this.config.contracts.usdc, ERC20_ABI, this.signer.provider);
-    return usdc.balanceOf(accountAddr);
-  }
-  /** Get the wallet (signer) address */
-  getAddress() {
-    return this.signer.address;
-  }
-};
-_MorphoCreditClient.ERC8004_ABI = [
-  "function register(string agentURI) returns (uint256)",
-  "function ownerOf(uint256 tokenId) view returns (address)",
-  "function balanceOf(address owner) view returns (uint256)"
-];
-// ══════════════════════════════════════════
-//  LTV Pre-check
-// ══════════════════════════════════════════
-_MorphoCreditClient.ORACLE_ABI = ["function price() view returns (uint256)"];
-var MorphoCreditClient = _MorphoCreditClient;
-
-// src/clients/WalletClient.ts
-import { ethers as ethers5, Contract as Contract4, Wallet } from "ethers";
-var WalletClient = class {
-  constructor(config) {
-    this.privateKey = null;
-    this.factoryAddress = config.factoryAddress;
-    this.usdcAddress = config.usdcAddress || ethers5.ZeroAddress;
-    this.chainId = config.chainId;
-    this.rpcUrl = config.rpcUrl;
-    this.provider = new ethers5.JsonRpcProvider(config.rpcUrl);
-    this.privateKey = config.privateKey || null;
+  async hasNegativeCreditReputation(agentId) {
+    const rep = await this.getReputation(agentId, "credit", "");
+    return rep.count > 0 && rep.averageValue < 0;
   }
+  // ============ Agether Integration ============
   /**
-   * Create a fresh signer to avoid nonce caching issues
+   * Verify agent is eligible for Agether credit
+   * Checks:
+   * 1. Agent exists in ERC-8004 registry
+   * 2. Agent has no negative credit reputation
    */
-  getFreshSigner() {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured - provide privateKey");
-    }
-    const freshProvider = new ethers5.JsonRpcProvider(this.rpcUrl);
-    return new Wallet(this.privateKey, freshProvider);
-  }
-  getFactoryContract() {
-    if (this.privateKey) {
-      return new Contract4(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.getFreshSigner());
-    }
-    return new Contract4(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.provider);
-  }
-  getAccountContract(accountAddress) {
-    if (this.privateKey) {
-      return new Contract4(accountAddress, AGENT_ACCOUNT_ABI, this.getFreshSigner());
-    }
-    return new Contract4(accountAddress, AGENT_ACCOUNT_ABI, this.provider);
-  }
-  getChainId() {
-    return this.chainId;
-  }
-  // ============ Account Factory ============
-  async accountExists(agentId) {
-    const factory = this.getFactoryContract();
-    return factory.accountExists(agentId);
-  }
-  async getAccount(agentId) {
-    const factory = this.getFactoryContract();
-    const address = await factory.getAccount(agentId);
-    if (address === ethers5.ZeroAddress) {
-      return null;
-    }
-    return address;
-  }
-  async predictAddress(agentId) {
-    const factory = this.getFactoryContract();
-    return factory.predictAddress(agentId);
-  }
-  async createAccount(agentId) {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured - provide privateKey");
-    }
-    const factory = this.getFactoryContract();
-    const tx = await factory.createAccount(agentId);
-    await tx.wait();
-    const account = await this.getAccount(agentId);
-    if (!account) {
-      throw new Error("Account creation failed");
+  async verifyForCredit(agentId) {
+    let owner;
+    try {
+      owner = await this.getOwner(agentId);
+    } catch {
+      return { eligible: false, reason: "Agent not found in ERC-8004 registry" };
     }
-    return account;
-  }
-  async totalAccounts() {
-    const factory = this.getFactoryContract();
-    return factory.totalAccounts();
-  }
-  // ============ Account Info ============
-  async getWalletInfo(accountAddress) {
-    const account = this.getAccountContract(accountAddress);
-    const [agentId, owner, ethBalance] = await Promise.all([
-      account.agentId(),
-      account.owner(),
-      account.ethBalance()
-    ]);
-    let usdcBalance = 0n;
-    if (this.usdcAddress !== ethers5.ZeroAddress) {
-      usdcBalance = await account.balanceOf(this.usdcAddress);
+    const reputation = await this.getReputation(agentId, "credit", "");
+    if (reputation.count > 0 && reputation.averageValue < 0) {
+      return {
+        eligible: false,
+        reason: "Agent has negative credit reputation",
+        owner,
+        reputation
+      };
     }
     return {
-      address: accountAddress,
-      agentId: BigInt(agentId),
+      eligible: true,
       owner,
-      ethBalance: BigInt(ethBalance),
-      usdcBalance: BigInt(usdcBalance)
-    };
-  }
-  async getProviderStatus(accountAddress, creditProvider) {
-    const provider = new Contract4(
-      creditProvider,
-      CREDIT_PROVIDER_ABI,
-      this.provider
-    );
-    const [isEligible, totalDebt, maxDrawable] = await Promise.all([
-      provider.isEligible(accountAddress),
-      provider.getTotalDebt(accountAddress),
-      provider.maxDrawable(accountAddress)
-    ]);
-    return {
-      provider: creditProvider,
-      isEligible,
-      totalDebt: BigInt(totalDebt),
-      maxDrawable: BigInt(maxDrawable)
+      reputation
     };
   }
-  // ============ Fund / Withdraw ============
-  async fundAccount(accountAddress, tokenAddress, amount) {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured");
-    }
-    const signer = this.getFreshSigner();
-    const token = new Contract4(tokenAddress, ERC20_ABI, signer);
-    const approveTx = await token.approve(accountAddress, amount);
-    await approveTx.wait();
-    const signer2 = this.getFreshSigner();
-    const account = new Contract4(accountAddress, AGENT_ACCOUNT_ABI, signer2);
-    const tx = await account.fund(tokenAddress, amount);
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  async withdraw(accountAddress, tokenAddress, amount, to) {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured");
-    }
-    const account = this.getAccountContract(accountAddress);
-    const recipient = to || await this.getFreshSigner().getAddress();
-    const tx = await account.withdraw(tokenAddress, amount, recipient);
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  // ============ Credit Operations ============
-  async drawCredit(accountAddress, creditProvider, amount) {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured");
-    }
-    const account = this.getAccountContract(accountAddress);
-    const tx = await account.drawCredit(creditProvider, amount);
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  async repayCredit(accountAddress, creditProvider, amount) {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured");
-    }
-    const account = this.getAccountContract(accountAddress);
-    const tx = await account.repayCredit(creditProvider, amount);
-    const receipt = await tx.wait();
-    return receipt.hash;
-  }
-  // ============ Generic Execute ============
-  async execute(accountAddress, target, value, data) {
-    if (!this.privateKey) {
-      throw new Error("Signer not configured");
+  // ============ Helpers ============
+  parseAgentIdFromReceipt(receipt) {
+    for (const log of receipt.logs) {
+      try {
+        const parsed = this.identityRegistry.interface.parseLog({
+          topics: log.topics,
+          data: log.data
+        });
+        if (parsed?.name === "Transfer") {
+          return parsed.args[2];
+        }
+      } catch {
+        continue;
+      }
     }
-    const account = this.getAccountContract(accountAddress);
-    const tx = await account.execute(target, value, data);
-    const receipt = await tx.wait();
-    return receipt.hash;
+    return 0n;
   }
-  // ============ Utility ============
-  generatePaymentMessageHash(accountAddress, recipient, amount, nonce, deadline, chainId) {
-    return ethers5.keccak256(
-      ethers5.AbiCoder.defaultAbiCoder().encode(
-        ["address", "uint256", "uint256", "uint256", "uint256", "address"],
-        [recipient, amount, nonce, deadline, chainId, accountAddress]
-      )
-    );
+  /**
+   * Get contract addresses
+   */
+  getContractAddresses() {
+    return {
+      identity: this.identityRegistry.target,
+      reputation: this.reputationRegistry.target
+    };
   }
 };
 
@@ -2239,24 +1729,18 @@ export {
   AGENT_ACCOUNT_ABI,
   AGENT_REPUTATION_ABI,
   AgentIdentityClient,
+  AgentNotApprovedError,
   AgetherClient,
   AgetherError,
-  CREDIT_PROVIDER_ABI,
   ChainId,
-  CreditNotActiveError,
-  CreditStatus,
   ERC20_ABI,
   IDENTITY_REGISTRY_ABI,
-  InsufficientCreditError,
-  LP_VAULT_ABI,
-  MORPHO_CREDIT_ABI,
-  MorphoCreditClient,
-  REPUTATION_CREDIT_ABI,
+  InsufficientBalanceError,
+  MORPHO_BLUE_ABI,
+  MorphoClient,
   ScoringClient,
   ScoringRejectedError,
   VALIDATION_REGISTRY_ABI,
-  VaultClient,
-  WalletClient,
   X402Client,
   bpsToRate,
   createConfig,
@@ -2268,7 +1752,6 @@ export {
   formatUSD,
   formatUnits,
   getDefaultConfig,
-  getUSDCAddress,
   parseUnits,
   rateToBps
 };