@elizaos/plugin-wallet 2.0.0-beta.1

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

@@ -0,0 +1,332 @@
+// @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";
+
+/**
+ * RSS Feed Item Interface
+ */
+interface RSSItem {
+  title?: string;
+  link?: string;
+  description?: string;
+  pubDate?: string;
+  category?: string[];
+  guid?: string;
+  content?: string;
+  creator?: string;
+}
+
+/**
+ * Brave New Coin RSS Service for Real-World Crypto Events
+ *
+ * This service fetches real-world news and events related to cryptocurrency
+ * from Brave New Coin RSS feed.
+ */
+export class NewsDataService extends Service {
+  static serviceType = "NEWS_DATA_SERVICE";
+  private rssUrl: string = "https://bravenewcoin.com/rss/insights";
+
+  get capabilityDescription(): string {
+    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)
+   */
+  static async start(runtime: IAgentRuntime) {
+    const service = new NewsDataService(runtime);
+    return service;
+  }
+
+  /**
+   * Stop the NewsData service (static method for framework)
+   */
+  static async stop(runtime: IAgentRuntime) {
+    const service = runtime.getService(NewsDataService.serviceType);
+    if (!service) {
+      throw new Error(`${NewsDataService.serviceType} service not found`);
+    }
+  }
+
+  /**
+   * Stop the service instance
+   */
+  async stop(): Promise<void> {
+    console.log("✅ [NewsDataService] Stopped");
+  }
+
+  /**
+   * Parse RSS XML to extract news items
+   */
+  private parseRSS(xmlText: string): RSSItem[] {
+    const items: RSSItem[] = [];
+
+    try {
+      // Extract all <item> blocks from the RSS feed
+      const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+      const itemMatches = xmlText.matchAll(itemRegex);
+
+      for (const match of itemMatches) {
+        const itemXml = match[1];
+
+        // Extract individual fields
+        const title = this.decodeHtmlEntities(
+          this.extractTag(itemXml, "title") || "",
+        );
+        const link = this.extractTag(itemXml, "link");
+        const description = this.extractTag(itemXml, "description");
+        const pubDate = this.extractTag(itemXml, "pubDate");
+        const guid = this.extractTag(itemXml, "guid");
+        const creator =
+          this.extractTag(itemXml, "dc:creator") ||
+          this.extractTag(itemXml, "author");
+        const content = this.extractTag(itemXml, "content:encoded");
+
+        // Extract categories (handle CDATA)
+        const categoryRegex =
+          /<category>(?:<!\[CDATA\[)?(.*?)(?:\]\]>)?<\/category>/gs;
+        const categories: string[] = [];
+        for (;;) {
+          const categoryMatch = categoryRegex.exec(itemXml);
+          if (categoryMatch === null) break;
+          const cat = categoryMatch[1].trim();
+          if (cat) {
+            categories.push(cat);
+          }
+        }
+
+        items.push({
+          title,
+          link,
+          description,
+          pubDate,
+          category: categories.length > 0 ? categories : undefined,
+          guid,
+          creator,
+          content,
+        });
+      }
+    } catch (error) {
+      console.error("❌ [NewsDataService] Error parsing RSS:", error);
+    }
+
+    return items;
+  }
+
+  /**
+   * Extract content from XML tag
+   */
+  private extractTag(xml: string, tagName: string): string | undefined {
+    const regex = new RegExp(
+      `<${tagName}[^>]*><!\\[CDATA\\[(.*?)\\]\\]><\\/${tagName}>`,
+      "s",
+    );
+    const cdataMatch = xml.match(regex);
+    if (cdataMatch) {
+      return cdataMatch[1].trim();
+    }
+
+    const simpleRegex = new RegExp(
+      `<${tagName}[^>]*>(.*?)<\\/${tagName}>`,
+      "s",
+    );
+    const simpleMatch = xml.match(simpleRegex);
+    if (simpleMatch) {
+      return simpleMatch[1].trim();
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Strip HTML tags from text
+   */
+  private stripHtml(html: string): string {
+    return html.replace(/<[^>]*>/g, "").trim();
+  }
+
+  /**
+   * Decode HTML entities (e.g., &#8217; to ')
+   */
+  private decodeHtmlEntities(text: string): string {
+    const entities: Record<string, string> = {
+      "&#8217;": "'",
+      "&#8216;": "'",
+      "&#8220;": '"',
+      "&#8221;": '"',
+      "&#8211;": "–",
+      "&#8212;": "—",
+      "&#038;": "&",
+      "&amp;": "&",
+      "&lt;": "<",
+      "&gt;": ">",
+      "&quot;": '"',
+      "&#39;": "'",
+    };
+
+    let decoded = text;
+    for (const [entity, char] of Object.entries(entities)) {
+      decoded = decoded.replace(new RegExp(entity, "g"), char);
+    }
+
+    // Handle numeric entities
+    decoded = decoded.replace(/&#(\d+);/g, (_match, dec) => {
+      return String.fromCharCode(dec);
+    });
+
+    return decoded;
+  }
+
+  /**
+   * Fetch latest crypto news from Brave New Coin RSS feed
+   */
+  async getLatestNews(options?: {
+    query?: string;
+    language?: string;
+    category?: string;
+    limit?: number;
+  }): Promise<RealWorldNewsArticle[]> {
+    try {
+      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: {
+          "User-Agent": "Mozilla/5.0 (compatible; SpartanBot/1.0)",
+        },
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(
+          `❌ [NewsDataService] RSS fetch error (${response.status}): ${errorText}`,
+        );
+        throw new Error(
+          `RSS fetch error: ${response.status} ${response.statusText}`,
+        );
+      }
+
+      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}`,
+        title: item.title || "Untitled",
+        link: item.link || "",
+        description: item.description
+          ? this.decodeHtmlEntities(this.stripHtml(item.description))
+          : undefined,
+        pubDate: item.pubDate || new Date().toISOString(),
+        source_id: "bravenewcoin",
+        source_priority: 1,
+        source_url: "https://bravenewcoin.com",
+        language: "en",
+        category: item.category,
+        creator: item.creator ? [item.creator] : undefined,
+        keywords: undefined,
+        video_url: null,
+        content: item.content ? this.stripHtml(item.content) : undefined,
+        image_url: undefined,
+        source_icon: undefined,
+        country: undefined,
+        ai_tag: undefined,
+        sentiment: undefined,
+        sentiment_stats: undefined,
+        ai_region: undefined,
+      }));
+
+      // Filter by query if provided
+      if (query) {
+        articles = articles.filter((article) => {
+          const searchText =
+            `${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
+      articles = articles.slice(0, limit);
+
+      return articles;
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(
+          "❌ [NewsDataService] Error fetching news:",
+          error.message,
+        );
+        throw error;
+      } else {
+        console.error("❌ [NewsDataService] Unknown error:", error);
+        throw new Error("Failed to fetch news from Brave New Coin RSS");
+      }
+    }
+  }
+
+  /**
+   * Fetch news about a specific token
+   */
+  async getTokenNews(
+    tokenSymbol: string,
+    options?: {
+      language?: string;
+      limit?: number;
+    },
+  ): Promise<RealWorldNewsArticle[]> {
+    const query = tokenSymbol.toLowerCase();
+    return this.getLatestNews({
+      query,
+      language: options?.language,
+      limit: options?.limit,
+    });
+  }
+
+  /**
+   * Fetch DeFi-specific news
+   */
+  async getDefiNews(options?: {
+    language?: string;
+    limit?: number;
+  }): Promise<RealWorldNewsArticle[]> {
+    const query = "defi";
+    return this.getLatestNews({
+      query,
+      language: options?.language,
+      limit: options?.limit,
+    });
+  }
+
+  /**
+   * Fetch blockchain and crypto market news
+   */
+  async getCryptoMarketNews(options?: {
+    language?: string;
+    limit?: number;
+  }): Promise<RealWorldNewsArticle[]> {
+    // Return all crypto news from the feed
+    return this.getLatestNews({
+      language: options?.language,
+      limit: options?.limit,
+    });
+  }
+}

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

