deploy_tracker.py

#!/usr/bin/env python3
"""contract-deploy-tracker: Track and analyze smart contract deployments across EVM chains.

Supports Ethereum, Base, Arbitrum, Optimism, and Polygon. Uses Etherscan-compatible
APIs and public RPC endpoints for block scanning and contract analysis.
"""

import csv
import hashlib
import io
import json
import os
import sys
import time
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Optional

import click
import requests
from rich.console import Console
from rich.panel import Panel
from rich.table import Table
from rich.text import Text
from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn

console = Console()

# ---------------------------------------------------------------------------
# Chain configuration
# ---------------------------------------------------------------------------

CHAINS = {
    "ethereum": {
        "name": "Ethereum",
        "explorer_api": "https://api.etherscan.io/api",
        "rpc": "https://eth.llamarpc.com",
        "env_key": "ETHERSCAN_API_KEY",
        "currency": "ETH",
        "chain_id": 1,
    },
    "base": {
        "name": "Base",
        "explorer_api": "https://api.basescan.org/api",
        "rpc": "https://rpc.ankr.com/base",
        "env_key": "BASESCAN_API_KEY",
        "currency": "ETH",
        "chain_id": 8453,
    },
    "arbitrum": {
        "name": "Arbitrum",
        "explorer_api": "https://api.arbiscan.io/api",
        "rpc": "https://rpc.ankr.com/arbitrum",
        "env_key": "ARBISCAN_API_KEY",
        "currency": "ETH",
        "chain_id": 42161,
    },
    "optimism": {
        "name": "Optimism",
        "explorer_api": "https://api-optimistic.etherscan.io/api",
        "rpc": "https://rpc.ankr.com/optimism",
        "env_key": "OPSCAN_API_KEY",
        "currency": "ETH",
        "chain_id": 10,
    },
    "polygon": {
        "name": "Polygon",
        "explorer_api": "https://api.polygonscan.com/api",
        "rpc": "https://rpc.ankr.com/polygon",
        "env_key": "POLYGONSCAN_API_KEY",
        "currency": "MATIC",
        "chain_id": 137,
    },
}

# ---------------------------------------------------------------------------
# Known factory contracts
# ---------------------------------------------------------------------------

KNOWN_FACTORIES = {
    "uniswap_v3_pool_deployer": {
        "address": "0x1F98431c8aD98523631AE4a59f267346ea31F984",
        "label": "Uniswap V3 Pool Deployer",
        "type": "create2",
        "description": "Deploys Uniswap V3 liquidity pool contracts via CREATE2",
    },
    "create2_deployer": {
        "address": "0x13b0D85CcD8bf66cFc1c8B6E4F4bA0b5B7B4E6E6",
        "label": "Create2 Deployer (0x13b0)",
        "type": "create2",
        "description": "Generic CREATE2 deployer used by many protocols",
    },
    "safe_proxy_factory": {
        "address": "0xa6B71E26C5e0845f74c812102Ca7114b6a511B77",
        "label": "Safe ProxyFactory",
        "type": "minimal_proxy",
        "description": "Deploys Safe (Gnosis) wallet proxy contracts",
    },
    "eip1167_deployer": {
        "address": "0x4e59b44847b379578588920cA78FbF26c0B4956C",
        "label": "EIP-1167 Minimal Proxy Deployer",
        "type": "minimal_proxy",
        "description": "Deploys EIP-1167 minimal proxy (clone) contracts",
    },
    "uniswap_v2_factory": {
        "address": "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
        "label": "Uniswap V2 Factory",
        "type": "create2",
        "description": "Deploys Uniswap V2 pair contracts via CREATE2",
    },
}

# ---------------------------------------------------------------------------
# EIP-1967 storage slots
# ---------------------------------------------------------------------------

# Implementation slot: bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)
EIP1967_IMPL_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"

# Admin slot: bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1)
EIP1967_ADMIN_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103"

# Beacon slot: bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1)
EIP1967_BEACON_SLOT = "0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50"

# ---------------------------------------------------------------------------
# Rate limiter
# ---------------------------------------------------------------------------

_last_request_times: dict[str, float] = {}
RATE_LIMIT_INTERVAL = 0.2  # 5 requests per second per domain


def _rate_limit(url: str) -> None:
    """Enforce rate limiting per API domain.

    Args:
        url: Full URL to extract domain from for per-domain limiting.
    """
    global _last_request_times
    domain = url.split("/")[2] if "/" in url else url
    now = time.time()
    last = _last_request_times.get(domain, 0.0)
    elapsed = now - last
    if elapsed < RATE_LIMIT_INTERVAL:
        time.sleep(RATE_LIMIT_INTERVAL - elapsed)
    _last_request_times[domain] = time.time()


# ---------------------------------------------------------------------------
# Cache system
# ---------------------------------------------------------------------------

def _cache_dir() -> Path:
    """Return cache directory path, creating it if needed.

    Returns:
        Path to ~/.contract-deploy-cache/
    """
    d = Path.home() / ".contract-deploy-cache"
    d.mkdir(parents=True, exist_ok=True)
    return d


def _cache_key(url: str, params: dict) -> str:
    """Generate deterministic cache key from URL and params.

    Args:
        url: Request URL.
        params: Query parameters dict.

    Returns:
        SHA-256 hex digest for use as filename.
    """
    raw = url + json.dumps(params, sort_keys=True)
    return hashlib.sha256(raw.encode()).hexdigest()


def _cache_get(key: str, ttl: int = 300) -> Optional[Any]:
    """Retrieve cached value if it exists and is not expired.

    Args:
        key: Cache key (SHA-256 hash).
        ttl: Time-to-live in seconds (default 300 = 5 minutes).

    Returns:
        Cached value or None if expired/missing.
    """
    path = _cache_dir() / f"{key}.json"
    if not path.exists():
        return None
    try:
        data = json.loads(path.read_text())
        if time.time() - data.get("ts", 0) > ttl:
            # Expired — remove stale cache file
            path.unlink(missing_ok=True)
            return None
        return data.get("value")
    except (json.JSONDecodeError, KeyError, OSError):
        return None


def _cache_set(key: str, value: Any) -> None:
    """Store a value in the cache with current timestamp.

    Args:
        key: Cache key.
        value: JSON-serializable value to cache.
    """
    path = _cache_dir() / f"{key}.json"
    try:
        path.write_text(json.dumps({"ts": time.time(), "value": value}, default=str))
    except OSError as e:
        console.print(f"[dim yellow]Warning: cache write failed: {e}[/dim yellow]")


