Analyzing Liquidity Pools

# Liquidity Pool Analyzer Configuration
# Version: 2.0.0

# API Configuration
api:
  # The Graph Subgraphs
  subgraphs:
    uniswap-v3-ethereum: "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3"
    uniswap-v3-arbitrum: "https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-arbitrum"
    uniswap-v3-polygon: "https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-polygon"
    uniswap-v2-ethereum: "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2"
    curve-ethereum: "https://api.thegraph.com/subgraphs/name/curvefi/curve"
    balancer-v2: "https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-v2"

  # DeFiLlama (fallback)
  defillama:
    pools_url: "https://yields.llama.fi/pools"
    timeout: 30

  # CoinGecko (token prices)
  coingecko:
    base_url: "https://api.coingecko.com/api/v3"
    timeout: 15
    rate_limit: 30  # requests per minute

# Cache Configuration
cache:
  enabled: true
  file: "~/.lp_analyzer_cache.json"
  ttl:
    pools: 300       # 5 minutes
    prices: 60       # 1 minute
    metadata: 3600   # 1 hour

# Default Settings
defaults:
  chain: "ethereum"
  protocol: "uniswap-v3"
  top: 10
  min_tvl: 0
  format: "table"

# Fee Tiers (common configurations)
fee_tiers:
  uniswap_v3:
    - 0.0001  # 0.01%
    - 0.0005  # 0.05%
    - 0.003   # 0.30%
    - 0.01    # 1.00%
  curve:
    - 0.0004  # 0.04%
  balancer:
    - 0.0001
    - 0.001
    - 0.003

# Health Indicator Thresholds
health:
  tvl:
    large: 100000000    # $100M+
    medium: 10000000    # $10M+
    small: 1000000      # $1M+
    micro: 0            # <$1M

  volume_tvl_ratio:
    very_high: 0.5
    high: 0.1
    medium: 0.05
    low: 0.01

  fee_apr:
    high: 20
    medium: 5
    low: 1

# IL Warning Thresholds
il:
  warning_threshold: 5     # Warn if IL > 5%
  critical_threshold: 10   # Critical if IL > 10%

# Supported Chains
chains:
  - ethereum
  - arbitrum
  - polygon
  - optimism
  - bsc
  - avalanche
  - base

# Supported Protocols
protocols:
  - uniswap-v2
  - uniswap-v3
  - sushiswap
  - curve
  - balancer
  - pancakeswap
  - quickswap

# Logging
logging:
  verbose: false
  log_file: null
  log_level: "INFO"

