@agether/openclaw-plugin 1.0.1 → 1.1.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agether",
   "name": "Agether Credit",
   "description": "On-chain credit protocol for AI agents — Morpho-backed overcollateralized credit, ERC-8004 identity, x402 payments",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "skills": ["skills/agether"],
   "configSchema": {
     "type": "object",
@@ -25,6 +25,11 @@
         "type": "string",
         "description": "Agether backend URL",
         "default": "http://95.179.189.214:3001"
+      },
+      "autoDraw": {
+        "type": "boolean",
+        "description": "Auto-borrow from Morpho credit line when USDC balance is low for x402 payments",
+        "default": false
       }
     },
     "required": ["privateKey"]
@@ -33,6 +38,7 @@
     "privateKey": { "label": "Private Key", "sensitive": true },
     "agentId": { "label": "Agent ID", "placeholder": "17676" },
     "rpcUrl": { "label": "RPC URL", "placeholder": "https://base-rpc.publicnode.com" },
-    "backendUrl": { "label": "Backend URL", "placeholder": "http://95.179.189.214:3001" }
+    "backendUrl": { "label": "Backend URL", "placeholder": "http://95.179.189.214:3001" },
+    "autoDraw": { "label": "Auto-Draw Credit", "placeholder": "false" }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/openclaw-plugin",
-  "version": "1.0.1",
+  "version": "1.1.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.0.0",
+    "@agether/sdk": "^1.1.0",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/src/index.ts

@@ -10,7 +10,9 @@ import axios from "axios";
 import {
   ACCOUNT_FACTORY_ABI,
   AGENT_ACCOUNT_ABI,
+  MORPHO_CREDIT_ABI,
   ERC20_ABI,
+  X402Client,
   getDefaultConfig,
 } from "@agether/sdk";
 
@@ -21,22 +23,9 @@ interface PluginConfig {
   agentId?: string;
   rpcUrl?: string;
   backendUrl?: string;
+  autoDraw?: boolean;
 }
 
-const MORPHO_CREDIT_ABI = [
-  "function depositCollateral(address collateralToken, uint256 amount)",
-  "function depositCollateralFor(address onBehalf, address collateralToken, uint256 amount)",
-  "function withdrawCollateral(address collateralToken, uint256 amount)",
-  "function drawWithCollateral(address collateralToken, uint256 amount)",
-  "function repayWithCollateral(address collateralToken, uint256 amount)",
-  "function getPosition(address account, address collateralToken) view returns (tuple(uint256 collateralAmount, uint256 borrowedAmount, uint256 borrowShares, bool isActive))",
-  "function getSupportedCollaterals() view returns (address[])",
-  "function asset() view returns (address)",
-  "function getCreditInfo(address account) view returns (tuple(uint256 limit, uint256 used, uint256 available, uint256 accruedInterest, uint256 aprBps, bool isActive, bool requiresCollateral))",
-  "function getTotalDebt(address account) view returns (uint256)",
-  "function maxDrawable(address account) view returns (uint256)",
-];
-
 const ERC8004_ABI = [
   "function register(string agentURI) returns (uint256)",
   "function ownerOf(uint256 tokenId) view returns (address)",
@@ -59,6 +48,7 @@ function getConfig(api: any): PluginConfig {
     agentId: cfg.agentId,
     rpcUrl: cfg.rpcUrl || "https://base-rpc.publicnode.com",
     backendUrl: cfg.backendUrl || "http://95.179.189.214:3001",
+    autoDraw: cfg.autoDraw === true || cfg.autoDraw === "true",
   };
 }
 
