popov/mines
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix name

Browse Source
This commit is contained in:
Dobromir Popov
2025-09-15 22:58:27 +03:00
parent c796013f19
commit d18906f1b1
6 changed files with 130 additions and 1448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
rin/proxy/custom/stratum_proxy.py
View File

@@ -1,7 +1,7 @@
#!/usr/bin/env python3
"""
RinCoin Stratum Proxy Server - REAL MINING VERSION
Properly constructs Stratum jobs and validates/submits real blocks
RinCoin Stratum Proxy Server - FIXED VERSION
Fixed block hash calculation and validation issues
"""
import socket
@@ -13,7 +13,7 @@ import hashlib
import struct
from requests.auth import HTTPBasicAuth
class RinCoinStratumBase:
class RinCoinStratumProxy:
def __init__(self, stratum_host='0.0.0.0', stratum_port=3334,
rpc_host='127.0.0.1', rpc_port=9556,
rpc_user='rinrpc', rpc_password='745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90',
@@ -33,7 +33,7 @@ class RinCoinStratumBase:
self.running = True
self.extranonce1_counter = 0
print(f"RinCoin Stratum Proxy Server - REAL MINING")
print(f"RinCoin Stratum Proxy Server")
print(f"Stratum: {stratum_host}:{stratum_port}")
print(f"RPC: {rpc_host}:{rpc_port}")
print(f"Target: {target_address}")
@@ -196,14 +196,21 @@ class RinCoinStratumBase:
return b'\x00' * 32
def bits_to_target(self, bits_hex):
"""Convert bits to target"""
"""Convert bits to target - FIXED VERSION"""
try:
bits = int(bits_hex, 16)
exponent = bits >> 24
mantissa = bits & 0xffffff
target = mantissa * (256 ** (exponent - 3))
# Bitcoin target calculation
if exponent <= 3:
target = mantissa >> (8 * (3 - exponent))
else:
target = mantissa << (8 * (exponent - 3))
return f"{target:064x}"
except:
except Exception as e:
print(f"Bits to target error: {e}")
return "0000ffff00000000000000000000000000000000000000000000000000000000"
def get_block_template(self):
@@ -241,21 +248,19 @@ class RinCoinStratumBase:
return None
def calculate_share_difficulty(self, hash_hex, target_hex):
"""Calculate actual share difficulty from hash"""
"""Calculate actual share difficulty from hash - FIXED"""
try:
hash_int = int(hash_hex, 16)
target_int = int(target_hex, 16)
if hash_int == 0:
return float('inf') # Perfect hash
# Bitcoin-style difficulty calculation
# Lower hash = higher difficulty
# Difficulty 1.0 = finding hash that meets network target exactly
max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
# Bitcoin-style difficulty calculation using difficulty 1 target
# Difficulty 1 target for mainnet
diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
# Share difficulty = how hard this specific hash was to find
difficulty = max_target / hash_int
# Share difficulty = how much harder this hash was compared to diff 1
difficulty = diff1_target / hash_int
return difficulty
except Exception as e:
@@ -263,15 +268,15 @@ class RinCoinStratumBase:
return 0.0
def calculate_network_difficulty(self, target_hex):
"""Calculate network difficulty from target"""
"""Calculate network difficulty from target - FIXED"""
try:
target_int = int(target_hex, 16)
# Bitcoin difficulty 1.0 target
max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
# Network difficulty = how much harder than difficulty 1.0
network_difficulty = max_target / target_int
network_difficulty = diff1_target / target_int
return network_difficulty
except Exception as e:
@@ -279,7 +284,7 @@ class RinCoinStratumBase:
return 1.0
def submit_share(self, job, extranonce1, extranonce2, ntime, nonce, target_address=None):
"""Validate share and submit block if valid"""
"""Validate share and submit block if valid - FIXED VERSION"""
try:
# Use provided address or default
address = target_address or self.target_address
@@ -296,33 +301,34 @@ class RinCoinStratumBase:
# Calculate merkle root
merkle_root = self.calculate_merkle_root(coinbase_txid, job['transactions'])
# Build block header
# Build block header - FIXED ENDIANNESS
header = b''
header += struct.pack('<I', job['version']) # Version
header += bytes.fromhex(job['prevhash'])[::-1] # Previous block hash
header += merkle_root[::-1] # Merkle root (reversed for big-endian)
header += struct.pack('<I', int(ntime, 16)) # Timestamp
header += bytes.fromhex(job['bits'])[::-1] # Bits
header += struct.pack('<I', int(nonce, 16)) # Nonce
header += struct.pack('<I', job['version']) # Version (little-endian)
header += bytes.fromhex(job['prevhash'])[::-1] # Previous block hash (big-endian in block)
header += merkle_root # Merkle root (already in correct endian)
header += struct.pack('<I', int(ntime, 16)) # Timestamp (little-endian)
header += bytes.fromhex(job['bits'])[::-1] # Bits (big-endian in block)
header += struct.pack('<I', int(nonce, 16)) # Nonce (little-endian)
# Calculate block hash
# Calculate block hash - FIXED DOUBLE SHA256
block_hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
block_hash_hex = block_hash[::-1].hex()
block_hash_hex = block_hash[::-1].hex() # Reverse for display/comparison
# Calculate real difficulties
share_difficulty = self.calculate_share_difficulty(block_hash_hex, job['target'])
network_difficulty = self.calculate_network_difficulty(job['target'])
# Check if hash meets target
# Check if hash meets target - FIXED COMPARISON
hash_int = int(block_hash_hex, 16)
target_int = int(job['target'], 16)
meets_target = hash_int <= target_int # FIXED: less than or equal
# Enhanced logging
timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
difficulty_percentage = (share_difficulty / network_difficulty) * 100 if network_difficulty > 0 else 0
# Progress indicator based on percentage
if difficulty_percentage >= 100:
if meets_target:
progress_icon = "🎉" # Block found!
elif difficulty_percentage >= 50:
progress_icon = "🔥" # Very close
@@ -338,37 +344,12 @@ class RinCoinStratumBase:
print(f" 📈 Progress: {difficulty_percentage:.4f}% of network difficulty")
print(f" 📍 Target: {job['target'][:16]}... | Height: {job['height']}")
print(f" ⏰ Time: {ntime} | Extranonce: {extranonce1}:{extranonce2}")
print(f" 🔍 Hash vs Target: {hash_int} {'<=' if meets_target else '>'} {target_int}")
if hash_int > target_int:
# Valid share but not a block - still send to node for validation
print(f" ✅ Share accepted (below network difficulty)")
# Send to node anyway to validate our work
try:
# Build complete block for validation
block = header
tx_count = 1 + len(job['transactions'])
block += self.encode_varint(tx_count)
block += coinbase_wit
for tx in job['transactions']:
block += bytes.fromhex(tx['data'])
block_hex = block.hex()
print(f" 🔍 Sending share to node for validation...")
result = self.rpc_call("submitblock", [block_hex])
if result is None:
print(f" 🎉 SURPRISE BLOCK! Node accepted our 'low difficulty' share as valid block!")
return True, "Block found and submitted"
else:
print(f" 📊 Node rejected as expected: {result}")
return True, "Share validated by node"
except Exception as e:
print(f" ⚠️ Node validation error: {e}")
return True, "Share accepted (node validation failed)"
return True, "Share accepted"
if not meets_target:
# Share doesn't meet target - reject but still useful for debugging
print(f" ❌ Share rejected (hash > target)")
return False, "Share too high"
# Valid block! Build full block and submit
print(f" 🎉 BLOCK FOUND! Hash: {block_hash_hex}")
@@ -407,10 +388,6 @@ class RinCoinStratumBase:
except Exception as e:
print(f"Share submission error: {e}")
return False, f"Submission error: {e}"
except Exception as e:
print(f"Share submission error: {e}")
return False, f"Submission error: {e}"
def send_stratum_response(self, client, msg_id, result, error=None):
"""Send Stratum response to client"""
@@ -463,8 +440,8 @@ class RinCoinStratumBase:
4 # extranonce2 size
])
# Send difficulty
self.send_stratum_notification(client, "mining.set_difficulty", [0.0001])
# Send difficulty - MUCH LOWER for testing
self.send_stratum_notification(client, "mining.set_difficulty", [0.00001])
# Send initial job
if self.current_job:
@@ -481,7 +458,6 @@ class RinCoinStratumBase:
print(f"[{timestamp}] 🔐 [{addr}] Authorized as {username}")
elif method == "mining.extranonce.subscribe":
# Handle extranonce subscription
self.send_stratum_response(client, msg_id, True)
elif method == "mining.submit":
@@ -494,38 +470,21 @@ class RinCoinStratumBase:
print(f"[{addr}] Submit: {username} | job={job_id} | nonce={nonce}")
# Validate submission
if self.current_job and job_id == self.current_job['job_id']:
# Always validate against current job
if self.current_job:
extranonce1 = self.clients[addr].get('extranonce1', '00000000')
# Submit share
success, message = self.submit_share(self.current_job, extranonce1, extranonce2, ntime, nonce)
if success:
self.send_stratum_response(client, msg_id, True)
if "Block found" in message:
# Get new job after block found
threading.Thread(target=self.update_job_after_block, daemon=True).start()
else:
self.send_stratum_response(client, msg_id, False, message)
# Always accept shares for debugging, even if they don't meet target
self.send_stratum_response(client, msg_id, True)
if success and "Block found" in message:
# Get new job after block found
threading.Thread(target=self.update_job_after_block, daemon=True).start()
else:
# For stale jobs, still validate for blocks but don't require exact job match
# This prevents missing blocks due to job timing issues
if self.current_job:
extranonce1 = self.clients[addr].get('extranonce1', '00000000')
# Use current job template but allow stale job_id
success, message = self.submit_share(self.current_job, extranonce1, extranonce2, ntime, nonce)
if success:
self.send_stratum_response(client, msg_id, True)
if "Block found" in message:
# Get new job after block found
threading.Thread(target=self.update_job_after_block, daemon=True).start()
else:
# Accept as share even if block validation fails for stale jobs
self.send_stratum_response(client, msg_id, True)
else:
self.send_stratum_response(client, msg_id, True)
self.send_stratum_response(client, msg_id, True)
else:
self.send_stratum_response(client, msg_id, False, "Invalid parameters")
@@ -541,7 +500,6 @@ class RinCoinStratumBase:
def send_job_to_client(self, client, job):
"""Send mining job to specific client"""
try:
# Send proper Stratum job
self.send_stratum_notification(client, "mining.notify", [
job["job_id"],
job["prevhash"],
@@ -649,7 +607,7 @@ class RinCoinStratumBase:
server_socket.listen(10)
timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] 🚀 REAL Mining Stratum proxy ready!")
print(f"[{timestamp}] 🚀 Mining Stratum proxy ready!")
print(f" 📡 Listening on {self.stratum_host}:{self.stratum_port}")
print(f" 💰 Mining to: {self.target_address}")
print(f" 📊 Current job: {self.current_job['job_id'] if self.current_job else 'None'}")
@@ -679,15 +637,6 @@ class RinCoinStratumBase:
finally:
print("Server stopped")
class RinCoinStratumProxy(RinCoinStratumBase):
"""Solo mining stratum proxy implementation"""
def __init__(self, stratum_host='0.0.0.0', stratum_port=3334,
rpc_host='127.0.0.1', rpc_port=9556,
rpc_user='rinrpc', rpc_password='745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90',
target_address='rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q'):
super().__init__(stratum_host, stratum_port, rpc_host, rpc_port, rpc_user, rpc_password, target_address)
if __name__ == "__main__":
proxy = RinCoinStratumProxy()
proxy.start()
proxy.start()