@agether/agether 2.0.1 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "OpenClaw plugin for Agether — onchain credit for AI agents",
   "main": "src/index.ts",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "dependencies": {
-    "@agether/sdk": "^2.3.4",
+    "@agether/sdk": "^2.4.0",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/src/index.ts

@@ -536,6 +536,173 @@ export default function register(api: any) {
     },
   });
 
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_supply  (lender-side — earn yield)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_supply",
+    description:
+      "Supply USDC to a Morpho Blue market as a LENDER to earn yield. " +
+      "This is the lending side — your USDC earns interest from borrowers. " +
+      "Unlike morpho_deposit (collateral for borrowing), this puts USDC to work earning APY.",
+    parameters: {
+      type: "object",
+      properties: {
+        amount: { type: "string", description: "USDC amount to supply (e.g. '500')" },
+        market: {
+          type: "string",
+          enum: ["WETH", "wstETH", "cbETH"],
+          description: "Which market to supply to, identified by collateral token (optional — auto-picks highest APY)",
+        },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string; market?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.supplyAsset(params.amount, params.market);
+        return ok(JSON.stringify({
+          status: "supplied",
+          amount: `$${params.amount} USDC`,
+          market: result.collateralToken,
+          agentAccount: result.agentAccount,
+          note: "USDC is now earning yield from borrowers in this market",
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_supply_status  (supply positions + yield)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_supply_status",
+    description:
+      "Show all supply (lending) positions with earned yield. " +
+      "Tracks yield WITHOUT any database — reads Morpho events directly from blockchain. " +
+      "Shows: current position value, net deposited, earned yield, and current APY.",
+    parameters: {
+      type: "object",
+      properties: {
+        market: {
+          type: "string",
+          enum: ["WETH", "wstETH", "cbETH"],
+          description: "Filter by market collateral token (optional)",
+        },
+      },
+      required: [],
+    },
+    async execute(_id: string, params: { market?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const positions = await client.getSupplyPositions(params.market);
+
+        if (positions.length === 0) {
+          return ok("No active supply positions. Use morpho_supply to start earning yield.");
+        }
+
+        const formatted = positions.map((p: any) => ({
+          market: `${p.collateralToken}/${p.loanToken}`,
+          suppliedAssets: `$${p.suppliedAssets} USDC`,
+          netDeposited: `$${p.netDeposited} USDC`,
+          earnedYield: `$${p.earnedYield} USDC`,
+          supplyApy: `${(p.supplyApy * 100).toFixed(2)}%`,
+          marketId: p.marketId.slice(0, 18) + "…",
+        }));
+
+        const totalYield = positions.reduce((s: number, p: any) => s + parseFloat(p.earnedYield), 0);
+        const totalSupplied = positions.reduce((s: number, p: any) => s + parseFloat(p.suppliedAssets), 0);
+
+        return ok(JSON.stringify({
+          positions: formatted,
+          totals: {
+            totalSupplied: `$${totalSupplied.toFixed(2)} USDC`,
+            totalYield: `$${totalYield.toFixed(6)} USDC`,
+          },
+        }, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_withdraw_supply  (withdraw lent USDC)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_withdraw_supply",
+    description:
+      "Withdraw supplied USDC (principal + earned interest) from a Morpho Blue lending position. " +
+      "Use amount 'all' to withdraw the full position. Different from morpho_withdraw which withdraws collateral.",
+    parameters: {
+      type: "object",
+      properties: {
+        amount: { type: "string", description: "USDC amount to withdraw (e.g. '100' or 'all')" },
+        market: {
+          type: "string",
+          enum: ["WETH", "wstETH", "cbETH"],
+          description: "Market collateral token (optional — auto-detects)",
+        },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string; market?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.withdrawSupply(params.amount, params.market);
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          amount: params.amount === "all" ? "all (full position)" : `$${params.amount} USDC`,
+          remainingSupply: `$${result.remainingSupply} USDC`,
+          destination: result.destination,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_pay_from_yield  (pay using only earned yield)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_pay_from_yield",
+    description:
+      "Pay a recipient using ONLY earned yield from a supply position. " +
+      "Your principal stays untouched — only the interest earned gets withdrawn and sent. " +
+      "Fails if requested amount exceeds available yield.",
+    parameters: {
+      type: "object",
+      properties: {
+        recipient: { type: "string", description: "Recipient address (0x...)" },
+        amount: { type: "string", description: "USDC amount to pay from yield (e.g. '2.50')" },
+        market: {
+          type: "string",
+          enum: ["WETH", "wstETH", "cbETH"],
+          description: "Which supply position to use (optional — auto-picks highest yield)",
+        },
+      },
+      required: ["recipient", "amount"],
+    },
+    async execute(_id: string, params: { recipient: string; amount: string; market?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.payFromYield(params.recipient, params.amount, params.market);
+        return ok(JSON.stringify({
+          status: "paid_from_yield",
+          amount: `$${params.amount} USDC`,
+          recipient: params.recipient,
+          remainingYield: `$${result.remainingYield} USDC`,
+          remainingSupply: `$${result.remainingSupply} USDC`,
+          note: "Paid from earned interest only — principal untouched",
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
   // ═══════════════════════════════════════════════════════
   //  TOOL: morpho_markets  (Morpho GraphQL API — no backend)
   // ═══════════════════════════════════════════════════════