Code Vault — 7 Open-Source Crypto Radar & Trading Tools

#!/usr/bin/env python3
"""
Vitalik Sell Radar — Event-Driven Edition
WebSocket subscription to ERC-20 Transfer events, real-time detection of
Vitalik's sell activity, instant push to Telegram.

Architecture:
1. WebSocket subscribes to Transfer(from=vitalik) events → sub-second detection
2. Classifies sell behavior (transfers to DEX Router / CEX / LP Pool)
3. Queries token info + price via DexScreener
4. Pushes alert to Telegram
5. Auto-reconnect + multi-RPC failover
"""

import asyncio
import json
import logging
import os
import signal
import sys
import time
from datetime import datetime, timezone
from pathlib import Path

import aiohttp
import websockets

# Load .env file
def load_env():
 env_path = Path(__file__).parent / ".env"
 if env_path.exists():
 for line in env_path.read_text().splitlines():
 line = line.strip()
 if line and not line.startswith("#") and "=" in line:
 k, v = line.split("=", 1)
 os.environ.setdefault(k.strip(), v.strip())

load_env()

# ============================================================
# Configuration
# ============================================================

# Vitalik's main wallet
VITALIK_ADDRESS = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
VITALIK_PADDED = "0x" + VITALIK_ADDRESS[2:].lower().zfill(64)

# ERC-20 Transfer event topic
TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"

# WebSocket RPC endpoints (free, support eth_subscribe)
WS_ENDPOINTS = [
 "wss://ethereum-rpc.publicnode.com",
 "wss://eth.drpc.org",
 "wss://ethereum.publicnode.com",
]

# HTTP RPC for querying token info
HTTP_RPC = os.environ.get("HTTP_RPC", "https://eth.drpc.org")

# Telegram
TG_BOT_TOKEN = os.environ.get("TG_BOT_TOKEN", "")
TG_CHAT_ID = os.environ.get("TG_CHAT_ID", "")

# Known DEX Router addresses (sell destinations)
KNOWN_DEX_ROUTERS = {
 # Uniswap
 "0x7a250d5630b4cf539739df2c5dacb4c659f2488d": "Uniswap V2 Router",
 "0xe592427a0aece92de3edee1f18e0157c05861564": "Uniswap V3 Router",
 "0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45": "Uniswap V3 Router2",
 "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad": "Uniswap Universal Router",
 "0xef1c6e67703c7bd7107eed8303fbe6ec2554bf6b": "Uniswap Universal Router (old)",
 # 1inch
 "0x1111111254eeb25477b68fb85ed929f73a960582": "1inch V5",
 "0x111111125421ca6dc452d289314280a0f8842a65": "1inch V6",
 # SushiSwap
 "0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f": "SushiSwap Router",
 # CoW Protocol
 "0x9008d19f58aabd9ed0d60971565aa8510560ab41": "CoW Settlement",
 # 0x
 "0xdef1c0ded9bec7f1a1670819833240f027b25eff": "0x Exchange Proxy",
 # Curve
 "0x99a58482bd75cbab83b27ec03ca68ff489b5788f": "Curve Router",
}

# Known CEX hot wallets (partial list)
KNOWN_CEX = {
 "0x28c6c06298d514db089934071355e5743bf21d60": "Binance Hot Wallet",
 "0x21a31ee1afc51d94c2efccaa2092ad1028285549": "Binance Hot Wallet 2",
 "0xdfd5293d8e347dfe59e90efd55b2956a1343963d": "Binance Hot Wallet 3",
 "0x56eddb7aa87536c09ccc2793473599fd21a8b17f": "Binance Hot Wallet 4",
 "0x71660c4005ba85c37ccec55d0c4493e66fe775d3": "Coinbase",
 "0xa9d1e08c7793af67e9d92fe308d5697fb81d3e43": "Coinbase 10",
 "0x503828976d22510aad0201ac7ec88293211d23da": "Coinbase 2",
 "0x2faf487a4414fe77e2327f0bf4ae2a264a776ad2": "FTX (defunct)",
 "0x267be1c1d684f78cb4f6a176c4911b741e4ffdc0": "Kraken",
 "0xae2d4617c862309a3d75a0ffb358c7a5009c673f": "Kraken 10",
}

# Minimum notification amount (USD), 0 = notify all
MIN_NOTIFY_USD = int(os.environ.get("MIN_NOTIFY_USD", "0"))

# Reconnect settings
RECONNECT_DELAY = 5
MAX_RECONNECT_DELAY = 60

# ============================================================
# Logging
# ============================================================

