mev-bot-watcher 1.7.2__py3-none-any.whl

mev_bot_watcher/__main__.py

@@ -0,0 +1,3 @@
+from .main import cli
+
+cli()

mev_bot_watcher/coingecko_client.py

@@ -0,0 +1,119 @@
+import logging
+from typing import Optional, Dict, List, Iterable
+
+import aiohttp
+
+
+COINGECKO_BASE_URL = "https://api.coingecko.com/api/v3"
+
+# Оверрайды для популярных токенов. Нужны для разрешения неоднозначности
+# (у одного тикера может быть много coin id в CoinGecko). Покрывают как
+# нативные токены, так и распространённые стейблкоины (base_tokens).
+_KNOWN_IDS = {
+    # native
+    "eth": "ethereum",
+    "btc": "bitcoin",
+    "bnb": "binancecoin",
+    "matic": "matic-network",
+    "pol": "polygon-ecosystem-token",
+    "sol": "solana",
+    "avax": "avalanche-2",
+    "ftm": "fantom",
+    "trx": "tron",
+    "near": "near",
+    "ada": "cardano",
+    "dot": "polkadot",
+    "mon": "monad",
+    # stablecoins / common base tokens
+    "usdc": "usd-coin",
+    "usdt": "tether",
+    "usde": "ethena-usde",
+    "dai": "dai",
+    "usds": "usds",
+    "frax": "frax",
+    "tusd": "true-usd",
+    "busd": "binance-usd",
+    "usdc.e": "usd-coin",
+}
+
+
+class CoinGeckoClient:
+    """Клиент CoinGecko: резолвит coin id по тикеру и получает цены в USD."""
+
+    def __init__(self):
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._symbol_to_ids: Optional[Dict[str, List[str]]] = None
+
+    async def __aenter__(self):
+        self._session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._session:
+            await self._session.close()
+            self._session = None
+
+    async def _ensure_coins_list(self):
+        """Одноразовая загрузка списка монет CoinGecko с кешем на процесс."""
+        if self._symbol_to_ids is not None:
+            return
+        url = f"{COINGECKO_BASE_URL}/coins/list"
+        async with self._session.get(url) as resp:
+            coins = await resp.json()
+        mapping: Dict[str, List[str]] = {}
+        for coin in coins:
+            sym = (coin.get("symbol") or "").lower()
+            if not sym:
+                continue
+            mapping.setdefault(sym, []).append(coin["id"])
+        self._symbol_to_ids = mapping
+
+    async def resolve_id_by_symbol(self, symbol: str) -> Optional[str]:
+        """Подбор coingecko id по тикеру.
+
+        Для wrapped-обёрток (символ начинается с W) первым делом пробуем
+        нативный эквивалент: WETH->ETH, WMON->MON и т.д. — это корректно,
+        т.к. цены wrapped-токена и нативного равны по смыслу 1:1. Если
+        нативный не находится уверенно, падаем обратно к точному поиску
+        исходного символа.
+        """
+        await self._ensure_coins_list()
+        sym = symbol.lower()
+
+        if sym.startswith("w") and len(sym) > 1:
+            unwrapped = self._confident_lookup(sym[1:])
+            if unwrapped:
+                return unwrapped
+
+        return self._best_effort_lookup(sym)
+
+    def _confident_lookup(self, sym: str) -> Optional[str]:
+        """Возвращает id только если уверены: либо оверрайд, либо id == sym."""
+        if sym in _KNOWN_IDS:
+            return _KNOWN_IDS[sym]
+        for cid in self._symbol_to_ids.get(sym) or []:
+            if cid == sym:
+                return cid
+        return None
+
+    def _best_effort_lookup(self, sym: str) -> Optional[str]:
+        """Точное совпадение по тикеру, даже если однозначности нет."""
+        confident = self._confident_lookup(sym)
+        if confident:
+            return confident
+        candidates = self._symbol_to_ids.get(sym) or []
+        return candidates[0] if candidates else None
+
+    async def get_prices_usd(self, ids: Iterable[str]) -> Dict[str, float]:
+        """Получение цен сразу пачкой (CoinGecko поддерживает ids через запятую)."""
+        unique = sorted({cid for cid in ids if cid})
+        if not unique:
+            return {}
+        url = f"{COINGECKO_BASE_URL}/simple/price?ids={','.join(unique)}&vs_currencies=usd"
+        async with self._session.get(url) as resp:
+            data = await resp.json()
+        return {cid: payload["usd"] for cid, payload in data.items() if "usd" in payload}
+
+    async def get_price_usd(self, coingecko_id: str) -> Optional[float]:
+        prices = await self.get_prices_usd([coingecko_id])
+        return prices.get(coingecko_id)

