@agether/sdk 2.8.0 → 2.9.0

package/dist/index.mjs

@@ -2,13 +2,13 @@
 import { ethers, Contract } from "ethers";
 
 // src/types/index.ts
-var ChainId = /* @__PURE__ */ ((ChainId4) => {
-  ChainId4[ChainId4["Ethereum"] = 1] = "Ethereum";
-  ChainId4[ChainId4["Base"] = 8453] = "Base";
-  ChainId4[ChainId4["BaseSepolia"] = 84532] = "BaseSepolia";
-  ChainId4[ChainId4["Sepolia"] = 11155111] = "Sepolia";
-  ChainId4[ChainId4["Hardhat"] = 31337] = "Hardhat";
-  return ChainId4;
+var ChainId = /* @__PURE__ */ ((ChainId3) => {
+  ChainId3[ChainId3["Ethereum"] = 1] = "Ethereum";
+  ChainId3[ChainId3["Base"] = 8453] = "Base";
+  ChainId3[ChainId3["BaseSepolia"] = 84532] = "BaseSepolia";
+  ChainId3[ChainId3["Sepolia"] = 11155111] = "Sepolia";
+  ChainId3[ChainId3["Hardhat"] = 31337] = "Hardhat";
+  return ChainId3;
 })(ChainId || {});
 var AgetherError = class extends Error {
   constructor(message, code, details) {
@@ -292,93 +292,246 @@ function getContractAddresses(chainId) {
 }
 
 // src/clients/AgetherClient.ts
+var MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var erc20Iface = new ethers.Interface(ERC20_ABI);
+var 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 }
+  }
+};
 var 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 {
+      this._useExternalSigner = true;
+    }
     const provider = options.signer.provider;
     if (!provider) throw new AgetherError("Signer must have a provider", "NO_PROVIDER");
-    this.agether4337Factory = new Contract(
-      options.config.contracts.agether4337Factory,
-      AGETHER_4337_FACTORY_ABI,
-      options.signer
-    );
-    this.identityRegistry = new Contract(
-      options.config.contracts.identityRegistry,
-      IDENTITY_REGISTRY_ABI,
-      provider
-    );
-    this.agether8004Scorer = new Contract(
-      options.config.contracts.agether8004Scorer,
-      AGETHER_8004_SCORER_ABI,
-      provider
-    );
-    this.validationModule = new Contract(
-      options.config.contracts.erc8004ValidationModule,
-      AGETHER_8004_VALIDATION_MODULE_ABI,
-      provider
-    );
+    if ("address" in options.signer && typeof options.signer.address === "string") {
+      this._eoaAddress = options.signer.address;
+    }
+    const c = options.config.contracts;
+    this.agether4337Factory = new Contract(c.agether4337Factory, AGETHER_4337_FACTORY_ABI, options.signer);
+    this.identityRegistry = new Contract(c.identityRegistry, IDENTITY_REGISTRY_ABI, options.signer);
+    this.agether8004Scorer = new Contract(c.agether8004Scorer, AGETHER_8004_SCORER_ABI, provider);
+    this.validationModule = new Contract(c.erc8004ValidationModule, AGETHER_8004_VALIDATION_MODULE_ABI, provider);
+    this.entryPoint = new Contract(c.entryPoint, ENTRYPOINT_V07_ABI, options.signer);
   }
-  // Static Factory
-  static fromPrivateKey(privateKey, agentId, chainIdOrConfig) {
-    const config = typeof chainIdOrConfig === "number" ? getDefaultConfig(chainIdOrConfig) : chainIdOrConfig;
+  static fromPrivateKey(privateKey, agentIdOrChain, chainIdOrConfig) {
+    let agentId;
+    let config;
+    if (typeof agentIdOrChain === "bigint") {
+      agentId = agentIdOrChain;
+      config = typeof chainIdOrConfig === "number" ? getDefaultConfig(chainIdOrConfig) : chainIdOrConfig;
+    } else {
+      config = typeof agentIdOrChain === "number" ? getDefaultConfig(agentIdOrChain) : agentIdOrChain;
+    }
     const provider = new ethers.JsonRpcProvider(config.rpcUrl);
     const signer = new ethers.Wallet(privateKey, provider);
-    return new _AgetherClient({ config, signer, agentId });
+    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
+    };
   }