@@ -0,0 +1,151 @@
+// @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
+ */
+
+/**
+ * Format a number as currency (USD)
+ */
+export function formatCurrency(value: number, decimals: number = 2): string {
+  if (value >= 1e12) {
+    return `$${(value / 1e12).toFixed(decimals)}T`;
+  } else if (value >= 1e9) {
+    return `$${(value / 1e9).toFixed(decimals)}B`;
+  } else if (value >= 1e6) {
+    return `$${(value / 1e6).toFixed(decimals)}M`;
+  } else if (value >= 1e3) {
+    return `$${(value / 1e3).toFixed(decimals)}K`;
+  } else {
+    return `$${value.toFixed(decimals)}`;
+  }
+}
+
+/**
+ * Format a percentage with appropriate emoji
+ */
+export function formatPercentage(value: number, decimals: number = 2): string {
+  const emoji = value >= 0 ? "📈" : "📉";
+  const sign = value >= 0 ? "+" : "";
+  return `${emoji} ${sign}${value.toFixed(decimals)}%`;
+}
+
+/**
+ * Format a timestamp as a human-readable date
+ */
+export function formatDate(timestamp: number | string): string {
+  const date = new Date(timestamp);
+  return date.toLocaleString();
+}
+
+/**
+ * Format a relative time (e.g., "2 hours ago")
+ */
+export function formatRelativeTime(timestamp: number | string): string {
+  const now = Date.now();
+  const date = new Date(timestamp).getTime();
+  const diff = now - date;
+
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) {
+    return `${days} day${days > 1 ? "s" : ""} ago`;
+  } else if (hours > 0) {
+    return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+  } else if (minutes > 0) {
+    return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+  } else {
+    return `${seconds} second${seconds > 1 ? "s" : ""} ago`;
+  }
+}
+
+/**
+ * Truncate text to a maximum length
+ */
+export function truncateText(text: string, maxLength: number = 200): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.substring(0, maxLength)}...`;
+}
+
+/**
+ * Get sentiment emoji
+ */
+export function getSentimentEmoji(sentiment?: string): string {
+  if (!sentiment) return "😐";
+
+  switch (sentiment.toLowerCase()) {
+    case "positive":
+      return "😊";
+    case "negative":
+      return "😟";
+    case "neutral":
+      return "😐";
+    default:
+      return "😐";
+  }
+}
+
+/**
+ * Format large numbers with commas
+ */
+export function formatNumber(value: number, decimals: number = 0): string {
+  return value.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  });
+}
+
+/**
+ * Extract token symbol from text
+ */
+export function extractTokenSymbol(text: string): string | null {
+  // Match 3-5 uppercase letters that might be a token symbol
+  const match = text.match(/\b([A-Z]{3,5})\b/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Format OHLCV data for display
+ */
+export function formatOHLCV(candle: {
+  timestamp: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+  volume?: number;
+}): string {
+  const date = formatDate(candle.timestamp);
+  let result = `📅 ${date}\n`;
+  result += `   Open: ${formatCurrency(candle.open)}\n`;
+  result += `   High: ${formatCurrency(candle.high)}\n`;
+  result += `   Low: ${formatCurrency(candle.low)}\n`;
+  result += `   Close: ${formatCurrency(candle.close)}`;
+  if (candle.volume !== undefined) {
+    result += `\n   Volume: ${formatCurrency(candle.volume)}`;
+  }
+  return result;
+}
+
+/**
+ * Clean HTML tags from text
+ */
+export function stripHtml(html: string): string {
+  return html.replace(/<[^>]*>/g, "");
+}
+
+/**
+ * Validate if a string is a valid token address
+ */
+export function isValidTokenAddress(address: string): boolean {
+  // Ethereum address (0x followed by 40 hex characters)
+  const ethRegex = /^0x[a-fA-F0-9]{40}$/;
+  // Solana address (base58, 32-44 characters)
+  const solRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+
+  return ethRegex.test(address) || solRegex.test(address);
+}