#!/usr/bin/env python3
"""
Pool Formatters

Formats pool analysis output.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""

import json
import csv
import io
from datetime import datetime
from typing import Dict, Any, List


class PoolFormatter:
    """Formats pool analysis for display."""

    def __init__(self):
        """Initialize formatter."""
        self.timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")

    def format(
        self,
        data: Any,
        format_type: str = "table",
        detailed: bool = False
    ) -> str:
        """Format data for output.

        Args:
            data: Pool or list of pools
            format_type: Output format (table, json, csv)
            detailed: Show detailed breakdown

        Returns:
            Formatted string
        """
        if format_type == "json":
            return self._format_json(data)
        elif format_type == "csv":
            return self._format_csv(data)
        else:
            if isinstance(data, list):
                return self._format_pool_list(data, detailed)
            else:
                return self._format_single_pool(data, detailed)

    def _format_single_pool(
        self,
        pool: Dict[str, Any],
        detailed: bool = False
    ) -> str:
        """Format a single pool analysis.

        Args:
            pool: Pool data
            detailed: Show detailed breakdown

        Returns:
            Formatted string
        """
        lines = []
        metrics = pool.get("metrics", {})

        # Header
        lines.append("=" * 78)
        lines.append(f"  LIQUIDITY POOL ANALYZER{' ' * 31}{self.timestamp}")
        lines.append("=" * 78)
        lines.append("")

        # Pool info
        protocol = pool.get("project", "Unknown")
        symbol = pool.get("symbol", "?")
        chain = pool.get("chain", "?")
        fee_tier = metrics.get("fee_tier_pct", 0)

        lines.append(f"  POOL: {symbol} ({protocol} - {fee_tier}%)")
        lines.append("-" * 78)
        lines.append(f"  Chain:          {chain}")

        # Format TVL
        tvl = metrics.get("tvl", 0)
        lines.append(f"  TVL:            {self._format_usd(tvl)}")

        # Format Volume
        volume = metrics.get("volume_24h", 0)
        lines.append(f"  24h Volume:     {self._format_usd(volume)}")

        lines.append(f"  Fee Tier:       {fee_tier}%")
        lines.append("")

        # Fee metrics
        lines.append("  FEE METRICS")
        lines.append("-" * 78)
        lines.append(f"  24h Fees:       {self._format_usd(metrics.get('daily_fees', 0))}")
        lines.append(f"  Fee APR:        {metrics.get('fee_apr', 0):.2f}%")
        lines.append(f"  Volume/TVL:     {metrics.get('volume_tvl_ratio', 0):.4f}")
        lines.append("")

        # Token composition (if available)
        token0 = pool.get("token0", {})
        token1 = pool.get("token1", {})
        if token0 or token1:
            lines.append("  TOKEN COMPOSITION")
            lines.append("-" * 78)
            if token0.get("symbol"):
                lines.append(f"  {token0.get('symbol', 'Token0')}:           (token details)")
            if token1.get("symbol"):
                lines.append(f"  {token1.get('symbol', 'Token1')}:           (token details)")
            lines.append("")

        # Health indicators
        health_score = metrics.get("health_score", 0)
        health_level = metrics.get("health_level", "unknown")
        lines.append("  HEALTH INDICATORS")
        lines.append("-" * 78)
        lines.append(f"  Health Score:   {health_score}/100 ({health_level.title()})")
        lines.append(f"  Efficiency:     {metrics.get('capital_efficiency', 'N/A').replace('_', ' ').title()}")

        warnings = metrics.get("warnings", [])
        if warnings:
            lines.append("")
            lines.append("  Warnings:")
            for w in warnings:
                lines.append(f"    - {w}")

        lines.append("=" * 78)

        return "\n".join(lines)

    def _format_pool_list(
        self,
        pools: List[Dict[str, Any]],
        detailed: bool = False
    ) -> str:
        """Format a list of pools as table.

        Args:
            pools: List of pools
            detailed: Show detailed breakdown

        Returns:
            Formatted string
        """
        lines = []

        # Header
        lines.append("=" * 78)
        lines.append(f"  LIQUIDITY POOL ANALYZER{' ' * 31}{self.timestamp}")
        lines.append("=" * 78)
        lines.append("")

        if not pools:
            lines.append("  No pools found matching criteria.")
            lines.append("=" * 78)
            return "\n".join(lines)

        # Table header
        lines.append("  POOL COMPARISON")
        lines.append("-" * 78)
        header = f"  {'Protocol':<15} {'Pair':<15} {'Chain':<12} {'TVL':>10} {'Fee APR':>10}"
        lines.append(header)
        lines.append("-" * 78)

        # Table rows
        for pool in pools:
            metrics = pool.get("metrics", {})
            protocol = (pool.get("project") or "?")[:14]
            symbol = (pool.get("symbol") or "?")[:14]
            chain = (pool.get("chain") or "?")[:11]
            tvl = metrics.get("tvl", pool.get("tvlUsd", 0))
            fee_apr = metrics.get("fee_apr", 0)

            tvl_str = self._format_usd_short(tvl)
            row = f"  {protocol:<15} {symbol:<15} {chain:<12} {tvl_str:>10} {fee_apr:>9.2f}%"
            lines.append(row)

        lines.append("-" * 78)
        lines.append(f"  Total: {len(pools)} pools")
        lines.append("=" * 78)

        return "\n".join(lines)

    def format_il_report(
        self,
        il_data: Dict[str, Any],
        pool: Dict[str, Any] = None
    ) -> str:
        """Format impermanent loss report.

        Args:
            il_data: IL calculation results
            pool: Optional pool data for context

        Returns:
            Formatted string
        """
        lines = []

        lines.append("=" * 78)
        lines.append(f"  IMPERMANENT LOSS CALCULATION{' ' * 26}{self.timestamp}")
        lines.append("=" * 78)
        lines.append("")

        lines.append("-" * 78)
        lines.append(f"  Entry Price:    ${il_data.get('entry_price', 0):,.2f}")
        lines.append(f"  Current Price:  ${il_data.get('current_price', 0):,.2f}")
        lines.append(f"  Price Change:   {il_data.get('price_change_pct', 0):+.1f}%")
        lines.append("")

        lines.append(f"  IL (%):         {il_data.get('il_pct', 0):.2f}%")

        if 'position_value' in il_data:
            lines.append(f"  IL (USD):       ${il_data.get('il_usd', 0):,.2f}")
            lines.append("")
            lines.append(f"  Value if HODL:  ${il_data.get('value_if_held', 0):,.2f}")
            lines.append(f"  Value in LP:    ${il_data.get('value_in_lp', 0):,.2f}")

        # Breakeven analysis if available
        if pool and pool.get("metrics"):
            lines.append("")
            lines.append("  BREAKEVEN ANALYSIS")
            lines.append("-" * 78)
            metrics = pool["metrics"]
            lines.append(f"  Fee Tier:       {metrics.get('fee_tier_pct', 0)}%")
            lines.append(f"  Daily Fee APR:  {metrics.get('fee_apr', 0)/365:.4f}%")

            # Calculate breakeven days
            il_pct = abs(il_data.get('il_pct', 0))
            daily_fee_pct = metrics.get('fee_apr', 0) / 365
            if daily_fee_pct > 0:
                days = il_pct / daily_fee_pct
                lines.append(f"  Days to Break:  {days:.0f} days")

        lines.append("=" * 78)

        return "\n".join(lines)

    def format_il_scenarios(
        self,
        scenarios: List[Dict[str, float]]
    ) -> str:
        """Format IL scenarios table.

        Args:
            scenarios: List of IL scenarios

        Returns:
            Formatted string
        """
        lines = []

        lines.append("=" * 78)
        lines.append("  IMPERMANENT LOSS SCENARIOS")
        lines.append("=" * 78)
        lines.append("")

        lines.append("-" * 78)
        header = f"  {'Price Change':>15} {'Price Ratio':>15} {'IL':>15}"
        lines.append(header)
        lines.append("-" * 78)

        for s in scenarios:
            pct = s.get("price_change_pct", 0)
            ratio = s.get("price_ratio", 1)
            il = s.get("il_pct", 0)

            row = f"  {pct:>+14.0f}% {ratio:>14.2f}x {il:>14.2f}%"
            lines.append(row)

        lines.append("-" * 78)
        lines.append("=" * 78)

        return "\n".join(lines)

    def _format_json(self, data: Any) -> str:
        """Format as JSON.

        Args:
            data: Data to format

        Returns:
            JSON string
        """
        output = {
            "timestamp": self.timestamp,
            "data": data if isinstance(data, list) else [data],
        }
        return json.dumps(output, indent=2, default=str)

    def _format_csv(self, data: Any) -> str:
        """Format as CSV.

        Args:
            data: Data to format

        Returns:
            CSV string
        """
        if not isinstance(data, list):
            data = [data]

        output = io.StringIO()
        writer = csv.writer(output)

        # Header
        writer.writerow([
            "Protocol", "Symbol", "Chain", "Pool Address",
            "TVL (USD)", "Volume 24h", "Fee Tier (%)", "Fee APR (%)",
            "Volume/TVL", "Health Score"
        ])

        for pool in data:
            metrics = pool.get("metrics", {})
            writer.writerow([
                pool.get("project", ""),
                pool.get("symbol", ""),
                pool.get("chain", ""),
                pool.get("pool", ""),
                metrics.get("tvl", pool.get("tvlUsd", 0)),
                metrics.get("volume_24h", pool.get("volumeUsd", 0)),
                metrics.get("fee_tier_pct", 0),
                metrics.get("fee_apr", 0),
                metrics.get("volume_tvl_ratio", 0),
                metrics.get("health_score", 0),
            ])

        return output.getvalue()

    def _format_usd(self, value: float) -> str:
        """Format USD value with appropriate suffix.

        Args:
            value: USD amount

        Returns:
            Formatted string
        """
        if value >= 1e9:
            return f"${value/1e9:.2f}B"
        elif value >= 1e6:
            return f"${value/1e6:.2f}M"
        elif value >= 1e3:
            return f"${value/1e3:.1f}K"
        else:
            return f"${value:,.2f}"

    def _format_usd_short(self, value: float) -> str:
        """Format USD value compactly.

        Args:
            value: USD amount

        Returns:
            Formatted string
        """
        if value >= 1e9:
            return f"${value/1e9:.1f}B"
        elif value >= 1e6:
            return f"${value/1e6:.0f}M"
        elif value >= 1e3:
            return f"${value/1e3:.0f}K"
        else:
            return f"${value:.0f}"


def main():
    """CLI entry point for testing."""
    formatter = PoolFormatter()

    # Test pool data
    pool = {
        "pool": "0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
        "project": "uniswap-v3",
        "chain": "Ethereum",
        "symbol": "USDC-WETH",
        "token0": {"symbol": "USDC"},
        "token1": {"symbol": "WETH"},
        "metrics": {
            "tvl": 500_000_000,
            "volume_24h": 125_000_000,
            "fee_tier_pct": 0.05,
            "daily_fees": 62500,
            "fee_apr": 4.56,
            "volume_tvl_ratio": 0.25,
            "capital_efficiency": "high",
            "health_score": 90,
            "health_level": "healthy",
            "warnings": [],
        }
    }

    print(formatter.format(pool, "table"))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Impermanent Loss Calculator

Calculates impermanent loss for liquidity positions.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""

import math
from typing import Dict, Any, List, Tuple


class ILCalculator:
    """Calculates impermanent loss for LP positions."""

    def __init__(self, verbose: bool = False):
        """Initialize calculator.

        Args:
            verbose: Enable verbose output
        """
        self.verbose = verbose

    def calculate_il(self, price_ratio: float) -> float:
        """Calculate impermanent loss for a price change.

        The formula: IL = 2 * sqrt(r) / (1 + r) - 1
        where r = new_price / original_price

        Args:
            price_ratio: Ratio of new price to original price

        Returns:
            IL as decimal (negative means loss)
        """
        if price_ratio <= 0:
            return 0.0

        il = (2 * math.sqrt(price_ratio) / (1 + price_ratio)) - 1

        if self.verbose:
            print(f"  Price ratio {price_ratio:.2f}x → IL {il*100:.2f}%")

        return il

    def calculate_il_from_prices(
        self,
        entry_price: float,
        current_price: float
    ) -> Dict[str, float]:
        """Calculate IL with detailed breakdown.

        Args:
            entry_price: Price at LP entry
            current_price: Current price

        Returns:
            Dictionary with IL details
        """
        price_ratio = current_price / entry_price
        price_change_pct = (price_ratio - 1) * 100
        il_decimal = self.calculate_il(price_ratio)
        il_pct = il_decimal * 100

        return {
            "entry_price": entry_price,
            "current_price": current_price,
            "price_ratio": round(price_ratio, 4),
            "price_change_pct": round(price_change_pct, 2),
            "il_decimal": round(il_decimal, 6),
            "il_pct": round(il_pct, 2),
        }

    def calculate_position_il(
        self,
        entry_price: float,
        current_price: float,
        position_value: float
    ) -> Dict[str, float]:
        """Calculate IL for a specific position size.

        Args:
            entry_price: Price at LP entry
            current_price: Current price
            position_value: Initial position value in USD

        Returns:
            Dictionary with position IL details
        """
        il_info = self.calculate_il_from_prices(entry_price, current_price)
        price_ratio = current_price / entry_price

        # Value if just held 50/50 split
        # Assuming entry was 50% token0 (USD) and 50% token1 (volatile)
        initial_token1_amount = (position_value / 2) / entry_price
        value_if_held = (position_value / 2) + (initial_token1_amount * current_price)

        # Value in LP (affected by IL)
        value_in_lp = value_if_held * (1 + il_info["il_decimal"])
        il_usd = value_in_lp - value_if_held

        return {
            **il_info,
            "position_value": position_value,
            "value_if_held": round(value_if_held, 2),
            "value_in_lp": round(value_in_lp, 2),
            "il_usd": round(il_usd, 2),
            "gain_vs_hold_pct": round((value_in_lp / value_if_held - 1) * 100, 2),
        }

    def calculate_breakeven(
        self,
        il_pct: float,
        fee_tier: float,
        tvl: float,
        daily_volume: float
    ) -> Dict[str, float]:
        """Calculate days to break even from fees.

        Args:
            il_pct: Impermanent loss percentage (negative)
            fee_tier: Pool fee tier (e.g., 0.003 for 0.3%)
            tvl: Pool TVL in USD
            daily_volume: Daily trading volume in USD

        Returns:
            Dictionary with breakeven analysis
        """
        if tvl <= 0 or daily_volume <= 0 or fee_tier <= 0:
            return {
                "days_to_breakeven": float("inf"),
                "daily_fee_pct": 0,
                "monthly_fee_pct": 0,
            }

        # Daily fee percentage earned by LPs
        daily_fees_usd = daily_volume * fee_tier
        daily_fee_pct = (daily_fees_usd / tvl) * 100

        # Days to recover IL
        il_abs = abs(il_pct)
        if daily_fee_pct > 0:
            days_to_breakeven = il_abs / daily_fee_pct
        else:
            days_to_breakeven = float("inf")

        return {
            "il_pct": il_pct,
            "fee_tier_pct": fee_tier * 100,
            "daily_fee_pct": round(daily_fee_pct, 4),
            "monthly_fee_pct": round(daily_fee_pct * 30, 2),
            "annual_fee_pct": round(daily_fee_pct * 365, 2),
            "days_to_breakeven": round(days_to_breakeven, 1) if days_to_breakeven != float("inf") else None,
        }

    def generate_il_scenarios(
        self,
        price_changes: List[float] = None
    ) -> List[Dict[str, float]]:
        """Generate IL for various price change scenarios.

        Args:
            price_changes: List of price change percentages

        Returns:
            List of IL scenarios
        """
        if price_changes is None:
            price_changes = [-75, -50, -25, -10, 10, 25, 50, 100, 200, 300, 400]

        scenarios = []
        for pct_change in price_changes:
            price_ratio = 1 + (pct_change / 100)
            if price_ratio > 0:
                il = self.calculate_il(price_ratio)
                scenarios.append({
                    "price_change_pct": pct_change,
                    "price_ratio": round(price_ratio, 2),
                    "il_pct": round(il * 100, 2),
                })

        return scenarios

    def compare_strategies(
        self,
        entry_price: float,
        current_price: float,
        position_value: float,
        fee_earned_pct: float
    ) -> Dict[str, Any]:
        """Compare LP strategy vs HODL.

        Args:
            entry_price: Price at LP entry
            current_price: Current price
            position_value: Initial position value
            fee_earned_pct: Total fees earned as percentage

        Returns:
            Strategy comparison
        """
        position_info = self.calculate_position_il(
            entry_price, current_price, position_value
        )

        # Value with fees added
        fees_earned = position_value * (fee_earned_pct / 100)
        lp_value_with_fees = position_info["value_in_lp"] + fees_earned

        # Net result
        net_gain_usd = lp_value_with_fees - position_info["value_if_held"]
        net_gain_pct = (net_gain_usd / position_info["value_if_held"]) * 100

        return {
            **position_info,
            "fees_earned_pct": fee_earned_pct,
            "fees_earned_usd": round(fees_earned, 2),
            "lp_value_with_fees": round(lp_value_with_fees, 2),
            "net_gain_usd": round(net_gain_usd, 2),
            "net_gain_pct": round(net_gain_pct, 2),
            "better_strategy": "LP" if net_gain_usd > 0 else "HODL",
        }


def main():
    """CLI entry point for testing."""
    calc = ILCalculator(verbose=True)

    print("Impermanent Loss Scenarios:")
    print("-" * 50)
    scenarios = calc.generate_il_scenarios()
    for s in scenarios:
        print(f"  {s['price_change_pct']:+4d}% price change → {s['il_pct']:+6.2f}% IL")

    print("\nPosition Analysis:")
    print("-" * 50)
    position = calc.calculate_position_il(
        entry_price=2000,
        current_price=3000,
        position_value=10000
    )
    print(f"  Entry: ${position['entry_price']}")
    print(f"  Current: ${position['current_price']}")
    print(f"  Price Change: {position['price_change_pct']:+.2f}%")
    print(f"  IL: {position['il_pct']:.2f}%")
    print(f"  Value if HODL: ${position['value_if_held']:,.2f}")
    print(f"  Value in LP: ${position['value_in_lp']:,.2f}")
    print(f"  IL Loss: ${position['il_usd']:,.2f}")

    print("\nBreakeven Analysis (0.3% fee tier):")
    print("-" * 50)
    breakeven = calc.calculate_breakeven(
        il_pct=position['il_pct'],
        fee_tier=0.003,
        tvl=500_000_000,
        daily_volume=100_000_000
    )
    print(f"  Daily Fee APR: {breakeven['daily_fee_pct']:.4f}%")
    print(f"  Annual Fee APR: {breakeven['annual_fee_pct']:.2f}%")
    if breakeven['days_to_breakeven']:
        print(f"  Days to Breakeven: {breakeven['days_to_breakeven']:.0f}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Liquidity Pool Analyzer - Main CLI

Analyze DEX liquidity pools for TVL, volume, fees, and impermanent loss.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""

import argparse
import sys
from pathlib import Path

# Add scripts directory to path for imports
sys.path.insert(0, str(Path(__file__).parent))

from pool_fetcher import PoolFetcher
from il_calculator import ILCalculator
from pool_metrics import PoolMetrics
from formatters import PoolFormatter


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Analyze DEX liquidity pools",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  %(prog)s --pool 0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640
  %(prog)s --pair ETH/USDC --protocol uniswap-v3
  %(prog)s --il-calc --entry-price 2000 --current-price 3000
  %(prog)s --compare --pair ETH/USDC --protocols uniswap-v3,curve
        """
    )

    # Pool identification
    parser.add_argument(
        "--pool", "-p",
        help="Pool address to analyze"
    )

    parser.add_argument(
        "--pair",
        help="Token pair to search (e.g., ETH/USDC)"
    )

    parser.add_argument(
        "--protocol",
        help="Protocol filter (uniswap-v3, curve, balancer, etc.)"
    )

    parser.add_argument(
        "--chain", "-c",
        default="ethereum",
        help="Blockchain (ethereum, arbitrum, polygon, etc.)"
    )

    # IL calculation
    parser.add_argument(
        "--il-calc",
        action="store_true",
        help="Calculate impermanent loss"
    )

    parser.add_argument(
        "--entry-price",
        type=float,
        help="Entry price for IL calculation"
    )

    parser.add_argument(
        "--current-price",
        type=float,
        help="Current price for IL calculation"
    )

    parser.add_argument(
        "--il-scenarios",
        action="store_true",
        help="Show IL for various price scenarios"
    )

    # Position analysis
    parser.add_argument(
        "--position",
        type=float,
        help="Position size in USD for projections"
    )

    # Comparison
    parser.add_argument(
        "--compare",
        action="store_true",
        help="Compare pools"
    )

    parser.add_argument(
        "--protocols",
        help="Protocols to compare, comma-separated"
    )

    parser.add_argument(
        "--fee-tiers",
        help="Fee tiers to compare, comma-separated"
    )

    # Filters
    parser.add_argument(
        "--min-tvl",
        type=float,
        default=0,
        help="Minimum TVL in USD"
    )

    parser.add_argument(
        "--top", "-t",
        type=int,
        default=10,
        help="Number of results to show"
    )

    # Output options
    parser.add_argument(
        "--format", "-f",
        choices=["table", "json", "csv"],
        default="table",
        help="Output format"
    )

    parser.add_argument(
        "--output", "-o",
        help="Output file"
    )

    parser.add_argument(
        "--detailed",
        action="store_true",
        help="Show detailed analysis"
    )

    # Other
    parser.add_argument(
        "--no-cache",
        action="store_true",
        help="Bypass cache"
    )

    parser.add_argument(
        "--verbose", "-v",
        action="store_true",
        help="Verbose output"
    )

    parser.add_argument(
        "--version",
        action="version",
        version="%(prog)s 2.0.0"
    )

    args = parser.parse_args()

    try:
        # Initialize components
        fetcher = PoolFetcher(use_cache=not args.no_cache, verbose=args.verbose)
        il_calc = ILCalculator(verbose=args.verbose)
        metrics_calc = PoolMetrics(verbose=args.verbose)
        formatter = PoolFormatter()

        # Handle IL calculation mode
        if args.il_calc and args.entry_price and args.current_price:
            return handle_il_calculation(args, il_calc, formatter)

        # Handle IL scenarios mode
        if args.il_scenarios:
            return handle_il_scenarios(il_calc, formatter, args)

        # Fetch pools
        if args.verbose:
            print("Fetching pool data...")

        pools = []

        if args.pool:
            # Specific pool by address
            pool = fetcher.fetch_pool_by_address(
                args.pool,
                chain=args.chain,
                protocol=args.protocol or "uniswap-v3"
            )
            if pool:
                pools = [pool]
        elif args.pair:
            # Search by token pair
            tokens = args.pair.upper().replace("/", "-").split("-")
            if len(tokens) >= 2:
                pools = fetcher.fetch_pools_by_pair(
                    tokens[0], tokens[1],
                    chain=args.chain if args.chain != "ethereum" else None,
                    protocol=args.protocol
                )
        elif args.protocol:
            # All pools for a protocol
            pools = fetcher.fetch_pools_by_protocol(
                args.protocol,
                chain=args.chain if args.chain != "ethereum" else None,
                min_tvl=args.min_tvl
            )
        else:
            print("Please specify --pool, --pair, or --protocol", file=sys.stderr)
            sys.exit(1)

        if not pools:
            print("No pools found matching criteria.", file=sys.stderr)
            sys.exit(0)

        # Apply filters
        if args.min_tvl > 0:
            pools = [p for p in pools if (p.get("tvlUsd") or 0) >= args.min_tvl]

        # Calculate metrics
        for pool in pools:
            metrics_calc.calculate_metrics(pool)

        # Limit results
        pools = pools[:args.top]

        if not pools:
            print("No pools match criteria after filtering.", file=sys.stderr)
            sys.exit(0)

        # Handle position projection
        if args.position and len(pools) == 1:
            position_metrics = metrics_calc.calculate_position_metrics(pools[0], args.position)
            pools[0]["position"] = position_metrics

        # Format output
        if len(pools) == 1 and not args.compare:
            output = formatter.format(pools[0], args.format, args.detailed)
        else:
            output = formatter.format(pools, args.format, args.detailed)

        # Output
        if args.output:
            with open(args.output, "w") as f:
                f.write(output)
            print(f"Results saved to {args.output}")
        else:
            print(output)

    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        if args.verbose:
            import traceback
            traceback.print_exc()
        sys.exit(1)


