Finding Arbitrage Opportunities

# Arbitrage Opportunity Finder Configuration
# ============================================
# Configure data sources, exchanges, and scanning parameters.

# ─────────────────────────────────────────────────────────────────
# Data Sources
# ─────────────────────────────────────────────────────────────────
# Primary aggregators and APIs for price data.

data_sources:
  coingecko:
    enabled: true
    base_url: "https://api.coingecko.com/api/v3"
    rate_limit: 10  # calls per minute (free tier)
    api_key: null   # Optional: for higher rate limits

  coinmarketcap:
    enabled: false
    base_url: "https://pro-api.coinmarketcap.com/v1"
    api_key: null   # Required for access

# ─────────────────────────────────────────────────────────────────
# Centralized Exchanges (CEX)
# ─────────────────────────────────────────────────────────────────
# Fee structures and API configurations for CEX.

cex:
  binance:
    enabled: true
    name: "Binance"
    maker_fee: 0.0010   # 0.10%
    taker_fee: 0.0010   # 0.10%
    withdrawal_fee: 0.0005
    api_base: "https://api.binance.com"
    api_key: null       # Optional for public data
    api_secret: null

  coinbase:
    enabled: true
    name: "Coinbase"
    maker_fee: 0.0040   # 0.40%
    taker_fee: 0.0060   # 0.60%
    withdrawal_fee: 0.0000  # Free for most assets
    api_base: "https://api.coinbase.com"
    api_key: null
    api_secret: null

  kraken:
    enabled: true
    name: "Kraken"
    maker_fee: 0.0016   # 0.16%
    taker_fee: 0.0026   # 0.26%
    withdrawal_fee: 0.0010
    api_base: "https://api.kraken.com"
    api_key: null
    api_secret: null

  kucoin:
    enabled: true
    name: "KuCoin"
    maker_fee: 0.0010
    taker_fee: 0.0010
    withdrawal_fee: 0.0003
    api_base: "https://api.kucoin.com"
    api_key: null
    api_secret: null

  okx:
    enabled: true
    name: "OKX"
    maker_fee: 0.0008   # 0.08%
    taker_fee: 0.0010   # 0.10%
    withdrawal_fee: 0.0004
    api_base: "https://www.okx.com"
    api_key: null
    api_secret: null

# ─────────────────────────────────────────────────────────────────
# Decentralized Exchanges (DEX)
# ─────────────────────────────────────────────────────────────────
# DEX configurations with subgraph endpoints.

dex:
  uniswap:
    enabled: true
    name: "Uniswap V3"
    fee_tiers: [0.0001, 0.0005, 0.003, 0.01]  # 0.01%, 0.05%, 0.3%, 1%
    default_fee: 0.003
    gas_estimate: 150000
    subgraph:
      ethereum: "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3"
      polygon: "https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-polygon"
      arbitrum: "https://api.thegraph.com/subgraphs/name/ianlapham/arbitrum-dev"
    chains: [ethereum, polygon, arbitrum, optimism]

  sushiswap:
    enabled: true
    name: "SushiSwap"
    fee: 0.003   # 0.30% fixed
    gas_estimate: 150000
    subgraph:
      ethereum: "https://api.thegraph.com/subgraphs/name/sushiswap/exchange"
    chains: [ethereum, polygon, arbitrum]

  curve:
    enabled: true
    name: "Curve"
    fee: 0.0004  # 0.04% for stable pools
    gas_estimate: 200000
    chains: [ethereum, polygon, arbitrum]

  balancer:
    enabled: true
    name: "Balancer V2"
    fee_range: [0.0001, 0.10]  # Pool-dependent
    default_fee: 0.001
    gas_estimate: 180000
    chains: [ethereum, polygon, arbitrum]

# ─────────────────────────────────────────────────────────────────
# Scanning Parameters
# ─────────────────────────────────────────────────────────────────
# Default parameters for opportunity scanning.

scanning:
  # Minimum profit threshold to report
  min_profit_pct: 0.1   # 0.1%

  # Maximum data staleness (seconds)
  max_staleness: 30

  # Default monitoring interval
  monitor_interval: 5   # seconds

  # Alert threshold
  alert_threshold: 0.3  # 0.3%

  # Rate limit handling
  request_delay_ms: 100
  backoff_multiplier: 2.0
  max_retries: 3

# ─────────────────────────────────────────────────────────────────
# Market Parameters
# ─────────────────────────────────────────────────────────────────
# Default market assumptions for calculations.

market:
  eth_price_usd: 2500.0
  btc_price_usd: 68000.0
  gas_price_gwei: 30.0
  default_slippage_pct: 0.1

# ─────────────────────────────────────────────────────────────────
# Triangular Arbitrage
# ─────────────────────────────────────────────────────────────────
# Settings for triangular path finding.

triangular:
  # Maximum path length
  max_hops: 3

  # Minimum liquidity per pair (USD)
  min_liquidity: 10000

  # Minimum profit to report
  min_profit_pct: 0.1

  # Maximum paths to return
  max_results: 100

# ─────────────────────────────────────────────────────────────────
# Output Settings
# ─────────────────────────────────────────────────────────────────

output:
  default_format: "console"  # console, json
  console_width: 70
  show_all_quotes: true
  show_warnings: true

# ─────────────────────────────────────────────────────────────────
# Common Trading Pairs
# ─────────────────────────────────────────────────────────────────
# Pre-configured pairs for quick scanning.

popular_pairs:
  - ["ETH", "USDC"]
  - ["ETH", "USDT"]
  - ["BTC", "USDC"]
  - ["BTC", "USDT"]
  - ["ETH", "BTC"]
  - ["USDC", "USDT"]

# ─────────────────────────────────────────────────────────────────
# Educational Disclaimer
# ─────────────────────────────────────────────────────────────────
# FOR EDUCATIONAL PURPOSES ONLY
#
# Arbitrage trading involves significant risks:
#   - Opportunities may disappear before execution
#   - Price data may be delayed or inaccurate
#   - Fees can exceed profits on small trades
#   - Market conditions change rapidly
#
# This tool provides analysis only. Always verify before trading.

#!/usr/bin/env python3
"""
Arbitrage Opportunity Finder - Main CLI Entry Point.

Scans for arbitrage opportunities across exchanges with:
- Direct spread detection (CEX-to-CEX, DEX-to-DEX)
- Triangular arbitrage path finding
- Profit calculation after all fees
- Real-time monitoring

Usage:
    python arb_finder.py scan ETH USDC
    python arb_finder.py scan ETH USDC --exchanges binance,coinbase,kraken
    python arb_finder.py triangular binance --min-profit 0.5
    python arb_finder.py monitor ETH USDC --threshold 0.5 --interval 5
    python arb_finder.py calc --buy-exchange binance --sell-exchange coinbase --pair ETH/USDC --amount 10
"""

import argparse
import sys
import time
from decimal import Decimal, InvalidOperation
from typing import Optional

