1#!/usr/bin/env python3
2"""
3CoinGecko Coins Tools
4 
5Tools for fetching coin lists, market data, detailed coin info, and tickers.
6"""
7 
8import os
9from dotenv import load_dotenv
10import json
11import argparse
12from typing import Dict, Any, Optional
13 
14from core.http_client import proxied_get
15 
16# Load environment variables
17load_dotenv()
18 
19 
20def get_api_key() -> str:
21    """Get CoinGecko API key from environment."""
22    api_key = os.getenv("COINGECKO_API_KEY")
23    if not api_key:
24        raise ValueError("COINGECKO_API_KEY environment variable is required")
25    return api_key
26 
27 
28def get_coins_list(include_platform: bool = False) -> Dict[str, Any]:
29    """
30    Get all supported coins with id, symbol, name.
31 
32    Args:
33        include_platform: Include platform contract addresses
34 
35    Returns:
36        Dictionary with list of all coins
37    """
38    api_key = get_api_key()
39 
40    url = "https://pro-api.coingecko.com/api/v3/coins/list"
41    headers = {"x-cg-pro-api-key": api_key}
42    params = {"include_platform": str(include_platform).lower()}
43 
44    response = proxied_get(url, headers=headers, params=params, timeout=30)
45    response.raise_for_status()
46    data = response.json()
47 
48    coins = []
49    for coin in data:
50        coin_data = {
51            "id": coin.get("id", ""),
52            "symbol": coin.get("symbol", "").upper(),
53            "name": coin.get("name", "")
54        }
55        if include_platform and "platforms" in coin:
56            coin_data["platforms"] = coin.get("platforms", {})
57        coins.append(coin_data)
58 
59    return {
60        "coins": coins,
61        "count": len(coins)
62    }
63 
64 
65def get_coins_markets(
66    vs_currency: str = "usd",
67    order: str = "market_cap_desc",
68    per_page: int = 100,
69    page: int = 1,
70    sparkline: bool = False,
71    price_change_percentage: str = "24h",
72    category: Optional[str] = None,
73    ids: Optional[str] = None
74) -> Dict[str, Any]:
75    """
76    Get market data for coins with sorting and pagination.
77 
78    Args:
79        vs_currency: Target currency (usd, eur, btc)
80        order: Sort order (market_cap_desc, volume_desc, price_change_24h_desc)
81        per_page: Results per page (max 250)
82        page: Page number
83        sparkline: Include 7-day sparkline data
84        price_change_percentage: Comma-separated time periods (1h, 24h, 7d, 14d, 30d, 200d, 1y)
85        category: Filter by category id
86        ids: Comma-separated coin ids to filter
87 
88    Returns:
89        Dictionary with market data for coins
90    """
91    api_key = get_api_key()
92 
93    url = "https://pro-api.coingecko.com/api/v3/coins/markets"
94    headers = {"x-cg-pro-api-key": api_key}
95    params = {
96        "vs_currency": vs_currency,
97        "order": order,
98        "per_page": min(per_page, 250),
99        "page": page,
100        "sparkline": str(sparkline).lower(),
101        "price_change_percentage": price_change_percentage
102    }
103    if category:
104        params["category"] = category
105    if ids:
106        params["ids"] = ids
107 
108    response = proxied_get(url, headers=headers, params=params, timeout=30)
109    response.raise_for_status()
110    data = response.json()
111 
112    coins = []
113    for coin in data:
114        coin_data = {
115            "id": coin.get("id", ""),
116            "symbol": coin.get("symbol", "").upper(),
117            "name": coin.get("name", ""),
118            "image": coin.get("image"),
119            "current_price": coin.get("current_price"),
120            "market_cap": coin.get("market_cap"),
121            "market_cap_rank": coin.get("market_cap_rank"),
122            "fully_diluted_valuation": coin.get("fully_diluted_valuation"),
123            "total_volume": coin.get("total_volume"),
124            "high_24h": coin.get("high_24h"),
125            "low_24h": coin.get("low_24h"),
126            "price_change_24h": coin.get("price_change_24h"),
127            "price_change_percentage_24h": coin.get("price_change_percentage_24h"),
128            "market_cap_change_24h": coin.get("market_cap_change_24h"),
129            "market_cap_change_percentage_24h": coin.get("market_cap_change_percentage_24h"),
130            "circulating_supply": coin.get("circulating_supply"),
131            "total_supply": coin.get("total_supply"),
132            "max_supply": coin.get("max_supply"),
133            "ath": coin.get("ath"),
134            "ath_change_percentage": coin.get("ath_change_percentage"),
135            "ath_date": coin.get("ath_date"),
136            "atl": coin.get("atl"),
137            "atl_change_percentage": coin.get("atl_change_percentage"),
138            "atl_date": coin.get("atl_date"),
139            "last_updated": coin.get("last_updated")
140        }
141        # Add price change percentages if available
142        for key in coin:
143            if key.startswith("price_change_percentage_"):
144                coin_data[key] = coin.get(key)
145        if sparkline and "sparkline_in_7d" in coin:
146            coin_data["sparkline_in_7d"] = coin.get("sparkline_in_7d")
147        coins.append(coin_data)
148 
149    return {
150        "coins": coins,
151        "count": len(coins),
152        "vs_currency": vs_currency,
153        "order": order,
154        "page": page,
155        "per_page": per_page
156    }
157 
158 
159def get_coin_data(
160    coin_id: str,
161    localization: bool = False,
162    tickers: bool = False,
163    market_data: bool = True,
164    community_data: bool = False,
165    developer_data: bool = False,
166    sparkline: bool = False
167) -> Dict[str, Any]:
168    """
169    Get full coin metadata including description, links, ATH, ATL, market data.
170 
171    Args:
172        coin_id: CoinGecko coin id
173        localization: Include localized languages
174        tickers: Include tickers data
175        market_data: Include market data
176        community_data: Include community data
177        developer_data: Include developer data
178        sparkline: Include sparkline 7 days data
179 
180    Returns:
181        Dictionary with comprehensive coin data
182    """
183    api_key = get_api_key()
184 
185    url = f"https://pro-api.coingecko.com/api/v3/coins/{coin_id}"
186    headers = {"x-cg-pro-api-key": api_key}
187    params = {
188        "localization": str(localization).lower(),
189        "tickers": str(tickers).lower(),
190        "market_data": str(market_data).lower(),
191        "community_data": str(community_data).lower(),
192        "developer_data": str(developer_data).lower(),
193        "sparkline": str(sparkline).lower()
194    }
195 
196    response = proxied_get(url, headers=headers, params=params, timeout=30)
197    response.raise_for_status()
198    data = response.json()
199 
200    result = {
201        "id": data.get("id", ""),
202        "symbol": data.get("symbol", "").upper(),
203        "name": data.get("name", ""),
204        "asset_platform_id": data.get("asset_platform_id"),
205        "platforms": data.get("platforms", {}),
206        "block_time_in_minutes": data.get("block_time_in_minutes"),
207        "hashing_algorithm": data.get("hashing_algorithm"),
208        "categories": data.get("categories", []),
209        "description": data.get("description", {}).get("en", ""),
210        "links": {
211            "homepage": data.get("links", {}).get("homepage", []),
212            "blockchain_site": data.get("links", {}).get("blockchain_site", []),
213            "official_forum_url": data.get("links", {}).get("official_forum_url", []),
214            "chat_url": data.get("links", {}).get("chat_url", []),
215            "announcement_url": data.get("links", {}).get("announcement_url", []),
216            "twitter_screen_name": data.get("links", {}).get("twitter_screen_name"),
217            "facebook_username": data.get("links", {}).get("facebook_username"),
218            "telegram_channel_identifier": data.get("links", {}).get("telegram_channel_identifier"),
219            "subreddit_url": data.get("links", {}).get("subreddit_url"),
220            "repos_url": data.get("links", {}).get("repos_url", {})
221        },
222        "image": data.get("image", {}),
223        "country_origin": data.get("country_origin"),
224        "genesis_date": data.get("genesis_date"),
225        "sentiment_votes_up_percentage": data.get("sentiment_votes_up_percentage"),
226        "sentiment_votes_down_percentage": data.get("sentiment_votes_down_percentage"),
227        "market_cap_rank": data.get("market_cap_rank"),
228        "coingecko_rank": data.get("coingecko_rank"),
229        "coingecko_score": data.get("coingecko_score"),
230        "developer_score": data.get("developer_score"),
231        "community_score": data.get("community_score"),
232        "liquidity_score": data.get("liquidity_score"),
233        "public_interest_score": data.get("public_interest_score"),
234        "last_updated": data.get("last_updated")
235    }
236 
237    if market_data and "market_data" in data:
238        md = data["market_data"]
239        result["market_data"] = {
240            "current_price": md.get("current_price", {}),
241            "total_value_locked": md.get("total_value_locked"),
242            "mcap_to_tvl_ratio": md.get("mcap_to_tvl_ratio"),
243            "fdv_to_tvl_ratio": md.get("fdv_to_tvl_ratio"),
244            "roi": md.get("roi"),
245            "ath": md.get("ath", {}),
246            "ath_change_percentage": md.get("ath_change_percentage", {}),
247            "ath_date": md.get("ath_date", {}),
248            "atl": md.get("atl", {}),
249            "atl_change_percentage": md.get("atl_change_percentage", {}),
250            "atl_date": md.get("atl_date", {}),
251            "market_cap": md.get("market_cap", {}),
252            "market_cap_rank": md.get("market_cap_rank"),
253            "fully_diluted_valuation": md.get("fully_diluted_valuation", {}),
254            "total_volume": md.get("total_volume", {}),
255            "high_24h": md.get("high_24h", {}),
256            "low_24h": md.get("low_24h", {}),
257            "price_change_24h": md.get("price_change_24h"),
258            "price_change_percentage_24h": md.get("price_change_percentage_24h"),
259            "price_change_percentage_7d": md.get("price_change_percentage_7d"),
260            "price_change_percentage_14d": md.get("price_change_percentage_14d"),
261            "price_change_percentage_30d": md.get("price_change_percentage_30d"),
262            "price_change_percentage_60d": md.get("price_change_percentage_60d"),
263            "price_change_percentage_200d": md.get("price_change_percentage_200d"),
264            "price_change_percentage_1y": md.get("price_change_percentage_1y"),
265            "market_cap_change_24h": md.get("market_cap_change_24h"),
266            "market_cap_change_percentage_24h": md.get("market_cap_change_percentage_24h"),
267            "total_supply": md.get("total_supply"),
268            "max_supply": md.get("max_supply"),
269            "circulating_supply": md.get("circulating_supply")
270        }
271 
272    if tickers and "tickers" in data:
273        result["tickers"] = data["tickers"]
274 
275    if community_data and "community_data" in data:
276        result["community_data"] = data["community_data"]
277 
278    if developer_data and "developer_data" in data:
279        result["developer_data"] = data["developer_data"]
280 
281    return result
282 
283 
284def get_coin_tickers(
285    coin_id: str,
286    exchange_ids: Optional[str] = None,
287    include_exchange_logo: bool = False,
288    page: int = 1,
289    order: str = "volume_desc",
290    depth: bool = False
291) -> Dict[str, Any]:
292    """
293    Get all trading pairs/tickers for a coin across exchanges.
294 
295    Args:
296        coin_id: CoinGecko coin id
297        exchange_ids: Comma-separated exchange ids to filter
298        include_exchange_logo: Include exchange logo
299        page: Page number
300        order: Sort order (trust_score_desc, trust_score_asc, volume_desc, volume_asc)
301        depth: Include order book depth (cost_to_move_up_usd, cost_to_move_down_usd)
302 
303    Returns:
304        Dictionary with tickers for the coin
305    """
306    api_key = get_api_key()
307 
308    url = f"https://pro-api.coingecko.com/api/v3/coins/{coin_id}/tickers"
309    headers = {"x-cg-pro-api-key": api_key}
310    params = {
311        "include_exchange_logo": str(include_exchange_logo).lower(),
312        "page": page,
313        "order": order,
314        "depth": str(depth).lower()
315    }
316    if exchange_ids:
317        params["exchange_ids"] = exchange_ids
318 
319    response = proxied_get(url, headers=headers, params=params, timeout=30)
320    response.raise_for_status()
321    data = response.json()
322 
323    tickers = []
324    for ticker in data.get("tickers", []):
325        ticker_data = {
326            "base": ticker.get("base", ""),
327            "target": ticker.get("target", ""),
328            "market": {
329                "name": ticker.get("market", {}).get("name", ""),
330                "identifier": ticker.get("market", {}).get("identifier", ""),
331                "has_trading_incentive": ticker.get("market", {}).get("has_trading_incentive")
332            },
333            "last": ticker.get("last"),
334            "volume": ticker.get("volume"),
335            "converted_last": ticker.get("converted_last", {}),
336            "converted_volume": ticker.get("converted_volume", {}),
337            "trust_score": ticker.get("trust_score"),
338            "bid_ask_spread_percentage": ticker.get("bid_ask_spread_percentage"),
339            "timestamp": ticker.get("timestamp"),
340            "last_traded_at": ticker.get("last_traded_at"),
341            "last_fetch_at": ticker.get("last_fetch_at"),
342            "is_anomaly": ticker.get("is_anomaly"),
343            "is_stale": ticker.get("is_stale"),
344            "trade_url": ticker.get("trade_url"),
345            "token_info_url": ticker.get("token_info_url"),
346            "coin_id": ticker.get("coin_id"),
347            "target_coin_id": ticker.get("target_coin_id")
348        }
349        if include_exchange_logo:
350            ticker_data["market"]["logo"] = ticker.get("market", {}).get("logo")
351        if depth:
352            ticker_data["cost_to_move_up_usd"] = ticker.get("cost_to_move_up_usd")
353            ticker_data["cost_to_move_down_usd"] = ticker.get("cost_to_move_down_usd")
354        tickers.append(ticker_data)
355 
356    return {
357        "name": data.get("name", ""),
358        "tickers": tickers,
359        "count": len(tickers),
360        "page": page
361    }
362 
363 
364def main():
365    """CLI interface for coins tools."""
366    parser = argparse.ArgumentParser(
367        description="CoinGecko Coins Tools",
368        formatter_class=argparse.RawDescriptionHelpFormatter
369    )
370 
371    subparsers = parser.add_subparsers(dest="command")
372 
373    # List command
374    list_parser = subparsers.add_parser("list", help="Get all supported coins")
375    list_parser.add_argument("--platforms", action="store_true", help="Include platform addresses")
376 
377    # Markets command
378    markets_parser = subparsers.add_parser("markets", help="Get market data for coins")
379    markets_parser.add_argument("--currency", default="usd")
380    markets_parser.add_argument("--order", default="market_cap_desc")
381    markets_parser.add_argument("--per-page", type=int, default=100)
382    markets_parser.add_argument("--page", type=int, default=1)
383    markets_parser.add_argument("--category", help="Filter by category")
384    markets_parser.add_argument("--ids", help="Filter by coin ids (comma-separated)")
385 
386    # Data command
387    data_parser = subparsers.add_parser("data", help="Get detailed coin data")
388    data_parser.add_argument("coin_id", help="CoinGecko coin ID")
389    data_parser.add_argument("--tickers", action="store_true", help="Include tickers")
390    data_parser.add_argument("--community", action="store_true", help="Include community data")
391    data_parser.add_argument("--developer", action="store_true", help="Include developer data")
392 
393    # Tickers command
394    tickers_parser = subparsers.add_parser("tickers", help="Get coin tickers")
395    tickers_parser.add_argument("coin_id", help="CoinGecko coin ID")
396    tickers_parser.add_argument("--exchanges", help="Filter by exchange ids")
397    tickers_parser.add_argument("--page", type=int, default=1)
398    tickers_parser.add_argument("--order", default="volume_desc")
399 
400    args = parser.parse_args()
401 
402    try:
403        if args.command == "list":
404            result = get_coins_list(args.platforms)
405        elif args.command == "markets":
406            result = get_coins_markets(
407                vs_currency=args.currency,
408                order=args.order,
409                per_page=args.per_page,
410                page=args.page,
411                category=args.category,
412                ids=args.ids
413            )
414        elif args.command == "data":
415            result = get_coin_data(
416                coin_id=args.coin_id,
417                tickers=args.tickers,
418                community_data=args.community,
419                developer_data=args.developer
420            )
421        elif args.command == "tickers":
422            result = get_coin_tickers(
423                coin_id=args.coin_id,
424                exchange_ids=args.exchanges,
425                page=args.page,
426                order=args.order
427            )
428        else:
429            parser.print_help()
430            return 0
431 
432        print(json.dumps(result, indent=2, ensure_ascii=False))
433        return 0
434 
435    except Exception as e:
436        print(json.dumps({"error": str(e)}, indent=2))
437        return 1
438 
439 
440if __name__ == "__main__":
441    exit(main())
442