scripts/preprocess.py

"""
Web3Coders Dataset Preprocessor – 2026 Edition (v2.0)

Preprocesses raw contract source files into the final dataset format:
- Compiles contracts to obtain bytecode and ABI (where applicable)
- Extracts security and gas metrics via Slither (Solidity) or equivalent
- Annotates with Halal compliance using HalalChain Compliance Checker
- Classifies contract type (DeFi, NFT, Token, etc.)
- Outputs JSONL files ready for Hugging Face dataset.

Usage:
    python scripts/preprocess.py --input source_contracts/ --output data/
    python scripts/preprocess.py --input source_contracts/ --output data/ --workers 8 --halal-api http://localhost:8000

Options:
    --input        Input directory containing contract source files
    --output       Output directory for JSONL shards (default: data/)
    --workers      Number of parallel workers (default: 4)
    --shard-size   Number of records per shard (default: 10000)
    --halal-api    Optional API endpoint for Halal compliance checking
    --no-compile   Skip compilation (only use existing ABIs/bytecode if provided)
"""

import os
import sys
import json
import hashlib
import subprocess
import argparse
import tempfile
import shutil
from pathlib import Path
from typing import Dict, Any, List, Optional, Tuple
from concurrent.futures import ThreadPoolExecutor, as_completed
import requests
from tqdm import tqdm

# ----------------------------------------------------------------------
# Language compilers/analyzers
# ----------------------------------------------------------------------

LANGUAGE_CONFIG = {
    "solidity": {
        "extensions": [".sol"],
        "compile_cmd": ["solc", "--combined-json", "bin,abi,hashes", "--optimize"],
        "analysis_module": "slither",  # fallback to subprocess if slither not importable
    },
    "vyper": {
        "extensions": [".vy"],
        "compile_cmd": ["vyper", "-f", "bytecode", "abi"],
    },
    "rust": {
        "extensions": [".rs"],
        "compile_cmd": ["rustc", "--emit=llvm-bc"],  # not directly usable for EVM
        "note": "Rust contracts (e.g., Solana) require special handling; placeholder."
    },
    "move": {
        "extensions": [".move"],
        "compile_cmd": ["move", "build"],  # Move CLI
        "note": "Move contracts (Aptos/Sui) require separate tooling; placeholder."
    },
}

# ----------------------------------------------------------------------
# Helper functions
# ----------------------------------------------------------------------

def compile_solidity(file_path: Path) -> Tuple[Optional[str], Optional[str]]:
    """Compile Solidity and return (bytecode, abi)."""
    try:
        # Use solc with combined-json output
        cmd = ["solc", "--combined-json", "bin,abi", str(file_path)]
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
        if result.returncode != 0:
            return None, None

        output = json.loads(result.stdout)
        # Expecting something like: {"contracts": {"file.sol:ContractName": {"bin": "...", "abi": "..."}}}
        contracts = output.get("contracts", {})
        if not contracts:
            return None, None

        # Take the first contract (usually the main one)
        contract_key = next(iter(contracts))
        contract_data = contracts[contract_key]
        bytecode = contract_data.get("bin")
        abi = contract_data.get("abi")
        return bytecode, abi
    except Exception as e:
        print(f"Compilation error for {file_path}: {e}", file=sys.stderr)
        return None, None

def compile_vyper(file_path: Path) -> Tuple[Optional[str], Optional[str]]:
    """Compile Vyper and return (bytecode, abi)."""
    try:
        # Vyper 0.3+ can output multiple formats
        # We'll run separately for bytecode and abi
        bytecode_cmd = ["vyper", "-f", "bytecode", str(file_path)]
        bytecode_result = subprocess.run(bytecode_cmd, capture_output=True, text=True, timeout=30)
        if bytecode_result.returncode != 0:
            return None, None
        bytecode = bytecode_result.stdout.strip()

        abi_cmd = ["vyper", "-f", "abi", str(file_path)]
        abi_result = subprocess.run(abi_cmd, capture_output=True, text=True, timeout=30)
        if abi_result.returncode != 0:
            return bytecode, None
        abi = abi_result.stdout.strip()
        return bytecode, abi
    except Exception as e:
        print(f"Compilation error for {file_path}: {e}", file=sys.stderr)
        return None, None