from price_fetcher import PriceFetcher, ExchangeType
from opportunity_scanner import OpportunityScanner
from triangular_finder import TriangularFinder
from profit_calculator import ProfitCalculator
from formatters import ConsoleFormatter, JSONFormatter


def parse_args() -> argparse.Namespace:
    """Parse command line arguments."""
    parser = argparse.ArgumentParser(
        description="Arbitrage Opportunity Finder",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Scan for ETH/USDC arbitrage across all exchanges
  %(prog)s scan ETH USDC

  # Scan specific exchanges
  %(prog)s scan ETH USDC --exchanges binance,coinbase,kraken

  # Scan DEX only
  %(prog)s scan ETH USDC --dex-only

  # Find triangular arbitrage on Binance
  %(prog)s triangular binance --min-profit 0.1

  # Monitor for opportunities with alerts
  %(prog)s monitor ETH USDC --threshold 0.3 --interval 5

  # Calculate profit for specific trade
  %(prog)s calc --buy-exchange binance --sell-exchange coinbase --pair ETH/USDC --amount 10

Supported Exchanges:
  CEX: binance, coinbase, kraken, kucoin, okx
  DEX: uniswap, sushiswap, curve, balancer

EDUCATIONAL DISCLAIMER:
  This tool is for analysis and learning only.
  Arbitrage involves risks. Always verify data before trading.
""",
    )

    subparsers = parser.add_subparsers(dest="command", help="Command")

    # Scan subcommand
    scan_parser = subparsers.add_parser(
        "scan", help="Scan for direct arbitrage opportunities"
    )
    scan_parser.add_argument("base", help="Base token (e.g., ETH)")
    scan_parser.add_argument("quote", help="Quote token (e.g., USDC)")
    scan_parser.add_argument(
        "--exchanges",
        type=str,
        help="Comma-separated list of exchanges",
    )
    scan_parser.add_argument(
        "--cex-only",
        action="store_true",
        help="Only scan centralized exchanges",
    )
    scan_parser.add_argument(
        "--dex-only",
        action="store_true",
        help="Only scan decentralized exchanges",
    )
    scan_parser.add_argument(
        "--min-profit",
        type=float,
        default=0.0,
        help="Minimum profit percentage to show (default: 0.0)",
    )

    # Triangular subcommand
    tri_parser = subparsers.add_parser(
        "triangular", help="Find triangular arbitrage paths"
    )
    tri_parser.add_argument("exchange", help="Exchange to analyze")
    tri_parser.add_argument(
        "--min-profit",
        type=float,
        default=0.1,
        help="Minimum profit percentage (default: 0.1)",
    )

    # Monitor subcommand
    mon_parser = subparsers.add_parser(
        "monitor", help="Real-time opportunity monitoring"
    )
    mon_parser.add_argument("base", help="Base token (e.g., ETH)")
    mon_parser.add_argument("quote", help="Quote token (e.g., USDC)")
    mon_parser.add_argument(
        "--threshold",
        type=float,
        default=0.3,
        help="Alert threshold percentage (default: 0.3)",
    )
    mon_parser.add_argument(
        "--interval",
        type=int,
        default=5,
        help="Polling interval in seconds (default: 5)",
    )
    mon_parser.add_argument(
        "--exchanges",
        type=str,
        help="Comma-separated list of exchanges",
    )

    # Calc subcommand
    calc_parser = subparsers.add_parser(
        "calc", help="Calculate profit for specific trade"
    )
    calc_parser.add_argument(
        "--buy-exchange",
        required=True,
        help="Exchange to buy on",
    )
    calc_parser.add_argument(
        "--sell-exchange",
        required=True,
        help="Exchange to sell on",
    )
    calc_parser.add_argument(
        "--pair",
        required=True,
        help="Trading pair (e.g., ETH/USDC)",
    )
    calc_parser.add_argument(
        "--amount",
        type=str,
        required=True,
        help="Trade amount in base currency",
    )
    calc_parser.add_argument(
        "--buy-price",
        type=str,
        help="Buy price (fetched if not provided)",
    )
    calc_parser.add_argument(
        "--sell-price",
        type=str,
        help="Sell price (fetched if not provided)",
    )

    # Global options for all subcommands
    for sub in [scan_parser, tri_parser, mon_parser, calc_parser]:
        sub.add_argument(
            "--output",
            choices=["console", "json"],
            default="console",
            help="Output format (default: console)",
        )
        sub.add_argument(
            "--eth-price",
            type=float,
            default=2500.0,
            help="ETH price in USD (default: 2500)",
        )
        sub.add_argument(
            "--gas-price",
            type=float,
            default=30.0,
            help="Gas price in gwei (default: 30)",
        )

    return parser.parse_args()


def run_scan(args: argparse.Namespace) -> int:
    """Run direct arbitrage scan."""
    # Parse exchanges
    exchanges = None
    if args.exchanges:
        exchanges = [e.strip() for e in args.exchanges.split(",")]

    exchange_type = None
    if args.cex_only:
        exchange_type = ExchangeType.CEX
    elif args.dex_only:
        exchange_type = ExchangeType.DEX

    # Create scanner
    scanner = OpportunityScanner(
        min_profit_pct=args.min_profit,
        gas_price_gwei=args.gas_price,
        eth_price_usd=args.eth_price,
    )

    # Run scan
    result = scanner.scan(
        args.base.upper(),
        args.quote.upper(),
        exchanges,
        exchange_type,
    )

    # Format output
    if args.output == "json":
        fmt = JSONFormatter()
        print(fmt.format_scan_result(result))
    else:
        fmt = ConsoleFormatter()
        print(fmt.format_scan_result(result))

    # Return code based on findings
    return 0 if result.opportunities else 1


def run_triangular(args: argparse.Namespace) -> int:
    """Run triangular arbitrage finder."""
    finder = TriangularFinder(min_profit_pct=args.min_profit)

    # Find opportunities
    paths = finder.find_opportunities(args.exchange)

    # Format output
    if args.output == "json":
        fmt = JSONFormatter()
        print(fmt.format_triangular_results(paths))
    else:
        fmt = ConsoleFormatter()
        print(fmt.format_triangular_results(paths))

    return 0 if paths else 1


def run_monitor(args: argparse.Namespace) -> int:
    """Run real-time monitoring."""
    # Parse exchanges
    exchanges = None
    if args.exchanges:
        exchanges = [e.strip() for e in args.exchanges.split(",")]

    scanner = OpportunityScanner(
        min_profit_pct=args.threshold,
        gas_price_gwei=args.gas_price,
        eth_price_usd=args.eth_price,
    )

    console = ConsoleFormatter()

    print(f"Monitoring {args.base}/{args.quote} for spreads > {args.threshold}%")
    print(f"Interval: {args.interval}s | Press Ctrl+C to stop\n")

    iteration = 0
    try:
        while True:
            iteration += 1
            result = scanner.scan(
                args.base.upper(),
                args.quote.upper(),
                exchanges,
            )

            if result.best_opportunity:
                best = result.best_opportunity
                if best.net_spread_pct >= args.threshold:
                    print(console.format_alert(best))
                    print()
                else:
                    print(
                        f"[{iteration}] Best: {best.buy_exchange} → {best.sell_exchange} "
                        f"({best.net_spread_pct:+.3f}%) - below threshold"
                    )
            else:
                print(f"[{iteration}] No opportunities found")

            time.sleep(args.interval)

    except KeyboardInterrupt:
        print("\nMonitoring stopped")
        return 0


def run_calc(args: argparse.Namespace) -> int:
    """Run profit calculation."""
    try:
        amount = Decimal(args.amount)
    except InvalidOperation:
        print(f"Error: Invalid amount '{args.amount}'", file=sys.stderr)
        return 1

    # Parse pair
    if "/" in args.pair:
        base, quote = args.pair.split("/")
    else:
        print(f"Error: Invalid pair format '{args.pair}' (use BASE/QUOTE)", file=sys.stderr)
        return 1

    # Get prices if not provided
    fetcher = PriceFetcher(use_mock=True)

    if args.buy_price:
        buy_price = Decimal(args.buy_price)
    else:
        quote_obj = fetcher.fetch_all_prices_sync(base, quote, [args.buy_exchange])
        if quote_obj:
            buy_price = quote_obj[0].ask
        else:
            print(f"Error: Could not fetch price from {args.buy_exchange}", file=sys.stderr)
            return 1

    if args.sell_price:
        sell_price = Decimal(args.sell_price)
    else:
        quote_obj = fetcher.fetch_all_prices_sync(base, quote, [args.sell_exchange])
        if quote_obj:
            sell_price = quote_obj[0].bid
        else:
            print(f"Error: Could not fetch price from {args.sell_exchange}", file=sys.stderr)
            return 1

    # Calculate
    calc = ProfitCalculator(
        gas_price_gwei=args.gas_price,
        eth_price_usd=args.eth_price,
    )

    breakdown = calc.calculate(
        pair=args.pair,
        buy_exchange=args.buy_exchange,
        sell_exchange=args.sell_exchange,
        buy_price=buy_price,
        sell_price=sell_price,
        amount=amount,
    )

    # Format output
    if args.output == "json":
        fmt = JSONFormatter()
        print(fmt.format_profit_breakdown(breakdown))
    else:
        fmt = ConsoleFormatter()
        print(fmt.format_profit_breakdown(breakdown))

    return 0 if breakdown.is_profitable else 1


def print_banner():
    """Print startup banner."""
    banner = """
╔══════════════════════════════════════════════════════════════════╗
║            ARBITRAGE OPPORTUNITY FINDER v1.0.0                  ║
║                                                                  ║
║  Find profitable arbitrage across CEX, DEX, and cross-chain    ║
║  Exchanges: Binance | Coinbase | Kraken | Uniswap | SushiSwap  ║
║                                                                  ║
║  ⚠️  EDUCATIONAL PURPOSES ONLY - Verify before trading          ║
╚══════════════════════════════════════════════════════════════════╝
"""
    print(banner, file=sys.stderr)


def main() -> int:
    """Main entry point."""
    args = parse_args()

    if not args.command:
        print_banner()
        print("Use --help for usage information", file=sys.stderr)
        print("\nQuick start:")
        print("  arb_finder.py scan ETH USDC")
        print("  arb_finder.py triangular binance")
        print("  arb_finder.py monitor ETH USDC --threshold 0.3")
        return 1

    # Run appropriate command
    if args.command == "scan":
        return run_scan(args)
    elif args.command == "triangular":
        return run_triangular(args)
    elif args.command == "monitor":
        return run_monitor(args)
    elif args.command == "calc":
        return run_calc(args)
    else:
        print(f"Unknown command: {args.command}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
Arbitrage opportunity output formatters.

Handles all output formatting:
- Console tables and reports
- JSON export
- Alert messages
"""

import json
from dataclasses import asdict
from decimal import Decimal
from typing import Any, Dict, List, Optional

from opportunity_scanner import ArbitrageOpportunity, ScanResult, RiskLevel
from triangular_finder import ArbitragePath
from profit_calculator import ProfitBreakdown


class DecimalEncoder(json.JSONEncoder):
    """JSON encoder that handles Decimal types."""

    def default(self, obj):
        if isinstance(obj, Decimal):
            return float(obj)
        if hasattr(obj, "value"):  # Enum
            return obj.value
        return super().default(obj)


class ConsoleFormatter:
    """Format output for console display."""

    # Risk level indicators
    RISK_INDICATORS = {
        RiskLevel.LOW: ("🟢", "LOW"),
        RiskLevel.MEDIUM: ("🟡", "MEDIUM"),
        RiskLevel.HIGH: ("🟠", "HIGH"),
        RiskLevel.EXTREME: ("🔴", "EXTREME"),
    }

    def __init__(self, width: int = 70):
        """Initialize formatter with display width."""
        self.width = width

    def _header(self, title: str) -> str:
        """Create a section header."""
        padding = (self.width - len(title) - 2) // 2
        return f"\n{'=' * padding} {title} {'=' * padding}\n"

    def _subheader(self, title: str) -> str:
        """Create a subsection header."""
        return f"\n{'-' * self.width}\n{title}\n{'-' * self.width}\n"

    def format_scan_result(self, result: ScanResult) -> str:
        """Format a scan result with all opportunities."""
        lines = []

        lines.append(self._header("ARBITRAGE SCAN RESULTS"))

        # Summary
        lines.append(f"Pair: {result.pair}")
        lines.append(f"Exchanges scanned: {len(result.quotes)}")
        lines.append(f"Opportunities found: {len(result.opportunities)}")

        if not result.opportunities:
            lines.append("\nNo profitable opportunities found (market is efficient)")
            return "\n".join(lines)

        # Price table
        lines.append(self._subheader("CURRENT PRICES"))
        lines.append(f"{'Exchange':<15} {'Bid':>12} {'Ask':>12} {'Spread':>8}")
        lines.append("-" * 50)

        for quote in sorted(result.quotes, key=lambda x: x.bid, reverse=True):
            lines.append(
                f"{quote.exchange:<15} "
                f"${quote.bid:>11,.2f} "
                f"${quote.ask:>11,.2f} "
                f"{quote.spread_pct:>7.3f}%"
            )

        # Opportunities table
        lines.append(self._subheader("OPPORTUNITIES"))
        lines.append(
            f"{'Buy On':<15} {'Sell On':<15} {'Gross':>8} {'Net':>8} {'Risk':<8}"
        )
        lines.append("-" * 60)

        for opp in result.opportunities[:10]:
            indicator = "+" if opp.is_profitable else "-"
            risk_icon, _ = self.RISK_INDICATORS.get(opp.risk_level, ("⚪", "?"))
            lines.append(
                f"{opp.buy_exchange:<15} "
                f"{opp.sell_exchange:<15} "
                f"{indicator}{opp.gross_spread_pct:>6.3f}% "
                f"{indicator}{opp.net_spread_pct:>6.3f}% "
                f"{risk_icon} {opp.risk_level.value:<6}"
            )

        # Best opportunity details
        if result.best_opportunity:
            lines.append(self._subheader("BEST OPPORTUNITY"))
            lines.append(self.format_opportunity_details(result.best_opportunity))

        return "\n".join(lines)

    def format_opportunity_details(self, opp: ArbitrageOpportunity) -> str:
        """Format detailed view of a single opportunity."""
        lines = []

        risk_icon, risk_label = self.RISK_INDICATORS.get(
            opp.risk_level, ("⚪", "UNKNOWN")
        )

        lines.append(f"Buy on {opp.buy_exchange} at ${opp.buy_price:,.2f}")
        lines.append(f"Sell on {opp.sell_exchange} at ${opp.sell_price:,.2f}")
        lines.append("")
        lines.append(f"Gross spread: {opp.gross_spread_pct:+.4f}%")
        lines.append(f"Buy fee: -{opp.buy_fee_pct:.2f}%")
        lines.append(f"Sell fee: -{opp.sell_fee_pct:.2f}%")
        if opp.estimated_gas_usd > 0:
            lines.append(f"Gas cost: ~${opp.estimated_gas_usd:.2f}")
        lines.append("-" * 40)
        lines.append(f"Net spread: {opp.net_spread_pct:+.4f}%")
        lines.append(f"Risk: {risk_icon} {risk_label}")

        if opp.notes:
            lines.append("")
            lines.append("Notes:")
            for note in opp.notes:
                lines.append(f"  • {note}")

        if opp.is_profitable:
            lines.append("")
            lines.append("✓ PROFITABLE - Consider execution")
        else:
            lines.append("")
            lines.append("✗ NOT PROFITABLE after fees")

        return "\n".join(lines)

    def format_triangular_results(self, paths: List[ArbitragePath]) -> str:
        """Format triangular arbitrage results."""
        lines = []

        lines.append(self._header("TRIANGULAR ARBITRAGE"))

        if not paths:
            lines.append("No profitable triangular paths found")
            return "\n".join(lines)

        lines.append(f"Found {len(paths)} paths\n")

        lines.append(f"{'Path':<30} {'Gross':>10} {'Fees':>10} {'Net':>10}")
        lines.append("-" * 65)

        for path in paths[:10]:
            path_str = " → ".join(path.tokens)
            indicator = "+" if path.is_profitable else "-"
            lines.append(
                f"{path_str:<30} "
                f"{indicator}{abs(path.gross_profit_pct):>8.4f}% "
                f"-{path.total_fees_pct:>8.4f}% "
                f"{indicator}{abs(path.net_profit_pct):>8.4f}%"
            )

        # Best path details
        if paths:
            best = paths[0]
            lines.append(self._subheader("BEST PATH"))
            lines.append(f"Path: {' → '.join(best.tokens)}")
            lines.append(f"Exchange: {best.exchange}")
            lines.append("")
            lines.append("Execution Steps:")
            for i, step in enumerate(best.execution_steps, 1):
                lines.append(f"  {i}. {step}")
            lines.append("")
            lines.append(f"Gross Profit: {best.gross_profit_pct:+.4f}%")
            lines.append(f"Total Fees: -{best.total_fees_pct:.4f}%")
            lines.append(f"Net Profit: {best.net_profit_pct:+.4f}%")

        return "\n".join(lines)

    def format_profit_breakdown(self, breakdown: ProfitBreakdown) -> str:
        """Format profit breakdown."""
        lines = []

        lines.append(self._header("PROFIT BREAKDOWN"))

        lines.append(f"Trade: {breakdown.trade_amount} {breakdown.pair.split('/')[0]}")
        lines.append(f"Buy on {breakdown.buy_exchange} at ${breakdown.buy_price:,.2f}")
        lines.append(f"Sell on {breakdown.sell_exchange} at ${breakdown.sell_price:,.2f}")

        lines.append("")
        lines.append(f"Gross Profit: ${breakdown.gross_profit:,.2f} ({breakdown.gross_profit_pct:+.3f}%)")

        lines.append("")
        lines.append("Costs:")
        lines.append(f"  Buy fee:        -${breakdown.buy_fee:,.2f}")
        lines.append(f"  Sell fee:       -${breakdown.sell_fee:,.2f}")
        lines.append(f"  Withdrawal:     -${breakdown.withdrawal_fee:,.2f}")
        lines.append(f"  Gas:            -${breakdown.gas_cost_usd:,.2f}")
        lines.append(f"  Slippage:       -${breakdown.slippage_cost:,.2f}")
        lines.append(f"  {'-' * 30}")
        lines.append(f"  Total:          -${breakdown.total_costs:,.2f}")

        lines.append("")
        lines.append(f"Net Profit: ${breakdown.net_profit:,.2f} ({breakdown.net_profit_pct:+.3f}%)")
        lines.append(f"Breakeven spread: {breakdown.breakeven_spread_pct:.3f}%")

        if breakdown.is_profitable:
            lines.append("\n✓ PROFITABLE")
        else:
            lines.append("\n✗ NOT PROFITABLE")

        return "\n".join(lines)

    def format_alert(
        self,
        opp: ArbitrageOpportunity,
        trade_amount: Optional[Decimal] = None,
    ) -> str:
        """Format an alert message for a detected opportunity."""
        lines = []

        lines.append("=" * 60)
        lines.append("🚨 ARBITRAGE ALERT")
        lines.append("=" * 60)
        lines.append("")
        lines.append(f"{opp.pair} spread {opp.net_spread_pct:+.3f}%")
        lines.append(f"Buy on {opp.buy_exchange} at ${opp.buy_price:,.2f}")
        lines.append(f"Sell on {opp.sell_exchange} at ${opp.sell_price:,.2f}")

        if trade_amount:
            profit = opp.profit_for_amount(trade_amount)
            lines.append(f"")
            lines.append(f"For {trade_amount} units:")
            lines.append(f"Estimated profit: ${profit:,.2f}")

        risk_icon, risk_label = self.RISK_INDICATORS.get(
            opp.risk_level, ("⚪", "?")
        )
        lines.append("")
        lines.append(f"Risk: {risk_icon} {risk_label}")

        return "\n".join(lines)


class JSONFormatter:
    """Format output as JSON."""

    def format_scan_result(self, result: ScanResult) -> str:
        """Format scan result as JSON."""
        data = {
            "pair": result.pair,
            "timestamp": result.timestamp,
            "quotes_count": len(result.quotes),
            "opportunities_count": len(result.opportunities),
            "quotes": [
                {
                    "exchange": q.exchange,
                    "exchange_type": q.exchange_type.value,
                    "bid": float(q.bid),
                    "ask": float(q.ask),
                    "spread_pct": q.spread_pct,
                    "volume_24h": float(q.volume_24h),
                }
                for q in result.quotes
            ],
            "opportunities": [
                {
                    "buy_exchange": o.buy_exchange,
                    "sell_exchange": o.sell_exchange,
                    "buy_price": float(o.buy_price),
                    "sell_price": float(o.sell_price),
                    "gross_spread_pct": o.gross_spread_pct,
                    "net_spread_pct": o.net_spread_pct,
                    "risk_level": o.risk_level.value,
                    "is_profitable": o.is_profitable,
                }
                for o in result.opportunities
            ],
            "best_opportunity": None,
        }

        if result.best_opportunity:
            o = result.best_opportunity
            data["best_opportunity"] = {
                "buy_exchange": o.buy_exchange,
                "sell_exchange": o.sell_exchange,
                "buy_price": float(o.buy_price),
                "sell_price": float(o.sell_price),
                "net_spread_pct": o.net_spread_pct,
                "risk_level": o.risk_level.value,
            }

        return json.dumps(data, indent=2, cls=DecimalEncoder)

    def format_triangular_results(self, paths: List[ArbitragePath]) -> str:
        """Format triangular results as JSON."""
        data = {
            "paths_count": len(paths),
            "paths": [
                {
                    "tokens": p.tokens,
                    "exchange": p.exchange,
                    "gross_profit_pct": p.gross_profit_pct,
                    "total_fees_pct": p.total_fees_pct,
                    "net_profit_pct": p.net_profit_pct,
                    "is_profitable": p.is_profitable,
                    "steps": p.execution_steps,
                }
                for p in paths
            ],
        }
        return json.dumps(data, indent=2, cls=DecimalEncoder)

    def format_profit_breakdown(self, breakdown: ProfitBreakdown) -> str:
        """Format profit breakdown as JSON."""
        data = {
            "pair": breakdown.pair,
            "buy_exchange": breakdown.buy_exchange,
            "sell_exchange": breakdown.sell_exchange,
            "trade_amount": float(breakdown.trade_amount),
            "buy_price": float(breakdown.buy_price),
            "sell_price": float(breakdown.sell_price),
            "gross_profit": float(breakdown.gross_profit),
            "gross_profit_pct": breakdown.gross_profit_pct,
            "costs": {
                "buy_fee": float(breakdown.buy_fee),
                "sell_fee": float(breakdown.sell_fee),
                "withdrawal_fee": float(breakdown.withdrawal_fee),
                "gas_cost_usd": float(breakdown.gas_cost_usd),
                "slippage_cost": float(breakdown.slippage_cost),
                "total": float(breakdown.total_costs),
            },
            "net_profit": float(breakdown.net_profit),
            "net_profit_pct": breakdown.net_profit_pct,
            "net_profit_usd": float(breakdown.net_profit_usd),
            "breakeven_spread_pct": breakdown.breakeven_spread_pct,
            "is_profitable": breakdown.is_profitable,
        }
        return json.dumps(data, indent=2, cls=DecimalEncoder)


def demo():
    """Demonstrate formatters."""
    from opportunity_scanner import OpportunityScanner

    # Run a scan
    scanner = OpportunityScanner(min_profit_pct=0.0)
    result = scanner.scan("ETH", "USDC")

    # Console format
    console = ConsoleFormatter()
    print(console.format_scan_result(result))

    # JSON format
    print("\n" + "=" * 70)
    print("JSON OUTPUT")
    print("=" * 70)
    json_fmt = JSONFormatter()
    print(json_fmt.format_scan_result(result))


if __name__ == "__main__":
    demo()

#!/usr/bin/env python3
"""
Arbitrage opportunity scanner.

Detects direct arbitrage opportunities (buy low, sell high)
across multiple exchanges with profit calculation.
"""

from dataclasses import dataclass
from decimal import Decimal
from enum import Enum
from typing import List, Optional, Tuple

from price_fetcher import PriceFetcher, PriceQuote, ExchangeType, ExchangeConfig


class OpportunityType(Enum):
    """Type of arbitrage opportunity."""
    DIRECT = "DIRECT"  # Buy on A, sell on B
    TRIANGULAR = "TRIANGULAR"  # A→B→C→A circular
    CROSS_CHAIN = "CROSS_CHAIN"  # Same asset across chains


class RiskLevel(Enum):
    """Risk level classification."""
    LOW = "LOW"
    MEDIUM = "MEDIUM"
    HIGH = "HIGH"
    EXTREME = "EXTREME"


@dataclass
class ArbitrageOpportunity:
    """Represents a single arbitrage opportunity."""

    opportunity_type: OpportunityType
    pair: str
    buy_exchange: str
    sell_exchange: str
    buy_price: Decimal
    sell_price: Decimal
    gross_spread_pct: float
    net_spread_pct: float
    gross_profit_per_unit: Decimal
    net_profit_per_unit: Decimal
    buy_fee_pct: float
    sell_fee_pct: float
    estimated_gas_usd: float  # For DEX
    risk_level: RiskLevel
    notes: List[str]
    buy_exchange_type: ExchangeType
    sell_exchange_type: ExchangeType

    @property
    def is_profitable(self) -> bool:
        """Check if opportunity is profitable after fees."""
        return self.net_profit_per_unit > 0

    def profit_for_amount(self, amount: Decimal) -> Decimal:
        """Calculate profit for a specific trade amount."""
        return amount * self.net_profit_per_unit / self.buy_price


@dataclass
class ScanResult:
    """Result of an arbitrage scan."""

    pair: str
    quotes: List[PriceQuote]
    opportunities: List[ArbitrageOpportunity]
    best_opportunity: Optional[ArbitrageOpportunity]
    timestamp: float


class OpportunityScanner:
    """
    Scans for arbitrage opportunities across exchanges.

    Features:
    - Direct spread detection (CEX-to-CEX, DEX-to-DEX, CEX-to-DEX)
    - Fee-aware profit calculation
    - Risk assessment
    """

    def __init__(
        self,
        fetcher: Optional[PriceFetcher] = None,
        min_profit_pct: float = 0.1,  # Minimum 0.1% profit
        gas_price_gwei: float = 30.0,
        eth_price_usd: float = 2500.0,
    ):
        """
        Initialize scanner.

        Args:
            fetcher: Price fetcher instance
            min_profit_pct: Minimum net profit percentage to report
            gas_price_gwei: Current gas price in gwei
            eth_price_usd: Current ETH price
        """
        self.fetcher = fetcher or PriceFetcher(use_mock=True)
        self.min_profit_pct = min_profit_pct
        self.gas_price_gwei = gas_price_gwei
        self.eth_price_usd = eth_price_usd

    def scan(
        self,
        base: str,
        quote: str,
        exchanges: Optional[List[str]] = None,
        exchange_type: Optional[ExchangeType] = None,
    ) -> ScanResult:
        """
        Scan for arbitrage opportunities on a pair.

        Args:
            base: Base token (e.g., ETH)
            quote: Quote token (e.g., USDC)
            exchanges: Specific exchanges to scan
            exchange_type: Filter by CEX or DEX

        Returns:
            ScanResult with all opportunities
        """
        import time

        # Fetch all prices
        quotes = self.fetcher.fetch_all_prices_sync(
            base, quote, exchanges, exchange_type
        )

        if len(quotes) < 2:
            return ScanResult(
                pair=f"{base}/{quote}",
                quotes=quotes,
                opportunities=[],
                best_opportunity=None,
                timestamp=time.time(),
            )

        # Find all opportunities
        opportunities = []

        for buy_quote in quotes:
            for sell_quote in quotes:
                if buy_quote.exchange == sell_quote.exchange:
                    continue

                opp = self._evaluate_opportunity(buy_quote, sell_quote)
                if opp and opp.net_spread_pct >= self.min_profit_pct:
                    opportunities.append(opp)

        # Sort by net profit
        opportunities.sort(key=lambda x: x.net_spread_pct, reverse=True)

        return ScanResult(
            pair=f"{base}/{quote}",
            quotes=quotes,
            opportunities=opportunities,
            best_opportunity=opportunities[0] if opportunities else None,
            timestamp=time.time(),
        )

    def _evaluate_opportunity(
        self,
        buy_quote: PriceQuote,
        sell_quote: PriceQuote,
    ) -> Optional[ArbitrageOpportunity]:
        """
        Evaluate a potential arbitrage opportunity.

        Args:
            buy_quote: Quote from buy exchange (use ask price)
            sell_quote: Quote from sell exchange (use bid price)

        Returns:
            ArbitrageOpportunity or None if not profitable
        """
        # Check basic profitability (sell price > buy price)
        if sell_quote.bid <= buy_quote.ask:
            return None

        # Get exchange configs
        buy_config = self.fetcher.get_exchange_config(
            buy_quote.exchange.lower().replace(" ", "").replace("v3", "")
        )
        sell_config = self.fetcher.get_exchange_config(
            sell_quote.exchange.lower().replace(" ", "").replace("v3", "")
        )

        # Default fees if config not found
        buy_fee = buy_config.taker_fee if buy_config else Decimal("0.001")
        sell_fee = sell_config.taker_fee if sell_config else Decimal("0.001")

        # Calculate gross spread
        gross_profit = sell_quote.bid - buy_quote.ask
        gross_spread_pct = float(gross_profit / buy_quote.ask * 100)

        # Calculate fees
        buy_fee_amount = buy_quote.ask * buy_fee
        sell_fee_amount = sell_quote.bid * sell_fee
        total_fees = buy_fee_amount + sell_fee_amount

        # Calculate gas costs (for DEX)
        gas_cost_usd = 0.0
        if buy_quote.exchange_type == ExchangeType.DEX:
            gas_units = buy_config.gas_overhead if buy_config else 150000
            gas_cost_usd += gas_units * self.gas_price_gwei * 1e-9 * self.eth_price_usd
        if sell_quote.exchange_type == ExchangeType.DEX:
            gas_units = sell_config.gas_overhead if sell_config else 150000
            gas_cost_usd += gas_units * self.gas_price_gwei * 1e-9 * self.eth_price_usd

        # Calculate net profit
        net_profit = gross_profit - total_fees
        net_spread_pct = float(net_profit / buy_quote.ask * 100)

        # Assess risk
        risk_level = self._assess_risk(buy_quote, sell_quote, net_spread_pct)

        # Generate notes
        notes = []
        if not buy_quote.is_fresh or not sell_quote.is_fresh:
            notes.append("Warning: Price data may be stale")
        if buy_quote.exchange_type == ExchangeType.DEX:
            notes.append(f"Buy requires on-chain tx (~${gas_cost_usd:.2f} gas)")
        if sell_quote.exchange_type == ExchangeType.DEX:
            notes.append(f"Sell requires on-chain tx")
        if gross_spread_pct > 2.0:
            notes.append("Large spread may indicate low liquidity or stale data")

        return ArbitrageOpportunity(
            opportunity_type=OpportunityType.DIRECT,
            pair=buy_quote.pair,
            buy_exchange=buy_quote.exchange,
            sell_exchange=sell_quote.exchange,
            buy_price=buy_quote.ask,
            sell_price=sell_quote.bid,
            gross_spread_pct=gross_spread_pct,
            net_spread_pct=net_spread_pct,
            gross_profit_per_unit=gross_profit,
            net_profit_per_unit=net_profit,
            buy_fee_pct=float(buy_fee) * 100,
            sell_fee_pct=float(sell_fee) * 100,
            estimated_gas_usd=gas_cost_usd,
            risk_level=risk_level,
            notes=notes,
            buy_exchange_type=buy_quote.exchange_type,
            sell_exchange_type=sell_quote.exchange_type,
        )

    def _assess_risk(
        self,
        buy_quote: PriceQuote,
        sell_quote: PriceQuote,
        net_spread_pct: float,
    ) -> RiskLevel:
        """Assess risk level of an opportunity."""
        risk_score = 0

        # Staleness
        if buy_quote.staleness_seconds > 10:
            risk_score += 2
        if sell_quote.staleness_seconds > 10:
            risk_score += 2

        # Spread size (very large spreads are suspicious)
        if net_spread_pct > 5.0:
            risk_score += 3
        elif net_spread_pct > 2.0:
            risk_score += 1

        # DEX involvement (execution uncertainty)
        if buy_quote.exchange_type == ExchangeType.DEX:
            risk_score += 1
        if sell_quote.exchange_type == ExchangeType.DEX:
            risk_score += 1

        # Volume (low volume = slippage risk)
        min_volume = min(buy_quote.volume_24h, sell_quote.volume_24h)
        if min_volume < Decimal("1000"):
            risk_score += 2
        elif min_volume < Decimal("10000"):
            risk_score += 1

        # Map to risk level
        if risk_score <= 1:
            return RiskLevel.LOW
        elif risk_score <= 3:
            return RiskLevel.MEDIUM
        elif risk_score <= 5:
            return RiskLevel.HIGH
        else:
            return RiskLevel.EXTREME

    def scan_multiple_pairs(
        self,
        pairs: List[Tuple[str, str]],
        exchanges: Optional[List[str]] = None,
    ) -> List[ScanResult]:
        """Scan multiple pairs for opportunities."""
        results = []
        for base, quote in pairs:
            result = self.scan(base, quote, exchanges)
            results.append(result)
        return results


def demo():
    """Demonstrate opportunity scanner."""
    scanner = OpportunityScanner(min_profit_pct=0.0)  # Show all

    print("=" * 70)
    print("ARBITRAGE OPPORTUNITY SCANNER")
    print("=" * 70)

    # Scan ETH/USDC
    result = scanner.scan("ETH", "USDC")

    print(f"\nScanned {len(result.quotes)} exchanges for ETH/USDC")
    print(f"Found {len(result.opportunities)} opportunities\n")

    if result.opportunities:
        print(f"{'Buy On':<15} {'Sell On':<15} {'Gross':>8} {'Net':>8} {'Risk':<8}")
        print("-" * 70)

        for opp in result.opportunities[:10]:
            profit_color = "+" if opp.is_profitable else "-"
            print(
                f"{opp.buy_exchange:<15} "
                f"{opp.sell_exchange:<15} "
                f"{profit_color}{opp.gross_spread_pct:>6.3f}% "
                f"{profit_color}{opp.net_spread_pct:>6.3f}% "
                f"{opp.risk_level.value:<8}"
            )

        if result.best_opportunity:
            best = result.best_opportunity
            print(f"\nBest Opportunity:")
            print(f"  Buy on {best.buy_exchange} at ${best.buy_price:,.2f}")
            print(f"  Sell on {best.sell_exchange} at ${best.sell_price:,.2f}")
            print(f"  Gross spread: {best.gross_spread_pct:.3f}%")
            print(f"  Net spread: {best.net_spread_pct:.3f}%")
            print(f"  Buy fee: {best.buy_fee_pct:.2f}%")
            print(f"  Sell fee: {best.sell_fee_pct:.2f}%")
            if best.notes:
                print(f"  Notes: {'; '.join(best.notes)}")
    else:
        print("No profitable opportunities found (market is efficient)")


if __name__ == "__main__":
    demo()

#!/usr/bin/env python3
"""
Multi-source price aggregation for arbitrage detection.

Fetches prices from:
- CoinGecko (free, aggregated)
- DEX subgraphs (Uniswap, SushiSwap)
- Mock exchange data (for simulation)
"""

import asyncio
import time
from dataclasses import dataclass, field
from decimal import Decimal
from enum import Enum
from typing import Dict, List, Optional, Tuple

import httpx


class ExchangeType(Enum):
    """Exchange type classification."""
    CEX = "CEX"
    DEX = "DEX"


@dataclass
class PriceQuote:
    """Price quote from a single source."""

    exchange: str
    exchange_type: ExchangeType
    pair: str
    bid: Decimal  # Best buy price (you sell at this)
    ask: Decimal  # Best sell price (you buy at this)
    mid: Decimal  # Mid-market price
    spread_pct: float  # Bid-ask spread percentage
    volume_24h: Decimal  # 24h volume in base currency
    timestamp: float  # Unix timestamp
    chain: str = "ethereum"  # For DEX

    @property
    def is_fresh(self) -> bool:
        """Check if quote is fresh (< 30 seconds old)."""
        return (time.time() - self.timestamp) < 30

    @property
    def staleness_seconds(self) -> float:
        """Get quote age in seconds."""
        return time.time() - self.timestamp


@dataclass
class ExchangeConfig:
    """Configuration for an exchange."""

    name: str
    exchange_type: ExchangeType
    maker_fee: Decimal
    taker_fee: Decimal
    withdrawal_fee: Decimal = Decimal("0")  # Per withdrawal
    gas_overhead: int = 0  # For DEX
    chains: List[str] = field(default_factory=lambda: ["ethereum"])


class PriceFetcher:
    """
    Multi-source price fetcher.

    Aggregates prices from CEX and DEX sources with:
    - Rate limiting
    - Timeout handling
    - Source reliability tracking
    """

    # CEX fee structures (as of 2024)
    CEX_CONFIGS = {
        "binance": ExchangeConfig(
            name="Binance",
            exchange_type=ExchangeType.CEX,
            maker_fee=Decimal("0.0010"),  # 0.10%
            taker_fee=Decimal("0.0010"),
        ),
        "coinbase": ExchangeConfig(
            name="Coinbase",
            exchange_type=ExchangeType.CEX,
            maker_fee=Decimal("0.0040"),  # 0.40%
            taker_fee=Decimal("0.0060"),  # 0.60%
        ),
        "kraken": ExchangeConfig(
            name="Kraken",
            exchange_type=ExchangeType.CEX,
            maker_fee=Decimal("0.0016"),  # 0.16%
            taker_fee=Decimal("0.0026"),  # 0.26%
        ),
        "kucoin": ExchangeConfig(
            name="KuCoin",
            exchange_type=ExchangeType.CEX,
            maker_fee=Decimal("0.0010"),
            taker_fee=Decimal("0.0010"),
        ),
        "okx": ExchangeConfig(
            name="OKX",
            exchange_type=ExchangeType.CEX,
            maker_fee=Decimal("0.0008"),  # 0.08%
            taker_fee=Decimal("0.0010"),
        ),
    }

    # DEX fee structures
    DEX_CONFIGS = {
        "uniswap": ExchangeConfig(
            name="Uniswap V3",
            exchange_type=ExchangeType.DEX,
            maker_fee=Decimal("0.0030"),  # 0.30% (most common tier)
            taker_fee=Decimal("0.0030"),
            gas_overhead=150000,
            chains=["ethereum", "polygon", "arbitrum", "optimism"],
        ),
        "sushiswap": ExchangeConfig(
            name="SushiSwap",
            exchange_type=ExchangeType.DEX,
            maker_fee=Decimal("0.0030"),
            taker_fee=Decimal("0.0030"),
            gas_overhead=150000,
            chains=["ethereum", "polygon", "arbitrum"],
        ),
        "curve": ExchangeConfig(
            name="Curve",
            exchange_type=ExchangeType.DEX,
            maker_fee=Decimal("0.0004"),  # 0.04%
            taker_fee=Decimal("0.0004"),
            gas_overhead=200000,
            chains=["ethereum", "polygon", "arbitrum"],
        ),
        "balancer": ExchangeConfig(
            name="Balancer",
            exchange_type=ExchangeType.DEX,
            maker_fee=Decimal("0.0010"),  # Varies by pool
            taker_fee=Decimal("0.0010"),
            gas_overhead=180000,
            chains=["ethereum", "polygon", "arbitrum"],
        ),
    }

    # Mock prices for simulation (simulate real market spreads)
    MOCK_PRICES = {
        ("ETH", "USDC"): {
            "binance": {"bid": 2541.20, "ask": 2541.50, "volume": 125000},
            "coinbase": {"bid": 2543.80, "ask": 2544.10, "volume": 45000},
            "kraken": {"bid": 2542.50, "ask": 2543.00, "volume": 35000},
            "kucoin": {"bid": 2540.90, "ask": 2541.40, "volume": 28000},
            "okx": {"bid": 2541.00, "ask": 2541.60, "volume": 52000},
            "uniswap": {"bid": 2542.10, "ask": 2542.80, "volume": 85000},
            "sushiswap": {"bid": 2540.50, "ask": 2541.30, "volume": 22000},
        },
        ("BTC", "USDC"): {
            "binance": {"bid": 67850.00, "ask": 67865.00, "volume": 4500},
            "coinbase": {"bid": 67920.00, "ask": 67950.00, "volume": 2100},
            "kraken": {"bid": 67880.00, "ask": 67910.00, "volume": 1800},
            "kucoin": {"bid": 67840.00, "ask": 67870.00, "volume": 1200},
            "okx": {"bid": 67855.00, "ask": 67880.00, "volume": 3200},
            "uniswap": {"bid": 67870.00, "ask": 67920.00, "volume": 950},
        },
        ("ETH", "BTC"): {
            "binance": {"bid": 0.03745, "ask": 0.03748, "volume": 8500},
            "coinbase": {"bid": 0.03752, "ask": 0.03756, "volume": 3200},
            "kraken": {"bid": 0.03748, "ask": 0.03752, "volume": 2100},
            "kucoin": {"bid": 0.03744, "ask": 0.03749, "volume": 1800},
            "okx": {"bid": 0.03746, "ask": 0.03750, "volume": 4100},
        },
        ("USDC", "USDT"): {
            "binance": {"bid": 0.9998, "ask": 1.0002, "volume": 500000},
            "coinbase": {"bid": 0.9997, "ask": 1.0003, "volume": 120000},
            "curve": {"bid": 0.99995, "ask": 1.00005, "volume": 2500000},
        },
    }

    def __init__(self, use_mock: bool = True, timeout: float = 10.0):
        """
        Initialize price fetcher.

        Args:
            use_mock: Use mock data instead of live APIs
            timeout: Request timeout in seconds
        """
        self.use_mock = use_mock
        self.timeout = timeout
        self.client = httpx.AsyncClient(timeout=timeout)

    def get_exchange_config(self, exchange: str) -> Optional[ExchangeConfig]:
        """Get exchange configuration."""
        exchange_lower = exchange.lower()
        if exchange_lower in self.CEX_CONFIGS:
            return self.CEX_CONFIGS[exchange_lower]
        if exchange_lower in self.DEX_CONFIGS:
            return self.DEX_CONFIGS[exchange_lower]
        return None

    def list_exchanges(self, exchange_type: Optional[ExchangeType] = None) -> List[str]:
        """List available exchanges."""
        result = []
        if exchange_type is None or exchange_type == ExchangeType.CEX:
            result.extend(self.CEX_CONFIGS.keys())
        if exchange_type is None or exchange_type == ExchangeType.DEX:
            result.extend(self.DEX_CONFIGS.keys())
        return result

    async def fetch_price(
        self,
        base: str,
        quote: str,
        exchange: str,
    ) -> Optional[PriceQuote]:
        """
        Fetch price from a single exchange.

        Args:
            base: Base token (e.g., ETH)
            quote: Quote token (e.g., USDC)
            exchange: Exchange name

        Returns:
            PriceQuote or None if unavailable
        """
        if self.use_mock:
            return self._get_mock_price(base, quote, exchange)

        # Real API integration would go here
        # For now, fall back to mock
        return self._get_mock_price(base, quote, exchange)

    def _get_mock_price(
        self,
        base: str,
        quote: str,
        exchange: str,
    ) -> Optional[PriceQuote]:
        """Get mock price data."""
        pair_key = (base.upper(), quote.upper())
        exchange_lower = exchange.lower()

        # Try direct pair
        if pair_key in self.MOCK_PRICES:
            prices = self.MOCK_PRICES[pair_key]
            if exchange_lower in prices:
                data = prices[exchange_lower]
                return self._build_quote(base, quote, exchange_lower, data)

        # Try inverse pair
        inverse_key = (quote.upper(), base.upper())
        if inverse_key in self.MOCK_PRICES:
            prices = self.MOCK_PRICES[inverse_key]
            if exchange_lower in prices:
                data = prices[exchange_lower]
                # Invert prices
                inverted = {
                    "bid": 1.0 / data["ask"],
                    "ask": 1.0 / data["bid"],
                    "volume": data["volume"],
                }
                return self._build_quote(base, quote, exchange_lower, inverted)

        return None

    def _build_quote(
        self,
        base: str,
        quote: str,
        exchange: str,
        data: dict,
    ) -> PriceQuote:
        """Build PriceQuote from raw data."""
        config = self.get_exchange_config(exchange)

        bid = Decimal(str(data["bid"]))
        ask = Decimal(str(data["ask"]))
        mid = (bid + ask) / 2
        spread_pct = float((ask - bid) / mid * 100)

        return PriceQuote(
            exchange=config.name if config else exchange,
            exchange_type=config.exchange_type if config else ExchangeType.CEX,
            pair=f"{base}/{quote}",
            bid=bid,
            ask=ask,
            mid=mid,
            spread_pct=spread_pct,
            volume_24h=Decimal(str(data["volume"])),
            timestamp=time.time(),
            chain="ethereum",
        )

    async def fetch_all_prices(
        self,
        base: str,
        quote: str,
        exchanges: Optional[List[str]] = None,
        exchange_type: Optional[ExchangeType] = None,
    ) -> List[PriceQuote]:
        """
        Fetch prices from multiple exchanges.

        Args:
            base: Base token
            quote: Quote token
            exchanges: Specific exchanges (default: all)
            exchange_type: Filter by CEX or DEX

        Returns:
            List of PriceQuote objects
        """
        if exchanges is None:
            exchanges = self.list_exchanges(exchange_type)

        # Fetch concurrently
        tasks = [
            self.fetch_price(base, quote, ex)
            for ex in exchanges
        ]
        results = await asyncio.gather(*tasks)

        # Filter None results
        return [r for r in results if r is not None]

    def fetch_all_prices_sync(
        self,
        base: str,
        quote: str,
        exchanges: Optional[List[str]] = None,
        exchange_type: Optional[ExchangeType] = None,
    ) -> List[PriceQuote]:
        """Synchronous wrapper for fetch_all_prices."""
        return asyncio.run(
            self.fetch_all_prices(base, quote, exchanges, exchange_type)
        )

    async def close(self):
        """Close HTTP client."""
        await self.client.aclose()


def demo():
    """Demonstrate price fetcher."""
    fetcher = PriceFetcher(use_mock=True)

    print("=" * 60)
    print("PRICE FETCHER DEMO")
    print("=" * 60)

    # Fetch ETH/USDC prices
    prices = fetcher.fetch_all_prices_sync("ETH", "USDC")

    print(f"\nETH/USDC prices across {len(prices)} exchanges:\n")
    print(f"{'Exchange':<15} {'Bid':>12} {'Ask':>12} {'Spread':>8} {'Volume':>12}")
    print("-" * 60)

    for quote in sorted(prices, key=lambda x: x.bid, reverse=True):
        print(
            f"{quote.exchange:<15} "
            f"${quote.bid:>11,.2f} "
            f"${quote.ask:>11,.2f} "
            f"{quote.spread_pct:>7.3f}% "
            f"{quote.volume_24h:>11,.0f}"
        )

    # Show best opportunity
    if len(prices) >= 2:
        sorted_by_bid = sorted(prices, key=lambda x: x.bid, reverse=True)
        sorted_by_ask = sorted(prices, key=lambda x: x.ask)

        best_sell = sorted_by_bid[0]
        best_buy = sorted_by_ask[0]

        if best_sell.bid > best_buy.ask:
            spread = float((best_sell.bid - best_buy.ask) / best_buy.ask * 100)
            print(f"\nBest opportunity:")
            print(f"  Buy on {best_buy.exchange} at ${best_buy.ask:,.2f}")
            print(f"  Sell on {best_sell.exchange} at ${best_sell.bid:,.2f}")
            print(f"  Gross spread: {spread:.3f}%")


if __name__ == "__main__":
    demo()