Update app.py

app.py

@@ -1,266 +1,410 @@
-import requests
+import os
+import random
 import time
+import threading
 import re
-from colorama import init, Fore, Style
+import cloudscraper
+import requests
+from bs4 import BeautifulSoup
+from colorama import init, Fore
 
 init(autoreset=True)
-print = lambda *a, **k: __builtins__.print(*a, **k, flush=True)
 
+# ================= KONFIGURASI =================
+BASE_URL = "https://firefaucet.win"
+DASHBOARD_URL = f"{BASE_URL}/"
+FAUCET_URL = f"{BASE_URL}/faucet/"
+PAYOUT_URL = f"{BASE_URL}/internal-api/payout/"
+BALANCE_URL = f"{BASE_URL}/balance/"
+WITHDRAW_INFO_URL = f"{BASE_URL}/internal-api/withdraw/get-withdrawal-info/"
+WITHDRAW_URL = f"{BASE_URL}/api/withdraw/"          # <--- PERBAIKAN: endpoint withdraw
+LEVELS_URL = f"{BASE_URL}/levels"
+
+# Environment variables
+SOLVER_URLS = os.getenv("SOLVER_URLS", "https://gi2h-minerton23.hf.space").split(',')
+SOLVER_KEY = os.getenv("SOLVER_KEY", "00000000000000000000#0000000000000000000#000000000000000000#")
+PROXY_URL = os.getenv("PROXY_URL", None)
+LTC_ADDRESS = os.getenv("LTC_ADDRESS", "ltc1qrthepxg7yxs5d8v94k6y8p74q0qxvv7vk5qe7m")        # Alamat LTC tujuan withdraw
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Referer": DASHBOARD_URL
+}
+
+COOKIES = {
+    "session": "ae530762-a411-49c1-9b86-00741a937b60.l40aeEK2wwSTMN2ifOUFUIi7KVw",
+    "refer_by" : "1022644"
+}
+
+# ================= SOLVER TURNSTILE =================
+class TurnstileSolver:
+    def __init__(self, email=""):
+        self.email = email
+        self.solver_url = random.choice(SOLVER_URLS).strip()
+        self.sitekey = "0x4AAAAAAAEUvFih09RuyAna"
+
+    def solve(self, domain):
+        domain_with_proto = f"https://{domain}" if not domain.startswith('http') else domain
+        headers = {"Content-Type": "application/json", "key": SOLVER_KEY}
+        data = {"type": "turnstile", "domain": domain_with_proto, "siteKey": self.sitekey}
+
+        for attempt in range(1, 6):
+            try:
+                resp = requests.post(f"{self.solver_url}/solve", headers=headers, json=data, timeout=30)
+                result = resp.json()
+                if "taskId" not in result:
+                    print(Fore.RED + f"❌ Tidak ada taskId (percobaan {attempt})", flush=True)
+                    continue
+                task_id = result["taskId"]
+                for _ in range(30):
+                    time.sleep(5)
+                    poll = requests.post(f"{self.solver_url}/solve", headers=headers,
+                                         json={"taskId": task_id}, timeout=30)
+                    poll_res = poll.json()
+                    if poll_res.get("status") == "done":
+                        token = poll_res.get("token") or poll_res.get("solution", {}).get("token")
+                        if token:
+                            print(Fore.GREEN + "✅ Token Turnstile diterima", flush=True)
+                            return token
+                    elif poll_res.get("status") == "error":
+                        print(Fore.RED + f"⚠️ Error solver: {poll_res}", flush=True)
+                        break
+                print(Fore.YELLOW + "⏳ Timeout polling, coba solver lain?", flush=True)
+            except Exception as e:
+                print(Fore.RED + f"⚠️ Solver error: {e}", flush=True)
+                time.sleep(2 ** attempt)
+        return None
 