def handle_il_calculation(args, il_calc, formatter):
    """Handle IL calculation mode.

    Args:
        args: CLI arguments
        il_calc: IL calculator instance
        formatter: Output formatter

    Returns:
        Exit code
    """
    position_value = args.position or 1000

    il_data = il_calc.calculate_position_il(
        entry_price=args.entry_price,
        current_price=args.current_price,
        position_value=position_value
    )

    if args.format == "json":
        output = formatter._format_json(il_data)
    else:
        output = formatter.format_il_report(il_data)

    if args.output:
        with open(args.output, "w") as f:
            f.write(output)
        print(f"Results saved to {args.output}")
    else:
        print(output)

    return 0


def handle_il_scenarios(il_calc, formatter, args):
    """Handle IL scenarios mode.

    Args:
        il_calc: IL calculator instance
        formatter: Output formatter
        args: CLI arguments

    Returns:
        Exit code
    """
    scenarios = il_calc.generate_il_scenarios()

    if args.format == "json":
        output = formatter._format_json(scenarios)
    else:
        output = formatter.format_il_scenarios(scenarios)

    if args.output:
        with open(args.output, "w") as f:
            f.write(output)
        print(f"Results saved to {args.output}")
    else:
        print(output)

    return 0


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Pool Fetcher

Fetches liquidity pool data from subgraphs and APIs.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""

