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

package/src/analytics/news/index.ts

@@ -1,5 +1,4 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
-import type { Plugin } from "@elizaos/core";
+import type { IAgentRuntime, Plugin } from "@elizaos/core";
 // Providers
 import { defiNewsProvider } from "./providers/defiNewsProvider";
 // Services
@@ -37,6 +36,12 @@ export const defiNewsPlugin: Plugin = {
   providers: [defiNewsProvider],
   actions: [],
   services: [NewsDataService],
+  async dispose(runtime: IAgentRuntime) {
+    const svc = runtime.getService<NewsDataService>(
+      NewsDataService.serviceType,
+    );
+    await svc?.stop();
+  },
 };
 
 export default defiNewsPlugin;

package/src/analytics/news/interfaces/types.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import type { IAgentRuntime, Memory, State } from "@elizaos/core";
 
 /**

package/src/analytics/news/providers/defiNewsProvider.ts

@@ -1,4 +1,3 @@
-// @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 { NewsDataService } from "../services/newsDataService";
 
@@ -29,10 +28,13 @@ interface CoinGeckoSearchResult {
 interface CoinGeckoCoinData {
   name: string;
   symbol: string;
+  market_cap_rank?: number;
   market_data?: {
     current_price?: { usd?: number };
     market_cap?: { usd?: number };
     total_volume?: { usd?: number };
+    high_24h?: { usd?: number };
+    low_24h?: { usd?: number };
     price_change_percentage_24h?: number;
     price_change_percentage_7d?: number;
     price_change_percentage_30d?: number;
@@ -40,6 +42,11 @@ interface CoinGeckoCoinData {
   community_data?: {
     twitter_followers?: number;
     reddit_subscribers?: number;
+    telegram_channel_user_count?: number;
+  };
+  developer_data?: {
+    forks?: number;
+    stars?: number;
   };
 }
 
@@ -92,7 +99,7 @@ export const defiNewsProvider: Provider = {
   description:
     "Provides DeFi market data, global crypto statistics, token information, and real-world crypto news",
   descriptionCompressed:
-    "provide DeFi market data, global crypto statistic, token information, real-world crypto new",
+    "DeFi market data, crypto stats, token info, crypto news",
   dynamic: true,
   contexts: ["finance", "crypto", "wallet"],
   contextGate: { anyOf: ["finance", "crypto", "wallet"] },
@@ -100,8 +107,6 @@ export const defiNewsProvider: Provider = {
   cacheScope: "turn",
   roleGate: { minRole: "USER" },
   get: async (runtime: IAgentRuntime, message: Memory, _state: State) => {
-    console.log("DEFI_NEWS provider called");
-
     let defiNewsInfo = "";
 
     try {
@@ -114,7 +119,6 @@ export const defiNewsProvider: Provider = {
       ) as NewsDataService;
 
       if (!newsDataService) {
-        console.log("NewsData service not available");
         return {
           data: {},
           values: {},
@@ -122,10 +126,8 @@ export const defiNewsProvider: Provider = {
         };
       }
 
-      console.log("DeFi News services found, generating report...");
-
       // Check if a specific token is mentioned in the message
-      const messageText = message.content?.text || "";
+      const messageText = message.content.text || "";
 
       defiNewsInfo += `=== DEFI & CRYPTO MARKET REPORT ===\n\n`;
 
@@ -139,8 +141,6 @@ export const defiNewsProvider: Provider = {
         extractedSymbols.unshift(namedSymbol); // Add to front
       }
 
-      console.log(`Extracted symbols: ${extractedSymbols.join(", ")}`);
-
       // If token symbols are detected and services are available, look them up
       if (extractedSymbols.length > 0 && coinGeckoService) {
         // Try to get Birdeye service for symbol lookup
@@ -154,8 +154,6 @@ export const defiNewsProvider: Provider = {
         if (birdeyeService && solanaService) {
           // Process up to 3 tokens
           for (const detectedSymbol of extractedSymbols.slice(0, 3)) {
-            console.log(`Looking up symbol: ${detectedSymbol}`);
-
             try {
               // Look up token by symbol across all chains
               const options =
@@ -164,17 +162,11 @@ export const defiNewsProvider: Provider = {
                 (t) => t.symbol.toUpperCase() === detectedSymbol.toUpperCase(),
               );
 
-              console.log(
-                `Birdeye found ${exactOptions.length} exact matches for ${detectedSymbol}`,
-              );
-
               if (exactOptions.length > 0) {
                 // Use the first exact match (usually the most popular/main token)
                 const tokenOption = exactOptions[0];
                 const tokenCA = tokenOption.address;
 
-                console.log(`Using token: ${tokenOption.symbol} at ${tokenCA}`);
-
                 // Verify it's actually a token
                 const addressType = await solanaService.getAddressType(tokenCA);
 
@@ -188,28 +180,16 @@ export const defiNewsProvider: Provider = {
                   if (tokenData) {
                     defiNewsInfo += tokenData;
                   }
-                } else {
-                  console.log(
-                    `Address ${tokenCA} is not a Token, it's a ${addressType}`,
-                  );
                 }
-              } else {
-                console.log(
-                  `No exact matches found for ${detectedSymbol}, skipping...`,
-                );
               }
             } catch (error) {
-              console.log(
-                `Error looking up ${detectedSymbol} via Birdeye:`,
-                error,
+              runtime.logger.warn(
+                `[DEFI_NEWS] error looking up ${detectedSymbol} via Birdeye: ${error instanceof Error ? error.message : String(error)}`,
               );
             }
           }
         } else {
           // Fallback to CoinGecko ID lookup for major tokens
-          console.log(
-            "Birdeye or Solana service not available, using CoinGecko fallback",
-          );
           for (const detectedSymbol of extractedSymbols.slice(0, 1)) {
             const coingeckoId = getCoinGeckoIdFromSymbol(detectedSymbol);
             if (coingeckoId) {
@@ -233,7 +213,6 @@ export const defiNewsProvider: Provider = {
         const globalCryptoData = await getGlobalCryptoData(coinGeckoService);
         defiNewsInfo += globalCryptoData;
       } else {
-        console.log("CoinGecko service not available, skipping market data");
         defiNewsInfo +=
           "⚠️ Market data unavailable (CoinGecko service not configured)\n\n";
       }
@@ -276,7 +255,7 @@ export const extractSymbols = (
   // strict mode will only extract symbols that are clearly formatted as a symbol using $SOL format
   mode: "strict" | "loose" = "loose",
 ): string[] => {
-  if (!text?.matchAll) return [];
+  if (!text.matchAll) return [];
   const symbols = new Set<string>();
 
   // Match patterns
@@ -557,15 +536,11 @@ async function getTokenInfoByAddress(
         tokenSymbol = onChainSymbol;
       }
     } catch (_error) {
-      console.log("Could not fetch on-chain symbol, using provided:", symbol);
+      // fall back to provided symbol when on-chain lookup fails
     }
 
-    console.log(
-      `Fetching CoinGecko data for ${tokenSymbol} at ${tokenAddress}`,
-    );
-
     // Try to search CoinGecko by symbol
-    let coinData = null;
+    let coinData: CoinGeckoCoinData | null = null;
     const searchResults = await coinGeckoService.searchCoin(tokenSymbol);
 
     if (searchResults && searchResults.length > 0) {
@@ -576,11 +551,9 @@ async function getTokenInfoByAddress(
       );
 
       if (solanaMatch) {
-        console.log(`Found exact Solana platform match: ${solanaMatch.id}`);
         coinData = await coinGeckoService.getCoinData(solanaMatch.id);
       } else {
         // Use first result as fallback
-        console.log(`Using first search result: ${searchResults[0].id}`);
         coinData = await coinGeckoService.getCoinData(searchResults[0].id);
       }
     }
@@ -608,8 +581,8 @@ async function getTokenInfoByAddress(
       if (md.total_volume?.usd) {
         tokenInfo += `   24h Volume: $${(md.total_volume.usd / 1e9).toFixed(2)}B\n`;
       }
-      if (md.market_cap_rank) {
-        tokenInfo += `   Market Cap Rank: #${md.market_cap_rank}\n`;
+      if (coinData.market_cap_rank) {
+        tokenInfo += `   Market Cap Rank: #${coinData.market_cap_rank}\n`;
       }
 
       tokenInfo += "\n📈 PRICE CHANGES:\n";

package/src/analytics/news/services/newsDataService.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 import type { IAgentRuntime } from "@elizaos/core";
 import { Service } from "@elizaos/core";
 import type { RealWorldNewsArticle } from "../interfaces/types";
@@ -31,13 +30,6 @@ export class NewsDataService extends Service {
     return "Provides real-world cryptocurrency news and events from Brave New Coin RSS feed";
   }
 
-  constructor(runtime?: IAgentRuntime) {
-    super(runtime);
-    console.log(
-      "✅ [NewsDataService] Initialized with Brave New Coin RSS feed",
-    );
-  }
-
   /**
    * Start the NewsData service (static method for framework)
    */
