@elizaos/plugin-wallet 2.0.0-beta.1 → 2.0.3-beta.6

package/src/analytics/lpinfo/kamino/providers/kaminoProvider.ts

@@ -1,5 +1,10 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
-import type { IAgentRuntime, Memory, Provider, State } from "@elizaos/core";
+import type {
+  Entity,
+  IAgentRuntime,
+  Memory,
+  Provider,
+  State,
+} from "@elizaos/core";
 import { ModelType } from "@elizaos/core";
 import type { KaminoService } from "../services/kaminoService";
 
@@ -19,6 +24,54 @@ type AccountLike = {
   }>;
 };
 
+type Metawallets = NonNullable<AccountLike["metawallets"]>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+function isMetawallets(value: unknown): value is Metawallets {
+  return (
+    Array.isArray(value) &&
+    value.every(
+      (metawallet) =>
+        isRecord(metawallet) &&
+        (metawallet.keypairs === undefined || isRecord(metawallet.keypairs)),
+    )
+  );
+}
+
+async function getAccountFromMessage(
+  runtime: IAgentRuntime,
+  message: Memory,
+): Promise<unknown | null> {
+  const entity = await runtime.getEntityById(message.entityId);
+  if (!entity) {
+    return null;
+  }
+
+  return buildAccountLike(entity);
+}
+
+function buildAccountLike(entity: Entity): AccountLike {
+  const metadata = isRecord(entity.metadata) ? entity.metadata : {};
+  const account = isRecord(metadata.account) ? metadata.account : {};
+  const firstName = entity.names[0];
+
+  return {
+    ...metadata,
+    ...account,
+    id: entity.id,
+    username: account.username ?? metadata.username,
+    name: account.name ?? metadata.name ?? firstName,
+    metawallets: isMetawallets(account.metawallets)
+      ? account.metawallets
+      : isMetawallets(metadata.metawallets)
+        ? metadata.metawallets
+        : undefined,
+  };
+}
+
 function getSolanaWalletAddresses(account: unknown): string[] {
   const walletAddresses: string[] = [];
   const accountData = account as AccountLike;
@@ -28,7 +81,7 @@ function getSolanaWalletAddresses(account: unknown): string[] {
   }
 
   for (const mw of accountData.metawallets) {
-    if (!mw?.keypairs) {
+    if (!mw.keypairs) {
       continue;
     }
 
@@ -95,7 +148,7 @@ export const kaminoProvider: Provider = {
   description:
     "Provides information about Kamino lending protocol positions, market data, and available lending/borrowing opportunities",
   descriptionCompressed:
-    "provide information Kamino lend protocol position, market data, available lending/borrow opportunity",
+    "Kamino lending positions, markets, lend/borrow opportunities",
   dynamic: true,
   contexts: ["finance", "crypto", "wallet"],
   contextGate: { anyOf: ["finance", "crypto", "wallet"] },
@@ -103,8 +156,6 @@ export const kaminoProvider: Provider = {
   cacheScope: "turn",
   roleGate: { minRole: "OWNER" },
   get: async (runtime: IAgentRuntime, message: Memory, _state: State) => {
-    console.log("KAMINO_LENDING provider called");
-
     let kaminoInfo = "";
 
     try {
@@ -113,31 +164,25 @@ export const kaminoProvider: Provider = {
       if (isDM) {
         const account = await getAccountFromMessage(runtime, message);
         if (!account) {
-          console.log("No account found for user");
           return {
             data: {},
-            values: {} as Record<string, unknown>,
+            values: {},
             text: "No account found for this user.",
           };
         }
 
-        console.log("Account found, getting Kamino service...");
-
         // Get Kamino service with proper type casting
         const kaminoService = runtime.getService(
           "KAMINO_SERVICE",
         ) as KaminoService;
         if (!kaminoService) {
-          console.log("Kamino service not available");
           return {
             data: {},
-            values: {} as Record<string, unknown>,
+            values: {},
             text: "Kamino service not available.",
           };
         }
 
-        console.log("Kamino service found, generating report...");
-
         kaminoInfo += `=== KAMINO LENDING PROTOCOL REPORT ===\n\n`;
 
         // Get user's Kamino positions
@@ -182,7 +227,7 @@ export const kaminoProvider: Provider = {
 
     return {
       data,
-      values: {} as Record<string, unknown>,
+      values: {},
       text,
     };
   },
@@ -214,10 +259,8 @@ async function getUserKaminoPositions(
         // Get real positions from Kamino service
         const positions = await kaminoService.getUserPositions(walletAddress);
 
-        if (positions.error) {
+        if ("error" in positions) {
           positionsInfo += `   ❌ Error: ${positions.error}\n\n`;
-        } else if (positions.message) {
-          positionsInfo += `   ℹ️ ${positions.message}\n\n`;
         } else if (
           positions.lending.length === 0 &&
           positions.borrowing.length === 0
@@ -314,12 +357,12 @@ async function getAvailableKaminoReserves(
       reservesInfo += "💰 TOP LENDING OPPORTUNITIES:\n\n";
 
       for (const reserve of topLendingReserves) {
-        reservesInfo += `🔸 ${reserve.symbol || "Unknown"}\n`;
-        reservesInfo += `   Supply APY: ${reserve.supplyApy?.toFixed(2) || "N/A"}%\n`;
-        reservesInfo += `   Borrow APY: ${reserve.borrowApy?.toFixed(2) || "N/A"}%\n`;
-        reservesInfo += `   Total Supply: $${reserve.totalSupply?.toLocaleString() || "N/A"}\n`;
-        reservesInfo += `   Total Borrow: $${reserve.totalBorrow?.toLocaleString() || "N/A"}\n`;
-        reservesInfo += `   Utilization: ${(reserve.utilization * 100)?.toFixed(2) || "N/A"}%\n`;
+        reservesInfo += `🔸 ${reserve.marketName || reserve.market || "Unknown"}\n`;
+        reservesInfo += `   Supply APY: ${reserve.supplyApy.toFixed(2) || "N/A"}%\n`;
+        reservesInfo += `   Borrow APY: ${reserve.borrowApy.toFixed(2) || "N/A"}%\n`;
+        reservesInfo += `   Total Supply: $${reserve.totalSupply.toLocaleString() || "N/A"}\n`;
+        reservesInfo += `   Total Borrow: $${reserve.totalBorrow.toLocaleString() || "N/A"}\n`;
+        reservesInfo += `   Utilization: ${(reserve.utilization * 100).toFixed(2) || "N/A"}%\n`;
         reservesInfo += `   Market: ${reserve.marketName || "Unknown"}\n\n`;
       }
     }
@@ -355,22 +398,23 @@ async function getKaminoMarketOverview(
     }
 
     marketInfo += `📊 Total Markets: ${overview.totalMarkets}\n`;
-    marketInfo += `💰 Total TVL: $${overview.totalTvl?.toLocaleString() || "N/A"}\n`;
-    marketInfo += `💳 Total Borrowed: $${overview.totalBorrowed?.toLocaleString() || "N/A"}\n\n`;
+    marketInfo += `💰 Total TVL: $${overview.totalTvl.toLocaleString() || "N/A"}\n`;
+    marketInfo += `💳 Total Borrowed: $${overview.totalBorrowed.toLocaleString() || "N/A"}\n\n`;
 
     // Show top markets by TVL
     if (overview.markets && overview.markets.length > 0) {
       marketInfo += "🏆 TOP MARKETS BY TVL:\n\n";
 
       const topMarkets = overview.markets
-        .sort((a, b) => (b.tvl || 0) - (a.tvl || 0))
+        .sort((a, b) => (b.lamports || 0) - (a.lamports || 0))
         .slice(0, 3);
 
       for (const market of topMarkets) {
-        marketInfo += `🔸 ${market.name || "Unknown Market"}\n`;
-        marketInfo += `   TVL: $${market.tvl?.toLocaleString() || "N/A"}\n`;
-        marketInfo += `   Borrowed: $${market.borrowed?.toLocaleString() || "N/A"}\n`;
-        marketInfo += `   Utilization: ${(market.utilization * 100)?.toFixed(2) || "N/A"}%\n\n`;
+        marketInfo += `🔸 ${market.marketName || "Unknown Market"}\n`;
+        marketInfo += `   Address: ${market.address}\n`;
+        marketInfo += `   Data Size: ${market.dataSize.toLocaleString()} bytes\n`;
+        marketInfo += `   Lamports: ${market.lamports.toLocaleString()}\n`;
+        marketInfo += `   Owner: ${market.owner}\n\n`;
       }
     }
   } catch (error) {
@@ -440,7 +484,7 @@ async function generateEnhancedKaminoLendingReport(
 ): Promise<string> {
   try {
     // Create a focused prompt for the LLM
-    const lendingPrompt = `You are a professional DeFi analyst specializing in Kamino Finance lending protocols. Generate a comprehensive, well-crafted lending analysis report for the user.
+    const lendingPrompt = `Generate a comprehensive lending analysis report for Kamino Finance lending.
 
 USER ACCOUNT DATA:
 ${formatAccountForPrompt(data.account)}

package/src/analytics/lpinfo/kamino/services/kaminoLiquidityService.ts

@@ -1,19 +1,19 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
-import type { AgentRuntime } from "@elizaos/core";
+import type { IAgentRuntime } from "@elizaos/core";
 import { logger, Service } from "@elizaos/core";
 
 // Kamino API constants
 const KAMINO_API_BASE_URL = "https://api.kamino.finance";
+const KAMINO_LIQUIDITY_PROGRAM_ID = "kamino-rest-api";
 
 // Known token addresses for reference
-const KNOWN_TOKENS = {
+const KNOWN_TOKENS: Record<string, string> = {
   HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC: "AI16Z Token",
   ai16z: "AI16Z Token (Symbol)",
   "4WfUvajjYTrq7KRdToJBkoHQ6bSt7NyBeLhP9LKwtFKh": "Kamino Strategy",
 };
 
 // Interfaces for type safety
-interface KaminoStrategy {
+export interface KaminoStrategy {
   address: string;
   strategyType: string;
   estimatedTvl: number;
@@ -34,14 +34,14 @@ interface KaminoStrategy {
   };
 }
 
-interface KaminoPosition {
+export interface KaminoPosition {
   type: string;
   range: string;
   liquidity: number;
   feesEarned: number;
 }
 
-interface TokenLiquidityStats {
+export interface TokenLiquidityStats {
   tokenIdentifier: string;
   normalizedToken: string;
   tokenName: string;
@@ -53,7 +53,7 @@ interface TokenLiquidityStats {
   poolCount: number;
 }
 
-interface TokenInfo {
+export interface TokenInfo {
   name: string;
   symbol: string;
   address: string;
@@ -124,7 +124,7 @@ interface KaminoMarketStatistics {
   };
 }
 
-interface KaminoPoolInfoWithStrategy {
+export interface KaminoPoolInfoWithStrategy {
   address: string;
   strategy: KaminoStrategy;
   tokenInfo: TokenInfo | null;
@@ -140,20 +140,22 @@ interface KaminoPoolInfoWithStrategy {
   };
 }
 
-interface KaminoPoolInfoTokenFallback {
+export interface KaminoPoolInfoTokenFallback {
   address: string;
   tokenInfo: TokenInfo;
   timestamp: string;
   note: string;
 }
 
-type KaminoPoolByAddressResult =
+export type KaminoPoolByAddressResult =
   | KaminoPoolInfoWithStrategy
   | KaminoPoolInfoTokenFallback
   | null;
 
 interface KaminoLiquidityConnectionTest {
   apiBaseUrl: string;
+  programId: string;
+  rpcEndpoint: string;
   connectionTest: boolean;
   stakingYieldsTest: boolean;
   limoTradesTest: boolean;
@@ -176,6 +178,19 @@ interface LimoTrade {
   order: string;
 }
 
+function getStringSetting(
+  runtime: IAgentRuntime | undefined,
+  key: string,
+  fallback: string,
+): string {
+  const value = runtime?.getSetting(key);
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+
+function formatLogError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 /**
  * Kamino Liquidity Protocol Service
  * Handles interactions with Kamino liquidity protocol using the official API
@@ -189,11 +204,14 @@ export class KaminoLiquidityService extends Service {
   capabilityDescription =
     "Provides detailed access to Kamino liquidity protocol pools and strategies for specific tokens via the official API." as const;
 
-  constructor(runtime: AgentRuntime) {
+  constructor(runtime?: IAgentRuntime) {
     super(runtime);
 
-    this.apiBaseUrl =
-      runtime.getSetting("KAMINO_API_URL") || KAMINO_API_BASE_URL;
+    this.apiBaseUrl = getStringSetting(
+      runtime,
+      "KAMINO_API_URL",
+      KAMINO_API_BASE_URL,
+    );
 
     logger.log(
       `KaminoLiquidityService initialized with API: ${this.apiBaseUrl}`,
@@ -225,7 +243,10 @@ export class KaminoLiquidityService extends Service {
 
       return await response.json();
     } catch (error) {
-      logger.error(`API request failed for ${endpoint}:`, error);
+      logger.error(
+        `API request failed for ${endpoint}:`,
+        formatLogError(error),
+      );
       throw error;
     }
   }
@@ -304,7 +325,7 @@ export class KaminoLiquidityService extends Service {
     } catch (error) {
       logger.error(
         `Error resolving token ${tokenIdentifier} with Birdeye:`,
-        error,
+        formatLogError(error),
       );
       return null;
     }
@@ -321,7 +342,7 @@ export class KaminoLiquidityService extends Service {
       logger.log(`Found ${yields.length} staking yields`);
       return yields;
     } catch (error) {
-      logger.error("Error fetching staking yields:", error);
+      logger.error("Error fetching staking yields:", formatLogError(error));
       return [];
     }
   }
@@ -338,7 +359,10 @@ export class KaminoLiquidityService extends Service {
       logger.log(`Found ${yields.length} median staking yields`);
       return yields;
     } catch (error) {
-      logger.error("Error fetching median staking yields:", error);
+      logger.error(
+        "Error fetching median staking yields:",
+        formatLogError(error),
+      );
       return [];
     }
   }
@@ -366,7 +390,7 @@ export class KaminoLiquidityService extends Service {
       logger.log(`Found ${trades.length} Limo trades`);
       return trades;
     } catch (error) {
-      logger.error("Error fetching Limo trades:", error);
+      logger.error("Error fetching Limo trades:", formatLogError(error));
       return [];
     }
   }
@@ -434,7 +458,7 @@ export class KaminoLiquidityService extends Service {
       logger.log("Market statistics retrieved successfully");
       return stats;
     } catch (error) {
-      logger.error("Error fetching market statistics:", error);
+      logger.error("Error fetching market statistics:", formatLogError(error));
       return null;
     }
   }
@@ -512,7 +536,7 @@ export class KaminoLiquidityService extends Service {
       logger.log(`Found ${strategies.length} strategies from API data`);
       return strategies;
     } catch (error) {
-      logger.error("Error getting all strategies:", error);
+      logger.error("Error getting all strategies:", formatLogError(error));
       return [];
     }
   }
@@ -602,7 +626,7 @@ export class KaminoLiquidityService extends Service {
       logger.log(`No strategy found for address: ${strategyAddress}`);
       return null;
     } catch (error) {
-      logger.error("Error getting strategy by address:", error);
+      logger.error("Error getting strategy by address:", formatLogError(error));
       return null;
     }
   }
@@ -621,13 +645,13 @@ export class KaminoLiquidityService extends Service {
 
       if (strategy) {
         // Get additional token information if available
-        let tokenInfo = null;
+        let tokenInfo: TokenInfo | null = null;
         try {
           tokenInfo = await this.resolveTokenWithBirdeye(strategy.tokenA);
         } catch (error) {
           logger.warn(
             `Could not resolve token info for ${strategy.tokenA}:`,
-            error,
+            formatLogError(error),
           );
         }
 
@@ -664,7 +688,10 @@ export class KaminoLiquidityService extends Service {
           };
         }
       } catch (error) {
-        logger.warn(`Could not resolve token info for ${poolAddress}:`, error);
+        logger.warn(
+          `Could not resolve token info for ${poolAddress}:`,
+          formatLogError(error),
+        );
       }
 
       logger.log(
@@ -672,7 +699,7 @@ export class KaminoLiquidityService extends Service {
       );
       return null;
     } catch (error) {
-      logger.error("Error getting pool by address:", error);
+      logger.error("Error getting pool by address:", formatLogError(error));
       return null;
     }
   }
@@ -691,7 +718,6 @@ export class KaminoLiquidityService extends Service {
 
       // Normalize token identifier
       const normalizedToken = this.normalizeTokenIdentifier(tokenIdentifier);
-      console.log("normalizedToken", normalizedToken);
 
       const stats: TokenLiquidityStats = {
         tokenIdentifier: tokenIdentifier,
@@ -803,7 +829,10 @@ export class KaminoLiquidityService extends Service {
           logger.log(`No strategies found involving token: ${normalizedToken}`);
         }
       } catch (apiError) {
-        logger.error("Error fetching strategies via API:", apiError);
+        logger.error(
+          "Error fetching strategies via API:",
+          formatLogError(apiError),
+        );
         logger.log(
           `API method failed, returning basic token info for ${normalizedToken}`,
         );
@@ -811,7 +840,10 @@ export class KaminoLiquidityService extends Service {
 
       return stats;
     } catch (error) {
-      logger.error("Error getting token liquidity info:", error);
+      logger.error(
+        "Error getting token liquidity info:",
+        formatLogError(error),
+      );
       throw error;
     }
   }
@@ -1011,6 +1043,8 @@ export class KaminoLiquidityService extends Service {
 
       const results = {
         apiBaseUrl: this.apiBaseUrl,
+        programId: KAMINO_LIQUIDITY_PROGRAM_ID,
+        rpcEndpoint: this.apiBaseUrl,
         connectionTest: false,
         stakingYieldsTest: false,
         limoTradesTest: false,
@@ -1027,7 +1061,7 @@ export class KaminoLiquidityService extends Service {
           `API connection test passed. Found ${stakingYields.length} staking yields`,
         );
       } catch (error) {
-        logger.error("API connection test failed:", error);
+        logger.error("API connection test failed:", formatLogError(error));
       }
 
       // Test Limo trades endpoint
@@ -1038,7 +1072,7 @@ export class KaminoLiquidityService extends Service {
           `Limo trades test passed. Found ${limoTrades.length} trades`,
         );
       } catch (error) {
-        logger.error("Limo trades test failed:", error);
+        logger.error("Limo trades test failed:", formatLogError(error));
       }
 
       // Test strategy discovery
@@ -1049,30 +1083,30 @@ export class KaminoLiquidityService extends Service {
           `Strategy discovery test: ${strategies.length} strategies found`,
         );
       } catch (error) {
-        logger.error("Strategy discovery test failed:", error);
+        logger.error("Strategy discovery test failed:", formatLogError(error));
       }
 
       logger.log("Connection test completed");
       return results;
     } catch (error) {
-      logger.error("Error in connection test:", error);
+      logger.error("Error in connection test:", formatLogError(error));
       throw error;
     }
   }
 
   // Service lifecycle methods
 
-  static async create(runtime: AgentRuntime): Promise<KaminoLiquidityService> {
+  static async create(runtime: IAgentRuntime): Promise<KaminoLiquidityService> {
     return new KaminoLiquidityService(runtime);
   }
 
-  static async start(runtime: AgentRuntime): Promise<KaminoLiquidityService> {
+  static async start(runtime: IAgentRuntime): Promise<KaminoLiquidityService> {
     const service = new KaminoLiquidityService(runtime);
     await service.start();
     return service;
   }
 
-  static async stop(runtime: AgentRuntime): Promise<void> {
+  static async stop(runtime: IAgentRuntime): Promise<void> {
     const service = runtime.getService(
       "KAMINO_LIQUIDITY_SERVICE",
     ) as KaminoLiquidityService;
@@ -1092,12 +1126,15 @@ export class KaminoLiquidityService extends Service {
 
       // Test connection on startup
       const testResults = await this.testConnection();
-      logger.log("Startup connection test results:", testResults);
+      logger.log({ testResults }, "Startup connection test results");
 
       this.isRunning = true;
       logger.log("KaminoLiquidityService started successfully");
     } catch (error) {
-      logger.error("Failed to start KaminoLiquidityService:", error);
+      logger.error(
+        "Failed to start KaminoLiquidityService:",
+        formatLogError(error),
+      );
       throw error;
     }
   }
@@ -1112,7 +1149,10 @@ export class KaminoLiquidityService extends Service {
       this.isRunning = false;
       logger.log("KaminoLiquidityService stopped successfully");
     } catch (error) {
-      logger.error("Failed to stop KaminoLiquidityService:", error);
+      logger.error(
+        "Failed to stop KaminoLiquidityService:",
+        formatLogError(error),
+      );
       throw error;
     }
   }