mev_bot_watcher/eth_client.py

@@ -0,0 +1,116 @@
+from typing import Optional, List, Any, Dict
+
+import aiohttp
+
+
+def _decode_abi_string(hex_result: str) -> str:
+    """Декодирование строки из результата eth_call.
+
+    Поддерживает стандартные ABI dynamic string (offset+length+data),
+    а также контракты со старым ABI, возвращающие bytes32 (как MKR).
+    """
+    if hex_result.startswith('0x'):
+        hex_result = hex_result[2:]
+    if not hex_result:
+        return ''
+    # bytes32 fallback: длина данных ≤ 64 hex (32 байта)
+    if len(hex_result) < 128:
+        return bytes.fromhex(hex_result).rstrip(b'\x00').decode('utf-8', errors='replace')
+    length = int(hex_result[64:128], 16)
+    data = hex_result[128:128 + length * 2]
+    return bytes.fromhex(data).decode('utf-8', errors='replace')
+
+
+class EthClient:
+    """Класс для работы с Ethereum JSON-RPC API"""
+
+    def __init__(self, rpc_url: str):
+        self.rpc_url = rpc_url
+        self.session = None
+
+    async def __aenter__(self):
+        self.session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+
+    async def eth_call(self, method: str, params: Optional[List[Any]] = None) -> Any:
+        """Асинхронная функция для отправки запросов JSON-RPC"""
+        if params is None:
+            params = []
+
+        async with self.session.post(
+                self.rpc_url, json={'jsonrpc': '2.0', 'id': 1, 'method': method, 'params': params}
+        ) as response:
+            result = await response.json()
+            return result['result']
+
+    async def get_latest_block(self) -> int:
+        """Функция для получения последнего блока"""
+        block_number = await self.eth_call('eth_blockNumber')
+        return int(block_number, 16)
+
+    async def get_balance(self, address: str) -> int:
+        """Нативный баланс адреса в wei через eth_getBalance"""
+        result = await self.eth_call('eth_getBalance', [address, 'latest'])
+        return int(result, 16)
+
+    async def get_erc20_balance(self, token_address: str, holder_address: str) -> int:
+        """Баланс ERC20 токена на адресе через вызов balanceOf(address)"""
+        # function selector: keccak256("balanceOf(address)")[:4] = 0x70a08231
+        padded = holder_address.lower().removeprefix('0x').zfill(64)
+        data = '0x70a08231' + padded
+        result = await self.eth_call('eth_call', [{'to': token_address, 'data': data}, 'latest'])
+        if not result or result == '0x':
+            return 0
+        return int(result, 16)
+
+    async def get_block_with_transactions(self, block_number: int | str) -> Dict:
+        """Функция для получения блока с полными транзакциями"""
+        block = await self.eth_call('eth_getBlockByNumber',
+                                    [hex(block_number) if isinstance(block_number, int) else block_number, True])
+        return block
+
+    async def get_transaction_receipt(self, tx_hash: str) -> Dict:
+        """Функция для получения receipt о транзакции"""
+        receipt = await self.eth_call('eth_getTransactionReceipt', [tx_hash])
+        return receipt
+
+    async def get_transaction_by_hash(self, tx_hash: str) -> Dict:
+        """Функция для получения транзакции по хешу"""
+        transaction = await self.eth_call('eth_getTransactionByHash', [tx_hash])
+        return transaction
+    
+    async def get_logs(self, from_block: int, to_block: int, address: str, topics: list) -> list:
+        """Получение логов по фильтру"""
+        params = {
+            'fromBlock': hex(from_block),
+            'toBlock': hex(to_block),
+            'address': address,
+            'topics': topics,
+        }
+        return await self.eth_call('eth_getLogs', [params])
+
+    async def get_token_symbol(self, address: str) -> str:
+        """Получение символа ERC20 токена через RPC вызов symbol()"""
+        # function selector: keccak256("symbol()")[:4] = 0x95d89b41
+        result = await self.eth_call('eth_call', [{'to': address, 'data': '0x95d89b41'}, 'latest'])
+        return _decode_abi_string(result)
+
+    async def get_decimals(self, address: str) -> int:
+        """Количество знаков ERC20 токена через RPC вызов decimals().
+
+        Фоллбэк на 18, если контракт не отвечает (нестандартный токен).
+        """
+        # function selector: keccak256("decimals()")[:4] = 0x313ce567
+        result = await self.eth_call('eth_call', [{'to': address, 'data': '0x313ce567'}, 'latest'])
+        if not result or result == '0x':
+            return 18
+        return int(result, 16)
+
+    async def eth_getBlockReceipts(self, block_number: int | str) -> Dict:
+        """Функция для получения receipt о блоке"""
+        receipts = await self.eth_call('eth_getBlockReceipts', [hex(block_number) if isinstance(block_number, int) else block_number])
+        return receipts

