@intentsolutionsio/mempool-analyzer 1.0.0

package/skills/analyzing-mempool/scripts/mev_detector.py

@@ -0,0 +1,387 @@
+#!/usr/bin/env python3
+"""
+MEV Opportunity Detector
+
+Detect potential MEV opportunities in pending transactions.
+
+Author: Jeremy Longshore <jeremy@intentsolutions.io>
+Version: 1.0.0
+License: MIT
+"""
+
+import os
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+from tx_decoder import TransactionDecoder
+
+
+@dataclass
+class MEVOpportunity:
+    """Detected MEV opportunity."""
+    opportunity_type: str  # sandwich, arbitrage, liquidation, backrun
+    target_tx: str  # Target transaction hash
+    estimated_profit_usd: float
+    required_capital_usd: float
+    risk_level: str  # low, medium, high
+    confidence: float  # 0.0 to 1.0
+    details: Dict[str, Any]
+
+
+@dataclass
+class PendingSwap:
+    """Detected pending swap transaction."""
+    tx_hash: str
+    dex: str
+    amount_in: Optional[int]
+    amount_out_min: Optional[int]
+    gas_price: int
+    from_address: str
+
+
+class MEVDetector:
+    """Detect MEV opportunities in pending transactions."""
+
+    # Default thresholds (can be overridden via config)
+    DEFAULT_MIN_SWAP_VALUE_USD = 10000  # $10k minimum swap
+    DEFAULT_MIN_PROFIT_USD = 100  # $100 minimum profit
+
+    def __init__(
+        self,
+        verbose: bool = False,
+        min_swap_value_usd: Optional[float] = None,
+        min_profit_usd: Optional[float] = None,
+        config_path: Optional[str] = None,
+    ):
+        """Initialize MEV detector.
+
+        Args:
+            verbose: Enable verbose output
+            min_swap_value_usd: Minimum swap value for detection (overrides config)
+            min_profit_usd: Minimum profit for detection (overrides config)
+            config_path: Path to settings.yaml config file
+        """
+        self.verbose = verbose
+        self.decoder = TransactionDecoder(verbose=verbose)
+
+        # Load config if available
+        config = self._load_config(config_path)
+
+        # Set thresholds with priority: explicit arg > config > default
+        config_mev = config.get("mev", {}) if config else {}
+        self.min_swap_value_usd = (
+            min_swap_value_usd
+            if min_swap_value_usd is not None
+            else config_mev.get("min_swap_value_usd", self.DEFAULT_MIN_SWAP_VALUE_USD)
+        )
+        self.min_profit_usd = (
+            min_profit_usd
+            if min_profit_usd is not None
+            else config_mev.get("min_profit_usd", self.DEFAULT_MIN_PROFIT_USD)
+        )
+
+    def _load_config(self, config_path: Optional[str] = None) -> Optional[Dict]:
+        """Load configuration from YAML file.
+
+        Args:
+            config_path: Explicit path to config, or None to use defaults
+
+        Returns:
+            Config dict or None if not found/loaded
+        """
+        if not HAS_YAML:
+            return None
+
+        # Search paths for config
+        search_paths = []
+        if config_path:
+            search_paths.append(config_path)
+
+        # Default locations
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        search_paths.extend([
+            os.path.join(script_dir, "..", "config", "settings.yaml"),
+            os.path.expanduser("~/.mempool_analyzer.yaml"),
+        ])
+
+        for path in search_paths:
+            if os.path.exists(path):
+                try:
+                    with open(path) as f:
+                        return yaml.safe_load(f)
+                except Exception as e:
+                    if self.verbose:
+                        print(f"Warning: Could not load config from {path}: {e}")
+
+        return None
+
+    def detect_pending_swaps(
+        self,
+        pending_txs: List[Any],
+        eth_price: float = 3000.0
+    ) -> List[PendingSwap]:
+        """Identify pending swap transactions.
+
+        Args:
+            pending_txs: List of pending transactions
+            eth_price: Current ETH price for USD estimation
+
+        Returns:
+            List of detected pending swaps
+        """
+        swaps = []
+
+        for tx in pending_txs:
+            # Get transaction fields
+            if hasattr(tx, "input_data"):
+                input_data = tx.input_data
+                to_address = tx.to_address
+                tx_hash = tx.hash
+                gas_price = tx.gas_price
+                from_address = tx.from_address
+            else:
+                input_data = tx.get("input", "")
+                to_address = tx.get("to", "")
+                tx_hash = tx.get("hash", "")
+                gas_price = tx.get("gasPrice", 0)
+                from_address = tx.get("from", "")
+                if isinstance(gas_price, str):
+                    gas_price = int(gas_price, 16)
+
+            # Try to identify as swap
+            swap_info = self.decoder.identify_dex_swap(input_data, to_address)
+            if swap_info:
+                swaps.append(PendingSwap(
+                    tx_hash=tx_hash,
+                    dex=swap_info.dex,
+                    amount_in=swap_info.amount_in,
+                    amount_out_min=swap_info.amount_out_min,
+                    gas_price=gas_price,
+                    from_address=from_address,
+                ))
+
+        return swaps
+
+    def detect_sandwich_opportunities(
+        self,
+        pending_swaps: List[PendingSwap],
+        eth_price: float = 3000.0
+    ) -> List[MEVOpportunity]:
+        """Detect potential sandwich attack opportunities.
+
+        Sandwich: Front-run a large swap, then back-run after price moves.
+
+        Args:
+            pending_swaps: List of detected pending swaps
+            eth_price: Current ETH price
+
+        Returns:
+            List of potential sandwich opportunities
+        """
+        opportunities = []
+
+        for swap in pending_swaps:
+            # Skip small swaps
+            if not swap.amount_in:
+                continue
+
+            # Estimate swap value (simplified - assumes ETH value)
+            value_eth = swap.amount_in / 10**18
+            value_usd = value_eth * eth_price
+
+            if value_usd < self.min_swap_value_usd:
+                continue
+
+            # Estimate potential profit (very simplified)
+            # Real sandwich profit depends on pool liquidity, slippage, etc.
+            estimated_slippage = min(value_usd / 1000000, 0.05)  # Up to 5% for large swaps
+            estimated_profit = value_usd * estimated_slippage * 0.3  # Capture 30% of slippage
+
+            if estimated_profit < self.min_profit_usd:
+                continue
+
+            opportunities.append(MEVOpportunity(
+                opportunity_type="sandwich",
+                target_tx=swap.tx_hash,
+                estimated_profit_usd=estimated_profit,
+                required_capital_usd=value_usd * 0.5,  # Need capital to front-run
+                risk_level="high",  # Sandwiches are risky
+                confidence=0.3,  # Low confidence without pool analysis
+                details={
+                    "dex": swap.dex,
+                    "swap_value_usd": value_usd,
+                    "target_slippage": estimated_slippage,
+                    "gas_price_gwei": swap.gas_price / 10**9,
+                },
+            ))
+
+        return opportunities
+
+    def detect_arbitrage_opportunities(
+        self,
+        pending_swaps: List[PendingSwap],
+        pool_prices: Dict[str, float] = None
+    ) -> List[MEVOpportunity]:
+        """Detect arbitrage opportunities from pending swaps.
+
+        Args:
+            pending_swaps: List of detected pending swaps
+            pool_prices: Optional pool price data for comparison
+
+        Returns:
+            List of potential arbitrage opportunities
+        """
+        # Simplified detection - would need real pool data
+        opportunities = []
+
+        # Group swaps by apparent token pair
+        # In real implementation, would decode full path and check pool prices
+
+        for swap in pending_swaps:
+            if not swap.amount_in or swap.amount_in < 10**18:
+                continue
+
+            # Mock arbitrage detection (placeholder)
+            # Real implementation would:
+            # 1. Decode swap path
+            # 2. Check prices on other DEXes
+            # 3. Calculate if price difference creates opportunity
+
+            if self.verbose:
+                print(f"Checking arb opportunity for {swap.tx_hash[:16]}...")
+
+        return opportunities
+
+    def detect_liquidation_opportunities(
+        self,
+        pending_txs: List[Any]
+    ) -> List[MEVOpportunity]:
+        """Detect pending liquidation opportunities.
+
+        Args:
+            pending_txs: List of pending transactions
+
+        Returns:
+            List of potential liquidation opportunities
+        """
+        opportunities = []
+
+        # Look for lending protocol interactions that might indicate
+        # underwater positions or pending liquidations
+
+        # This would require:
+        # 1. Monitoring Aave/Compound/etc health factors
+        # 2. Detecting position updates that lower health
+        # 3. Calculating profitability of liquidation
+
+        # Placeholder - real implementation is complex
+
+        return opportunities
+
+    def detect_all_opportunities(
+        self,
+        pending_txs: List[Any],
+        eth_price: float = 3000.0
+    ) -> Dict[str, List[MEVOpportunity]]:
+        """Run all MEV detection algorithms.
+
+        Args:
+            pending_txs: List of pending transactions
+            eth_price: Current ETH price
+
+        Returns:
+            Dict mapping opportunity type to list of opportunities
+        """
+        # First, identify swaps
+        swaps = self.detect_pending_swaps(pending_txs, eth_price)
+
+        results = {
+            "pending_swaps": len(swaps),
+            "sandwich": self.detect_sandwich_opportunities(swaps, eth_price),
+            "arbitrage": self.detect_arbitrage_opportunities(swaps),
+            "liquidation": self.detect_liquidation_opportunities(pending_txs),
+        }
+
+        return results
+
+    def format_opportunities(
+        self,
+        opportunities: List[MEVOpportunity]
+    ) -> str:
+        """Format opportunities for display.
+
+        Args:
+            opportunities: List of MEV opportunities
+
+        Returns:
+            Formatted string
+        """
+        if not opportunities:
+            return "No MEV opportunities detected."
+
+        lines = [
+            "",
+            "MEV OPPORTUNITIES DETECTED",
+            "=" * 80,
+            f"{'Type':<12} {'Est. Profit':<14} {'Capital Req':<14} {'Risk':<10} {'Confidence':<12}",
+            "-" * 80,
+        ]
+
+        for opp in sorted(opportunities, key=lambda x: x.estimated_profit_usd, reverse=True):
+            lines.append(
+                f"{opp.opportunity_type:<12} "
+                f"${opp.estimated_profit_usd:>11,.0f} "
+                f"${opp.required_capital_usd:>11,.0f} "
+                f"{opp.risk_level:<10} "
+                f"{opp.confidence * 100:>10.0f}%"
+            )
+
+        lines.append("-" * 80)
+        lines.append(f"Total: {len(opportunities)} potential opportunities")
+        lines.append("")
+        lines.append("⚠️  WARNING: MEV detection is for educational purposes only.")
+        lines.append("    Actual profitability requires real-time pool data and")
+        lines.append("    sophisticated execution infrastructure.")
+
+        return "\n".join(lines)
+
+
+def main():
+    """CLI entry point for testing."""
+    detector = MEVDetector(verbose=True)
+
+    # Create mock pending transactions
+    class MockTx:
+        def __init__(self, value, gas_price):
+            import random
+            self.hash = f"0x{''.join(random.choices('0123456789abcdef', k=64))}"
+            self.from_address = f"0x{''.join(random.choices('0123456789abcdef', k=40))}"
+            self.to_address = "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"
+            self.value = value
+            self.gas_price = gas_price
+            self.input_data = "0x38ed1739" + "0" * 256
+
+    import random
+    mock_txs = [
+        MockTx(random.randint(1, 100) * 10**18, (30 + random.randint(0, 20)) * 10**9)
+        for _ in range(20)
+    ]
+
+    # Detect
+    print("=== Scanning for Pending Swaps ===")
+    swaps = detector.detect_pending_swaps(mock_txs)
+    print(f"Found {len(swaps)} pending swaps")
+
+    print("\n=== Checking for MEV Opportunities ===")
+    opportunities = detector.detect_sandwich_opportunities(swaps)
+    print(detector.format_opportunities(opportunities))
+
+
+if __name__ == "__main__":
+    main()

