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

proxy fix

Browse Source
This commit is contained in:
Dobromir Popov
2025-09-17 17:53:40 +03:00
parent 15f41c3268
commit 2bcd28be28
4 changed files with 867 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
MINE/rin/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,11 +33,57 @@ class RinCoinStratumBase:
self.running = True
self.extranonce1_counter = 0
print(f"RinCoin Stratum Proxy Server - REAL MINING")
# Logging setup
self.log_file = "mining_log.txt"
self.init_log_file()
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}")
def init_log_file(self):
"""Initialize mining log file with header"""
try:
with open(self.log_file, 'w') as f:
f.write("=" * 80 + "\n")
f.write("RinCoin Mining Log\n")
f.write("=" * 80 + "\n")
f.write(f"Started: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"Target Address: {self.target_address}\n")
f.write(f"Stratum: {self.stratum_host}:{self.stratum_port}\n")
f.write(f"RPC: {self.rpc_host}:{self.rpc_port}\n")
f.write("=" * 80 + "\n\n")
except Exception as e:
print(f"Failed to initialize log file: {e}")
def log_hash_found(self, hash_hex, difficulty, height, reward, nonce, ntime):
"""Log found hash to file"""
try:
timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
with open(self.log_file, 'a') as f:
f.write(f"[{timestamp}] 🎉 HASH FOUND!\n")
f.write(f" Hash: {hash_hex}\n")
f.write(f" Difficulty: {difficulty:.6f}\n")
f.write(f" Height: {height}\n")
f.write(f" Reward: {reward:.8f} RIN\n")
f.write(f" Nonce: {nonce}\n")
f.write(f" Time: {ntime}\n")
f.write("-" * 40 + "\n")
except Exception as e:
print(f"Failed to log hash: {e}")
def log_wallet_balance(self):
"""Log current wallet balance to file"""
try:
balance = self.rpc_call("getbalance")
if balance is not None:
timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
with open(self.log_file, 'a') as f:
f.write(f"[{timestamp}] 💰 Wallet Balance: {balance:.8f} RIN\n")
except Exception as e:
print(f"Failed to log wallet balance: {e}")
def rpc_call(self, method, params=[]):
"""Make RPC call to RinCoin node"""
try:
@@ -196,14 +242,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 +294,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 +314,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 +330,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 +347,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 +390,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}")
@@ -376,6 +403,10 @@ class RinCoinStratumBase:
print(f" 📊 Block height: {job['height']}")
print(f" 🔍 Difficulty: {share_difficulty:.6f} (target: {network_difficulty:.6f})")
# Log the found hash
reward_rin = job['coinbasevalue'] / 100000000
self.log_hash_found(block_hash_hex, share_difficulty, job['height'], reward_rin, nonce, ntime)
# Build complete block
block = header
@@ -398,6 +429,8 @@ class RinCoinStratumBase:
if result is None:
print(f" ✅ Block accepted by network!")
# Log wallet balance after successful block submission
self.log_wallet_balance()
return True, "Block found and submitted"
else:
print(f" ❌ Block rejected: {result}")
@@ -407,10 +440,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 +492,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 +510,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 +522,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 +552,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"],
@@ -605,6 +615,7 @@ class RinCoinStratumBase:
def job_updater(self):
"""Periodically update mining jobs"""
balance_log_counter = 0
while self.running:
try:
time.sleep(30) # Update every 30 seconds
@@ -616,6 +627,12 @@ class RinCoinStratumBase:
if new_height > old_height:
print(f"New block detected! Broadcasting new job...")
self.broadcast_new_job()
# Log wallet balance every 10 minutes (20 cycles of 30 seconds)
balance_log_counter += 1
if balance_log_counter >= 20:
self.log_wallet_balance()
balance_log_counter = 0
except Exception as e:
print(f"Job updater error: {e}")
@@ -633,6 +650,9 @@ class RinCoinStratumBase:
print(f"Current height: {blockchain_info.get('blocks', 'unknown')}")
print(f"Chain: {blockchain_info.get('chain', 'unknown')}")
# Log initial wallet balance
self.log_wallet_balance()
# Get initial block template
if not self.get_block_template():
print("Failed to get initial block template!")
@@ -649,10 +669,11 @@ 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'}")
print(f" 📝 Mining log: {self.log_file}")
print("")
print(" 🔧 Miner command:")
print(f" ./cpuminer -a rinhash -o stratum+tcp://{self.stratum_host}:{self.stratum_port} -u worker1 -p x -t 4")
@@ -679,15 +700,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()