mev_bot_watcher/log_progress.py

@@ -0,0 +1,56 @@
+import logging
+import time
+
+UPDATE_INTERVAL = 15
+
+
+def print_progress(tasks, total_tasks=0, update_interval=UPDATE_INTERVAL):
+    completed_tasks = 0
+    start_time = time.time()
+    last_update_time = start_time
+    total_tasks = total_tasks if total_tasks else len(tasks)
+
+    for future in tasks:
+        yield future
+        completed_tasks += 1
+        current_time = time.time()
+        if current_time - last_update_time >= update_interval:
+            calculate_progress(completed_tasks, current_time, start_time, total_tasks)
+            last_update_time = current_time
+
+
+def calculate_progress(completed_tasks, current_time, start_time, total_tasks):
+    progress_percentage = (completed_tasks / total_tasks) * 100
+    elapsed_time = current_time - start_time
+    avg_time_per_task = elapsed_time / completed_tasks if completed_tasks > 0 else 0
+    remaining_tasks = total_tasks - completed_tasks
+    estimated_remaining_time = avg_time_per_task * remaining_tasks
+    logging.info(
+        f"Progress: {completed_tasks}/{total_tasks} tasks completed "
+        f"({progress_percentage:.2f}%). "
+        f"Estimated remaining time: {estimated_remaining_time:.2f} seconds."
+    )
+
+
+def setup_logging():
+    class ColorFormatter(logging.Formatter):
+        COLORS = {
+            'DEBUG': '\033[96m',  # Cyan
+            'INFO': '\033[92m',  # Green
+            'WARNING': '\033[93m',  # Yellow
+            'ERROR': '\033[91m',  # Red
+            'CRITICAL': '\033[95m',  # Magenta
+        }
+        RESET = '\033[0m'
+
+        def format(self, record):
+            log_color = self.COLORS.get(record.levelname, self.RESET)
+            message = super().format(record)  # Используем стандартный форматтер
+            return f"{log_color}{message}{self.RESET}"
+
+    logger = logging.getLogger("")
+    handler = logging.StreamHandler()
+    handler.setFormatter(ColorFormatter())
+
+    logger.setLevel(logging.INFO)
+    logger.addHandler(handler)

mev_bot_watcher/main.py

