@agether/sdk 2.8.0 → 2.9.0

package/dist/cli.js

@@ -47,7 +47,7 @@ var init_types = __esm({
 });
 
 // src/utils/abis.ts
-var IDENTITY_REGISTRY_ABI, AGETHER_4337_FACTORY_ABI, ACCOUNT_FACTORY_ABI, AGETHER_8004_VALIDATION_MODULE_ABI, ERC8004_VALIDATION_MODULE_ABI, AGETHER_8004_SCORER_ABI, AGENT_REPUTATION_ABI, MORPHO_BLUE_ABI, ERC20_ABI, ENTRYPOINT_V07_ABI, SAFE7579_ACCOUNT_ABI;
+var IDENTITY_REGISTRY_ABI, AGETHER_4337_FACTORY_ABI, ACCOUNT_FACTORY_ABI, AGETHER_8004_VALIDATION_MODULE_ABI, AGETHER_8004_SCORER_ABI, MORPHO_BLUE_ABI, ERC20_ABI, ENTRYPOINT_V07_ABI, SAFE7579_ACCOUNT_ABI;
 var init_abis = __esm({
   "src/utils/abis.ts"() {
     "use strict";
@@ -87,7 +87,6 @@ var init_abis = __esm({
       // Admin (via TimelockController)
       "function setValidationRegistry(address registry_)"
     ];
-    ERC8004_VALIDATION_MODULE_ABI = AGETHER_8004_VALIDATION_MODULE_ABI;
     AGETHER_8004_SCORER_ABI = [
       "function getCreditScore(uint256 agentId) view returns (uint256)",
       "function getAttestation(uint256 agentId) view returns (tuple(uint256 score, uint256 timestamp, address signer))",
@@ -98,7 +97,6 @@ var init_abis = __esm({
       "function setOracleSigner(address signer_)",
       "event ScoreUpdated(uint256 indexed agentId, uint256 score, uint256 timestamp, address signer)"
     ];
-    AGENT_REPUTATION_ABI = AGETHER_8004_SCORER_ABI;
     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)",
@@ -294,6 +292,12 @@ var init_MorphoClient = __esm({
         /** Dynamic token registry: symbol (uppercase) → { address, symbol, decimals } */
         this._tokenCache = /* @__PURE__ */ new Map();
         this._discoveredAt = 0;
+        if (!config.agentId) {
+          throw new AgetherError(
+            "agentId is required. Use AgetherClient.register() first to get an agentId.",
+            "NO_AGENT_ID"
+          );
+        }
         const chainId = config.chainId ?? 1 /* Ethereum */;
         const defaultCfg = getDefaultConfig(chainId);
         this.config = defaultCfg;
@@ -323,26 +327,7 @@ var init_MorphoClient = __esm({
         const addrs = { ...defaultCfg.contracts, ...config.contracts };
         this.agether4337Factory = new import_ethers.Contract(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
         this.morphoBlue = new import_ethers.Contract(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
-        this.agether8004Scorer = new import_ethers.Contract(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-        this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
         this.entryPoint = new import_ethers.Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-        this.validationModule = new import_ethers.Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-      }
-      // ════════════════════════════════════════════════════════
-      //  KYA Gate Check
-      // ════════════════════════════════════════════════════════
-      /**
-       * Check whether the KYA (Know Your Agent) code verification gate is active.
-       * Reads the ERC8004ValidationModule's validationRegistry — when set to
-       * a non-zero address, the module enforces KYA code approval.
-       */
-      async isKyaRequired() {
-        try {
-          const registryAddr = await this.validationModule.validationRegistry();
-          return registryAddr !== import_ethers.ethers.ZeroAddress;
-        } catch {
-          return false;
-        }
       }
       // ════════════════════════════════════════════════════════
       //  Account Management
@@ -350,7 +335,6 @@ var init_MorphoClient = __esm({
       /** 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++) {
@@ -372,7 +356,6 @@ var init_MorphoClient = __esm({
         throw lastErr;
       }
       getAgentId() {
-        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
         return this.agentId;
       }
       /**
@@ -405,182 +388,6 @@ var init_MorphoClient = __esm({
         }
         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.agether4337Factory.accountExists(BigInt(this.agentId));
-          if (exists) {
-            const acct = await this.agether4337Factory.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.agether4337Factory.accountExists(agentId);
-        let txHash;
-        if (!acctExists) {
-          const tx = await this.agether4337Factory.createAccount(agentId);
-          const receipt = await tx.wait();
-          this._refreshSigner();
-          txHash = receipt.hash;
-        }
-        const acctAddr = await this.agether4337Factory.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 discoveredTokens = await this._getDiscoveredTokens();
-        const eoaCollateral = {};
-        for (const info of discoveredTokens) {
-          try {
-            const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
-            const bal = await token.balanceOf(eoaAddr);
-            eoaCollateral[info.symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
-          } catch (e) {
-            console.warn(`[agether] EOA collateral fetch failed for ${info.symbol}:`, e instanceof Error ? e.message : e);
-            eoaCollateral[info.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 info of discoveredTokens) {
-            try {
-              const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
-              const bal = await token.balanceOf(acctAddr);
-              acctCollateral[info.symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
-            } catch (e) {
-              console.warn(`[agether] AgentAccount collateral fetch failed for ${info.symbol}:`, e instanceof Error ? e.message : e);
-              acctCollateral[info.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 };
-      }
-      /**
-       * Withdraw (transfer) a token from AgentAccount to EOA.
-       * Executes an ERC-20 transfer via Safe UserOp.
-       *
-       * @param tokenSymbol - Token to withdraw (e.g. 'USDC', 'WETH', 'wstETH')
-       * @param amount - Amount to withdraw (human-readable, e.g. '100' for 100 USDC, or 'all')
-       */
-      async withdrawToken(tokenSymbol, amount) {
-        const acctAddr = await this.getAccountAddress();
-        const eoaAddr = await this.getSignerAddress();
-        const tokenInfo = await this._resolveToken(tokenSymbol);
-        const tokenContract = new import_ethers.Contract(tokenInfo.address, ERC20_ABI, this.provider);
-        let weiAmount;
-        if (amount === "all") {
-          weiAmount = await tokenContract.balanceOf(acctAddr);
-          if (weiAmount === 0n) throw new AgetherError(`No ${tokenSymbol} in AgentAccount`, "INSUFFICIENT_BALANCE");
-        } else {
-          weiAmount = import_ethers.ethers.parseUnits(amount, tokenInfo.decimals);
-        }
-        const data = erc20Iface.encodeFunctionData("transfer", [eoaAddr, weiAmount]);
-        const receipt = await this.exec(tokenInfo.address, data);
-        const actualAmount = amount === "all" ? import_ethers.ethers.formatUnits(weiAmount, tokenInfo.decimals) : amount;
-        return { tx: receipt.hash, token: tokenSymbol, amount: actualAmount, destination: eoaAddr };
-      }
-      /**
-       * Withdraw ETH from AgentAccount to EOA.
-       * Executes a native ETH transfer via Safe UserOp.
-       *
-       * @param amount - ETH amount (e.g. '0.01' or 'all')
-       */
-      async withdrawEth(amount) {
-        const acctAddr = await this.getAccountAddress();
-        const eoaAddr = await this.getSignerAddress();
-        let weiAmount;
-        if (amount === "all") {
-          weiAmount = await this.provider.getBalance(acctAddr);
-          if (weiAmount === 0n) throw new AgetherError("No ETH in AgentAccount", "INSUFFICIENT_BALANCE");
-        } else {
-          weiAmount = import_ethers.ethers.parseEther(amount);
-        }
-        const receipt = await this.exec(eoaAddr, "0x", weiAmount);
-        const actualAmount = amount === "all" ? import_ethers.ethers.formatEther(weiAmount) : amount;
-        return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: eoaAddr };
-      }
       // ════════════════════════════════════════════════════════
       //  Market Discovery (Morpho GraphQL API)
       // ════════════════════════════════════════════════════════
@@ -759,7 +566,7 @@ var init_MorphoClient = __esm({
           }
         }
         return {
-          agentId: this.agentId || "?",
+          agentId: this.agentId,
           agentAccount: acctAddr,
           totalDebt: import_ethers.ethers.formatUnits(totalDebt, 6),
           positions
@@ -1596,50 +1403,6 @@ var init_MorphoClient = __esm({
           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 = await this._resolveToken(tokenSymbol);
-        let targetAddr;
-        if (target.address) {
-          targetAddr = target.address;
-        } else if (target.agentId) {
-          targetAddr = await this.agether4337Factory.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 (Agether8004Scorer contract)
-      // ════════════════════════════════════════════════════════
-      async getCreditScore() {
-        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
-        return this.agether8004Scorer.getCreditScore(BigInt(this.agentId));
-      }
-      async getAttestation() {
-        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
-        const att = await this.agether8004Scorer.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.agether8004Scorer.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.agether8004Scorer.isScoreFresh(BigInt(this.agentId));
-        return { fresh, age };
-      }
       // ════════════════════════════════════════════════════════
       //  Internal Helpers
       // ════════════════════════════════════════════════════════
@@ -1661,9 +1424,6 @@ var init_MorphoClient = __esm({
           const addrs = this.config.contracts;
           this.agether4337Factory = new import_ethers.Contract(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
           this.entryPoint = new import_ethers.Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-          this.validationModule = new import_ethers.Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-          this.agether8004Scorer = new import_ethers.Contract(addrs.agether8004Scorer, 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);
@@ -1672,9 +1432,6 @@ var init_MorphoClient = __esm({
           const addrs = this.config.contracts;
           this.agether4337Factory = new import_ethers.Contract(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
           this.entryPoint = new import_ethers.Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-          this.validationModule = new import_ethers.Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-          this.agether8004Scorer = new import_ethers.Contract(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-          this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
         }
       }
       // ────────────────────────────────────────────────────────────
@@ -1877,23 +1634,6 @@ var init_MorphoClient = __esm({
           "UNKNOWN_COLLATERAL"
         );
       }
-      /**
-       * Get all discovered collateral tokens (for balance iteration, etc.).
-       * Returns unique tokens from the Morpho API market discovery.
-       */
-      async _getDiscoveredTokens() {
-        await this.getMarkets();
-        const seen = /* @__PURE__ */ new Set();
-        const tokens = [];
-        for (const [key, info] of this._tokenCache) {
-          if (key.startsWith("0x")) continue;
-          if (seen.has(info.address.toLowerCase())) continue;
-          seen.add(info.address.toLowerCase());
-          if (info.symbol === "USDC" || info.symbol === "USDbC") continue;
-          tokens.push(info);
-        }
-        return tokens;
-      }
       /**
        * Compute net deposited amounts per market using Morpho GraphQL API.
        *
@@ -1959,89 +1699,707 @@ var init_MorphoClient = __esm({
   }
 });
 
-// src/clients/X402Client.ts
-var X402Client_exports = {};
-__export(X402Client_exports, {
-  X402Client: () => X402Client
+// src/clients/AgetherClient.ts
+var AgetherClient_exports = {};
+__export(AgetherClient_exports, {
+  AgetherClient: () => AgetherClient
 });
-var import_fetch, import_client, import_client2, import_accounts, X402Client;
-var init_X402Client = __esm({
-  "src/clients/X402Client.ts"() {
+var import_ethers2, MODE_SINGLE2, erc20Iface2, KNOWN_TOKENS, AgetherClient;
+var init_AgetherClient = __esm({
+  "src/clients/AgetherClient.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;
+    import_ethers2 = require("ethers");
+    init_types();
+    init_abis();
+    init_config();
+    MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+    erc20Iface2 = new import_ethers2.ethers.Interface(ERC20_ABI);
+    KNOWN_TOKENS = {
+      [8453 /* Base */]: {
+        WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
+        wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
+        cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
+      },
+      [1 /* Ethereum */]: {
+        WETH: { address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", symbol: "WETH", decimals: 18 },
+        wstETH: { address: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0", symbol: "wstETH", decimals: 18 },
+        cbETH: { address: "0xBe9895146f7AF43049ca1c1AE358B0541Ea49704", symbol: "cbETH", decimals: 18 }
+      }
+    };
+    AgetherClient = class _AgetherClient {
+      constructor(options) {
+        this.config = options.config;
+        this.signer = options.signer;
+        this.agentId = options.agentId;
+        this._rpcUrl = options.config.rpcUrl;
+        if (options._privateKey) {
+          this._privateKey = options._privateKey;
+          this._useExternalSigner = false;
         } else {
-          throw new Error(
-            "X402Client: provide either privateKey or walletClient in config."
-          );
+          this._useExternalSigner = true;
         }
-        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);
-              if (config.validatorModule) {
-                const validatorHex = config.validatorModule.replace("0x", "").toLowerCase();
-                const sigHex = sig.replace("0x", "");
-                return `0x${validatorHex}${sigHex}`;
-              }
-              return `${sig}00`;
-            }
-          });
-          this.address = accountAddr;
+        const provider = options.signer.provider;
+        if (!provider) throw new AgetherError("Signer must have a provider", "NO_PROVIDER");
+        if ("address" in options.signer && typeof options.signer.address === "string") {
+          this._eoaAddress = options.signer.address;
+        }
+        const c = options.config.contracts;
+        this.agether4337Factory = new import_ethers2.Contract(c.agether4337Factory, AGETHER_4337_FACTORY_ABI, options.signer);
+        this.identityRegistry = new import_ethers2.Contract(c.identityRegistry, IDENTITY_REGISTRY_ABI, options.signer);
+        this.agether8004Scorer = new import_ethers2.Contract(c.agether8004Scorer, AGETHER_8004_SCORER_ABI, provider);
+        this.validationModule = new import_ethers2.Contract(c.erc8004ValidationModule, AGETHER_8004_VALIDATION_MODULE_ABI, provider);
+        this.entryPoint = new import_ethers2.Contract(c.entryPoint, ENTRYPOINT_V07_ABI, options.signer);
+      }
+      static fromPrivateKey(privateKey, agentIdOrChain, chainIdOrConfig) {
+        let agentId;
+        let config;
+        if (typeof agentIdOrChain === "bigint") {
+          agentId = agentIdOrChain;
+          config = typeof chainIdOrConfig === "number" ? getDefaultConfig(chainIdOrConfig) : chainIdOrConfig;
         } else {
-          signer = baseSigner;
+          config = typeof agentIdOrChain === "number" ? getDefaultConfig(agentIdOrChain) : agentIdOrChain;
         }
-        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;
+        const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
+        const signer = new import_ethers2.ethers.Wallet(privateKey, provider);
+        return new _AgetherClient({ config, signer, agentId, _privateKey: privateKey });
+      }
+      // ════════════════════════════════════════════════════════
+      //  Registration
+      // ════════════════════════════════════════════════════════
+      /**
+       * Register: create ERC-8004 identity + Safe account in one flow.
+       * If already registered, returns existing state.
+       *
+       * Sets `this.agentId` on success so subsequent operations work immediately.
+       */
+      async register() {
+        const eoaAddr = await this._getSignerAddress();
+        if (this.agentId !== void 0) {
+          const exists = await this.agether4337Factory.accountExists(this.agentId);
+          if (exists) {
+            const acct = await this.agether4337Factory.getAccount(this.agentId);
+            this.accountAddress = acct;
+            const kyaRequired2 = await this.isKyaRequired();
+            return {
+              agentId: this.agentId.toString(),
+              address: eoaAddr,
+              agentAccount: acct,
+              alreadyRegistered: true,
+              kyaRequired: kyaRequired2
+            };
+          }
+        }
+        let agentId;
+        if (this.agentId !== void 0) {
+          const balance = await this.identityRegistry.balanceOf(eoaAddr);
+          if (balance > 0n) {
+            agentId = this.agentId;
+          } else {
+            agentId = await this._mintNewIdentity();
+          }
+        } else {
+          agentId = await this._mintNewIdentity();
+        }
+        this.agentId = agentId;
+        const acctExists = await this.agether4337Factory.accountExists(agentId);
+        let txHash;
+        if (!acctExists) {
+          const tx = await this.agether4337Factory.createAccount(agentId);
+          const receipt = await tx.wait();
+          this._refreshSigner();
+          txHash = receipt.hash;
+        }
+        const acctAddr = await this.agether4337Factory.getAccount(agentId);
+        this.accountAddress = acctAddr;
+        const kyaRequired = await this.isKyaRequired();
+        return {
+          agentId: agentId.toString(),
+          address: eoaAddr,
+          agentAccount: acctAddr,
+          alreadyRegistered: acctExists,
+          kyaRequired,
+          tx: txHash
+        };
+      }
+      /** 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;
+      }
+      // ════════════════════════════════════════════════════════
+      //  Account Management
+      // ════════════════════════════════════════════════════════
+      /**
+       * Deploy a Safe account smart wallet for the agent.
+       * The caller must own the ERC-8004 NFT.
+       */
+      async createAccount() {
+        const id = this._requireAgentId();
+        const tx = await this.agether4337Factory.createAccount(id);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        const event = receipt.logs.map((log) => {
+          try {
+            return this.agether4337Factory.interface.parseLog(log);
+          } catch {
+            return null;
+          }
+        }).find((e) => e?.name === "AccountCreated");
+        if (event) {
+          this.accountAddress = event.args.safeAccount;
+        } else {
+          this.accountAddress = await this.agether4337Factory.getAccount(id);
+        }
+        return this.accountAddress;
+      }
+      /** Get the Safe account address for the current agent. Cached after first call. */
+      async getAccountAddress() {
+        if (this.accountAddress) return this.accountAddress;
+        const id = this._requireAgentId();
+        const addr = await this.agether4337Factory.getAccount(id);
+        if (addr === import_ethers2.ethers.ZeroAddress) {
+          throw new AgetherError(
+            "No account found. Create one with createAccount() or register().",
+            "NO_ACCOUNT"
+          );
+        }
+        this.accountAddress = addr;
+        return addr;
+      }
+      /** Check whether the Safe account has been deployed. */
+      async accountExists() {
+        const id = this._requireAgentId();
+        return this.agether4337Factory.accountExists(id);
+      }
+      // ════════════════════════════════════════════════════════
+      //  Balances
+      // ════════════════════════════════════════════════════════
+      /**
+       * Get ETH, USDC, and collateral token balances for EOA and Safe account.
+       *
+       * Collateral tokens are resolved from a built-in registry of well-known
+       * tokens per chain (WETH, wstETH, cbETH).
+       */
+      async getBalances() {
+        const provider = this.signer.provider;
+        const eoaAddr = await this._getSignerAddress();
+        const usdc = new import_ethers2.Contract(this.config.contracts.usdc, ERC20_ABI, provider);
+        const ethBal = await provider.getBalance(eoaAddr);
+        const usdcBal = await usdc.balanceOf(eoaAddr);
+        const knownTokens = KNOWN_TOKENS[this.config.chainId] ?? {};
+        const eoaCollateral = {};
+        for (const [symbol, info] of Object.entries(knownTokens)) {
+          try {
+            const token = new import_ethers2.Contract(info.address, ERC20_ABI, provider);
+            const bal = await token.balanceOf(eoaAddr);
+            eoaCollateral[symbol] = import_ethers2.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 !== void 0 ? this.agentId.toString() : "?",
+          address: eoaAddr,
+          eth: import_ethers2.ethers.formatEther(ethBal),
+          usdc: import_ethers2.ethers.formatUnits(usdcBal, 6),
+          collateral: eoaCollateral
+        };
+        try {
+          const acctAddr = await this.getAccountAddress();
+          const acctEth = await provider.getBalance(acctAddr);
+          const acctUsdc = await usdc.balanceOf(acctAddr);
+          const acctCollateral = {};
+          for (const [symbol, info] of Object.entries(knownTokens)) {
+            try {
+              const token = new import_ethers2.Contract(info.address, ERC20_ABI, provider);
+              const bal = await token.balanceOf(acctAddr);
+              acctCollateral[symbol] = import_ethers2.ethers.formatUnits(bal, info.decimals);
+            } catch (e) {
+              console.warn(`[agether] Account collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
+              acctCollateral[symbol] = "0";
+            }
+          }
+          result.agentAccount = {
+            address: acctAddr,
+            eth: import_ethers2.ethers.formatEther(acctEth),
+            usdc: import_ethers2.ethers.formatUnits(acctUsdc, 6),
+            collateral: acctCollateral
+          };
+        } catch (e) {
+          if (e instanceof AgetherError && (e.code === "NO_ACCOUNT" || e.code === "NO_AGENT_ID")) {
+          } else {
+            console.warn("[agether] getBalances: failed to fetch Safe account data:", e.message ?? e);
+          }
+        }
+        return result;
+      }
+      /**
+       * Fund the Safe account with USDC from EOA.
+       * This is a simple ERC-20 transfer (does NOT require a UserOp).
+       */
+      async fundAccount(usdcAmount) {
+        const acctAddr = await this.getAccountAddress();
+        const usdc = new import_ethers2.Contract(this.config.contracts.usdc, ERC20_ABI, this.signer);
+        const amount = import_ethers2.ethers.parseUnits(usdcAmount, 6);
+        const tx = await usdc.transfer(acctAddr, amount);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        return {
+          txHash: receipt.hash,
+          blockNumber: receipt.blockNumber,
+          status: receipt.status === 1 ? "success" : "failed",
+          gasUsed: receipt.gasUsed
+        };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Withdrawals (Safe → EOA via UserOps)
+      // ════════════════════════════════════════════════════════
+      /**
+       * Withdraw an ERC-20 token from Safe account to EOA.
+       * Executes a transfer via Safe UserOp.
+       *
+       * @param tokenSymbol - Token to withdraw (e.g. 'USDC', 'WETH', 'wstETH') or 0x address
+       * @param amount - Amount to withdraw (human-readable, e.g. '100', or 'all')
+       */
+      async withdrawToken(tokenSymbol, amount) {
+        const acctAddr = await this.getAccountAddress();
+        const eoaAddr = await this._getSignerAddress();
+        const tokenInfo = await this._resolveToken(tokenSymbol);
+        const tokenContract = new import_ethers2.Contract(tokenInfo.address, ERC20_ABI, this.signer.provider);
+        let weiAmount;
+        if (amount === "all") {
+          weiAmount = await tokenContract.balanceOf(acctAddr);
+          if (weiAmount === 0n) {
+            throw new AgetherError(`No ${tokenInfo.symbol} in Safe account`, "INSUFFICIENT_BALANCE");
+          }
+        } else {
+          weiAmount = import_ethers2.ethers.parseUnits(amount, tokenInfo.decimals);
+        }
+        const data = erc20Iface2.encodeFunctionData("transfer", [eoaAddr, weiAmount]);
+        const receipt = await this._exec(tokenInfo.address, data);
+        const actualAmount = amount === "all" ? import_ethers2.ethers.formatUnits(weiAmount, tokenInfo.decimals) : amount;
+        return { tx: receipt.hash, token: tokenInfo.symbol, amount: actualAmount, destination: eoaAddr };
+      }
+      /**
+       * Withdraw ETH from Safe account to EOA.
+       * Executes a native ETH transfer via Safe UserOp.
+       *
+       * @param amount - ETH amount (e.g. '0.01' or 'all')
+       */
+      async withdrawEth(amount) {
+        const acctAddr = await this.getAccountAddress();
+        const eoaAddr = await this._getSignerAddress();
+        let weiAmount;
+        if (amount === "all") {
+          weiAmount = await this.signer.provider.getBalance(acctAddr);
+          if (weiAmount === 0n) throw new AgetherError("No ETH in Safe account", "INSUFFICIENT_BALANCE");
+        } else {
+          weiAmount = import_ethers2.ethers.parseEther(amount);
+        }
+        const receipt = await this._exec(eoaAddr, "0x", weiAmount);
+        const actualAmount = amount === "all" ? import_ethers2.ethers.formatEther(weiAmount) : amount;
+        return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: eoaAddr };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Sponsorship
+      // ════════════════════════════════════════════════════════
+      /**
+       * Send tokens to another agent's Safe account (or any address).
+       * Transfers from EOA (does NOT require a UserOp).
+       *
+       * @param target - `{ agentId: '42' }` or `{ address: '0x...' }`
+       * @param tokenSymbol - Token to send (e.g. 'WETH', 'USDC') or 0x address
+       * @param amount - Amount to send (human-readable)
+       */
+      async sponsor(target, tokenSymbol, amount) {
+        const tokenInfo = await this._resolveToken(tokenSymbol);
+        let targetAddr;
+        if (target.address) {
+          targetAddr = target.address;
+        } else if (target.agentId) {
+          targetAddr = await this.agether4337Factory.getAccount(BigInt(target.agentId));
+          if (targetAddr === import_ethers2.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_ethers2.ethers.parseUnits(amount, tokenInfo.decimals);
+        const tokenContract = new import_ethers2.Contract(tokenInfo.address, ERC20_ABI, this.signer);
+        const tx = await tokenContract.transfer(targetAddr, weiAmount);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        return { tx: receipt.hash, targetAccount: targetAddr, targetAgentId: target.agentId };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Identity & Validation
+      // ════════════════════════════════════════════════════════
+      /**
+       * Check if the KYA gate is active on the validation module.
+       * If validationRegistry is not set, all txs pass (KYA disabled).
+       */
+      async isKyaRequired() {
+        try {
+          const registryAddr = await this.validationModule.validationRegistry();
+          return registryAddr !== import_ethers2.ethers.ZeroAddress;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Check if this agent's code is KYA-approved.
+       * Uses the ERC8004ValidationModule.isKYAApproved(account) view.
+       */
+      async isKyaApproved() {
+        try {
+          const acctAddr = await this.getAccountAddress();
+          return this.validationModule.isKYAApproved(acctAddr);
+        } catch {
+          return false;
+        }
+      }
+      /** Check whether the agent's ERC-8004 NFT exists. */
+      async identityExists() {
+        const id = this._requireAgentId();
+        try {
+          await this.identityRegistry.ownerOf(id);
+          return true;
+        } catch (e) {
+          console.warn("[agether] identityExists check failed:", e instanceof Error ? e.message : e);
+          return false;
+        }
+      }
+      /** Get the owner address of the ERC-8004 NFT. */
+      async getIdentityOwner() {
+        const id = this._requireAgentId();
+        return this.identityRegistry.ownerOf(id);
+      }
+      // ════════════════════════════════════════════════════════
+      //  Reputation
+      // ════════════════════════════════════════════════════════
+      /** Read the agent's current credit score from the Agether8004Scorer contract. */
+      async getCreditScore() {
+        const id = this._requireAgentId();
+        return this.agether8004Scorer.getCreditScore(id);
+      }
+      /** Check if the score is fresh (within MAX_ORACLE_AGE). */
+      async isScoreFresh() {
+        const id = this._requireAgentId();
+        const [fresh, age] = await this.agether8004Scorer.isScoreFresh(id);
+        return { fresh, age };
+      }
+      /** Check if the agent meets a minimum score threshold. */
+      async isEligible(minScore = 500n) {
+        const id = this._requireAgentId();
+        const [eligible, currentScore] = await this.agether8004Scorer.isEligible(id, minScore);
+        return { eligible, currentScore };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Getters
+      // ════════════════════════════════════════════════════════
+      get chainId() {
+        return this.config.chainId;
+      }
+      get contracts() {
+        return this.config.contracts;
+      }
+      get currentAccountAddress() {
+        return this.accountAddress;
+      }
+      getSigner() {
+        return this.signer;
+      }
+      getAgentId() {
+        return this._requireAgentId();
+      }
+      // ════════════════════════════════════════════════════════
+      //  Private Helpers
+      // ════════════════════════════════════════════════════════
+      /** Require agentId to be set, throw a helpful error otherwise. */
+      _requireAgentId() {
+        if (this.agentId === void 0) {
+          throw new AgetherError("agentId not set. Call register() first.", "NO_AGENT_ID");
+        }
+        return this.agentId;
+      }
+      /** Resolve EOA signer address (async, cached). */
+      async _getSignerAddress() {
+        if (!this._eoaAddress) {
+          this._eoaAddress = await this.signer.getAddress();
+        }
+        return this._eoaAddress;
+      }
+      /**
+       * Resolve a token symbol or address to { address, symbol, decimals }.
+       *
+       * Supports:
+       * - `'USDC'` → from chain config
+       * - Well-known symbols (`'WETH'`, `'wstETH'`, `'cbETH'`) → built-in per-chain registry
+       * - `'0x...'` address → reads decimals and symbol onchain
+       */
+      async _resolveToken(symbolOrAddress) {
+        if (symbolOrAddress.toUpperCase() === "USDC") {
+          return { address: this.config.contracts.usdc, symbol: "USDC", decimals: 6 };
+        }
+        const chainTokens = KNOWN_TOKENS[this.config.chainId] ?? {};
+        const bySymbol = chainTokens[symbolOrAddress] || chainTokens[symbolOrAddress.toUpperCase()];
+        if (bySymbol) return bySymbol;
+        if (symbolOrAddress.startsWith("0x") && symbolOrAddress.length === 42) {
+          try {
+            const token = new import_ethers2.Contract(
+              symbolOrAddress,
+              ["function decimals() view returns (uint8)", "function symbol() view returns (string)"],
+              this.signer.provider
+            );
+            const [decimals, symbol] = await Promise.all([token.decimals(), token.symbol()]);
+            return { address: symbolOrAddress, symbol, decimals: Number(decimals) };
+          } catch (e) {
+            throw new AgetherError(
+              `Failed to read token at ${symbolOrAddress}: ${e instanceof Error ? e.message : e}`,
+              "UNKNOWN_TOKEN"
+            );
+          }
+        }
+        throw new AgetherError(
+          `Unknown token: ${symbolOrAddress}. Use a known symbol (USDC, WETH, wstETH, cbETH) or a 0x address.`,
+          "UNKNOWN_TOKEN"
+        );
+      }
+      /**
+       * Refresh signer and rebind contracts for fresh nonce.
+       *
+       * For the privateKey path: recreates provider + wallet.
+       * For external signers: just rebinds contract instances.
+       */
+      _refreshSigner() {
+        if (!this._useExternalSigner && this._privateKey) {
+          const provider = new import_ethers2.ethers.JsonRpcProvider(this._rpcUrl);
+          const wallet = new import_ethers2.ethers.Wallet(this._privateKey, provider);
+          this.signer = wallet;
+          this._eoaAddress = wallet.address;
+        }
+        const c = this.config.contracts;
+        this.agether4337Factory = new import_ethers2.Contract(c.agether4337Factory, AGETHER_4337_FACTORY_ABI, this.signer);
+        this.identityRegistry = new import_ethers2.Contract(c.identityRegistry, IDENTITY_REGISTRY_ABI, this.signer);
+        this.agether8004Scorer = new import_ethers2.Contract(c.agether8004Scorer, AGETHER_8004_SCORER_ABI, this.signer.provider);
+        this.validationModule = new import_ethers2.Contract(c.erc8004ValidationModule, AGETHER_8004_VALIDATION_MODULE_ABI, this.signer.provider);
+        this.entryPoint = new import_ethers2.Contract(c.entryPoint, ENTRYPOINT_V07_ABI, this.signer);
+      }
+      // ────────────────────────────────────────────────────────
+      //  ERC-4337 UserOp helpers (Safe + Safe7579 + EntryPoint v0.7)
+      // ────────────────────────────────────────────────────────
+      /**
+       * Pack two uint128 values into a single bytes32:
+       *   bytes32 = (hi << 128) | lo
+       */
+      _packUint128(hi, lo) {
+        return import_ethers2.ethers.zeroPadValue(import_ethers2.ethers.toBeHex(hi << 128n | lo), 32);
+      }
+      /**
+       * Build, sign and submit a PackedUserOperation through EntryPoint.handleOps.
+       */
+      async _submitUserOp(callData) {
+        const sender = await this.getAccountAddress();
+        const eoaAddr = await this._getSignerAddress();
+        const validatorAddr = this.config.contracts.erc8004ValidationModule;
+        const nonceKey = BigInt(validatorAddr) << 32n;
+        const nonce = await this.entryPoint.getNonce(sender, nonceKey);
+        const feeData = await this.signer.provider.getFeeData();
+        const maxFeePerGas = feeData.maxFeePerGas ?? import_ethers2.ethers.parseUnits("0.5", "gwei");
+        const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? import_ethers2.ethers.parseUnits("0.1", "gwei");
+        const verificationGasLimit = 500000n;
+        const callGasLimit = 800000n;
+        const preVerificationGas = 100000n;
+        const accountGasLimits = this._packUint128(verificationGasLimit, callGasLimit);
+        const gasFees = this._packUint128(maxPriorityFeePerGas, maxFeePerGas);
+        const requiredPrefund = (verificationGasLimit + callGasLimit + preVerificationGas) * maxFeePerGas;
+        const accountBalance = await this.signer.provider.getBalance(sender);
+        if (accountBalance < requiredPrefund) {
+          const topUp = requiredPrefund - accountBalance;
+          const topUpWithBuffer = topUp * 120n / 100n;
+          const fundTx = await this.signer.sendTransaction({
+            to: sender,
+            value: topUpWithBuffer
+          });
+          await fundTx.wait();
+          this._refreshSigner();
+        }
+        const userOp = {
+          sender,
+          nonce,
+          initCode: "0x",
+          callData,
+          accountGasLimits,
+          preVerificationGas,
+          gasFees,
+          paymasterAndData: "0x",
+          signature: "0x"
+        };
+        const userOpHash = await this.entryPoint.getUserOpHash(userOp);
+        const signature = await this.signer.signMessage(import_ethers2.ethers.getBytes(userOpHash));
+        userOp.signature = signature;
+        const tx = await this.entryPoint.handleOps([userOp], eoaAddr);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        const epIface = new import_ethers2.ethers.Interface(ENTRYPOINT_V07_ABI);
+        for (const log of receipt.logs) {
+          try {
+            const parsed = epIface.parseLog({ topics: log.topics, data: log.data });
+            if (parsed?.name === "UserOperationEvent" && !parsed.args.success) {
+              let revertMsg = "UserOp inner execution reverted";
+              for (const rLog of receipt.logs) {
+                try {
+                  const rParsed = epIface.parseLog({ topics: rLog.topics, data: rLog.data });
+                  if (rParsed?.name === "UserOperationRevertReason") {
+                    const reason = rParsed.args.revertReason;
+                    try {
+                      if (reason.length >= 10 && reason.slice(0, 10) === "0x08c379a0") {
+                        const decoded = import_ethers2.ethers.AbiCoder.defaultAbiCoder().decode(
+                          ["string"],
+                          "0x" + reason.slice(10)
+                        );
+                        revertMsg = `UserOp reverted: ${decoded[0]}`;
+                      } else {
+                        revertMsg = `UserOp reverted with data: ${reason}`;
+                      }
+                    } catch {
+                      revertMsg = `UserOp reverted with data: ${reason}`;
+                    }
+                    break;
+                  }
+                } catch {
+                  continue;
+                }
+              }
+              throw new AgetherError(revertMsg, "USEROP_EXECUTION_FAILED");
+            }
+          } catch (e) {
+            if (e instanceof AgetherError) throw e;
+            continue;
+          }
+        }
+        return receipt;
+      }
+      /**
+       * Execute a single call via Safe7579 account (ERC-7579 single mode)
+       * through an ERC-4337 UserOperation.
+       */
+      async _exec(target, data, value = 0n) {
+        const valueHex = import_ethers2.ethers.zeroPadValue(import_ethers2.ethers.toBeHex(value), 32);
+        const executionCalldata = import_ethers2.ethers.concat([target, valueHex, data]);
+        const safe7579Iface = new import_ethers2.ethers.Interface(SAFE7579_ACCOUNT_ABI);
+        const callData = safe7579Iface.encodeFunctionData("execute", [MODE_SINGLE2, executionCalldata]);
+        return this._submitUserOp(callData);
+      }
+    };
+  }
+});
+
+// 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);
+              if (config.validatorModule) {
+                const validatorHex = config.validatorModule.replace("0x", "").toLowerCase();
+                const sigHex = sig.replace("0x", "");
+                return `0x${validatorHex}${sigHex}`;
+              }
+              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;
         const restored = config.initialSpendingState;
         const restoredBorrowed = restored && restored.date === today ? BigInt(restored.totalBorrowed) : 0n;
         this._spendingTracker = { date: today, totalBorrowed: restoredBorrowed, dailyLimit };
@@ -2325,7 +2683,7 @@ var init_X402Client = __esm({
 });
 
 // src/cli.ts
-var import_ethers2 = require("ethers");
+var import_ethers3 = require("ethers");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
@@ -2369,13 +2727,25 @@ async function waitForTx(tx, retries = 5) {
 }
 async function getMorphoClient(config) {
   const { MorphoClient: MorphoClient2 } = await Promise.resolve().then(() => (init_MorphoClient(), MorphoClient_exports));
+  if (!config.agentId || config.agentId === "0") {
+    throw new Error("Agent not registered. Run: agether register");
+  }
   return new MorphoClient2({
     privateKey: config.privateKey,
     rpcUrl: config.rpcUrl,
-    agentId: config.agentId !== "0" ? config.agentId : void 0,
+    agentId: config.agentId,
     chainId: config.chainId
   });
 }
+async function getAgetherClient(config) {
+  const { AgetherClient: AgetherClient2 } = await Promise.resolve().then(() => (init_AgetherClient(), AgetherClient_exports));
+  const chainId = config.chainId ?? 1;
+  const agentId = config.agentId && config.agentId !== "0" ? BigInt(config.agentId) : void 0;
+  if (agentId !== void 0) {
+    return AgetherClient2.fromPrivateKey(config.privateKey, agentId, chainId);
+  }
+  return AgetherClient2.fromPrivateKey(config.privateKey, chainId);
+}
 async function getX402Client(config) {
   const { X402Client: X402Client2 } = await Promise.resolve().then(() => (init_X402Client(), X402Client_exports));
   let accountAddress;
@@ -2438,7 +2808,7 @@ async function cmdInit(privateKey, agentId, chain) {
   const rpcUrl = process.env.AGETHER_RPC_URL || CHAIN_RPC[chainId] || DEFAULT_RPC;
   let wallet;
   try {
-    wallet = new import_ethers2.ethers.Wallet(privateKey);
+    wallet = new import_ethers3.ethers.Wallet(privateKey);
   } catch {
     console.error("\u274C Invalid private key");
     process.exit(1);
@@ -2455,8 +2825,8 @@ async function cmdInit(privateKey, agentId, chain) {
 }
 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 provider = new import_ethers3.ethers.JsonRpcProvider(config.rpcUrl);
+  const signer = new import_ethers3.ethers.Wallet(config.privateKey, provider);
   const agentName = name || `Agent-${signer.address.slice(0, 8)}`;
   console.log(`\u{1F916} Registering agent: ${agentName}
 `);
@@ -2479,7 +2849,7 @@ async function cmdRegister(name) {
     process.exit(1);
   }
   console.log("  [2/4] Registering on ERC-8004 IdentityRegistry...");
-  const agentRegistry = new import_ethers2.ethers.Contract(registryAddr, ERC8004_ABI, signer);
+  const agentRegistry = new import_ethers3.ethers.Contract(registryAddr, ERC8004_ABI, signer);
   let agentId;
   if (config.agentId && config.agentId !== "0") {
     agentId = BigInt(config.agentId);
@@ -2510,7 +2880,7 @@ async function cmdRegister(name) {
       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 transferTopic = import_ethers3.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]);
@@ -2543,11 +2913,11 @@ async function cmdRegister(name) {
   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 deployer = new import_ethers3.ethers.Wallet(deployerPk, provider);
     const usdcAddr = contracts.usdc;
     if (usdcAddr) {
       try {
-        const usdc = new import_ethers2.ethers.Contract(usdcAddr, MOCK_ERC20_ABI, deployer);
+        const usdc = new import_ethers3.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");
@@ -2560,7 +2930,7 @@ async function cmdRegister(name) {
   }
   console.log("  [4/4] Creating Safe account...");
   if (factoryAddr) {
-    const factory = new import_ethers2.ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI2, signer);
+    const factory = new import_ethers3.ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI2, signer);
     try {
       const exists = await factory.accountExists(agentId);
       if (exists) {
@@ -2578,7 +2948,7 @@ async function cmdRegister(name) {
     }
   }
   if (validationAddr) {
-    const vr = new import_ethers2.ethers.Contract(validationAddr, VALIDATION_REGISTRY_ABI, provider);
+    const vr = new import_ethers3.ethers.Contract(validationAddr, VALIDATION_REGISTRY_ABI, provider);
     try {
       const approved = await vr.isAgentCodeApproved(agentId);
       console.log(`
@@ -2597,8 +2967,8 @@ async function cmdRegister(name) {
 }
 async function cmdBalance() {
   const config = requireConfig();
-  const mc = await getMorphoClient(config);
-  const balances = await mc.getBalances();
+  const ac = await getAgetherClient(config);
+  const balances = await ac.getBalances();
   console.log(`
 \u{1F4B0} Agent #${balances.agentId} Balances
 `);
@@ -2636,8 +3006,9 @@ async function cmdStatus() {
   }
   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 ac = await getAgetherClient(config);
+    const score = await ac.getCreditScore();
+    const { fresh, age } = await ac.isScoreFresh();
     const ageHrs = Number(age) / 3600;
     console.log(`
   Credit Score: ${score} ${fresh ? "\u2705" : `\u26A0\uFE0F stale (${ageHrs.toFixed(1)}h old)`}`);
@@ -2766,13 +3137,13 @@ async function cmdWithdraw(amount, token) {
 }
 async function cmdSponsor(amount, token, agentId, address) {
   const config = requireConfig();
-  const mc = await getMorphoClient(config);
+  const ac = await getAgetherClient(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);
+    const result = await ac.sponsor(target, token, amount);
     console.log(`\u2705 Sponsored ${amount} ${token}`);
     console.log(`   Target: ${result.targetAccount}`);
     console.log(`   TX: ${result.tx}`);
@@ -2782,15 +3153,14 @@ async function cmdSponsor(amount, token, agentId, address) {
 }
 async function cmdFund(amount) {
   const config = requireConfig();
-  const mc = await getMorphoClient(config);
+  const ac = await getAgetherClient(config);
   console.log(`
 \u{1F4B5} Funding AgentAccount with $${amount} USDC...
 `);
   try {
-    const result = await mc.fundAccount(amount);
+    const result = await ac.fundAccount(amount);
     console.log(`\u2705 Funded $${amount} USDC`);
-    console.log(`   AgentAccount: ${result.agentAccount}`);
-    console.log(`   TX: ${result.tx}`);
+    console.log(`   TX: ${result.txHash}`);
   } catch (e) {
     console.error(`\u274C ${decodeError(e)}`);
   }
@@ -2799,7 +3169,7 @@ 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(`   Wallet: ${new import_ethers3.ethers.Wallet(config.privateKey).address}`);
   console.log(`
 \u{1F4E1} ${method} ${url}`);
   if (body) console.log(`\u{1F4E6} Body: ${body}`);