Skip to content

jeremylongshore/tons-of-skills-marketplace / plugins/crypto/mempool-analyzer/skills/analyzing-mempool

analyzing-mempool

Verified

Monitor blockchain mempools for pending transactions, gas analysis, and MEV opportunities. Use when analyzing pending transactions, optimizing gas prices, or researching MEV. Trigger with phrases like "check mempool", "scan pending txs", "find MEV", "gas price analysis", or "pending swaps".

FileKindSize
ARD.mdmarkdown4.3 KB
PRD.mdmarkdown2.9 KB
SKILL.mdskill md3.7 KB
config/settings.yamlconfig1004 B
references/errors.mdmarkdown2.6 KB
references/examples.mdmarkdown3.7 KB
references/implementation.mdmarkdown2.2 KB
scripts/formatters.pyscript6.5 KB
scripts/gas_analyzer.pyscript8.7 KB
scripts/mempool_analyzer.pyscript9.9 KB
scripts/mev_detector.pyscript12.2 KB
scripts/rpc_client.pyscript10.2 KB
scripts/tx_decoder.pyscript9.2 KB

scripts/mev_detector.py

View on GitHub
#!/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()
add-product-e2e-evalpaperclipai/paperclipAdd or extend a Paperclip full-stack runner E2E workflow, fixture, matcher, or report evidence path for local or Daytona execution.Stars: 115kUpdated Claude CodeCodexVerifiedInstall
add-runner-evalpaperclipai/paperclipAdd or extend a Paperclip Runner protocol evaluation definition, roster, assertion, or report fixture with provenance and narrow validation.Stars: 115kUpdated Claude CodeCodexVerifiedInstall
diagnose-why-work-stoppedpaperclipai/paperclipCompatibility entry point for failed, stalled, looping, or over-recovered Paperclip work. Use fix-failed-paperclip-run for the full diagnosis, regression, repair, real verification, and green-PR workflow; honor an explicitly requested diagnosis-only scope.Stars: 115kUpdated Claude CodeCodexVerifiedInstall
fix-failed-paperclip-runpaperclipai/paperclipDiagnose and fix failed, stuck, slow, or incorrectly blocked Paperclip tasks and runs. Use with a task/run URL or failure report to trace the root cause, prove a regression red then green, check second-order effects, verify the real workflow, and deliver a PR with passing checks.Stars: 115kUpdated Claude CodeCodexVerifiedInstall