@@ -0,0 +1,222 @@
+import logging
+import asyncio
+import yaml
+import click
+from typing import Dict, List, Optional
+
+from .tx_watcher import TxWatcher
+from .eth_client import EthClient
+from .coingecko_client import CoinGeckoClient
+from .log_progress import setup_logging
+from .telegram_notifier import BotInfo
+from .tx_analyzer import TxAnalyzer, TokenInfo
+from .ws_connector import WsConnectorRaw
+
+
+def load_config(config_path: str) -> Dict:
+    """Загрузка конфигурации из YAML файла"""
+    with open(config_path, 'r') as file:
+        return yaml.safe_load(file)
+
+
+def get_bot_config_by_name(config: Dict, bot_name: str) -> Optional[Dict]:
+    """Получение конфигурации бота по имени"""
+    if 'bots' not in config:
+        return None
+
+    for name, bot_config in config['bots'].items():
+        if name == bot_name:
+            return bot_config
+
+    return None
+
+
+def get_token_addresses(bot_config: Dict) -> tuple:
+    """Возвращает (wrapped_token, [base_tokens]) из конфигурации бота."""
+    wrapped = bot_config['wrapped_token'].lower()
+    base = [a.lower() for a in (bot_config.get('base_tokens') or [])]
+    return wrapped, base
+
+
+async def build_tokens(eth_client: EthClient, cg_client: CoinGeckoClient,
+                       wrapped: str, base: List[str]) -> List[TokenInfo]:
+    """Собирает список TokenInfo: wrapped (is_wrapped=True) + base_tokens."""
+    tokens = [await TokenInfo.from_rpc(eth_client, cg_client, wrapped, is_wrapped=True)]
+    for addr in base:
+        tokens.append(await TokenInfo.from_rpc(eth_client, cg_client, addr, is_wrapped=False))
+    return tokens
+
+
+def parse_ws_rpc(ws_rpc) -> tuple:
+    """Разбирает ws_rpc_url как строку или dict с login/password.
+
+    Returns (url, login, password). login/password = None если не заданы.
+    """
+    if ws_rpc is None:
+        return None, None, None
+    if isinstance(ws_rpc, str):
+        return ws_rpc, None, None
+    if isinstance(ws_rpc, dict):
+        return ws_rpc.get('url'), ws_rpc.get('login'), ws_rpc.get('password')
+    raise ValueError(f"ws_rpc_url must be string or dict, got {type(ws_rpc).__name__}")
+
+
+@click.group()
+def cli():
+    """Утилита для анализа и мониторинга Ethereum транзакций"""
+    setup_logging()
+
+
+@cli.command()
+@click.option('--config', '-c', required=True, type=click.Path(exists=True), default='config.yaml', help='Путь к файлу конфигурации')
+@click.option('--bot-name', '-b', required=True, type=str, help='Имя бота в конфигурации')
+@click.option('--start-block', '-s', type=int, help='Номер блока, с которого начать анализ (до последнего блока)')
+@click.option('--block', '-n', 'block', type=int, help='Номер одиночного блока для отладочного прогона')
+def analyze(config: str, bot_name: str, start_block: Optional[int], block: Optional[int]):
+    """Режим анализа: диапазон от start-block или одиночный блок через функции подсчёта"""
+
+    if (start_block is None) == (block is None):
+        raise click.UsageError("Specify exactly one of --start-block / --block")
+
+    # Загружаем конфигурацию
+    full_config = load_config(config)
+
+    # Получаем конфигурацию указанного бота
+    bot_config = get_bot_config_by_name(full_config, bot_name)
+
+    if not bot_config:
+        available_bots = ", ".join(full_config['bots'].keys())
+        logging.error(f"Bot '{bot_name}' not found in config. Available bots: {available_bots}")
+        return
+
+    # Извлекаем настройки для указанного бота
+    wrapped, base = get_token_addresses(bot_config)
+    watched_address = bot_config['watched_address'].lower()
+    http_rpc_url = bot_config['http_rpc_url']
+
+    logging.info(f"Starting analysis for bot '{bot_name}':")
+    logging.info(f"Wrapped token: {wrapped}")
+    logging.info(f"Base tokens: {base}")
+    logging.info(f"Watched address: {watched_address}")
+    if start_block is not None:
+        logging.info(f"Starting from block: {start_block}")
+    else:
+        logging.info(f"Single block: {block}")
+
+    # Запускаем анализ
+    async def run_analysis():
+        async with EthClient(http_rpc_url) as eth_client, CoinGeckoClient() as cg_client:
+            tokens = await build_tokens(eth_client, cg_client, wrapped, base)
+            for t in tokens:
+                logging.info(f"Token {t.symbol} ({t.address}) decimals={t.decimals} "
+                             f"coingecko_id={t.coingecko_id}")
+            analyzer = TxAnalyzer(eth_client, tokens, watched_address, cg_client=cg_client)
+            if start_block is not None:
+                await analyzer.analyze_from_block(start_block)
+            else:
+                await analyzer.analyze_single_block(block)
+
+    asyncio.run(run_analysis())
+
+
+@cli.command()
+@click.option('--config', '-c', required=True, type=click.Path(exists=True), default='config.yaml', help='Путь к файлу конфигурации')
+@click.option('--bot-name', '-b', type=str, help='Имя конкретного бота (если не указано, мониторятся все боты)')
+def monitor(config: str, bot_name: Optional[str] = None):
+    """Режим мониторинга: постоянно отслеживать новые транзакции для всех или указанного бота"""
+
+    full_config = load_config(config)
+
+    if bot_name:
+        # Мониторинг только одного бота
+        bot_config = get_bot_config_by_name(full_config, bot_name)
+        if not bot_config:
+            available_bots = ", ".join(full_config['bots'].keys())
+            logging.error(f"Bot '{bot_name}' not found in config. Available bots: {available_bots}")
+            return
+        bots_to_monitor = {bot_name: bot_config}
+    else:
+        # Мониторинг всех ботов
+        bots_to_monitor = full_config['bots']
+
+    logging.info(f"Starting monitoring for {len(bots_to_monitor)} bots")
+
+    telegram_config = full_config.get('telegram')
+
+    async def run_monitoring():
+        cg_client = CoinGeckoClient()
+        await cg_client.__aenter__()
+
+        # Настройка Telegram уведомлений
+        notifier = None
+        if telegram_config and telegram_config.get('bot_token'):
+            from telegram_notifier import TelegramNotifier
+            schedule = telegram_config.get('notify_schedule', '0 * * * *')
+            notifier = TelegramNotifier(
+                bot_token=telegram_config['bot_token'],
+                chat_id=str(telegram_config['chat_id']),
+                notify_schedule=schedule,
+                cg_client=cg_client,
+            )
+            logging.info(f"Telegram notifications enabled (schedule: {schedule})")
+
+        tasks = []
+        eth_clients = []
+        ws_connectors = []
+
+        for name, bot_cfg in bots_to_monitor.items():
+            wrapped, base = get_token_addresses(bot_cfg)
+            watched_address = bot_cfg['watched_address'].lower()
+            scanner_url = bot_cfg.get('scanner_url')
+            loss_alert_usd = bot_cfg.get('loss_alert_usd')
+            ws_url, ws_login, ws_password = parse_ws_rpc(bot_cfg.get('ws_rpc_url'))
+            http_rpc_url = bot_cfg.get('http_rpc_url')
+
+            logging.info(f"Setting up monitoring for bot '{name}':")
+            logging.info(f"Wrapped token: {wrapped}")
+            logging.info(f"Base tokens: {base}")
+            logging.info(f"Watched address: {watched_address}")
+
+            ws = WsConnectorRaw(ws_url, login=ws_login, password=ws_password, name=name)
+            ws_connectors.append(ws)
+            eth_client = EthClient(http_rpc_url)
+            await eth_client.__aenter__()
+            eth_clients.append(eth_client)
+
+            tokens = await build_tokens(eth_client, cg_client, wrapped, base)
+            bot_info = await BotInfo.from_rpc(eth_client, name, watched_address, tokens,
+                                              scanner_url=scanner_url,
+                                              loss_alert_usd=loss_alert_usd)
+            if loss_alert_usd is not None:
+                logging.info(f"Instant loss alerts enabled (threshold: ${loss_alert_usd})")
+
+            if notifier:
+                notifier.register_bot(bot_info)
+
+            watcher = TxWatcher(eth_client, tokens, watched_address,
+                                bot_name=name, notifier=notifier)
+            await watcher.subscribe(ws)
+            tasks.append(ws.run())
+
+        if notifier:
+            async def send_startup_after_connect():
+                await asyncio.gather(*(ws.ready.wait() for ws in ws_connectors))
+                await notifier.send_startup_message()
+
+            tasks.append(send_startup_after_connect())
+            tasks.append(notifier.run_periodic_flush())
+
+        try:
+            await asyncio.gather(*tasks)
+        finally:
+            if notifier:
+                await notifier.force_flush()
+            for client in eth_clients:
+                await client.__aexit__(None, None, None)
+            await cg_client.__aexit__(None, None, None)
+
+    asyncio.run(run_monitoring())
+
+
+if __name__ == "__main__":
+    cli()