-  // Account Management
+  /** 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 tx = await this.agether4337Factory.createAccount(this.agentId);
+    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 (e) {
-        console.warn("[agether] createAccount parseLog skip:", e instanceof Error ? e.message : e);
+      } catch {
         return null;
       }
     }).find((e) => e?.name === "AccountCreated");
     if (event) {
       this.accountAddress = event.args.safeAccount;
     } else {
-      this.accountAddress = await this.agether4337Factory.getAccount(this.agentId);
+      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 addr = await this.agether4337Factory.getAccount(this.agentId);
+    const id = this._requireAgentId();
+    const addr = await this.agether4337Factory.getAccount(id);
     if (addr === ethers.ZeroAddress) {
-      throw new AgetherError("No account found. Create one with createAccount().", "NO_ACCOUNT");
+      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() {
-    return this.agether4337Factory.accountExists(this.agentId);
+    const id = this._requireAgentId();
+    return this.agether4337Factory.accountExists(id);
   }
-  // Balances
+  // ════════════════════════════════════════════════════════
+  //  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.signer.getAddress();
+    const eoaAddr = await this._getSignerAddress();
     const usdc = new 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 Contract(info.address, ERC20_ABI, provider);
+        const bal = await token.balanceOf(eoaAddr);
+        eoaCollateral[symbol] = 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 = {
-      eoa: { eth: ethers.formatEther(ethBal), usdc: ethers.formatUnits(usdcBal, 6) }
+      agentId: this.agentId !== void 0 ? this.agentId.toString() : "?",
+      address: eoaAddr,
+      eth: ethers.formatEther(ethBal),
+      usdc: ethers.formatUnits(usdcBal, 6),
+      collateral: eoaCollateral
     };
     try {
       const acctAddr = await this.getAccountAddress();
       const acctEth = await provider.getBalance(acctAddr);
       const acctUsdc = await usdc.balanceOf(acctAddr);
-      result.account = {
+      const acctCollateral = {};
+      for (const [symbol, info] of Object.entries(knownTokens)) {
+        try {
+          const token = new Contract(info.address, ERC20_ABI, provider);
+          const bal = await token.balanceOf(acctAddr);
+          acctCollateral[symbol] = 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: ethers.formatEther(acctEth),
-        usdc: ethers.formatUnits(acctUsdc, 6)
+        usdc: ethers.formatUnits(acctUsdc, 6),
+        collateral: acctCollateral
       };
     } catch (e) {
-      console.warn("[agether] getBalances: no Safe account or fetch failed:", e instanceof Error ? e.message : 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;
   }
@@ -392,6 +545,7 @@ var AgetherClient = class _AgetherClient {
     const amount = 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,
@@ -399,7 +553,89 @@ var AgetherClient = class _AgetherClient {
       gasUsed: receipt.gasUsed
     };
   }
-  // Identity & Validation
+  // ════════════════════════════════════════════════════════
+  //  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 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 = ethers.parseUnits(amount, tokenInfo.decimals);
+    }
+    const data = erc20Iface.encodeFunctionData("transfer", [eoaAddr, weiAmount]);
+    const receipt = await this._exec(tokenInfo.address, data);
+    const actualAmount = amount === "all" ? 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 = ethers.parseEther(amount);
+    }
+    const receipt = await this._exec(eoaAddr, "0x", weiAmount);
+    const actualAmount = amount === "all" ? 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 === ethers.ZeroAddress) {
+        throw new AgetherError("Target agent has no account", "NO_ACCOUNT");
+      }
+    } else {
+      throw new AgetherError("Provide agentId or address", "INVALID_TARGET");
+    }
+    const weiAmount = ethers.parseUnits(amount, tokenInfo.decimals);
+    const tokenContract = new 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).
@@ -424,31 +660,45 @@ var AgetherClient = class _AgetherClient {
       return false;
     }
   }
+  /** Check whether the agent's ERC-8004 NFT exists. */
   async identityExists() {
+    const id = this._requireAgentId();
     try {
-      await this.identityRegistry.ownerOf(this.agentId);
+      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() {
-    return this.identityRegistry.ownerOf(this.agentId);
+    const id = this._requireAgentId();
+    return this.identityRegistry.ownerOf(id);
   }
-  // Reputation
+  // ════════════════════════════════════════════════════════
+  //  Reputation
+  // ════════════════════════════════════════════════════════
+  /** Read the agent's current credit score from the Agether8004Scorer contract. */
   async getCreditScore() {
-    return this.agether8004Scorer.getCreditScore(this.agentId);
+    const id = this._requireAgentId();
+    return this.agether8004Scorer.getCreditScore(id);
   }
+  /** Check if the score is fresh (within MAX_ORACLE_AGE). */
   async isScoreFresh() {
-    const [fresh, age] = await this.agether8004Scorer.isScoreFresh(this.agentId);
+    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 [eligible, currentScore] = await this.agether8004Scorer.isEligible(this.agentId, minScore);
+    const id = this._requireAgentId();
+    const [eligible, currentScore] = await this.agether8004Scorer.isEligible(id, minScore);
     return { eligible, currentScore };
   }
-  // Getters
+  // ════════════════════════════════════════════════════════
+  //  Getters
+  // ════════════════════════════════════════════════════════
   get chainId() {
     return this.config.chainId;
   }
@@ -462,24 +712,209 @@ var AgetherClient = class _AgetherClient {
     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 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 ethers.JsonRpcProvider(this._rpcUrl);
+      const wallet = new ethers.Wallet(this._privateKey, provider);
+      this.signer = wallet;
+      this._eoaAddress = wallet.address;
+    }
+    const c = this.config.contracts;
+    this.agether4337Factory = new Contract(c.agether4337Factory, AGETHER_4337_FACTORY_ABI, this.signer);
+    this.identityRegistry = new Contract(c.identityRegistry, IDENTITY_REGISTRY_ABI, this.signer);
+    this.agether8004Scorer = new Contract(c.agether8004Scorer, AGETHER_8004_SCORER_ABI, this.signer.provider);
+    this.validationModule = new Contract(c.erc8004ValidationModule, AGETHER_8004_VALIDATION_MODULE_ABI, this.signer.provider);
+    this.entryPoint = new 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 ethers.zeroPadValue(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 ?? ethers.parseUnits("0.5", "gwei");
+    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? 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(ethers.getBytes(userOpHash));
+    userOp.signature = signature;
+    const tx = await this.entryPoint.handleOps([userOp], eoaAddr);
+    const receipt = await tx.wait();
+    this._refreshSigner();
+    const epIface = new 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 = 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 = ethers.zeroPadValue(ethers.toBeHex(value), 32);
+    const executionCalldata = ethers.concat([target, valueHex, data]);
+    const safe7579Iface = new ethers.Interface(SAFE7579_ACCOUNT_ABI);
+    const callData = safe7579Iface.encodeFunctionData("execute", [MODE_SINGLE, executionCalldata]);
+    return this._submitUserOp(callData);
+  }
 };
 
 // src/clients/MorphoClient.ts
 import { ethers as ethers2, Contract as Contract2 } from "ethers";
 import axios from "axios";
 var MORPHO_API_URL = "https://api.morpho.org/graphql";
-var MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var MODE_SINGLE2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
 var morphoIface = new ethers2.Interface(MORPHO_BLUE_ABI);
-var erc20Iface = new ethers2.Interface(ERC20_ABI);
+var erc20Iface2 = new ethers2.Interface(ERC20_ABI);
 var MorphoClient = class {
   constructor(config) {
     this._marketCache = /* @__PURE__ */ new Map();
     /** 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;
@@ -509,26 +944,7 @@ var MorphoClient = class {
     const addrs = { ...defaultCfg.contracts, ...config.contracts };
     this.agether4337Factory = new Contract2(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
     this.morphoBlue = new Contract2(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
-    this.agether8004Scorer = new Contract2(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-    this.identityRegistry = new Contract2(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
     this.entryPoint = new Contract2(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-    this.validationModule = new Contract2(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 !== ethers2.ZeroAddress;
-    } catch {
-      return false;
-    }
   }
   // ════════════════════════════════════════════════════════
   //  Account Management
@@ -536,7 +952,6 @@ var MorphoClient = class {
   /** 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++) {
@@ -558,7 +973,6 @@ var MorphoClient = class {
     throw lastErr;
   }
   getAgentId() {
-    if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
     return this.agentId;
   }
   /**
@@ -591,182 +1005,6 @@ var MorphoClient = class {
     }
     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 Contract2(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 Contract2(info.address, ERC20_ABI, this.provider);
-        const bal = await token.balanceOf(eoaAddr);
-        eoaCollateral[info.symbol] = ethers2.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: ethers2.formatEther(ethBal),
-      usdc: ethers2.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 Contract2(info.address, ERC20_ABI, this.provider);
-          const bal = await token.balanceOf(acctAddr);
-          acctCollateral[info.symbol] = ethers2.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: ethers2.formatEther(acctEth),
-        usdc: ethers2.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 Contract2(this.config.contracts.usdc, ERC20_ABI, this._signer);
-    const amount = ethers2.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 Contract2(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 = ethers2.parseUnits(amount, tokenInfo.decimals);
-    }
-    const data = erc20Iface.encodeFunctionData("transfer", [eoaAddr, weiAmount]);
-    const receipt = await this.exec(tokenInfo.address, data);
-    const actualAmount = amount === "all" ? ethers2.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 = ethers2.parseEther(amount);
-    }
-    const receipt = await this.exec(eoaAddr, "0x", weiAmount);
-    const actualAmount = amount === "all" ? ethers2.formatEther(weiAmount) : amount;
-    return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: eoaAddr };
-  }
   // ════════════════════════════════════════════════════════
   //  Market Discovery (Morpho GraphQL API)
   // ════════════════════════════════════════════════════════
@@ -945,7 +1183,7 @@ var MorphoClient = class {
       }
     }
     return {
-      agentId: this.agentId || "?",
+      agentId: this.agentId,
       agentAccount: acctAddr,
       totalDebt: ethers2.formatUnits(totalDebt, 6),
       positions
@@ -1191,7 +1429,7 @@ var MorphoClient = class {
     const targets = [usdcAddr, morphoAddr];
     const values = [0n, 0n];
     const datas = [
-      erc20Iface.encodeFunctionData("approve", [morphoAddr, amount]),
+      erc20Iface2.encodeFunctionData("approve", [morphoAddr, amount]),
       morphoIface.encodeFunctionData("supply", [
         this._toTuple(params),
         amount,
@@ -1423,7 +1661,7 @@ var MorphoClient = class {
     const targets = [colInfo.address, morphoAddr];
     const values = [0n, 0n];
     const datas = [
-      erc20Iface.encodeFunctionData("approve", [morphoAddr, weiAmount]),
+      erc20Iface2.encodeFunctionData("approve", [morphoAddr, weiAmount]),
       morphoIface.encodeFunctionData("supplyCollateral", [
         this._toTuple(params),
         weiAmount,
@@ -1574,7 +1812,7 @@ var MorphoClient = class {
     const targets = [colInfo.address, morphoAddr, morphoAddr];
     const values = [0n, 0n, 0n];
     const datas = [
-      erc20Iface.encodeFunctionData("approve", [morphoAddr, colWei]),
+      erc20Iface2.encodeFunctionData("approve", [morphoAddr, colWei]),
       morphoIface.encodeFunctionData("supplyCollateral", [
         this._toTuple(params),
         colWei,
@@ -1662,7 +1900,7 @@ var MorphoClient = class {
     const targets = [usdcAddr, morphoAddr];
     const values = [0n, 0n];
     const datas = [
-      erc20Iface.encodeFunctionData("approve", [morphoAddr, approveAmount]),
+      erc20Iface2.encodeFunctionData("approve", [morphoAddr, approveAmount]),
       morphoIface.encodeFunctionData("repay", [
         this._toTuple(params),
         repayAssets,
@@ -1751,7 +1989,7 @@ var MorphoClient = class {
       const targets = [usdcAddr, morphoAddr, morphoAddr];
       const values = [0n, 0n, 0n];
       const datas = [
-        erc20Iface.encodeFunctionData("approve", [morphoAddr, dustApproveAmount]),
+        erc20Iface2.encodeFunctionData("approve", [morphoAddr, dustApproveAmount]),
         morphoIface.encodeFunctionData("repay", [
           this._toTuple(params),
           0n,
@@ -1782,50 +2020,6 @@ var MorphoClient = class {
       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 === ethers2.ZeroAddress) throw new AgetherError("Target agent has no account", "NO_ACCOUNT");
-    } else {
-      throw new AgetherError("Provide agentId or address", "INVALID_TARGET");
-    }
-    const weiAmount = ethers2.parseUnits(amount, colInfo.decimals);
-    const colToken = new Contract2(colInfo.address, ERC20_ABI, this._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
   // ════════════════════════════════════════════════════════
@@ -1847,9 +2041,6 @@ var MorphoClient = class {
       const addrs = this.config.contracts;
       this.agether4337Factory = new Contract2(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
       this.entryPoint = new Contract2(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-      this.validationModule = new Contract2(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-      this.agether8004Scorer = new Contract2(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-      this.identityRegistry = new Contract2(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
     } else {
       this.provider = new ethers2.JsonRpcProvider(this._rpcUrl);
       const wallet = new ethers2.Wallet(this._privateKey, this.provider);
@@ -1858,9 +2049,6 @@ var MorphoClient = class {
       const addrs = this.config.contracts;
       this.agether4337Factory = new Contract2(addrs.agether4337Factory, ACCOUNT_FACTORY_ABI, this._signer);
       this.entryPoint = new Contract2(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
-      this.validationModule = new Contract2(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
-      this.agether8004Scorer = new Contract2(addrs.agether8004Scorer, AGENT_REPUTATION_ABI, this._signer);
-      this.identityRegistry = new Contract2(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
     }
   }
   // ────────────────────────────────────────────────────────────
@@ -1967,7 +2155,7 @@ var MorphoClient = class {
     const valueHex = ethers2.zeroPadValue(ethers2.toBeHex(value), 32);
     const executionCalldata = ethers2.concat([target, valueHex, data]);
     const safe7579Iface = new ethers2.Interface(SAFE7579_ACCOUNT_ABI);
-    const callData = safe7579Iface.encodeFunctionData("execute", [MODE_SINGLE, executionCalldata]);
+    const callData = safe7579Iface.encodeFunctionData("execute", [MODE_SINGLE2, executionCalldata]);
     return this._submitUserOp(callData);
   }
   /**
@@ -2063,23 +2251,6 @@ var MorphoClient = class {
       "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.
    *