def analyze_solidity_security(file_path: Path) -> Dict[str, Any]:
    """Use Slither to get security and gas info."""
    try:
        # Try importing slither
        from slither import Slither
        slither = Slither(str(file_path))
        vulnerabilities = []
        for detector in slither.detectors:
            vulnerabilities.extend([v.name for v in detector.detect()])

        # Gas estimates: approximate
        gas_info = {}
        for f in slither.functions:
            if f.gas_estimated:
                gas_info[f.name] = f.gas_estimated

        # Quality score
        score = slither.get_code_quality_score() if hasattr(slither, 'get_code_quality_score') else 0

        return {
            "vulnerabilities": vulnerabilities,
            "gas_estimates": gas_info,
            "slither_score": score,
        }
    except ImportError:
        # Fallback: use slither CLI to get output
        try:
            cmd = ["slither", str(file_path), "--json", "-"]
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
            if result.returncode != 0:
                return {"vulnerabilities": [], "gas_estimates": {}, "slither_score": 0}
            data = json.loads(result.stdout)
            # Parse detection results
            vulns = []
            for detection in data.get("detectors", []):
                vulns.extend([issue["check"] for issue in detection.get("issues", [])])
            # Gas not easily extracted via CLI; leave empty
            return {"vulnerabilities": vulns, "gas_estimates": {}, "slither_score": 0}
        except Exception:
            return {"vulnerabilities": [], "gas_estimates": {}, "slither_score": 0}
    except Exception as e:
        print(f"Slither analysis error for {file_path}: {e}", file=sys.stderr)
        return {"vulnerabilities": [], "gas_estimates": {}, "slither_score": 0}

def classify_contract_type(source_code: str) -> str:
    """Heuristic classification of contract type based on keywords and patterns."""
    source = source_code.lower()
    if "interface" in source and "erc20" in source:
        return "Token"
    elif "erc721" in source or "erc1155" in source:
        return "NFT"
    elif "dao" in source or "governance" in source or "proposal" in source:
        return "DAO"
    elif "lending" in source or "borrow" in source or "pool" in source:
        return "DeFi"
    elif "murabaha" in source or "mudarabah" in source or "islamic" in source:
        return "Islamic Finance"
    elif "staking" in source or "rewards" in source:
        return "Staking"
    else:
        return "General"

def check_halal_compliance(source_code: str, api_endpoint: Optional[str] = None) -> Tuple[str, str]:
    """
    Check Halal compliance using either local module or API.
    Returns (status, fatwa_reference).
    """
    # Default to pending if not determined
    status = "pending"
    fatwa_ref = ""

    if api_endpoint:
        try:
            resp = requests.post(
                f"{api_endpoint}/compliance",
                json={"source": source_code},
                timeout=30
            )
            if resp.status_code == 200:
                data = resp.json()
                status = data.get("status", "pending")
                fatwa_ref = data.get("fatwa_reference", "")
        except Exception as e:
            print(f"Halal API error: {e}", file=sys.stderr)
    else:
        # Attempt to use local halalchain module if available
        try:
            from halalchain import ComplianceChecker
            checker = ComplianceChecker()
            result = checker.check_contract(source_code, rules=["no-riba", "no-gharar"])
            status = result.get("status", "pending")
            fatwa_ref = result.get("fatwa_reference", "")
        except ImportError:
            # Local fallback: simple keyword checks
            if "riba" not in source_code.lower() and "interest" not in source_code.lower():
                status = "compliant"
            else:
                status = "non-compliant"
    return status, fatwa_ref

# ----------------------------------------------------------------------
# Main preprocessing worker
# ----------------------------------------------------------------------