import json
import time
from datetime import datetime
from pathlib import Path
from typing import Dict, Any, List, Optional

try:
    import requests
except ImportError:
    requests = None


class PoolFetcher:
    """Fetches pool data from DEX subgraphs and APIs."""

    # DeFiLlama endpoints
    DEFILLAMA_POOLS_URL = "https://yields.llama.fi/pools"

    # Subgraph endpoints
    SUBGRAPH_ENDPOINTS = {
        "uniswap-v3-ethereum": "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3",
        "uniswap-v3-arbitrum": "https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-arbitrum",
        "uniswap-v3-polygon": "https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-polygon",
        "uniswap-v2-ethereum": "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2",
    }

    CACHE_FILE = Path.home() / ".lp_analyzer_cache.json"
    CACHE_TTL = 300  # 5 minutes

    def __init__(self, use_cache: bool = True, verbose: bool = False):
        """Initialize fetcher.

        Args:
            use_cache: Whether to use cached data
            verbose: Enable verbose output
        """
        self.use_cache = use_cache
        self.verbose = verbose
        self._cache = {}

    def fetch_pool_by_address(
        self,
        address: str,
        chain: str = "ethereum",
        protocol: str = "uniswap-v3"
    ) -> Optional[Dict[str, Any]]:
        """Fetch pool data by contract address.

        Args:
            address: Pool contract address
            chain: Blockchain (ethereum, arbitrum, etc.)
            protocol: DEX protocol

        Returns:
            Pool data dictionary or None
        """
        cache_key = f"pool_{address}_{chain}"

        # Check cache
        if self.use_cache:
            cached = self._load_cache(cache_key)
            if cached:
                if self.verbose:
                    print(f"  Using cached data for {address[:10]}...")
                return cached

        # Try subgraph first
        subgraph_key = f"{protocol}-{chain}"
        if subgraph_key in self.SUBGRAPH_ENDPOINTS:
            pool = self._fetch_from_subgraph(address, subgraph_key)
            if pool:
                self._save_cache(cache_key, pool)
                return pool

        # Fallback to DeFiLlama
        pool = self._fetch_from_defillama(address)
        if pool:
            self._save_cache(cache_key, pool)
            return pool

        # Return mock data as last resort
        if self.verbose:
            print(f"  Pool not found, using mock data")
        return self._get_mock_pool(address)

    def fetch_pools_by_pair(
        self,
        token0: str,
        token1: str,
        chain: str = None,
        protocol: str = None
    ) -> List[Dict[str, Any]]:
        """Fetch pools for a token pair.

        Args:
            token0: First token symbol
            token1: Second token symbol
            chain: Optional chain filter
            protocol: Optional protocol filter

        Returns:
            List of matching pools
        """
        # Fetch from DeFiLlama (has all pools)
        all_pools = self._fetch_all_pools()

        # Normalize search terms
        search_tokens = {token0.upper(), token1.upper()}

        # Filter matching pools
        matches = []
        for pool in all_pools:
            symbol = pool.get("symbol", "").upper()
            # Check if both tokens are in the symbol
            if all(t in symbol for t in search_tokens):
                if chain and pool.get("chain", "").lower() != chain.lower():
                    continue
                if protocol and protocol.lower() not in pool.get("project", "").lower():
                    continue
                matches.append(pool)

        # Sort by TVL
        matches.sort(key=lambda x: -(x.get("tvlUsd") or 0))

        if self.verbose:
            print(f"  Found {len(matches)} pools for {token0}/{token1}")

        return matches

    def fetch_pools_by_protocol(
        self,
        protocol: str,
        chain: str = None,
        min_tvl: float = 0
    ) -> List[Dict[str, Any]]:
        """Fetch all pools for a protocol.

        Args:
            protocol: Protocol name (uniswap-v3, curve, etc.)
            chain: Optional chain filter
            min_tvl: Minimum TVL filter

        Returns:
            List of pools
        """
        all_pools = self._fetch_all_pools()

        matches = []
        for pool in all_pools:
            if protocol.lower() not in pool.get("project", "").lower():
                continue
            if chain and pool.get("chain", "").lower() != chain.lower():
                continue
            if (pool.get("tvlUsd") or 0) < min_tvl:
                continue
            matches.append(pool)

        matches.sort(key=lambda x: -(x.get("tvlUsd") or 0))

        return matches

    def _fetch_all_pools(self) -> List[Dict[str, Any]]:
        """Fetch all pools from DeFiLlama.

        Returns:
            List of all pools
        """
        cache_key = "all_pools"

        if self.use_cache:
            cached = self._load_cache(cache_key)
            if cached:
                return cached

        if requests is None:
            return self._get_mock_pools()

        try:
            if self.verbose:
                print(f"  Fetching from DeFiLlama...")

            response = requests.get(
                self.DEFILLAMA_POOLS_URL,
                timeout=30,
                headers={"Accept": "application/json"}
            )
            response.raise_for_status()

            data = response.json()
            pools = data.get("data", [])

            if self.use_cache and pools:
                self._save_cache(cache_key, pools)

            return pools

        except Exception as e:
            if self.verbose:
                print(f"  API error: {e}")
            return self._get_mock_pools()

    def _fetch_from_subgraph(
        self,
        address: str,
        subgraph_key: str
    ) -> Optional[Dict[str, Any]]:
        """Fetch pool from The Graph subgraph.

        Args:
            address: Pool address
            subgraph_key: Subgraph identifier

        Returns:
            Pool data or None
        """
        if requests is None:
            return None

        endpoint = self.SUBGRAPH_ENDPOINTS.get(subgraph_key)
        if not endpoint:
            return None

        query = """
        query Pool($id: ID!) {
            pool(id: $id) {
                id
                token0 { symbol, decimals, name }
                token1 { symbol, decimals, name }
                feeTier
                liquidity
                sqrtPrice
                tick
                totalValueLockedUSD
                volumeUSD
                feesUSD
                txCount
                createdAtTimestamp
            }
        }
        """

        try:
            response = requests.post(
                endpoint,
                json={"query": query, "variables": {"id": address.lower()}},
                timeout=15
            )
            response.raise_for_status()

            data = response.json()
            pool_data = data.get("data", {}).get("pool")

            if pool_data:
                return self._normalize_subgraph_pool(pool_data, subgraph_key)

        except Exception as e:
            if self.verbose:
                print(f"  Subgraph error: {e}")

        return None

    def _fetch_from_defillama(self, address: str) -> Optional[Dict[str, Any]]:
        """Fetch pool from DeFiLlama by address.

        Args:
            address: Pool address

        Returns:
            Pool data or None
        """
        pools = self._fetch_all_pools()
        address_lower = address.lower()

        for pool in pools:
            pool_id = pool.get("pool", "")
            if address_lower in pool_id.lower():
                return pool

        return None

    def _normalize_subgraph_pool(
        self,
        pool: Dict[str, Any],
        subgraph_key: str
    ) -> Dict[str, Any]:
        """Normalize subgraph pool data to standard format.

        Args:
            pool: Raw subgraph pool data
            subgraph_key: Source subgraph

        Returns:
            Normalized pool data
        """
        # Extract chain and protocol from subgraph key
        parts = subgraph_key.split("-")
        protocol = "-".join(parts[:-1])
        chain = parts[-1]

        fee_tier = int(pool.get("feeTier", 0))
        fee_pct = fee_tier / 10000 if fee_tier else 0.003

        return {
            "pool": pool.get("id"),
            "project": protocol,
            "chain": chain.capitalize(),
            "symbol": f"{pool['token0']['symbol']}-{pool['token1']['symbol']}",
            "token0": pool["token0"],
            "token1": pool["token1"],
            "tvlUsd": float(pool.get("totalValueLockedUSD", 0)),
            "volumeUsd": float(pool.get("volumeUSD", 0)),
            "feesUsd": float(pool.get("feesUSD", 0)),
            "feeTier": fee_pct,
            "txCount": int(pool.get("txCount", 0)),
            "createdAt": pool.get("createdAtTimestamp"),
            "source": "subgraph",
        }

    def _load_cache(self, key: str) -> Optional[Any]:
        """Load data from cache.

        Args:
            key: Cache key

        Returns:
            Cached data or None
        """
        if not self.CACHE_FILE.exists():
            return None

        try:
            with open(self.CACHE_FILE, "r") as f:
                cache = json.load(f)

            entry = cache.get(key)
            if not entry:
                return None

            # Check TTL
            cached_time = entry.get("timestamp", 0)
            if time.time() - cached_time > self.CACHE_TTL:
                return None

            return entry.get("data")

        except (json.JSONDecodeError, IOError):
            return None

    def _save_cache(self, key: str, data: Any) -> None:
        """Save data to cache.

        Args:
            key: Cache key
            data: Data to cache
        """
        try:
            cache = {}
            if self.CACHE_FILE.exists():
                with open(self.CACHE_FILE, "r") as f:
                    cache = json.load(f)

            cache[key] = {
                "timestamp": time.time(),
                "data": data
            }

            with open(self.CACHE_FILE, "w") as f:
                json.dump(cache, f)

        except IOError:
            pass

    def _get_mock_pool(self, address: str) -> Dict[str, Any]:
        """Get mock pool data for testing.

        Args:
            address: Pool address

        Returns:
            Mock pool data
        """
        return {
            "pool": address,
            "project": "uniswap-v3",
            "chain": "Ethereum",
            "symbol": "ETH-USDC",
            "token0": {"symbol": "USDC", "decimals": 6},
            "token1": {"symbol": "WETH", "decimals": 18},
            "tvlUsd": 500_000_000,
            "volumeUsd": 100_000_000,
            "feeTier": 0.0005,
            "feesUsd": 50_000,
            "source": "mock",
        }

    def _get_mock_pools(self) -> List[Dict[str, Any]]:
        """Get mock pools for testing.

        Returns:
            List of mock pools
        """
        return [
            {
                "pool": "0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
                "project": "uniswap-v3",
                "chain": "Ethereum",
                "symbol": "USDC-WETH",
                "tvlUsd": 500_000_000,
                "volumeUsd": 125_000_000,
                "apy": 4.5,
                "feeTier": 0.0005,
            },
            {
                "pool": "0x4e68ccd3e89f51c3074ca5072bbac773960dfa36",
                "project": "uniswap-v3",
                "chain": "Ethereum",
                "symbol": "WETH-USDT",
                "tvlUsd": 150_000_000,
                "volumeUsd": 45_000_000,
                "apy": 8.2,
                "feeTier": 0.003,
            },
            {
                "pool": "curve-3pool",
                "project": "curve-dex",
                "chain": "Ethereum",
                "symbol": "DAI-USDC-USDT",
                "tvlUsd": 890_000_000,
                "volumeUsd": 50_000_000,
                "apy": 2.1,
                "feeTier": 0.0004,
            },
        ]


