Code Vault — 7 Công Cụ Mã Nguồn Mở Cho Radar và Giao Dịch Crypto

#!/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
"""
 → v1
Python，AI（ + ）

：
1. — /，
2. / — ETH+SOL，BSC
3. /CZ — BSC

：GMGN + DEXScreener
：SQLite
"""

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

# === ===
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（GMGN1-5，10）

# — /
# {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 # 3（）

# .envTG
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',
]

# ============================================================
# /CZ
# ============================================================
BINANCE_CZ_KEYWORDS = {
 # CZ
 'cz', 'changpeng', 'zhao', 'czb', 'czbinance',
 # （BSC！）
 'heyi', 'yi he', 'he yi', '', 'yihe',
 'sister yi', 'yi jie', '', '',
 # 
 'binance', 'bnb', 'pancake', 'pancakeswap',
 # CZ（、、）
 'giggle academy', 'binance life', 'bnb chain',
 'principles', 'cz book',
 # YZi Labs (Binance Labs)
 'yzi', 'yzi labs',
 # （BSC）
 '', '', '', 'cz', '',
 # Four.meme
 'fourmeme', 'four meme', '4meme',
 # CZ/
 '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',
}

# ============================================================
# 
# ============================================================
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):
 # 7
 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'):
 # Markdown
 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():
 """SQLite"""
 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, -- 
 first_token_address TEXT, -- 
 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 -- 
 )''')
 
 # 
 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'
 """
 # namesymbol
 text = f"{name} {symbol}".lower().strip()
 
 # /
 noise = ['token', 'coin', 'inu', 'swap', 'finance', 'protocol',
 'dao', 'defi', 'nft', 'meta', 'verse', 'fi', 'ai',
 'pepe', 'wojak', 'chad', 'based']
 
 # camelCase
 text = re.sub(r'([a-z])([A-Z])', r'\1 \2', text)
 # （2028、1000x）
 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):
 """
 
 ：
 ('novel', None) — 
 ('heating', narrative_row) — ！！
 ('existing', existing_theme_row) — ，
 
 ：302+ = 
 """
 c = conn.cursor()
 now = int(time.time())
 HEAT_WINDOW = 1800 # 30
 HEAT_THRESHOLD = 2 # 2
 
 # 
 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()
 
 # ：HEAT_WINDOW
 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)
 
 # — 1000
 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):
 """ — +1"""
 c = conn.cursor()
 # 
 c.execute('SELECT seen_count FROM tokens_seen WHERE address = ?', (address,))
 existing = c.fetchone()
 if existing:
 # ：+1，
 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):
 """
 
 ：('musk_trump', matched_keywords) / ('binance_cz', matched_keywords) / ('novel', None) / ('common', None)
 """
 text = f"{name} {symbol}".lower()
 
 # 1. 
 for pat in SPAM_PATTERNS:
 if re.search(pat, text, re.IGNORECASE):
 return ('spam', None)
 
 # 2. /
 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:
 # /：ETH+SOL，BSC
 chain_lower = chain.lower()
 if chain_lower in ('eth', 'ethereum', 'sol', 'solana', 'bsc', 'base'):
 return ('musk_trump', matched_mt)
 
 # 3. /CZ — BSC
 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)
 
 # 4. /（★★）
 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)
 
 # 5. → 
 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, # 
 'honeypot': honeypot, 'mintable': mintable,
 'sell_tax': sell_tax, 'buy_tax': buy_tax
 }
 except:
 pass
 return {'safe': False, 'reason': ''} # ，

# ============================================================
# GMGN
# ============================================================
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):
 """/ — """
 desc = ''
 
 # SOL：Pump.fundescription
 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
 
 # ：DEXScreener info（+）
 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:
 # DEXScreenerdescription
 return {
 'description': desc,
 'twitter': twitter,
 'telegram': telegram,
 'website': website,
 }
 except:
 pass
 
 return {'description': desc, 'twitter': '', 'telegram': '', 'website': ''}

def fetch_new_tokens():
 """GMGN + """
 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():
 """
 FLAP — BSC
 ：（）
 ：24h，1h/，>，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
 
 # ：
 # 1: 24h（），
 # 2: 1h24h，
 # 3: > ，
 buy_ratio = buys / max(sells, 1)
 
 is_support = False
 reason = ''
 
 # A: 24h，1h/
 if chg_24h < -10 and chg_1h > chg_24h * 0.3:
 is_support = True
 reason = f'24h{chg_24h:.0f}%1h{chg_1h:+.0f}%'
 
 # B: 24h，1h，
 if -10 <= chg_24h <= 30 and chg_1h > -5 and buy_ratio > 1.1:
 is_support = True
 reason = f' {buy_ratio:.2f}'
 
 # C: 
 if chg_24h < -30 and chg_1h > 10:
 is_support = True
 reason = f'{chg_24h:.0f}%{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):
 """FLAP"""
 msg = f" — FLAP\n"
 msg += f": BSC | : 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" ${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 += "\nFLAP — "
 
 # 
 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" — /\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:
 # 200，
 if len(desc) > 200:
 desc = desc[:200] + '...'
 msg += f": {desc}\n\n"
 
 msg += f": {', '.join(matched_kw[:5])}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f" ${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):
 """/CZ"""
 msg = f" — /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": {', '.join(matched_kw[:5])}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f" ${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" — \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"{count} — \n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f" ${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
 
 # — （GMGN）
 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 # ，
 
 snapshots.append({
 'ts': now,
 'mc': mc,
 'vol': vol,
 'price': price,
 'buys': buys,
 })
 
 # 20（200）
 if len(snapshots) > 20:
 snapshots[:] = snapshots[-20:]
 
 # 3
 if len(snapshots) < MOMENTUM_CONSECUTIVE_UP:
 continue
 
 # N
 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
 if gain <= 0: # 
 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
 
 # ： + >5%
 if pct_gain < 5:
 continue
 
 # ：，+1
 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"/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 = "FLAP"
 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)
 
 # FLAP/CTO
 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) # 
 else:
 narrative_tag += " | "
 
 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]
 
 # — 1
 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"\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" ${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" — / ★★\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": {', '.join(matched_kw[:5])}\n\n"
 msg += f"```\n"
 msg += f" ${token['mc']:>12,.0f}\n"
 msg += f" ${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():
 """"""
 conn = init_db()
 tokens = fetch_new_tokens()
 
 log(f" {len(tokens)} ...")
 
 # === — ， ===
 # FLAP
 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']
 
 # — seen_countnarrativestoken_count，
 if is_token_seen(conn, addr):
 # seen_count
 c = conn.cursor()
 c.execute('UPDATE tokens_seen SET seen_count = seen_count + 1, market_cap = ? WHERE address = ?', (token['mc'], addr))
 # narrativestoken_count（）
 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) # TG
 
 return pushed, len(momentum_alerts)

# ============================================================
# 
# ============================================================
def main():
 log("=" * 50)
 log(" v1 ")
 log(f": {SCAN_INTERVAL}s")
 log(f": — ，")
 log("=" * 50)
 
 # DB
 init_db()
 
 # 
 tg_send(
 " v1 \n\n"
 ": \n"
 "3+>5%\n"
 ":\n"
 "★★★ / | /CZ | FLAP\n"
 "★★ | FLAP | \n"
 "★ \n\n"
 f": {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": {e}")
 
 time.sleep(SCAN_INTERVAL)

if __name__ == '__main__':
 main()