Update solo_miner.py

solo_miner.py

@@ -1,204 +1,204 @@
-import sys
-import os
-import time
-import json
-import random
-import requests
-import platform
-import threading
-import subprocess
-import multiprocessing
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, Optional, Tuple
-from concurrent.futures import ThreadPoolExecutor
-from urllib.parse import urlparse
-try:
-    from cryptonight import cryptonight
-except ImportError:
-    print("Error: py-cryptonight not installed. Please install Python and run:")
-    print("pip install py-cryptonight requests rich")
-    sys.exit(1)
-
-class MoneroNodeManager:
-    def __init__(self):
-        self.daemon_url = None
-
-    def find_fastest_node(self) -> str:
-        """Find the fastest responding public node"""
-        from node_list import PUBLIC_NODES
-        best_latency = float('inf')
-        best_node = None
-
-        print("Finding fastest public node...")
-        for node in PUBLIC_NODES:
-            try:
-                start_time = time.time()
-                response = requests.get(f"{node}/get_info", timeout=5)
-                if response.status_code == 200:
-                    latency = time.time() - start_time
-                    if latency < best_latency:
-                        best_latency = latency
-                        best_node = node
-                    print(f"Node {node} responded in {latency:.2f}s")
-            except:
-                print(f"Node {node} not responding")
-                continue
-
-        if best_node:
-            print(f"\nSelected fastest node: {best_node} (latency: {best_latency:.2f}s)")
-            return best_node
-        raise Exception("No responsive public nodes found")
-
-class MoneroSoloMiner:
-    def __init__(self, daemon_url: str = None, threads: int = None):
-        self.node_manager = MoneroNodeManager()
-        self.daemon_url = daemon_url or self.node_manager.find_fastest_node()
-        self.threads = threads or (multiprocessing.cpu_count() - 1)
-        self.running = False
-        self.wallet_address = None
-        self.stats = {
-            "start_time": None,
-            "hashes": 0,
-            "blocks_found": 0,
-            "best_diff": 0,
-            "node_height": 0,
-            "network_height": 0
-        }
-        self._lock = threading.Lock()
-
-    def get_block_template(self) -> Optional[Dict]:
-        try:
-            payload = {
-                "jsonrpc": "2.0",
-                "id": "0",
-                "method": "get_block_template",
-                "params": {
-                    "wallet_address": self.wallet_address,
-                    "reserve_size": 1
-                }
-            }
-            response = requests.post(self.daemon_url + "/json_rpc", json=payload)
-            result = response.json().get("result", {})
-            return result
-        except Exception as e:
-            print(f"Error getting block template: {e}")
-            return None
-
-    def submit_block(self, block_blob: str) -> bool:
-        try:
-            payload = {
-                "jsonrpc": "2.0",
-                "id": "0",
-                "method": "submit_block",
-                "params": [block_blob]
-            }
-            response = requests.post(self.daemon_url + "/json_rpc", json=payload)
-            result = response.json()
-            if "error" not in result:
-                return True
-            print(f"Block submission error: {result['error']}")
-            return False
-        except Exception as e:
-            print(f"Error submitting block: {e}")
-            return False
-
-    def mine_block(self, block_template: Dict):
-        blob = block_template["blockhashing_blob"]
-        difficulty = int(block_template["difficulty"])
-        height = block_template["height"]
-
-        while self.running:
-            nonce = random.getrandbits(32)
-            blob = blob[:78] + hex(nonce)[2:].zfill(8) + blob[86:]
-            
-            hash_result = cryptonight(bytes.fromhex(blob))
-            result_num = int.from_bytes(hash_result, byteorder='little')
-            
-            with self._lock:
-                self.stats["hashes"] += 1
-                if result_num < difficulty:
-                    print(f"\nBlock found at height {height}!")
-                    self.stats["blocks_found"] += 1
-                    if self.submit_block(blob):
-                        print("Block successfully submitted!")
-                    return True
-                
-                current_diff = (2**256 - 1) // result_num
-                if current_diff > self.stats["best_diff"]:
-                    self.stats["best_diff"] = current_diff
-
-    def display_stats(self):
-        while self.running:
-            elapsed = time.time() - self.stats["start_time"]
-            hashrate = self.stats["hashes"] / elapsed if elapsed > 0 else 0
-            
-            print("\033[H\033[J")  # Clear screen
-            print(f"=== Monero Solo Mining Stats ===")
-            print(f"Runtime: {elapsed:.1f} seconds")
-            print(f"Hashrate: {hashrate:.2f} H/s")
-            print(f"Total hashes: {self.stats['hashes']}")
-            print(f"Blocks found: {self.stats['blocks_found']}")
-            print(f"Best diff: {self.stats['best_diff']}")
-            print(f"Mining with {self.threads} threads")
-            print("Press Ctrl+C to stop mining")
-            
-            time.sleep(1)
-
-    def start_mining(self):
-        print("Starting Monero solo mining...")
-        self.running = True
-        self.stats["start_time"] = time.time()
-
-        # Start stats display in a separate thread
-        stats_thread = threading.Thread(target=self.display_stats)
-        stats_thread.daemon = True
-        stats_thread.start()
-
-        while self.running:
-            template = self.get_block_template()
-            if not template:
-                print("Failed to get block template. Retrying in 10 seconds...")
-                time.sleep(10)
-                continue
-
-            with ThreadPoolExecutor(max_workers=self.threads) as executor:
-                futures = [executor.submit(self.mine_block, template) for _ in range(self.threads)]
-                for future in futures:
-                    if future.result():
-                        break
-
-    def stop_mining(self):
-        self.running = False
-
-if __name__ == "__main__":
-    import argparse
-    
-    parser = argparse.ArgumentParser(description='Monero Solo Miner')
-    parser.add_argument('--wallet', help='Your Monero wallet address (optional for testing)')
-    parser.add_argument('--threads', type=int, help='Number of mining threads')
-    parser.add_argument('--node', help='Custom node URL (optional)')
-    
-    args = parser.parse_args()
-    
-    try:
-        miner = MoneroSoloMiner(
-            daemon_url=args.node,
-            threads=args.threads
-        )
-        
-        # Use test wallet if none provided
-        miner.wallet_address = args.wallet or "44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A"  # Test wallet
-        
-        print(f"Mining with {miner.threads} threads on node: {miner.daemon_url}")
-        miner.start_mining()
-        
-    except KeyboardInterrupt:
-        print("\nStopping miner...")
-        miner.stop_mining()
-        print("\nMining stopped. Summary:")
-        print(f"Total hashes: {miner.stats['hashes']}")
-        print(f"Blocks found: {miner.stats['blocks_found']}")
-    except Exception as e:
-        print(f"Error: {e}")
-        sys.exit(1)
+import sys
+import os
+import time
+import json
+import random
+import requests
+import platform
+import threading
+import subprocess
+import multiprocessing
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Optional, Tuple
+from concurrent.futures import ThreadPoolExecutor
+from urllib.parse import urlparse
+try:
+    from pycryptonight import cn_slow_hash as cryptonight
+except ImportError:
+    print("Error: py-cryptonight not installed. Please install Python and run:")
+    print("pip install py-cryptonight requests rich")
+    sys.exit(1)
+
+class MoneroNodeManager:
+    def __init__(self):
+        self.daemon_url = None
+
+    def find_fastest_node(self) -> str:
+        """Find the fastest responding public node"""
+        from node_list import PUBLIC_NODES
+        best_latency = float('inf')
+        best_node = None
+
+        print("Finding fastest public node...")
+        for node in PUBLIC_NODES:
+            try:
+                start_time = time.time()
+                response = requests.get(f"{node}/get_info", timeout=5)
+                if response.status_code == 200:
+                    latency = time.time() - start_time
+                    if latency < best_latency:
+                        best_latency = latency
+                        best_node = node
+                    print(f"Node {node} responded in {latency:.2f}s")
+            except:
+                print(f"Node {node} not responding")
+                continue
+
+        if best_node:
+            print(f"\nSelected fastest node: {best_node} (latency: {best_latency:.2f}s)")
+            return best_node
+        raise Exception("No responsive public nodes found")
+
+class MoneroSoloMiner:
+    def __init__(self, daemon_url: str = None, threads: int = None):
+        self.node_manager = MoneroNodeManager()
+        self.daemon_url = daemon_url or self.node_manager.find_fastest_node()
+        self.threads = threads or (multiprocessing.cpu_count() - 1)
+        self.running = False
+        self.wallet_address = None
+        self.stats = {
+            "start_time": None,
+            "hashes": 0,
+            "blocks_found": 0,
+            "best_diff": 0,
+            "node_height": 0,
+            "network_height": 0
+        }
+        self._lock = threading.Lock()
+
+    def get_block_template(self) -> Optional[Dict]:
+        try:
+            payload = {
+                "jsonrpc": "2.0",
+                "id": "0",
+                "method": "get_block_template",
+                "params": {
+                    "wallet_address": self.wallet_address,
+                    "reserve_size": 1
+                }
+            }
+            response = requests.post(self.daemon_url + "/json_rpc", json=payload)
+            result = response.json().get("result", {})
+            return result
+        except Exception as e:
+            print(f"Error getting block template: {e}")
+            return None
+
+    def submit_block(self, block_blob: str) -> bool:
+        try:
+            payload = {
+                "jsonrpc": "2.0",
+                "id": "0",
+                "method": "submit_block",
+                "params": [block_blob]
+            }
+            response = requests.post(self.daemon_url + "/json_rpc", json=payload)
+            result = response.json()
+            if "error" not in result:
+                return True
+            print(f"Block submission error: {result['error']}")
+            return False
+        except Exception as e:
+            print(f"Error submitting block: {e}")
+            return False
+
+    def mine_block(self, block_template: Dict):
+        blob = block_template["blockhashing_blob"]
+        difficulty = int(block_template["difficulty"])
+        height = block_template["height"]
+
+        while self.running:
+            nonce = random.getrandbits(32)
+            blob = blob[:78] + hex(nonce)[2:].zfill(8) + blob[86:]
+            
+            hash_result = cryptonight(bytes.fromhex(blob))
+            result_num = int.from_bytes(hash_result, byteorder='little')
+            
+            with self._lock:
+                self.stats["hashes"] += 1
+                if result_num < difficulty:
+                    print(f"\nBlock found at height {height}!")
+                    self.stats["blocks_found"] += 1
+                    if self.submit_block(blob):
+                        print("Block successfully submitted!")
+                    return True
+                
+                current_diff = (2**256 - 1) // result_num
+                if current_diff > self.stats["best_diff"]:
+                    self.stats["best_diff"] = current_diff
+
+    def display_stats(self):
+        while self.running:
+            elapsed = time.time() - self.stats["start_time"]
+            hashrate = self.stats["hashes"] / elapsed if elapsed > 0 else 0
+            
+            print("\033[H\033[J")  # Clear screen
+            print(f"=== Monero Solo Mining Stats ===")
+            print(f"Runtime: {elapsed:.1f} seconds")
+            print(f"Hashrate: {hashrate:.2f} H/s")
+            print(f"Total hashes: {self.stats['hashes']}")
+            print(f"Blocks found: {self.stats['blocks_found']}")
+            print(f"Best diff: {self.stats['best_diff']}")
+            print(f"Mining with {self.threads} threads")
+            print("Press Ctrl+C to stop mining")
+            
+            time.sleep(1)
+
+    def start_mining(self):
+        print("Starting Monero solo mining...")
+        self.running = True
+        self.stats["start_time"] = time.time()
+
+        # Start stats display in a separate thread
+        stats_thread = threading.Thread(target=self.display_stats)
+        stats_thread.daemon = True
+        stats_thread.start()
+
+        while self.running:
+            template = self.get_block_template()
+            if not template:
+                print("Failed to get block template. Retrying in 10 seconds...")
+                time.sleep(10)
+                continue
+
+            with ThreadPoolExecutor(max_workers=self.threads) as executor:
+                futures = [executor.submit(self.mine_block, template) for _ in range(self.threads)]
+                for future in futures:
+                    if future.result():
+                        break
+
+    def stop_mining(self):
+        self.running = False
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Monero Solo Miner')
+    parser.add_argument('--wallet', help='Your Monero wallet address (optional for testing)')
+    parser.add_argument('--threads', type=int, help='Number of mining threads')
+    parser.add_argument('--node', help='Custom node URL (optional)')
+    
+    args = parser.parse_args()
+    
+    try:
+        miner = MoneroSoloMiner(
+            daemon_url=args.node,
+            threads=args.threads
+        )
+        
+        # Use test wallet if none provided
+        miner.wallet_address = args.wallet or "44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A"  # Test wallet
+        
+        print(f"Mining with {miner.threads} threads on node: {miner.daemon_url}")
+        miner.start_mining()
+        
+    except KeyboardInterrupt:
+        print("\nStopping miner...")
+        miner.stop_mining()
+        print("\nMining stopped. Summary:")
+        print(f"Total hashes: {miner.stats['hashes']}")
+        print(f"Blocks found: {miner.stats['blocks_found']}")
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)