def main():
    """CLI entry point for testing."""
    fetcher = PoolFetcher(verbose=True)

    print("Fetching ETH/USDC pools:")
    pools = fetcher.fetch_pools_by_pair("ETH", "USDC")

    print(f"\nFound {len(pools)} pools:")
    for pool in pools[:5]:
        tvl = pool.get("tvlUsd", 0)
        if tvl >= 1e9:
            tvl_str = f"${tvl/1e9:.1f}B"
        elif tvl >= 1e6:
            tvl_str = f"${tvl/1e6:.0f}M"
        else:
            tvl_str = f"${tvl:,.0f}"

        print(f"  {pool.get('project')}: {pool.get('symbol')} on {pool.get('chain')} - TVL: {tvl_str}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Pool Metrics Calculator

Calculates derived metrics for liquidity pools.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""

from typing import Dict, Any, List, Optional


class PoolMetrics:
    """Calculates metrics for liquidity pools."""

    def __init__(self, verbose: bool = False):
        """Initialize metrics calculator.

        Args:
            verbose: Enable verbose output
        """
        self.verbose = verbose

    def calculate_metrics(self, pool: Dict[str, Any]) -> Dict[str, Any]:
        """Calculate all metrics for a pool.

        Args:
            pool: Pool data dictionary

        Returns:
            Pool with metrics added
        """
        # Basic metrics
        pool["metrics"] = {}

        # TVL metrics
        self._calculate_tvl_metrics(pool)

        # Fee metrics
        self._calculate_fee_metrics(pool)

        # Efficiency metrics
        self._calculate_efficiency_metrics(pool)

        # Health indicators
        self._calculate_health_indicators(pool)

        if self.verbose:
            print(f"  Calculated metrics for {pool.get('symbol')}")

        return pool

    def _calculate_tvl_metrics(self, pool: Dict[str, Any]) -> None:
        """Calculate TVL-related metrics.

        Args:
            pool: Pool data (modified in place)
        """
        tvl = pool.get("tvlUsd", 0)
        volume_24h = pool.get("volumeUsd", 0) or pool.get("volume24h", 0)

        # TVL category
        if tvl >= 100_000_000:
            tvl_category = "large"
        elif tvl >= 10_000_000:
            tvl_category = "medium"
        elif tvl >= 1_000_000:
            tvl_category = "small"
        else:
            tvl_category = "micro"

        pool["metrics"]["tvl"] = tvl
        pool["metrics"]["tvl_category"] = tvl_category
        pool["metrics"]["volume_24h"] = volume_24h

    def _calculate_fee_metrics(self, pool: Dict[str, Any]) -> None:
        """Calculate fee-related metrics.

        Args:
            pool: Pool data (modified in place)
        """
        tvl = pool.get("tvlUsd", 0)
        volume_24h = pool.get("volumeUsd", 0) or pool.get("volume24h", 0)
        fee_tier = pool.get("feeTier", 0.003)  # Default 0.3%

        # Ensure fee_tier is decimal (not percentage)
        if fee_tier > 1:
            fee_tier = fee_tier / 10000  # Convert from basis points

        # Calculate fees
        if volume_24h > 0:
            daily_fees = volume_24h * fee_tier
        else:
            daily_fees = 0

        # Calculate APR
        if tvl > 0 and daily_fees > 0:
            fee_apr = (daily_fees / tvl) * 365 * 100
        else:
            fee_apr = 0

        pool["metrics"]["fee_tier"] = fee_tier
        pool["metrics"]["fee_tier_pct"] = round(fee_tier * 100, 4)
        pool["metrics"]["daily_fees"] = round(daily_fees, 2)
        pool["metrics"]["weekly_fees"] = round(daily_fees * 7, 2)
        pool["metrics"]["monthly_fees"] = round(daily_fees * 30, 2)
        pool["metrics"]["annual_fees"] = round(daily_fees * 365, 2)
        pool["metrics"]["fee_apr"] = round(fee_apr, 2)

    def _calculate_efficiency_metrics(self, pool: Dict[str, Any]) -> None:
        """Calculate efficiency metrics.

        Args:
            pool: Pool data (modified in place)
        """
        tvl = pool.get("tvlUsd", 0)
        volume_24h = pool.get("volumeUsd", 0) or pool.get("volume24h", 0)

        # Volume/TVL ratio (turnover)
        if tvl > 0:
            volume_tvl_ratio = volume_24h / tvl
        else:
            volume_tvl_ratio = 0

        # Capital efficiency rating
        if volume_tvl_ratio >= 0.5:
            efficiency = "very_high"
        elif volume_tvl_ratio >= 0.1:
            efficiency = "high"
        elif volume_tvl_ratio >= 0.05:
            efficiency = "medium"
        elif volume_tvl_ratio >= 0.01:
            efficiency = "low"
        else:
            efficiency = "very_low"

        pool["metrics"]["volume_tvl_ratio"] = round(volume_tvl_ratio, 4)
        pool["metrics"]["capital_efficiency"] = efficiency

    def _calculate_health_indicators(self, pool: Dict[str, Any]) -> None:
        """Calculate pool health indicators.

        Args:
            pool: Pool data (modified in place)
        """
        tvl = pool.get("tvlUsd", 0)
        volume_24h = pool.get("volumeUsd", 0) or pool.get("volume24h", 0)
        fee_apr = pool["metrics"].get("fee_apr", 0)

        warnings = []
        health_score = 100

        # TVL check
        if tvl < 100_000:
            warnings.append("Very low TVL - high slippage risk")
            health_score -= 30
        elif tvl < 1_000_000:
            warnings.append("Low TVL - moderate slippage risk")
            health_score -= 15

        # Volume check
        if volume_24h < 10_000:
            warnings.append("Very low volume - illiquid")
            health_score -= 25
        elif volume_24h < 100_000:
            warnings.append("Low volume - may be illiquid")
            health_score -= 10

        # Fee APR check
        if fee_apr < 1:
            warnings.append("Low fee income - may not offset IL")
            health_score -= 15
        elif fee_apr > 100:
            warnings.append("Unusually high APR - verify data")
            health_score -= 10

        # Volume/TVL ratio check
        vol_tvl = pool["metrics"].get("volume_tvl_ratio", 0)
        if vol_tvl < 0.01:
            warnings.append("Very low capital utilization")
            health_score -= 10

        # Determine health level
        if health_score >= 80:
            health_level = "healthy"
        elif health_score >= 60:
            health_level = "moderate"
        elif health_score >= 40:
            health_level = "poor"
        else:
            health_level = "risky"

        pool["metrics"]["health_score"] = max(0, health_score)
        pool["metrics"]["health_level"] = health_level
        pool["metrics"]["warnings"] = warnings

    def calculate_position_metrics(
        self,
        pool: Dict[str, Any],
        position_value: float
    ) -> Dict[str, Any]:
        """Calculate metrics for a specific position size.

        Args:
            pool: Pool data with metrics
            position_value: Position size in USD

        Returns:
            Position-specific metrics
        """
        metrics = pool.get("metrics", {})
        tvl = metrics.get("tvl", 0)
        fee_apr = metrics.get("fee_apr", 0)

        # Position share of pool
        if tvl > 0:
            position_share = (position_value / tvl) * 100
        else:
            position_share = 0

        # Projected fees
        daily_fees_pool = metrics.get("daily_fees", 0)
        if tvl > 0:
            position_daily_fees = daily_fees_pool * (position_value / tvl)
        else:
            position_daily_fees = 0

        return {
            "position_value": position_value,
            "position_share_pct": round(position_share, 4),
            "daily_fees": round(position_daily_fees, 2),
            "weekly_fees": round(position_daily_fees * 7, 2),
            "monthly_fees": round(position_daily_fees * 30, 2),
            "annual_fees": round(position_daily_fees * 365, 2),
            "fee_apr": fee_apr,
        }

    def compare_pools(
        self,
        pools: List[Dict[str, Any]]
    ) -> Dict[str, Any]:
        """Compare metrics across multiple pools.

        Args:
            pools: List of pools with metrics

        Returns:
            Comparison summary
        """
        if not pools:
            return {}

        # Find best in each category
        max_tvl = max(pools, key=lambda p: p.get("metrics", {}).get("tvl", 0))
        max_apr = max(pools, key=lambda p: p.get("metrics", {}).get("fee_apr", 0))
        max_efficiency = max(pools, key=lambda p: p.get("metrics", {}).get("volume_tvl_ratio", 0))
        healthiest = max(pools, key=lambda p: p.get("metrics", {}).get("health_score", 0))

        return {
            "pool_count": len(pools),
            "highest_tvl": {
                "pool": max_tvl.get("symbol"),
                "tvl": max_tvl.get("metrics", {}).get("tvl"),
            },
            "highest_apr": {
                "pool": max_apr.get("symbol"),
                "apr": max_apr.get("metrics", {}).get("fee_apr"),
            },
            "most_efficient": {
                "pool": max_efficiency.get("symbol"),
                "ratio": max_efficiency.get("metrics", {}).get("volume_tvl_ratio"),
            },
            "healthiest": {
                "pool": healthiest.get("symbol"),
                "score": healthiest.get("metrics", {}).get("health_score"),
            },
        }


def main():
    """CLI entry point for testing."""
    calculator = PoolMetrics(verbose=True)

    # Test pool
    pool = {
        "pool": "0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
        "project": "uniswap-v3",
        "chain": "Ethereum",
        "symbol": "USDC-WETH",
        "tvlUsd": 500_000_000,
        "volumeUsd": 125_000_000,
        "feeTier": 0.0005,
    }

    calculator.calculate_metrics(pool)

    print("\nPool Metrics:")
    print("-" * 50)
    metrics = pool["metrics"]
    print(f"  TVL: ${metrics['tvl']:,.0f} ({metrics['tvl_category']})")
    print(f"  Volume/24h: ${metrics['volume_24h']:,.0f}")
    print(f"  Fee Tier: {metrics['fee_tier_pct']}%")
    print(f"  Daily Fees: ${metrics['daily_fees']:,.2f}")
    print(f"  Fee APR: {metrics['fee_apr']:.2f}%")
    print(f"  Volume/TVL: {metrics['volume_tvl_ratio']:.4f}")
    print(f"  Capital Efficiency: {metrics['capital_efficiency']}")
    print(f"  Health Score: {metrics['health_score']}/100 ({metrics['health_level']})")

    if metrics["warnings"]:
        print(f"  Warnings:")
        for w in metrics["warnings"]:
            print(f"    - {w}")

    print("\nPosition Projection ($10,000):")
    position = calculator.calculate_position_metrics(pool, 10000)
    print(f"  Share of Pool: {position['position_share_pct']:.4f}%")
    print(f"  Daily Fees: ${position['daily_fees']:.2f}")
    print(f"  Monthly Fees: ${position['monthly_fees']:.2f}")
    print(f"  Annual Fees: ${position['annual_fees']:.2f}")


if __name__ == "__main__":
    main()