-class AllAndRichAutoClaim:
-    def __init__(self):
-        self.base = "https://partner.allandrich.shop"
-        self.dashboard_url = self.base + "/dashboard"
-        self.login_url = self.base + "/login"
+# ================= BOT UTAMA =================
+class FaucetBot:
+    def __init__(self, cookies, email="user@example.com"):
+        self.session = cloudscraper.create_scraper()
+        self.session.cookies.update(cookies)
+        self.email = email
+        self.solver = TurnstileSolver(email)
+        self.running = True
+        self.proxy_url = PROXY_URL
+        self.using_proxy = False
+
+        if self.proxy_url:
+            self.proxy_session = cloudscraper.create_scraper()
+            self.proxy_session.cookies.update(cookies)
+            proxies = {"http": self.proxy_url, "https": self.proxy_url}
+            self.proxy_session.proxies.update(proxies)
+        else:
+            self.proxy_session = None
+
+    def get_csrf_token(self, use_proxy=False):
+        session = self.proxy_session if use_proxy and self.proxy_session else self.session
+        try:
+            resp = session.get(DASHBOARD_URL, headers=HEADERS, timeout=30)
+            resp.raise_for_status()
+            soup = BeautifulSoup(resp.text, "html.parser")
+            token_input = soup.find("input", {"name": "csrf_token"})
+            if token_input:
+                return token_input['value']
+            else:
+                print(Fore.RED + "⚠️ CSRF token tidak ditemukan", flush=True)
+                return None
+        except Exception as e:
+            print(Fore.RED + f"⚠️ Gagal ambil CSRF: {e}", flush=True)
+            return None
 
-        self.email = "gi2h27@gmail.com"
+    def check_cooldown(self, html):
+        match = re.search(r'(?:after|in)\s+(\d+)\s*(minute|minutes|hour|hours)', html, re.IGNORECASE)
+        if match:
+            value = int(match.group(1))
+            unit = match.group(2).lower()
+            seconds = value * 3600 if 'hour' in unit else value * 60
+            print(Fore.YELLOW + f"⏳ Cooldown {value} {unit}, menunggu {seconds} detik...", flush=True)
+            time.sleep(seconds)
+            return True
+        if re.search(r'please come back after|try again later|cooldown', html, re.IGNORECASE):
+            default_wait = 30 * 60
+            print(Fore.YELLOW + f"⏳ Cooldown terdeteksi (tanpa durasi), menunggu {default_wait//60} menit default...", flush=True)
+            time.sleep(default_wait)
+            return True
+        return False
 
-        self.session = requests.Session()
-        self.session.headers.update({
-            "User-Agent": "Mozilla/5.0",
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Referer": self.dashboard_url
-        })
+    def get_balance(self, use_proxy=False):
+        session = self.proxy_session if use_proxy and self.proxy_session else self.session
+        try:
+            resp = session.get(BALANCE_URL, headers=HEADERS, timeout=30)
+            if resp.status_code != 200:
+                return None
+            soup = BeautifulSoup(resp.text, "html.parser")
+            usd_elem = soup.find("span", id="ltc-usd-balance")
+            ltc_elem = soup.find("b", id="ltc-balance")
+            usd = usd_elem.text.strip() if usd_elem else "N/A"
+            ltc = ltc_elem.text.strip() if ltc_elem else "N/A"
+            return usd, ltc
+        except Exception as e:
+            print(Fore.RED + f"⚠️ Gagal ambil balance: {e}", flush=True)
+            return None
 
-    # ========================
-    # LOGIN
-    # ========================
-    def get_login_csrf(self):
-        print("Opening login page...")
+    # ========== FUNGSI WITHDRAW ==========
+    def get_withdrawal_info(self, coin="ltc", use_proxy=False):
+        session = self.proxy_session if use_proxy and self.proxy_session else self.session
+        params = {"coin": coin}
+        try:
+            resp = session.get(WITHDRAW_INFO_URL, headers=HEADERS, params=params, timeout=30)
+            resp.raise_for_status()
+            return resp.json()
+        except Exception as e:
+            print(Fore.RED + f"⚠️ Gagal ambil info withdrawal: {e}", flush=True)
+            return None
+
+    def withdraw(self, coin="ltc", address=None, amount=None, use_proxy=False):
+        """Lakukan withdraw dengan amount USD ke address tertentu (network mainnet)"""
+        if not address:
+            address = LTC_ADDRESS
+            if not address:
+                print(Fore.RED + "❌ Alamat LTC tidak ditemukan. Set LTC_ADDRESS di environment variable.", flush=True)
+                return False
 
