@agether/openclaw-plugin 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/openclaw-plugin",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "OpenClaw plugin for Agether — on-chain credit for AI agents",
   "main": "src/index.ts",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "dependencies": {
-    "@agether/sdk": "^1.3.0",
+    "@agether/sdk": "^1.4.0",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/src/index.ts

@@ -1,19 +1,14 @@
 /**
- * Agether OpenClaw Plugin
+ * Agether OpenClaw Plugin — thin wrapper over @agether/sdk
  *
- * Registers on-chain credit tools for AI agents.
- * Uses @agether/sdk clients under the hood.
+ * Each tool = SDK call → format result with txLink.
+ * Backend-only calls (score, compare, markets) use axios directly.
  */
 
-import { ethers } from "ethers";
 import axios from "axios";
 import {
-  ACCOUNT_FACTORY_ABI,
-  AGENT_ACCOUNT_ABI,
-  MORPHO_CREDIT_ABI,
-  ERC20_ABI,
+  MorphoCreditClient,
   X402Client,
-  getDefaultConfig,
 } from "@agether/sdk";
 
 // ─── Helpers ──────────────────────────────────────────────
@@ -21,23 +16,32 @@ import {
 interface PluginConfig {
   privateKey: string;
   agentId?: string;
-  rpcUrl?: string;
-  backendUrl?: string;
+  rpcUrl: string;
+  backendUrl: string;
   autoDraw?: boolean;
 }
 
-const ERC8004_ABI = [
-  "function register(string agentURI) returns (uint256)",
-  "function ownerOf(uint256 tokenId) view returns (address)",
-  "function balanceOf(address owner) view returns (uint256)",
-  "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)",
-];
+const BASESCAN = "https://basescan.org/tx";
+function txLink(hash: string): string {
+  return hash ? `${BASESCAN}/${hash}` : "";
+}
+
+function ok(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
 
-const COLLATERAL_TOKENS: Record<string, { address: string; decimals: number }> = {
-  WETH: { address: "0x4200000000000000000000000000000000000006", decimals: 18 },
-  wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", decimals: 18 },
-  cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", decimals: 18 },
-};
+function fail(err: unknown) {
+  let msg = err instanceof Error ? err.message : String(err);
+  if (msg.includes("0xda04aecc")) {
+    msg = "ExceedsMaxLtv — collateral too low for this borrow amount (max 80% LTV / 125% collateral ratio)";
+  } else if (msg.includes("0xfeca99cb")) {
+    msg = "ExecutionFailed — the inner contract call reverted. Likely ExceedsMaxLtv or insufficient collateral.";
+  } else if (msg.includes("0xa920ef9f")) {
+    msg = "PositionNotActive — no collateral deposited for this token";
+  }
+  if (msg.length > 300) msg = msg.slice(0, 250) + "…";
+  return { content: [{ type: "text" as const, text: `❌ ${msg}` }], isError: true };
+}
 
 function getConfig(api: any): PluginConfig {
   const cfg = api.config?.plugins?.entries?.agether?.config;
@@ -53,47 +57,23 @@ function getConfig(api: any): PluginConfig {
   };
 }
 
-function getSigner(cfg: PluginConfig) {
-  const provider = new ethers.JsonRpcProvider(cfg.rpcUrl);
-  return new ethers.Wallet(cfg.privateKey, provider);
-}
-
 async function getBackendStatus(cfg: PluginConfig) {
   const { data } = await axios.get(`${cfg.backendUrl}/status`);
   return data;
 }
 
-async function getAccountAddr(signer: ethers.Wallet, factoryAddr: string, agentId: string) {
-  const factory = new ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI, signer);
-  const addr = await factory.getAccount(agentId);
-  if (addr === ethers.ZeroAddress) throw new Error("No AgentAccount. Register first.");
-  return addr;
-}
-
-// ─── Auto-resolve agentId from chain ──────────────────────
-let _cachedAgentId: string | null = null;
-
-async function resolveAgentId(cfg: PluginConfig, signer: ethers.Wallet, status: any): Promise<string> {
-  // 1. Config takes priority
-  if (cfg.agentId && cfg.agentId !== "0") return cfg.agentId;
-  // 2. Session cache
-  if (_cachedAgentId) return _cachedAgentId;
-  // 3. Look up on-chain: does this wallet own any ERC-8004 token?
-  const agentRegistry = new ethers.Contract(status.contracts.agentRegistry, ERC8004_ABI, signer.provider!);
-  const balance: bigint = await agentRegistry.balanceOf(signer.address);
-  if (balance === 0n) throw new Error("No agent registered. Use agether_register first.");
-  const tokenId: bigint = await agentRegistry.tokenOfOwnerByIndex(signer.address, 0);
-  _cachedAgentId = tokenId.toString();
-  return _cachedAgentId;
-}
-
-function ok(text: string) {
-  return { content: [{ type: "text" as const, text }] };
-}
-
-function fail(err: unknown) {
-  const msg = err instanceof Error ? err.message : String(err);
-  return { content: [{ type: "text" as const, text: `❌ ${msg}` }], isError: true };
+function createClient(cfg: PluginConfig, status: any): MorphoCreditClient {
+  return new MorphoCreditClient({
+    privateKey: cfg.privateKey,
+    rpcUrl: cfg.rpcUrl,
+    agentId: cfg.agentId,
+    contracts: {
+      morphoCredit: status.contracts.morphoCredit,
+      accountFactory: status.contracts.accountFactory,
+      usdc: status.contracts.usdc,
+      agentRegistry: status.contracts.agentRegistry,
+    },
+  });
 }
 
 // ─── Plugin Entry ─────────────────────────────────────────
@@ -110,38 +90,9 @@ export default function register(api: any) {
     async execute() {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const address = signer.address;
-
-        const provider = signer.provider!;
-        const ethBal = await provider.getBalance(address);
-        const usdc = new ethers.Contract(status.contracts.usdc, ERC20_ABI, provider);
-        const usdcBal = await usdc.balanceOf(address);
-
-        const result: any = {
-          address,
-          agentId: cfg.agentId || _cachedAgentId || "not registered",
-          eth: ethers.formatEther(ethBal),
-          usdc: ethers.formatUnits(usdcBal, 6),
-        };
-
-        // AgentAccount balances — try to auto-resolve agentId
-        try {
-          const agentId = await resolveAgentId(cfg, signer, status);
-          result.agentId = agentId;
-          if (status.contracts.accountFactory) {
-            const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-            const accEth = await provider.getBalance(accountAddr);
-            const accUsdc = await usdc.balanceOf(accountAddr);
-            result.agentAccount = {
-              address: accountAddr,
-              eth: ethers.formatEther(accEth),
-              usdc: ethers.formatUnits(accUsdc, 6),
-            };
-          }
-        } catch { /* no agent registered yet */ }
-
+        const client = createClient(cfg, status);
+        const result = await client.getBalances();
         return ok(JSON.stringify(result, null, 2));
       } catch (e) { return fail(e); }
     },
@@ -153,7 +104,7 @@ export default function register(api: any) {
   api.registerTool({
     name: "agether_register",
     description:
-      "Register a new ERC-8004 agent identity on Base and create an AgentAccount. Returns the new agentId. If agentId is already configured, returns the existing one.",
+      "Register a new ERC-8004 agent identity on Base and create an AgentAccount. Returns the new agentId.",
     parameters: {
       type: "object",
       properties: {
@@ -164,82 +115,15 @@ export default function register(api: any) {
     async execute(_id: string, params: { name: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-
-        const agentRegistry = new ethers.Contract(status.contracts.agentRegistry, ERC8004_ABI, signer);
-
-        let agentId: bigint;
-
-        // If agentId already set, verify and use
-        if (cfg.agentId && cfg.agentId !== "0") {
-          agentId = BigInt(cfg.agentId);
-          const owner = await agentRegistry.ownerOf(agentId);
-          if (owner.toLowerCase() !== signer.address.toLowerCase()) {
-            return fail("agentId in config does not belong to this wallet");
-          }
-          // Ensure AgentAccount exists
-          if (status.contracts.accountFactory) {
-            const factory = new ethers.Contract(status.contracts.accountFactory, ACCOUNT_FACTORY_ABI, signer);
-            const exists = await factory.accountExists(agentId);
-            if (!exists) {
-              const tx = await factory.createAccount(agentId);
-              await tx.wait();
-            }
-          }
-          return ok(JSON.stringify({
-            status: "already_registered",
-            agentId: agentId.toString(),
-            address: signer.address,
-          }));
-        }
-
-        // Mint new ERC-8004 identity
-        const registrationFile = JSON.stringify({
-          type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
-          name: params.name,
-          description: "AI agent registered via Agether OpenClaw plugin",
-          active: true,
-          registrations: [{
-            agentId: 0,
-            agentRegistry: `eip155:${status.chainId}:${status.contracts.agentRegistry}`,
-          }],
-        });
-        const agentURI = `data:application/json;base64,${Buffer.from(registrationFile).toString("base64")}`;
-
-        const tx = await agentRegistry["register(string)"](agentURI);
-        const receipt = await tx.wait();
-
-        // Parse agentId from Transfer event
-        const transferTopic = ethers.id("Transfer(address,address,uint256)");
-        const transferLog = receipt.logs.find((l: any) => l.topics[0] === transferTopic);
-        if (transferLog?.topics?.length >= 4) {
-          agentId = BigInt(transferLog.topics[3]);
-        } else {
-          return fail("Could not parse agentId from receipt");
-        }
-
-        // Create AgentAccount
-        let accountAddr = "";
-        if (status.contracts.accountFactory) {
-          const factory = new ethers.Contract(status.contracts.accountFactory, ACCOUNT_FACTORY_ABI, signer);
-          const exists = await factory.accountExists(agentId);
-          if (!exists) {
-            const accTx = await factory.createAccount(agentId);
-            await accTx.wait();
-          }
-          accountAddr = await factory.getAccount(agentId);
-        }
-
-        // Cache agentId for the session so all subsequent tools work
-        _cachedAgentId = agentId.toString();
-
+        const client = createClient(cfg, status);
+        const result = await client.register(params.name);
         return ok(JSON.stringify({
-          status: "registered",
-          agentId: agentId.toString(),
-          address: signer.address,
-          agentAccount: accountAddr,
-          tx: tx.hash,
+          status: result.alreadyRegistered ? "already_registered" : "registered",
+          agentId: result.agentId,
+          address: result.address,
+          agentAccount: result.agentAccount,
+          tx: result.tx ? txLink(result.tx) : undefined,
         }));
       } catch (e) { return fail(e); }
     },
@@ -256,33 +140,10 @@ export default function register(api: any) {
     async execute() {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const morpho = new ethers.Contract(status.contracts.morphoCredit, MORPHO_CREDIT_ABI, signer.provider!);
-
-        const positions: any[] = [];
-        for (const [symbol, info] of Object.entries(COLLATERAL_TOKENS)) {
-          const pos = await morpho.getPosition(accountAddr, info.address);
-          if (pos.isActive || pos.collateralAmount > 0n || pos.borrowedAmount > 0n) {
-            positions.push({
-              token: symbol,
-              collateral: ethers.formatUnits(pos.collateralAmount, info.decimals),
-              debt: `$${ethers.formatUnits(pos.borrowedAmount, 6)}`,
-              active: pos.isActive,
-            });
-          }
-        }
-
-        const totalDebt = await morpho.getTotalDebt(accountAddr);
-
-        return ok(JSON.stringify({
-          agentAccount: accountAddr,
-          totalDebt: `$${ethers.formatUnits(totalDebt, 6)}`,
-          positions: positions.length > 0 ? positions : "No active positions",
-        }, null, 2));
+        const client = createClient(cfg, status);
+        const result = await client.getStatus();
+        return ok(JSON.stringify(result, null, 2));
       } catch (e) { return fail(e); }
     },
   });
@@ -305,55 +166,22 @@ export default function register(api: any) {
     async execute(_id: string, params: { amount: string; token: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const tokenInfo = COLLATERAL_TOKENS[params.token];
-        if (!tokenInfo) return fail(`Unsupported token: ${params.token}. Use WETH, wstETH, or cbETH`);
-
-        const morphoCreditAddr = status.contracts.morphoCredit;
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const amount = ethers.parseUnits(params.amount, tokenInfo.decimals);
-
-        // Check balance
-        const token = new ethers.Contract(tokenInfo.address, ERC20_ABI, signer);
-        const balance = await token.balanceOf(signer.address);
-        if (balance < amount) {
-          return fail(`Insufficient ${params.token}: have ${ethers.formatUnits(balance, tokenInfo.decimals)}, need ${params.amount}`);
-        }
-
-        // Approve
-        const approveTx = await token.approve(morphoCreditAddr, amount);
-        await approveTx.wait();
-
-        // Deposit for AgentAccount
-        const morpho = new ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer);
-        const depositTx = await morpho.depositCollateralFor(accountAddr, tokenInfo.address, amount);
-        await depositTx.wait();
-
-        // Approve credit provider on AgentAccount
-        const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-        try {
-          const cpTx = await account.approveCreditProvider(morphoCreditAddr);
-          await cpTx.wait();
-        } catch { /* already approved */ }
-
-        const pos = await morpho.getPosition(accountAddr, tokenInfo.address);
-
+        const client = createClient(cfg, status);
+        const result = await client.deposit(params.token, params.amount);
         return ok(JSON.stringify({
           status: "deposited",
           amount: `${params.amount} ${params.token}`,
-          totalCollateral: `${ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${params.token}`,
-          agentAccount: accountAddr,
-          tx: depositTx.hash,
+          totalCollateral: result.totalCollateral.toString(),
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
         }));
       } catch (e) { return fail(e); }
     },
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_deposit_and_borrow  (Flow 2)
+  //  TOOL: morpho_deposit_and_borrow
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "morpho_deposit_and_borrow",
@@ -371,66 +199,24 @@ export default function register(api: any) {
     async execute(_id: string, params: { collateralAmount: string; token: string; borrowAmount: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const tokenInfo = COLLATERAL_TOKENS[params.token];
-        if (!tokenInfo) return fail(`Unsupported token: ${params.token}`);
-
-        const morphoCreditAddr = status.contracts.morphoCredit;
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const collateralWei = ethers.parseUnits(params.collateralAmount, tokenInfo.decimals);
-        const borrowWei = ethers.parseUnits(params.borrowAmount, 6);
-
-        // Check collateral balance
-        const token = new ethers.Contract(tokenInfo.address, ERC20_ABI, signer);
-        const balance = await token.balanceOf(signer.address);
-        if (balance < collateralWei) {
-          return fail(`Insufficient ${params.token}: have ${ethers.formatUnits(balance, tokenInfo.decimals)}, need ${params.collateralAmount}`);
-        }
-
-        // Step 1: Approve collateral
-        const approveTx = await token.approve(morphoCreditAddr, collateralWei);
-        await approveTx.wait();
-
-        // Step 2: Deposit collateral for AgentAccount
-        const morpho = new ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer);
-        const depositTx = await morpho.depositCollateralFor(accountAddr, tokenInfo.address, collateralWei);
-        await depositTx.wait();
-
-        // Step 3: Approve credit provider on AgentAccount
-        const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-        try {
-          const cpTx = await account.approveCreditProvider(morphoCreditAddr);
-          await cpTx.wait();
-        } catch { /* already approved */ }
-
-        // Step 4: Borrow via AgentAccount.execute → drawWithCollateral
-        const morphoIface = new ethers.Interface(MORPHO_CREDIT_ABI);
-        const borrowCalldata = morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
-        const borrowTx = await account.execute(morphoCreditAddr, 0, borrowCalldata);
-        await borrowTx.wait();
-
-        const pos = await morpho.getPosition(accountAddr, tokenInfo.address);
-        const totalDebt = await morpho.getTotalDebt(accountAddr);
-
+        const client = createClient(cfg, status);
+        const result = await client.depositAndBorrow(params.token, params.collateralAmount, params.borrowAmount);
         return ok(JSON.stringify({
           status: "deposited_and_borrowed",
           collateral: `${params.collateralAmount} ${params.token}`,
           borrowed: `$${params.borrowAmount}`,
-          totalCollateral: `${ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${params.token}`,
-          totalDebt: `$${ethers.formatUnits(totalDebt, 6)}`,
-          agentAccount: accountAddr,
-          depositTx: depositTx.hash,
-          borrowTx: borrowTx.hash,
+          totalDebt: result.totalDebt.toString(),
+          agentAccount: result.agentAccount,
+          depositTx: txLink(result.depositTx),
+          borrowTx: txLink(result.borrowTx),
         }));
       } catch (e) { return fail(e); }
     },
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_sponsor  (Flows 4-7: Human sponsors agent)
+  //  TOOL: morpho_sponsor
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "morpho_sponsor",
@@ -443,88 +229,31 @@ export default function register(api: any) {
         agentAddress: { type: "string", description: "Target AgentAccount address (alternative to agentId)" },
         amount: { type: "string", description: "Collateral amount (e.g. '0.05')" },
         token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
-        borrow: { type: "string", description: "Optional: USDC amount to borrow for the agent (e.g. '50'). Only works if caller owns the AgentAccount." },
+        borrow: { type: "string", description: "Optional: USDC amount to borrow for the agent" },
       },
       required: ["amount", "token"],
     },
     async execute(_id: string, params: { agentId?: string; agentAddress?: string; amount: string; token: string; borrow?: string }) {
       try {
+        if (!params.agentId && !params.agentAddress) return fail("Provide either agentId or agentAddress");
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
+        const client = createClient(cfg, status);
 
-        if (!params.agentId && !params.agentAddress) {
-          return fail("Provide either agentId or agentAddress");
-        }
-
-        const tokenInfo = COLLATERAL_TOKENS[params.token];
-        if (!tokenInfo) return fail(`Unsupported token: ${params.token}`);
-
-        const morphoCreditAddr = status.contracts.morphoCredit;
-        let accountAddr: string;
-
-        // Resolve target AgentAccount
-        if (params.agentAddress) {
-          accountAddr = params.agentAddress;
-        } else {
-          const factory = new ethers.Contract(status.contracts.accountFactory, ACCOUNT_FACTORY_ABI, signer);
-          accountAddr = await factory.getAccount(params.agentId!);
-          if (accountAddr === ethers.ZeroAddress) {
-            return fail(`No AgentAccount for agent #${params.agentId}`);
-          }
-        }
-
-        const collateralWei = ethers.parseUnits(params.amount, tokenInfo.decimals);
-
-        // Check sponsor's balance
-        const token = new ethers.Contract(tokenInfo.address, ERC20_ABI, signer);
-        const balance = await token.balanceOf(signer.address);
-        if (balance < collateralWei) {
-          return fail(`Insufficient ${params.token}: have ${ethers.formatUnits(balance, tokenInfo.decimals)}, need ${params.amount}`);
-        }
-
-        // Approve + deposit for target
-        const approveTx = await token.approve(morphoCreditAddr, collateralWei);
-        await approveTx.wait();
-
-        const morpho = new ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer);
-        const depositTx = await morpho.depositCollateralFor(accountAddr, tokenInfo.address, collateralWei);
-        await depositTx.wait();
+        const target = params.agentId
+          ? { agentId: params.agentId }
+          : { address: params.agentAddress! };
 
-        const result: any = {
+        const result = await client.sponsor(target, params.token, params.amount, params.borrow);
+        return ok(JSON.stringify({
           status: "sponsored",
-          target: accountAddr,
-          targetAgentId: params.agentId || "by address",
+          target: result.targetAccount,
+          targetAgentId: result.targetAgentId || "by address",
           collateral: `${params.amount} ${params.token}`,
-          depositTx: depositTx.hash,
-        };
-
-        // Optional: borrow for the agent (only works if caller owns the AgentAccount)
-        if (params.borrow) {
-          try {
-            const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-            try {
-              const cpTx = await account.approveCreditProvider(morphoCreditAddr);
-              await cpTx.wait();
-            } catch { /* already approved or not owner */ }
-
-            const borrowWei = ethers.parseUnits(params.borrow, 6);
-            const morphoIface = new ethers.Interface(MORPHO_CREDIT_ABI);
-            const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
-            const borrowTx = await account.execute(morphoCreditAddr, 0, calldata);
-            await borrowTx.wait();
-            result.borrowed = `$${params.borrow}`;
-            result.borrowTx = borrowTx.hash;
-          } catch (e: any) {
-            result.borrowError = `Borrow failed (caller may not own this AgentAccount): ${e.message}`;
-          }
-        }
-
-        const pos = await morpho.getPosition(accountAddr, tokenInfo.address);
-        result.totalCollateral = `${ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${params.token}`;
-        result.totalDebt = `$${ethers.formatUnits(pos.borrowedAmount, 6)}`;
-
-        return ok(JSON.stringify(result));
+          borrowed: result.borrowed ? `$${params.borrow}` : undefined,
+          depositTx: txLink(result.depositTx),
+          borrowTx: result.borrowTx ? txLink(result.borrowTx) : undefined,
+        }));
       } catch (e) { return fail(e); }
     },
   });
@@ -546,45 +275,16 @@ export default function register(api: any) {
     async execute(_id: string, params: { amount: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const morpho = new ethers.Contract(status.contracts.morphoCredit, MORPHO_CREDIT_ABI, signer.provider!);
-
-        // Find active collateral
-        let activeToken: string | null = null;
-        for (const [symbol, info] of Object.entries(COLLATERAL_TOKENS)) {
-          const pos = await morpho.getPosition(accountAddr, info.address);
-          if (pos.collateralAmount > 0n) { activeToken = symbol; break; }
-        }
-        if (!activeToken) return fail("No collateral deposited. Use morpho_deposit first.");
-
-        const collateralAddr = COLLATERAL_TOKENS[activeToken].address;
-        const amountWei = ethers.parseUnits(params.amount, 6);
-
-        // Borrow via AgentAccount.execute → drawWithCollateral
-        const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-
-        // Ensure credit provider approved (one-time, idempotent)
-        try { const cpTx = await account.approveCreditProvider(status.contracts.morphoCredit); await cpTx.wait(); } catch { /* already approved */ }
-
-        const morphoIface = new ethers.Interface(MORPHO_CREDIT_ABI);
-        const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, amountWei]);
-
-        const tx = await account.execute(status.contracts.morphoCredit, 0, calldata);
-        await tx.wait();
-
-        const totalDebt = await morpho.getTotalDebt(accountAddr);
-
+        const client = createClient(cfg, status);
+        const result = await client.borrow(params.amount);
         return ok(JSON.stringify({
           status: "borrowed",
           amount: `$${params.amount}`,
-          collateral: activeToken,
-          totalDebt: `$${ethers.formatUnits(totalDebt, 6)}`,
-          agentAccount: accountAddr,
-          tx: tx.hash,
+          collateral: result.collateralToken,
+          totalDebt: result.totalDebt.toString(),
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
         }));
       } catch (e) { return fail(e); }
     },
@@ -607,53 +307,14 @@ export default function register(api: any) {
     async execute(_id: string, params: { amount: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const morpho = new ethers.Contract(status.contracts.morphoCredit, MORPHO_CREDIT_ABI, signer.provider!);
-
-        // Find active collateral with debt
-        let activeToken: string | null = null;
-        for (const [symbol, info] of Object.entries(COLLATERAL_TOKENS)) {
-          const pos = await morpho.getPosition(accountAddr, info.address);
-          if (pos.borrowedAmount > 0n) { activeToken = symbol; break; }
-        }
-        if (!activeToken) return fail("No Morpho debt to repay");
-
-        const collateralAddr = COLLATERAL_TOKENS[activeToken].address;
-        const amountWei = ethers.parseUnits(params.amount, 6);
-
-        // Check USDC in AgentAccount
-        const usdc = new ethers.Contract(status.contracts.usdc, ERC20_ABI, signer.provider!);
-        const accBalance = await usdc.balanceOf(accountAddr);
-        if (accBalance < amountWei) {
-          return fail(`Insufficient USDC in AgentAccount: have $${ethers.formatUnits(accBalance, 6)}, need $${params.amount}`);
-        }
-
-        const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-        const morphoIface = new ethers.Interface(MORPHO_CREDIT_ABI);
-        const erc20Iface = new ethers.Interface(ERC20_ABI);
-
-        // Single tx via executeBatch: approve USDC + repayWithCollateral
-        const tx = await account.executeBatch(
-          [status.contracts.usdc, status.contracts.morphoCredit],
-          [0, 0],
-          [
-            erc20Iface.encodeFunctionData("approve", [status.contracts.morphoCredit, amountWei]),
-            morphoIface.encodeFunctionData("repayWithCollateral", [collateralAddr, amountWei]),
-          ],
-        );
-        await tx.wait();
-
-        const totalDebt = await morpho.getTotalDebt(accountAddr);
-
+        const client = createClient(cfg, status);
+        const result = await client.repay(params.amount);
         return ok(JSON.stringify({
           status: "repaid",
           amount: `$${params.amount}`,
-          remainingDebt: `$${ethers.formatUnits(totalDebt, 6)}`,
-          tx: tx.hash,
+          remainingDebt: result.remainingDebt.toString(),
+          tx: txLink(result.tx),
         }));
       } catch (e) { return fail(e); }
     },
@@ -677,56 +338,23 @@ export default function register(api: any) {
     async execute(_id: string, params: { amount: string; token: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const tokenInfo = COLLATERAL_TOKENS[params.token];
-        if (!tokenInfo) return fail(`Unsupported token: ${params.token}`);
-
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const morpho = new ethers.Contract(status.contracts.morphoCredit, MORPHO_CREDIT_ABI, signer.provider!);
-        const pos = await morpho.getPosition(accountAddr, tokenInfo.address);
-
-        if (pos.collateralAmount === 0n) return fail(`No ${params.token} collateral deposited`);
-
-        const withdrawAmount = params.amount.toLowerCase() === "all" ? pos.collateralAmount : ethers.parseUnits(params.amount, tokenInfo.decimals);
-
-        if (withdrawAmount > pos.collateralAmount) {
-          return fail(`Cannot withdraw more than deposited: max ${ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${params.token}`);
-        }
-
-        const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-        const morphoIface = new ethers.Interface(MORPHO_CREDIT_ABI);
-        const erc20Iface = new ethers.Interface(ERC20_ABI);
-
-        // Single tx via executeBatch: withdrawCollateral + transfer to EOA
-        const tx = await account.executeBatch(
-          [status.contracts.morphoCredit, tokenInfo.address],
-          [0, 0],
-          [
-            morphoIface.encodeFunctionData("withdrawCollateral", [tokenInfo.address, withdrawAmount]),
-            erc20Iface.encodeFunctionData("transfer", [signer.address, withdrawAmount]),
-          ],
-        );
-        await tx.wait();
-
-        const newPos = await morpho.getPosition(accountAddr, tokenInfo.address);
-
+        const client = createClient(cfg, status);
+        const result = await client.withdraw(params.token, params.amount);
         return ok(JSON.stringify({
           status: "withdrawn",
-          amount: `${ethers.formatUnits(withdrawAmount, tokenInfo.decimals)} ${params.token}`,
-          remainingCollateral: `${ethers.formatUnits(newPos.collateralAmount, tokenInfo.decimals)} ${params.token}`,
-          remainingDebt: `$${ethers.formatUnits(newPos.borrowedAmount, 6)}`,
-          destination: signer.address,
-          tx: tx.hash,
+          amount: result.amount.toString(),
+          token: result.token,
+          remainingCollateral: result.remainingCollateral.toString(),
+          destination: result.destination,
+          tx: txLink(result.tx),
         }));
       } catch (e) { return fail(e); }
     },
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_compare
+  //  TOOL: morpho_compare  (backend API)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "morpho_compare",
@@ -743,27 +371,20 @@ export default function register(api: any) {
       try {
         const cfg = getConfig(api);
         const { data } = await axios.get(`${cfg.backendUrl}/morpho/estimate/${params.amount}`);
-        const signer = getSigner(cfg);
-
-        // Get wallet balances
-        const balances: Record<string, string> = {};
-        for (const [symbol, info] of Object.entries(COLLATERAL_TOKENS)) {
-          const token = new ethers.Contract(info.address, ERC20_ABI, signer.provider!);
-          const bal = await token.balanceOf(signer.address);
-          balances[symbol] = ethers.formatUnits(bal, info.decimals);
-        }
-
+        const status = await getBackendStatus(cfg);
+        const client = createClient(cfg, status);
+        const balances = await client.getBalances();
         return ok(JSON.stringify({
           borrowAmount: `$${params.amount}`,
           estimates: data,
-          walletBalances: balances,
+          walletBalances: { eth: balances.eth, usdc: balances.usdc },
         }, null, 2));
       } catch (e) { return fail(e); }
     },
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_markets
+  //  TOOL: morpho_markets  (backend API)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "morpho_markets",
@@ -779,7 +400,7 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: agether_score
+  //  TOOL: agether_score  (backend API)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "agether_score",
@@ -788,9 +409,9 @@ export default function register(api: any) {
     async execute() {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
+        const client = createClient(cfg, status);
+        const agentId = await client.getAgentId();
         const { data } = await axios.get(`${cfg.backendUrl}/credit/score/${agentId}`);
         return ok(JSON.stringify(data, null, 2));
       } catch (e) { return fail(e); }
@@ -813,97 +434,66 @@ export default function register(api: any) {
     async execute(_id: string, params: { amount: string }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const amountWei = ethers.parseUnits(params.amount, 6);
-
-        const usdc = new ethers.Contract(status.contracts.usdc, ERC20_ABI, signer);
-        const balance = await usdc.balanceOf(signer.address);
-        if (balance < amountWei) {
-          return fail(`Insufficient USDC: have $${ethers.formatUnits(balance, 6)}, need $${params.amount}`);
-        }
-
-        const tx = await usdc.transfer(accountAddr, amountWei);
-        await tx.wait();
-
+        const client = createClient(cfg, status);
+        const result = await client.fundAccount(params.amount);
         return ok(JSON.stringify({
           status: "funded",
           amount: `$${params.amount}`,
-          agentAccount: accountAddr,
-          tx: tx.hash,
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
         }));
       } catch (e) { return fail(e); }
     },
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: x402_pay  (Flows 8 & 9 — uses SDK X402Client)
+  //  TOOL: x402_pay
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "x402_pay",
     description:
       "Make a paid API call using x402 protocol. Pays with USDC from AgentAccount via EIP-3009 signature. " +
-      "If autoDraw is enabled in config (or --auto-draw param is true), automatically borrows USDC from Morpho " +
-      "credit line when AgentAccount balance is insufficient.",
+      "If autoDraw is enabled, automatically borrows USDC from Morpho credit line when balance is insufficient.",
     parameters: {
       type: "object",
       properties: {
         url: { type: "string", description: "API endpoint URL" },
         method: { type: "string", enum: ["GET", "POST"], description: "HTTP method (default: GET)" },
         body: { type: "string", description: "JSON body for POST requests" },
-        autoDraw: { type: "boolean", description: "Auto-borrow from Morpho if USDC insufficient (default: uses config autoDraw setting)" },
+        autoDraw: { type: "boolean", description: "Auto-borrow from Morpho if USDC insufficient" },
       },
       required: ["url"],
     },
     async execute(_id: string, params: { url: string; method?: string; body?: string; autoDraw?: boolean }) {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
+        const client = createClient(cfg, status);
 
-        // Resolve AgentAccount address for x402 payments
         let accountAddress: string | undefined;
         let agentId: string | undefined;
         try {
-          agentId = await resolveAgentId(cfg, signer, status);
-          accountAddress = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
+          agentId = await client.getAgentId();
+          accountAddress = await client.getAccountAddress();
         } catch { /* no account, pay from EOA */ }
 
-        // Auto-draw: if enabled, check USDC balance and borrow if needed
+        // Auto-draw: borrow $10 if balance < $1
         const shouldAutoDraw = params.autoDraw ?? cfg.autoDraw;
-        if (shouldAutoDraw && accountAddress && agentId) {
-          const usdc = new ethers.Contract(status.contracts.usdc, ERC20_ABI, signer.provider!);
-          const accBalance = await usdc.balanceOf(accountAddress);
-          // If balance < $1, try to auto-borrow $10 (enough for several x402 calls)
-          if (accBalance < ethers.parseUnits("1", 6)) {
-            try {
-              const morpho = new ethers.Contract(status.contracts.morphoCredit, MORPHO_CREDIT_ABI, signer.provider!);
-              let collateralAddr: string | null = null;
-              for (const [, info] of Object.entries(COLLATERAL_TOKENS)) {
-                const pos = await morpho.getPosition(accountAddress, info.address);
-                if (pos.collateralAmount > 0n) { collateralAddr = info.address; break; }
-              }
-              if (collateralAddr) {
-                const account = new ethers.Contract(accountAddress, AGENT_ACCOUNT_ABI, signer);
-                const morphoIface = new ethers.Interface(MORPHO_CREDIT_ABI);
-                const drawAmount = ethers.parseUnits("10", 6); // $10 auto-draw
-                const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, drawAmount]);
-                const tx = await account.execute(status.contracts.morphoCredit, 0, calldata);
-                await tx.wait();
-              }
-            } catch { /* auto-draw failed — proceed anyway, x402 might still work from EOA */ }
-          }
+        if (shouldAutoDraw && accountAddress) {
+          try {
+            const accUsdc = await client.getAccountUSDC();
+            if (accUsdc < 1_000_000n) {
+              await client.borrow("10");
+            }
+          } catch { /* auto-draw failed, proceed anyway */ }
         }
 
-        // Use SDK's X402Client directly (no execSync)
         const x402 = new X402Client({
           privateKey: cfg.privateKey,
-          rpcUrl: cfg.rpcUrl!,
-          backendUrl: cfg.backendUrl!,
-          agentId: agentId,
+          rpcUrl: cfg.rpcUrl,
+          backendUrl: cfg.backendUrl,
+          agentId,
           accountAddress,
         });
 
@@ -914,13 +504,14 @@ export default function register(api: any) {
           result = await x402.get(params.url);
         }
 
-        if (!result.success) {
-          return fail(result.error || "x402 payment failed");
-        }
+        if (!result.success) return fail(result.error || "x402 payment failed");
 
         const response: any = { status: "paid", data: result.data };
         if (result.paymentInfo) {
-          response.payment = result.paymentInfo;
+          response.payment = {
+            ...result.paymentInfo,
+            tx: result.paymentInfo.txHash ? txLink(result.paymentInfo.txHash) : undefined,
+          };
         }
         return ok(JSON.stringify(response, null, 2));
       } catch (e) { return fail(e); }
@@ -928,7 +519,7 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  AUTO-REPLY COMMANDS (no AI needed)
+  //  SLASH COMMANDS (no AI needed)
   // ═══════════════════════════════════════════════════════
 
   api.registerCommand({
@@ -937,29 +528,17 @@ export default function register(api: any) {
     handler: async () => {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
-        const provider = signer.provider!;
-        const ethBal = await provider.getBalance(signer.address);
         const status = await getBackendStatus(cfg);
-        const usdc = new ethers.Contract(status.contracts.usdc, ERC20_ABI, provider);
-        const usdcBal = await usdc.balanceOf(signer.address);
-
-        let agentId: string | undefined;
-        try { agentId = await resolveAgentId(cfg, signer, status); } catch {}
-
-        let text = `💰 Agent #${agentId || "?"}\n`;
-        text += `Address: ${signer.address}\n`;
-        text += `ETH: ${parseFloat(ethers.formatEther(ethBal)).toFixed(6)}\n`;
-        text += `USDC: $${ethers.formatUnits(usdcBal, 6)}`;
-
-        if (agentId && status.contracts.accountFactory) {
-          try {
-            const accAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-            const accUsdc = await usdc.balanceOf(accAddr);
-            text += `\n\n🏦 AgentAccount: ${accAddr}\nUSDC: $${ethers.formatUnits(accUsdc, 6)}`;
-          } catch { /* no account */ }
+        const client = createClient(cfg, status);
+        const b = await client.getBalances();
+
+        let text = `💰 Agent #${b.agentId}\n`;
+        text += `Address: ${b.address}\n`;
+        text += `ETH: ${parseFloat(b.eth).toFixed(6)}\n`;
+        text += `USDC: $${b.usdc}`;
+        if (b.agentAccount) {
+          text += `\n\n🏦 AgentAccount: ${b.agentAccount.address}\nUSDC: $${b.agentAccount.usdc}`;
         }
-
         return { text };
       } catch (e: any) {
         return { text: `❌ ${e.message}` };
@@ -973,23 +552,14 @@ export default function register(api: any) {
     handler: async () => {
       try {
         const cfg = getConfig(api);
-        const signer = getSigner(cfg);
         const status = await getBackendStatus(cfg);
-        const agentId = await resolveAgentId(cfg, signer, status);
-
-        const accountAddr = await getAccountAddr(signer, status.contracts.accountFactory, agentId);
-        const morpho = new ethers.Contract(status.contracts.morphoCredit, MORPHO_CREDIT_ABI, signer.provider!);
-        const totalDebt = await morpho.getTotalDebt(accountAddr);
+        const client = createClient(cfg, status);
+        const s = await client.getStatus();
 
-        let text = `📊 Morpho — Agent #${agentId}\nAccount: ${accountAddr}\nTotal debt: $${ethers.formatUnits(totalDebt, 6)}\n`;
-
-        for (const [symbol, info] of Object.entries(COLLATERAL_TOKENS)) {
-          const pos = await morpho.getPosition(accountAddr, info.address);
-          if (pos.collateralAmount > 0n || pos.borrowedAmount > 0n) {
-            text += `\n${symbol}: ${ethers.formatUnits(pos.collateralAmount, info.decimals)} collateral, $${ethers.formatUnits(pos.borrowedAmount, 6)} debt`;
-          }
+        let text = `📊 Morpho\nAccount: ${s.agentAccount}\nTotal debt: ${s.totalDebt}\n`;
+        for (const p of s.positions) {
+          text += `\n${p.token}: ${p.collateral} collateral, ${p.debt} debt`;
         }
-
         return { text };
       } catch (e: any) {
         return { text: `❌ ${e.message}` };