package/skills/analyzing-mempool/scripts/rpc_client.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Ethereum RPC Client
+
+Connect to Ethereum nodes and fetch mempool data.
+
+Author: Jeremy Longshore <jeremy@intentsolutions.io>
+Version: 1.0.0
+License: MIT
+"""
+
+import os
+import sys
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+
+# Default RPC endpoints (public, may be rate limited)
+DEFAULT_RPC_URLS = {
+    "ethereum": "https://eth.llamarpc.com",
+    "polygon": "https://polygon-rpc.com",
+    "arbitrum": "https://arb1.arbitrum.io/rpc",
+    "optimism": "https://mainnet.optimism.io",
+    "base": "https://mainnet.base.org",
+}
+
+
+@dataclass
+class PendingTransaction:
+    """Represents a pending transaction in the mempool."""
+    hash: str
+    from_address: str
+    to_address: Optional[str]
+    value: int  # in wei
+    gas: int
+    gas_price: int  # in wei
+    max_fee_per_gas: Optional[int]
+    max_priority_fee_per_gas: Optional[int]
+    nonce: int
+    input_data: str
+    block_number: Optional[int]
+
+
+@dataclass
+class GasInfo:
+    """Current gas price information."""
+    base_fee: int
+    priority_fee: int
+    gas_price: int  # legacy
+    pending_count: int
+
+
+class RPCClient:
+    """Ethereum JSON-RPC client for mempool access."""
+
+    def __init__(
+        self,
+        rpc_url: str = None,
+        chain: str = "ethereum",
+        verbose: bool = False
+    ):
+        """Initialize RPC client.
+
+        Args:
+            rpc_url: Custom RPC URL or None for default
+            chain: Chain name for default URL lookup
+            verbose: Enable verbose output
+        """
+        self.rpc_url = rpc_url or os.environ.get("ETH_RPC_URL") or DEFAULT_RPC_URLS.get(chain)
+        self.chain = chain
+        self.verbose = verbose
+        self._request_id = 0
+
+    def _rpc_call(self, method: str, params: List = None) -> Any:
+        """Make JSON-RPC call."""
+        if not requests:
+            raise ImportError("requests library required: pip install requests")
+
+        self._request_id += 1
+        payload = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params or [],
+            "id": self._request_id,
+        }
+
+        if self.verbose:
+            print(f"RPC: {method}")
+
+        response = requests.post(
+            self.rpc_url,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        result = response.json()
+        if "error" in result:
+            raise Exception(f"RPC error: {result['error']}")
+
+        return result.get("result")
+
+    def get_pending_transactions(self, limit: int = 100, allow_mock: bool = False) -> List[PendingTransaction]:
+        """Get pending transactions from mempool.
+
+        Note: Not all nodes support txpool_content.
+
+        Args:
+            limit: Maximum transactions to return
+            allow_mock: If True, return mock data when RPC fails (for demo/testing)
+
+        Returns:
+            List of pending transactions
+
+        Raises:
+            RuntimeError: If no RPC method succeeds and allow_mock is False
+        """
+        errors = []
+
+        try:
+            # Try txpool_content (Geth nodes)
+            result = self._rpc_call("txpool_content")
+            if result:
+                return self._parse_txpool_content(result, limit)
+        except Exception as e:
+            errors.append(f"txpool_content: {e}")
+            if self.verbose:
+                print(f"txpool_content not available: {e}", file=sys.stderr)
+
+        try:
+            # Try eth_pendingTransactions (some nodes)
+            result = self._rpc_call("eth_pendingTransactions")
+            if result:
+                return self._parse_pending_transactions(result[:limit])
+        except Exception as e:
+            errors.append(f"eth_pendingTransactions: {e}")
+            if self.verbose:
+                print(f"eth_pendingTransactions not available: {e}", file=sys.stderr)
+
+        # If allow_mock is True (demo mode), return mock data with warning
+        if allow_mock:
+            print("WARNING: Using mock data - could not fetch real mempool data", file=sys.stderr)
+            return self._get_mock_pending_transactions(limit)
+
+        # Otherwise raise an exception
+        raise RuntimeError(
+            f"Could not fetch pending transactions from RPC. "
+            f"Both 'txpool_content' and 'eth_pendingTransactions' failed.\n"
+            f"Errors: {'; '.join(errors)}\n"
+            f"Hint: Use --demo flag to use mock data for testing."
+        )
+
+    def _parse_txpool_content(self, content: Dict, limit: int) -> List[PendingTransaction]:
+        """Parse txpool_content response."""
+        transactions = []
+
+        for pool in ["pending", "queued"]:
+            pool_data = content.get(pool, {})
+            for address, nonces in pool_data.items():
+                for nonce, tx in nonces.items():
+                    if len(transactions) >= limit:
+                        break
+                    transactions.append(self._tx_to_pending(tx))
+
+        return transactions[:limit]
+
+    def _parse_pending_transactions(self, txs: List[Dict]) -> List[PendingTransaction]:
+        """Parse eth_pendingTransactions response."""
+        return [self._tx_to_pending(tx) for tx in txs]
+
+    def _tx_to_pending(self, tx: Dict) -> PendingTransaction:
+        """Convert raw tx dict to PendingTransaction."""
+        return PendingTransaction(
+            hash=tx.get("hash", ""),
+            from_address=tx.get("from", ""),
+            to_address=tx.get("to"),
+            value=int(tx.get("value", "0x0"), 16),
+            gas=int(tx.get("gas", "0x0"), 16),
+            gas_price=int(tx.get("gasPrice", "0x0"), 16),
+            max_fee_per_gas=int(tx.get("maxFeePerGas", "0x0"), 16) if tx.get("maxFeePerGas") else None,
+            max_priority_fee_per_gas=int(tx.get("maxPriorityFeePerGas", "0x0"), 16) if tx.get("maxPriorityFeePerGas") else None,
+            nonce=int(tx.get("nonce", "0x0"), 16),
+            input_data=tx.get("input", "0x"),
+            block_number=int(tx.get("blockNumber", "0x0"), 16) if tx.get("blockNumber") else None,
+        )
+
+    def _get_mock_pending_transactions(self, limit: int) -> List[PendingTransaction]:
+        """Generate mock pending transactions for demo."""
+        import random
+
+        mock_txs = []
+        base_gas_price = 30 * 10**9  # 30 gwei
+
+        # Common router addresses
+        routers = [
+            "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",  # Uniswap V2
+            "0xE592427A0AEce92De3Edee1F18E0157C05861564",  # Uniswap V3
+            "0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F",  # SushiSwap
+        ]
+
+        # Sample swap input data prefix
+        swap_input = "0x38ed1739"  # swapExactTokensForTokens
+
+        for i in range(min(limit, 20)):
+            gas_price = base_gas_price + random.randint(-5, 20) * 10**9
+            mock_txs.append(PendingTransaction(
+                hash=f"0x{''.join(random.choices('0123456789abcdef', k=64))}",
+                from_address=f"0x{''.join(random.choices('0123456789abcdef', k=40))}",
+                to_address=random.choice(routers),
+                value=random.randint(0, 10) * 10**18,
+                gas=random.randint(100000, 500000),
+                gas_price=gas_price,
+                max_fee_per_gas=gas_price + 5 * 10**9,
+                max_priority_fee_per_gas=2 * 10**9,
+                nonce=random.randint(1, 1000),
+                input_data=swap_input + "0" * 128,
+                block_number=None,
+            ))
+
+        return mock_txs
+
+    def get_gas_price(self) -> GasInfo:
+        """Get current gas price information.
+
+        Returns:
+            GasInfo with current gas prices
+        """
+        try:
+            # Get base fee from latest block
+            block = self._rpc_call("eth_getBlockByNumber", ["latest", False])
+            base_fee = int(block.get("baseFeePerGas", "0x0"), 16)
+
+            # Get legacy gas price
+            gas_price = int(self._rpc_call("eth_gasPrice"), 16)
+
+            # Estimate priority fee
+            priority_fee = max(gas_price - base_fee, 1 * 10**9)
+
+            # Get pending tx count (optional - not all nodes support txpool_status)
+            pending_count = 0
+            try:
+                txpool_status = self._rpc_call("txpool_status")
+                pending_count = int(txpool_status.get("pending", "0x0"), 16)
+            except Exception:
+                # txpool_status not supported by this node - use 0 as fallback
+                pass
+
+            return GasInfo(
+                base_fee=base_fee,
+                priority_fee=priority_fee,
+                gas_price=gas_price,
+                pending_count=pending_count,
+            )
+
+        except Exception as e:
+            if self.verbose:
+                print(f"Error getting gas price: {e}")
+            # Return reasonable defaults
+            return GasInfo(
+                base_fee=30 * 10**9,
+                priority_fee=2 * 10**9,
+                gas_price=32 * 10**9,
+                pending_count=0,
+            )
+
+    def get_transaction(self, tx_hash: str) -> Optional[Dict]:
+        """Get transaction by hash.
+
+        Args:
+            tx_hash: Transaction hash
+
+        Returns:
+            Transaction dict or None
+        """
+        try:
+            return self._rpc_call("eth_getTransactionByHash", [tx_hash])
+        except Exception:
+            # Transaction not found or RPC error - return None
+            return None
+
+    def get_block_number(self) -> int:
+        """Get current block number."""
+        result = self._rpc_call("eth_blockNumber")
+        return int(result, 16)
+
+
+def main():
+    """CLI entry point for testing."""
+    client = RPCClient(verbose=True)
+
+    print("=== Current Gas Prices ===")
+    gas = client.get_gas_price()
+    print(f"Base Fee: {gas.base_fee / 10**9:.2f} gwei")
+    print(f"Priority Fee: {gas.priority_fee / 10**9:.2f} gwei")
+    print(f"Gas Price: {gas.gas_price / 10**9:.2f} gwei")
+    print(f"Pending Txs: {gas.pending_count}")
+
+    print("\n=== Pending Transactions ===")
+    pending = client.get_pending_transactions(limit=5)
+    for tx in pending:
+        print(f"  {tx.hash[:16]}... | {tx.gas_price / 10**9:.1f} gwei | {tx.gas} gas")
+
+
+if __name__ == "__main__":
+    main()