@agether/agether 3.0.0 → 3.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "3.0.0",
+  "version": "3.1.3",
   "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": "^2.15.0",
+    "@agether/sdk": "^2.17.2",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/src/index.ts

@@ -1806,6 +1806,324 @@ export default function register(api: any) {
     },
   });
 
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_yield_spread
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_yield_spread",
+    description: "Analyze yield spread between LST/LRT collateral yield and Morpho borrow rates. Shows profitable carry trades.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Filter by collateral token (e.g. 'wstETH'). Omit for all LST markets." },
+      },
+    },
+    async execute(_id: string, params: { token?: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createMorphoClient(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: params.token
+              ? `No LST markets found for ${params.token}`
+              : "No LST/LRT markets found on this chain",
+          }));
+        }
+
+        const summary = 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 ? '✅' : '❌',
+          maxLeverage: `${s.maxSafeLeverage}x`,
+          leveragedApy: `${s.leveragedNetApy > 0 ? '+' : ''}${s.leveragedNetApy}%`,
+          liquidity: `$${(s.liquidity / 1e6).toFixed(1)}M`,
+        }));
+
+        return ok(JSON.stringify({
+          status: "yield_spread_analysis",
+          markets: summary,
+          bestOpportunity: filtered[0]
+            ? `${filtered[0].collateralToken}/${filtered[0].loanToken}: ${filtered[0].netSpread > 0 ? '+' : ''}${filtered[0].netSpread.toFixed(2)}% spread (${filtered[0].leveragedNetApy}% at ${filtered[0].maxSafeLeverage}x leverage)`
+            : "none",
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_position_analysis
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_position_analysis",
+    description: "Analyze position health over time. Shows current HF/LTV and projects future values based on LST yield vs borrow rate. Tracks historical snapshots.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Collateral token to analyze (e.g. 'wstETH'). Omit for all positions." },
+      },
+    },
+    async execute(_id: string, params: { token?: string }) {
+      try {
+        const cfg = getConfig(api);
+        requireChain(cfg);
+        const client = createMorphoClient(cfg);
+
+        // Get current positions and yield data
+        const [status, spreads] = await Promise.all([
+          client.getStatus(),
+          client.getYieldSpread(),
+        ]);
+
+        if (status.positions.length === 0) {
+          return ok(JSON.stringify({
+            status: "no_positions",
+            message: "No active Morpho positions to analyze.",
+          }));
+        }
+
+        const analyses = [];
+
+        for (const pos of status.positions) {
+          if (params.token && pos.collateralToken.toLowerCase() !== params.token.toLowerCase()) continue;
+
+          const collateralValue = parseFloat(pos.collateral);
+          const debtValue = parseFloat(pos.debt);
+          if (collateralValue === 0) continue;
+
+          // Find yield spread for this collateral
+          const spread = spreads.find(
+            (s: any) => s.collateralToken.toLowerCase() === pos.collateralToken.toLowerCase()
+              && s.loanToken.toLowerCase() === pos.loanToken.toLowerCase()
+          );
+
+          const collateralYield = spread?.collateralYield ?? 0;
+          const borrowRate = spread?.borrowRate ?? 0;
+          const lltv = spread?.lltv ?? 0.8;
+
+          // Current metrics
+          const currentLtv = debtValue > 0 ? (debtValue / collateralValue) : 0;
+          const currentHf = debtValue > 0 ? (collateralValue * lltv) / debtValue : Infinity;
+
+          // Project forward: how collateral and debt change over time
+          // Collateral grows at yield rate, debt grows at borrow rate
+          const projections = [30, 90, 180, 365].map(days => {
+            const yearFraction = days / 365;
+            const projectedCollateral = collateralValue * (1 + (collateralYield / 100) * yearFraction);
+            const projectedDebt = debtValue * (1 + (borrowRate / 100) * yearFraction);
+            const projectedLtv = projectedDebt > 0 ? projectedDebt / projectedCollateral : 0;
+            const projectedHf = projectedDebt > 0 ? (projectedCollateral * lltv) / projectedDebt : Infinity;
+            const yieldEarned = projectedCollateral - collateralValue;
+            const interestPaid = projectedDebt - debtValue;
+            const netProfit = yieldEarned - interestPaid;
+
+            return {
+              days,
+              collateral: projectedCollateral.toFixed(6),
+              debt: projectedDebt.toFixed(6),
+              ltv: (projectedLtv * 100).toFixed(2) + '%',
+              healthFactor: projectedHf === Infinity ? '∞' : projectedHf.toFixed(3),
+              yieldEarned: yieldEarned.toFixed(6),
+              interestPaid: interestPaid.toFixed(6),
+              netProfit: (netProfit >= 0 ? '+' : '') + netProfit.toFixed(6),
+              ltvChange: ((currentLtv - projectedLtv) * 100).toFixed(3) + '% improvement',
+            };
+          });
+
+          // Calculate when LTV reaches key thresholds
+          const timeToSafeLtv = currentLtv > 0.5 && collateralYield > borrowRate
+            ? Math.ceil(((currentLtv - 0.5) / (currentLtv * (collateralYield - borrowRate) / 100)) * 365)
+            : null;
+
+          // Max additional borrowable from yield growth
+          const excessCollateralIn30d = collateralValue * (collateralYield / 100) * (30 / 365);
+          const additionalBorrowable = excessCollateralIn30d * lltv;
+
+          analyses.push({
+            collateralToken: pos.collateralToken,
+            loanToken: pos.loanToken,
+            current: {
+              collateral: collateralValue.toFixed(6) + ' ' + pos.collateralToken,
+              debt: debtValue.toFixed(6) + ' ' + pos.loanToken,
+              ltv: (currentLtv * 100).toFixed(2) + '%',
+              healthFactor: currentHf === Infinity ? '∞' : currentHf.toFixed(3),
+              lltv: (lltv * 100).toFixed(0) + '%',
+            },
+            rates: {
+              collateralYield: collateralYield + '% APY',
+              borrowRate: borrowRate.toFixed(2) + '% APY',
+              netSpread: (collateralYield - borrowRate > 0 ? '+' : '') + (collateralYield - borrowRate).toFixed(2) + '%',
+              profitable: collateralYield > borrowRate,
+            },
+            projections,
+            insights: {
+              daysToSafeLtv50: timeToSafeLtv ? timeToSafeLtv + ' days' : 'already below or not applicable',
+              additionalBorrowableIn30d: additionalBorrowable.toFixed(6) + ' ' + pos.loanToken,
+              excessCollateralIn30d: excessCollateralIn30d.toFixed(6) + ' ' + pos.collateralToken,
+              annualProfit: debtValue > 0
+                ? ((collateralValue * collateralYield / 100) - (debtValue * borrowRate / 100)).toFixed(4) + ' net/year'
+                : 'no debt',
+            },
+          });
+        }
+
+        // Save snapshot for historical tracking
+        try {
+          const snapshotDir = path.join(
+            process.env.HOME || "/root", ".openclaw", "agether-snapshots"
+          );
+          if (!fs.existsSync(snapshotDir)) fs.mkdirSync(snapshotDir, { recursive: true });
+
+          const snapshot = {
+            timestamp: new Date().toISOString(),
+            chainId: cfg.chainId,
+            positions: analyses.map(a => ({
+              collateralToken: a.collateralToken,
+              loanToken: a.loanToken,
+              ltv: a.current.ltv,
+              healthFactor: a.current.healthFactor,
+              collateral: a.current.collateral,
+              debt: a.current.debt,
+            })),
+          };
+
+          const snapshotFile = path.join(snapshotDir, "snapshots.json");
+          let snapshots: any[] = [];
+          if (fs.existsSync(snapshotFile)) {
+            try { snapshots = JSON.parse(fs.readFileSync(snapshotFile, "utf-8")); } catch {}
+          }
+          snapshots.push(snapshot);
+          // Keep last 1000 snapshots
+          if (snapshots.length > 1000) snapshots = snapshots.slice(-1000);
+          fs.writeFileSync(snapshotFile, JSON.stringify(snapshots, null, 2));
+        } catch {
+          // Snapshot save failed — non-critical
+        }
+
+        return ok(JSON.stringify({
+          status: "position_analysis",
+          positions: analyses,
+          summary: analyses.length > 0
+            ? analyses.map(a =>
+                `${a.collateralToken}/${a.loanToken}: LTV ${a.current.ltv} → ${a.projections[3].ltv} in 1yr | ` +
+                `HF ${a.current.healthFactor} → ${a.projections[3].healthFactor} | ` +
+                `Net spread: ${a.rates.netSpread}`
+              ).join('\n')
+            : 'No positions match filter',
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_position_history
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_position_history",
+    description: "Show historical HF/LTV snapshots for positions. Tracks how yield has improved position health over time.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Filter by collateral token (optional)" },
+        days: { type: "number", description: "Number of days to look back (default: 30)" },
+      },
+    },
+    async execute(_id: string, params: { token?: string; days?: number }) {
+      try {
+        const snapshotDir = path.join(
+          process.env.HOME || "/root", ".openclaw", "agether-snapshots"
+        );
+        const snapshotFile = path.join(snapshotDir, "snapshots.json");
+
+        if (!fs.existsSync(snapshotFile)) {
+          return ok(JSON.stringify({
+            status: "no_history",
+            message: "No snapshots yet. Run morpho_position_analysis first to start tracking.",
+          }));
+        }
+
+        const snapshots = JSON.parse(fs.readFileSync(snapshotFile, "utf-8"));
+        const lookbackMs = (params.days ?? 30) * 24 * 60 * 60 * 1000;
+        const cutoff = new Date(Date.now() - lookbackMs).toISOString();
+
+        const filtered = snapshots.filter((s: any) => s.timestamp >= cutoff);
+
+        if (filtered.length === 0) {
+          return ok(JSON.stringify({
+            status: "no_recent_history",
+            message: `No snapshots in the last ${params.days ?? 30} days.`,
+            totalSnapshots: snapshots.length,
+          }));
+        }
+
+        // Group by position and show trend
+        const positions: Record<string, any[]> = {};
+        for (const snap of filtered) {
+          for (const pos of snap.positions) {
+            if (params.token && !pos.collateralToken.includes(params.token)) continue;
+            const key = `${pos.collateralToken}/${pos.loanToken}`;
+            if (!positions[key]) positions[key] = [];
+            positions[key].push({
+              time: snap.timestamp,
+              ltv: pos.ltv,
+              hf: pos.healthFactor,
+              collateral: pos.collateral,
+              debt: pos.debt,
+            });
+          }
+        }
+
+        const trends = Object.entries(positions).map(([pair, data]: [string, any[]]) => {
+          const first = data[0];
+          const last = data[data.length - 1];
+          const ltvFirst = parseFloat(first.ltv);
+          const ltvLast = parseFloat(last.ltv);
+          const hfFirst = parseFloat(first.hf) || 0;
+          const hfLast = parseFloat(last.hf) || 0;
+
+          return {
+            pair,
+            snapshots: data.length,
+            firstSnapshot: first.time,
+            lastSnapshot: last.time,
+            ltvTrend: {
+              start: first.ltv,
+              current: last.ltv,
+              change: ((ltvLast - ltvFirst)).toFixed(3) + '%',
+              improving: ltvLast < ltvFirst,
+            },
+            hfTrend: {
+              start: first.hf,
+              current: last.hf,
+              change: (hfLast - hfFirst).toFixed(3),
+              improving: hfLast > hfFirst,
+            },
+            dataPoints: data,
+          };
+        });
+
+        return ok(JSON.stringify({
+          status: "position_history",
+          period: `Last ${params.days ?? 30} days`,
+          totalSnapshots: filtered.length,
+          trends,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+
   // ═══════════════════════════════════════════════════════
   //  SLASH COMMANDS (no AI needed)
   // ═══════════════════════════════════════════════════════