Upload 4 files

node_list.py

@@ -0,0 +1,8 @@
+# List of reliable public Monero nodes
+PUBLIC_NODES = [
+    "https://node.moneroworld.com:18089",
+    "https://node.supportxmr.com:18089",
+    "https://node.xmr.ru:18081",
+    "https://node.c3pool.com:18089",
+    "https://node.xmr.to:18081"
+]

requirements.txt

@@ -0,0 +1,3 @@
+py-cryptonight>=0.2.0
+requests>=2.25.1
+rich>=10.0.0

solo_miner.py

@@ -0,0 +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)

xmrig-config.json.template

@@ -0,0 +1,25 @@
+{
+  "algo": "rx/0",
+  "autosave": true,
+  "cpu": true,
+  "opencl": false,
+  "cuda": false,
+  "pools": [
+    {
+      "url": "127.0.0.1:18081",
+      "user": "{{WALLET_ADDRESS}}",
+      "pass": "x",
+      "keepalive": true,
+      "rig-id": "solo",
+      "nicehash": false,
+      "enabled": true
+    }
+  ],
+  "api": {
+    "id": null,
+    "worker-id": null,
+    "port": {{API_PORT}},
+    "access-token": null,
+    "restricted": true
+  }
+}