Merge pull request #23 from drift-labs:delist-recommender

Added new coingecko integration for market-recommender backend endpoint.

Author: goldhaxx

.env.example

@@ -1,3 +1,5 @@
 RPC_URL=""
 BACKEND_URL=http://localhost:8000
-DEV=true
+DEV=true
+DRIFT_DATA_API_BASE_URL = "https://data.api.drift.trade" # Drift Trade data api base URL. Test at https://data.api.drift.trade/playground
+DRIFT_DATA_API_HEADERS = {"Key": "Value"} # Make sure to update this with any headers you may need or remove the key/value placeholders

LEGACY-list-delist-recommender.py

@@ -23,6 +23,7 @@
     vaults,
     delist_recommender,
     list_recommender,
+    market_recommender,
 )
 from backend.middleware.cache_middleware import CacheMiddleware
 from backend.middleware.readiness import ReadinessMiddleware
@@ -90,8 +91,7 @@ async def lifespan(app: FastAPI):
 app.include_router(positions.router, prefix="/api/positions", tags=["positions"])
 app.include_router(delist_recommender.router, prefix="/api/delist-recommender", tags=["delist-recommender"])
 app.include_router(list_recommender.router, prefix="/api/list-recommender", tags=["list-recommender"])
-
-
+app.include_router(market_recommender.router, prefix="/api/market-recommender", tags=["market-recommender"])
 # NOTE: All other routes should be in /api/* within the /api folder. Routes outside of /api are not exposed in k8s
 @app.get("/")
 async def root():

backend/api/list_recommender.py

