@agether/sdk 1.11.0 → 1.11.1

package/dist/cli.js

@@ -1,2252 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/types/index.ts
-var AgetherError;
-var init_types = __esm({
-  "src/types/index.ts"() {
-    "use strict";
-    AgetherError = class extends Error {
-      constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = "AgetherError";
-      }
-    };
-  }
-});
-
-// src/utils/abis.ts
-var IDENTITY_REGISTRY_ABI, ACCOUNT_FACTORY_ABI, AGENT_ACCOUNT_ABI, AGENT_REPUTATION_ABI, MORPHO_BLUE_ABI, ERC20_ABI, KYA_HOOK_ABI;
-var init_abis = __esm({
-  "src/utils/abis.ts"() {
-    "use strict";
-    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)"
-    ];
-    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)",
-      "function protocolHook() view returns (address)",
-      "function identityRegistry() view returns (address)",
-      "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
-    ];
-    AGENT_ACCOUNT_ABI = [
-      "function agentId() view returns (uint256)",
-      "function owner() view returns (address)",
-      "function factory() view returns (address)",
-      "function identityRegistry() view returns (address)",
-      "function balanceOf(address token) view returns (uint256)",
-      "function ethBalance() view returns (uint256)",
-      // ERC-7579 execution
-      "function execute(bytes32 mode, bytes executionCalldata) payable",
-      "function executeFromExecutor(bytes32 mode, bytes executionCalldata) payable returns (bytes[])",
-      // ERC-7579 module management
-      "function installModule(uint256 moduleTypeId, address module, bytes initData) payable",
-      "function uninstallModule(uint256 moduleTypeId, address module, bytes deInitData) payable",
-      "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)",
-      "function hook() view returns (address)",
-      // Funding (direct, no execution needed)
-      "function fund(address token, uint256 amount)",
-      "function withdraw(address token, uint256 amount, address to)",
-      "function withdrawETH(uint256 amount, address to)",
-      // EIP-1271
-      "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
-    ];
-    AGENT_REPUTATION_ABI = [
-      "function getCreditScore(uint256 agentId) view returns (uint256)",
-      "function getAttestation(uint256 agentId) view returns (tuple(uint256 score, uint256 timestamp, address signer))",
-      "function isScoreFresh(uint256 agentId) view returns (bool fresh, uint256 age)",
-      "function isEligible(uint256 agentId, uint256 minScore) view returns (bool eligible, uint256 currentScore)",
-      "function oracleSigner() view returns (address)",
-      "function submitScore(uint256 agentId, uint256 score_, uint256 timestamp_, bytes signature)",
-      "function setOracleSigner(address signer_)",
-      "event ScoreUpdated(uint256 indexed agentId, uint256 score, uint256 timestamp, address signer)"
-    ];
-    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))"
-    ];
-    ERC20_ABI = [
-      "function balanceOf(address account) view returns (uint256)",
-      "function allowance(address owner, address spender) view returns (uint256)",
-      "function approve(address spender, uint256 amount) returns (bool)",
-      "function transfer(address to, uint256 amount) returns (bool)",
-      "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-      "function decimals() view returns (uint8)",
-      "function symbol() view returns (string)",
-      "function name() view returns (string)"
-    ];
-    KYA_HOOK_ABI = [
-      "function validationRegistry() view returns (address)",
-      "function setValidationRegistry(address newRegistry)"
-    ];
-  }
-});
-
-// src/utils/config.ts
-function getDefaultConfig(chainId) {
-  return {
-    chainId,
-    rpcUrl: RPC_URLS[chainId],
-    contracts: CONTRACT_ADDRESSES[chainId],
-    scoringEndpoint: SCORING_ENDPOINTS[chainId]
-  };
-}
-var CONTRACT_ADDRESSES, RPC_URLS, SCORING_ENDPOINTS;
-var init_config = __esm({
-  "src/utils/config.ts"() {
-    "use strict";
-    init_types();
-    CONTRACT_ADDRESSES = {
-      [1 /* Ethereum */]: {
-        accountFactory: "0x0000000000000000000000000000000000000000",
-        validationRegistry: "0x0000000000000000000000000000000000000000",
-        agentReputation: "0x0000000000000000000000000000000000000000",
-        kyaHook: "0x0000000000000000000000000000000000000000",
-        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-        morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
-      },
-      [8453 /* Base */]: {
-        accountFactory: "0x89a8758E60A56EcB47247D92E05447eFd450d6Bf",
-        validationRegistry: "0x6f76cF69B71Dc5F9A414BCEe4583b12738E47985",
-        agentReputation: "0xe88f3419a2dbac70e3aF6E487b0C63e8301C6A87",
-        kyaHook: "0x28e50Aa9eD517E369b2806928709B44062aD9821",
-        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-        morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
-      },
-      [84532 /* BaseSepolia */]: {
-        accountFactory: "0x0000000000000000000000000000000000000000",
-        validationRegistry: "0x0000000000000000000000000000000000000000",
-        agentReputation: "0x0000000000000000000000000000000000000000",
-        kyaHook: "0x0000000000000000000000000000000000000000",
-        usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-        identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-        morphoBlue: "0x0000000000000000000000000000000000000000"
-      },
-      [11155111 /* Sepolia */]: {
-        accountFactory: "0x0000000000000000000000000000000000000000",
-        validationRegistry: "0x0000000000000000000000000000000000000000",
-        agentReputation: "0x0000000000000000000000000000000000000000",
-        kyaHook: "0x0000000000000000000000000000000000000000",
-        usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-        identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-        morphoBlue: "0x0000000000000000000000000000000000000000"
-      },
-      [31337 /* Hardhat */]: {
-        accountFactory: "0x0000000000000000000000000000000000000000",
-        validationRegistry: "0x0000000000000000000000000000000000000000",
-        agentReputation: "0x0000000000000000000000000000000000000000",
-        kyaHook: "0x0000000000000000000000000000000000000000",
-        usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
-        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-        morphoBlue: "0x0000000000000000000000000000000000000000"
-      }
-    };
-    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"
-    };
-    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"
-    };
-  }
-});
-
-// src/clients/MorphoClient.ts
-var MorphoClient_exports = {};
-__export(MorphoClient_exports, {
-  MorphoClient: () => MorphoClient
-});
-var import_ethers, import_axios, BASE_COLLATERALS, MORPHO_API_URL, MODE_SINGLE, MODE_BATCH, morphoIface, erc20Iface, MorphoClient;
-var init_MorphoClient = __esm({
-  "src/clients/MorphoClient.ts"() {
-    "use strict";
-    import_ethers = require("ethers");
-    import_axios = __toESM(require("axios"));
-    init_types();
-    init_abis();
-    init_config();
-    BASE_COLLATERALS = {
-      WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
-      wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
-      cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
-    };
-    MORPHO_API_URL = "https://api.morpho.org/graphql";
-    MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
-    MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
-    morphoIface = new import_ethers.ethers.Interface(MORPHO_BLUE_ABI);
-    erc20Iface = new import_ethers.ethers.Interface(ERC20_ABI);
-    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._rpcUrl = config.rpcUrl || defaultCfg.rpcUrl;
-        if ("signer" in config && config.signer) {
-          this._useExternalSigner = true;
-          const signerProvider = config.signer.provider;
-          if (signerProvider) {
-            this.provider = signerProvider;
-            this._signer = config.signer;
-          } else {
-            this.provider = new import_ethers.ethers.JsonRpcProvider(this._rpcUrl);
-            this._signer = config.signer.connect(this.provider);
-          }
-          if ("address" in config.signer && typeof config.signer.address === "string") {
-            this._eoaAddress = config.signer.address;
-          }
-        } else {
-          this._privateKey = config.privateKey;
-          this._useExternalSigner = false;
-          this.provider = new import_ethers.ethers.JsonRpcProvider(this._rpcUrl);
-          const wallet = new import_ethers.ethers.Wallet(this._privateKey, this.provider);
-          this._signer = wallet;
-          this._eoaAddress = wallet.address;
-        }
-        const addrs = { ...defaultCfg.contracts, ...config.contracts };
-        this.accountFactory = new import_ethers.Contract(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this._signer);
-        this.morphoBlue = new import_ethers.Contract(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
-        this.agentReputation = new import_ethers.Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
-        this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
-      }
-      // ════════════════════════════════════════════════════════
-      //  KYA Gate Check
-      // ════════════════════════════════════════════════════════
-      /**
-       * Check whether the KYA (Know Your Agent) code verification gate is active.
-       * Reads the account's installed hook and checks if it has a non-zero
-       * validationRegistry — when set, the hook enforces KYA code approval.
-       */
-      async isKyaRequired() {
-        try {
-          const acctAddr = await this.getAccountAddress();
-          const account = new import_ethers.Contract(acctAddr, AGENT_ACCOUNT_ABI, this.provider);
-          const hookAddr = await account.hook();
-          if (hookAddr === import_ethers.ethers.ZeroAddress) return false;
-          const hook = new import_ethers.Contract(hookAddr, KYA_HOOK_ABI, this.provider);
-          const registryAddr = await hook.validationRegistry();
-          return registryAddr !== import_ethers.ethers.ZeroAddress;
-        } catch {
-          return false;
-        }
-      }
-      // ════════════════════════════════════════════════════════
-      //  Account Management
-      // ════════════════════════════════════════════════════════
-      /** Resolve the AgentAccount address (cached, with retry for flaky RPCs). */
-      async getAccountAddress() {
-        if (this._accountAddress) return this._accountAddress;
-        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
-        const MAX_RETRIES = 3;
-        let lastErr;
-        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-          try {
-            const addr = await this.accountFactory.getAccount(BigInt(this.agentId));
-            if (addr === import_ethers.ethers.ZeroAddress) {
-              throw new AgetherError("No AgentAccount found. Call register() first.", "NO_ACCOUNT");
-            }
-            this._accountAddress = addr;
-            return addr;
-          } catch (err) {
-            if (err instanceof AgetherError) throw err;
-            lastErr = err;
-            if (attempt < MAX_RETRIES) {
-              await new Promise((r) => setTimeout(r, 500 * attempt));
-            }
-          }
-        }
-        throw lastErr;
-      }
-      getAgentId() {
-        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
-        return this.agentId;
-      }
-      /**
-       * Get the EOA wallet address (synchronous, best-effort).
-       *
-       * For the `privateKey` path this always works. For the `signer` path
-       * it works if the signer exposes `.address` synchronously (e.g. ethers.Wallet).
-       * If the address has not been resolved yet, throws — call `getSignerAddress()` first.
-       */
-      getWalletAddress() {
-        if (this._eoaAddress) return this._eoaAddress;
-        const signer = this._signer;
-        if (signer.address && typeof signer.address === "string") {
-          const addr = signer.address;
-          this._eoaAddress = addr;
-          return addr;
-        }
-        throw new AgetherError(
-          "EOA address not yet resolved. Call getSignerAddress() (async) first, or use a signer that exposes .address synchronously.",
-          "ADDRESS_NOT_RESOLVED"
-        );
-      }
-      /**
-       * Resolve the EOA signer address (async, works with all signer types).
-       * Result is cached after the first call.
-       */
-      async getSignerAddress() {
-        if (!this._eoaAddress) {
-          this._eoaAddress = await this._signer.getAddress();
-        }
-        return this._eoaAddress;
-      }
-      /** Mint a new ERC-8004 identity and return the agentId. */
-      async _mintNewIdentity() {
-        const regTx = await this.identityRegistry.register();
-        const regReceipt = await regTx.wait();
-        this._refreshSigner();
-        let agentId = 0n;
-        for (const log of regReceipt.logs) {
-          try {
-            const parsed = this.identityRegistry.interface.parseLog({ topics: log.topics, data: log.data });
-            if (parsed?.name === "Transfer") {
-              agentId = parsed.args[2];
-              break;
-            }
-          } catch (e) {
-            console.warn("[agether] parseLog skip:", e instanceof Error ? e.message : e);
-            continue;
-          }
-        }
-        if (agentId === 0n) throw new AgetherError("Failed to parse agentId from registration", "PARSE_ERROR");
-        return agentId;
-      }
-      /**
-       * Register: create ERC-8004 identity + AgentAccount in one flow.
-       * If already registered, returns existing state.
-       */
-      async register(_name) {
-        const eoaAddr = await this.getSignerAddress();
-        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;
-            const kyaRequired2 = await this.isKyaRequired();
-            return { agentId: this.agentId, address: eoaAddr, agentAccount: acct, alreadyRegistered: true, kyaRequired: kyaRequired2 };
-          }
-        }
-        let agentId;
-        if (this.agentId) {
-          const balance = await this.identityRegistry.balanceOf(eoaAddr);
-          if (balance > 0n) {
-            agentId = BigInt(this.agentId);
-          } else {
-            agentId = await this._mintNewIdentity();
-          }
-        } else {
-          agentId = await this._mintNewIdentity();
-        }
-        this.agentId = agentId.toString();
-        const acctExists = await this.accountFactory.accountExists(agentId);
-        let txHash;
-        if (!acctExists) {
-          const tx = await this.accountFactory.createAccount(agentId);
-          const receipt = await tx.wait();
-          this._refreshSigner();
-          txHash = receipt.hash;
-        }
-        const acctAddr = await this.accountFactory.getAccount(agentId);
-        this._accountAddress = acctAddr;
-        const kyaRequired = await this.isKyaRequired();
-        return {
-          agentId: this.agentId,
-          address: eoaAddr,
-          agentAccount: acctAddr,
-          alreadyRegistered: acctExists,
-          kyaRequired,
-          tx: txHash
-        };
-      }
-      /** Get ETH / USDC / collateral balances for EOA and AgentAccount. */
-      async getBalances() {
-        const eoaAddr = await this.getSignerAddress();
-        const usdc = new import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
-        const ethBal = await this.provider.getBalance(eoaAddr);
-        const usdcBal = await usdc.balanceOf(eoaAddr);
-        const eoaCollateral = {};
-        for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
-          try {
-            const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
-            const bal = await token.balanceOf(eoaAddr);
-            eoaCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
-          } catch (e) {
-            console.warn(`[agether] EOA collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-            eoaCollateral[symbol] = "0";
-          }
-        }
-        const result = {
-          agentId: this.agentId || "?",
-          address: eoaAddr,
-          eth: import_ethers.ethers.formatEther(ethBal),
-          usdc: import_ethers.ethers.formatUnits(usdcBal, 6),
-          collateral: eoaCollateral
-        };
-        try {
-          const acctAddr = await this.getAccountAddress();
-          const acctEth = await this.provider.getBalance(acctAddr);
-          const acctUsdc = await usdc.balanceOf(acctAddr);
-          const acctCollateral = {};
-          for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
-            try {
-              const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
-              const bal = await token.balanceOf(acctAddr);
-              acctCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
-            } catch (e) {
-              console.warn(`[agether] AgentAccount collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-              acctCollateral[symbol] = "0";
-            }
-          }
-          result.agentAccount = {
-            address: acctAddr,
-            eth: import_ethers.ethers.formatEther(acctEth),
-            usdc: import_ethers.ethers.formatUnits(acctUsdc, 6),
-            collateral: acctCollateral
-          };
-        } catch (err) {
-          if (err instanceof AgetherError && err.code === "NO_ACCOUNT") {
-          } else {
-            console.warn("[agether] getBalances: failed to fetch AgentAccount data:", err.message ?? err);
-          }
-        }
-        return result;
-      }
-      /** Transfer USDC from EOA to AgentAccount. */
-      async fundAccount(usdcAmount) {
-        const acctAddr = await this.getAccountAddress();
-        const usdc = new import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this._signer);
-        const amount = import_ethers.ethers.parseUnits(usdcAmount, 6);
-        const tx = await usdc.transfer(acctAddr, amount);
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        return { tx: receipt.hash, amount: usdcAmount, agentAccount: acctAddr };
-      }
-      // ════════════════════════════════════════════════════════
-      //  Market Discovery (Morpho GraphQL API)
-      // ════════════════════════════════════════════════════════
-      /**
-       * Fetch USDC borrow markets on Base from Morpho API.
-       * Caches results for 5 minutes.
-       */
-      async getMarkets(forceRefresh = false) {
-        if (!forceRefresh && this._discoveredMarkets && Date.now() - this._discoveredAt < 3e5) {
-          return this._discoveredMarkets;
-        }
-        const chainId = this.config.chainId;
-        const usdcAddr = this.config.contracts.usdc.toLowerCase();
-        const query = `{
-      markets(
-        first: 50
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"] }
-      ) {
-        items {
-          uniqueKey
-          lltv
-          oracleAddress
-          irmAddress
-          loanAsset { address symbol decimals }
-          collateralAsset { address symbol decimals }
-          state {
-            borrowAssets
-            supplyAssets
-            utilization
-          }
-        }
-      }
-    }`;
-        try {
-          const resp = await import_axios.default.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: import_ethers.ethers.ZeroAddress, symbol: "N/A", decimals: 0 },
-            oracle: m.oracleAddress,
-            irm: m.irmAddress,
-            lltv: BigInt(m.lltv),
-            totalSupplyAssets: BigInt(m.state?.supplyAssets ?? "0"),
-            totalBorrowAssets: BigInt(m.state?.borrowAssets ?? "0"),
-            utilization: m.state?.utilization ? Number(m.state.utilization) : 0
-          }));
-          this._discoveredAt = Date.now();
-          for (const mi of this._discoveredMarkets) {
-            if (mi.collateralAsset.address !== import_ethers.ethers.ZeroAddress) {
-              this._marketCache.set(mi.collateralAsset.address.toLowerCase(), {
-                loanToken: mi.loanAsset.address,
-                collateralToken: mi.collateralAsset.address,
-                oracle: mi.oracle,
-                irm: mi.irm,
-                lltv: mi.lltv
-              });
-            }
-          }
-          return this._discoveredMarkets;
-        } catch (e) {
-          console.warn("[agether] getMarkets failed, using cache:", e instanceof Error ? e.message : e);
-          return this._discoveredMarkets ?? [];
-        }
-      }
-      /**
-       * Get MarketParams for a collateral token.
-       * Tries cache → API → on-chain idToMarketParams.
-       */
-      async findMarketForCollateral(collateralSymbolOrAddress) {
-        const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-        const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
-        const cached = this._marketCache.get(colAddr);
-        if (cached) return cached;
-        await this.getMarkets();
-        const fromApi = this._marketCache.get(colAddr);
-        if (fromApi) return fromApi;
-        throw new AgetherError(
-          `No Morpho market found for collateral ${collateralSymbolOrAddress}`,
-          "MARKET_NOT_FOUND"
-        );
-      }
-      /** Read MarketParams on-chain by market ID (bytes32). */
-      async getMarketParams(marketId) {
-        const result = await this.morphoBlue.idToMarketParams(marketId);
-        return {
-          loanToken: result.loanToken,
-          collateralToken: result.collateralToken,
-          oracle: result.oracle,
-          irm: result.irm,
-          lltv: result.lltv
-        };
-      }
-      // ════════════════════════════════════════════════════════
-      //  Position Reads
-      // ════════════════════════════════════════════════════════
-      /** Read on-chain position for a specific market. */
-      async getPosition(marketId) {
-        const acctAddr = await this.getAccountAddress();
-        const pos = await this.morphoBlue.position(marketId, acctAddr);
-        return {
-          supplyShares: pos.supplyShares,
-          borrowShares: pos.borrowShares,
-          collateral: pos.collateral
-        };
-      }
-      /**
-       * Full status: positions across all discovered markets.
-       */
-      async getStatus() {
-        const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
-        const positions = [];
-        let totalDebt = 0n;
-        for (const m of markets) {
-          if (!m.collateralAsset || m.collateralAsset.address === import_ethers.ethers.ZeroAddress) continue;
-          try {
-            const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-            if (pos.collateral === 0n && pos.borrowShares === 0n && pos.supplyShares === 0n) continue;
-            let debt = 0n;
-            if (pos.borrowShares > 0n) {
-              try {
-                const mkt = await this.morphoBlue.market(m.uniqueKey);
-                const totalBorrowShares = BigInt(mkt.totalBorrowShares);
-                const totalBorrowAssets = BigInt(mkt.totalBorrowAssets);
-                debt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
-                totalDebt += debt;
-              } catch (e) {
-                console.warn(`[agether] debt calc failed for market ${m.uniqueKey}:`, e instanceof Error ? e.message : e);
-              }
-            }
-            positions.push({
-              marketId: m.uniqueKey,
-              collateralToken: m.collateralAsset.symbol,
-              collateral: import_ethers.ethers.formatUnits(pos.collateral, m.collateralAsset.decimals),
-              borrowShares: pos.borrowShares.toString(),
-              supplyShares: pos.supplyShares.toString(),
-              debt: import_ethers.ethers.formatUnits(debt, 6)
-            });
-          } catch (e) {
-            console.warn(`[agether] position read failed for market:`, e instanceof Error ? e.message : e);
-            continue;
-          }
-        }
-        return {
-          agentId: this.agentId || "?",
-          agentAccount: acctAddr,
-          totalDebt: import_ethers.ethers.formatUnits(totalDebt, 6),
-          positions
-        };
-      }
-      // ════════════════════════════════════════════════════════
-      //  Balance & Borrowing Capacity
-      // ════════════════════════════════════════════════════════
-      /**
-       * Get the USDC balance of the AgentAccount.
-       * @returns USDC balance in raw units (6 decimals)
-       */
-      async getUsdcBalance() {
-        const acctAddr = await this.getAccountAddress();
-        const usdc = new import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
-        return usdc.balanceOf(acctAddr);
-      }
-      /**
-       * Calculate the maximum additional USDC that can be borrowed
-       * given the agent's current collateral and debt across all markets.
-       *
-       * For each market with collateral deposited:
-       *   maxBorrow = (collateralValue * LLTV) - currentDebt
-       *
-       * Uses the Morpho oracle to price collateral → loan token.
-       *
-       * @returns Maximum additional USDC borrowable (6 decimals)
-       */
-      async getMaxBorrowable() {
-        const acctAddr = await this.getAccountAddress();
-        const markets = await this.getMarkets();
-        let totalAdditional = 0n;
-        const byMarket = [];
-        for (const m of markets) {
-          if (!m.collateralAsset || m.collateralAsset.address === import_ethers.ethers.ZeroAddress) continue;
-          try {
-            const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-            if (pos.collateral === 0n) continue;
-            const mktState = await this.morphoBlue.market(m.uniqueKey);
-            const totalBorrowShares = BigInt(mktState.totalBorrowShares);
-            const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
-            const currentDebt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
-            let collateralValueInLoan;
-            try {
-              const oracleContract = new import_ethers.Contract(m.oracle, [
-                "function price() view returns (uint256)"
-              ], this.provider);
-              const oraclePrice = await oracleContract.price();
-              const ORACLE_PRICE_SCALE = 10n ** 36n;
-              collateralValueInLoan = BigInt(pos.collateral) * oraclePrice / ORACLE_PRICE_SCALE;
-            } catch (e) {
-              console.warn(`[agether] oracle price fetch failed:`, e instanceof Error ? e.message : e);
-              continue;
-            }
-            const maxBorrowTotal = collateralValueInLoan * m.lltv / 10n ** 18n;
-            const maxAdditional = maxBorrowTotal > currentDebt ? maxBorrowTotal - currentDebt : 0n;
-            totalAdditional += maxAdditional;
-            byMarket.push({
-              collateralToken: m.collateralAsset.symbol,
-              maxAdditional,
-              currentDebt,
-              collateralValue: collateralValueInLoan
-            });
-          } catch (e) {
-            console.warn(`[agether] maxBorrow calc failed:`, e instanceof Error ? e.message : e);
-            continue;
-          }
-        }
-        return { total: totalAdditional, byMarket };
-      }
-      // ════════════════════════════════════════════════════════
-      //  Market Rates & Yield Estimation
-      // ════════════════════════════════════════════════════════
-      /**
-       * Fetch current supply/borrow APY for a collateral market from Morpho GraphQL API.
-       *
-       * Note: On Morpho Blue, collateral does NOT earn yield directly. Supply APY
-       * is what lenders earn; borrow APY is what borrowers pay.
-       */
-      async getMarketRates(collateralSymbolOrAddress) {
-        const chainId = this.config.chainId;
-        const usdcAddr = this.config.contracts.usdc.toLowerCase();
-        let collateralFilter = "";
-        if (collateralSymbolOrAddress) {
-          const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-          const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
-          collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
-        }
-        const query = `{
-      markets(
-        first: 50
-        orderBy: SupplyAssetsUsd
-        orderDirection: Desc
-        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"]${collateralFilter} }
-      ) {
-        items {
-          uniqueKey
-          lltv
-          loanAsset { address symbol decimals }
-          collateralAsset { address symbol decimals }
-          state {
-            borrowAssets
-            supplyAssets
-            utilization
-            supplyApy
-            borrowApy
-          }
-        }
-      }
-    }`;
-        try {
-          const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
-          const items = resp.data?.data?.markets?.items ?? [];
-          return items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== import_ethers.ethers.ZeroAddress).map((m) => ({
-            collateralToken: m.collateralAsset.symbol,
-            loanToken: m.loanAsset.symbol,
-            supplyApy: m.state?.supplyApy ? Number(m.state.supplyApy) : 0,
-            borrowApy: m.state?.borrowApy ? Number(m.state.borrowApy) : 0,
-            utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
-            totalSupplyUsd: m.state?.supplyAssets ? Number(m.state.supplyAssets) / 1e6 : 0,
-            totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / 1e6 : 0,
-            lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
-            marketId: m.uniqueKey
-          }));
-        } catch (e) {
-          console.warn("[agether] getMarketRates failed:", e instanceof Error ? e.message : e);
-          return [];
-        }
-      }
-      /**
-       * Estimate theoretical yield for a given collateral amount over a period.
-       *
-       * ⚠️ IMPORTANT: On Morpho Blue, collateral does NOT earn yield directly.
-       * This estimates what the collateral WOULD earn if it were instead supplied
-       * as a lender (not used as collateral). This is a theoretical upper bound
-       * useful for setting spending caps.
-       *
-       * @param collateralSymbol - e.g. 'WETH'
-       * @param amount - collateral amount in human-readable (e.g. '1.5')
-       * @param periodDays - estimation period in days (default: 1)
-       * @param ethPriceUsd - ETH price in USD for value conversion (if not provided, uses oracle)
-       * @returns Estimated yield in USD for the period
-       */
-      async getYieldEstimate(collateralSymbol, amount, periodDays = 1, ethPriceUsd) {
-        const colInfo = BASE_COLLATERALS[collateralSymbol];
-        if (!colInfo) throw new AgetherError(`Unknown collateral: ${collateralSymbol}`, "UNKNOWN_COLLATERAL");
-        const rates = await this.getMarketRates(collateralSymbol);
-        if (rates.length === 0) {
-          throw new AgetherError(`No market found for ${collateralSymbol}`, "MARKET_NOT_FOUND");
-        }
-        const market = rates[0];
-        const supplyApy = market.supplyApy;
-        let collateralValueUsd;
-        if (ethPriceUsd) {
-          collateralValueUsd = parseFloat(amount) * ethPriceUsd;
-        } else {
-          try {
-            const params = await this.findMarketForCollateral(collateralSymbol);
-            const oracleContract = new import_ethers.Contract(params.oracle, [
-              "function price() view returns (uint256)"
-            ], this.provider);
-            const oraclePrice = await oracleContract.price();
-            const ORACLE_PRICE_SCALE = 10n ** 36n;
-            const amountWei = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
-            const valueInUsdc = amountWei * oraclePrice / ORACLE_PRICE_SCALE;
-            collateralValueUsd = Number(valueInUsdc) / 1e6;
-          } catch (e) {
-            console.warn("[agether] oracle price fetch for yield estimation failed:", e instanceof Error ? e.message : e);
-            throw new AgetherError("Cannot determine collateral value. Provide ethPriceUsd.", "PRICE_UNAVAILABLE");
-          }
-        }
-        const estimatedYieldUsd = collateralValueUsd * supplyApy * (periodDays / 365);
-        return {
-          collateralToken: collateralSymbol,
-          amount,
-          periodDays,
-          theoreticalSupplyApy: supplyApy,
-          estimatedYieldUsd,
-          collateralValueUsd,
-          disclaimer: "Collateral on Morpho Blue does NOT earn yield directly. This estimates what it WOULD earn if supplied as a lender instead. Use as a theoretical spending cap."
-        };
-      }
-      // ════════════════════════════════════════════════════════
-      //  Lending Operations (all via AgentAccount.executeBatch)
-      // ════════════════════════════════════════════════════════
-      /**
-       * Deposit collateral into Morpho Blue.
-       *
-       * Flow:
-       * 1. EOA transfers collateral to AgentAccount
-       * 2. AgentAccount.executeBatch:
-       *    [collateral.approve(MorphoBlue), Morpho.supplyCollateral(params)]
-       */
-      async supplyCollateral(tokenSymbol, amount, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const weiAmount = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const colToken = new import_ethers.Contract(colInfo.address, ERC20_ABI, this._signer);
-        const transferTx = await colToken.transfer(acctAddr, weiAmount);
-        await transferTx.wait();
-        this._refreshSigner();
-        const targets = [colInfo.address, morphoAddr];
-        const values = [0n, 0n];
-        const datas = [
-          erc20Iface.encodeFunctionData("approve", [morphoAddr, weiAmount]),
-          morphoIface.encodeFunctionData("supplyCollateral", [
-            this._toTuple(params),
-            weiAmount,
-            acctAddr,
-            "0x"
-          ])
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        return {
-          tx: receipt.hash,
-          collateralToken: tokenSymbol,
-          amount,
-          agentAccount: acctAddr
-        };
-      }
-      /**
-       * Borrow USDC against existing collateral.
-       *
-       * AgentAccount.execute: Morpho.borrow(params, amount, 0, account, account)
-       *
-       * @param usdcAmount - USDC amount (e.g. '100')
-       * @param tokenSymbol - collateral symbol to identify which market (default: first with collateral)
-       */
-      async borrow(usdcAmount, tokenSymbol, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const amount = import_ethers.ethers.parseUnits(usdcAmount, 6);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        let params;
-        let usedToken = tokenSymbol || "WETH";
-        if (marketParams) {
-          params = marketParams;
-        } else if (tokenSymbol) {
-          params = await this.findMarketForCollateral(tokenSymbol);
-        } else {
-          const { params: p, symbol } = await this._findActiveMarket();
-          params = p;
-          usedToken = symbol;
-        }
-        const data = morphoIface.encodeFunctionData("borrow", [
-          this._toTuple(params),
-          amount,
-          0n,
-          acctAddr,
-          acctAddr
-        ]);
-        const receipt = await this.exec(morphoAddr, data);
-        return {
-          tx: receipt.hash,
-          amount: usdcAmount,
-          collateralToken: usedToken,
-          agentAccount: acctAddr
-        };
-      }
-      /**
-       * Deposit collateral AND borrow USDC in one batched transaction.
-       *
-       * AgentAccount.executeBatch:
-       *   [collateral.approve, Morpho.supplyCollateral, Morpho.borrow]
-       *
-       * The collateral must be transferred to AgentAccount first.
-       */
-      async depositAndBorrow(tokenSymbol, collateralAmount, borrowUsdcAmount, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const colWei = import_ethers.ethers.parseUnits(collateralAmount, colInfo.decimals);
-        const borrowWei = import_ethers.ethers.parseUnits(borrowUsdcAmount, 6);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const colToken = new import_ethers.Contract(colInfo.address, ERC20_ABI, this._signer);
-        const transferTx = await colToken.transfer(acctAddr, colWei);
-        await transferTx.wait();
-        this._refreshSigner();
-        const targets = [colInfo.address, morphoAddr, morphoAddr];
-        const values = [0n, 0n, 0n];
-        const datas = [
-          erc20Iface.encodeFunctionData("approve", [morphoAddr, colWei]),
-          morphoIface.encodeFunctionData("supplyCollateral", [
-            this._toTuple(params),
-            colWei,
-            acctAddr,
-            "0x"
-          ]),
-          morphoIface.encodeFunctionData("borrow", [
-            this._toTuple(params),
-            borrowWei,
-            0n,
-            acctAddr,
-            acctAddr
-          ])
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        return {
-          tx: receipt.hash,
-          collateralToken: tokenSymbol,
-          collateralAmount,
-          borrowAmount: borrowUsdcAmount,
-          agentAccount: acctAddr
-        };
-      }
-      /**
-       * Repay borrowed USDC from AgentAccount.
-       *
-       * AgentAccount.executeBatch:
-       *   [USDC.approve(MorphoBlue), Morpho.repay(params)]
-       */
-      async repay(usdcAmount, tokenSymbol, marketParams) {
-        const acctAddr = await this.getAccountAddress();
-        const 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;
-        }
-        let repayAssets;
-        let repayShares;
-        let approveAmount;
-        if (usdcAmount === "all") {
-          const markets = await this.getMarkets();
-          const mkt = markets.find(
-            (m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase()
-          );
-          if (mkt) {
-            const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
-            repayShares = BigInt(pos.borrowShares);
-            repayAssets = 0n;
-            const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
-            const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
-            const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
-            const estimated = totalBorrowShares > 0n ? repayShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
-            approveAmount = estimated > 0n ? estimated : import_ethers.ethers.parseUnits("1", 6);
-          } else {
-            repayAssets = import_ethers.ethers.parseUnits("999999", 6);
-            repayShares = 0n;
-            approveAmount = repayAssets;
-          }
-        } else {
-          repayAssets = import_ethers.ethers.parseUnits(usdcAmount, 6);
-          repayShares = 0n;
-          approveAmount = repayAssets;
-          try {
-            const markets = await this.getMarkets();
-            const mkt = markets.find(
-              (m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase()
-            );
-            if (mkt) {
-              const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
-              const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
-              const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
-              const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
-              const currentDebt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
-              if (repayAssets >= currentDebt && BigInt(pos.borrowShares) > 0n) {
-                repayShares = BigInt(pos.borrowShares);
-                repayAssets = 0n;
-                approveAmount = currentDebt + 10n;
-              }
-            }
-          } catch (e) {
-            console.warn("[agether] share-based repay detection failed, falling through to asset-based:", e instanceof Error ? e.message : e);
-          }
-        }
-        const targets = [usdcAddr, morphoAddr];
-        const values = [0n, 0n];
-        const datas = [
-          erc20Iface.encodeFunctionData("approve", [morphoAddr, approveAmount]),
-          morphoIface.encodeFunctionData("repay", [
-            this._toTuple(params),
-            repayAssets,
-            repayShares,
-            acctAddr,
-            "0x"
-          ])
-        ];
-        const receipt = await this.batch(targets, values, datas);
-        let remainingDebt = "0";
-        try {
-          const status = await this.getStatus();
-          remainingDebt = status.totalDebt;
-        } catch (e) {
-          console.warn("[agether] failed to read remaining debt after repay:", e instanceof Error ? e.message : e);
-        }
-        return { tx: receipt.hash, amount: usdcAmount, remainingDebt };
-      }
-      /**
-       * Withdraw collateral from Morpho Blue.
-       *
-       * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
-       *
-       * @param receiver - defaults to EOA wallet
-       */
-      async withdrawCollateral(tokenSymbol, amount, marketParams, receiver) {
-        const acctAddr = await this.getAccountAddress();
-        const colInfo = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
-        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
-        const morphoAddr = this.config.contracts.morphoBlue;
-        const dest = receiver || await this.getSignerAddress();
-        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 = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
-        }
-        const data = morphoIface.encodeFunctionData("withdrawCollateral", [
-          this._toTuple(params),
-          weiAmount,
-          acctAddr,
-          dest
-        ]);
-        const receipt = await this.exec(morphoAddr, data);
-        let remainingCollateral = "0";
-        try {
-          const markets = await this.getMarkets();
-          const market = markets.find(
-            (m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase()
-          );
-          if (market) {
-            const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
-            remainingCollateral = import_ethers.ethers.formatUnits(pos.collateral, colInfo.decimals);
-          }
-        } catch (e) {
-          console.warn("[agether] failed to read remaining collateral after withdraw:", e instanceof Error ? e.message : e);
-        }
-        return {
-          tx: receipt.hash,
-          token: tokenSymbol,
-          amount: amount === "all" ? import_ethers.ethers.formatUnits(weiAmount, colInfo.decimals) : amount,
-          remainingCollateral,
-          destination: dest
-        };
-      }
-      /**
-       * Sponsor: transfer collateral to another agent's AgentAccount.
-       * (The agent must then supplyCollateral themselves via their own account.)
-       */
-      async sponsor(target, tokenSymbol, amount) {
-        const colInfo = BASE_COLLATERALS[tokenSymbol];
-        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
-        let targetAddr;
-        if (target.address) {
-          targetAddr = target.address;
-        } else if (target.agentId) {
-          targetAddr = await this.accountFactory.getAccount(BigInt(target.agentId));
-          if (targetAddr === import_ethers.ethers.ZeroAddress) throw new AgetherError("Target agent has no account", "NO_ACCOUNT");
-        } else {
-          throw new AgetherError("Provide agentId or address", "INVALID_TARGET");
-        }
-        const weiAmount = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
-        const colToken = new import_ethers.Contract(colInfo.address, ERC20_ABI, this._signer);
-        const tx = await colToken.transfer(targetAddr, weiAmount);
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        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
-      // ════════════════════════════════════════════════════════
-      /**
-       * Refresh the signer and re-bind contract instances.
-       *
-       * For the **privateKey** path: recreates provider + wallet so the next tx
-       * fetches a fresh nonce from chain. Anvil (and some RPC providers) return a
-       * stale `eth_getTransactionCount` right after a block is mined, causing
-       * "nonce too low" on the follow-up tx.
-       *
-       * For the **external signer** path: the signer is immutable and owned by the
-       * caller (e.g. custody provider). We only re-bind contract instances to
-       * ensure they reference the current signer. Nonce management is the caller's
-       * responsibility.
-       */
-      _refreshSigner() {
-        if (this._useExternalSigner) {
-          const addrs = this.config.contracts;
-          this.accountFactory = new import_ethers.Contract(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this._signer);
-          this.agentReputation = new import_ethers.Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
-          this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
-        } else {
-          this.provider = new import_ethers.ethers.JsonRpcProvider(this._rpcUrl);
-          const wallet = new import_ethers.ethers.Wallet(this._privateKey, this.provider);
-          this._signer = wallet;
-          this._eoaAddress = wallet.address;
-          const addrs = this.config.contracts;
-          this.accountFactory = new import_ethers.Contract(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this._signer);
-          this.agentReputation = new import_ethers.Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
-          this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
-        }
-      }
-      /**
-       * Execute a single call via AgentAccount.execute (ERC-7579 single mode).
-       */
-      async exec(target, data, value = 0n) {
-        const acctAddr = await this.getAccountAddress();
-        const account = new import_ethers.Contract(acctAddr, AGENT_ACCOUNT_ABI, this._signer);
-        const executionCalldata = import_ethers.ethers.AbiCoder.defaultAbiCoder().encode(
-          ["address", "uint256", "bytes"],
-          [target, value, data]
-        );
-        let gasLimit;
-        try {
-          const estimate = await account.execute.estimateGas(MODE_SINGLE, executionCalldata);
-          gasLimit = estimate * 130n / 100n;
-        } catch (e) {
-          console.warn("[agether] exec gas estimation failed, using default 500k:", e instanceof Error ? e.message : e);
-          gasLimit = 500000n;
-        }
-        const tx = await account.execute(MODE_SINGLE, executionCalldata, { gasLimit });
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        return receipt;
-      }
-      /**
-       * Execute multiple calls via AgentAccount.execute (ERC-7579 batch mode).
-       */
-      async batch(targets, values, datas) {
-        const acctAddr = await this.getAccountAddress();
-        const account = new import_ethers.Contract(acctAddr, AGENT_ACCOUNT_ABI, this._signer);
-        const executions = targets.map((t, i) => [t, values[i], datas[i]]);
-        const executionCalldata = import_ethers.ethers.AbiCoder.defaultAbiCoder().encode(
-          ["(address,uint256,bytes)[]"],
-          [executions]
-        );
-        let gasLimit;
-        try {
-          const estimate = await account.execute.estimateGas(MODE_BATCH, executionCalldata);
-          gasLimit = estimate * 130n / 100n;
-        } catch (e) {
-          console.warn("[agether] batch gas estimation failed, using default 800k:", e instanceof Error ? e.message : e);
-          gasLimit = 800000n;
-        }
-        const tx = await account.execute(MODE_BATCH, executionCalldata, { gasLimit });
-        const receipt = await tx.wait();
-        this._refreshSigner();
-        return receipt;
-      }
-      /** 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 === import_ethers.ethers.ZeroAddress) continue;
-          try {
-            const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
-            if (pos.collateral > 0n) {
-              return {
-                params: {
-                  loanToken: m.loanAsset.address,
-                  collateralToken: m.collateralAsset.address,
-                  oracle: m.oracle,
-                  irm: m.irm,
-                  lltv: m.lltv
-                },
-                symbol: m.collateralAsset.symbol
-              };
-            }
-          } catch (e) {
-            console.warn("[agether] _findActiveMarket position check failed:", e instanceof Error ? e.message : e);
-            continue;
-          }
-        }
-        const params = await this.findMarketForCollateral("WETH");
-        return { params, symbol: "WETH" };
-      }
-    };
-  }
-});
-
-// src/clients/X402Client.ts
-var X402Client_exports = {};
-__export(X402Client_exports, {
-  X402Client: () => X402Client
-});
-var import_fetch, import_client, import_client2, import_accounts, X402Client;
-var init_X402Client = __esm({
-  "src/clients/X402Client.ts"() {
-    "use strict";
-    import_fetch = require("@x402/fetch");
-    import_client = require("@x402/core/client");
-    import_client2 = require("@x402/evm/exact/client");
-    import_accounts = require("viem/accounts");
-    X402Client = class {
-      constructor(config) {
-        this.config = config;
-        let baseSigner;
-        if ("walletClient" in config && config.walletClient) {
-          const wc = config.walletClient;
-          const account = wc.account;
-          if (!account) {
-            throw new Error(
-              "X402Client: walletClient must have an attached account. Pass an account when creating the WalletClient or use privateKey mode instead."
-            );
-          }
-          this.address = account.address;
-          baseSigner = {
-            address: account.address,
-            signTypedData: (msg) => wc.signTypedData({
-              account,
-              domain: msg.domain,
-              types: msg.types,
-              primaryType: msg.primaryType,
-              message: msg.message
-            })
-          };
-        } else if ("privateKey" in config && config.privateKey) {
-          const privateKey = config.privateKey.startsWith("0x") ? config.privateKey : `0x${config.privateKey}`;
-          const account = (0, import_accounts.privateKeyToAccount)(privateKey);
-          this.address = account.address;
-          baseSigner = account;
-        } else {
-          throw new Error(
-            "X402Client: provide either privateKey or walletClient in config."
-          );
-        }
-        let signer;
-        if (config.accountAddress) {
-          const accountAddr = config.accountAddress;
-          const inner = baseSigner;
-          signer = (0, import_accounts.toAccount)({
-            address: accountAddr,
-            async signMessage({ message }) {
-              if ("signMessage" in inner && typeof inner.signMessage === "function") {
-                return inner.signMessage({ message });
-              }
-              throw new Error("signMessage not supported by underlying signer");
-            },
-            async signTransaction(tx) {
-              if ("signTransaction" in inner && typeof inner.signTransaction === "function") {
-                return inner.signTransaction(tx);
-              }
-              throw new Error("signTransaction not supported by underlying signer");
-            },
-            async signTypedData(typedData) {
-              const sig = await inner.signTypedData(typedData);
-              return `${sig}00`;
-            }
-          });
-          this.address = accountAddr;
-        } else {
-          signer = baseSigner;
-        }
-        const client = new import_client.x402Client();
-        (0, import_client2.registerExactEvmScheme)(client, { signer });
-        this.paidFetch = (0, import_fetch.wrapFetchWithPayment)(fetch, client);
-        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        const dailyLimit = config.dailySpendLimitUsdc ? BigInt(Math.round(parseFloat(config.dailySpendLimitUsdc) * 1e6)) : 0n;
-        this._spendingTracker = { date: today, totalBorrowed: 0n, dailyLimit };
-      }
-      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.address;
-      }
-      /** Get the current spending tracker state */
-      getSpendingTracker() {
-        this._resetTrackerIfNewDay();
-        return { ...this._spendingTracker };
-      }
-      /** Get remaining daily spending allowance in USDC (human-readable) */
-      getRemainingDailyAllowance() {
-        this._resetTrackerIfNewDay();
-        if (this._spendingTracker.dailyLimit === 0n) return "unlimited";
-        const remaining = this._spendingTracker.dailyLimit - this._spendingTracker.totalBorrowed;
-        return (Number(remaining > 0n ? remaining : 0n) / 1e6).toFixed(2);
-      }
-      /**
-       * Pay with auto-draw: Make an x402 request with automatic Morpho borrowing.
-       *
-       * Flow:
-       * 1. Check USDC balance on AgentAccount
-       * 2. Probe the URL to discover payment amount (if 402)
-       * 3. If insufficient USDC, calculate deficit
-       * 4. Check spending limit
-       * 5. Borrow from Morpho via MorphoClient
-       * 6. Proceed with x402 payment
-       */
-      async payWithAutoDraw(url, opts) {
-        const { morphoClient, ...fetchOpts } = opts || {};
-        if (!this.config.autoDraw || !morphoClient) {
-          return this.request(url, fetchOpts);
-        }
-        try {
-          const usdcBalance = await morphoClient.getUsdcBalance();
-          console.log(`   [auto-draw] AgentAccount USDC balance: ${(Number(usdcBalance) / 1e6).toFixed(2)}`);
-          const paymentAmount = await this._probePaymentAmount(url, fetchOpts);
-          if (paymentAmount !== null) {
-            console.log(`   [auto-draw] Payment required: ${(Number(paymentAmount) / 1e6).toFixed(6)} USDC`);
-            const bufferStr = this.config.autoDrawBuffer || "0.5";
-            const buffer = BigInt(Math.round(parseFloat(bufferStr) * 1e6));
-            const needed = paymentAmount + buffer;
-            if (usdcBalance < needed) {
-              const deficit = needed - usdcBalance;
-              console.log(`   [auto-draw] Insufficient balance. Need to borrow ${(Number(deficit) / 1e6).toFixed(2)} USDC`);
-              const limitCheck = await this._checkSpendingLimit(deficit, morphoClient);
-              if (!limitCheck.allowed) {
-                return {
-                  success: false,
-                  error: `Auto-draw blocked: ${limitCheck.reason}`
-                };
-              }
-              const maxBorrowable = await morphoClient.getMaxBorrowable();
-              if (maxBorrowable.total < deficit) {
-                return {
-                  success: false,
-                  error: `Auto-draw failed: insufficient collateral. Need ${(Number(deficit) / 1e6).toFixed(2)} USDC but can only borrow ${(Number(maxBorrowable.total) / 1e6).toFixed(2)} USDC more.`
-                };
-              }
-              const borrowAmount = (Number(deficit) / 1e6).toFixed(6);
-              console.log(`   [auto-draw] Borrowing ${borrowAmount} USDC from Morpho...`);
-              const borrowResult = await morphoClient.borrow(borrowAmount);
-              console.log(`   [auto-draw] Borrow tx: ${borrowResult.tx}`);
-              this._trackSpending(deficit);
-              const result = await this.request(url, fetchOpts);
-              return {
-                ...result,
-                autoDrawInfo: {
-                  borrowed: borrowAmount,
-                  borrowTx: borrowResult.tx,
-                  reason: `USDC balance insufficient (had ${(Number(usdcBalance) / 1e6).toFixed(2)}, needed ${(Number(needed) / 1e6).toFixed(2)})`
-                }
-              };
-            }
-          }
-          return this.request(url, fetchOpts);
-        } catch (error) {
-          console.log(`   [auto-draw] Auto-draw check failed: ${error instanceof Error ? error.message : String(error)}. Proceeding with normal request.`);
-          return this.request(url, fetchOpts);
-        }
-      }
-      // ──────────── Core request — @x402/fetch handles 402 automatically ────────────
-      async request(url, options) {
-        try {
-          console.log(`   [x402] ${options?.method || "GET"} ${url}`);
-          const response = await this.paidFetch(url, {
-            ...options,
-            headers: {
-              ...options?.headers,
-              "X-Agent-Id": this.config.agentId || ""
-            }
-          });
-          if (response.ok) {
-            const data = await response.json();
-            const paymentResponse = response.headers.get("PAYMENT-RESPONSE");
-            let txHash;
-            if (paymentResponse) {
-              try {
-                const settlement = JSON.parse(
-                  Buffer.from(paymentResponse, "base64").toString("utf-8")
-                );
-                txHash = settlement.transaction;
-              } catch (e) {
-                console.warn("[agether] x402 payment response parse failed:", e instanceof Error ? e.message : e);
-              }
-            }
-            return {
-              success: true,
-              data,
-              ...txHash ? {
-                paymentInfo: {
-                  amount: "",
-                  asset: "USDC",
-                  network: "eip155:8453",
-                  txHash
-                }
-              } : {}
-            };
-          }
-          const errBody = await response.text();
-          return {
-            success: false,
-            error: `HTTP ${response.status}: ${errBody}`
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: `Request failed: ${error instanceof Error ? error.message : String(error)}`
-          };
-        }
-      }
-      // ──────────── Auto-Draw Helpers ────────────
-      /**
-       * Probe a URL to discover payment requirements without paying.
-       * Makes a request and parses the 402 PAYMENT-REQUIRED header.
-       * @returns Payment amount in raw USDC units (6 decimals), or null if not a 402.
-       */
-      async _probePaymentAmount(url, options) {
-        try {
-          const response = await fetch(url, {
-            ...options,
-            headers: {
-              ...options?.headers,
-              "X-Agent-Id": this.config.agentId || ""
-            }
-          });
-          if (response.status !== 402) return null;
-          const paymentHeader = response.headers.get("X-PAYMENT") || response.headers.get("PAYMENT-REQUIRED");
-          if (!paymentHeader) return null;
-          try {
-            const decoded = JSON.parse(Buffer.from(paymentHeader, "base64").toString("utf-8"));
-            const requirements = Array.isArray(decoded) ? decoded : decoded.accepts || [decoded];
-            if (requirements.length > 0) {
-              const amount = requirements[0].maxAmountRequired || requirements[0].amount;
-              if (amount) {
-                return BigInt(amount);
-              }
-            }
-          } catch (e) {
-            console.warn("[agether] x402 payment header parse failed:", e instanceof Error ? e.message : e);
-          }
-          return null;
-        } catch (e) {
-          console.warn("[agether] x402 getPaymentRequired failed:", e instanceof Error ? e.message : e);
-          return null;
-        }
-      }
-      /** Reset spending tracker if it's a new day */
-      _resetTrackerIfNewDay() {
-        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        if (this._spendingTracker.date !== today) {
-          this._spendingTracker = {
-            date: today,
-            totalBorrowed: 0n,
-            dailyLimit: this._spendingTracker.dailyLimit
-          };
-        }
-      }
-      /** Track a new spending amount */
-      _trackSpending(amount) {
-        this._resetTrackerIfNewDay();
-        this._spendingTracker.totalBorrowed += amount;
-      }
-      /**
-       * Check if a borrow amount is within spending limits.
-       * Considers both fixed daily limits and yield-limited spending.
-       */
-      async _checkSpendingLimit(amount, morphoClient) {
-        this._resetTrackerIfNewDay();
-        if (this.config.yieldLimitedSpending) {
-          try {
-            const status = await morphoClient.getStatus();
-            let totalDailyYieldUsdc = 0;
-            for (const pos of status.positions) {
-              if (parseFloat(pos.collateral) > 0) {
-                try {
-                  const estimate = await morphoClient.getYieldEstimate(
-                    pos.collateralToken,
-                    pos.collateral,
-                    1
-                    // 1 day
-                  );
-                  totalDailyYieldUsdc += estimate.estimatedYieldUsd;
-                } catch (e) {
-                  console.warn(`[agether] yield calc failed for ${pos.collateralToken}:`, e instanceof Error ? e.message : e);
-                }
-              }
-            }
-            const yieldLimit = BigInt(Math.round(totalDailyYieldUsdc * 1e6));
-            const newTotal = this._spendingTracker.totalBorrowed + amount;
-            if (yieldLimit > 0n && newTotal > yieldLimit) {
-              return {
-                allowed: false,
-                reason: `Yield-limited spending exceeded. Daily yield cap: $${(Number(yieldLimit) / 1e6).toFixed(2)}, already spent: $${(Number(this._spendingTracker.totalBorrowed) / 1e6).toFixed(2)}, requested: $${(Number(amount) / 1e6).toFixed(2)}`
-              };
-            }
-          } catch (e) {
-            console.warn("[agether] yield-limited spending check failed, falling through to fixed limit:", e instanceof Error ? e.message : e);
-          }
-        }
-        if (this._spendingTracker.dailyLimit > 0n) {
-          const newTotal = this._spendingTracker.totalBorrowed + amount;
-          if (newTotal > this._spendingTracker.dailyLimit) {
-            return {
-              allowed: false,
-              reason: `Daily spending limit exceeded. Limit: $${(Number(this._spendingTracker.dailyLimit) / 1e6).toFixed(2)}, already spent: $${(Number(this._spendingTracker.totalBorrowed) / 1e6).toFixed(2)}, requested: $${(Number(amount) / 1e6).toFixed(2)}`
-            };
-          }
-        }
-        return { allowed: true };
-      }
-    };
-  }
-});
-
-// src/cli.ts
-var import_ethers2 = require("ethers");
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os = __toESM(require("os"));
-var CONFIG_PATH = path.join(os.homedir(), ".agether", "config.json");
-var DEFAULT_RPC = "https://base-rpc.publicnode.com";
-var DEFAULT_BACKEND = "http://95.179.189.214:3001";
-function loadConfig() {
-  try {
-    if (fs.existsSync(CONFIG_PATH)) {
-      return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
-    }
-  } catch {
-  }
-  return null;
-}
-function saveConfig(config) {
-  const dir = path.dirname(CONFIG_PATH);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-}
-function requireConfig() {
-  const config = loadConfig();
-  if (!config) {
-    console.error("\u274C Not initialized. Run: agether init <private-key>");
-    process.exit(1);
-  }
-  return config;
-}
-async function waitForTx(tx, retries = 5) {
-  for (let attempt = 1; attempt <= retries; attempt++) {
-    try {
-      const receipt = await tx.wait();
-      if (receipt) return receipt;
-    } catch (e) {
-      if (attempt === retries) throw e;
-      console.log(`        \u23F3 Receipt fetch failed (attempt ${attempt}/${retries}), retrying...`);
-      await new Promise((r) => setTimeout(r, 2e3 * attempt));
-    }
-  }
-  throw new Error("Failed to get transaction receipt after retries");
-}
-async function getMorphoClient(config) {
-  const { MorphoClient: MorphoClient2 } = await Promise.resolve().then(() => (init_MorphoClient(), MorphoClient_exports));
-  return new MorphoClient2({
-    privateKey: config.privateKey,
-    rpcUrl: config.rpcUrl,
-    agentId: config.agentId !== "0" ? config.agentId : void 0
-  });
-}
-async function getX402Client(config) {
-  const { X402Client: X402Client2 } = await Promise.resolve().then(() => (init_X402Client(), X402Client_exports));
-  let accountAddress;
-  try {
-    const mc = await getMorphoClient(config);
-    accountAddress = await mc.getAccountAddress();
-  } catch {
-  }
-  return new X402Client2({
-    privateKey: config.privateKey,
-    rpcUrl: config.rpcUrl,
-    backendUrl: config.backendUrl,
-    agentId: config.agentId,
-    accountAddress
-  });
-}
-var ERC8004_ABI = [
-  "function register(string agentURI) external returns (uint256 agentId)",
-  "function register() external returns (uint256 agentId)",
-  "function ownerOf(uint256 tokenId) view returns (address)",
-  "function balanceOf(address owner) view returns (uint256)",
-  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
-];
-var ACCOUNT_FACTORY_ABI2 = [
-  "function getAccount(uint256 agentId) view returns (address)",
-  "function accountExists(uint256 agentId) view returns (bool)",
-  "function createAccount(uint256 agentId) returns (address account)",
-  "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
-];
-var VALIDATION_REGISTRY_ABI = [
-  "function isAgentCodeApproved(uint256 agentId) view returns (bool)"
-];
-var MOCK_ERC20_ABI = [
-  "function mint(address to, uint256 amount) external"
-];
-async function apiGet(backendUrl, endpoint) {
-  const res = await fetch(`${backendUrl}${endpoint}`);
-  return res.json();
-}
-function decodeError(error) {
-  const msg = error?.message || String(error);
-  if (msg.includes("CodeNotApproved")) return "Agent code not approved. Complete KYA first.";
-  if (msg.includes("0xda04aecc") || msg.includes("ExceedsMaxLtv"))
-    return "ExceedsMaxLtv \u2014 collateral too low for this borrow amount.";
-  if (msg.includes("0xfeca99cb") || msg.includes("ExecutionFailed"))
-    return "ExecutionFailed \u2014 the inner contract call reverted.";
-  if (msg.includes("0xa920ef9f"))
-    return "PositionNotActive \u2014 no collateral deposited for this token.";
-  if (msg.length > 200) return msg.slice(0, 200) + "...";
-  return msg;
-}
-async function cmdInit(privateKey, agentId) {
-  const rpcUrl = process.env.AGETHER_RPC_URL || DEFAULT_RPC;
-  const backendUrl = process.env.AGETHER_BACKEND_URL || DEFAULT_BACKEND;
-  let wallet;
-  try {
-    wallet = new import_ethers2.ethers.Wallet(privateKey);
-  } catch {
-    console.error("\u274C Invalid private key");
-    process.exit(1);
-  }
-  const config = { privateKey, agentId: agentId || "0", rpcUrl, backendUrl };
-  saveConfig(config);
-  console.log("\u2705 Initialized Agether CLI");
-  console.log(`   Address: ${wallet.address}`);
-  console.log(`   RPC:     ${rpcUrl}`);
-  console.log(`   Backend: ${backendUrl}`);
-  console.log(`   Config:  ${CONFIG_PATH}`);
-}
-async function cmdRegister(name) {
-  const config = requireConfig();
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const agentName = name || `Agent-${signer.address.slice(0, 8)}`;
-  console.log(`\u{1F916} Registering agent: ${agentName}
-`);
-  console.log(`   Wallet: ${signer.address}`);
-  console.log("\n  [1/4] Fetching contract addresses...");
-  let contracts;
-  try {
-    const statusResp = await apiGet(config.backendUrl, "/status");
-    contracts = statusResp.contracts || {};
-    console.log("        \u2713 Backend OK");
-  } catch (e) {
-    console.error(`        \u274C Failed to reach backend: ${e.message}`);
-    process.exit(1);
-  }
-  const registryAddr = contracts.agentRegistry || contracts.identityRegistry;
-  const factoryAddr = contracts.accountFactory;
-  const validationAddr = contracts.validationRegistry;
-  if (!registryAddr || !factoryAddr) {
-    console.error("        \u274C Backend missing agentRegistry or accountFactory");
-    process.exit(1);
-  }
-  console.log("  [2/4] Registering on ERC-8004 IdentityRegistry...");
-  const agentRegistry = new import_ethers2.ethers.Contract(registryAddr, ERC8004_ABI, signer);
-  let agentId;
-  if (config.agentId && config.agentId !== "0") {
-    agentId = BigInt(config.agentId);
-    try {
-      const owner = await agentRegistry.ownerOf(agentId);
-      if (owner.toLowerCase() === signer.address.toLowerCase()) {
-        console.log(`        \u2713 Already registered as Agent #${agentId}`);
-      } else {
-        console.error("        \u274C agentId does not belong to this wallet");
-        process.exit(1);
-      }
-    } catch {
-      console.error(`        \u274C agentId ${agentId} does not exist on-chain`);
-      process.exit(1);
-    }
-  } else {
-    const existingBalance = await agentRegistry.balanceOf(signer.address);
-    if (existingBalance > 0n) {
-      console.log(`        \u26A0 Wallet already owns ${existingBalance} token(s), minting another`);
-    }
-    try {
-      const registrationFile = JSON.stringify({
-        type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
-        name: agentName,
-        description: "AI agent registered via Agether CLI",
-        active: true
-      });
-      const agentURI = `data:application/json;base64,${Buffer.from(registrationFile).toString("base64")}`;
-      const tx = await agentRegistry["register(string)"](agentURI);
-      const receipt = await waitForTx(tx);
-      const transferTopic = import_ethers2.ethers.id("Transfer(address,address,uint256)");
-      const transferLog = receipt.logs.find((log) => log.topics[0] === transferTopic);
-      if (transferLog && transferLog.topics.length >= 4) {
-        agentId = BigInt(transferLog.topics[3]);
-      } else {
-        console.error("        \u274C Could not parse agentId from receipt");
-        process.exit(1);
-      }
-      console.log(`        \u2713 Agent #${agentId} registered`);
-      console.log(`        TX: ${tx.hash}`);
-      config.agentId = agentId.toString();
-      saveConfig(config);
-    } catch (e) {
-      if (config.agentId && config.agentId !== "0") {
-        agentId = BigInt(config.agentId);
-        console.log(`        Using existing Agent #${agentId}`);
-      } else {
-        const balance = await agentRegistry.balanceOf(signer.address);
-        if (balance > 0n) {
-          console.error(`        Wallet owns ${balance} token(s) but agentId unknown.`);
-          console.error("        Set manually: agether init <pk> --agent-id <id>");
-        } else {
-          console.error(`        \u274C Registration failed: ${e.message}`);
-        }
-        process.exit(1);
-      }
-    }
-  }
-  const network = await provider.getNetwork();
-  const chainId = Number(network.chainId);
-  if (chainId === 31337 || chainId === 1) {
-    console.log("  [3/4] Minting test USDC (Hardhat fork)...");
-    const deployerPk = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
-    const deployer = new import_ethers2.ethers.Wallet(deployerPk, provider);
-    const usdcAddr = contracts.usdc;
-    if (usdcAddr) {
-      try {
-        const usdc = new import_ethers2.ethers.Contract(usdcAddr, MOCK_ERC20_ABI, deployer);
-        const tx = await usdc.mint(signer.address, BigInt(5e10));
-        await waitForTx(tx);
-        console.log("        \u2713 Minted $50,000 USDC");
-      } catch {
-        console.log("        \u26A0 Mint failed (probably real network)");
-      }
-    }
-  } else {
-    console.log("  [3/4] Skipping USDC mint (real network)");
-  }
-  console.log("  [4/4] Creating AgentAccount...");
-  if (factoryAddr) {
-    const factory = new import_ethers2.ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI2, signer);
-    try {
-      const exists = await factory.accountExists(agentId);
-      if (exists) {
-        const addr = await factory.getAccount(agentId);
-        console.log(`        Already exists: ${addr}`);
-      } else {
-        const tx = await factory.createAccount(agentId);
-        await waitForTx(tx);
-        const addr = await factory.getAccount(agentId);
-        console.log(`        \u2713 Created: ${addr}`);
-        console.log(`        TX: ${tx.hash}`);
-      }
-    } catch (e) {
-      console.error(`        \u274C Failed: ${e.message}`);
-    }
-  }
-  if (validationAddr) {
-    const vr = new import_ethers2.ethers.Contract(validationAddr, VALIDATION_REGISTRY_ABI, provider);
-    try {
-      const approved = await vr.isAgentCodeApproved(agentId);
-      console.log(`
-  KYA Status: ${approved ? "\u2705 Approved" : "\u23F3 Pending"}`);
-    } catch {
-      console.log("\n  KYA Status: \u26A0 Could not check");
-    }
-  }
-  console.log(`
-\u2705 Agent #${agentId} ready!`);
-  console.log(`   Config: ${CONFIG_PATH}`);
-  console.log("\n   Next steps:");
-  console.log("     agether balance");
-  console.log("     agether deposit --amount 0.05 --token WETH");
-  console.log("     agether borrow --amount 100");
-}
-async function cmdBalance() {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  const balances = await mc.getBalances();
-  console.log(`
-\u{1F4B0} Agent #${balances.agentId} Balances
-`);
-  console.log(`  EOA:     ${balances.address}`);
-  console.log(`  ETH:     ${parseFloat(balances.eth).toFixed(6)}`);
-  console.log(`  USDC:    $${parseFloat(balances.usdc).toFixed(2)}`);
-  if (balances.agentAccount) {
-    console.log(`
-  AgentAccount: ${balances.agentAccount.address}`);
-    console.log(`  ETH:          ${parseFloat(balances.agentAccount.eth).toFixed(6)}`);
-    console.log(`  USDC:         $${parseFloat(balances.agentAccount.usdc).toFixed(2)}`);
-  }
-}
-async function cmdStatus() {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log("\n\u{1F4CA} Morpho Positions\n");
-  const status = await mc.getStatus();
-  console.log(`  Agent #${status.agentId}`);
-  console.log(`  Account:    ${status.agentAccount}`);
-  console.log(`  Total Debt: $${parseFloat(status.totalDebt).toFixed(2)}`);
-  if (status.positions.length === 0) {
-    console.log("\n  No active positions. Deposit collateral first:");
-    console.log("    agether deposit --amount 0.05 --token WETH");
-    return;
-  }
-  console.log("\n  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("  \u2502 Token     \u2502 Collateral       \u2502 Debt (USDC)      \u2502");
-  console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  for (const p of status.positions) {
-    const tok = p.collateralToken.padEnd(9);
-    const col = parseFloat(p.collateral).toFixed(6).padStart(16);
-    const debt = ("$" + parseFloat(p.debt).toFixed(2)).padStart(16);
-    console.log(`  \u2502 ${tok} \u2502 ${col} \u2502 ${debt} \u2502`);
-  }
-  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  try {
-    const score = await mc.getCreditScore();
-    const { fresh, age } = await mc.isScoreFresh();
-    const ageHrs = Number(age) / 3600;
-    console.log(`
-  Credit Score: ${score} ${fresh ? "\u2705" : `\u26A0\uFE0F stale (${ageHrs.toFixed(1)}h old)`}`);
-  } catch {
-    console.log("\n  Credit Score: not yet computed");
-  }
-}
-async function cmdScore() {
-  const config = requireConfig();
-  console.log(`
-\u{1F4C8} Agent #${config.agentId} Score
-`);
-  try {
-    const data = await apiGet(config.backendUrl, `/score/${config.agentId}/current`);
-    if (data.score !== void 0) {
-      console.log(`  On-chain Score: ${data.score}`);
-      console.log(`  Timestamp:      ${data.timestamp ? new Date(Number(data.timestamp) * 1e3).toISOString() : "N/A"}`);
-      console.log(`  Signer:         ${data.signer || "N/A"}`);
-      console.log(`  Fresh:          ${data.fresh ? "\u2705" : "\u26A0\uFE0F stale"}`);
-    } else {
-      console.log("  No score on-chain yet.");
-    }
-  } catch {
-    console.log("  Could not fetch current score.");
-  }
-  console.log("\n  To compute a fresh score (x402-gated, costs USDC):");
-  console.log(`    agether x402 ${config.backendUrl}/score/${config.agentId}`);
-}
-async function cmdMarkets() {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log("\n\u{1F4C8} Morpho Blue Markets (Base USDC)\n");
-  const markets = await mc.getMarkets();
-  if (markets.length === 0) {
-    console.log("  No markets found. API may be unavailable.");
-    return;
-  }
-  console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log("  \u2502 Collateral    \u2502 LLTV     \u2502 Util %     \u2502 Supply (USDC)    \u2502");
-  console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  for (const m of markets.slice(0, 15)) {
-    const col = (m.collateralAsset?.symbol || "N/A").padEnd(13);
-    const lltv = (Number(m.lltv) / 1e18 * 100).toFixed(0).padStart(6) + "%";
-    const util = (m.utilization * 100).toFixed(1).padStart(8) + "%";
-    const supply = ("$" + (Number(m.totalSupplyAssets) / 1e6).toLocaleString()).padStart(16);
-    console.log(`  \u2502 ${col} \u2502 ${lltv} \u2502 ${util} \u2502 ${supply} \u2502`);
-  }
-  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-}
-async function cmdDeposit(amount, token) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log(`
-\u{1F4B0} Depositing ${amount} ${token} as collateral...
-`);
-  try {
-    const result = await mc.supplyCollateral(token, amount);
-    console.log(`\u2705 Deposited ${amount} ${token}`);
-    console.log(`   AgentAccount: ${result.agentAccount}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdBorrow(amount, token) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log(`
-\u{1F4B8} Borrowing $${amount} USDC...
-`);
-  try {
-    const result = await mc.borrow(amount, token);
-    console.log(`\u2705 Borrowed $${amount} USDC`);
-    console.log(`   Collateral: ${result.collateralToken}`);
-    console.log(`   AgentAccount: ${result.agentAccount}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdDepositAndBorrow(collateralAmount, token, borrowAmount) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log(`
-\uFFFD\uFFFD Depositing ${collateralAmount} ${token} + Borrowing $${borrowAmount}...
-`);
-  try {
-    const result = await mc.depositAndBorrow(token, collateralAmount, borrowAmount);
-    console.log(`\u2705 Deposited ${collateralAmount} ${token} & Borrowed $${borrowAmount} USDC`);
-    console.log(`   AgentAccount: ${result.agentAccount}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdRepay(amount, token) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log(`
-\u{1F4B3} Repaying $${amount} USDC...
-`);
-  try {
-    const result = await mc.repay(amount, token);
-    console.log(`\u2705 Repaid $${amount}`);
-    console.log(`   Remaining debt: $${parseFloat(result.remainingDebt).toFixed(2)}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdWithdraw(amount, token) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log(`
-\u{1F4E4} Withdrawing ${amount} ${token}...
-`);
-  try {
-    const result = await mc.withdrawCollateral(token, amount);
-    console.log(`\u2705 Withdrew ${result.amount} ${token}`);
-    console.log(`   Remaining collateral: ${result.remainingCollateral}`);
-    console.log(`   Destination: ${result.destination}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdSponsor(amount, token, agentId, address) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  const target = agentId ? { agentId } : { address };
-  console.log(`
-\u{1F381} Sponsoring ${amount} ${token} to ${agentId || address}...
-`);
-  try {
-    const result = await mc.sponsor(target, token, amount);
-    console.log(`\u2705 Sponsored ${amount} ${token}`);
-    console.log(`   Target: ${result.targetAccount}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdFund(amount) {
-  const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  console.log(`
-\u{1F4B5} Funding AgentAccount with $${amount} USDC...
-`);
-  try {
-    const result = await mc.fundAccount(amount);
-    console.log(`\u2705 Funded $${amount} USDC`);
-    console.log(`   AgentAccount: ${result.agentAccount}`);
-    console.log(`   TX: ${result.tx}`);
-  } catch (e) {
-    console.error(`\u274C ${decodeError(e)}`);
-  }
-}
-async function cmdX402Call(url, method = "GET", body) {
-  const config = requireConfig();
-  console.log("\n\u{1F510} x402 Paid API Call\n");
-  const x402 = await getX402Client(config);
-  console.log(`   Wallet: ${new import_ethers2.ethers.Wallet(config.privateKey).address}`);
-  console.log(`
-\u{1F4E1} ${method} ${url}`);
-  if (body) console.log(`\u{1F4E6} Body: ${body}`);
-  try {
-    let result;
-    if (method === "POST" && body) {
-      result = await x402.post(url, JSON.parse(body));
-    } else {
-      result = await x402.get(url);
-    }
-    if (result.success) {
-      console.log("\n\u2705 Success!");
-      if (result.paymentInfo) {
-        console.log(`\u{1F4B0} Paid: ${result.paymentInfo.amount} ${result.paymentInfo.asset} on ${result.paymentInfo.network}`);
-        if (result.paymentInfo.txHash) console.log(`\u{1F4DC} TX: ${result.paymentInfo.txHash}`);
-      }
-      console.log("\n\u{1F4C4} Response:");
-      console.log(JSON.stringify(result.data, null, 2));
-    } else {
-      console.error(`
-\u274C Failed: ${result.error}`);
-    }
-  } catch (e) {
-    console.error(`\u274C Error: ${e.message}`);
-  }
-}
-function cmdHelp() {
-  console.log(`
-\u{1F3E6} Agether CLI \u2014 Direct Morpho Blue Credit for AI Agents
-
-USAGE:
-  agether <command> [options]
-
-SETUP:
-  init <private-key> [--agent-id <id>]    Initialize with private key
-  register [--name <n>]                   Register ERC-8004 + create AgentAccount
-
-INFO:
-  balance                                 Check ETH + USDC balances
-  status                                  Show Morpho positions & credit score
-  score                                   Get credit score
-  markets                                 List Morpho Blue USDC markets
-
-MORPHO LENDING:
-  deposit --amount <n> --token <t>        Deposit collateral (WETH, wstETH, cbETH)
-  borrow --amount <usd> [--token <t>]     Borrow USDC against collateral
-  deposit-and-borrow --amount <n> --token <t> --borrow <usd>
-                                          Deposit + borrow in one batched tx
-  repay --amount <usd> [--token <t>]      Repay borrowed USDC
-  withdraw --amount <n> --token <t>       Withdraw collateral (use 'all' for max)
-  sponsor --amount <n> --token <t> --agent-id <id>   Send collateral to another agent
-  fund --amount <usd>                     Transfer USDC from EOA to AgentAccount
-
-x402 PAYMENTS:
-  x402 <url> [--method GET|POST] [--body <json>]   Make a paid API call
-
-ENVIRONMENT:
-  AGETHER_RPC_URL       RPC endpoint (default: ${DEFAULT_RPC})
-  AGETHER_BACKEND_URL   Backend URL (default: ${DEFAULT_BACKEND})
-
-EXAMPLE FLOW:
-  agether init 0xYOUR_PRIVATE_KEY
-  agether register --name "MyAgent"
-  agether deposit --amount 0.05 --token WETH       # ~$125 collateral
-  agether borrow --amount 50                        # Borrow $50 USDC
-  agether status                                    # Check positions
-  agether repay --amount 50                         # Repay when done
-  agether withdraw --amount all --token WETH        # Withdraw collateral
-`);
-}
-function parseArgs(args) {
-  const command = args[0] || "help";
-  const positional = [];
-  const options = {};
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      const next = args[i + 1];
-      if (next && !next.startsWith("--")) {
-        options[key] = next;
-        i++;
-      } else {
-        options[key] = true;
-      }
-    } else {
-      positional.push(arg);
-    }
-  }
-  return { command, positional, options };
-}
-async function main() {
-  const { command, positional, options } = parseArgs(process.argv.slice(2));
-  try {
-    switch (command) {
-      case "init":
-        if (!positional[0]) {
-          console.error("\u274C Private key required: agether init <private-key>");
-          process.exit(1);
-        }
-        await cmdInit(positional[0], options["agent-id"]);
-        break;
-      case "register":
-        await cmdRegister(options.name);
-        break;
-      case "balance":
-        await cmdBalance();
-        break;
-      case "status":
-        await cmdStatus();
-        break;
-      case "score":
-        await cmdScore();
-        break;
-      case "markets":
-        await cmdMarkets();
-        break;
-      case "deposit":
-        if (!options.amount || !options.token) {
-          console.error("\u274C --amount and --token required");
-          console.error("   agether deposit --amount 0.05 --token WETH");
-          process.exit(1);
-        }
-        await cmdDeposit(options.amount, options.token);
-        break;
-      case "borrow":
-        if (!options.amount) {
-          console.error("\u274C --amount required (in USD)");
-          console.error("   agether borrow --amount 100");
-          process.exit(1);
-        }
-        await cmdBorrow(options.amount, options.token);
-        break;
-      case "deposit-and-borrow":
-        if (!options.amount || !options.token || !options.borrow) {
-          console.error("\u274C --amount, --token, and --borrow required");
-          console.error("   agether deposit-and-borrow --amount 0.05 --token WETH --borrow 100");
-          process.exit(1);
-        }
-        await cmdDepositAndBorrow(
-          options.amount,
-          options.token,
-          options.borrow
-        );
-        break;
-      case "repay":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
-          process.exit(1);
-        }
-        await cmdRepay(options.amount, options.token);
-        break;
-      case "withdraw":
-        if (!options.amount || !options.token) {
-          console.error("\u274C --amount and --token required");
-          console.error("   agether withdraw --amount 0.05 --token WETH");
-          console.error("   agether withdraw --amount all --token WETH");
-          process.exit(1);
-        }
-        await cmdWithdraw(options.amount, options.token);
-        break;
-      case "sponsor":
-        if (!options.amount || !options.token) {
-          console.error("\u274C --amount and --token required, plus --agent-id or --address");
-          process.exit(1);
-        }
-        if (!options["agent-id"] && !options.address) {
-          console.error("\u274C --agent-id or --address required");
-          process.exit(1);
-        }
-        await cmdSponsor(
-          options.amount,
-          options.token,
-          options["agent-id"],
-          options.address
-        );
-        break;
-      case "fund":
-        if (!options.amount) {
-          console.error("\u274C --amount required (USDC)");
-          process.exit(1);
-        }
-        await cmdFund(options.amount);
-        break;
-      case "x402":
-        if (!positional[0]) {
-          console.error("\u274C URL required: agether x402 <url>");
-          process.exit(1);
-        }
-        await cmdX402Call(
-          positional[0],
-          options.method || "GET",
-          options.body
-        );
-        break;
-      case "help":
-      case "--help":
-      case "-h":
-        cmdHelp();
-        break;
-      default:
-        console.error(`\u274C Unknown command: ${command}`);
-        cmdHelp();
-        process.exit(1);
-    }
-  } catch (e) {
-    console.error(`\u274C Error: ${e.message}`);
-    process.exit(1);
-  }
-}
-main();