@@ -59,9 +51,7 @@ export class NewsDataService extends Service {
   /**
    * Stop the service instance
    */
-  async stop(): Promise<void> {
-    console.log("✅ [NewsDataService] Stopped");
-  }
+  async stop(): Promise<void> {}
 
   /**
    * Parse RSS XML to extract news items
@@ -198,10 +188,6 @@ export class NewsDataService extends Service {
       const limit = options?.limit || 10;
       const query = options?.query?.toLowerCase();
 
-      console.log(
-        `🔍 [NewsDataService] Fetching news from Brave New Coin RSS feed`,
-      );
-
       const response = await fetch(this.rssUrl, {
         method: "GET",
         headers: {
@@ -222,10 +208,6 @@ export class NewsDataService extends Service {
       const xmlText = await response.text();
       const rssItems = this.parseRSS(xmlText);
 
-      console.log(
-        `✅ [NewsDataService] Parsed ${rssItems.length} news articles from RSS`,
-      );
-
       // Convert RSS items to RealWorldNewsArticle format
       let articles: RealWorldNewsArticle[] = rssItems.map((item, index) => ({
         article_id: item.guid || `bnc-${Date.now()}-${index}`,
@@ -260,9 +242,6 @@ export class NewsDataService extends Service {
             `${article.title} ${article.description || ""} ${article.content || ""} ${article.category?.join(" ") || ""}`.toLowerCase();
           return searchText.includes(query);
         });
-        console.log(
-          `🔍 [NewsDataService] Filtered to ${articles.length} articles matching query: ${query}`,
-        );
       }
 
       // Limit results

package/src/analytics/news/utils/formatters.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import {
+  extractTokenSymbol,
+  formatCurrency,
+  formatNumber,
+  formatPercentage,
+  getSentimentEmoji,
+  isValidTokenAddress,
+  stripHtml,
+  truncateText,
+} from "./formatters.js";
+
+/**
+ * DeFi news formatters render financial figures and validate token addresses.
+ * Magnitude suffixes, percent sign/emoji, and address-shape validation must be
+ * exact — isValidTokenAddress in particular gates EVM/Solana address inputs.
+ */
+
+describe("formatCurrency", () => {
+  it("scales with T/B/M/K suffixes", () => {
+    expect(formatCurrency(1.5e12)).toBe("$1.50T");
+    expect(formatCurrency(2.5e9)).toBe("$2.50B");
+    expect(formatCurrency(3.5e6)).toBe("$3.50M");
+    expect(formatCurrency(4.5e3)).toBe("$4.50K");
+    expect(formatCurrency(12.3)).toBe("$12.30");
+  });
+});
+
+describe("formatPercentage", () => {
+  it("adds sign + trend emoji", () => {
+    expect(formatPercentage(5)).toBe("📈 +5.00%");
+    expect(formatPercentage(-3.2)).toBe("📉 -3.20%");
+  });
+});
+
+describe("text helpers", () => {
+  it("truncateText, getSentimentEmoji, formatNumber, extractTokenSymbol, stripHtml", () => {
+    expect(truncateText("short", 200)).toBe("short");
+    expect(truncateText("abcdef", 3)).toBe("abc...");
+    expect(getSentimentEmoji("positive")).toBe("😊");
+    expect(getSentimentEmoji("negative")).toBe("😟");
+    expect(getSentimentEmoji(undefined)).toBe("😐");
+    expect(formatNumber(1234567)).toBe("1,234,567");
+    expect(extractTokenSymbol("buy some WBTC now")).toBe("WBTC");
+    expect(extractTokenSymbol("nothing here")).toBeNull();
+    expect(stripHtml("<p>hi <b>there</b></p>")).toBe("hi there");
+  });
+});
+
+describe("isValidTokenAddress", () => {
+  it("accepts EVM + Solana shapes, rejects others", () => {
+    expect(isValidTokenAddress(`0x${"a".repeat(40)}`)).toBe(true);
+    expect(
+      isValidTokenAddress("So11111111111111111111111111111111111111112"),
+    ).toBe(true);
+    expect(isValidTokenAddress("0x123")).toBe(false); // too short
+    expect(isValidTokenAddress(`0x${"g".repeat(40)}`)).toBe(false); // non-hex
+    expect(isValidTokenAddress("not an address")).toBe(false);
+  });
+});

package/src/analytics/news/utils/formatters.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
 /**
  * Utility functions for formatting DeFi news data
  */

package/src/analytics/token-info/action.ts

@@ -1,5 +1,4 @@
 import type {
-  Action,
   ActionResult,
   HandlerCallback,
   HandlerOptions,
@@ -7,41 +6,8 @@ import type {
   Memory,
   State,
 } from "@elizaos/core";
-import { parseTokenInfoParams, selectedContextMatches } from "./params";
+import { parseTokenInfoParams } from "./params";
 import { TOKEN_INFO_SERVICE_TYPE, type TokenInfoService } from "./service";
-import { TOKEN_INFO_SUBACTIONS } from "./types";
-
-const TOKEN_INFO_CONTEXTS = ["finance", "crypto", "wallet"] as const;
-const TOKEN_INFO_KEYWORDS = [
-  "token",
-  "coin",
-  "crypto",
-  "dexscreener",
-  "birdeye",
-  "coingecko",
-  "price",
-  "pair",
-  "pairs",
-  "market cap",
-  "liquidity",
-  "trending",
-  "wallet",
-  "portfolio",
-  "boosted",
-  "profile",
-] as const;
-
-function hasTokenInfoIntent(message: Memory, state?: State): boolean {
-  const text = [
-    typeof message.content?.text === "string" ? message.content.text : "",
-    typeof state?.values?.recentMessages === "string"
-      ? state.values.recentMessages
-      : "",
-  ]
-    .join("\n")
-    .toLowerCase();
-  return TOKEN_INFO_KEYWORDS.some((keyword) => text.includes(keyword));
-}
 
 function unavailable(
   callback: HandlerCallback | undefined,
@@ -49,7 +15,7 @@ function unavailable(
   data: Record<string, unknown>,
 ): ActionResult {
   const dataAsContent = data as Parameters<HandlerCallback>[0]["data"];
-  callback?.({ text, actions: ["TOKEN_INFO"], data: dataAsContent });
+  callback?.({ text, actions: ["WALLET"], data: dataAsContent });
   return {
     success: false,
     text,
@@ -58,183 +24,57 @@ function unavailable(
   };
 }
 
-export const tokenInfoAction: Action = {
-  name: "TOKEN_INFO",
-  contexts: [...TOKEN_INFO_CONTEXTS],
-  contextGate: { anyOf: [...TOKEN_INFO_CONTEXTS] },
-  roleGate: { minRole: "USER" },
-  similes: [
-    "DEXSCREENER_SEARCH",
-    "DEXSCREENER_TOKEN_INFO",
-    "DEXSCREENER_TRENDING",
-    "DEXSCREENER_NEW_PAIRS",
-    "DEXSCREENER_CHAIN_PAIRS",
-    "DEXSCREENER_BOOSTED_TOKENS",
-    "DEXSCREENER_TOKEN_PROFILES",
-    "BIRDEYE_LOOKUP",
-    "BIRDEYE_TOKEN_SEARCH",
-    "TOKEN_SEARCH",
-    "TOKEN_LOOKUP",
-    "TOKEN_PRICE",
-    "COINGECKO",
-  ],
-  description:
-    "Fetch crypto token and market information from registered providers. target selects provider (dexscreener, birdeye, coingecko). subaction selects search, token, trending, new-pairs, chain-pairs, boosted, profiles, or wallet.",
-  descriptionCompressed:
-    "Crypto token info provider registry: target dexscreener|birdeye|coingecko; subaction search|token|trending|new-pairs|chain-pairs|boosted|profiles|wallet.",
-  parameters: [
-    {
-      name: "target",
-      description:
-        "Provider to use. Omit to use the default provider for the subaction.",
-      required: false,
-      schema: { type: "string", enum: ["dexscreener", "birdeye", "coingecko"] },
-      examples: ["dexscreener", "birdeye", "coingecko"],
-    },
-    {
-      name: "subaction",
-      description: "Token information operation.",
-      required: true,
-      schema: { type: "string", enum: [...TOKEN_INFO_SUBACTIONS] },
-      examples: ["search", "token", "trending", "wallet"],
-    },
-    {
-      name: "query",
-      description:
-        "Search query, coin id, token symbol, token address, or wallet address.",
-      required: false,
-      schema: { type: "string" },
-    },
-    {
-      name: "address",
-      description: "Token or wallet address.",
-      required: false,
-      schema: { type: "string" },
-    },
-    {
-      name: "tokenAddress",
-      description: "Token contract address.",
-      required: false,
-      schema: { type: "string" },
-    },
-    {
-      name: "chain",
-      description:
-        "Chain/network for provider operations that need one, such as chain-pairs or CoinGecko contract lookup.",
-      required: false,
-      schema: { type: "string" },
-      examples: ["ethereum", "solana", "base"],
-    },
-    {
-      name: "timeframe",
-      description: "Trending window when supported.",
-      required: false,
-      schema: { type: "string", enum: ["1h", "6h", "24h"], default: "24h" },
-    },
-    {
-      name: "limit",
-      description: "Maximum result count.",
-      required: false,
-      schema: { type: "number", minimum: 1, maximum: 100, default: 10 },
-    },
-    {
-      name: "sortBy",
-      description: "Pair ranking metric for chain-pairs.",
-      required: false,
-      schema: {
-        type: "string",
-        enum: ["volume", "liquidity", "priceChange", "txns"],
-      },
-    },
-    {
-      name: "top",
-      description: "For boosted tokens, return top boosted rather than latest.",
-      required: false,
-      schema: { type: "boolean", default: false },
-    },
-    {
-      name: "id",
-      description: "CoinGecko coin id.",
-      required: false,
-      schema: { type: "string" },
-    },
-  ],
-  validate: async (_runtime, message, state) =>
-    selectedContextMatches(state, TOKEN_INFO_CONTEXTS) ||
-    hasTokenInfoIntent(message, state),
-  handler: async (
-    runtime: IAgentRuntime,
-    message: Memory,
-    state?: State,
-    options?: HandlerOptions | Record<string, unknown>,
-    callback?: HandlerCallback,
-  ): Promise<ActionResult> => {
-    const service = runtime.getService(
-      TOKEN_INFO_SERVICE_TYPE,
-    ) as TokenInfoService | null;
-    if (!service || typeof service.route !== "function") {
-      return unavailable(callback, "Token info service is not available.", {
-        actionName: "TOKEN_INFO",
-        error: "SERVICE_UNAVAILABLE",
-      });
-    }
-
-    const params = parseTokenInfoParams(message, state, options);
-    const routed = await service.route({
-      runtime,
-      message,
-      state,
-      options,
-      params,
-      callback,
+/**
+ * Folded into WALLET as `action=token_info`. Routes token-info queries through
+ * the registered TokenInfoService providers (DexScreener, Birdeye, CoinGecko).
+ */
+export async function tokenInfoHandler(
+  runtime: IAgentRuntime,
+  message: Memory,
+  state?: State,
+  options?: HandlerOptions | Record<string, unknown>,
+  callback?: HandlerCallback,
+): Promise<ActionResult> {
+  const service = runtime.getService(
+    TOKEN_INFO_SERVICE_TYPE,
+  ) as TokenInfoService | null;
+  if (!service || typeof service.route !== "function") {
+    return unavailable(callback, "Token info service is not available.", {
+      actionName: "WALLET",
+      subaction: "token_info",
+      error: "SERVICE_UNAVAILABLE",
     });
+  }
 
-    if (routed.ok) {
-      const result = routed.result;
-      return {
-        ...result,
-        data: {
-          ...(result.data ?? {}),
-          actionName: "TOKEN_INFO",
-          target: routed.provider.name,
-          supportedProviders: service.listProviders(),
-        },
-      };
-    }
+  const params = parseTokenInfoParams(message, state, options);
+  const routed = await service.route({
+    runtime,
+    message,
+    state,
+    options,
+    params,
+    callback,
+  });
 
-    return unavailable(callback, routed.detail, {
-      actionName: "TOKEN_INFO",
-      error: routed.error,
-      detail: routed.detail,
-      providers: routed.providers,
-    });
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Search for PEPE on DexScreener" },
+  if (routed.ok) {
+    const result = routed.result;
+    return {
+      ...result,
+      data: {
+        ...(result.data ?? {}),
+        actionName: "WALLET",
+        subaction: "token_info",
+        target: routed.provider.name,
+        supportedProviders: service.listProviders(),
       },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "Searching DexScreener.",
-          action: "TOKEN_INFO",
-        },
-      },
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Look up bitcoin on CoinGecko" },
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "Looking up Bitcoin on CoinGecko.",
-          action: "TOKEN_INFO",
-        },
-      },
-    ],
-  ],
-};
+    };
+  }
+
+  return unavailable(callback, routed.detail, {
+    actionName: "WALLET",
+    subaction: "token_info",
+    error: routed.error,
+    detail: routed.detail,
+    providers: routed.providers,
+  });
+}

package/src/analytics/token-info/index.ts

@@ -1,3 +1,3 @@
-export { tokenInfoAction } from "./action";
+export { tokenInfoHandler } from "./action";
 export { TOKEN_INFO_SERVICE_TYPE, TokenInfoService } from "./service";
 export * from "./types";