logging.basicConfig(
 level=logging.INFO,
 format="%(asctime)s [%(levelname)s] %(message)s",
 datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("vitalik-radar")

# ============================================================
# Global state
# ============================================================

# Dedup set for processed tx hashes (last 1000)
seen_txs: set = set()
seen_txs_list: list = []

# HTTP session
http_session: aiohttp.ClientSession | None = None

# Token info cache: {address: {symbol, name, decimals}}
token_cache: dict = {}

# Running flag
running = True

# ============================================================
# Utility functions
# ============================================================

def shorten_addr(addr: str) -> str:
 """Shorten address for display"""
 return f"{addr[:6]}...{addr[-4:]}"

def decode_transfer_value(data_hex: str, decimals: int) -> float:
 """Decode Transfer event value"""
 try:
 raw = int(data_hex, 16)
 return raw / (10 ** decimals)
 except:
 return 0.0

def topic_to_address(topic: str) -> str:
 """Extract 20-byte address from 32-byte topic"""
 return "0x" + topic[-40:]

def classify_recipient(to_addr: str) -> tuple[str, str]:
 """
 Classify recipient address.
 Returns (type, name)
 Type: "dex" / "cex" / "pool" / "unknown"
 """
 to_lower = to_addr.lower()

 if to_lower in KNOWN_DEX_ROUTERS:
 return "dex", KNOWN_DEX_ROUTERS[to_lower]

 if to_lower in KNOWN_CEX:
 return "cex", KNOWN_CEX[to_lower]

 return "unknown", ""

async def get_http_session() -> aiohttp.ClientSession:
 global http_session
 if http_session is None or http_session.closed:
 http_session = aiohttp.ClientSession()
 return http_session

async def rpc_call(method: str, params: list) -> dict | None:
 """HTTP JSON-RPC call"""
 session = await get_http_session()
 try:
 async with session.post(
 HTTP_RPC,
 json={"jsonrpc": "2.0", "id": 1, "method": method, "params": params},
 timeout=aiohttp.ClientTimeout(total=10),
 ) as resp:
 data = await resp.json()
 return data.get("result")
 except Exception as e:
 log.error(f"RPC call {method} failed: {e}")
 return None

async def get_token_info(token_addr: str) -> dict:
 """Query ERC-20 token info (symbol, name, decimals)"""
 addr_lower = token_addr.lower()
 if addr_lower in token_cache:
 return token_cache[addr_lower]

 info = {"symbol": "???", "name": "Unknown", "decimals": 18, "address": token_addr}

 # symbol()
 result = await rpc_call("eth_call", [
 {"to": token_addr, "data": "0x95d89b41"}, "latest"
 ])
 if result and len(result) > 2:
 try:
 hex_str = result[2:]
 if len(hex_str) >= 128:
 offset = int(hex_str[:64], 16) * 2
 length = int(hex_str[offset:offset+64], 16)
 symbol_hex = hex_str[offset+64:offset+64+length*2]
 info["symbol"] = bytes.fromhex(symbol_hex).decode("utf-8", errors="replace").strip('\x00')
 elif len(hex_str) == 64:
 info["symbol"] = bytes.fromhex(hex_str).decode("utf-8", errors="replace").strip('\x00')
 except:
 pass

 # decimals()
 result = await rpc_call("eth_call", [
 {"to": token_addr, "data": "0x313ce567"}, "latest"
 ])
 if result and len(result) > 2:
 try:
 info["decimals"] = int(result, 16)
 except:
 pass

 # name()
 result = await rpc_call("eth_call", [
 {"to": token_addr, "data": "0x06fdde03"}, "latest"
 ])
 if result and len(result) > 2:
 try:
 hex_str = result[2:]
 if len(hex_str) >= 128:
 offset = int(hex_str[:64], 16) * 2
 length = int(hex_str[offset:offset+64], 16)
 name_hex = hex_str[offset+64:offset+64+length*2]
 info["name"] = bytes.fromhex(name_hex).decode("utf-8", errors="replace").strip('\x00')
 elif len(hex_str) == 64:
 info["name"] = bytes.fromhex(hex_str).decode("utf-8", errors="replace").strip('\x00')
 except:
 pass

 token_cache[addr_lower] = info
 return info

async def check_if_pool(addr: str) -> bool:
 """Check if address is a Uniswap V2/V3 pool (has token0 method)"""
 result = await rpc_call("eth_call", [
 {"to": addr, "data": "0x0dfe1681"}, "latest" # token0()
 ])
 if result and len(result) == 66: # 0x + 64 hex chars
 return True
 return False

async def get_eth_price() -> float:
 """Get ETH price from CoinGecko"""
 session = await get_http_session()
 try:
 async with session.get(
 "https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd",
 timeout=aiohttp.ClientTimeout(total=5),
 ) as resp:
 data = await resp.json()
 return data.get("ethereum", {}).get("usd", 0)
 except:
 return 2300 # fallback

async def get_token_price_usd(token_addr: str) -> float | None:
 """Get token USD price from DexScreener (free, no API key needed)"""
 session = await get_http_session()
 try:
 async with session.get(
 f"https://api.dexscreener.com/latest/dex/tokens/{token_addr}",
 timeout=aiohttp.ClientTimeout(total=5),
 ) as resp:
 data = await resp.json()
 pairs = data.get("pairs", [])
 if pairs:
 # Pick pair with highest liquidity
 pairs.sort(key=lambda p: float(p.get("liquidity", {}).get("usd", 0) or 0), reverse=True)
 price = float(pairs[0].get("priceUsd", 0) or 0)
 return price if price > 0 else None
 except:
 pass
 return None

# ============================================================
# Telegram notifications
# ============================================================

async def send_telegram(text: str):
 """Send Telegram message"""
 if not TG_BOT_TOKEN:
 log.warning("[TG] No bot token configured, skipping notification")
 return

 session = await get_http_session()
 url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage"
 payload = {
 "chat_id": TG_CHAT_ID,
 "text": text,
 "parse_mode": "HTML",
 "disable_web_page_preview": True,
 }

 try:
 async with session.post(url, json=payload, timeout=aiohttp.ClientTimeout(total=10)) as resp:
 result = await resp.json()
 if not result.get("ok"):
 log.error(f"[TG] Send failed: {result.get('description', '')}")
 # Retry with plain text if HTML parse fails
 if "parse" in result.get("description", "").lower():
 payload["parse_mode"] = None
 async with session.post(url, json=payload) as resp2:
 pass
 else:
 log.info("[TG] Message sent")
 except Exception as e:
 log.error(f"[TG] Error: {e}")

# ============================================================
# Event handling
# ============================================================

async def handle_transfer_event(log_entry: dict):
 """Process a single Transfer event"""
 tx_hash = log_entry.get("transactionHash", "")
 token_addr = log_entry.get("address", "")
 topics = log_entry.get("topics", [])
 data = log_entry.get("data", "0x0")

 # Dedup
 dedup_key = f"{tx_hash}:{token_addr}"
 if dedup_key in seen_txs:
 return
 seen_txs.add(dedup_key)
 seen_txs_list.append(dedup_key)
 # Cleanup (keep last 1000)
 while len(seen_txs_list) > 1000:
 old = seen_txs_list.pop(0)
 seen_txs.discard(old)

 # Parse topics: [Transfer, from, to]
 if len(topics) < 3:
 return

 from_addr = topic_to_address(topics[1])
 to_addr = topic_to_address(topics[2])

 # Confirm it's from Vitalik
 if from_addr.lower() != VITALIK_ADDRESS.lower():
 return

 # Get token info
 token_info = await get_token_info(token_addr)
 symbol = token_info["symbol"]
 decimals = token_info["decimals"]
 amount = decode_transfer_value(data, decimals)

 if amount == 0:
 return

 # Classify recipient
 recipient_type, recipient_name = classify_recipient(to_addr)

 # If unknown, check if it's an LP pool
 is_pool = False
 if recipient_type == "unknown":
 is_pool = await check_if_pool(to_addr)
 if is_pool:
 recipient_type = "pool"
 recipient_name = "LP Pool"

 # Determine if this is a "sell" action
 is_sell = recipient_type in ("dex", "cex", "pool")

 # If not a sell, just a regular transfer — log silently
 if not is_sell:
 log.info(f"[Transfer] {symbol} {amount:,.2f} → {shorten_addr(to_addr)} (regular transfer, not notifying)")
 return

 # Get price
 token_price = await get_token_price_usd(token_addr)
 usd_value = amount * token_price if token_price else None

 # Below minimum notification amount — skip
 if usd_value is not None and usd_value < MIN_NOTIFY_USD:
 log.info(f"[Sell] {symbol} ${usd_value:.0f} < ${MIN_NOTIFY_USD} minimum, skipping")
 return

 # Build notification message
 timestamp = datetime.now(timezone.utc).strftime("%H:%M:%S UTC")

 sell_type_label = {
 "dex": "🔄 DEX Sell",
 "cex": "🏦 CEX Transfer",
 "pool": "🌊 Pool Sell",
 }

 msg_lines = [
 f"<b>🚨 Vitalik Sell Signal</b>",
 f"",
 f"Token: <b>{symbol}</b>",
 f"Amount: {amount:,.4f}",
 ]

 if usd_value is not None:
 msg_lines.append(f"Value: <b>${usd_value:,.0f}</b>")

 if token_price is not None:
 msg_lines.append(f"Price: ${token_price:,.8f}")

 msg_lines.extend([
 f"",
 f"Type: {sell_type_label.get(recipient_type, 'Unknown')}",
 f"Destination: {recipient_name or shorten_addr(to_addr)}",
 f"Time: {timestamp}",
 f"",
 f"TX: https://etherscan.io/tx/{tx_hash}",
 f"Token: https://dexscreener.com/ethereum/{token_addr}",
 ])

 msg = "\n".join(msg_lines)
 log.info(f"[SELL DETECTED] {symbol} {amount:,.4f} → {recipient_name or to_addr} | ${usd_value or '?'}")
 await send_telegram(msg)

# ============================================================
# WebSocket listener main loop
# ============================================================

async def subscribe_and_listen(ws_url: str):
 """Connect to WebSocket and subscribe to Vitalik Transfer events"""
 log.info(f"Connecting to {ws_url}...")

 async with websockets.connect(
 ws_url,
 ping_interval=20,
 ping_timeout=30,
 close_timeout=10,
 max_size=2**20, # 1MB
 ) as ws:
 # Subscribe to Transfer FROM Vitalik
 sub_from = {
 "jsonrpc": "2.0", "id": 1,
 "method": "eth_subscribe",
 "params": ["logs", {
 "topics": [TRANSFER_TOPIC, VITALIK_PADDED]
 }]
 }
 await ws.send(json.dumps(sub_from))
 resp = await asyncio.wait_for(ws.recv(), timeout=10)
 data = json.loads(resp)
 if "error" in data:
 raise Exception(f"Subscribe failed: {data['error']}")
 sub_id_from = data.get("result", "")
 log.info(f"✅ Subscribed to Transfer FROM Vitalik (id={sub_id_from[:10]}...)")

 # Also subscribe to Transfer TO Vitalik (monitor buys/receives)
 sub_to = {
 "jsonrpc": "2.0", "id": 2,
 "method": "eth_subscribe",
 "params": ["logs", {
 "topics": [TRANSFER_TOPIC, None, VITALIK_PADDED]
 }]
 }
 await ws.send(json.dumps(sub_to))
 resp2 = await asyncio.wait_for(ws.recv(), timeout=10)
 data2 = json.loads(resp2)
 sub_id_to = data2.get("result", "")
 if sub_id_to:
 log.info(f"✅ Subscribed to Transfer TO Vitalik (id={sub_id_to[:10]}...)")

 log.info("🔍 Monitoring Vitalik wallet... waiting for events")

 # Listen for events
 async for message in ws:
 if not running:
 break

 try:
 evt = json.loads(message)

 if "params" not in evt:
 continue

 sub_id = evt["params"].get("subscription", "")
 log_entry = evt["params"].get("result", {})

 if sub_id == sub_id_from:
 # Vitalik sent tokens → check if it's a sell
 await handle_transfer_event(log_entry)
 elif sub_id == sub_id_to:
 # Vitalik received tokens — log silently
 token_addr = log_entry.get("address", "")
 token_info = await get_token_info(token_addr)
 data_hex = log_entry.get("data", "0x0")
 amount = decode_transfer_value(data_hex, token_info["decimals"])
 log.debug(f"[Receive] {token_info['symbol']} +{amount:,.4f}")

 except json.JSONDecodeError:
 continue
 except Exception as e:
 log.error(f"Event handling error: {e}", exc_info=True)

async def main():
 """Main loop with auto-reconnect"""
 global running

 # Validate required config
 if not TG_BOT_TOKEN:
 log.warning("TG_BOT_TOKEN not set — Telegram notifications disabled")
 if not TG_CHAT_ID:
 log.warning("TG_CHAT_ID not set — Telegram notifications disabled")

 # Signal handling
 def shutdown(sig, frame):
 global running
 log.info(f"Received signal {sig}, shutting down...")
 running = False

 signal.signal(signal.SIGINT, shutdown)
 signal.signal(signal.SIGTERM, shutdown)

 # Startup notice
 log.info("=" * 50)
 log.info("Vitalik Sell Radar — Started")
 log.info(f"Monitoring: {VITALIK_ADDRESS}")
 log.info(f"Min notify: ${MIN_NOTIFY_USD}")
 log.info(f"Telegram: {'✅ Configured' if TG_BOT_TOKEN else '❌ Not configured'}")
 log.info("=" * 50)

 if TG_BOT_TOKEN and TG_CHAT_ID:
 await send_telegram(
 "🟢 Vitalik Sell Radar — Started\n\n"
 f"Monitoring: {shorten_addr(VITALIK_ADDRESS)}\n"
 f"Min notify: ${MIN_NOTIFY_USD}\n"
 "Mode: WebSocket event-driven (sub-second latency)"
 )

 endpoint_idx = 0
 reconnect_delay = RECONNECT_DELAY

 while running:
 ws_url = WS_ENDPOINTS[endpoint_idx % len(WS_ENDPOINTS)]
 try:
 await subscribe_and_listen(ws_url)
 reconnect_delay = RECONNECT_DELAY # reset on success
 except websockets.exceptions.ConnectionClosed as e:
 log.warning(f"WebSocket closed: {e}")
 except asyncio.TimeoutError:
 log.warning("WebSocket timeout")
 except Exception as e:
 log.error(f"WebSocket error: {e}")

 if not running:
 break

 # Switch endpoint and retry
 endpoint_idx += 1
 log.info(f"Reconnecting in {reconnect_delay}s... (next: {WS_ENDPOINTS[endpoint_idx % len(WS_ENDPOINTS)]})")
 await asyncio.sleep(reconnect_delay)
 reconnect_delay = min(reconnect_delay * 1.5, MAX_RECONNECT_DELAY)

 # Cleanup
 if http_session and not http_session.closed:
 await http_session.close()

 log.info("Vitalik Sell Radar — Stopped")

if __name__ == "__main__":
 asyncio.run(main())

#!/usr/bin/env python3
"""
radar → radar v1
Python，zero AI cost（key matching + ）

3. Binance/CZ — BSC

data：GMGN + DEXScreenersearch
"""

import requests
import json
import time
import os
import re
import sqlite3
import hashlib
from datetime import datetime, timedelta
from pathlib import Path
from difflib import SequenceMatcher

# === configuration ===
DATA_DIR = os.path.expanduser("~/crypto-trading")
DB_FILE = os.path.join(DATA_DIR, "narrative_history.db")
LOG_FILE = os.path.join(DATA_DIR, "narrative_radar.log")
SEEN_FILE = os.path.join(DATA_DIR, "narrative_seen.json")
FLAP_SEEN_FILE = os.path.join(DATA_DIR, "flap_seen.json")

SCAN_INTERVAL = 30 # 30（GMGNdata1-5，10data）

# {address: [{'ts': timestamp, 'mc': market_cap, 'vol': volume, 'price': price}, ...]}
MOMENTUM_TRACKER = {}
MOMENTUM_PUSHED = {} # {address: {'count': N, 'last_ts': ts, 'last_mc': mc}} 
MOMENTUM_CONSECUTIVE_UP = 3 # consecutive3（data）

# from.envreadTGconfiguration
def load_env():
 env = {}
 env_file = os.path.expanduser("~/.env")
 if os.path.exists(env_file):
 with open(env_file) as f:
 for line in f:
 line = line.strip()
 if '=' in line and not line.startswith('#'):
 k, v = line.split('=', 1)
 env[k] = v
 return env

ENV = load_env()
TG_TOKEN = ENV.get('TELEGRAM_BOT_TOKEN', '')
TG_CHAT_ID = int(os.environ.get('TG_CHAT_ID', '0'))

GMGN_HEADERS = {
 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
 'Accept': 'application/json',
 'Referer': 'https://gmgn.ai/',
}

# ============================================================
# ============================================================
MUSK_TRUMP_KEYWORDS = {
 'musk', 'elon', 'elonmusk',
 # SpaceX/Tesla/X
 'spacex', 'starship', 'tesla', 'cybertruck', 'roadster',
 'neuralink', 'boring', 'hyperloop', 'xai', 'grok',
 'floki', 'shiba', # 
 'doge father', 'dogefather', 'technoking',
 'mars colony', 'mars',
 'trump', 'donald', 'maga', 'potus', 'trump47',
 'melania', 'barron', 'ivanka',
 'dark maga', 'darkmaga', 'ultra maga', 'save america',
 'truth social', 'covfefe',
 'doge department', 'd.o.g.e', 'government efficiency',
}

MUSK_TRUMP_PATTERNS = [
 r'\belon\b', r'\bmusk\b', r'\btrump\b', r'\bmaga\b',
 r'\bspacex\b', r'\bstarship\b', r'\btesla\b', r'\bgrok\b',
 r'\bmelania\b', r'\bbarron\b', r'\bdoge\s*department\b',
 r'\bd\.?o\.?g\.?e\b', # D.O.G.E
 r'\bx\s*ai\b', r'\bneuralink\b',
]

# ============================================================
# ============================================================
BINANCE_CZ_KEYWORDS = {
 # CZcore 
 'cz', 'changpeng', 'zhao', 'czb', 'czbinance',
 'heyi', 'yi he', 'he yi', '', 'yihe',
 'sister yi', 'yi jie', '', '',
 'binance', 'bnb', 'pancake', 'pancakeswap',
 'giggle academy', 'binance life', 'bnb chain',
 'principles', 'cz book',
 'yzi', 'yzi labs',
 '', 'Binance', '', 'cz', '',
 'fourmeme', 'four meme', '4meme',
 'czs dog', 'cz dog', 'bnb dog',
 'build on bnb', 'bnb ecosystem',
}

BINANCE_CZ_PATTERNS = [
 r'\bcz\b', r'\bbinance\b', r'\bbnb\b',
 r'\bheyi\b', r'\byi\s*he\b', r'\bhe\s*yi\b',
 r'\b\b', r'\b\b',
 r'\bpancake\b', r'\bgiggle\b', r'\byzi\b',
 r'\bfourmeme\b', r'\b4meme\b',
]

# ============================================================
# ============================================================
CELEBRITY_VIRAL_KEYWORDS = {
 'vitalik', 'buterin', 'sam altman', 'satoshi',
 'michael saylor', 'saylor', 'cathie wood',
 'jack dorsey', 'zuckerberg', 'bezos',
 'jensen huang', 'nvidia', 'tim cook',
 'justin sun', 'sun yuchen', '', 'tron',
 'arthur hayes', 'su zhu', '3ac',
 'brian armstrong', 'coinbase',
 'larry fink', 'blackrock',
 'gary gensler', 'sec',
 'michael novogratz', 'galaxy',
 'biden', 'obama', 'putin', 'xi jinping',
 'kanye', 'drake', 'snoop dogg', 'paris hilton',
 'mark cuban', 'mr beast', 'mrbeast',
 'lobster', '', 'lobsta',
 'hawk tuah', 'griddy', 'skibidi',
 'rizz', 'sigma', 'gyatt',
 'etf', 'halving', '',
 'world war', 'wwiii',
 'fed', 'rate cut', '',
 'tiktok ban', 'tiktok',
}

CELEBRITY_VIRAL_PATTERNS = [
 r'\bvitalik\b', r'\bsaylor\b', r'\bblackrock\b',
 r'\bcoinbase\b', r'\bjustin\s*sun\b', r'\blobster\b',
 r'\betf\b', r'\bhalving\b', r'\bmrbeast\b',
 r'\bsnoop\b', r'\bkanye\b', r'\bdrake\b',
]

# ============================================================
# ============================================================
SPAM_PATTERNS = [
 r'airdrop', r'presale', r'pre\s*sale',
 r'1000x', r'100x guaranteed',
 r'safe\s*moon', r'baby\s*\w+', # babydoge
 r'pornhub', r'porn', r'xxx', r'nsfw',
 r'nigga', r'nigger', r'faggot',
 r'scam', r'rugpull', r'rug\s*pull',
 r'official\s*token', r'official\s*coin',
]

COMMON_NOISE_WORDS = {
 'nice', 'good', 'bad', 'cool', 'hot', 'big', 'small',
 'life', 'love', 'hate', 'happy', 'sad', 'fun', 'lol',
 'cat', 'dog', 'moon', 'sun', 'star', 'king', 'queen',
 'gold', 'rich', 'cash', 'money', 'pay', 'buy', 'sell',
 'pump', 'dump', 'bull', 'bear', 'green', 'red',
 'hello', 'world', 'yes', 'no', 'wow', 'omg', 'lmao',
 'simp', 'chad', 'based', 'cope', 'seethe',
 'test', 'new', 'old', 'real', 'fake',
 'shit', 'shitcoin', 'fuck', 'fart', 'poop', 'pee',
 'cum', 'dick', 'ass', 'boob', 'tit',
 'nigga', 'retard', 'slop',
 'the', 'and', 'for', 'from', 'with', 'this', 'that',
 'coin', 'token', 'meme', 'pepe', 'wojak',
 'peg', 'usd', 'usdt', 'usdc', 'dai',
}

# ============================================================
# toolfunction
# ============================================================
def log(msg):
 ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 line = f"[{ts}] {msg}"
 print(line)
 os.makedirs(DATA_DIR, exist_ok=True)
 with open(LOG_FILE, 'a') as f:
 f.write(line + '\n')

def load_flap_seen():
 if os.path.exists(FLAP_SEEN_FILE):
 try:
 with open(FLAP_SEEN_FILE) as f:
 return json.load(f)
 except:
 pass
 return {}

def save_flap_seen(data):
 cutoff = int(time.time()) - 86400 * 7
 data = {k: v for k, v in data.items() if v > cutoff}
 with open(FLAP_SEEN_FILE, 'w') as f:
 json.dump(data, f)

def tg_send(text, parse_mode='Markdown'):
 if not TG_TOKEN:
 log(f"[TG] No token, skip: {text[:80]}")
 return False
 try:
 resp = requests.post(
 f'https://api.telegram.org/bot{TG_TOKEN}/sendMessage',
 json={'chat_id': TG_CHAT_ID, 'text': text, 'parse_mode': parse_mode},
 timeout=10
 )
 result = resp.json()
 if not result.get('ok'):
 if 'can\'t parse' in str(result.get('description', '')).lower():
 resp = requests.post(
 f'https://api.telegram.org/bot{TG_TOKEN}/sendMessage',
 json={'chat_id': TG_CHAT_ID, 'text': text},
 timeout=10
 )
 else:
 log(f"[TG] Error: {result.get('description', '')}")
 return False
 return True
 except Exception as e:
 log(f"[TG] Send error: {e}")
 return False

# ============================================================
# ============================================================
def init_db():
 """initializeSQLitelibrary"""
 conn = sqlite3.connect(DB_FILE)
 c = conn.cursor()
 
 c.execute('''CREATE TABLE IF NOT EXISTS narratives (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 theme TEXT NOT NULL, -- （）
 first_token_name TEXT, -- token
 first_token_address TEXT, -- address
 first_chain TEXT, -- 
 first_seen_at INTEGER, -- 
 token_count INTEGER DEFAULT 1, -- 
 last_seen_at INTEGER -- 
 )''')
 
 c.execute('''CREATE TABLE IF NOT EXISTS tokens_seen (
 address TEXT PRIMARY KEY,
 chain TEXT,
 name TEXT,
 symbol TEXT,
 narrative_theme TEXT,
 category TEXT, -- 'musk_trump' / 'binance_cz' / 'novel' / 'common'
 first_seen_at INTEGER,
 market_cap REAL,
 pushed INTEGER DEFAULT 0, -- 
 seen_count INTEGER DEFAULT 1 -- 
 )''')
 
 # index
 c.execute('CREATE INDEX IF NOT EXISTS idx_theme ON narratives(theme)')
 c.execute('CREATE INDEX IF NOT EXISTS idx_addr ON tokens_seen(address)')
 
 conn.commit()
 return conn

def normalize_theme(name, symbol):
 """
 ：'Elon Mars Colony' → 'elon mars colony'
 'TRUMP2028' → 'trump'
 'PancakeBunny' → 'pancake bunny'
 """
 text = f"{name} {symbol}".lower().strip()
 
 noise = ['token', 'coin', 'inu', 'swap', 'finance', 'protocol',
 'dao', 'defi', 'nft', 'meta', 'verse', 'fi', 'ai',
 'pepe', 'wojak', 'chad', 'based']
 
 # splitcamelCase
 text = re.sub(r'([a-z])([A-Z])', r'\1 \2', text)
 text = re.sub(r'\d+x?', '', text)
 text = re.sub(r'[^a-z\s]', ' ', text)
 words = [w for w in text.split() if w and len(w) > 1 and w not in noise]
 
 if not words:
 return name.lower().strip()
 
 return ' '.join(sorted(set(words)))

def is_similar_theme(theme1, theme2, threshold=0.7):
 if theme1 == theme2:
 return True
 if theme1 in theme2 or theme2 in theme1:
 return True
 words1 = set(theme1.split())
 words2 = set(theme2.split())
 if words1 and words2:
 overlap = len(words1 & words2) / min(len(words1), len(words2))
 if overlap >= 0.6:
 return True
 return SequenceMatcher(None, theme1, theme2).ratio() >= threshold

def check_narrative_novelty(conn, theme, name, symbol, address, chain):
 """
 return：
 ('novel', None) — 
 ('heating', narrative_row) — ！！
 ('existing', existing_theme_row) — ，
 
 """
 c = conn.cursor()
 now = int(time.time())
 HEAT_WINDOW = 1800 # 30
 HEAT_THRESHOLD = 2 # 2aboveis 
 
 c.execute('SELECT id, theme, first_token_name, first_token_address, first_chain, first_seen_at, token_count, last_seen_at FROM narratives WHERE theme = ?', (theme,))
 exact = c.fetchone()
 if exact:
 row_id, _, _, _, _, first_seen, count, last_seen = exact
 new_count = count + 1
 c.execute('UPDATE narratives SET token_count = ?, last_seen_at = ? WHERE theme = ?',
 (new_count, now, theme))
 conn.commit()
 
 if now - first_seen < HEAT_WINDOW and new_count >= HEAT_THRESHOLD:
 return ('heating', exact)
 if now - last_seen < HEAT_WINDOW and new_count >= HEAT_THRESHOLD:
 return ('heating', exact)
 
 return ('existing', exact)
 
 c.execute('SELECT id, theme, first_token_name, first_token_address, first_chain, first_seen_at, token_count, last_seen_at FROM narratives ORDER BY last_seen_at DESC LIMIT 1000')
 for row in c.fetchall():
 if is_similar_theme(theme, row[1]):
 row_id, _, _, _, _, first_seen, count, last_seen = row
 new_count = count + 1
 c.execute('UPDATE narratives SET token_count = ?, last_seen_at = ? WHERE id = ?',
 (new_count, now, row[0]))
 conn.commit()
 
 if now - last_seen < HEAT_WINDOW and new_count >= HEAT_THRESHOLD:
 return ('heating', row)
 
 return ('existing', row)
 
 c.execute('''INSERT INTO narratives (theme, first_token_name, first_token_address, first_chain, first_seen_at, last_seen_at)
 VALUES (?, ?, ?, ?, ?, ?)''',
 (theme, name, address, chain, now, now))
 conn.commit()
 return ('novel', None)

def get_token_seen_count(conn, address):
 c = conn.cursor()
 c.execute('SELECT seen_count FROM tokens_seen WHERE address = ?', (address,))
 row = c.fetchone()
 return row[0] if row else 0

def is_token_seen(conn, address):
 c = conn.cursor()
 c.execute('SELECT address FROM tokens_seen WHERE address = ?', (address,))
 return c.fetchone() is not None

def record_token(conn, address, chain, name, symbol, theme, category, mc, pushed=False):
 c = conn.cursor()
 c.execute('SELECT seen_count FROM tokens_seen WHERE address = ?', (address,))
 existing = c.fetchone()
 if existing:
 new_count = existing[0] + 1
 c.execute('''UPDATE tokens_seen SET seen_count = ?, market_cap = ?, category = ?
 WHERE address = ?''', (new_count, mc, category, address))
 else:
 c.execute('''INSERT INTO tokens_seen 
 (address, chain, name, symbol, narrative_theme, category, first_seen_at, market_cap, pushed, seen_count)
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1)''',
 (address, chain, name, symbol, theme, category, int(time.time()), mc, 1 if pushed else 0))
 conn.commit()

# ============================================================
# ============================================================
def classify_narrative(name, symbol, chain):
 """
 classificationtoken
 return：('musk_trump', matched_keywords) / ('binance_cz', matched_keywords) / ('novel', None) / ('common', None)
 """
 text = f"{name} {symbol}".lower()
 
 for pat in SPAM_PATTERNS:
 if re.search(pat, text, re.IGNORECASE):
 return ('spam', None)
 
 matched_mt = []
 for kw in MUSK_TRUMP_KEYWORDS:
 if kw.lower() in text:
 matched_mt.append(kw)
 if not matched_mt:
 for pat in MUSK_TRUMP_PATTERNS:
 m = re.search(pat, text, re.IGNORECASE)
 if m:
 matched_mt.append(m.group())
 
 if matched_mt:
 chain_lower = chain.lower()
 if chain_lower in ('eth', 'ethereum', 'sol', 'solana', 'bsc', 'base'):
 return ('musk_trump', matched_mt)
 
 matched_bc = []
 for kw in BINANCE_CZ_KEYWORDS:
 if kw.lower() in text:
 matched_bc.append(kw)
 if not matched_bc:
 for pat in BINANCE_CZ_PATTERNS:
 m = re.search(pat, text, re.IGNORECASE)
 if m:
 matched_bc.append(m.group())
 
 if matched_bc:
 chain_lower = chain.lower()
 if chain_lower in ('bsc',):
 return ('binance_cz', matched_bc)
 else:
 return ('binance_cz_wrong_chain', matched_bc)
 
 matched_cv = []
 for kw in CELEBRITY_VIRAL_KEYWORDS:
 if kw.lower() in text:
 matched_cv.append(kw)
 if not matched_cv:
 for pat in CELEBRITY_VIRAL_PATTERNS:
 m = re.search(pat, text, re.IGNORECASE)
 if m:
 matched_cv.append(m.group())
 
 if matched_cv:
 return ('celebrity_viral', matched_cv)
 
 return ('check_novelty', None)

# ============================================================
# ============================================================
def check_token_safety(chain, address):
 if chain in ('sol', 'solana'):
 try:
 r = requests.get(f'https://api.rugcheck.xyz/v1/tokens/{address}/report', timeout=10)
 if r.status_code == 200:
 data = r.json()
 score = data.get('score', 999)
 mint = data.get('mintAuthority')
 freeze = data.get('freezeAuthority')
 return {
 'safe': not mint and not freeze,
 'score': score, 'mint': mint is not None,
 'freeze': freeze is not None
 }
 except:
 pass
 else:
 chain_map = {'ethereum': '1', 'eth': '1', 'bsc': '56', 'base': '8453'}
 cid = chain_map.get(chain, '1')
 try:
 r = requests.get(f'https://api.gopluslabs.io/api/v1/token_security/{cid}?contract_addresses={address}', timeout=10)
 if r.status_code == 200:
 result = r.json().get('result', {})
 data = result.get(address.lower(), {})
 if data:
 honeypot = data.get('is_honeypot', '0') == '1'
 mintable = data.get('is_mintable', '0') == '1'
 sell_tax = float(data.get('sell_tax', '0') or '0')
 buy_tax = float(data.get('buy_tax', '0') or '0')
 return {
 'safe': not honeypot and not mintable, # as
 'honeypot': honeypot, 'mintable': mintable,
 'sell_tax': sell_tax, 'buy_tax': buy_tax
 }
 except:
 pass

# ============================================================
# ============================================================
def gmgn_get(url):
 try:
 resp = requests.get(url, headers=GMGN_HEADERS, timeout=15)
 if resp.status_code == 200:
 return resp.json().get('data', {})
 except:
 pass
 return {}

def fetch_token_description(chain, address):
 """token/ — radarcore """
 desc = ''
 
 if chain in ('sol', 'solana'):
 try:
 r = requests.get(f'https://frontend-api-v3.pump.fun/coins/{address}', timeout=8)
 if r.status_code == 200:
 data = r.json()
 desc = data.get('description', '') or ''
 twitter = data.get('twitter', '') or ''
 telegram = data.get('telegram', '') or ''
 website = data.get('website', '') or ''
 return {
 'description': desc.strip(),
 'twitter': twitter,
 'telegram': telegram,
 'website': website,
 }
 except:
 pass
 
 try:
 chain_dex = {'sol': 'solana', 'eth': 'ethereum', 'bsc': 'bsc', 'base': 'base',
 'solana': 'solana', 'ethereum': 'ethereum'}.get(chain, chain)
 r = requests.get(f'https://api.dexscreener.com/latest/dex/tokens/{address}', timeout=8)
 if r.status_code == 200:
 pairs = r.json().get('pairs', [])
 if pairs:
 info = pairs[0].get('info', {})
 websites = info.get('websites', [])
 socials = info.get('socials', [])
 twitter = ''
 telegram = ''
 website = ''
 for s in socials:
 if s.get('type') == 'twitter':
 twitter = s.get('url', '')
 elif s.get('type') == 'telegram':
 telegram = s.get('url', '')
 for w in websites:
 if w.get('label', '').lower() == 'website':
 website = w.get('url', '')
 if not desc:
 return {
 'description': desc,
 'twitter': twitter,
 'telegram': telegram,
 'website': website,
 }
 except:
 pass
 
 return {'description': desc, 'twitter': '', 'telegram': '', 'website': ''}

def fetch_new_tokens():
 """fromGMGN + multi-dimensionalcovering"""
 all_tokens = []
 seen_addrs = set()
 
 for chain in ['eth', 'bsc', 'base']:
 urls = [
 f'https://gmgn.ai/defi/quotation/v1/rank/{chain}/swaps/1h?orderby=open_timestamp&direction=desc&limit=100',
 f'https://gmgn.ai/defi/quotation/v1/rank/{chain}/swaps/1h?orderby=swaps&direction=desc&limit=50',
 ]
 
 for url in urls:
 data = gmgn_get(url)
 tokens = data.get('rank', [])
 
 for t in tokens:
 addr = t.get('address', '')
 if not addr or addr in seen_addrs:
 continue
 
 mc = t.get('market_cap', 0) or t.get('fdv', 0) or 0
 liq = t.get('liquidity', 0) or 0
 
 if mc < 1000 or liq < 500 or mc > 10000000:
 continue
 
 age_ts = t.get('open_timestamp', 0)
 age_h = (time.time() - age_ts) / 3600 if age_ts > 0 else 999
 
 
 seen_addrs.add(addr)
 all_tokens.append({
 'address': addr,
 'chain': chain,
 'name': t.get('name', '?'),
 'symbol': t.get('symbol', '?'),
 'mc': mc,
 'liq': liq,
 'volume': t.get('volume', 0) or 0,
 'holders': t.get('holder_count', 0) or 0,
 'sm': t.get('smart_degen_count', 0) or 0,
 'chg_1h': t.get('price_change_percent1h', 0) or 0,
 'chg_24h': t.get('price_change_percent', 0) or 0,
 'age_h': age_h,
 'price': t.get('price', 0),
 'buys_1h': t.get('buys', 0) or 0,
 'sells_1h': t.get('sells', 0) or 0,
 })
 
 time.sleep(0.3)
 
 return all_tokens

def fetch_flap_tokens():
 """
 FLAPplatformscan — BSCcommunitydriver
 features：24h，but 1hstabilize/，>sell，holders
 """
 data = gmgn_get(
 'https://gmgn.ai/defi/quotation/v1/rank/bsc/swaps/24h?launchpad=flap&orderby=volume&direction=desc&limit=30'
 )
 tokens = data.get('rank', [])
 
 candidates = []
 for t in tokens:
 addr = t.get('address', '')
 if not addr:
 continue
 
 mc = t.get('market_cap', 0) or 0
 liq = t.get('liquidity', 0) or 0
 vol = t.get('volume', 0) or 0
 holders = t.get('holder_count', 0) or 0
 buys = t.get('buys', 0) or 0
 sells = t.get('sells', 0) or 0
 chg_1h = t.get('price_change_percent1h', 0) or 0
 chg_24h = t.get('price_change_percent', 0) or 0
 age_ts = t.get('open_timestamp', 0)
 age_h = (time.time() - age_ts) / 3600 if age_ts > 0 else 0
 
 if mc < 1000 or liq < 500:
 continue
 if holders < 5:
 continue
 
 buy_ratio = buys / max(sells, 1)
 
 is_support = False
 reason = ''
 
 if chg_24h < -10 and chg_1h > chg_24h * 0.3:
 is_support = True
 reason = f'24h{chg_24h:.0f}%but 1hstabilize{chg_1h:+.0f}%'
 
 if -10 <= chg_24h <= 30 and chg_1h > -5 and buy_ratio > 1.1:
 is_support = True
 reason = f' {buy_ratio:.2f}'
 
 if chg_24h < -30 and chg_1h > 10:
 is_support = True
 reason = f'{chg_24h:.0f}%bounce{chg_1h:+.0f}%'
 
 if is_support and buy_ratio >= 1.0:
 candidates.append({
 'address': addr,
 'chain': 'bsc',
 'name': t.get('name', '?'),
 'symbol': t.get('symbol', '?'),
 'mc': mc,
 'liq': liq,
 'volume': vol,
 'holders': holders,
 'sm': 0,
 'chg_1h': chg_1h,
 'chg_24h': chg_24h,
 'age_h': age_h,
 'price': t.get('price', 0),
 'buys': buys,
 'sells': sells,
 'buy_ratio': buy_ratio,
 'support_reason': reason,
 'launchpad': 'flap',
 })
 
 candidates.sort(key=lambda x: x['mc'], reverse=True)
 return candidates

def format_flap_alert(token, desc_info=None):
 msg = f"radar — FLAP\n"
 msg += f": BSC | platform: FLAP\n\n"
 msg += f"{token['name']} ({token['symbol']})\n"
 msg += f"`{token['address']}`\n\n"
 
 desc = (desc_info or {}).get('description', '')
 if desc:
 if len(desc) > 200:
 desc = desc[:200] + '...'
 msg += f": {desc}\n\n"
 
 msg += f": {token['support_reason']}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f"liquidity ${token['liq']:>12,.0f}\n"
 msg += f"24h ${token['volume']:>12,.0f}\n"
 msg += f" {token['holders']:>12,d}\n"
 msg += f"/ {token['buys']:>6,d}/{token['sells']:>6,d}\n"
 msg += f" {token['buy_ratio']:>12.2f}\n"
 msg += f"1h {token['chg_1h']:>+11.1f}%\n"
 msg += f"24h {token['chg_24h']:>+11.1f}%\n"
 msg += f"```\n"
 msg += "\nFLAPcommunity — "
 
 links = []
 if (desc_info or {}).get('twitter'):
 links.append(f"\nTwitter: {desc_info['twitter']}")
 if (desc_info or {}).get('telegram'):
 links.append(f"TG: {desc_info['telegram']}")
 if (desc_info or {}).get('website'):
 links.append(f"Web: {desc_info['website']}")
 if links:
 msg += '\n'.join(links)
 
 return msg

# ============================================================
# ============================================================
def format_musk_trump_alert(token, matched_kw, desc_info=None):
 chain_map = {'sol': 'SOL', 'eth': 'ETH', 'bsc': 'BSC', 'base': 'BASE'}
 ch = chain_map.get(token['chain'], token['chain'].upper())
 
 msg += f": {ch}\n\n"
 msg += f"{token['name']} ({token['symbol']})\n"
 msg += f"`{token['address']}`\n\n"
 
 desc = (desc_info or {}).get('description', '')
 if desc:
 if len(desc) > 200:
 desc = desc[:200] + '...'
 msg += f": {desc}\n\n"
 
 msg += f"key : {', '.join(matched_kw[:5])}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f"liquidity ${token['liq']:>12,.0f}\n"
 msg += f"1h {token['chg_1h']:>+11.1f}%\n"
 if token.get('sm', 0) > 0:
 msg += f" {token['sm']:>12d}\n"
 msg += f" {token['age_h']:>10.1f}h\n"
 msg += f"```\n"
 
 links = []
 if (desc_info or {}).get('twitter'):
 links.append(f"Twitter: {desc_info['twitter']}")
 if (desc_info or {}).get('telegram'):
 links.append(f"TG: {desc_info['telegram']}")
 if (desc_info or {}).get('website'):
 links.append(f"Web: {desc_info['website']}")
 if links:
 msg += '\n' + '\n'.join(links)
 
 return msg

def format_binance_cz_alert(token, matched_kw, desc_info=None):
 """Binance/CZ"""
 msg = f"radar — Binance/CZ\n"
 msg += f": BSC\n\n"
 msg += f"{token['name']} ({token['symbol']})\n"
 msg += f"`{token['address']}`\n\n"
 
 desc = (desc_info or {}).get('description', '')
 if desc:
 if len(desc) > 200:
 desc = desc[:200] + '...'
 msg += f": {desc}\n\n"
 
 msg += f"key : {', '.join(matched_kw[:5])}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f"liquidity ${token['liq']:>12,.0f}\n"
 msg += f"1h {token['chg_1h']:>+11.1f}%\n"
 msg += f" {token['age_h']:>10.1f}h\n"
 msg += f"```\n"
 
 links = []
 if (desc_info or {}).get('twitter'):
 links.append(f"Twitter: {desc_info['twitter']}")
 if (desc_info or {}).get('telegram'):
 links.append(f"TG: {desc_info['telegram']}")
 if (desc_info or {}).get('website'):
 links.append(f"Web: {desc_info['website']}")
 if links:
 msg += '\n' + '\n'.join(links)
 
 return msg

def format_novel_narrative_alert(token, theme, desc_info=None):
 return format_heating_narrative_alert(token, theme, 1, desc_info)

def format_heating_narrative_alert(token, theme, count, desc_info=None):
 chain_map = {'sol': 'SOL', 'eth': 'ETH', 'bsc': 'BSC', 'base': 'BASE'}
 ch = chain_map.get(token['chain'], token['chain'].upper())
 
 msg = f"radar — \n"
 msg += f": {ch}\n\n"
 msg += f"{token['name']} ({token['symbol']})\n"
 msg += f"`{token['address']}`\n\n"
 
 desc = (desc_info or {}).get('description', '')
 if desc:
 if len(desc) > 300:
 desc = desc[:300] + '...'
 msg += f": {desc}\n\n"
 else:
 msg += f": {theme}\n\n"
 
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f"liquidity ${token['liq']:>12,.0f}\n"
 msg += f"1h {token['chg_1h']:>+11.1f}%\n"
 if token.get('sm', 0) > 0:
 msg += f" {token['sm']:>12d}\n"
 msg += f" {token['holders']:>12d}\n"
 msg += f" {token['age_h']:>10.1f}h\n"
 msg += f"```"
 
 links = []
 if (desc_info or {}).get('twitter'):
 links.append(f"\nTwitter: {desc_info['twitter']}")
 if (desc_info or {}).get('telegram'):
 links.append(f"TG: {desc_info['telegram']}")
 if (desc_info or {}).get('website'):
 links.append(f"Web: {desc_info['website']}")
 if links:
 msg += '\n'.join(links)
 
 return msg

# ============================================================
# ============================================================
def track_momentum(tokens):
 """
 """
 global MOMENTUM_TRACKER, MOMENTUM_PUSHED
 now = time.time()
 alerts = []
 
 current_addrs = set()
 
 for token in tokens:
 addr = token['address']
 mc = token['mc']
 vol = token.get('volume', 0) or 0
 price = token.get('price', 0) or 0
 buys = token.get('buys_1h', 0) or token.get('buys', 0) or 0
 
 current_addrs.add(addr)
 
 if mc < 1000 or token.get('liq', 0) < 500 or mc > 10000000:
 continue
 
 if addr not in MOMENTUM_TRACKER:
 MOMENTUM_TRACKER[addr] = []
 
 snapshots = MOMENTUM_TRACKER[addr]
 
 if snapshots and snapshots[-1]['mc'] == mc and snapshots[-1]['vol'] == vol:
 continue # data，
 
 snapshots.append({
 'ts': now,
 'mc': mc,
 'vol': vol,
 'price': price,
 'buys': buys,
 })
 
 if len(snapshots) > 20:
 snapshots[:] = snapshots[-20:]
 
 if len(snapshots) < MOMENTUM_CONSECUTIVE_UP:
 continue
 
 recent = snapshots[-MOMENTUM_CONSECUTIVE_UP:]
 consecutive_up = True
 total_gain = 0
 
 for i in range(1, len(recent)):
 prev_mc = recent[i-1]['mc']
 curr_mc = recent[i]['mc']
 if prev_mc <= 0:
 consecutive_up = False
 break
 gain = (curr_mc - prev_mc) / prev_mc
 consecutive_up = False
 break
 total_gain += gain
 
 if not consecutive_up:
 continue
 
 vol_increasing = True
 for i in range(1, len(recent)):
 if recent[i]['buys'] < recent[i-1]['buys'] * 0.8: # 
 vol_increasing = False
 break
 
 first_mc = recent[0]['mc']
 last_mc = recent[-1]['mc']
 pct_gain = ((last_mc - first_mc) / first_mc * 100) if first_mc > 0 else 0
 
 if pct_gain < 5:
 continue
 
 push_info = MOMENTUM_PUSHED.get(addr, {'count': 0, 'last_ts': 0, 'last_mc': 0})
 
 if push_info['count'] > 0 and last_mc <= push_info['last_mc']:
 continue
 
 push_info['count'] += 1
 push_info['last_ts'] = now
 push_info['last_mc'] = last_mc
 signal_count = push_info['count']
 
 safety = check_token_safety(token['chain'], addr)
 if not safety.get('safe'):
 continue
 
 category, matched_kw = classify_narrative(token['name'], token['symbol'], token['chain'])
 is_flap = token.get('launchpad') == 'flap'
 
 if category == 'musk_trump':
 stars = 3
 narrative_tag = f"/ ({', '.join(matched_kw[:3])})"
 elif category == 'binance_cz':
 stars = 3
 narrative_tag = f"Binance/CZ ({', '.join(matched_kw[:3])})"
 elif category == 'celebrity_viral':
 stars = 2
 narrative_tag = f"/ ({', '.join(matched_kw[:3])})"
 elif is_flap:
 stars = 2
 narrative_tag = "FLAPcommunity"
 else:
 theme = normalize_theme(token['name'], token['symbol'])
 theme_words = [w for w in theme.split() if w not in COMMON_NOISE_WORDS and len(w) > 2]
 if len(theme_words) >= 2:
 stars = 2
 narrative_tag = f": {theme}"
 else:
 stars = 1
 narrative_tag = ""
 
 desc_info = fetch_token_description(token['chain'], addr)
 
 if is_flap:
 has_twitter = bool(desc_info.get('twitter'))
 has_tg = bool(desc_info.get('telegram'))
 has_web = bool(desc_info.get('website'))
 community_tags = []
 if has_twitter:
 community_tags.append("")
 if has_tg:
 community_tags.append("TG")
 if has_web:
 community_tags.append("")
 if community_tags:
 narrative_tag += f" | {' '.join(community_tags)}"
 stars = min(3, stars + 1) # community
 else:
 narrative_tag += " | communityLinks"
 
 msg = format_momentum_alert(token, pct_gain, len(recent), vol_increasing, stars, narrative_tag, desc_info, signal_count)
 alerts.append({'msg': msg, 'token': token})
 MOMENTUM_PUSHED[addr] = push_info
 
 log(f"[{signal_count}] {token['name']} ({token['symbol']}) on {token['chain']} — {len(recent)} +{pct_gain:.1f}%")
 
 stale = [a for a in MOMENTUM_TRACKER if a not in current_addrs]
 for a in stale:
 if now - MOMENTUM_TRACKER[a][-1]['ts'] > 600: # 10
 del MOMENTUM_TRACKER[a]
 
 MOMENTUM_PUSHED = {k: v for k, v in MOMENTUM_PUSHED.items() if now - v.get('last_ts', 0) < 3600}
 
 return alerts

def format_momentum_alert(token, pct_gain, rounds, vol_up, stars, narrative_tag, desc_info=None, seen_count=0):
 chain_map = {'sol': 'SOL', 'eth': 'ETH', 'bsc': 'BSC', 'base': 'BASE'}
 ch = chain_map.get(token['chain'], token['chain'].upper())
 
 vol_tag = "" if vol_up else ""
 star_str = "★" * stars + "☆" * (3 - stars)
 
 msg = f"radar\n"
 msg += f": {ch}\n\n"
 msg += f"{token['name']} ({token['symbol']})\n"
 msg += f"`{token['address']}`\n\n"
 
 desc = (desc_info or {}).get('description', '')
 if desc:
 if len(desc) > 200:
 desc = desc[:200] + '...'
 msg += f": {desc}\n\n"
 
 msg += f": {narrative_tag}\n"
 msg += f"{rounds} +{pct_gain:.1f}% {vol_tag}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f"liquidity ${token['liq']:>12,.0f}\n"
 msg += f"1h {token['chg_1h']:>+11.1f}%\n"
 if token.get('sm', 0) > 0:
 msg += f" {token['sm']:>12d}\n"
 msg += f" {token['age_h']:>10.1f}h\n"
 msg += f"```\n"
 msg += f": {star_str} : {seen_count}"
 
 links = []
 if (desc_info or {}).get('twitter'):
 links.append(f"\nTwitter: {desc_info['twitter']}")
 if (desc_info or {}).get('telegram'):
 links.append(f"TG: {desc_info['telegram']}")
 if (desc_info or {}).get('website'):
 links.append(f"Web: {desc_info['website']}")
 if links:
 msg += '\n'.join(links)
 
 return msg

def format_celebrity_alert(token, matched_kw, desc_info=None):
 chain_map = {'sol': 'SOL', 'eth': 'ETH', 'bsc': 'BSC', 'base': 'BASE'}
 ch = chain_map.get(token['chain'], token['chain'].upper())
 
 msg = f"radar — / ★★\n"
 msg += f": {ch}\n\n"
 msg += f"{token['name']} ({token['symbol']})\n"
 msg += f"`{token['address']}`\n\n"
 
 desc = (desc_info or {}).get('description', '')
 if desc:
 if len(desc) > 200:
 desc = desc[:200] + '...'
 msg += f": {desc}\n\n"
 
 msg += f"key : {', '.join(matched_kw[:5])}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f"liquidity ${token['liq']:>12,.0f}\n"
 msg += f"1h {token['chg_1h']:>+11.1f}%\n"
 if token.get('sm', 0) > 0:
 msg += f" {token['sm']:>12d}\n"
 msg += f" {token['age_h']:>10.1f}h\n"
 msg += f"```"
 
 links = []
 if (desc_info or {}).get('twitter'):
 links.append(f"\nTwitter: {desc_info['twitter']}")
 if (desc_info or {}).get('telegram'):
 links.append(f"TG: {desc_info['telegram']}")
 if links:
 msg += '\n'.join(links)
 
 return msg

# ============================================================
# ============================================================
def scan_narratives():
 """scanfunction"""
 conn = init_db()
 tokens = fetch_new_tokens()
 
 log(f"scan {len(tokens)} ...")
 
 flap_tokens = []
 try:
 flap_tokens = fetch_flap_tokens()
 except:
 pass
 all_momentum_tokens = tokens + flap_tokens
 momentum_alerts = track_momentum(all_momentum_tokens)
 
 for token in tokens:
 addr = token['address']
 chain = token['chain']
 name = token['name']
 symbol = token['symbol']
 
 if is_token_seen(conn, addr):
 # updateseen_count
 c = conn.cursor()
 c.execute('UPDATE tokens_seen SET seen_count = seen_count + 1, market_cap = ? WHERE address = ?', (token['mc'], addr))
 theme_tmp = normalize_theme(name, symbol)
 if theme_tmp:
 c.execute('UPDATE narratives SET token_count = token_count + 1, last_seen_at = ? WHERE theme = ?', (int(time.time()), theme_tmp))
 conn.commit()
 continue
 
 category, matched_kw = classify_narrative(name, symbol, chain)
 
 if category == 'spam':
 record_token(conn, addr, chain, name, symbol, '', 'spam', token['mc'])
 continue
 
 min_mc = 1000
 min_liq = 500
 if token['mc'] < min_mc or token['liq'] < min_liq:
 record_token(conn, addr, chain, name, symbol, '', 'too_small', token['mc'])
 continue
 
 theme = normalize_theme(name, symbol)
 
 record_token(conn, addr, chain, name, symbol, theme, category, token['mc'])
 check_narrative_novelty(conn, theme, name, symbol, addr, chain)
 
 conn.close()
 
 pushed = 0
 for ma in momentum_alerts[:8]: # 8
 if tg_send(ma['msg']):
 pushed += 1
 time.sleep(1) # TGrate limiting
 
 return pushed, len(momentum_alerts)

# ============================================================
# ============================================================
def main():
 log("=" * 50)
 log("radar v1 ")
 log(f"scan: {SCAN_INTERVAL}s")
 log("=" * 50)
 
 # initializeDB
 init_db()
 
 tg_send(
 "radar v1 \n\n"
 "classificationlabels:\n"
 "★★★ / | Binance/CZ | FLAPcommunity\n"
 "★★ | FLAPcommunity | \n"
 f"scan: {SCAN_INTERVAL}"
 )
 
 scan_count = 0
 total_pushed = 0
 
 while True:
 try:
 scan_count += 1
 pushed, found = scan_narratives()
 total_pushed += pushed
 
 if pushed > 0:
 log(f"{scan_count}: {found}, {pushed} ({total_pushed})")
 else:
 if scan_count % 20 == 0: # 20
 log(f"{scan_count}: ({total_pushed})")
 
 except Exception as e:
 log(f"scan: {e}")
 
 time.sleep(SCAN_INTERVAL)

if __name__ == '__main__':
 main()