@nirholas/bnbchain-mcp 1.0.0

package/src/vendors/predictions/polymarket_client.rs

@@ -0,0 +1,390 @@
+use crate::config::Config;
+use crate::error::{PolymarketError, Result};
+use crate::models::*;
+use reqwest::Client;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::RwLock;
+
+#[derive(Debug, Clone)]
+pub struct CacheEntry<T> {
+    pub data: T,
+    pub timestamp: Instant,
+}
+
+impl<T> CacheEntry<T> {
+    pub fn new(data: T) -> Self {
+        Self {
+            data,
+            timestamp: Instant::now(),
+        }
+    }
+
+    pub fn is_expired(&self, ttl: Duration) -> bool {
+        self.timestamp.elapsed() > ttl
+    }
+}
+
+#[derive(Debug)]
+pub struct PolymarketClient {
+    client: Client,
+    base_url: String,
+    config: Arc<Config>,
+    market_cache: Arc<RwLock<HashMap<String, CacheEntry<Vec<Market>>>>>,
+    single_market_cache: Arc<RwLock<HashMap<String, CacheEntry<Market>>>>,
+}
+
+impl PolymarketClient {
+    pub fn new_with_config(config: &Arc<Config>) -> Result<Self> {
+        let client_builder = Client::builder()
+            .timeout(config.api_timeout())
+            .gzip(true)
+            .pool_max_idle_per_host(10)
+            .pool_idle_timeout(Duration::from_secs(30))
+            .tcp_keepalive(Duration::from_secs(60));
+
+        let client_builder = if let Some(ref api_key) = config.api.api_key {
+            let mut headers = reqwest::header::HeaderMap::new();
+            let auth_value =
+                reqwest::header::HeaderValue::from_str(&format!("Bearer {api_key}"))
+                    .map_err(|e| PolymarketError::config_error(format!("Invalid API key: {e}")))?;
+            headers.insert(reqwest::header::AUTHORIZATION, auth_value);
+            client_builder.default_headers(headers)
+        } else {
+            client_builder
+        };
+
+        let client = client_builder.build().map_err(|e| {
+            PolymarketError::config_error(format!("Failed to build HTTP client: {e}"))
+        })?;
+
+        Ok(Self {
+            client,
+            base_url: config.api.base_url.clone(),
+            config: config.clone(),
+            market_cache: Arc::new(RwLock::new(HashMap::new())),
+            single_market_cache: Arc::new(RwLock::new(HashMap::new())),
+        })
+    }
+
+    async fn make_request_with_retry<T: for<'de> serde::Deserialize<'de>>(
+        &self,
+        url: &str,
+    ) -> Result<T> {
+        let mut last_error = None;
+        let max_retries = self.config.api.max_retries;
+        let mut connection_failures = 0;
+        const MAX_CONNECTION_FAILURES: u32 = 3;
+
+        for attempt in 1..=max_retries {
+            match self.client.get(url).send().await {
+                Ok(response) => {
+                    connection_failures = 0;
+
+                    if response.status().is_success() {
+                        match response.text().await {
+                            Ok(text) => match serde_json::from_str::<T>(&text) {
+                                Ok(data) => return Ok(data),
+                                Err(e) => {
+                                    last_error = Some(PolymarketError::deserialization_error(
+                                        format!("JSON parsing error: {e}"),
+                                    ));
+                                }
+                            },
+                            Err(e) => {
+                                last_error = Some(PolymarketError::network_error(format!(
+                                    "Response reading error: {e}"
+                                )));
+                            }
+                        }
+                    } else {
+                        let status = response.status();
+                        let text = response.text().await.unwrap_or_default();
+
+                        if status.as_u16() == 429 {
+                            tokio::time::sleep(Duration::from_secs(60)).await;
+                        }
+
+                        last_error = Some(PolymarketError::api_error(
+                            format!("HTTP error: {text}"),
+                            Some(status.as_u16()),
+                        ));
+                    }
+                }
+                Err(e) => {
+                    connection_failures += 1;
+
+                    if connection_failures >= MAX_CONNECTION_FAILURES {
+                        tokio::time::sleep(Duration::from_secs(5)).await;
+                    }
+
+                    last_error = Some(PolymarketError::network_error(format!(
+                        "Request error: {e}"
+                    )));
+                }
+            }
+
+            if attempt < max_retries {
+                let base_delay = self.config.retry_delay();
+                let backoff_multiplier = if connection_failures > 0 {
+                    2 * connection_failures
+                } else {
+                    1 << attempt
+                };
+                let jitter = fastrand::f64() * 0.1;
+                let delay_ms = (f64::from(base_delay.as_millis() as u32)
+                    * f64::from(backoff_multiplier)
+                    * (1.0 + jitter)) as u64;
+                let delay = Duration::from_millis(delay_ms.min(30000));
+
+                tokio::time::sleep(delay).await;
+            }
+        }
+
+        let error = last_error
+            .unwrap_or_else(|| PolymarketError::network_error("All retry attempts failed"));
+        Err(error)
+    }
+
+    /// Fetches markets from the Polymarket API with optional filtering parameters.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The API request fails
+    /// - The response cannot be deserialized
+    /// - Query parameters cannot be serialized
+    pub async fn get_markets(&self, params: Option<MarketsQueryParams>) -> Result<Vec<Market>> {
+        let query_params = params.unwrap_or_default();
+        let cache_key = format!(
+            "markets_{}",
+            serde_json::to_string(&query_params).map_err(|e| {
+                PolymarketError::deserialization_error(format!(
+                    "Failed to serialize query params: {e}"
+                ))
+            })?
+        );
+
+        if self.config.cache.enabled {
+            let cache = self.market_cache.read().await;
+            if let Some(entry) = cache.get(&cache_key) {
+                if !entry.is_expired(self.config.cache_ttl()) {
+                    return Ok(entry.data.clone());
+                }
+            }
+        }
+
+        let query_string = query_params.to_query_string();
+        let url = format!("{}/markets{}", self.base_url, query_string);
+        let response: Vec<Market> = self.make_request_with_retry(&url).await?;
+
+        if self.config.cache.enabled {
+            let mut cache = self.market_cache.write().await;
+            cache.insert(cache_key, CacheEntry::new(response.clone()));
+        }
+
+        Ok(response)
+    }
+
+    /// Fetches a specific market by its ID.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The API request fails
+    /// - The market is not found
+    /// - The response cannot be deserialized
+    pub async fn get_market_by_id(&self, market_id: &str) -> Result<Market> {
+        let cache_key = market_id.to_string();
+
+        if self.config.cache.enabled {
+            let cache = self.single_market_cache.read().await;
+            if let Some(entry) = cache.get(&cache_key) {
+                if !entry.is_expired(self.config.cache_ttl()) {
+                    return Ok(entry.data.clone());
+                }
+            }
+        }
+
+        let url = format!("{}/markets/{}", self.base_url, market_id);
+        let market: Market = self.make_request_with_retry(&url).await?;
+
+        if self.config.cache.enabled {
+            let mut cache = self.single_market_cache.write().await;
+            cache.insert(cache_key, CacheEntry::new(market.clone()));
+        }
+
+        Ok(market)
+    }
+
+    /// Searches for markets containing the specified keyword in question, description, or category.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The underlying API request fails
+    /// - The response cannot be deserialized
+    pub async fn search_markets(&self, keyword: &str, limit: Option<u32>) -> Result<Vec<Market>> {
+        let params = MarketsQueryParams {
+            limit: limit.or(Some(20)),
+            ..Default::default()
+        };
+
+        let markets = self.get_markets(Some(params)).await?;
+
+        let keyword_lower = keyword.to_lowercase();
+        let filtered: Vec<Market> = markets
+            .into_iter()
+            .filter(|market| {
+                market.question.to_lowercase().contains(&keyword_lower)
+                    || market
+                        .description
+                        .as_ref()
+                        .is_some_and(|desc| desc.to_lowercase().contains(&keyword_lower))
+                    || market
+                        .category
+                        .as_ref()
+                        .is_some_and(|cat| cat.to_lowercase().contains(&keyword_lower))
+            })
+            .collect();
+
+        Ok(filtered)
+    }
+
+    /// Gets current prices for all outcomes of a specific market.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The market cannot be fetched
+    /// - Price data is malformed
+    pub async fn get_market_prices(&self, market_id: &str) -> Result<Vec<MarketPrice>> {
+        let market = self.get_market_by_id(market_id).await?;
+        let mut prices = Vec::new();
+
+        for (i, _outcome) in market.outcomes.iter().enumerate() {
+            if let Some(price_str) = market.outcome_prices.get(i) {
+                if let Ok(price) = price_str.parse::<f64>() {
+                    prices.push(MarketPrice {
+                        market_id: market_id.to_string(),
+                        outcome_id: format!("outcome_{i}"),
+                        price,
+                        timestamp: chrono::Utc::now().to_rfc3339(),
+                    });
+                }
+            }
+        }
+
+        Ok(prices)
+    }
+
+    /// Gets markets with the highest trading volume, sorted by volume descending.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The API request fails
+    /// - The response cannot be deserialized
+    pub async fn get_trending_markets(&self, limit: Option<u32>) -> Result<Vec<Market>> {
+        let params = MarketsQueryParams {
+            limit: limit.or(Some(10)),
+            order: Some("volume24hr".to_string()),
+            ascending: Some(false),
+            active: Some(true),
+            ..Default::default()
+        };
+
+        self.get_markets(Some(params)).await
+    }
+
+    /// Gets currently active (not archived) markets.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The API request fails
+    /// - The response cannot be deserialized
+    pub async fn get_active_markets(&self, limit: Option<u32>) -> Result<Vec<Market>> {
+        let params = MarketsQueryParams {
+            limit: limit.or(Some(50)),
+            active: Some(true),
+            archived: Some(false),
+            ..Default::default()
+        };
+
+        self.get_markets(Some(params)).await
+    }
+
+    /// Gets positions for a specific wallet address.
+    ///
+    /// Uses the Polymarket Data API to fetch current positions.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The API request fails
+    /// - The response cannot be deserialized
+    pub async fn get_user_positions(&self, wallet_address: &str) -> Result<Vec<Position>> {
+        let url = format!(
+            "{}/positions?user={}",
+            self.config.api.clob_url, wallet_address
+        );
+        let response: Vec<Position> = self.make_request_with_retry(&url).await?;
+        Ok(response)
+    }
+
+    /// Gets trade history for a specific wallet address.
+    ///
+    /// Uses the Polymarket Data API to fetch trade history.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The API request fails
+    /// - The response cannot be deserialized
+    pub async fn get_user_trades(
+        &self,
+        wallet_address: &str,
+        limit: Option<u32>,
+    ) -> Result<Vec<Trade>> {
+        let limit = limit.unwrap_or(50);
+        let url = format!(
+            "{}/trades?user={}&limit={}",
+            self.config.api.clob_url, wallet_address, limit
+        );
+        let response: Vec<Trade> = self.make_request_with_retry(&url).await?;
+        Ok(response)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    fn create_test_config() -> Arc<Config> {
+        let mut config = Config::default();
+        config.api.base_url = "http://localhost:3000".to_string();
+        config.cache.enabled = false;
+        Arc::new(config)
+    }
+
+    #[tokio::test]
+    async fn test_client_creation() {
+        let config = create_test_config();
+        let client = PolymarketClient::new_with_config(&config);
+        assert!(client.is_ok());
+    }
+
+    #[test]
+    fn test_cache_entry_expiration() {
+        let entry = CacheEntry::new("test_data".to_string());
+
+        assert!(!entry.is_expired(Duration::from_secs(1)));
+
+        std::thread::sleep(Duration::from_millis(10));
+        assert!(!entry.is_expired(Duration::from_secs(1)));
+        assert!(entry.is_expired(Duration::from_millis(5)));
+    }
+}

package/src/vendors/sentiment/main.py

@@ -0,0 +1,224 @@
+"""
+@author Nich
+@website x.com/nichxbt
+@github github.com/nirholas
+@license MIT
+"""
+import requests
+from mcp.server.fastmcp import FastMCP
+from datetime import datetime, timedelta, UTC
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+mcp = FastMCP("CryptoSentiment")
+SANTIMENT_API_KEY = os.getenv("SANTIMENT_API_KEY")
+if not SANTIMENT_API_KEY:
+    raise ValueError("SANTIMENT_API_KEY not found in environment variables. Please set it in .env file.")
+SANTIMENT_API_URL = "https://api.santiment.net/graphql"
+HEADERS = {"Authorization": f"Apikey {SANTIMENT_API_KEY}"}
+
+def fetch_santiment_data(metric: str, asset: str, days: int) -> dict:
+    now = datetime.now(UTC)
+    
+    to_date = now
+    from_date = to_date - timedelta(days=days)
+    
+    query = f"""
+    {{
+      getMetric(metric: "{metric}") {{
+        timeseriesData(
+          slug: "{asset}"
+          from: "{from_date.isoformat()}"
+          to: "{to_date.isoformat()}"
+          interval: "1d"
+        ) {{
+          datetime
+          value
+        }}
+      }}
+    }}
+    """
+    response = requests.post(SANTIMENT_API_URL, json={"query": query}, headers=HEADERS)
+    result = response.json()
+    if result.get("errors"):
+        raise Exception(f"API error: {result.get('errors')}")
+    return result
+
+def fetch_trending_words(days: int = 7) -> dict:
+    now = datetime.now(UTC)
+    
+    to_date = now
+    from_date = to_date - timedelta(days=days)
+    
+    query = f"""
+    {{
+      getTrendingWords(size: 10, from: "{from_date.isoformat()}", to: "{to_date.isoformat()}", interval: "1d") {{
+        datetime
+        topWords {{
+          word
+          score
+        }}
+      }}
+    }}
+    """
+    response = requests.post(SANTIMENT_API_URL, json={"query": query}, headers=HEADERS)
+    result = response.json()
+    if result.get("errors"):
+        raise Exception(f"API error: {result.get('errors')}")
+    return result
+
+@mcp.tool()
+def get_sentiment_balance(asset: str, days: int = 7) -> str:
+    """
+    Retrieve the sentiment balance (sentiment_balance_total) for a given asset.
+    
+    Parameters:
+    - asset (str): The cryptocurrency slug (e.g., "bitcoin", "ethereum"). Required.
+    - days (int): Number of days to calculate the average sentiment balance, defaults to 7.
+    
+    Usage:
+    - Use this tool to get the average sentiment balance (positive minus negative sentiment) over a period.
+    
+    Returns:
+    - A string with the average sentiment balance (e.g., "Bitcoin's sentiment balance over the past 7 days is 12.5").
+    """
+    try:
+        data = fetch_santiment_data("sentiment_balance_total", asset, days)
+        timeseries = data.get("data", {}).get("getMetric", {}).get("timeseriesData", [])
+        if not timeseries:
+            return f"Unable to fetch sentiment data for {asset}. Check subscription limits or asset availability."
+        avg_balance = sum(float(d["value"]) for d in timeseries) / len(timeseries)
+        return f"{asset.capitalize()}'s sentiment balance over the past {days} days is {avg_balance:.1f}."
+    except Exception as e:
+        return f"Error fetching sentiment balance for {asset}: {str(e)}"
+
+@mcp.tool()
+def get_social_volume(asset: str, days: int = 7) -> str:
+    """
+    Retrieve the total social volume (social_volume_total) for a given asset. It calculates the total number of social data text documents that contain the given search term at least once. Examples of documents are telegram messages and reddit posts.
+    
+    Parameters:
+    - asset (str): The cryptocurrency slug (e.g., "bitcoin", "ethereum"). Required.
+    - days (int): Number of days to sum the social volume, defaults to 7.
+    
+    Usage:
+    - Call this tool to get the total number of social media mentions for an asset over a period.
+    
+    Returns:
+    - A string with the total social volume (e.g., "Bitcoin's social volume over the past 7 days is 15,000 mentions").
+    """
+    try:
+        data = fetch_santiment_data("social_volume_total", asset, days)
+        timeseries = data.get("data", {}).get("getMetric", {}).get("timeseriesData", [])
+        if not timeseries:
+            return f"Unable to fetch social volume for {asset}. Check subscription limits or asset availability."
+        total_volume = sum(int(d["value"]) for d in timeseries)
+        return f"{asset.capitalize()}'s social volume over the past {days} days is {total_volume:,} mentions."
+    except Exception as e:
+        return f"Error fetching social volume for {asset}: {str(e)}"
+
+@mcp.tool()
+def alert_social_shift(asset: str, threshold: float = 50.0, days: int = 7) -> str:
+    """
+    Detect significant shifts (spikes or drops) in social volume (social_volume_total) for a given asset.
+    
+    Parameters:
+    - asset (str): The cryptocurrency slug (e.g., "bitcoin", "ethereum"). Required.
+    - threshold (float): Minimum percentage change (absolute value) to trigger an alert, defaults to 50.0 (i.e., 50%).
+    - days (int): Number of days to analyze for baseline volume, defaults to 7.
+    
+    Usage:
+    - Call this tool to check if the latest social volume has significantly spiked or dropped compared to the previous average.
+    
+    Returns:
+    - A string indicating if a shift occurred (e.g., "Bitcoin's social volume spiked by 75.0% in the last 24 hours" or "Bitcoin's social volume dropped by 60.0% in the last 24 hours").
+    """
+    try:
+        data = fetch_santiment_data("social_volume_total", asset, days)
+        timeseries = data.get("data", {}).get("getMetric", {}).get("timeseriesData", [])
+        
+        if not timeseries or len(timeseries) < 2:
+            return f"Unable to detect social volume shift for {asset}, insufficient data."
+        
+        latest_volume = int(timeseries[-1]["value"])  # Latest day's volume
+        prev_avg_volume = sum(int(d["value"]) for d in timeseries[:-1]) / (len(timeseries) - 1)  # Average of previous days
+        change_percent = ((latest_volume - prev_avg_volume) / prev_avg_volume) * 100
+        
+        abs_change = abs(change_percent)
+        if abs_change >= threshold:
+            direction = "spiked" if change_percent > 0 else "dropped"
+            return f"{asset.capitalize()}'s social volume {direction} by {abs_change:.1f}% in the last 24 hours, from an average of {prev_avg_volume:,.0f} to {latest_volume:,}."
+        return f"No significant shift detected for {asset.capitalize()}, change is {change_percent:.1f}%."
+    except Exception as e:
+        return f"Error detecting social volume shift for {asset}: {str(e)}"
+
+@mcp.tool()
+def get_trending_words(days: int = 7, top_n: int = 5) -> str:
+    """
+    Retrieve the top trending words in the crypto space over a specified period, aggregated and ranked by score.
+    
+    Parameters:
+    - days (int): Number of days to analyze trending words, defaults to 7.
+    - top_n (int): Number of top trending words to return, defaults to 5.
+    
+    Usage:
+    - Call this tool to get a list of the most popular words trending in cryptocurrency discussions, ranked across the entire period.
+    
+    Returns:
+    - A string listing the top trending words (e.g., "Top 5 trending words over the past 7 days: 'halving', 'bullrun', 'defi', 'nft', 'pump'").
+    """
+    try:
+        data = fetch_trending_words(days)
+        trends = data.get("data", {}).get("getTrendingWords", [])
+        if not trends:
+            return "Unable to fetch trending words. Check API subscription limits or connectivity."
+        
+        word_scores = {}
+        for day in trends:
+            for word_data in day["topWords"]:
+                word = word_data["word"]
+                score = word_data["score"]
+                if word in word_scores:
+                    word_scores[word] += score
+                else:
+                    word_scores[word] = score
+        
+        if not word_scores:
+            return "No trending words data available for the specified period."
+        
+        top_words = sorted(word_scores.items(), key=lambda x: x[1], reverse=True)[:top_n]
+        top_words_list = [word for word, _ in top_words]
+        
+        return f"Top {top_n} trending words over the past {days} days: {', '.join(top_words_list)}."
+    except Exception as e:
+        return f"Error fetching trending words: {str(e)}"
+
+@mcp.tool()
+def get_social_dominance(asset: str, days: int = 7) -> str:
+    """
+    Retrieve the social dominance (social_dominance_total) for a given asset. Social Dominance shows the share of the discussions in crypto media that is referring to a particular asset or phrase.
+    
+    Parameters:
+    - asset (str): The cryptocurrency slug (e.g., "bitcoin", "ethereum"). Required.
+    - days (int): Number of days to calculate average social dominance, defaults to 7.
+    
+    Usage:
+    - Call this tool to get the percentage of social media discussion dominated by the asset.
+    
+    Returns:
+    - A string with the average social dominance (e.g., "Bitcoin's social dominance over the past 7 days is 25.3%").
+    """
+    try:
+        data = fetch_santiment_data("social_dominance_total", asset, days)
+        timeseries = data.get("data", {}).get("getMetric", {}).get("timeseriesData", [])
+        if not timeseries:
+            return f"Unable to fetch social dominance for {asset}. Check subscription limits or asset availability."
+        avg_dominance = sum(float(d["value"]) for d in timeseries) / len(timeseries)
+        return f"{asset.capitalize()}'s social dominance over the past {days} days is {avg_dominance:.1f}%."
+    except Exception as e:
+        return f"Error fetching social dominance for {asset}: {str(e)}"
+
+if __name__ == "__main__":
+    mcp.run()