def process_contract(file_path: Path, config: Dict) -> Optional[Dict[str, Any]]:
    """
    Process a single contract file and return a record ready for dataset.
    """
    lang = None
    for l, cfg in LANGUAGE_CONFIG.items():
        if file_path.suffix in cfg["extensions"]:
            lang = l
            break
    if not lang:
        return None

    # Read source code
    with open(file_path, "r", encoding="utf-8") as f:
        source_code = f.read()

    # Compile to get bytecode and ABI (if not disabled)
    bytecode = None
    abi = None
    if not config.get("no_compile", False):
        if lang == "solidity":
            bytecode, abi = compile_solidity(file_path)
        elif lang == "vyper":
            bytecode, abi = compile_vyper(file_path)
        else:
            # For Rust/Move, we cannot easily get EVM bytecode; leave empty
            pass

    # Security & gas analysis (only for Solidity for now)
    security_audit = {}
    gas_estimates = []
    if lang == "solidity":
        sec = analyze_solidity_security(file_path)
        security_audit = sec
        # Convert gas dict to list of floats (average or max)
        if sec.get("gas_estimates"):
            gas_estimates = list(sec["gas_estimates"].values())
        # Determine audit pass/fail based on vulnerabilities
        audit_status = "pass" if len(sec.get("vulnerabilities", [])) == 0 else "fail"

    # Halal compliance
    status, fatwa_ref = check_halal_compliance(source_code, config.get("halal_api"))

    # Contract type classification
    contract_type = classify_contract_type(source_code)

    # Build record
    record = {
        "source_code": source_code,
        "bytecode": bytecode or "",
        "abi": abi or "",
        "gas_estimates": gas_estimates,
        "security_audit": security_audit.get("vulnerabilities", []) if lang == "solidity" else "",
        "halal_compliance": status,
        "fatwa_reference": fatwa_ref,
        "contract_type": contract_type,
    }
    return record

# ----------------------------------------------------------------------
# Directory processing with sharding
# ----------------------------------------------------------------------

def process_directory(input_dir: Path, output_dir: Path, config: Dict):
    """
    Process all contract files in input_dir and write JSONL shards to output_dir.
    """
    # Collect all files with known extensions
    files = []
    for lang, cfg in LANGUAGE_CONFIG.items():
        for ext in cfg["extensions"]:
            files.extend(input_dir.rglob(f"*{ext}"))

    total = len(files)
    print(f"Found {total} contract files to process.")

    # Create output directory
    output_dir.mkdir(parents=True, exist_ok=True)

    # Determine shard size
    shard_size = config.get("shard_size", 10000)

    # Parallel processing
    workers = config.get("workers", 4)
    records = []
    errors = []

    with ThreadPoolExecutor(max_workers=workers) as executor:
        futures = {executor.submit(process_contract, f, config): f for f in files}
        with tqdm(total=total, desc="Processing contracts") as pbar:
            for future in as_completed(futures):
                file_path = futures[future]
                try:
                    record = future.result()
                    if record:
                        records.append(record)
                    else:
                        errors.append(str(file_path))
                except Exception as e:
                    errors.append(f"{file_path}: {e}")
                pbar.update(1)

    print(f"Processed {len(records)} contracts successfully, {len(errors)} errors.")

    # Write shards
    split_name = "train"  # assume all go to train; could be split later
    for i in range(0, len(records), shard_size):
        shard_records = records[i:i+shard_size]
        shard_num = i // shard_size
        shard_file = output_dir / f"{split_name}-{shard_num:05d}-of-{ (len(records)//shard_size)+1 :05d}.jsonl"
        with open(shard_file, "w", encoding="utf-8") as f:
            for rec in shard_records:
                f.write(json.dumps(rec) + "\n")
        print(f"Written {shard_file} with {len(shard_records)} records.")

    # Optionally create validation and test splits (e.g., random sampling)
    # For simplicity, we skip here; user can split later.

# ----------------------------------------------------------------------
# Main
# ----------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser(description="Preprocess Web3Coders dataset (2026)")
    parser.add_argument("--input", required=True, help="Input directory with source contracts")
    parser.add_argument("--output", default="data", help="Output directory for JSONL shards")
    parser.add_argument("--workers", type=int, default=4, help="Number of parallel workers")
    parser.add_argument("--shard-size", type=int, default=10000, help="Records per shard")
    parser.add_argument("--halal-api", help="Halal compliance API endpoint (optional)")
    parser.add_argument("--no-compile", action="store_true", help="Skip compilation (use existing ABI/bytecode if available?)")
    args = parser.parse_args()

    input_dir = Path(args.input)
    if not input_dir.exists():
        print(f"Error: Input directory {input_dir} does not exist.", file=sys.stderr)
        sys.exit(1)

    output_dir = Path(args.output)

    config = {
        "workers": args.workers,
        "shard_size": args.shard_size,
        "halal_api": args.halal_api,
        "no_compile": args.no_compile,
    }

    process_directory(input_dir, output_dir, config)

if __name__ == "__main__":
    main()