def clear_cache() -> int:
    """Clear all cached data.

    Returns:
        Number of cache files removed.
    """
    cache_dir = _cache_dir()
    count = 0
    for f in cache_dir.glob("*.json"):
        f.unlink()
        count += 1
    return count


# ---------------------------------------------------------------------------
# Configuration / API key management
# ---------------------------------------------------------------------------

def _get_api_key(chain_cfg: dict) -> str:
    """Get API key for a chain from environment variables.

    Checks chain-specific key first (e.g. BASESCAN_API_KEY), then falls back
    to generic ETHERSCAN_API_KEY. Returns empty string if neither is set.

    Args:
        chain_cfg: Chain configuration dict.

    Returns:
        API key string, or empty string for free-tier usage.
    """
    return (
        os.environ.get(chain_cfg.get("env_key", ""), "")
        or os.environ.get("ETHERSCAN_API_KEY", "")
    )


# ---------------------------------------------------------------------------
# HTTP / RPC request helpers
# ---------------------------------------------------------------------------

def etherscan_request(chain_cfg: dict, module: str, action: str,
                      ttl: int = 300, **kwargs) -> dict:
    """Make an Etherscan-compatible API request with caching and rate limiting.

    Constructs the proper URL with module, action, and additional parameters.
    Supports all Etherscan v2 API endpoints. Results are cached locally.

    Args:
        chain_cfg: Chain configuration dict from CHAINS.
        module: API module name (e.g. 'contract', 'account', 'proxy').
        action: API action (e.g. 'getabi', 'txlist', 'getcontractcreation').
        ttl: Cache TTL in seconds (default 300).
        **kwargs: Additional query parameters passed to the API.

    Returns:
        Parsed JSON response as dict. Etherscan format:
        {"status": "1", "message": "OK", "result": ...}

    Raises:
        click.ClickException: On network failure or invalid response.
    """
    params = {"module": module, "action": action, **kwargs}
    api_key = _get_api_key(chain_cfg)
    if api_key:
        params["apikey"] = api_key

    url = chain_cfg["explorer_api"]
    cache_key = _cache_key(url, params)
    cached = _cache_get(cache_key, ttl=ttl)
    if cached is not None:
        return cached

    _rate_limit(url)
    try:
        resp = requests.get(url, params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
    except requests.Timeout:
        raise click.ClickException(f"Request timed out for {url}")
    except requests.ConnectionError as e:
        raise click.ClickException(f"Connection error: {e}")
    except requests.HTTPError as e:
        raise click.ClickException(f"HTTP error: {e}")
    except json.JSONDecodeError:
        raise click.ClickException(f"Invalid JSON response from {url}")

    # Check for Etherscan rate limit message
    if isinstance(data.get("result"), str) and "rate limit" in data["result"].lower():
        console.print("[yellow]Rate limited by API, waiting 1s...[/yellow]")
        time.sleep(1)
        _rate_limit(url)
        try:
            resp = requests.get(url, params=params, timeout=30)
            resp.raise_for_status()
            data = resp.json()
        except Exception as e:
            raise click.ClickException(f"Retry failed: {e}")

    _cache_set(cache_key, data)
    return data


def rpc_request(chain_cfg: dict, method: str, params: list,
                ttl: int = 60) -> Any:
    """Make a JSON-RPC request to the chain's public endpoint.

    Args:
        chain_cfg: Chain configuration dict.
        method: RPC method name (e.g. 'eth_blockNumber', 'eth_getCode').
        params: Method parameters list.
        ttl: Cache TTL in seconds (default 60).

    Returns:
        The 'result' field from the JSON-RPC response.

    Raises:
        click.ClickException: On RPC or network error.
    """
    url = chain_cfg["rpc"]
    cache_key = _cache_key(url, {"method": method, "params": params})
    cached = _cache_get(cache_key, ttl=ttl)
    if cached is not None:
        return cached

    _rate_limit(url)
    payload = {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
    try:
        resp = requests.post(url, json=payload, timeout=30)
        resp.raise_for_status()
        data = resp.json()
    except requests.Timeout:
        raise click.ClickException(f"RPC request timed out for {url}")
    except requests.ConnectionError as e:
        raise click.ClickException(f"RPC connection error: {e}")
    except json.JSONDecodeError:
        raise click.ClickException(f"Invalid JSON from RPC at {url}")

    if "error" in data:
        err = data["error"]
        raise click.ClickException(f"RPC error {err.get('code', '?')}: {err.get('message', 'unknown')}")

    result = data.get("result")
    if result is not None:
        _cache_set(cache_key, result)
    return result


# ---------------------------------------------------------------------------
# Chain lookup helper
# ---------------------------------------------------------------------------

def get_chain(name: str) -> dict:
    """Look up chain config by short name.

    Args:
        name: Chain identifier (e.g. 'ethereum', 'base', 'arb', 'op', 'polygon').

    Returns:
        Chain configuration dict.

    Raises:
        click.ClickException: If chain not found.
    """
    aliases = {
        "eth": "ethereum",
        "arb": "arbitrum",
        "op": "optimism",
        "matic": "polygon",
    }
    name = aliases.get(name.lower(), name.lower())
    if name not in CHAINS:
        raise click.ClickException(
            f"Unknown chain '{name}'. Available: {', '.join(CHAINS.keys())}"
        )
    return CHAINS[name]


# ---------------------------------------------------------------------------
# Export helpers
# ---------------------------------------------------------------------------

def export_data(rows: list[dict], fmt: str, output: Optional[str]) -> None:
    """Export data rows to CSV or JSON format.

    Args:
        rows: List of dicts to export.
        fmt: Output format — 'csv' or 'json'.
        output: File path to write to, or None for stdout.
    """
    if not rows:
        console.print("[yellow]No data to export.[/yellow]")
        return

    if fmt == "json":
        text = json.dumps(rows, indent=2, default=str)
    elif fmt == "csv":
        buf = io.StringIO()
        writer = csv.DictWriter(buf, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)
        text = buf.getvalue()
    else:
        raise click.ClickException(f"Unknown export format: '{fmt}'")

    if output:
        Path(output).write_text(text)
        console.print(f"[green]✓ Exported {len(rows)} rows to {output}[/green]")
    else:
        click.echo(text)


# ---------------------------------------------------------------------------
# Bytecode / contract analysis
# ---------------------------------------------------------------------------

def bytecode_size(bytecode_hex: str) -> int:
    """Calculate bytecode size in bytes from hex string.

    Strips 0x prefix and counts hex character pairs.

    Args:
        bytecode_hex: Hex-encoded bytecode (e.g. '0x6080604052...').

    Returns:
        Size in bytes.
    """
    clean = bytecode_hex.replace("0x", "")
    return len(clean) // 2


def is_eip1167_proxy(bytecode_hex: str) -> bool:
    """Detect EIP-1167 minimal proxy (clone) pattern in bytecode.

    The minimal proxy bytecode is exactly 45 bytes and starts with
    0x363d3d373d3d3d363d73 followed by the implementation address
    and ends with 0x5af43d82803e903d91602b57fd5bf3.

    Args:
        bytecode_hex: Hex-encoded bytecode.

    Returns:
        True if bytecode matches EIP-1167 pattern.
    """
    clean = bytecode_hex.replace("0x", "").lower()
    if len(clean) != 90:  # 45 bytes = 90 hex chars
        return False
    prefix = "363d3d373d3d3d363d73"
    suffix = "5af43d82803e903d91602b57fd5bf3"
    return clean.startswith(prefix) and clean.endswith(suffix)


def extract_eip1167_target(bytecode_hex: str) -> Optional[str]:
    """Extract implementation address from EIP-1167 minimal proxy bytecode.

    Args:
        bytecode_hex: Hex-encoded bytecode.

    Returns:
        Checksummed address string, or None if not a minimal proxy.
    """
    clean = bytecode_hex.replace("0x", "").lower()
    if not is_eip1167_proxy(bytecode_hex):
        return None
    # Address is bytes 10-29 (20 bytes = 40 hex chars)
    addr_hex = clean[20:60]
    return "0x" + addr_hex


def detect_proxy(chain_cfg: dict, address: str) -> dict:
    """Detect if a contract is a proxy using EIP-1967 storage slots and bytecode analysis.

    Checks:
    1. EIP-1967 implementation slot for standard proxy pattern
    2. EIP-1967 admin slot for proxy admin
    3. EIP-1967 beacon slot for beacon proxies
    4. EIP-1167 minimal proxy pattern in bytecode

    Args:
        chain_cfg: Chain configuration dict.
        address: Contract address to check.

    Returns:
        Dict with keys: is_proxy, proxy_type, implementation, admin, beacon.
    """
    result = {
        "is_proxy": False,
        "proxy_type": None,
        "implementation": None,
        "admin": None,
        "beacon": None,
    }

    # Check EIP-1967 implementation slot
    try:
        impl_data = rpc_request(chain_cfg, "eth_getStorageAt", [
            address, EIP1967_IMPL_SLOT, "latest"
        ], ttl=120)
        if impl_data and impl_data != "0x" + "0" * 64:
            impl_addr = "0x" + impl_data[-40:]
            if int(impl_addr, 16) != 0:
                result["is_proxy"] = True
                result["proxy_type"] = "eip1967"
                result["implementation"] = impl_addr
    except click.ClickException:
        pass

    # Check admin slot
    try:
        admin_data = rpc_request(chain_cfg, "eth_getStorageAt", [
            address, EIP1967_ADMIN_SLOT, "latest"
        ], ttl=120)
        if admin_data and admin_data != "0x" + "0" * 64:
            admin_addr = "0x" + admin_data[-40:]
            if int(admin_addr, 16) != 0:
                result["admin"] = admin_addr
    except click.ClickException:
        pass

    # Check beacon slot
    try:
        beacon_data = rpc_request(chain_cfg, "eth_getStorageAt", [
            address, EIP1967_BEACON_SLOT, "latest"
        ], ttl=120)
        if beacon_data and beacon_data != "0x" + "0" * 64:
            beacon_addr = "0x" + beacon_data[-40:]
            if int(beacon_addr, 16) != 0:
                result["is_proxy"] = True
                result["proxy_type"] = "beacon"
                result["beacon"] = beacon_addr
    except click.ClickException:
        pass

    # Check EIP-1167 minimal proxy via bytecode
    if not result["is_proxy"]:
        try:
            bytecode = get_bytecode(chain_cfg, address)
            if is_eip1167_proxy(bytecode):
                result["is_proxy"] = True
                result["proxy_type"] = "eip1167_minimal"
                result["implementation"] = extract_eip1167_target(bytecode)
        except click.ClickException:
            pass

    return result


def get_bytecode(chain_cfg: dict, address: str) -> str:
    """Fetch deployed bytecode at an address via eth_getCode.

    Args:
        chain_cfg: Chain configuration dict.
        address: Contract address.

    Returns:
        Hex-encoded bytecode string (e.g. '0x6080604052...').
    """
    code = rpc_request(chain_cfg, "eth_getCode", [address, "latest"])
    return code or "0x"


def check_verification(chain_cfg: dict, address: str) -> dict:
    """Check if a contract is verified on the block explorer.

    Uses getabi endpoint to check verification status, and getsourcecode
    to retrieve source code if verified.

    Args:
        chain_cfg: Chain configuration dict.
        address: Contract address to check.

    Returns:
        Dict with 'verified' (bool), 'abi' (parsed or None), 'source_code' (str or None),
        'contract_name' (str or None).
    """
    result = {"verified": False, "abi": None, "source_code": None, "contract_name": None}

    data = etherscan_request(chain_cfg, "contract", "getabi", address=address, ttl=600)
    verified = data.get("status") == "1" and data.get("message") == "OK"
    result["verified"] = verified

    if verified:
        try:
            result["abi"] = json.loads(data["result"])
        except (json.JSONDecodeError, TypeError):
            result["abi"] = data["result"]

    # Get source code and contract name if verified
    if verified:
        src_data = etherscan_request(
            chain_cfg, "contract", "getsourcecode", address=address, ttl=600
        )
        if src_data.get("status") == "1" and src_data.get("result"):
            src_info = src_data["result"]
            if isinstance(src_info, list) and src_info:
                src_info = src_info[0]
            source = src_info.get("SourceCode", "")
            result["contract_name"] = src_info.get("ContractName", "")
            if source:
                # Handle multi-file sources wrapped in {{ }}
                if source.startswith("{{"):
                    try:
                        parsed = json.loads(source[1:-1])
                        sources = parsed.get("sources", {})
                        combined = ""
                        for fname, fdata in sources.items():
                            combined += f"\n// --- {fname} ---\n"
                            combined += fdata.get("content", "")[:200]
                        result["source_code"] = combined[:500]
                    except json.JSONDecodeError:
                        result["source_code"] = source[:500]
                else:
                    result["source_code"] = source[:500]

    return result


def get_contract_creation(chain_cfg: dict, addresses: list[str]) -> list[dict]:
    """Get contract creation info via Etherscan getcontractcreation endpoint.

    Args:
        chain_cfg: Chain configuration dict.
        addresses: List of contract addresses (up to 5 at a time).

    Returns:
        List of dicts with 'contractAddress', 'contractCreator', 'txHash' keys.
    """
    if not addresses:
        return []
    # Etherscan accepts comma-separated addresses
    addr_str = ",".join(addresses[:5])
    data = etherscan_request(
        chain_cfg, "contract", "getcontractcreation",
        contractaddresses=addr_str, ttl=600
    )
    if data.get("status") == "1" and data.get("result"):
        results = data["result"]
        if isinstance(results, list):
            return results
    return []


def get_tx_list(chain_cfg: dict, address: str, startblock: int = 0,
                endblock: int = 99999999, page: int = 1,
                offset: int = 100) -> list[dict]:
    """Get normal transaction list for an address via Etherscan account/txlist.

    Args:
        chain_cfg: Chain configuration dict.
        address: Wallet or contract address.
        startblock: Starting block number (inclusive).
        endblock: Ending block number (inclusive).
        page: Page number for pagination.
        offset: Number of results per page (max 10000).

    Returns:
        List of transaction dicts from Etherscan API.
    """
    data = etherscan_request(
        chain_cfg, "account", "txlist",
        address=address, startblock=startblock, endblock=endblock,
        page=page, offset=offset, sort="desc"
    )
    if data.get("status") == "1" and data.get("result"):
        results = data["result"]
        if isinstance(results, list):
            return results
    return []


def get_internal_txs(chain_cfg: dict, address: str, startblock: int = 0,
                     endblock: int = 99999999, page: int = 1,
                     offset: int = 100) -> list[dict]:
    """Get internal transactions for an address via Etherscan.

    Internal transactions are contract-to-contract calls that don't
    appear in the main transaction list.

    Args:
        chain_cfg: Chain configuration dict.
        address: Wallet or contract address.
        startblock: Starting block number.
        endblock: Ending block number.
        page: Page number.
        offset: Results per page.

    Returns:
        List of internal transaction dicts.
    """
    data = etherscan_request(
        chain_cfg, "account", "txlistinternal",
        address=address, startblock=startblock, endblock=endblock,
        page=page, offset=offset, sort="desc"
    )
    if data.get("status") == "1" and data.get("result"):
        results = data["result"]
        if isinstance(results, list):
            return results
    return []


# ---------------------------------------------------------------------------
# Block scanning via RPC
# ---------------------------------------------------------------------------

def get_block_by_number(chain_cfg: dict, block_num: int) -> Optional[dict]:
    """Fetch a block with full transaction objects via eth_getBlockByNumber.

    Args:
        chain_cfg: Chain configuration dict.
        block_num: Block number as integer.

    Returns:
        Block dict with full transaction objects, or None on failure.
    """
    hex_num = hex(block_num)
    return rpc_request(chain_cfg, "eth_getBlockByNumber", [hex_num, True])


def get_latest_block(chain_cfg: dict) -> int:
    """Get the latest block number via eth_blockNumber.

    Args:
        chain_cfg: Chain configuration dict.

    Returns:
        Latest block number as integer.
    """
    result = rpc_request(chain_cfg, "eth_blockNumber", [])
    return int(result, 16)


def get_tx_receipt(chain_cfg: dict, tx_hash: str) -> Optional[dict]:
    """Get transaction receipt to find created contract address.

    Args:
        chain_cfg: Chain configuration dict.
        tx_hash: Transaction hash.

    Returns:
        Receipt dict or None.
    """
    return rpc_request(chain_cfg, "eth_getTransactionReceipt", [tx_hash])


def find_creations_in_block(block: dict) -> list[dict]:
    """Find contract creation transactions in a block.

    Contract creation transactions have to=null (or empty string).
    The created contract address can be found in the transaction receipt.

    Args:
        block: Block dict from eth_getBlockByNumber with full txs.

    Returns:
        List of dicts with creation info: hash, from, to, input_len, gas,
        value, blockNumber, timestamp.
    """
    creations = []
    block_number = block.get("number", "0x0")
    if isinstance(block_number, str):
        block_number = int(block_number, 16)

    block_timestamp = block.get("timestamp", "0x0")
    if isinstance(block_timestamp, str):
        block_timestamp = int(block_timestamp, 16)

    for tx in block.get("transactions", []):
        to_addr = tx.get("to")
        # Contract creation: to is null, None, or empty
        if to_addr is None or to_addr == "" or to_addr == "0x":
            gas_val = tx.get("gas", "0x0")
            if isinstance(gas_val, str):
                gas_val = int(gas_val, 16)

            value_val = tx.get("value", "0x0")
            if isinstance(value_val, str):
                value_val = int(value_val, 16)

            tx_hash = tx.get("hash", "")
            from_addr = tx.get("from", "")
            input_data = tx.get("input", "0x")

            creations.append({
                "hash": tx_hash,
                "from": from_addr,
                "to": None,
                "input_len": len(input_data),
                "bytecode_size": bytecode_size(input_data) if input_data else 0,
                "gas": gas_val,
                "gas_price": int(tx.get("gasPrice", "0x0"), 16) if isinstance(tx.get("gasPrice"), str) else tx.get("gasPrice", 0),
                "value": value_val,
                "blockNumber": block_number,
                "timestamp": block_timestamp,
                "tx_index": int(tx.get("transactionIndex", "0x0"), 16) if isinstance(tx.get("transactionIndex"), str) else tx.get("transactionIndex", 0),
            })
    return creations


# ---------------------------------------------------------------------------
# Rich display helpers
# ---------------------------------------------------------------------------

def make_table(title: str, columns: list[str]) -> Table:
    """Create a styled Rich table.

    Args:
        title: Table title displayed above.
        columns: List of column header names.

    Returns:
        Configured Rich Table object ready for add_row() calls.
    """
    table = Table(title=title, show_lines=True, expand=True, title_style="bold cyan")
    for col in columns:
        table.add_column(col, overflow="fold")
    return table


def truncate_addr(addr: str, n: int = 8) -> str:
    """Truncate an Ethereum address for compact display.

    Shows first n and last n characters with ... in between.

    Args:
        addr: Full Ethereum address (0x...).
        n: Number of chars to keep from each end.

    Returns:
        Truncated address string.
    """
    if not addr or len(addr) <= n * 2 + 5:
        return addr or ""
    return f"{addr[:2 + n]}...{addr[-n:]}"


def format_wei(wei: int) -> str:
    """Format wei value to human-readable ETH.

    Args:
        wei: Value in wei.

    Returns:
        Formatted string like '1.234 ETH'.
    """
    eth = wei / 10**18
    if eth < 0.0001:
        return f"{wei} wei"
    return f"{eth:.4f} ETH"


def format_timestamp(ts: int) -> str:
    """Format Unix timestamp to ISO date string.

    Args:
        ts: Unix timestamp in seconds.

    Returns:
        ISO format datetime string.
    """
    if not ts:
        return "N/A"
    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")


# ---------------------------------------------------------------------------
# CLI group
# ---------------------------------------------------------------------------

@click.group()
@click.version_option(version="0.1.0", prog_name="contract-deploy-tracker")
def cli():
    """contract-deploy-tracker — Track and analyze smart contract deployments across EVM chains.

    Supports Ethereum, Base, Arbitrum, Optimism, and Polygon.
    Uses Etherscan-compatible APIs and public RPC endpoints.
    """
    pass


# ---------------------------------------------------------------------------
# recent — scan recent blocks for contract creations
# ---------------------------------------------------------------------------

@cli.command()
@click.option("-c", "--chain", default="ethereum", show_default=True, help="Chain to query.")
@click.option("-n", "--num-blocks", default=10, type=int, show_default=True, help="Number of recent blocks to scan.")
@click.option("--start-block", default=None, type=int, help="Start scanning from this block (overrides --num-blocks).")
@click.option("--export", "export_fmt", type=click.Choice(["csv", "json"]), help="Export format.")
@click.option("-o", "--output", default=None, help="Output file path (stdout if omitted).")
def recent(chain: str, num_blocks: int, start_block: Optional[int],
           export_fmt: Optional[str], output: Optional[str]):
    """Scan recent blocks for contract creation transactions.

    Uses eth_getBlockByNumber via public RPC to find transactions where
    the 'to' field is null, indicating contract deployment.
    """
    chain_cfg = get_chain(chain)
    console.print(f"[bold]Scanning recent blocks on {chain_cfg['name']}...[/bold]")

    latest = get_latest_block(chain_cfg)
    console.print(f"Latest block: [cyan]{latest:,}[/cyan]")

    if start_block is not None:
        blocks_to_scan = latest - start_block + 1
        start = start_block
    else:
        blocks_to_scan = num_blocks
        start = latest - num_blocks + 1

    console.print(f"Scanning blocks [cyan]{start:,}[/cyan] to [cyan]{latest:,}[/cyan] ({blocks_to_scan} blocks)")

    all_creations = []
    with Progress(
        SpinnerColumn(),
        TextColumn("[progress.description]{task.description}"),
        BarColumn(),
        TaskProgressColumn(),
        console=console,
    ) as progress:
        task = progress.add_task("Scanning blocks...", total=blocks_to_scan)
        for i in range(blocks_to_scan):
            block_num = latest - i
            progress.update(task, advance=1, description=f"Block {block_num:,}")
            block = get_block_by_number(chain_cfg, block_num)
            if block:
                creations = find_creations_in_block(block)
                for c in creations:
                    c["chain"] = chain
                    c["explorer"] = chain_cfg["explorer_api"].replace("/api", "")
                all_creations.extend(creations)

    if export_fmt:
        export_data(all_creations, export_fmt, output)
        return

    if not all_creations:
        console.print("[yellow]No contract creations found in scanned blocks.[/yellow]")
        return

    table = make_table(
        f"Contract Creations on {chain_cfg['name']} ({blocks_to_scan} blocks)",
        ["Block", "Deployer", "Tx Hash", "Gas", "Bytecode Size", "Timestamp"]
    )
    for c in all_creations:
        table.add_row(
            f"{c['blockNumber']:,}",
            truncate_addr(c["from"]),
            truncate_addr(c["hash"]),
            f"{c['gas']:,}",
            f"{c.get('bytecode_size', 0):,} B",
            format_timestamp(c.get("timestamp", 0)),
        )
    console.print(table)

    # Summary
    total_gas = sum(c["gas"] for c in all_creations)
    unique_deployers = len(set(c["from"] for c in all_creations))
    avg_size = sum(c.get("bytecode_size", 0) for c in all_creations) / max(len(all_creations), 1)
    console.print(Panel(
        f"Total deployments: [green]{len(all_creations)}[/green]\n"
        f"Unique deployers: [cyan]{unique_deployers}[/cyan]\n"
        f"Total gas used: [yellow]{total_gas:,}[/yellow]\n"
        f"Avg bytecode size: [cyan]{avg_size:,.0f} bytes[/cyan]",
        title="Summary", expand=False
    ))


# ---------------------------------------------------------------------------
# deployer — analyze all contracts deployed by an address
# ---------------------------------------------------------------------------

@cli.command()
@click.argument("address")
@click.option("-c", "--chain", default="ethereum", show_default=True, help="Chain to query.")
@click.option("-n", "--limit", default=50, type=int, show_default=True, help="Max transactions to fetch.")
@click.option("--include-internal/--no-internal", default=True, help="Include internal contract creations.")
@click.option("--check-verify/--no-verify", default=False, help="Check verification status (slow, 1 request per contract).")
@click.option("--export", "export_fmt", type=click.Choice(["csv", "json"]), help="Export format.")
@click.option("-o", "--output", default=None, help="Output file path.")
def deployer(address: str, chain: str, limit: int, include_internal: bool,
             check_verify: bool, export_fmt: Optional[str], output: Optional[str]):
    """Analyze all contracts deployed by ADDRESS.

    Queries Etherscan txlist for direct creations (to=null) and optionally
    internal transactions for factory-created contracts.
    """
    chain_cfg = get_chain(chain)
    console.print(f"[bold]Analyzing deployer:[/bold] [cyan]{address}[/cyan]")
    console.print(f"Chain: [cyan]{chain_cfg['name']}[/cyan]\n")

    # Direct contract creations from txlist
    console.print("Fetching transaction list...")
    txs = get_tx_list(chain_cfg, address, page=1, offset=limit)
    direct_creations = [
        tx for tx in txs
        if tx.get("to") == "" or tx.get("to") is None or tx.get("to") == "0x"
    ]
    for tx in direct_creations:
        tx["creation_type"] = "direct"
    console.print(f"  Found [green]{len(direct_creations)}[/green] direct contract creations")

    # Internal contract creations
    internal_creations = []
    if include_internal:
        console.print("Fetching internal transactions...")
        internal = get_internal_txs(chain_cfg, address, page=1, offset=limit)
        for tx in internal:
            ca = tx.get("contractAddress", "")
            if ca and ca != "":
                tx["creation_type"] = "internal"
                internal_creations.append(tx)
        console.print(f"  Found [green]{len(internal_creations)}[/green] internal contract creations")

    all_creations = direct_creations + internal_creations

    if not all_creations:
        console.print("[yellow]No contract creations found for this deployer.[/yellow]")
        return

    # Check verification if requested
    verification_map: dict[str, dict] = {}
    if check_verify:
        contract_addrs = [
            tx.get("contractAddress", "") for tx in all_creations if tx.get("contractAddress")
        ]
        if contract_addrs:
            console.print(f"Checking verification for {len(contract_addrs)} contracts...")
            with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console) as progress:
                task = progress.add_task("Checking...", total=len(contract_addrs))
                for addr in contract_addrs:
                    progress.update(task, advance=1, description=f"Checking {truncate_addr(addr)}")
                    verification_map[addr] = check_verification(chain_cfg, addr)

    if export_fmt:
        rows = []
        for tx in all_creations:
            ca = tx.get("contractAddress", "")
            rows.append({
                "contract_address": ca,
                "tx_hash": tx.get("hash", ""),
                "block_number": tx.get("blockNumber", ""),
                "gas_used": tx.get("gasUsed", tx.get("gas", "")),
                "verified": verification_map.get(ca, {}).get("verified", False),
                "creation_type": tx.get("creation_type", "direct"),
            })
        export_data(rows, export_fmt, output)
        return

    table = make_table(
        f"Contracts Deployed by {truncate_addr(address, 10)}",
        ["Contract Address", "Tx Hash", "Block", "Gas Used", "Verified", "Type"]
    )
    verified_count = 0
    for tx in all_creations:
        ca = tx.get("contractAddress", "")
        verified = verification_map.get(ca, {}).get("verified", False)
        if verified:
            verified_count += 1
        table.add_row(
            truncate_addr(ca) if ca else "[dim]pending[/dim]",
            truncate_addr(tx.get("hash", "")),
            str(tx.get("blockNumber", "")),
            f"{int(tx.get('gasUsed', tx.get('gas', 0))):,}",
            "[green]✓[/green]" if verified else "[red]✗[/red]",
            tx.get("creation_type", "direct"),
        )
    console.print(table)

    # Summary
    console.print(Panel(
        f"Total contracts: [green]{len(all_creations)}[/green]\n"
        f"Direct creations: [cyan]{len(direct_creations)}[/cyan]\n"
        f"Internal creations: [cyan]{len(internal_creations)}[/cyan]\n"
        f"Verified: [green]{verified_count}[/green] / {len(all_creations)}",
        title="Deployer Summary", expand=False
    ))


# ---------------------------------------------------------------------------
# verify — check verification status
# ---------------------------------------------------------------------------

@cli.command()
@click.argument("addresses", nargs=-1, required=True)
@click.option("-c", "--chain", default="ethereum", show_default=True, help="Chain to query.")
@click.option("--export", "export_fmt", type=click.Choice(["csv", "json"]), help="Export format.")
@click.option("-o", "--output", default=None, help="Output file path.")
def verify(addresses: tuple, chain: str, export_fmt: Optional[str], output: Optional[str]):
    """Check verification status of contracts on the block explorer.

    Uses Etherscan getabi endpoint — if it returns valid ABI, the contract
    is verified. Also fetches source code and contract name.
    """
    chain_cfg = get_chain(chain)
    console.print(f"[bold]Checking verification on {chain_cfg['name']}[/bold]\n")

    rows = []
    for addr in addresses:
        console.print(f"  Checking [cyan]{addr}[/cyan]...")
        info = check_verification(chain_cfg, addr)
        rows.append({
            "address": addr,
            "verified": info["verified"],
            "contract_name": info.get("contract_name", ""),
            "has_source": bool(info.get("source_code")),
        })

    if export_fmt:
        export_data(rows, export_fmt, output)
        return

    table = make_table("Contract Verification Status", ["Address", "Verified", "Contract Name", "Source Code"])
    for r in rows:
        table.add_row(
            r["address"],
            "[green]✓ Verified[/green]" if r["verified"] else "[red]✗ Not Verified[/red]",
            r.get("contract_name") or "[dim]N/A[/dim]",
            "[green]Available[/green]" if r["has_source"] else "[dim]N/A[/dim]",
        )
    console.print(table)

    verified_total = sum(1 for r in rows if r["verified"])
    console.print(f"\n[bold]{verified_total}/{len(rows)} contracts verified[/bold]")


# ---------------------------------------------------------------------------
# factory — track proxy factory deployments
# ---------------------------------------------------------------------------

@cli.command()
@click.option("-c", "--chain", default="ethereum", show_default=True, help="Chain to query.")
@click.option("-n", "--limit", default=20, type=int, show_default=True, help="Max recent txs per factory.")
@click.option("--factory", "factory_filter", default=None, help="Filter to specific factory name (partial match).")
@click.option("--export", "export_fmt", type=click.Choice(["csv", "json"]), help="Export format.")
@click.option("-o", "--output", default=None, help="Output file path.")
def factory(chain: str, limit: int, factory_filter: Optional[str],
            export_fmt: Optional[str], output: Optional[str]):
    """Track proxy factory deployments (Create2, minimal proxy, Safe, Uniswap).

    Scans known factory contract addresses for recent deployment transactions.
    """
    chain_cfg = get_chain(chain)
    console.print(f"[bold]Tracking factory deployments on {chain_cfg['name']}...[/bold]\n")

    all_rows = []
    for key, info in KNOWN_FACTORIES.items():
        if factory_filter and factory_filter.lower() not in info["label"].lower() and factory_filter.lower() not in key:
            continue

        console.print(f"  [cyan]{info['label']}[/cyan]")
        console.print(f"    Address: {info['address']}")
        console.print(f"    Type: {info['type']} — {info['description']}")
        console.print(f"    Fetching last {limit} transactions...")

        try:
            txs = get_tx_list(chain_cfg, info["address"], page=1, offset=limit)
        except click.ClickException as e:
            console.print(f"    [red]Error: {e}[/red]")
            continue

        # Filter for transactions that created contracts
        for tx in txs[:limit]:
            ca = tx.get("contractAddress", "")
            is_creation = (tx.get("to") == "" or tx.get("to") is None or
                          tx.get("to") == "0x" or (ca and ca != ""))
            if is_creation:
                all_rows.append({
                    "factory": info["label"],
                    "factory_type": info["type"],
                    "contract_address": ca or "N/A",
                    "tx_hash": tx.get("hash", ""),
                    "block": tx.get("blockNumber", ""),
                    "gas_used": tx.get("gasUsed", tx.get("gas", "")),
                    "from": tx.get("from", ""),
                })

        console.print(f"    [green]Found {len([r for r in all_rows if r['factory'] == info['label']])} deployments[/green]\n")

    if export_fmt:
        export_data(all_rows, export_fmt, output)
        return

    if not all_rows:
        console.print("[yellow]No factory deployments found in recent transactions.[/yellow]")
        return

    table = make_table("Factory Deployments", ["Factory", "Type", "Contract", "Tx Hash", "Block", "Gas"])
    for r in all_rows:
        table.add_row(
            r["factory"],
            r["factory_type"],
            truncate_addr(r["contract_address"]),
            truncate_addr(r["tx_hash"]),
            str(r["block"]),
            f"{int(r['gas_used']):,}" if r["gas_used"] else "N/A",
        )
    console.print(table)
    console.print(f"\n[bold]Total factory deployments: {len(all_rows)}[/bold]")


# ---------------------------------------------------------------------------
# stats — deployment statistics for last N blocks
# ---------------------------------------------------------------------------

@cli.command()
@click.option("-c", "--chain", default="ethereum", show_default=True, help="Chain to query.")
@click.option("-n", "--num-blocks", default=100, type=int, show_default=True, help="Number of blocks to analyze.")
@click.option("--export", "export_fmt", type=click.Choice(["csv", "json"]), help="Export format.")
@click.option("-o", "--output", default=None, help="Output file path.")
def stats(chain: str, num_blocks: int, export_fmt: Optional[str], output: Optional[str]):
    """Deployment statistics for the last N blocks.

    Analyzes blocks via RPC to compute total deployments, gas consumed,
    top deployers, and average bytecode sizes.
    """
    chain_cfg = get_chain(chain)
    console.print(f"[bold]Analyzing last {num_blocks} blocks on {chain_cfg['name']}...[/bold]")

    latest = get_latest_block(chain_cfg)
    console.print(f"Latest block: [cyan]{latest:,}[/cyan]")
    console.print(f"Scanning blocks [cyan]{latest - num_blocks + 1:,}[/cyan] to [cyan]{latest:,}[/cyan]\n")

    deployer_counts: dict[str, int] = {}
    deployer_gas: dict[str, int] = {}
    total_deployments = 0
    total_gas = 0
    total_bytecode_size = 0
    blocks_scanned = 0
    blocks_with_deployments = 0

    with Progress(
        SpinnerColumn(),
        TextColumn("[progress.description]{task.description}"),
        BarColumn(),
        TaskProgressColumn(),
        console=console,
    ) as progress:
        task = progress.add_task("Scanning blocks...", total=num_blocks)
        for i in range(num_blocks):
            block_num = latest - i
            progress.update(task, advance=1, description=f"Block {block_num:,}")
            block = get_block_by_number(chain_cfg, block_num)
            if not block:
                continue
            blocks_scanned += 1
            creations = find_creations_in_block(block)
            if creations:
                blocks_with_deployments += 1
            for c in creations:
                total_deployments += 1
                total_gas += c["gas"]
                total_bytecode_size += c.get("bytecode_size", 0)
                deployer_addr = c["from"]
                deployer_counts[deployer_addr] = deployer_counts.get(deployer_addr, 0) + 1
                deployer_gas[deployer_addr] = deployer_gas.get(deployer_addr, 0) + c["gas"]

    # Top deployers sorted by count
    top_deployers = sorted(deployer_counts.items(), key=lambda x: x[1], reverse=True)[:15]

    if export_fmt:
        rows = [
            {"metric": "blocks_scanned", "value": blocks_scanned},
            {"metric": "blocks_with_deployments", "value": blocks_with_deployments},
            {"metric": "total_deployments", "value": total_deployments},
            {"metric": "total_gas_consumed", "value": total_gas},
            {"metric": "total_bytecode_bytes", "value": total_bytecode_size},
            {"metric": "avg_deployments_per_block", "value": round(total_deployments / max(blocks_scanned, 1), 3)},
            {"metric": "avg_gas_per_deployment", "value": round(total_gas / max(total_deployments, 1), 0)},
            {"metric": "avg_bytecode_size", "value": round(total_bytecode_size / max(total_deployments, 1), 0)},
        ]
        for addr, count in top_deployers:
            rows.append({
                "metric": f"top_deployer:{addr}",
                "contracts_deployed": count,
                "gas_consumed": deployer_gas.get(addr, 0),
            })
        export_data(rows, export_fmt, output)
        return

    # Stats panel
    deploy_rate = total_deployments / max(blocks_scanned, 1)
    active_rate = blocks_with_deployments / max(blocks_scanned, 1) * 100
    avg_gas = total_gas / max(total_deployments, 1)
    avg_size = total_bytecode_size / max(total_deployments, 1)

    console.print(Panel(
        f"Blocks Scanned:          [cyan]{blocks_scanned:,}[/cyan]\n"
        f"Blocks w/ Deployments:   [cyan]{blocks_with_deployments:,}[/cyan] ({active_rate:.1f}%)\n"
        f"Total Deployments:       [green]{total_deployments:,}[/green]\n"
        f"Total Gas Consumed:      [yellow]{total_gas:,}[/yellow]\n"
        f"Total Bytecode:          [cyan]{total_bytecode_size:,}[/cyan] bytes\n"
        f"Avg Deployments/Block:   [cyan]{deploy_rate:.3f}[/cyan]\n"
        f"Avg Gas/Deployment:      [yellow]{avg_gas:,.0f}[/yellow]\n"
        f"Avg Bytecode Size:       [cyan]{avg_size:,.0f}[/cyan] bytes",
        title=f"Deployment Statistics ({chain_cfg['name']})", expand=False
    ))

    if top_deployers:
        table = make_table("Top Deployers", ["#", "Deployer", "Contracts", "Gas Used", "Share"])
        for idx, (addr, count) in enumerate(top_deployers, 1):
            share = count / max(total_deployments, 1) * 100
            gas = deployer_gas.get(addr, 0)
            table.add_row(
                str(idx),
                truncate_addr(addr, 10),
                str(count),
                f"{gas:,}",
                f"{share:.1f}%",
            )
        console.print(table)


# ---------------------------------------------------------------------------
# inspect — detailed contract inspection
# ---------------------------------------------------------------------------

@cli.command()
@click.argument("address")
@click.option("-c", "--chain", default="ethereum", show_default=True, help="Chain to query.")
@click.option("--export", "export_fmt", type=click.Choice(["csv", "json"]), help="Export format.")
@click.option("-o", "--output", default=None, help="Output file path.")
def inspect(address: str, chain: str, export_fmt: Optional[str], output: Optional[str]):
    """Detailed inspection of a deployed contract.

    Shows creation transaction, deployer, bytecode size, proxy detection
    (EIP-1967 slots + EIP-1167 pattern), verification status, and
    source code snippet if verified.
    """
    chain_cfg = get_chain(chain)
    console.print(f"[bold]Inspecting contract on {chain_cfg['name']}...[/bold]\n")

    # Creation info via getcontractcreation
    console.print("  Fetching creation info...")
    creation_info = get_contract_creation(chain_cfg, [address])
    deployer = ""
    creation_tx = ""
    if creation_info:
        deployer = creation_info[0].get("contractCreator", "")
        creation_tx = creation_info[0].get("txHash", "")

    # Bytecode
    console.print("  Fetching bytecode...")
    bytecode = get_bytecode(chain_cfg, address)
    code_size = bytecode_size(bytecode)
    is_minimal = is_eip1167_proxy(bytecode)

    # Proxy detection
    console.print("  Checking proxy slots...")
    proxy_info = detect_proxy(chain_cfg, address)

    # Verification
    console.print("  Checking verification...")
    ver_info = check_verification(chain_cfg, address)

    # Build export data
    row = {
        "address": address,
        "chain": chain,
        "deployer": deployer,
        "creation_tx": creation_tx,
        "bytecode_size": code_size,
        "bytecode_hash": hashlib.sha256(bytecode.encode()).hexdigest()[:16] if bytecode and bytecode != "0x" else "",
        "is_proxy": proxy_info["is_proxy"],
        "proxy_type": proxy_info.get("proxy_type"),
        "implementation": proxy_info.get("implementation"),
        "admin": proxy_info.get("admin"),
        "beacon": proxy_info.get("beacon"),
        "is_eip1167": is_minimal,
        "verified": ver_info["verified"],
        "contract_name": ver_info.get("contract_name", ""),
    }

    if export_fmt:
        export_data([row], export_fmt, output)
        return

    # Display
    console.print()
    lines = [
        f"Address:        [cyan]{address}[/cyan]",
        f"Chain:          [cyan]{chain_cfg['name']}[/cyan]",
        f"Deployer:       [cyan]{deployer or 'Unknown'}[/cyan]",
        f"Creation Tx:    [dim]{creation_tx or 'Unknown'}[/dim]",
        f"Bytecode Size:  [yellow]{code_size:,} bytes[/yellow]",
        f"Verified:       {'[green]✓ Yes[/green]' if ver_info['verified'] else '[red]✗ No[/red]'}",
    ]

    if ver_info.get("contract_name"):
        lines.append(f"Contract Name:  [cyan]{ver_info['contract_name']}[/cyan]")

    if proxy_info["is_proxy"]:
        lines.append(f"Proxy:          [magenta]Yes ({proxy_info['proxy_type']})[/magenta]")
        if proxy_info.get("implementation"):
            lines.append(f"Implementation: [cyan]{proxy_info['implementation']}[/cyan]")
        if proxy_info.get("admin"):
            lines.append(f"Admin:          [yellow]{proxy_info['admin']}[/yellow]")
        if proxy_info.get("beacon"):
            lines.append(f"Beacon:         [cyan]{proxy_info['beacon']}[/cyan]")
    elif is_minimal:
        target = extract_eip1167_target(bytecode)
        lines.append(f"Proxy:          [magenta]Yes (EIP-1167 minimal proxy)[/magenta]")
        lines.append(f"Clone Target:   [cyan]{target}[/cyan]")
    else:
        lines.append("Proxy:          [dim]No[/dim]")

    console.print(Panel("\n".join(lines), title="Contract Inspection", expand=False))

    if ver_info.get("source_code"):
        console.print("\n[bold]Source Code Snippet:[/bold]")
        console.print(Panel(ver_info["source_code"], title="Source (first 500 chars)", expand=True))


# ---------------------------------------------------------------------------
# config — show current configuration
# ---------------------------------------------------------------------------

@cli.command()
def config():
    """Show current configuration, chain settings, and API key status."""
    table = make_table("Chain Configuration", [
        "Chain", "Chain ID", "Explorer API", "RPC Endpoint", "API Key Env", "Key Set"
    ])
    for key, cfg in CHAINS.items():
        api_key = _get_api_key(cfg)
        table.add_row(
            cfg["name"],
            str(cfg["chain_id"]),
            cfg["explorer_api"],
            cfg["rpc"],
            cfg["env_key"],
            "[green]✓[/green]" if api_key else "[dim]✗ (free tier)[/dim]",
        )
    console.print(table)

    cache_count = len(list(_cache_dir().glob("*.json")))
    console.print(Panel(
        f"Cache directory: [cyan]{_cache_dir()}[/cyan]\n"
        f"Cached entries:  [cyan]{cache_count}[/cyan]\n"
        f"Rate limit:      [cyan]5 req/sec per domain[/cyan]\n"
        f"Cache TTL:       [cyan]300s (API) / 60s (RPC)[/cyan]",
        title="Settings", expand=False
    ))


# ---------------------------------------------------------------------------
# cache — cache management
# ---------------------------------------------------------------------------

@cli.command()
@click.option("--clear", is_flag=True, help="Clear all cached data.")
@click.option("--show-dir", is_flag=True, help="Show cache directory path.")
def cache(clear: bool, show_dir: bool):
    """Manage the local response cache."""
    if show_dir:
        console.print(f"Cache directory: [cyan]{_cache_dir()}[/cyan]")

    if clear:
        count = clear_cache()
        console.print(f"[green]✓ Cleared {count} cached entries.[/green]")
    elif not show_dir:
        cache_dir = _cache_dir()
        files = list(cache_dir.glob("*.json"))
        console.print(f"Cache directory: [cyan]{cache_dir}[/cyan]")
        console.print(f"Cached entries: [cyan]{len(files)}[/cyan]")
        total_size = sum(f.stat().st_size for f in files)
        console.print(f"Total size: [cyan]{total_size / 1024:.1f} KB[/cyan]")


# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------

if __name__ == "__main__":
    cli()