@agether/sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1610 @@
+// src/clients/AgetherClient.ts
+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";
+  ChainId3[ChainId3["BaseSepolia"] = 84532] = "BaseSepolia";
+  ChainId3[ChainId3["Sepolia"] = 11155111] = "Sepolia";
+  ChainId3[ChainId3["Hardhat"] = 31337] = "Hardhat";
+  return ChainId3;
+})(ChainId || {});
+var AgetherError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AgetherError";
+  }
+};
+var InsufficientCreditError = class extends AgetherError {
+  constructor(available, requested) {
+    super(
+      `Insufficient credit: available ${available}, requested ${requested}`,
+      "INSUFFICIENT_CREDIT",
+      { available: available.toString(), requested: requested.toString() }
+    );
+  }
+};
+var ScoringRejectedError = class extends AgetherError {
+  constructor(riskScore, reason) {
+    super(
+      `Scoring rejected: risk score ${riskScore}${reason ? `, ${reason}` : ""}`,
+      "SCORING_REJECTED",
+      { riskScore, reason }
+    );
+  }
+};
+var CreditNotActiveError = class extends AgetherError {
+  constructor(account, status) {
+    super(
+      `Credit line for ${account} is not active (status: ${CreditStatus[status]})`,
+      "CREDIT_NOT_ACTIVE",
+      { account, status: CreditStatus[status] }
+    );
+  }
+};
+
+// src/utils/abis.ts
+var IDENTITY_REGISTRY_ABI = [
+  "function ownerOf(uint256 agentId) view returns (address)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function totalSupply() view returns (uint256)",
+  "function exists(uint256 agentId) view returns (bool)",
+  "function register() returns (uint256 agentId)",
+  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+];
+var ACCOUNT_FACTORY_ABI = [
+  "function getAccount(uint256 agentId) view returns (address)",
+  "function accountExists(uint256 agentId) view returns (bool)",
+  "function predictAddress(uint256 agentId) view returns (address)",
+  "function totalAccounts() view returns (uint256)",
+  "function getAgentId(address account) view returns (uint256)",
+  "function createAccount(uint256 agentId) returns (address account)",
+  "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
+];
+var AGENT_ACCOUNT_ABI = [
+  "function agentId() view returns (uint256)",
+  "function owner() view returns (address)",
+  "function balanceOf(address token) view returns (uint256)",
+  "function ethBalance() view returns (uint256)",
+  "function execute(address target, uint256 value, bytes data) 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)"
+];
+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)"
+];
+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 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)"
+];
+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[])"
+];
+var ERC20_ABI = [
+  "function balanceOf(address account) view returns (uint256)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function transfer(address to, uint256 amount) returns (bool)",
+  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)"
+];
+
+// src/utils/config.ts
+var CONTRACT_ADDRESSES = {
+  [1 /* Ethereum */]: {
+    accountFactory: "0x0000000000000000000000000000000000000000",
+    reputationCredit: "0x0000000000000000000000000000000000000000",
+    lpVault: "0x0000000000000000000000000000000000000000",
+    validationRegistry: "0x0000000000000000000000000000000000000000",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    agentReputation: "0x0000000000000000000000000000000000000000"
+  },
+  [8453 /* Base */]: {
+    accountFactory: "0xeB72f248Ad9F4bf4024e8D9da75cf7AAD37B58f5",
+    reputationCredit: "0x57B2B4ef3e7B8BE5FC86c6369602125d240F552A",
+    lpVault: "0x612A80D6c3175F8283e9C7EE71d5177fE9acc338",
+    validationRegistry: "0x8842f2383A86134Dd80c3Ecf6Bbae2e38396A5ec",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    agentReputation: "0xF1bed094D4E33E47CC8C72E086FFFde09e2211b4",
+    morphoCredit: "0x7dFfa40E17471F7f26F5662D0F07a31977F47BeB"
+  },
+  [84532 /* BaseSepolia */]: {
+    accountFactory: "0x0000000000000000000000000000000000000000",
+    reputationCredit: "0x0000000000000000000000000000000000000000",
+    lpVault: "0x0000000000000000000000000000000000000000",
+    validationRegistry: "0x0000000000000000000000000000000000000000",
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+    agentReputation: "0x0000000000000000000000000000000000000000"
+  },
+  [11155111 /* Sepolia */]: {
+    accountFactory: "0x0000000000000000000000000000000000000000",
+    reputationCredit: "0x0000000000000000000000000000000000000000",
+    lpVault: "0x0000000000000000000000000000000000000000",
+    validationRegistry: "0x0000000000000000000000000000000000000000",
+    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+    agentReputation: "0x0000000000000000000000000000000000000000"
+  },
+  [31337 /* Hardhat */]: {
+    accountFactory: "0x0000000000000000000000000000000000000000",
+    reputationCredit: "0x0000000000000000000000000000000000000000",
+    lpVault: "0x0000000000000000000000000000000000000000",
+    validationRegistry: "0x0000000000000000000000000000000000000000",
+    usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    agentReputation: "0x0000000000000000000000000000000000000000",
+    morphoCredit: "0x0000000000000000000000000000000000000000"
+  }
+};
+var RPC_URLS = {
+  [1 /* Ethereum */]: "https://ethereum-rpc.publicnode.com",
+  [8453 /* Base */]: "https://base-rpc.publicnode.com",
+  [84532 /* BaseSepolia */]: "https://sepolia.base.org",
+  [11155111 /* Sepolia */]: "https://rpc.sepolia.org",
+  [31337 /* Hardhat */]: "http://127.0.0.1:8545"
+};
+var SCORING_ENDPOINTS = {
+  [1 /* Ethereum */]: "https://scoring.agether.ai/v1",
+  [8453 /* Base */]: "http://95.179.189.214:3001",
+  [84532 /* BaseSepolia */]: "http://95.179.189.214:3001",
+  [11155111 /* Sepolia */]: "https://scoring-testnet.agether.ai/v1",
+  [31337 /* Hardhat */]: "http://127.0.0.1:3001"
+};
+function getDefaultConfig(chainId) {
+  return {
+    chainId,
+    rpcUrl: RPC_URLS[chainId],
+    contracts: CONTRACT_ADDRESSES[chainId],
+    scoringEndpoint: SCORING_ENDPOINTS[chainId]
+  };
+}
+function createConfig(chainId, options) {
+  const defaultConfig = getDefaultConfig(chainId);
+  return {
+    ...defaultConfig,
+    ...options,
+    contracts: {
+      ...defaultConfig.contracts,
+      ...options?.contracts
+    }
+  };
+}
+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");
+    }
+    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
+    );
+  }
+  // ============ 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 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.
+   */
+  async createAccount() {
+    const tx = await this.accountFactory.createAccount(this.agentId);
+    const receipt = await tx.wait();
+    const event = receipt.logs.map((log) => {
+      try {
+        return this.accountFactory.interface.parseLog(log);
+      } catch {
+        return null;
+      }
+    }).find((e) => e?.name === "AccountCreated");
+    if (event) {
+      this.accountAddress = event.args.account;
+    } else {
+      this.accountAddress = await this.accountFactory.getAccount(this.agentId);
+    }
+    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"
+      );
+    }
+    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();
+  }
+  // ============ 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])
+    };
+  }
+  /**
+   * Get ICreditProvider.CreditInfo view.
+   */
+  async getCreditInfo() {
+    const account = await this.getAccountAddress();
+    const info = await this.reputationCredit.getCreditInfo(account);
+    return {
+      limit: info.limit,
+      used: info.used,
+      available: info.available,
+      accruedInterest: info.accruedInterest,
+      aprBps: info.aprBps,
+      isActive: info.isActive,
+      requiresCollateral: info.requiresCollateral
+    };
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Get total debt (principal + interest).
+   */
+  async getTotalDebt() {
+    const account = await this.getAccountAddress();
+    return this.reputationCredit.getTotalDebt(account);
+  }
+  /**
+   * Check if agent is eligible for credit.
+   */
+  async isEligible() {
+    const account = await this.getAccountAddress();
+    return this.reputationCredit.isEligible(account);
+  }
+  // ============ Draw & Repay ============
+  /**
+   * Draw funds from credit line via AgentAccount.
+   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+   */
+  async draw(_amountOrRequest) {
+    this._requireUndercollateralizedEnabled();
+  }
+  /**
+   * Repay credit line debt via AgentAccount.
+   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+   */
+  async repay(_amountOrRequest) {
+    this._requireUndercollateralizedEnabled();
+  }
+  /**
+   * Repay full debt.
+   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+   */
+  async repayFull() {
+    this._requireUndercollateralizedEnabled();
+  }
+  // ============ Limit Increase ============
+  /**
+   * Request a limit increase on-chain.
+   * @deprecated Undercollateralized credit is not available yet. Use MorphoCredit.
+   */
+  async requestLimitIncrease(_newLimit) {
+    this._requireUndercollateralizedEnabled();
+  }
+  // ============ 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();
+  }
+  // ============ Getters ============
+  get chainId() {
+    return this.config.chainId;
+  }
+  get contracts() {
+    return this.config.contracts;
+  }
+  get currentAccountAddress() {
+    return this.accountAddress;
+  }
+  /** Get the underlying signer */
+  getSigner() {
+    return this.signer;
+  }
+};
+
+// src/clients/ScoringClient.ts
+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
+    });
+  }
+  /**
+   * Evaluate a credit application (does not submit on-chain)
+   * Backend endpoint: POST /credit/evaluate
+   */
+  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;
+      }
+      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;
+        }
+        throw new AgetherError(
+          `Process application failed: ${error.message}`,
+          "PROCESS_APPLICATION_FAILED",
+          { status: error.response?.status }
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * 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 protocol info
+   * Backend endpoint: GET /credit/protocol-info
+   */
+  async getProtocolInfo() {
+    const response = await this.client.get("/credit/protocol-info");
+    return response.data;
+  }
+  /**
+   * Get backend service status
+   * Backend endpoint: GET /status
+   */
+  async getStatus() {
+    const response = await this.client.get("/status");
+    return response.data;
+  }
+  /**
+   * Get full OCCR score explanation with subscores, decay, and loan positions
+   * Backend endpoint: GET /agents/:agentId/score-explanation
+   */
+  async getScoreExplanation(agentId) {
+    const response = await this.client.get(
+      `/agents/${agentId.toString()}/score-explanation`
+    );
+    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
+    );
+  }
+  // ============ 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();
+    return {
+      txHash: receipt.hash,
+      blockNumber: receipt.blockNumber,
+      status: receipt.status === 1 ? "success" : "failed",
+      gasUsed: receipt.gasUsed
+    };
+  }
+  /**
+   * Withdraw assets from vault
+   */
+  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();
+    return {
+      txHash: receipt.hash,
+      blockNumber: receipt.blockNumber,
+      status: receipt.status === 1 ? "success" : "failed",
+      gasUsed: receipt.gasUsed
+    };
+  }
+  /**
+   * 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();
+    return {
+      txHash: receipt.hash,
+      blockNumber: receipt.blockNumber,
+      status: receipt.status === 1 ? "success" : "failed",
+      gasUsed: receipt.gasUsed
+    };
+  }
+  // ============ View Functions ============
+  /**
+   * Get vault statistics
+   */
+  async getStats() {
+    const [totalAssets, totalBorrowed, availableLiquidity] = await Promise.all([
+      this.vault.totalAssets(),
+      this.vault.totalBorrowed(),
+      this.vault.availableLiquidity()
+    ]);
+    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);
+    return {
+      totalAssets,
+      totalBorrowed,
+      availableLiquidity,
+      utilizationRate,
+      sharePrice
+    };
+  }
+  /**
+   * 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;
+    return {
+      shares,
+      assets,
+      pendingYield
+    };
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Check if withdrawal is allowed (sufficient liquidity)
+   */
+  async canWithdraw(assets) {
+    const liquidity = await this.vault.availableLiquidity();
+    return liquidity >= assets;
+  }
+  /**
+   * Get current APY estimate
+   */
+  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);
+    }
+    return this.asset;
+  }
+  /**
+   * Get underlying asset address
+   */
+  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 = 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() {
+    try {
+      const address = await this.signer.getAddress();
+      const balance = await this.identityRegistry.balanceOf(address);
+      return balance > 0n;
+    } 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.");
+    }
+    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) {
+      try {
+        const parsed = this.identityRegistry.interface.parseLog({
+          topics: log.topics,
+          data: log.data
+        });
+        if (parsed?.name === "Transfer") {
+          return parsed.args[2];
+        }
+      } catch {
+        continue;
+      }
+    }
+    return 0n;
+  }
+  /**
+   * Get contract addresses
+   */
+  getContractAddresses() {
+    return {
+      identity: this.identityRegistry.target,
+      reputation: this.reputationRegistry.target
+    };
+  }
+};
+
+// src/clients/X402Client.ts
+import { ethers as ethers3 } from "ethers";
+var USDC_DOMAINS = {
+  "eip155:1": { name: "USD Coin", version: "2", address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" },
+  "eip155:8453": { name: "USD Coin", version: "2", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" },
+  "eip155:84532": { name: "USD Coin", version: "2", address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e" },
+  "eip155:42161": { name: "USD Coin", version: "2", address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" },
+  "eip155:10": { name: "USD Coin", version: "2", address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" }
+};
+function chainIdFromNetwork(network) {
+  const m = network.match(/^eip155:(\d+)$/);
+  return m ? Number(m[1]) : 1;
+}
+var X402Client = class {
+  constructor(config) {
+    this.config = config;
+    const provider = new ethers3.JsonRpcProvider(config.rpcUrl);
+    this.wallet = new ethers3.Wallet(config.privateKey, provider);
+  }
+  async get(url, opts) {
+    return this.request(url, { ...opts, method: "GET" });
+  }
+  async post(url, body, opts) {
+    return this.request(url, {
+      ...opts,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0,
+      headers: { "Content-Type": "application/json", ...opts?.headers }
+    });
+  }
+  getAddress() {
+    return this.wallet.address;
+  }
+  // ──────────── Core request / 402-retry loop ────────────
+  async request(url, options) {
+    try {
+      console.log("   [1/4] Calling resource server\u2026");
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...options?.headers,
+          "X-Agent-Id": this.config.agentId || ""
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        return { success: true, data };
+      }
+      if (response.status !== 402) {
+        return { success: false, error: `HTTP ${response.status}: ${await response.text()}` };
+      }
+      console.log("   [2/4] 402 received \u2014 parsing payment requirements\u2026");
+      const parsed = await this.parsePaymentRequired(response);
+      if (!parsed) {
+        return { success: false, error: "Could not parse payment requirements from 402 response" };
+      }
+      const { requirements, resource } = parsed;
+      console.log(`         scheme  : ${requirements.scheme}`);
+      console.log(`         network : ${requirements.network}`);
+      console.log(`         amount  : ${requirements.amount} (atomic)`);
+      console.log(`         asset   : ${requirements.asset}`);
+      console.log(`         payTo   : ${requirements.payTo}`);
+      console.log("   [3/4] Signing EIP-3009 transferWithAuthorization\u2026");
+      const paymentPayload = await this.buildPaymentPayload(requirements, resource, url);
+      const paymentB64 = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
+      await this.riskCheck(paymentPayload, requirements);
+      console.log("   [4/4] Retrying with PAYMENT-SIGNATURE header\u2026");
+      const paidResponse = await fetch(url, {
+        ...options,
+        headers: {
+          ...options?.headers,
+          "X-Agent-Id": this.config.agentId || "",
+          // v2 header
+          "PAYMENT-SIGNATURE": paymentB64,
+          // v1 compat header (some servers still use this)
+          "X-PAYMENT": paymentB64
+        }
+      });
+      if (paidResponse.ok) {
+        const data = await paidResponse.json();
+        const settlementHeader = paidResponse.headers.get("PAYMENT-RESPONSE") || paidResponse.headers.get("X-PAYMENT-RESPONSE");
+        let txHash;
+        if (settlementHeader) {
+          try {
+            const settlement = JSON.parse(Buffer.from(settlementHeader, "base64").toString("utf-8"));
+            txHash = settlement.transaction;
+          } catch {
+          }
+        }
+        return {
+          success: true,
+          data,
+          paymentInfo: {
+            amount: requirements.amount,
+            asset: requirements.extra?.name || "USDC",
+            network: requirements.network,
+            txHash
+          }
+        };
+      }
+      const errBody = await paidResponse.text();
+      return { success: false, error: `Payment rejected (HTTP ${paidResponse.status}): ${errBody}` };
+    } catch (error) {
+      return { success: false, error: `Request failed: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
+  // ──────────── Parse 402 response ────────────
+  async parsePaymentRequired(response) {
+    const prHeader = response.headers.get("PAYMENT-REQUIRED") || response.headers.get("x-payment-required");
+    if (prHeader) {
+      try {
+        const decoded = JSON.parse(Buffer.from(prHeader, "base64").toString("utf-8"));
+        if (decoded.accepts?.length) {
+          return { requirements: decoded.accepts[0], resource: decoded.resource };
+        }
+      } catch {
+      }
+    }
+    try {
+      const body = await response.json();
+      if (body.accepts && Array.isArray(body.accepts) && body.accepts.length > 0) {
+        return { requirements: body.accepts[0], resource: body.resource };
+      }
+      if (body.paymentRequirements) {
+        const pr = Array.isArray(body.paymentRequirements) ? body.paymentRequirements[0] : body.paymentRequirements;
+        return { requirements: pr, resource: body.resource };
+      }
+      if (body.scheme && body.network) {
+        return { requirements: body, resource: body.resource };
+      }
+    } catch {
+    }
+    const wwwAuth = response.headers.get("WWW-Authenticate");
+    if (wwwAuth) {
+      const m = wwwAuth.match(/x402[^"]*"([^"]+)"/);
+      if (m) {
+        try {
+          const decoded = JSON.parse(Buffer.from(m[1], "base64").toString("utf-8"));
+          const reqs = Array.isArray(decoded) ? decoded[0] : decoded;
+          return { requirements: reqs };
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  // ──────────── Build x402 v2 PaymentPayload with EIP-3009 ────────────
+  //
+  // If an AgentAccount is configured, we use it as the `from` address
+  // (smart wallet pays directly). The AgentAccount implements EIP-1271
+  // so USDC's transferWithAuthorization will call isValidSignature()
+  // to verify the owner's ECDSA signature. The facilitator detects
+  // the >65-byte or smart-wallet case and uses the bytes overload.
+  async buildPaymentPayload(reqs, resource, url) {
+    const now = Math.floor(Date.now() / 1e3);
+    const validAfter = String(now - 60);
+    const validBefore = String(now + (reqs.maxTimeoutSeconds || 300));
+    const nonce = ethers3.hexlify(ethers3.randomBytes(32));
+    const chainId = chainIdFromNetwork(reqs.network);
+    const usdcDomain = USDC_DOMAINS[reqs.network] || USDC_DOMAINS["eip155:1"];
+    const payerAddress = this.config.accountAddress || this.wallet.address;
+    const isSmartWallet = !!this.config.accountAddress;
+    const domain = {
+      name: usdcDomain.name,
+      version: usdcDomain.version,
+      chainId,
+      verifyingContract: reqs.asset || usdcDomain.address
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const value = {
+      from: payerAddress,
+      // AgentAccount or EOA
+      to: reqs.payTo,
+      value: reqs.amount,
+      validAfter,
+      validBefore,
+      nonce
+    };
+    let signature = await this.wallet.signTypedData(domain, types, value);
+    if (isSmartWallet) {
+      signature = signature + "00";
+    }
+    if (isSmartWallet) {
+      console.log(`         \u2713 Signed for AgentAccount ${payerAddress.slice(0, 10)}\u2026 (EIP-1271, chain=${chainId})`);
+    } else {
+      console.log(`         \u2713 Signed (from=${payerAddress.slice(0, 10)}\u2026, chain=${chainId})`);
+    }
+    return {
+      x402Version: 2,
+      resource: resource || { url, description: "", mimeType: "application/json" },
+      accepted: {
+        scheme: reqs.scheme,
+        network: reqs.network,
+        amount: reqs.amount,
+        asset: reqs.asset,
+        payTo: reqs.payTo,
+        maxTimeoutSeconds: reqs.maxTimeoutSeconds,
+        extra: reqs.extra || {}
+      },
+      payload: {
+        signature,
+        authorization: {
+          from: payerAddress,
+          // AgentAccount address — facilitator checks balance here
+          to: reqs.payTo,
+          value: reqs.amount,
+          validAfter,
+          validBefore,
+          nonce
+        }
+      }
+    };
+  }
+  // ──────────── Risk check via our backend ────────────
+  async riskCheck(paymentPayload, reqs) {
+    try {
+      const verifyUrl = `${this.config.backendUrl}/x402/verify`;
+      const resp = await fetch(verifyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Agent-Id": this.config.agentId || "",
+          ...this.config.accountAddress ? { "X-Agent-Account": this.config.accountAddress } : {}
+        },
+        body: JSON.stringify({
+          x402Version: 2,
+          paymentPayload,
+          paymentRequirements: reqs
+        }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (resp.ok) {
+        const result = await resp.json();
+        const decision = resp.headers.get("X-Risk-Decision") || (result.isValid ? "allow" : "unknown");
+        const score = resp.headers.get("X-Risk-Score") || "?";
+        console.log(`         \u2713 Risk check: ${decision} (score=${score})`);
+      } else {
+        console.log(`         \u26A0 Risk check failed (HTTP ${resp.status}) \u2014 continuing anyway`);
+      }
+    } catch {
+      console.log("         \u26A0 Risk check unavailable \u2014 continuing");
+    }
+  }
+};
+
+// src/clients/WalletClient.ts
+import { ethers as ethers4, Contract as Contract3, Wallet } from "ethers";
+var WalletClient = class {
+  constructor(config) {
+    this.privateKey = null;
+    this.factoryAddress = config.factoryAddress;
+    this.usdcAddress = config.usdcAddress || ethers4.ZeroAddress;
+    this.chainId = config.chainId;
+    this.rpcUrl = config.rpcUrl;
+    this.provider = new ethers4.JsonRpcProvider(config.rpcUrl);
+    this.privateKey = config.privateKey || null;
+  }
+  /**
+   * Create a fresh signer to avoid nonce caching issues
+   */
+  getFreshSigner() {
+    if (!this.privateKey) {
+      throw new Error("Signer not configured - provide privateKey");
+    }
+    const freshProvider = new ethers4.JsonRpcProvider(this.rpcUrl);
+    return new Wallet(this.privateKey, freshProvider);
+  }
+  getFactoryContract() {
+    if (this.privateKey) {
+      return new Contract3(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.getFreshSigner());
+    }
+    return new Contract3(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.provider);
+  }
+  getAccountContract(accountAddress) {
+    if (this.privateKey) {
+      return new Contract3(accountAddress, AGENT_ACCOUNT_ABI, this.getFreshSigner());
+    }
+    return new Contract3(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 === ethers4.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");
+    }
+    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 !== ethers4.ZeroAddress) {
+      usdcBalance = await account.balanceOf(this.usdcAddress);
+    }
+    return {
+      address: accountAddress,
+      agentId: BigInt(agentId),
+      owner,
+      ethBalance: BigInt(ethBalance),
+      usdcBalance: BigInt(usdcBalance)
+    };
+  }
+  async getProviderStatus(accountAddress, creditProvider) {
+    const provider = new Contract3(
+      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)
+    };
+  }
+  // ============ Fund / Withdraw ============
+  async fundAccount(accountAddress, tokenAddress, amount) {
+    if (!this.privateKey) {
+      throw new Error("Signer not configured");
+    }
+    const signer = this.getFreshSigner();
+    const token = new Contract3(tokenAddress, ERC20_ABI, signer);
+    const approveTx = await token.approve(accountAddress, amount);
+    await approveTx.wait();
+    const signer2 = this.getFreshSigner();
+    const account = new Contract3(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");
+    }
+    const account = this.getAccountContract(accountAddress);
+    const tx = await account.execute(target, value, data);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  // ============ Utility ============
+  generatePaymentMessageHash(accountAddress, recipient, amount, nonce, deadline, chainId) {
+    return ethers4.keccak256(
+      ethers4.AbiCoder.defaultAbiCoder().encode(
+        ["address", "uint256", "uint256", "uint256", "uint256", "address"],
+        [recipient, amount, nonce, deadline, chainId, accountAddress]
+      )
+    );
+  }
+};
+
+// src/utils/format.ts
+function parseUnits(value, decimals = 6) {
+  const [integer, fraction = ""] = value.split(".");
+  const paddedFraction = fraction.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(integer + paddedFraction);
+}
+function formatUnits(value, decimals = 6) {
+  const str = value.toString().padStart(decimals + 1, "0");
+  const integer = str.slice(0, -decimals) || "0";
+  const fraction = str.slice(-decimals);
+  return `${integer}.${fraction}`;
+}
+function formatUSD(value, decimals = 6) {
+  const num = Number(formatUnits(value, decimals));
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD"
+  }).format(num);
+}
+function formatPercent(bps) {
+  return `${(bps / 100).toFixed(2)}%`;
+}
+function formatAPR(bps) {
+  return formatPercent(Number(bps));
+}
+function formatHealthFactor(factor) {
+  const num = Number(factor) / 1e18;
+  if (num >= 100) return "\u221E";
+  return num.toFixed(2);
+}
+function formatAddress(address) {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function formatTimestamp(timestamp) {
+  return new Date(Number(timestamp) * 1e3).toISOString();
+}
+function bpsToRate(bps) {
+  return Number(bps) / 1e4;
+}
+function rateToBps(rate) {
+  return BigInt(Math.round(rate * 1e4));
+}
+export {
+  ACCOUNT_FACTORY_ABI,
+  AGENT_ACCOUNT_ABI,
+  AGENT_REPUTATION_ABI,
+  AgentIdentityClient,
+  AgetherClient,
+  AgetherError,
+  CREDIT_PROVIDER_ABI,
+  ChainId,
+  CreditNotActiveError,
+  CreditStatus,
+  ERC20_ABI,
+  IDENTITY_REGISTRY_ABI,
+  InsufficientCreditError,
+  LP_VAULT_ABI,
+  REPUTATION_CREDIT_ABI,
+  ScoringClient,
+  ScoringRejectedError,
+  VALIDATION_REGISTRY_ABI,
+  VaultClient,
+  WalletClient,
+  X402Client,
+  bpsToRate,
+  createConfig,
+  formatAPR,
+  formatAddress,
+  formatHealthFactor,
+  formatPercent,
+  formatTimestamp,
+  formatUSD,
+  formatUnits,
+  getDefaultConfig,
+  getUSDCAddress,
+  parseUnits,
+  rateToBps
+};