@agether/agether 3.1.4 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "3.1.4",
+  "version": "3.3.0",
   "description": "OpenClaw plugin for Agether — onchain credit for AI agents on Ethereum & Base",
   "main": "src/index.ts",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "dependencies": {
-    "@agether/sdk": "file:../sdk",
+    "@agether/sdk": "^2.18.1",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/src/index.ts

@@ -29,6 +29,7 @@ import {
   ScoringClient,
   getContractAddresses,
   ChainId,
+  AaveClient,
 } from "@agether/sdk";
 
 // ─── Constants ────────────────────────────────────────────
@@ -355,6 +356,19 @@ function createMorphoClient(cfg: PluginConfig): MorphoClient {
 }
 
 /** @deprecated Use createAgetherClient or createMorphoClient instead */
+function createAaveClient(cfg: PluginConfig): AaveClient {
+  const agentId = state.getAgentId(cfg.chainId) || cfg.agentId;
+  if (!agentId) {
+    throw new Error("agentId not set. Register first with agether_register, then try again.");
+  }
+  return new AaveClient({
+    privateKey: cfg.privateKey,
+    rpcUrl: cfg.rpcUrl,
+    agentId,
+    chainId: cfg.chainId,
+  });
+}
+
 function createClient(cfg: PluginConfig): MorphoClient {
   return createMorphoClient(cfg);
 }
@@ -672,7 +686,7 @@ export default function register(api: any) {
   //  TOOL: morpho_deposit
   // ═══════════════════════════════════════════════════════
   api.registerTool({
-    name: "morpho_deposit_collateral",
+    name: "morpho_deposit",
     description: "Deposit collateral into Morpho Blue to enable borrowing. Validates balance first.",
     parameters: {
       type: "object",
@@ -2125,6 +2139,520 @@ export default function register(api: any) {
   });
 
 
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_repay_and_withdraw
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_repay_and_withdraw",
+    description: "Repay all debt and withdraw all collateral from Morpho in one atomic batch. Full position exit.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Collateral token (optional — auto-detects active position)" },
+        loanToken: { type: "string", description: "Loan token (optional)" },
+        toEoa: { type: "boolean", description: "Send withdrawn collateral to EOA wallet (default: true)" },
+      },
+    },
+    async execute(_id: string, params: { token?: string; loanToken?: string; toEoa?: boolean }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createMorphoClient(cfg);
+        const result = await client.repayAndWithdraw(params.token, params.loanToken, params.toEoa ?? true);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+        return ok(JSON.stringify({
+          status: "position_closed",
+          repaid: result.repaid,
+          withdrawn: result.withdrawn + ' ' + result.collateralToken,
+          loanToken: result.loanToken,
+          tx: explorer + result.tx,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  AAVE V3 TOOLS
+  // ═══════════════════════════════════════════════════════
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_markets
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_markets",
+    description: "List Aave V3 reserves with supply/borrow APY, LTV, prices. Shows all available markets on the current chain.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const reserves = await client.getReserves();
+
+        if (reserves.length === 0) {
+          return ok(JSON.stringify({ status: "no_reserves", message: "No Aave V3 reserves found on this chain." }));
+        }
+
+        const summary = reserves.map(r => ({
+          asset: r.symbol,
+          supplyApy: r.supplyApy.toFixed(2) + '%',
+          borrowApy: r.borrowApy.toFixed(2) + '%',
+          maxLtv: r.ltv.toFixed(0) + '%',
+          liquidationThreshold: r.liquidationThreshold.toFixed(0) + '%',
+          priceUsd: '$' + r.priceUsd.toFixed(2),
+          borrowingEnabled: r.borrowingEnabled,
+          active: r.isActive,
+        }));
+
+        return ok(JSON.stringify({ status: "aave_reserves", chain: cfg.chainId === 8453 ? "Base" : "Ethereum", reserves: summary }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_status
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_status",
+    description: "Show Aave V3 account overview: total collateral, debt, health factor, and per-asset positions with APY.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const data = await client.getAccountData();
+
+        return ok(JSON.stringify({
+          status: "aave_account",
+          chain: cfg.chainId === 8453 ? "Base" : "Ethereum",
+          totalCollateralUsd: '$' + data.totalCollateralUsd.toFixed(2),
+          totalDebtUsd: '$' + data.totalDebtUsd.toFixed(2),
+          availableBorrowUsd: '$' + data.availableBorrowUsd.toFixed(2),
+          currentLtv: data.currentLtv.toFixed(2) + '%',
+          liquidationThreshold: data.liquidationThreshold.toFixed(2) + '%',
+          healthFactor: data.healthFactor === Infinity ? 'Safe (no debt)' : data.healthFactor.toFixed(3),
+          positions: data.positions.map(p => ({
+            asset: p.asset,
+            supplied: p.supplied > 0 ? p.supplied.toFixed(6) + ' (' + '$' + p.suppliedUsd.toFixed(2) + ')' : '0',
+            borrowed: p.borrowed > 0 ? p.borrowed.toFixed(6) + ' (' + '$' + p.borrowedUsd.toFixed(2) + ')' : '0',
+            usedAsCollateral: p.usedAsCollateral,
+            supplyApy: p.supplyApy.toFixed(2) + '%',
+            borrowApy: p.borrowApy.toFixed(2) + '%',
+          })),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_supply
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_deposit",
+    description: "Deposit an asset to Aave V3 as collateral or to earn yield.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to supply (e.g. 'WETH', 'USDC', 'wstETH')" },
+        amount: { type: "string", description: "Amount to supply" },
+      },
+      required: ["token", "amount"],
+    },
+    async execute(_id: string, params: { token: string; amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.supply(params.token, params.amount);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+
+        return ok(JSON.stringify({
+          status: "supplied",
+          token: params.token,
+          amount: params.amount,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_withdraw
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_withdraw",
+    description: "Withdraw a supplied asset from Aave V3.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to withdraw (e.g. 'WETH', 'USDC')" },
+        amount: { type: "string", description: "Amount to withdraw. Use 'all' for full balance." },
+      },
+      required: ["token", "amount"],
+    },
+    async execute(_id: string, params: { token: string; amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.withdraw(params.token, params.amount);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          token: params.token,
+          amount: params.amount,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_borrow
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_borrow",
+    description: "Borrow an asset from Aave V3 against supplied collateral. Uses variable rate.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to borrow (e.g. 'USDC', 'WETH')" },
+        amount: { type: "string", description: "Amount to borrow" },
+      },
+      required: ["token", "amount"],
+    },
+    async execute(_id: string, params: { token: string; amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.borrow(params.token, params.amount);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+
+        return ok(JSON.stringify({
+          status: "borrowed",
+          token: params.token,
+          amount: params.amount,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_repay
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_repay",
+    description: "Repay borrowed asset on Aave V3. Use amount 'all' to repay full debt.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to repay (e.g. 'USDC', 'WETH')" },
+        amount: { type: "string", description: "Amount to repay. Use 'all' for full debt." },
+      },
+      required: ["token", "amount"],
+    },
+    async execute(_id: string, params: { token: string; amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.repay(params.token, params.amount);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+
+        return ok(JSON.stringify({
+          status: "repaid",
+          token: params.token,
+          amount: params.amount,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_set_collateral
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_set_collateral",
+    description: "Enable or disable a supplied asset as collateral on Aave V3.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to toggle (e.g. 'WETH', 'wstETH')" },
+        enabled: { type: "boolean", description: "true to enable as collateral, false to disable" },
+      },
+      required: ["token", "enabled"],
+    },
+    async execute(_id: string, params: { token: string; enabled: boolean }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.setCollateral(params.token, params.enabled);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+
+        return ok(JSON.stringify({
+          status: "collateral_updated",
+          token: params.token,
+          enabled: params.enabled,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_supply_and_borrow
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_deposit_and_borrow",
+    description: "Deposit collateral and borrow in one atomic batch on Aave V3. Preferred over separate deposit + borrow.",
+    parameters: {
+      type: "object",
+      properties: {
+        supplyToken: { type: "string", description: "Token to supply as collateral (e.g. 'wstETH', 'WETH')" },
+        supplyAmount: { type: "string", description: "Amount to supply" },
+        borrowToken: { type: "string", description: "Token to borrow (e.g. 'USDC', 'WETH')" },
+        borrowAmount: { type: "string", description: "Amount to borrow" },
+      },
+      required: ["supplyToken", "supplyAmount", "borrowToken", "borrowAmount"],
+    },
+    async execute(_id: string, params: { supplyToken: string; supplyAmount: string; borrowToken: string; borrowAmount: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.supplyAndBorrow(params.supplyToken, params.supplyAmount, params.borrowToken, params.borrowAmount);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+        return ok(JSON.stringify({
+          status: "supplied_and_borrowed",
+          supplied: params.supplyAmount + ' ' + params.supplyToken,
+          borrowed: params.borrowAmount + ' ' + params.borrowToken,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_search
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_search",
+    description: "Search Aave V3 reserves by token name or symbol.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to search for (e.g. 'wstETH', 'USDC')" },
+      },
+      required: ["token"],
+    },
+    async execute(_id: string, params: { token: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const results = await client.searchReserves(params.token);
+        if (results.length === 0) {
+          return ok(JSON.stringify({ status: "no_results", message: `No Aave reserves match '${params.token}'` }));
+        }
+        return ok(JSON.stringify({
+          status: "search_results",
+          reserves: results.map(r => ({
+            symbol: r.symbol,
+            supplyApy: r.supplyApy.toFixed(2) + '%',
+            borrowApy: r.borrowApy.toFixed(2) + '%',
+            ltv: r.ltv.toFixed(0) + '%',
+            price: '$' + r.priceUsd.toFixed(2),
+            borrowingEnabled: r.borrowingEnabled,
+          })),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_borrowing_options
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_borrowing_options",
+    description: "Show what you can borrow on Aave V3. Without args: scans wallet for collateral tokens. With collateral: shows options for that token.",
+    parameters: {
+      type: "object",
+      properties: {
+        collateral: { type: "string", description: "Collateral token to check (optional — omit to scan wallet)" },
+      },
+    },
+    async execute(_id: string, params: { collateral?: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const options = await client.getBorrowingOptions(params.collateral);
+        if (options.length === 0) {
+          return ok(JSON.stringify({
+            status: "no_options",
+            message: params.collateral
+              ? `No Aave collateral options for ${params.collateral}`
+              : "No tokens found in wallet that can be used as Aave collateral",
+          }));
+        }
+        return ok(JSON.stringify({
+          status: "borrowing_options",
+          options: options.map(o => ({
+            collateral: o.collateral,
+            balance: o.collateralBalance.toFixed(6),
+            valueUsd: '$' + o.collateralValueUsd.toFixed(2),
+            maxBorrowUsd: '$' + o.maxBorrowUsd.toFixed(2),
+            borrowableTokens: o.borrowable.map(b => ({
+              token: b.symbol,
+              borrowApy: b.borrowApy.toFixed(2) + '%',
+              price: '$' + b.priceUsd.toFixed(2),
+            })),
+          })),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_max_borrowable
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_max_borrowable",
+    description: "Calculate max additional borrowable on Aave V3 given current collateral and debt.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const data = await client.getMaxBorrowable();
+        return ok(JSON.stringify({
+          status: "max_borrowable",
+          availableBorrowUsd: '$' + data.availableBorrowUsd.toFixed(2),
+          currentLtv: data.currentLtv.toFixed(2) + '%',
+          liquidationThreshold: data.liquidationThreshold.toFixed(2) + '%',
+          totalCollateralUsd: '$' + data.totalCollateralUsd.toFixed(2),
+          totalDebtUsd: '$' + data.totalDebtUsd.toFixed(2),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_wallet_tokens
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_wallet_tokens",
+    description: "Scan wallet for tokens that exist as Aave V3 reserves. Shows balances in EOA and AgentAccount.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const tokens = await client.getWalletTokens();
+        if (tokens.length === 0) {
+          return ok(JSON.stringify({ status: "no_tokens", message: "No Aave-compatible tokens found in wallet." }));
+        }
+        return ok(JSON.stringify({
+          status: "wallet_tokens",
+          tokens: tokens.map(t => ({
+            symbol: t.symbol,
+            eoaBalance: t.eoaBalance.toFixed(6),
+            safeBalance: t.safeBalance.toFixed(6),
+            priceUsd: '$' + t.priceUsd.toFixed(2),
+            totalValueUsd: '$' + t.valueUsd.toFixed(2),
+            canSupply: t.canSupply,
+            canBorrow: t.canBorrow,
+          })),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_yield_spread
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_yield_spread",
+    description: "Analyze LST/LRT yield vs Aave V3 borrow rates for carry trades. Live APYs from DeFi Llama.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Filter by collateral token (optional)" },
+      },
+    },
+    async execute(_id: string, params: { token?: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const spreads = await client.getYieldSpread();
+        const filtered = params.token
+          ? spreads.filter((s: any) => s.collateralToken.toLowerCase() === params.token!.toLowerCase())
+          : spreads;
+
+        if (filtered.length === 0) {
+          return ok(JSON.stringify({ status: "no_lst_markets", message: "No LST carry trade opportunities on Aave." }));
+        }
+
+        return ok(JSON.stringify({
+          status: "aave_yield_spread",
+          markets: filtered.map((s: any) => ({
+            collateral: s.collateralToken,
+            loan: s.loanToken,
+            collateralYield: s.collateralYield + '%',
+            borrowRate: s.borrowRate.toFixed(2) + '%',
+            netSpread: (s.netSpread > 0 ? '+' : '') + s.netSpread.toFixed(2) + '%',
+            profitable: s.profitable ? 'yes' : 'no',
+            maxLeverage: s.maxSafeLeverage + 'x',
+          })),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: aave_repay_and_withdraw
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "aave_repay_and_withdraw",
+    description: "Repay all debt and withdraw all collateral from Aave V3 in one atomic batch. Full position exit.",
+    parameters: {
+      type: "object",
+      properties: {
+        repayToken: { type: "string", description: "Token to repay (e.g. 'USDC')" },
+        withdrawToken: { type: "string", description: "Token to withdraw (e.g. 'wstETH')" },
+      },
+      required: ["repayToken", "withdrawToken"],
+    },
+    async execute(_id: string, params: { repayToken: string; withdrawToken: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createAaveClient(cfg);
+        const receipt = await client.repayAndWithdraw(params.repayToken, params.withdrawToken);
+        const explorer = cfg.chainId === 8453 ? 'https://basescan.org/tx/' : 'https://etherscan.io/tx/';
+        return ok(JSON.stringify({
+          status: "position_closed",
+          repaid: 'all ' + params.repayToken,
+          withdrawn: 'all ' + params.withdrawToken,
+          tx: explorer + receipt.hash,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+
   // ═══════════════════════════════════════════════════════
   //  SLASH COMMANDS (no AI needed)
   // ═══════════════════════════════════════════════════════