@@ -321,10 +311,7 @@ export default function register(api: any) {
         await depositTx.wait();
 
         // Approve credit provider on AgentAccount
-        const account = new ethers.Contract(accountAddr, [
-          ...AGENT_ACCOUNT_ABI,
-          "function approveCreditProvider(address creditProvider)",
-        ], signer);
+        const account = new ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
         try {
           const cpTx = await account.approveCreditProvider(morphoCreditAddr);
           await cpTx.wait();
@@ -343,6 +330,183 @@ export default function register(api: any) {
     },
   });
 
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_deposit_and_borrow  (Flow 2)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_deposit_and_borrow",
+    description:
+      "Deposit collateral AND borrow USDC in one call. Deposits collateral from EOA into Morpho, then borrows the specified USDC amount. USDC lands in AgentAccount.",
+    parameters: {
+      type: "object",
+      properties: {
+        collateralAmount: { type: "string", description: "Amount of collateral (e.g. '0.05')" },
+        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
+        borrowAmount: { type: "string", description: "USDC amount to borrow (e.g. '50')" },
+      },
+      required: ["collateralAmount", "token", "borrowAmount"],
+    },
+    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);
+        if (!cfg.agentId) return fail("No agentId configured");
+
+        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, cfg.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);
+
+        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,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_sponsor  (Flows 4-7: Human sponsors agent)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_sponsor",
+    description:
+      "Deposit collateral for another agent (by agentId or AgentAccount address). The caller pays collateral from their wallet. Optionally borrow USDC for the agent if caller owns the AgentAccount.",
+    parameters: {
+      type: "object",
+      properties: {
+        agentId: { type: "string", description: "Target agent's ERC-8004 ID (e.g. '17676')" },
+        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." },
+      },
+      required: ["amount", "token"],
+    },
+    async execute(_id: string, params: { agentId?: string; agentAddress?: string; amount: string; token: string; borrow?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const signer = getSigner(cfg);
+        const status = await getBackendStatus(cfg);
+
+        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 result: any = {
+          status: "sponsored",
+          target: accountAddr,
+          targetAgentId: params.agentId || "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));
+      } catch (e) { return fail(e); }
+    },
+  });
+
   // ═══════════════════════════════════════════════════════
   //  TOOL: morpho_borrow
   // ═══════════════════════════════════════════════════════
@@ -644,47 +808,90 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: x402_pay
+  //  TOOL: x402_pay  (Flows 8 & 9 — uses SDK X402Client)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "x402_pay",
     description:
-      "Make a paid API call using x402 protocol. Pays with USDC via EIP-3009 signature. Returns the API response.",
+      "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.",
     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)" },
       },
       required: ["url"],
     },
-    async execute(_id: string, params: { url: string; method?: string; body?: string }) {
+    async execute(_id: string, params: { url: string; method?: string; body?: string; autoDraw?: boolean }) {
       try {
         const cfg = getConfig(api);
-        // Delegate to CLI for now since x402 flow is complex (EIP-3009 signing)
-        const { execSync } = await import("child_process");
-        const args = [`x402 "${params.url}"`];
-        if (params.method) args.push(`--method ${params.method}`);
-        if (params.body) args.push(`--body '${params.body}'`);
-
-        const env = {
-          ...process.env,
-          AGETHER_PRIVATE_KEY: cfg.privateKey,
-          AGETHER_RPC_URL: cfg.rpcUrl,
-          AGETHER_BACKEND_URL: cfg.backendUrl,
-        };
+        const signer = getSigner(cfg);
+        const status = await getBackendStatus(cfg);
 
-        const result = execSync(`agether ${args.join(" ")}`, {
-          encoding: "utf-8",
-          timeout: 30000,
-          env,
+        // Resolve AgentAccount address for x402 payments
+        let accountAddress: string | undefined;
+        if (cfg.agentId && status.contracts.accountFactory) {
+          try {
+            accountAddress = await getAccountAddr(signer, status.contracts.accountFactory, cfg.agentId);
+          } catch { /* no account, pay from EOA */ }
+        }
+
+        // Auto-draw: if enabled, check USDC balance and borrow if needed
+        const shouldAutoDraw = params.autoDraw ?? cfg.autoDraw;
+        if (shouldAutoDraw && accountAddress && cfg.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 */ }
+          }
+        }
+
+        // Use SDK's X402Client directly (no execSync)
+        const x402 = new X402Client({
+          privateKey: cfg.privateKey,
+          rpcUrl: cfg.rpcUrl!,
+          backendUrl: cfg.backendUrl!,
+          agentId: cfg.agentId,
+          accountAddress,
         });
 
-        return ok(result);
-      } catch (e: any) {
-        return fail(e.stderr || e.stdout || e.message);
-      }
+        let result;
+        if (params.method?.toUpperCase() === "POST" && params.body) {
+          result = await x402.post(params.url, JSON.parse(params.body));
+        } else {
+          result = await x402.get(params.url);
+        }
+
+        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;
+        }
+        return ok(JSON.stringify(response, null, 2));
+      } catch (e) { return fail(e); }
     },
   });