@agether/sdk 1.11.1 → 2.0.0

package/dist/index.mjs

@@ -55,38 +55,41 @@ var IDENTITY_REGISTRY_ABI = [
   "function register() returns (uint256 agentId)",
   "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
 ];
-var ACCOUNT_FACTORY_ABI = [
+var SAFE_AGENT_FACTORY_ABI = [
   "function getAccount(uint256 agentId) view returns (address)",
   "function accountExists(uint256 agentId) view returns (bool)",
-  "function predictAddress(uint256 agentId) view returns (address)",
   "function totalAccounts() view returns (uint256)",
   "function getAgentId(address account) view returns (uint256)",
-  "function createAccount(uint256 agentId) returns (address account)",
-  "function protocolHook() view returns (address)",
+  "function getAgentIdByIndex(uint256 index) view returns (uint256)",
+  "function getAllAgentIds() view returns (uint256[])",
+  "function createAccount(uint256 agentId) returns (address safeAccount)",
   "function identityRegistry() view returns (address)",
-  "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
+  "function validationModule() view returns (address)",
+  "function hookMultiplexer() view returns (address)",
+  "function safeSingleton() view returns (address)",
+  "function safe7579() view returns (address)",
+  "function bootstrap() view returns (address)",
+  "function SENTINEL_OWNER() view returns (address)",
+  "event AccountCreated(uint256 indexed agentId, address indexed safeAccount, address indexed owner)"
 ];
-var AGENT_ACCOUNT_ABI = [
-  "function agentId() view returns (uint256)",
+var ACCOUNT_FACTORY_ABI = SAFE_AGENT_FACTORY_ABI;
+var ERC8004_VALIDATION_MODULE_ABI = [
+  // View
+  "function getConfig(address account) view returns (address registry, uint256 agentId)",
+  "function getOwner(address account) view returns (address)",
+  "function isInstalled(address account) view returns (bool)",
+  "function isKYAApproved(address account) view returns (bool)",
+  "function validationRegistry() view returns (address)",
   "function owner() view returns (address)",
-  "function factory() view returns (address)",
-  "function identityRegistry() view returns (address)",
-  "function balanceOf(address token) view returns (uint256)",
-  "function ethBalance() view returns (uint256)",
-  // ERC-7579 execution
-  "function execute(bytes32 mode, bytes executionCalldata) payable",
-  "function executeFromExecutor(bytes32 mode, bytes executionCalldata) payable returns (bytes[])",
-  // ERC-7579 module management
-  "function installModule(uint256 moduleTypeId, address module, bytes initData) payable",
-  "function uninstallModule(uint256 moduleTypeId, address module, bytes deInitData) payable",
-  "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)",
-  "function hook() view returns (address)",
-  // Funding (direct, no execution needed)
-  "function fund(address token, uint256 amount)",
-  "function withdraw(address token, uint256 amount, address to)",
-  "function withdrawETH(uint256 amount, address to)",
-  // EIP-1271
-  "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
+  // Admin (via TimelockController)
+  "function setValidationRegistry(address registry_)"
+];
+var HOOK_MULTIPLEXER_ABI = [
+  "function getHooks() view returns (address[])",
+  "function hookCount() view returns (uint256)",
+  "function owner() view returns (address)",
+  "function addHook(address hook)",
+  "function removeHook(address hook)"
 ];
 var AGENT_REPUTATION_ABI = [
   "function getCreditScore(uint256 agentId) view returns (uint256)",
@@ -132,57 +135,113 @@ var ERC20_ABI = [
   "function symbol() view returns (string)",
   "function name() view returns (string)"
 ];
-var KYA_HOOK_ABI = [
-  "function validationRegistry() view returns (address)",
-  "function setValidationRegistry(address newRegistry)"
+var ENTRYPOINT_V07_ABI = [
+  "function handleOps(tuple(address sender, uint256 nonce, bytes initCode, bytes callData, bytes32 accountGasLimits, uint256 preVerificationGas, bytes32 gasFees, bytes paymasterAndData, bytes signature)[] ops, address payable beneficiary)",
+  "function getUserOpHash(tuple(address sender, uint256 nonce, bytes initCode, bytes callData, bytes32 accountGasLimits, uint256 preVerificationGas, bytes32 gasFees, bytes paymasterAndData, bytes signature) userOp) view returns (bytes32)",
+  "function getNonce(address sender, uint192 key) view returns (uint256 nonce)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function depositTo(address account) payable",
+  "event UserOperationEvent(bytes32 indexed userOpHash, address indexed sender, address indexed paymaster, uint256 nonce, bool success, uint256 actualGasCost, uint256 actualGasUsed)"
+];
+var SAFE7579_ACCOUNT_ABI = [
+  // ERC-7579 execution (called via UserOp through Safe7579 fallback)
+  "function execute(bytes32 mode, bytes executionCalldata) payable",
+  "function executeFromExecutor(bytes32 mode, bytes executionCalldata) payable returns (bytes[])",
+  // ERC-7579 module queries
+  "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)",
+  // EIP-1271
+  "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
 ];
 
 // src/utils/config.ts
+var ZERO = "0x0000000000000000000000000000000000000000";
+var ENTRYPOINT_V07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+var ERC8004_IDENTITY_REGISTRY = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
+var ERC8004_IDENTITY_REGISTRY_TESTNET = "0x8004A818BFB912233c491871b3d84c89A494BD9e";
+var MORPHO_BLUE = "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";
+var SAFE_SINGLETON = "0x41675C099F32341bf84BFc5382aF534df5C7461a";
+var SAFE_PROXY_FACTORY = "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67";
+var SAFE7579 = "0x7579EE8307284F293B1927136486880611F20002";
 var CONTRACT_ADDRESSES = {
   [1 /* Ethereum */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    kyaHook: "0x0000000000000000000000000000000000000000",
+    safeSingleton: SAFE_SINGLETON,
+    safeProxyFactory: SAFE_PROXY_FACTORY,
+    safe7579: SAFE7579,
+    entryPoint: ENTRYPOINT_V07,
+    safeAgentFactory: ZERO,
+    safe7579Bootstrap: ZERO,
+    erc8004ValidationModule: ZERO,
+    hookMultiplexer: ZERO,
+    validationRegistry: ZERO,
+    agentReputation: ZERO,
+    timelockController: ZERO,
     usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
+    identityRegistry: ERC8004_IDENTITY_REGISTRY,
+    morphoBlue: MORPHO_BLUE
   },
   [8453 /* Base */]: {
-    accountFactory: "0x89a8758E60A56EcB47247D92E05447eFd450d6Bf",
-    validationRegistry: "0x6f76cF69B71Dc5F9A414BCEe4583b12738E47985",
-    agentReputation: "0xe88f3419a2dbac70e3aF6E487b0C63e8301C6A87",
-    kyaHook: "0x28e50Aa9eD517E369b2806928709B44062aD9821",
+    safeSingleton: SAFE_SINGLETON,
+    safeProxyFactory: SAFE_PROXY_FACTORY,
+    safe7579: SAFE7579,
+    entryPoint: ENTRYPOINT_V07,
+    safeAgentFactory: "0xB0A88ffe28491E793F7706829278f20d724947d1",
+    safe7579Bootstrap: "0x72A636bc23B2644138489c3bBE3B05a0a7184b33",
+    erc8004ValidationModule: "0x49e27A6B4d012B87271897b51d0296ABcFCb0BBd",
+    hookMultiplexer: "0x12c77f17F91f06a11C2C34C618ce9d78f9a34541",
+    validationRegistry: "0x88E21e8883c093E4c8d0d0cE68f1c93Cf6190f51",
+    agentReputation: "0x4C2d42cbD35f6541f0902499CFEC27C1Cf5683E3",
+    timelockController: "0x0517b4f73b61774C88A2B1c5745141315E831015",
     usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
+    identityRegistry: ERC8004_IDENTITY_REGISTRY,
+    morphoBlue: MORPHO_BLUE
   },
   [84532 /* BaseSepolia */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    kyaHook: "0x0000000000000000000000000000000000000000",
+    safeSingleton: SAFE_SINGLETON,
+    safeProxyFactory: SAFE_PROXY_FACTORY,
+    safe7579: SAFE7579,
+    entryPoint: ENTRYPOINT_V07,
+    safeAgentFactory: ZERO,
+    safe7579Bootstrap: ZERO,
+    erc8004ValidationModule: ZERO,
+    hookMultiplexer: ZERO,
+    validationRegistry: ZERO,
+    agentReputation: ZERO,
+    timelockController: ZERO,
     usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    morphoBlue: "0x0000000000000000000000000000000000000000"
+    identityRegistry: ERC8004_IDENTITY_REGISTRY_TESTNET,
+    morphoBlue: ZERO
   },
   [11155111 /* Sepolia */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    kyaHook: "0x0000000000000000000000000000000000000000",
+    safeSingleton: SAFE_SINGLETON,
+    safeProxyFactory: SAFE_PROXY_FACTORY,
+    safe7579: SAFE7579,
+    entryPoint: ENTRYPOINT_V07,
+    safeAgentFactory: ZERO,
+    safe7579Bootstrap: ZERO,
+    erc8004ValidationModule: ZERO,
+    hookMultiplexer: ZERO,
+    validationRegistry: ZERO,
+    agentReputation: ZERO,
+    timelockController: ZERO,
     usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    morphoBlue: "0x0000000000000000000000000000000000000000"
+    identityRegistry: ERC8004_IDENTITY_REGISTRY_TESTNET,
+    morphoBlue: ZERO
   },
   [31337 /* Hardhat */]: {
-    accountFactory: "0x0000000000000000000000000000000000000000",
-    validationRegistry: "0x0000000000000000000000000000000000000000",
-    agentReputation: "0x0000000000000000000000000000000000000000",
-    kyaHook: "0x0000000000000000000000000000000000000000",
+    safeSingleton: SAFE_SINGLETON,
+    safeProxyFactory: SAFE_PROXY_FACTORY,
+    safe7579: SAFE7579,
+    entryPoint: ENTRYPOINT_V07,
+    safeAgentFactory: ZERO,
+    safe7579Bootstrap: ZERO,
+    erc8004ValidationModule: ZERO,
+    hookMultiplexer: ZERO,
+    validationRegistry: ZERO,
+    agentReputation: ZERO,
+    timelockController: ZERO,
     usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    morphoBlue: "0x0000000000000000000000000000000000000000"
+    identityRegistry: ERC8004_IDENTITY_REGISTRY,
+    morphoBlue: ZERO
   }
 };
 var RPC_URLS = {
@@ -227,9 +286,9 @@ var AgetherClient = class _AgetherClient {
     this.agentId = options.agentId;
     const provider = options.signer.provider;
     if (!provider) throw new AgetherError("Signer must have a provider", "NO_PROVIDER");
-    this.accountFactory = new Contract(
-      options.config.contracts.accountFactory,
-      ACCOUNT_FACTORY_ABI,
+    this.safeAgentFactory = new Contract(
+      options.config.contracts.safeAgentFactory,
+      SAFE_AGENT_FACTORY_ABI,
       options.signer
     );
     this.identityRegistry = new Contract(
@@ -237,16 +296,16 @@ var AgetherClient = class _AgetherClient {
       IDENTITY_REGISTRY_ABI,
       provider
     );
-    this.validationRegistry = new Contract(
-      options.config.contracts.validationRegistry,
-      VALIDATION_REGISTRY_ABI,
-      provider
-    );
     this.agentReputation = new Contract(
       options.config.contracts.agentReputation,
       AGENT_REPUTATION_ABI,
       provider
     );
+    this.validationModule = new Contract(
+      options.config.contracts.erc8004ValidationModule,
+      ERC8004_VALIDATION_MODULE_ABI,
+      provider
+    );
   }
   // Static Factory
   static fromPrivateKey(privateKey, agentId, chainIdOrConfig) {
@@ -257,26 +316,26 @@ var AgetherClient = class _AgetherClient {
   }
   // Account Management
   async createAccount() {
-    const tx = await this.accountFactory.createAccount(this.agentId);
+    const tx = await this.safeAgentFactory.createAccount(this.agentId);
     const receipt = await tx.wait();
     const event = receipt.logs.map((log) => {
       try {
-        return this.accountFactory.interface.parseLog(log);
+        return this.safeAgentFactory.interface.parseLog(log);
       } catch (e) {
         console.warn("[agether] createAccount parseLog skip:", e instanceof Error ? e.message : e);
         return null;
       }
     }).find((e) => e?.name === "AccountCreated");
     if (event) {
-      this.accountAddress = event.args.account;
+      this.accountAddress = event.args.safeAccount;
     } else {
-      this.accountAddress = await this.accountFactory.getAccount(this.agentId);
+      this.accountAddress = await this.safeAgentFactory.getAccount(this.agentId);
     }
     return this.accountAddress;
   }
   async getAccountAddress() {
     if (this.accountAddress) return this.accountAddress;
-    const addr = await this.accountFactory.getAccount(this.agentId);
+    const addr = await this.safeAgentFactory.getAccount(this.agentId);
     if (addr === ethers.ZeroAddress) {
       throw new AgetherError("No account found. Create one with createAccount().", "NO_ACCOUNT");
     }
@@ -284,10 +343,7 @@ var AgetherClient = class _AgetherClient {
     return addr;
   }
   async accountExists() {
-    return this.accountFactory.accountExists(this.agentId);
-  }
-  async predictAddress() {
-    return this.accountFactory.predictAddress(this.agentId);
+    return this.safeAgentFactory.accountExists(this.agentId);
   }
   // Balances
   async getBalances() {
@@ -309,10 +365,14 @@ var AgetherClient = class _AgetherClient {
         usdc: ethers.formatUnits(acctUsdc, 6)
       };
     } catch (e) {
-      console.warn("[agether] getBalances: no AgentAccount or fetch failed:", e instanceof Error ? e.message : e);
+      console.warn("[agether] getBalances: no Safe account or fetch failed:", e instanceof Error ? 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 Contract(this.config.contracts.usdc, ERC20_ABI, this.signer);
@@ -326,37 +386,30 @@ var AgetherClient = class _AgetherClient {
       gasUsed: receipt.gasUsed
     };
   }
-  async withdrawUsdc(usdcAmount) {
-    const acctAddr = await this.getAccountAddress();
-    const account = new Contract(acctAddr, AGENT_ACCOUNT_ABI, this.signer);
-    const amount = ethers.parseUnits(usdcAmount, 6);
-    const eoaAddr = await this.signer.getAddress();
-    const tx = await account.withdraw(this.config.contracts.usdc, amount, eoaAddr);
-    const receipt = await tx.wait();
-    return {
-      txHash: receipt.hash,
-      blockNumber: receipt.blockNumber,
-      status: receipt.status === 1 ? "success" : "failed",
-      gasUsed: receipt.gasUsed
-    };
-  }
-  async withdrawEth(ethAmount) {
-    const acctAddr = await this.getAccountAddress();
-    const account = new Contract(acctAddr, AGENT_ACCOUNT_ABI, this.signer);
-    const amount = ethers.parseEther(ethAmount);
-    const eoaAddr = await this.signer.getAddress();
-    const tx = await account.withdrawETH(amount, eoaAddr);
-    const receipt = await tx.wait();
-    return {
-      txHash: receipt.hash,
-      blockNumber: receipt.blockNumber,
-      status: receipt.status === 1 ? "success" : "failed",
-      gasUsed: receipt.gasUsed
-    };
-  }
   // 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 !== ethers.ZeroAddress;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if this agent's code is KYA-approved.
+   * Uses the ERC8004ValidationModule.isKYAApproved(account) view.
+   */
   async isKyaApproved() {
-    return this.validationRegistry.isAgentCodeApproved(this.agentId);
+    try {
+      const acctAddr = await this.getAccountAddress();
+      return this.validationModule.isKYAApproved(acctAddr);
+    } catch {
+      return false;
+    }
   }
   async identityExists() {
     try {
@@ -444,27 +497,24 @@ var MorphoClient = class {
       this._eoaAddress = wallet.address;
     }
     const addrs = { ...defaultCfg.contracts, ...config.contracts };
-    this.accountFactory = new Contract2(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this._signer);
+    this.safeAgentFactory = new Contract2(addrs.safeAgentFactory, ACCOUNT_FACTORY_ABI, this._signer);
     this.morphoBlue = new Contract2(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
     this.agentReputation = new Contract2(addrs.agentReputation, 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 account's installed hook and checks if it has a non-zero
-   * validationRegistry — when set, the hook enforces KYA code approval.
+   * Reads the ERC8004ValidationModule's validationRegistry — when set to
+   * a non-zero address, the module enforces KYA code approval.
    */
   async isKyaRequired() {
     try {
-      const acctAddr = await this.getAccountAddress();
-      const account = new Contract2(acctAddr, AGENT_ACCOUNT_ABI, this.provider);
-      const hookAddr = await account.hook();
-      if (hookAddr === ethers2.ZeroAddress) return false;
-      const hook = new Contract2(hookAddr, KYA_HOOK_ABI, this.provider);
-      const registryAddr = await hook.validationRegistry();
+      const registryAddr = await this.validationModule.validationRegistry();
       return registryAddr !== ethers2.ZeroAddress;
     } catch {
       return false;
@@ -481,7 +531,7 @@ var MorphoClient = class {
     let lastErr;
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
       try {
-        const addr = await this.accountFactory.getAccount(BigInt(this.agentId));
+        const addr = await this.safeAgentFactory.getAccount(BigInt(this.agentId));
         if (addr === ethers2.ZeroAddress) {
           throw new AgetherError("No AgentAccount found. Call register() first.", "NO_ACCOUNT");
         }
@@ -559,9 +609,9 @@ var MorphoClient = class {
   async register(_name) {
     const eoaAddr = await this.getSignerAddress();
     if (this.agentId) {
-      const exists = await this.accountFactory.accountExists(BigInt(this.agentId));
+      const exists = await this.safeAgentFactory.accountExists(BigInt(this.agentId));
       if (exists) {
-        const acct = await this.accountFactory.getAccount(BigInt(this.agentId));
+        const acct = await this.safeAgentFactory.getAccount(BigInt(this.agentId));
         this._accountAddress = acct;
         const kyaRequired2 = await this.isKyaRequired();
         return { agentId: this.agentId, address: eoaAddr, agentAccount: acct, alreadyRegistered: true, kyaRequired: kyaRequired2 };
@@ -579,15 +629,15 @@ var MorphoClient = class {
       agentId = await this._mintNewIdentity();
     }
     this.agentId = agentId.toString();
-    const acctExists = await this.accountFactory.accountExists(agentId);
+    const acctExists = await this.safeAgentFactory.accountExists(agentId);
     let txHash;
     if (!acctExists) {
-      const tx = await this.accountFactory.createAccount(agentId);
+      const tx = await this.safeAgentFactory.createAccount(agentId);
       const receipt = await tx.wait();
       this._refreshSigner();
       txHash = receipt.hash;
     }
-    const acctAddr = await this.accountFactory.getAccount(agentId);
+    const acctAddr = await this.safeAgentFactory.getAccount(agentId);
     this._accountAddress = acctAddr;
     const kyaRequired = await this.isKyaRequired();
     return {
@@ -789,7 +839,7 @@ var MorphoClient = class {
             const mkt = await this.morphoBlue.market(m.uniqueKey);
             const totalBorrowShares = BigInt(mkt.totalBorrowShares);
             const totalBorrowAssets = BigInt(mkt.totalBorrowAssets);
-            debt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
+            debt = totalBorrowShares > 0n ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares : 0n;
             totalDebt += debt;
           } catch (e) {
             console.warn(`[agether] debt calc failed for market ${m.uniqueKey}:`, e instanceof Error ? e.message : e);
@@ -851,7 +901,7 @@ var MorphoClient = class {
         const mktState = await this.morphoBlue.market(m.uniqueKey);
         const totalBorrowShares = BigInt(mktState.totalBorrowShares);
         const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
-        const currentDebt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
+        const currentDebt = totalBorrowShares > 0n ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares : 0n;
         let collateralValueInLoan;
         try {
           const oracleContract = new Contract2(m.oracle, [
@@ -1214,13 +1264,14 @@ var MorphoClient = class {
     if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const morphoAddr = this.config.contracts.morphoBlue;
+    const usdcAddr = this.config.contracts.usdc;
     const dest = receiver || await this.getSignerAddress();
     let weiAmount;
+    const markets = await this.getMarkets();
+    const market = markets.find(
+      (m) => m.collateralAsset?.address.toLowerCase() === colInfo.address.toLowerCase()
+    );
     if (amount === "all") {
-      const markets = await this.getMarkets();
-      const market = markets.find(
-        (m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase()
-      );
       if (!market) throw new AgetherError("Market not found", "MARKET_NOT_FOUND");
       const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
       weiAmount = pos.collateral;
@@ -1228,19 +1279,65 @@ var MorphoClient = class {
     } else {
       weiAmount = ethers2.parseUnits(amount, colInfo.decimals);
     }
-    const data = morphoIface.encodeFunctionData("withdrawCollateral", [
+    let hasDustDebt = false;
+    let dustBorrowShares = 0n;
+    let dustApproveAmount = 0n;
+    if (market) {
+      try {
+        const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
+        dustBorrowShares = BigInt(pos.borrowShares);
+        if (dustBorrowShares > 0n) {
+          hasDustDebt = true;
+          const onChainMkt = await this.morphoBlue.market(market.uniqueKey);
+          const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+          const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+          const estimated = totalBorrowShares > 0n ? dustBorrowShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
+          dustApproveAmount = estimated > 0n ? estimated : ethers2.parseUnits("1", 6);
+          console.log(`[agether] dust borrow shares detected: ${dustBorrowShares} shares \u2248 ${ethers2.formatUnits(dustApproveAmount, 6)} USDC \u2014 auto-repaying before withdraw`);
+        }
+      } catch (e) {
+        console.warn("[agether] failed to check borrow shares before withdraw:", e instanceof Error ? e.message : e);
+      }
+    }
+    const withdrawData = morphoIface.encodeFunctionData("withdrawCollateral", [
       this._toTuple(params),
       weiAmount,
       acctAddr,
       dest
     ]);
-    const receipt = await this.exec(morphoAddr, data);
+    let receipt;
+    if (hasDustDebt) {
+      const usdcContract = new Contract2(usdcAddr, ERC20_ABI, this._signer);
+      const acctBalance = await usdcContract.balanceOf(acctAddr);
+      if (acctBalance < dustApproveAmount) {
+        const shortfall = dustApproveAmount - acctBalance;
+        const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
+        if (eoaBalance >= shortfall) {
+          console.log(`[agether] transferring ${ethers2.formatUnits(shortfall, 6)} USDC from EOA \u2192 AgentAccount for dust repay`);
+          const transferTx = await usdcContract.transfer(acctAddr, shortfall);
+          await transferTx.wait();
+          this._refreshSigner();
+        }
+      }
+      const targets = [usdcAddr, morphoAddr, morphoAddr];
+      const values = [0n, 0n, 0n];
+      const datas = [
+        erc20Iface.encodeFunctionData("approve", [morphoAddr, dustApproveAmount]),
+        morphoIface.encodeFunctionData("repay", [
+          this._toTuple(params),
+          0n,
+          dustBorrowShares,
+          acctAddr,
+          "0x"
+        ]),
+        withdrawData
+      ];
+      receipt = await this.batch(targets, values, datas);
+    } else {
+      receipt = await this.exec(morphoAddr, withdrawData);
+    }
     let remainingCollateral = "0";
     try {
-      const markets = await this.getMarkets();
-      const market = markets.find(
-        (m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase()
-      );
       if (market) {
         const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
         remainingCollateral = ethers2.formatUnits(pos.collateral, colInfo.decimals);
@@ -1267,7 +1364,7 @@ var MorphoClient = class {
     if (target.address) {
       targetAddr = target.address;
     } else if (target.agentId) {
-      targetAddr = await this.accountFactory.getAccount(BigInt(target.agentId));
+      targetAddr = await this.safeAgentFactory.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");
@@ -1320,7 +1417,9 @@ var MorphoClient = class {
   _refreshSigner() {
     if (this._useExternalSigner) {
       const addrs = this.config.contracts;
-      this.accountFactory = new Contract2(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this._signer);
+      this.safeAgentFactory = new Contract2(addrs.safeAgentFactory, 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.agentReputation = new Contract2(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
       this.identityRegistry = new Contract2(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
     } else {
@@ -1329,57 +1428,87 @@ var MorphoClient = class {
       this._signer = wallet;
       this._eoaAddress = wallet.address;
       const addrs = this.config.contracts;
-      this.accountFactory = new Contract2(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this._signer);
+      this.safeAgentFactory = new Contract2(addrs.safeAgentFactory, 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.agentReputation = new Contract2(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
       this.identityRegistry = new Contract2(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
     }
   }
+  // ────────────────────────────────────────────────────────────
+  //  ERC-4337 UserOp helpers (Safe + Safe7579 + EntryPoint v0.7)
+  // ────────────────────────────────────────────────────────────
   /**
-   * Execute a single call via AgentAccount.execute (ERC-7579 single mode).
+   * Pack two uint128 values into a single bytes32:
+   *   bytes32 = (hi << 128) | lo
+   */
+  _packUint128(hi, lo) {
+    return ethers2.zeroPadValue(ethers2.toBeHex(hi << 128n | lo), 32);
+  }
+  /**
+   * Build, sign and submit a PackedUserOperation through EntryPoint.handleOps.
+   *
+   * @param callData – the ABI-encoded calldata for the Safe7579 account
+   *   (e.g. `execute(mode, executionCalldata)`)
+   * @returns the transaction receipt of the handleOps call
+   */
+  async _submitUserOp(callData) {
+    const sender = await this.getAccountAddress();
+    const nonce = await this.entryPoint.getNonce(sender, 0);
+    const feeData = await this.provider.getFeeData();
+    const maxFeePerGas = feeData.maxFeePerGas ?? ethers2.parseUnits("0.5", "gwei");
+    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? ethers2.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 userOp = {
+      sender,
+      nonce,
+      initCode: "0x",
+      callData,
+      accountGasLimits,
+      preVerificationGas,
+      gasFees,
+      paymasterAndData: "0x",
+      signature: "0x"
+      // placeholder — replaced after signing
+    };
+    const userOpHash = await this.entryPoint.getUserOpHash(userOp);
+    const signature = await this._signer.signMessage(ethers2.getBytes(userOpHash));
+    userOp.signature = signature;
+    const tx = await this.entryPoint.handleOps([userOp], await this.getSignerAddress());
+    const receipt = await tx.wait();
+    this._refreshSigner();
+    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 acctAddr = await this.getAccountAddress();
-    const account = new Contract2(acctAddr, AGENT_ACCOUNT_ABI, this._signer);
     const executionCalldata = ethers2.AbiCoder.defaultAbiCoder().encode(
       ["address", "uint256", "bytes"],
       [target, value, data]
     );
-    let gasLimit;
-    try {
-      const estimate = await account.execute.estimateGas(MODE_SINGLE, executionCalldata);
-      gasLimit = estimate * 130n / 100n;
-    } catch (e) {
-      console.warn("[agether] exec gas estimation failed, using default 500k:", e instanceof Error ? e.message : e);
-      gasLimit = 500000n;
-    }
-    const tx = await account.execute(MODE_SINGLE, executionCalldata, { gasLimit });
-    const receipt = await tx.wait();
-    this._refreshSigner();
-    return receipt;
+    const safe7579Iface = new ethers2.Interface(SAFE7579_ACCOUNT_ABI);
+    const callData = safe7579Iface.encodeFunctionData("execute", [MODE_SINGLE, executionCalldata]);
+    return this._submitUserOp(callData);
   }
   /**
-   * Execute multiple calls via AgentAccount.execute (ERC-7579 batch mode).
+   * Execute multiple calls via Safe7579 account (ERC-7579 batch mode)
+   * through an ERC-4337 UserOperation.
    */
   async batch(targets, values, datas) {
-    const acctAddr = await this.getAccountAddress();
-    const account = new Contract2(acctAddr, AGENT_ACCOUNT_ABI, this._signer);
     const executions = targets.map((t, i) => [t, values[i], datas[i]]);
     const executionCalldata = ethers2.AbiCoder.defaultAbiCoder().encode(
       ["(address,uint256,bytes)[]"],
       [executions]
     );
-    let gasLimit;
-    try {
-      const estimate = await account.execute.estimateGas(MODE_BATCH, executionCalldata);
-      gasLimit = estimate * 130n / 100n;
-    } catch (e) {
-      console.warn("[agether] batch gas estimation failed, using default 800k:", e instanceof Error ? e.message : e);
-      gasLimit = 800000n;
-    }
-    const tx = await account.execute(MODE_BATCH, executionCalldata, { gasLimit });
-    const receipt = await tx.wait();
-    this._refreshSigner();
-    return receipt;
+    const safe7579Iface = new ethers2.Interface(SAFE7579_ACCOUNT_ABI);
+    const callData = safe7579Iface.encodeFunctionData("execute", [MODE_BATCH, executionCalldata]);
+    return this._submitUserOp(callData);
   }
   /** Convert MorphoMarketParams to Solidity tuple. */
   _toTuple(p) {
@@ -2205,19 +2334,22 @@ function rateToBps(rate) {
 }
 export {
   ACCOUNT_FACTORY_ABI,
-  AGENT_ACCOUNT_ABI,
   AGENT_REPUTATION_ABI,
   AgentIdentityClient,
   AgentNotApprovedError,
   AgetherClient,
   AgetherError,
   ChainId,
+  ENTRYPOINT_V07_ABI,
   ERC20_ABI,
+  ERC8004_VALIDATION_MODULE_ABI,
+  HOOK_MULTIPLEXER_ABI,
   IDENTITY_REGISTRY_ABI,
   InsufficientBalanceError,
-  KYA_HOOK_ABI,
   MORPHO_BLUE_ABI,
   MorphoClient,
+  SAFE7579_ACCOUNT_ABI,
+  SAFE_AGENT_FACTORY_ABI,
   ScoringClient,
   ScoringRejectedError,
   VALIDATION_REGISTRY_ABI,