-        r = self.session.get(self.dashboard_url, timeout=30)
+        # Ambil info withdrawal
+        info = self.get_withdrawal_info(coin, use_proxy=use_proxy)
+        if not info:
+            return False
 
-        match = re.search(
-            r'name="csrf_token"\s+value="([^"]+)"',
-            r.text
-        )
+        user_balance_usd = info['user']['balance_usd']
+        if user_balance_usd < 4.0:
+            print(Fore.YELLOW + f"⏳ Saldo belum mencukupi untuk withdraw: ${user_balance_usd:.2f} < $4", flush=True)
+            return False
 
-        if match:
-            print("CSRF login OK")
-            return match.group(1)
+        daily_limit = info['user']['daily_withdrawal_limit']
+        max_possible = min(user_balance_usd, daily_limit['max'] - daily_limit['used'])
+        if max_possible < 4.0:
+            print(Fore.YELLOW + f"⏳ Maksimum withdraw ${max_possible:.2f} < $4", flush=True)
+            return False
 
-        print("CSRF login not found")
-        return None
+        if amount is None:
+            amount = max_possible
+        else:
+            amount = min(amount, max_possible)
 
-    def login(self):
-        csrf = self.get_login_csrf()
+        # Dapatkan CSRF token
+        csrf = self.get_csrf_token(use_proxy=use_proxy)
         if not csrf:
             return False
 
