# captcha_solver.py - PokéVault Asynchronous Python Standalone Solver
import asyncio
import time
import logging
import urllib.parse
from typing import Optional
import aiohttp
import discord

logger = logging.getLogger(__name__)

BALANCE_ENDPOINT = "http://148.113.8.216:8081/balance"

def _make_connector() -> aiohttp.TCPConnector:
    import ssl
    ctx = ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = ssl.CERT_NONE
    return aiohttp.TCPConnector(ssl=ctx)

async def fetch_license_balance(license_key: str, solver_url: str = "http://148.113.8.216:8081") -> Optional[dict]:
    """Fetch real-time daily quota usage and limits for a license key."""
    if not license_key:
        return None
    try:
        connector = _make_connector()
        async with aiohttp.ClientSession(connector=connector) as session:
            headers = {"Authorization": f"Bearer {license_key}"}
            async with session.get(f"{solver_url}/balance", headers=headers, timeout=aiohttp.ClientTimeout(total=15)) as resp:
                if resp.status != 200:
                    return None
                res_json = await resp.json(content_type=None)
                data = res_json.get("data", {})
                is_unlimited = data.get("is_unlimited", False)
                daily_limit = data.get("daily_limit", 2000)
                return {
                    "is_unlimited": is_unlimited,
                    "remaining": "Unlimited" if is_unlimited else data.get("solves_remaining", "N/A"),
                    "daily_usage": data.get("daily_usage", 0),
                    "daily_limit": "Unlimited" if daily_limit == -1 else str(daily_limit),
                    "plan_type": str(data.get("plan_type", "payg")).upper()
                }
    except Exception:
        return None

async def solve_captcha_for_client(token: str, user_id: str, username: str, api_key: str, solver_url: str = "http://148.113.8.216:8081", captcha_webhook: str = None) -> dict:
    """End-to-end OAuth Captcha Solver using PokéVault solver cluster."""
    hcaptcha_sitekey = '24e07a58-bdb4-492c-96aa-33b0ea7e1b2c'
    hcaptcha_host = 'verify.poketwo.net'
    user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Not_A Brand/24"

    if not api_key:
        return {"success": False, "error": "No solverApiKey provided"}

    last_error = "Solve failed"

    for attempt in range(1, 4):
        try:
            logger.info("[Attempt %d/3] Starting end-to-end solve for %s...", attempt, username)
            start_time = time.monotonic()
            connector = _make_connector()
            
            async with aiohttp.ClientSession(connector=connector) as session:
                # ── Step 1 & 3: Solve hCaptcha AND Submit to Poketwo ──
                solve_payload = {
                    "uid": user_id,
                    "sitekey": hcaptcha_sitekey,
                    "host": hcaptcha_host,
                    "user_agent": user_agent
                }
                headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
                
                async with session.post(f"{solver_url}/solve_and_submit", json=solve_payload, headers=headers, timeout=300) as resp:
                    if resp.status == 403:
                        return {"success": False, "error": "API Key has run out of solves!"}
                    elif resp.status == 401:
                        return {"success": False, "error": "Invalid API Key!"}
                    solve_result = await resp.json()
                        
                if not solve_result or not solve_result.get("success"):
                    last_error = f"Solve/Submit failed: {solve_result.get('error', 'Unknown error')}"
                    continue

                oauth_url = solve_result.get("location")
                if not oauth_url or "discord.com/oauth2" not in oauth_url:
                    last_error = "No Discord OAuth URL received from solver"
                    continue

                # ── Step 2 & 4: Authorize Discord OAuth ──
                parsed_url = urllib.parse.urlparse(oauth_url)
                api_auth_url = f"https://discord.com/api/v9/oauth2/authorize?{parsed_url.query}"
                auth_headers = {"Authorization": token, "Content-Type": "application/json"}
                auth_payload = {"permissions": "0", "authorize": True, "integration_type": 0}
                
                async with session.post(api_auth_url, json=auth_payload, headers=auth_headers, timeout=30) as auth_resp:
                    auth_data = await auth_resp.json()
                    callback_url = auth_data.get("location")
                        
                if not callback_url:
                    return {"success": True, "solveTime": f"{(time.monotonic() - start_time):.2f}"}
                    
                # Navigate callback via pure HTTP using cf_get
                cb_payload = {
                    "url": callback_url,
                    "headers": {
                        "Cookie": solve_result.get("cookieString", ""),
                        "User-Agent": solve_result.get("userAgent", user_agent),
                        "Referer": "https://discord.com/"
                    },
                    "proxy": solve_result.get("proxyUsed", "")
                }
                
                async with session.post(f"{solver_url}/cf_get", json=cb_payload, headers=headers, timeout=60) as cb_resp:
                    cb_data = await cb_resp.json()
                        
                elapsed = time.monotonic() - start_time
                return {"success": True, "solveTime": f"{elapsed:.2f}"}
                
        except Exception as err:
            last_error = f"Solver exception: {err}"
            logger.warning("[Warning] Captcha solve attempt %d/3 failed: %s", attempt, last_error)
            
        if attempt < 3:
            await asyncio.sleep(3)

    return {"success": False, "error": last_error}

Python OTP Code Fetcher Snippet:

# rxc_mail_fetcher.py - Fetch verification codes from RXCMails accounts
import imaplib
import email
import re
import time

def fetch_latest_verification_code(email_user: str, email_pass: str, timeout_sec: int = 45) -> str:
    """
    Connects to mail.rxcmails.online:993 via SSL, polls inbox, and extracts 6-digit OTP code.
    """
    IMAP_HOST = 'mail.rxcmails.online'
    IMAP_PORT = 993

    start_time = time.time()
    while time.time() - start_time < timeout_sec:
        try:
            mail = imaplib.IMAP4_SSL(IMAP_HOST, IMAP_PORT)
            mail.login(email_user, email_pass)
            mail.select('INBOX')

            status, messages = mail.search(None, 'ALL')
            msg_ids = messages[0].split()

            if msg_ids:
                latest_id = msg_ids[-1]
                status, data = mail.fetch(latest_id, '(RFC822)')
                raw_email = data[0][1]
                msg = email.message_from_bytes(raw_email)

                # Extract email body
                body = ""
                if msg.is_multipart():
                    for part in msg.walk():
                        if part.get_content_type() == "text/plain":
                            body = part.get_payload(decode=True).decode()
                            break
                else:
                    body = msg.get_payload(decode=True).decode()

                # Extract 6-digit numerical OTP or verification links
                code_match = re.search(r'\b(\d{6})\b', body)
                mail.logout()
                if code_match:
                    return code_match.group(1)

            mail.logout()
        except Exception as e:
            print(f"[IMAP Warning] {e}")

        time.sleep(3)

    return None

# Usage example:
# otp = fetch_latest_verification_code("user123@rxcmails.online", "generated_password")
# print("Fetched OTP:", otp)

{
  "solver_url": "http://148.113.8.216:8081/solve",
  "solver_key": "YOUR_PEAK_KEY_HERE",
  "captcha_webhook": "https://discord.com/api/webhooks/YOUR_WEBHOOK_URL",
  "auto_submit": true
}