@@ -0,0 +1,95 @@
+"""
+Simple manual testing script for CoinGecko API functions.
+Run this directly to see the output in your terminal.
+
+Usage:
+    python test_coingecko.py --symbol BTC --coin-id bitcoin --num-tokens 10 --days 30
+    python test_coingecko.py -s ETH -c ethereum -n 5 -d 7
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Add the parent directory to the Python path so we can import the utils
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+from backend.utils.coingecko_api import (
+    fetch_coingecko_data,
+    fetch_all_coingecko_market_data,
+    fetch_all_coingecko_volumes,
+    fetch_coingecko_historical_volume
+)
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description='Test CoinGecko API functions for a specific token')
+    parser.add_argument('-s', '--symbol', type=str, default='BTC',
+                      help='Token symbol (e.g., BTC, ETH)')
+    parser.add_argument('-c', '--coin-id', type=str, default='bitcoin',
+                      help='CoinGecko coin ID (e.g., bitcoin, ethereum)')
+    parser.add_argument('-n', '--num-tokens', type=int, default=10,
+                      help='Number of top tokens to fetch (default: 10, max: 250)')
+    parser.add_argument('-d', '--days', type=int, default=30,
+                      help='Number of days for historical volume data (default: 30)')
+    return parser.parse_args()
+
+def run_tests(target_symbol: str, target_coin_id: str, num_tokens: int, days: int):
+    """Run tests for CoinGecko API functions."""
+    print("\n=== Starting CoinGecko API Tests ===\n")
+    
+    print(f"Fetching data for {num_tokens} top tokens by market cap...")
+    market_data = fetch_all_coingecko_market_data(num_tokens)
+    
+    if not market_data:
+        print("Error: No market data received")
+        return
+    
+    total_tokens = len(market_data)
+    print(f"\nReceived data for {total_tokens} tokens")
+    if total_tokens < num_tokens:
+        print(f"Note: Requested {num_tokens} tokens but only received {total_tokens}.")
+        print("This is normal if you requested more tokens than are available on CoinGecko.")
+    
+    print("\nTop 10 tokens by market cap (or all if less than 10):")
+    tokens_to_show = sorted(
+        market_data.items(),
+        key=lambda x: x[1].get('market_cap_rank', float('inf'))
+    )[:min(10, total_tokens)]
+    
+    for current_coin_id, data in tokens_to_show:
+        symbol = data.get('symbol', '???')
+        rank = data.get('market_cap_rank', 'N/A')
+        price = data.get('current_price', 'N/A')
+        print(f"#{rank}: {symbol} @ ${price}")
+    
+    # Test specific coin data if provided
+    if target_coin_id and target_symbol:
+        print(f"\nDetailed data for {target_symbol}:")
+        coin_data = market_data.get(target_coin_id)
+        
+        if not coin_data:
+            print(f"Error: Could not find data for {target_symbol} ({target_coin_id})")
+            return
+        
+        # Display detailed coin information
+        print(f"Name: {coin_data.get('name')}")
+        print(f"Current Price: ${coin_data.get('current_price')}")
+        print(f"Market Cap Rank: #{coin_data.get('market_cap_rank')}")
+        print(f"Market Cap: ${coin_data.get('market_cap'):,}")
+        print(f"Circulating Supply: {coin_data.get('circulating_supply'):,.2f} {target_symbol}")
+        print(f"All-Time High: ${coin_data.get('ath_price')}")
+        
+        print(f"\nFetching {days}-day historical volume data...")
+        volume_data = fetch_coingecko_historical_volume(target_coin_id, number_of_days=days)
+        if volume_data:
+            print(f"{days}-day Volume: ${volume_data:,.2f}")
+        else:
+            print("Error: Could not fetch volume data")
+
+if __name__ == "__main__":
+    args = parse_arguments()
+    print(f"Starting CoinGecko API tests for {args.symbol} ({args.coin_id})...")
+    print(f"Will fetch top {args.num_tokens} tokens by market cap...")
+    print(f"Historical volume period: {args.days} days")
+    run_tests(args.symbol, args.coin_id, args.num_tokens, args.days)
+    print("\nTests completed!") 

backend/api/market_recommender.py

@@ -0,0 +1,140 @@
+"""
+Detailed testing script for CoinGecko API that aggregates data from multiple endpoints.
+Provides comprehensive token information including market data and historical volumes.
+
+Usage:
+    python test_coingecko_detailed.py --num-tokens 10
+    python test_coingecko_detailed.py -n 5
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import List, Dict
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Add the parent directory to the Python path so we can import the utils
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+from backend.utils.coingecko_api import (
+    fetch_all_coingecko_market_data,
+    fetch_coingecko_historical_volume,
+    fetch_all_coingecko_volumes
+)
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description='Test CoinGecko API with detailed output')
+    parser.add_argument('-n', '--num-tokens', type=int, default=10,
+                      help='Number of top tokens to fetch (default: 10, max: 250)')
+    return parser.parse_args()
+
+def format_token_data(market_data: Dict, volume_30d: float) -> Dict:
+    """Format token data according to the specified structure."""
+    return {
+        "symbol": market_data.get('symbol', ''),
+        "coingecko_data": {
+            "coingecko_name": market_data.get('name'),
+            "coingecko_id": market_data.get('id'),
+            "coingecko_image_url": market_data.get('image_url'),
+            "coingecko_current_price": market_data.get('current_price'),
+            "coingecko_market_cap_rank": market_data.get('market_cap_rank'),
+            "coingecko_market_cap": market_data.get('market_cap'),
+            "coingecko_fully_diluted_valuation": market_data.get('fully_diluted_valuation'),
+            "coingecko_total_volume_24h": market_data.get('total_volume_24h'),
+            "coingecko_mc_derived": market_data.get('market_cap'),  # Same as market_cap for now
+            "coingecko_circulating": market_data.get('circulating_supply'),
+            "coingecko_total_supply": market_data.get('total_supply'),
+            "coingecko_max_supply": market_data.get('max_supply'),
+            "coingecko_ath_price": market_data.get('ath_price'),
+            "coingecko_ath_change_percentage": market_data.get('ath_change_percentage'),
+            "coingecko_volume_30d": volume_30d
+        }
+    }
+
+def run_detailed_test(num_tokens: int = 10) -> None:
+    """
+    Run a detailed test of CoinGecko API functionality.
+    
+    Args:
+        num_tokens: Number of tokens to fetch data for (default: 10)
+    """
+    logger.info(f"Starting detailed test for {num_tokens} tokens")
+    
+    # Fetch market data for all tokens
+    market_data = fetch_all_coingecko_market_data()
+    if not market_data or isinstance(market_data, dict) and "error" in market_data:
+        logger.error("Failed to fetch market data")
+        return
+    
+    # Convert dictionary to list and sort by market cap
+    tokens_list = []
+    for coin_id, token_data in market_data.items():
+        token_data['id'] = coin_id  # Add coin_id to the token data
+        tokens_list.append(token_data)
+    
+    # Sort tokens by market cap and take top N
+    sorted_tokens = sorted(
+        tokens_list,
+        key=lambda x: float(x.get("market_cap", 0) or 0),  # Handle None values
+        reverse=True
+    )[:num_tokens]
+    
+    # Get list of coin IDs for volume fetch
+    coin_ids = [token.get("id") for token in sorted_tokens]
+    logger.info(f"Fetching 30d volume data for top {len(coin_ids)} tokens")
+    
+    # Fetch 30d volume data for all tokens at once
+    volume_data = fetch_all_coingecko_volumes(coin_ids)
+    
+    results = []
+    total_tokens = len(sorted_tokens)
+    
+    for idx, token in enumerate(sorted_tokens, 1):
+        coin_id = token.get("id")
+        symbol = token.get("symbol", "").upper()
+        
+        # Get the 30d volume from the volume data
+        total_volume = volume_data.get(coin_id, 0)
+        
+        results.append({
+            "symbol": symbol,
+            "name": token.get("name"),
+            "market_cap": token.get("market_cap", 0),
+            "total_volume_30d": total_volume
+        })
+        
+        # Log progress
+        progress = (idx / total_tokens) * 100
+        logger.info(f"Progress: {progress:.1f}% ({idx}/{total_tokens})")
+    
+    # Format and display results
+    if results:
+        print("\nResults:")
+        print(f"{'Symbol':<10} {'Name':<20} {'Market Cap':>15} {'30d Volume':>20}")
+        print("-" * 65)
+        
+        for r in results:
+            print(
+                f"{r['symbol']:<10} "
+                f"{r['name'][:20]:<20} "
+                f"${r['market_cap']:>14,.0f} "
+                f"${r['total_volume_30d']:>19,.0f}"
+            )
+    else:
+        logger.warning("No results to display")
+
+if __name__ == "__main__":
+    args = parse_arguments()
+    print(f"Starting detailed CoinGecko API tests for {args.num_tokens} tokens...")
+    
+    run_detailed_test(args.num_tokens)
+    
+    print("\nTests completed!")