-        payload = {
+        # Data POST sesuai form (network mainnet untuk LTC)
+        data = {
             "csrf_token": csrf,
-            "website": "",
-            "js_challenge": "passed",
-            "email": self.email
+            "coin": coin,
+            "network": "mainnet",          # <--- PENTING: field network
+            "address": address,
+            "amount": str(amount)
         }
 
-        print("Sending login...")
-
-        r = self.session.post(
-            self.login_url,
-            data=payload,
-            timeout=30
-        )
-
-        if "dashboard" in r.text.lower():
-            print(f"{Fore.GREEN}✓ Login success{Style.RESET_ALL}")
-            return True
-
-        print("Login unclear, retry later")
-        return False
+        headers_post = HEADERS.copy()
+        headers_post.update({
+            "Content-Type": "application/x-www-form-urlencoded",
+            "X-Requested-With": "XMLHttpRequest"
+        })
 
-    # ========================
-    # UPDATE CSRF
-    # ========================
-    def update_csrf_token(self):
+        session = self.proxy_session if use_proxy and self.proxy_session else self.session
         try:
-            r = self.session.get(self.dashboard_url, timeout=30)
-
-            match = re.search(
-                r'name="csrf_token"\s+value="([^"]+)"',
-                r.text
-            )
-
-            if match:
-                return match.group(1)
-
+            resp = session.post(WITHDRAW_URL, headers=headers_post, data=data, timeout=30)
+            if resp.status_code == 200:
+                result = resp.json()
+                if result.get('success'):
+                    print(Fore.GREEN + f"✅ Withdraw sukses! ID: {result.get('withdrawal_id')}", flush=True)
+                    return True
+                else:
+                    print(Fore.RED + f"❌ Withdraw gagal: {result.get('message')}", flush=True)
+                    return False
+            else:
+                print(Fore.RED + f"❌ Withdraw error status: {resp.status_code}", flush=True)
+                return False
         except Exception as e:
-            print("CSRF error:", e)
-
-        return None
+            print(Fore.RED + f"⚠️ Gagal POST withdraw: {e}", flush=True)
+            return False
 
-    # ========================
-    # START FAUCET
-    # ========================
-    def start_faucet(self, csrf):
+    # ========== FUNGSI LEVEL ==========
+    def check_and_claim_levels(self, use_proxy=False):
+        """Cek level tiap jam dan klaim jika tersedia"""
+        session = self.proxy_session if use_proxy and self.proxy_session else self.session
         try:
-            data = {
-                "csrf_token": csrf,
-                "action": "start_faucet"
-            }
-
-            r = self.session.post(
-                self.dashboard_url,
-                data=data,
-                timeout=30
-            )
+            resp = session.get(LEVELS_URL, headers=HEADERS)
+            resp.raise_for_status()
+            soup = BeautifulSoup(resp.text, "html.parser")
 
-            txt = r.text.lower()
+            collect_buttons = [a['href'] for a in soup.select("a.collect-btn") if 'disabled' not in a.get('class', [])]
 
-            if "started" in txt:
-                print("✓ Faucet started")
-                return True
+            if not collect_buttons:
+                print(Fore.YELLOW + "⚠️ Tidak ada level yang tersedia untuk diklaim saat ini.")
+                return
 
-            if "already" in txt:
-                print("✓ Faucet already running")
-                return True
+            for href in collect_buttons:
+                url = href if href.startswith("http") else BASE_URL + href
+                print(Fore.MAGENTA + f"🟢 Mengklaim level: {url}")
+                claim_resp = session.get(url, headers=HEADERS)
+                if claim_resp.status_code == 200:
+                    print(Fore.GREEN + "✅ Claim level berhasil!")
+                else:
+                    print(Fore.RED + f"⚠️ Claim gagal, status code: {claim_resp.status_code}")
 
         except Exception as e:
-            print("Start faucet error:", e)
-
-        return False
-
-    # ========================
-    # BALANCE PARSER
-    # ========================
-    def extract_balance_info(self, html_text):
-        balance_info = {
-            "balance": "0.00000000",
-            "total_withdrawn": "0.00000000"
-        }
+            print(Fore.RED + "⚠️ Error saat cek atau klaim level:", e)
 
-        try:
-            balance_pattern = r'<div class="balance-display">([\d.,]+) DOGE</div>'
-            match = re.search(balance_pattern, html_text)
-            if match:
-                balance_info["balance"] = match.group(1).replace(",", "")
-
-            withdrawn_pattern = r'Total Withdrawn:\s*<strong>([\d.]+) DOGE</strong>'
-            match = re.search(withdrawn_pattern, html_text)
-            if match:
-                balance_info["total_withdrawn"] = match.group(1)
-
-        except:
-            pass
-
-        return balance_info
-
-    # ========================
-    # MESSAGE PARSER
-    # ========================
-    def extract_message_box(self, html):
-        match = re.search(
-            r'<div[^>]*id="message-box"[^>]*>(.*?)</div>',
-            html,
-            re.DOTALL
-        )
+    # ========== LOOP UTAMA ==========
+    def claim_faucet(self, use_proxy=False):
+        session = self.proxy_session if use_proxy and self.proxy_session else self.session
+        csrf = self.get_csrf_token(use_proxy=use_proxy)
+        if not csrf:
+            return False
 
-        if match:
-            msg = re.sub(r'<[^>]+>', '', match.group(1))
-            return re.sub(r'\s+', ' ', msg).strip()
+        token = self.solver.solve("firefaucet.win")
+        if not token:
+            print(Fore.RED + "❌ Gagal mendapatkan token Turnstile", flush=True)
+            return False
 
-        return None
+        data = {
+            "csrf_token": csrf,
+            "selected-captcha": "turnstile",
+            "cf-turnstile-response": token
+        }
+        headers_post = HEADERS.copy()
+        headers_post.update({
+            "Content-Type": "application/x-www-form-urlencoded",
+            "X-Requested-With": "XMLHttpRequest"
+        })
 
-    # ========================
-    # COLLECT
-    # ========================
-    def collect_reward(self, csrf):
         try:
-            data = {
-                "csrf_token": csrf,
-                "action": "collect"
-            }
-
-            r = self.session.post(
-                self.dashboard_url,
-                data=data,
-                timeout=30
-            )
-
-            info = self.extract_balance_info(r.text)
-            balance = info["balance"]
-            withdrawn = info["total_withdrawn"]
-
-            print("=" * 40)
-            print("Balance:", balance, "DOGE")
-            print("Withdrawn:", withdrawn, "DOGE")
-
-            msg = self.extract_message_box(r.text)
-            if msg:
-                print("INFO:", msg)
-
-            if "successful auto-withdrawal" in r.text.lower():
-                print("✓ Withdrawal success")
-                return True
-
-            if "please wait" in r.text.lower():
-                print("⏳ Timer active")
-                return False
-
-            if "credited" in r.text.lower():
-                return True
-
-            return False
-
+            resp = session.post(FAUCET_URL, headers=headers_post, data=data, timeout=30, allow_redirects=True)
+            html = resp.text
+            print(Fore.CYAN + f"📍 Response URL: {resp.url}", flush=True)
+            print(Fore.CYAN + f"📊 Status code: {resp.status_code}", flush=True)
+            if resp.history:
+                print(Fore.YELLOW + "🔄 Redirect history:", [r.url for r in resp.history], flush=True)
         except Exception as e:
-            print("Collect error:", e)
+            print(Fore.RED + f"⚠️ Gagal POST claim: {e}", flush=True)
             return False
 
-    # ========================
-    # MAIN LOOP
-    # ========================
-    def run_auto_claim(self, interval_minutes=1):
-        print("=" * 50)
-        print("🚀 Starting AllAndRich Auto Claim Bot")
-        print("=" * 50)
-
-        if not self.login():
-            print("Login failed")
-            return
+        if "Proxy Detected" in html or "<title>Proxy Detected</title>" in html:
+            print(Fore.RED + "🚫 Proxy terdeteksi!", flush=True)
+            return "proxy_detected"
 
-        claim_count = 0
+        if self.check_cooldown(html):
+            return False
 
-        while True:
+        success = False
+        soup = BeautifulSoup(html, "html.parser")
+        success_div = soup.find("div", class_="success_msg")
+        if success_div:
+            print(Fore.GREEN + f"✅ Claim sukses: {success_div.text.strip()}", flush=True)
+            success = True
+        elif "successfully added" in html.lower():
+            print(Fore.GREEN + "✅ Claim sukses (dari teks)", flush=True)
+            success = True
+        else:
+            print(Fore.RED + "❌ Claim gagal, respon tidak dikenali", flush=True)
+            print(Fore.YELLOW + "📄 HTML preview (first 500 chars):", flush=True)
+            print(html[:500], flush=True)
+
+        return success
+
+    def payout_loop(self):
+        while self.running:
             try:
-                print("\nAttempt:", claim_count + 1)
-                print("Time:", time.strftime('%Y-%m-%d %H:%M:%S'))
-
-                csrf = self.update_csrf_token()
-
-                if not csrf:
-                    print("CSRF refresh failed, retrying...")
-                    time.sleep(10)
-                    continue
-
-                result = self.collect_reward(csrf)
-
-                if not result:
-                    print("Trying start faucet...")
-                    self.start_faucet(csrf)
-
-                claim_count += 1
-
-                wait_time = interval_minutes * 60
-
-                for remaining in range(wait_time, 0, -1):
-                    if remaining % 15 == 0 or remaining <= 5:
-                        m, s = divmod(remaining, 60)
-                        print(f"Next claim in {m:02d}:{s:02d}")
-                    time.sleep(1)
-
-            except KeyboardInterrupt:
-                print("Bot stopped")
-                break
-
+                resp = self.session.get(PAYOUT_URL, headers=HEADERS, timeout=30)
+                resp.raise_for_status()
+                data = resp.json()
+                if data.get("success"):
+                    print(Fore.GREEN + f"💰 Payout berhasil! Balance: {data.get('balance')}", flush=True)
+                    print(Fore.CYAN + f"⏳ Next payout: {data.get('time_left')}", flush=True)
+                else:
+                    print(Fore.RED + f"⚠️ Payout gagal: {data}", flush=True)
             except Exception as e:
-                print("Loop error:", e)
-                time.sleep(30)
-
-
-def main():
-    bot = AllAndRichAutoClaim()
-    bot.run_auto_claim(1)
-
+                print(Fore.RED + f"⚠️ Gagal request payout: {e}", flush=True)
+            for _ in range(60):
+                if not self.running:
+                    break
+                time.sleep(1)
+
+    def balance_loop(self):
+        while self.running:
+            balance = self.get_balance(use_proxy=self.using_proxy)
+            if balance:
+                usd, ltc = balance
+                print(Fore.CYAN + f"💵 Balance: ${usd} USD | {ltc} LTC", flush=True)
+            else:
+                print(Fore.RED + "❌ Gagal mengambil balance", flush=True)
+            for _ in range(300):
+                if not self.running:
+                    break
+                time.sleep(1)
+
+    def withdraw_loop(self):
+        """Loop pengecekan saldo untuk withdraw setiap 5 menit"""
+        while self.running:
+            time.sleep(300)  # 5 menit
+            info = self.get_withdrawal_info(use_proxy=self.using_proxy)
+            if info and info['user']['balance_usd'] >= 4.0:
+                print(Fore.CYAN + f"💰 Saldo mencukupi untuk withdraw: ${info['user']['balance_usd']:.2f}", flush=True)
+                self.withdraw(use_proxy=self.using_proxy)
+            else:
+                if info:
+                    print(Fore.CYAN + f"💰 Saldo saat ini: ${info['user']['balance_usd']:.2f} (< $4)", flush=True)
+
+    def level_loop(self):
+        """Loop pengecekan level setiap jam"""
+        while self.running:
+            self.check_and_claim_levels(use_proxy=self.using_proxy)
+            # Tunggu 1 jam (3600 detik) sebelum cek lagi
+            for _ in range(3600):
+                if not self.running:
+                    break
+                time.sleep(1)
+
+    def claim_loop(self):
+        while self.running:
+            result = self.claim_faucet(use_proxy=False)
+
+            if result == "proxy_detected":
+                if self.proxy_session and not self.using_proxy:
+                    print(Fore.YELLOW + "🔄 Mencoba menggunakan proxy...", flush=True)
+                    result2 = self.claim_faucet(use_proxy=True)
+                    if result2 == "proxy_detected":
+                        print(Fore.RED + "🚫 Proxy juga terdeteksi. Menunggu 1 jam sebelum coba lagi...", flush=True)
+                        time.sleep(3600)
+                    elif result2 is True:
+                        print(Fore.GREEN + "✅ Claim sukses dengan proxy!", flush=True)
+                        self.using_proxy = True
+                        time.sleep(60)
+                        continue
+                    else:
+                        print(Fore.RED + "❌ Claim dengan proxy gagal karena alasan lain.", flush=True)
+                        time.sleep(10)
+                else:
+                    print(Fore.RED + "🚫 Proxy terdeteksi dan tidak ada proxy alternatif. Menunggu 1 jam...", flush=True)
+                    time.sleep(3600)
+            elif result is True:
+                print(Fore.CYAN + "⏳ Menunggu 60 detik sebelum claim berikutnya...", flush=True)
+                time.sleep(60)
+            else:
+                print(Fore.CYAN + "⏳ Mencoba lagi dalam 10 detik...", flush=True)
+                time.sleep(10)
+
+    def run(self):
+        print(Fore.MAGENTA + "🔹 Memulai bot faucet dengan Turnstile solver, thread payout, balance monitor, withdraw monitor, dan level checker...", flush=True)
+        payout_thread = threading.Thread(target=self.payout_loop, daemon=True)
+        payout_thread.start()
+        balance_thread = threading.Thread(target=self.balance_loop, daemon=True)
+        balance_thread.start()
+        withdraw_thread = threading.Thread(target=self.withdraw_loop, daemon=True)
+        withdraw_thread.start()
+        level_thread = threading.Thread(target=self.level_loop, daemon=True)
+        level_thread.start()
+        try:
+            self.claim_loop()
+        except KeyboardInterrupt:
+            print(Fore.YELLOW + "\n🛑 Dihentikan oleh user.", flush=True)
+            self.running = False
 
+# ================= EKSEKUSI =================
 if __name__ == "__main__":
-    main()
+    bot = FaucetBot(COOKIES, email="your_email@example.com")
+    bot.run()