1351 lines
66 KiB
Python
1351 lines
66 KiB
Python
# #!/usr/bin/env python3
|
|
# """
|
|
# stratum_proxy.py
|
|
# RinCoin Stratum Proxy Server
|
|
# DEBUG RPC: we get node logs with 'docker logs --tail=200 rincoin-node'
|
|
# MINE: /mnt/shared/DEV/repos/d-popov.com/mines/rin/miner/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://localhost:3334 -u x -p x -t 32
|
|
# """
|
|
|
|
# import socket
|
|
# import threading
|
|
# import json
|
|
# import time
|
|
# import requests
|
|
# import hashlib
|
|
# import struct
|
|
# from requests.auth import HTTPBasicAuth
|
|
|
|
# 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',
|
|
# target_address='rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q',
|
|
# submit_all_blocks=False, submit_threshold=0.1):
|
|
|
|
# self.stratum_host = stratum_host
|
|
# self.stratum_port = stratum_port
|
|
# self.rpc_host = rpc_host
|
|
# self.rpc_port = rpc_port
|
|
# self.rpc_user = rpc_user
|
|
# self.rpc_password = rpc_password
|
|
# self.target_address = target_address
|
|
# self.submit_all_blocks = submit_all_blocks
|
|
# # For debugging: submit blocks that meet this fraction of network difficulty
|
|
# self.submit_threshold = submit_threshold # Configurable percentage of network difficulty
|
|
|
|
# self.clients = {}
|
|
# self.job_counter = 0
|
|
# self.current_job = None
|
|
# self.running = True
|
|
# self.extranonce1_counter = 0
|
|
|
|
# # Dynamic difficulty adjustment
|
|
# self.share_stats = {} # Track shares per client
|
|
# self.last_difficulty_adjustment = time.time()
|
|
# self.target_share_interval = 15 # Target: 1 share every 15 seconds (optimal for 1-min blocks)
|
|
|
|
# # Production monitoring
|
|
# self.stats = {
|
|
# 'start_time': time.time(),
|
|
# 'total_shares': 0,
|
|
# 'accepted_shares': 0,
|
|
# 'rejected_shares': 0,
|
|
# 'blocks_found': 0,
|
|
# 'total_hashrate': 0,
|
|
# 'connections': 0,
|
|
# 'last_share_time': time.time(),
|
|
# 'shares_last_minute': [],
|
|
# 'current_share_rate': 0.0
|
|
# }
|
|
# self.max_connections = 50 # Production limit
|
|
|
|
# # 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:
|
|
# url = f"http://{self.rpc_host}:{self.rpc_port}/"
|
|
# headers = {'content-type': 'text/plain'}
|
|
# auth = HTTPBasicAuth(self.rpc_user, self.rpc_password)
|
|
|
|
# payload = {
|
|
# "jsonrpc": "1.0",
|
|
# "id": "stratum_proxy",
|
|
# "method": method,
|
|
# "params": params
|
|
# }
|
|
|
|
# response = requests.post(url, json=payload, headers=headers, auth=auth, timeout=30)
|
|
|
|
# if response.status_code == 200:
|
|
# result = response.json()
|
|
# if 'error' in result and result['error'] is not None:
|
|
# print(f"RPC Error: {result['error']}")
|
|
# return None
|
|
# return result.get('result')
|
|
# else:
|
|
# print(f"HTTP Error: {response.status_code}")
|
|
# return None
|
|
|
|
# except Exception as e:
|
|
# print(f"RPC Call Error: {e}")
|
|
# return None
|
|
|
|
# def encode_varint(self, n):
|
|
# """Encode integer as Bitcoin-style varint"""
|
|
# if n < 0xfd:
|
|
# return bytes([n])
|
|
# elif n <= 0xffff:
|
|
# return b"\xfd" + struct.pack('<H', n)
|
|
# elif n <= 0xffffffff:
|
|
# return b"\xfe" + struct.pack('<I', n)
|
|
# else:
|
|
# return b"\xff" + struct.pack('<Q', n)
|
|
|
|
# def decode_bech32_address(self, address):
|
|
# """Decode RinCoin bech32 address to script"""
|
|
# try:
|
|
# if not address or not address.startswith('rin1'):
|
|
# raise ValueError("Not a RinCoin bech32 address")
|
|
|
|
# result = self.rpc_call("validateaddress", [address])
|
|
# if not result or not result.get('isvalid'):
|
|
# raise ValueError("Address not valid per node")
|
|
# script_hex = result.get('scriptPubKey')
|
|
# if not script_hex:
|
|
# raise ValueError("Node did not return scriptPubKey")
|
|
# return bytes.fromhex(script_hex)
|
|
# except Exception as e:
|
|
# print(f"Address decode error: {e}")
|
|
# return None
|
|
|
|
# def build_coinbase_transaction(self, template, extranonce1, extranonce2):
|
|
# """Build coinbase transaction variants (with and without witness) for default address"""
|
|
# return self.build_coinbase_transaction_for_address(template, extranonce1, extranonce2, self.target_address)
|
|
|
|
# def build_coinbase_transaction_for_address(self, template, extranonce1, extranonce2, target_address):
|
|
# """Build coinbase transaction variants (with and without witness)"""
|
|
# try:
|
|
# has_witness_commitment = template.get('default_witness_commitment') is not None
|
|
|
|
# # Common parts
|
|
# value = template.get('coinbasevalue', 0)
|
|
# script_pubkey = self.decode_bech32_address(target_address)
|
|
# if not script_pubkey:
|
|
# return None, None
|
|
# witness_commitment = template.get('default_witness_commitment')
|
|
|
|
# # ScriptSig (block height minimal push + tag + extranonces)
|
|
# height = template.get('height', 0)
|
|
# height_bytes = struct.pack('<I', height)
|
|
# height_compact = bytes([len(height_bytes.rstrip(b'\x00'))]) + height_bytes.rstrip(b'\x00')
|
|
# scriptsig = height_compact + b'/RinCoin/' + extranonce1.encode() + extranonce2.encode()
|
|
|
|
# # Helper to build outputs blob
|
|
# def build_outputs_blob() -> bytes:
|
|
# outputs_blob = b''
|
|
# outputs_list = []
|
|
# # Main output
|
|
# outputs_list.append(struct.pack('<Q', value) + self.encode_varint(len(script_pubkey)) + script_pubkey)
|
|
# # Witness commitment OP_RETURN output if present
|
|
# if witness_commitment:
|
|
# commit_script = bytes.fromhex(witness_commitment)
|
|
# outputs_list.append(struct.pack('<Q', 0) + self.encode_varint(len(commit_script)) + commit_script)
|
|
# outputs_blob += self.encode_varint(len(outputs_list))
|
|
# for out in outputs_list:
|
|
# outputs_blob += out
|
|
# return outputs_blob
|
|
|
|
# # Build non-witness serialization (txid serialization)
|
|
# cb_nowit = b''
|
|
# cb_nowit += struct.pack('<I', 1) # version
|
|
# cb_nowit += b'\x01' # input count
|
|
# cb_nowit += b'\x00' * 32 # prevout hash
|
|
# cb_nowit += b'\xff\xff\xff\xff' # prevout index
|
|
# cb_nowit += self.encode_varint(len(scriptsig)) + scriptsig
|
|
# cb_nowit += b'\xff\xff\xff\xff' # sequence
|
|
# cb_nowit += build_outputs_blob() # outputs
|
|
# cb_nowit += struct.pack('<I', 0) # locktime
|
|
|
|
# # Build with-witness serialization (block serialization)
|
|
# if has_witness_commitment:
|
|
# cb_wit = b''
|
|
# cb_wit += struct.pack('<I', 1) # version
|
|
# cb_wit += b'\x00\x01' # segwit marker+flag
|
|
# cb_wit += b'\x01' # input count
|
|
# cb_wit += b'\x00' * 32 # prevout hash
|
|
# cb_wit += b'\xff\xff\xff\xff' # prevout index
|
|
# cb_wit += self.encode_varint(len(scriptsig)) + scriptsig
|
|
# cb_wit += b'\xff\xff\xff\xff' # sequence
|
|
# cb_wit += build_outputs_blob() # outputs
|
|
# # Witness stack for coinbase (32-byte reserved value)
|
|
# cb_wit += b'\x01' # witness stack count
|
|
# cb_wit += b'\x20' # item length
|
|
# cb_wit += b'\x00' * 32 # reserved value
|
|
# cb_wit += struct.pack('<I', 0) # locktime
|
|
# else:
|
|
# cb_wit = cb_nowit
|
|
|
|
# return cb_wit, cb_nowit
|
|
|
|
# except Exception as e:
|
|
# print(f"Coinbase construction error: {e}")
|
|
# return None, None
|
|
|
|
# def calculate_merkle_root(self, coinbase_txid, transactions):
|
|
# """Calculate merkle root with coinbase at index 0"""
|
|
# try:
|
|
# # Start with all transaction hashes (coinbase + others)
|
|
# hashes = [coinbase_txid]
|
|
# for tx in transactions:
|
|
# hashes.append(bytes.fromhex(tx['hash'])[::-1]) # Reverse for little-endian
|
|
|
|
# # Build merkle tree
|
|
# while len(hashes) > 1:
|
|
# if len(hashes) % 2 == 1:
|
|
# hashes.append(hashes[-1]) # Duplicate last hash if odd
|
|
|
|
# next_level = []
|
|
# for i in range(0, len(hashes), 2):
|
|
# combined = hashes[i] + hashes[i + 1]
|
|
# next_level.append(hashlib.sha256(hashlib.sha256(combined).digest()).digest())
|
|
|
|
# hashes = next_level
|
|
|
|
# return hashes[0] if hashes else b'\x00' * 32
|
|
|
|
# except Exception as e:
|
|
# print(f"Merkle root calculation error: {e}")
|
|
# return b'\x00' * 32
|
|
|
|
# def calculate_merkle_branches(self, tx_hashes, tx_index):
|
|
# """Calculate merkle branches for a specific transaction index"""
|
|
# try:
|
|
# if not tx_hashes or tx_index >= len(tx_hashes):
|
|
# return []
|
|
|
|
# branches = []
|
|
# current_index = tx_index
|
|
|
|
# # Start with the full list of transaction hashes
|
|
# hashes = tx_hashes[:]
|
|
|
|
# while len(hashes) > 1:
|
|
# if len(hashes) % 2 == 1:
|
|
# hashes.append(hashes[-1]) # Duplicate last hash if odd
|
|
|
|
# # Find the partner for current_index
|
|
# partner_index = current_index ^ 1 # Flip the least significant bit
|
|
|
|
# if partner_index < len(hashes):
|
|
# # Add the partner hash to branches (in big-endian for stratum)
|
|
# branches.append(hashes[partner_index][::-1].hex())
|
|
# else:
|
|
# # This shouldn't happen, but add the duplicate if it does
|
|
# branches.append(hashes[current_index][::-1].hex())
|
|
|
|
# # Move to next level
|
|
# next_level = []
|
|
# for i in range(0, len(hashes), 2):
|
|
# combined = hashes[i] + hashes[i + 1]
|
|
# next_level.append(hashlib.sha256(hashlib.sha256(combined).digest()).digest())
|
|
|
|
# hashes = next_level
|
|
# current_index //= 2
|
|
|
|
# return branches
|
|
|
|
# except Exception as e:
|
|
# print(f"Merkle branches calculation error: {e}")
|
|
# return []
|
|
|
|
# def bits_to_target(self, bits_hex):
|
|
# """Convert bits to target - FIXED VERSION"""
|
|
# try:
|
|
# bits = int(bits_hex, 16)
|
|
# exponent = bits >> 24
|
|
# mantissa = bits & 0xffffff
|
|
|
|
# # Bitcoin target calculation
|
|
# if exponent <= 3:
|
|
# target = mantissa >> (8 * (3 - exponent))
|
|
# else:
|
|
# target = mantissa << (8 * (exponent - 3))
|
|
|
|
# return f"{target:064x}"
|
|
# except Exception as e:
|
|
# print(f"Bits to target error: {e}")
|
|
# return "0000ffff00000000000000000000000000000000000000000000000000000000"
|
|
|
|
# def get_block_template(self):
|
|
# """Get new block template and create Stratum job"""
|
|
# try:
|
|
# template = self.rpc_call("getblocktemplate", [{"rules": ["segwit", "mweb"]}])
|
|
# if not template:
|
|
# return None
|
|
|
|
# self.job_counter += 1
|
|
|
|
# job = {
|
|
# "job_id": f"job_{self.job_counter:08x}",
|
|
# "template": template,
|
|
# "prevhash": template.get("previousblockhash", "0" * 64),
|
|
# "version": template.get('version', 1),
|
|
# "bits": template.get('bits', '1d00ffff'),
|
|
# "ntime": f"{int(time.time()):08x}",
|
|
# "target": self.bits_to_target(template.get('bits', '1d00ffff')),
|
|
# "height": template.get('height', 0),
|
|
# "coinbasevalue": template.get('coinbasevalue', 0),
|
|
# "transactions": template.get('transactions', [])
|
|
# }
|
|
|
|
# self.current_job = job
|
|
# timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
# network_difficulty = self.calculate_network_difficulty(job['target'])
|
|
# print(f"[{timestamp}] 🆕 NEW JOB: {job['job_id']} | Height: {job['height']} | Reward: {job['coinbasevalue']/100000000:.2f} RIN")
|
|
# print(f" 🎯 Network Difficulty: {network_difficulty:.6f} | Bits: {job['bits']}")
|
|
# print(f" 📍 Target: {job['target'][:16]}... | Transactions: {len(job['transactions'])}")
|
|
# return job
|
|
|
|
# except Exception as e:
|
|
# print(f"Get block template error: {e}")
|
|
# return None
|
|
|
|
# def calculate_share_difficulty(self, hash_hex, target_hex):
|
|
# """Calculate actual share difficulty from hash - FIXED"""
|
|
# try:
|
|
# hash_int = int(hash_hex, 16)
|
|
|
|
# if hash_int == 0:
|
|
# return float('inf') # Perfect hash
|
|
|
|
# # Bitcoin-style difficulty calculation using difficulty 1 target
|
|
# # Difficulty 1 target for mainnet
|
|
# diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
|
|
|
|
# # Share difficulty = how much harder this hash was compared to diff 1
|
|
# difficulty = diff1_target / hash_int
|
|
|
|
# return difficulty
|
|
# except Exception as e:
|
|
# print(f"Difficulty calculation error: {e}")
|
|
# return 0.0
|
|
|
|
# def calculate_network_difficulty(self, target_hex):
|
|
# """Calculate network difficulty from target - FIXED"""
|
|
# try:
|
|
# target_int = int(target_hex, 16)
|
|
|
|
# # Bitcoin difficulty 1.0 target
|
|
# diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
|
|
|
|
# # Network difficulty = how much harder than difficulty 1.0
|
|
# network_difficulty = diff1_target / target_int
|
|
|
|
# return network_difficulty
|
|
# except Exception as e:
|
|
# print(f"Network difficulty calculation error: {e}")
|
|
# return 1.0
|
|
|
|
# def calculate_optimal_difficulty(self, addr, is_new_client=False):
|
|
# """Calculate optimal stratum difficulty for a client based on hashrate and network conditions"""
|
|
# try:
|
|
# # Get current network difficulty
|
|
# network_diff = self.calculate_network_difficulty(self.current_job['target']) if self.current_job else 1.0
|
|
|
|
# if is_new_client:
|
|
# # Calculate difficulty for 4 shares per minute (15 second intervals)
|
|
# # Formula: difficulty = (shares_per_second * 2^32) / hashrate
|
|
# target_shares_per_second = 4 / 60 # 4 shares per minute
|
|
# assumed_hashrate = 680000 # H/s (conservative estimate)
|
|
# calculated_difficulty = (target_shares_per_second * (2**32)) / assumed_hashrate
|
|
|
|
# # Scale based on network difficulty to maintain relative percentage
|
|
# target_percentage = calculated_difficulty / network_diff if network_diff > 0 else 0.32
|
|
# scaled_difficulty = network_diff * target_percentage
|
|
|
|
# # Use the calculated difficulty (should be around 421 for 680kH/s)
|
|
# initial_difficulty = calculated_difficulty
|
|
|
|
# # Ensure reasonable bounds
|
|
# min_difficulty = 0.0001 # Absolute minimum
|
|
# # IMPORTANT: DO NOT CHANGE THIS VALUE. our pool may grow big in the future, so we need to be able to handle it.
|
|
# max_difficulty = network_diff * 0.1 # Maximum 10% of network
|
|
# initial_difficulty = max(min_difficulty, min(max_difficulty, initial_difficulty))
|
|
|
|
# percentage = (initial_difficulty / network_diff) * 100
|
|
# print(f" 📊 NEW CLIENT {addr}: Network diff {network_diff:.6f}")
|
|
# print(f" 🎯 Starting difficulty: {initial_difficulty:.6f} ({percentage:.4f}% of network)")
|
|
# miner_hashrate = self.clients.get(addr, {}).get('estimated_hashrate', 0)
|
|
# if miner_hashrate > 0:
|
|
# print(f" Target: 1 share every {self.target_share_interval}s @ {miner_hashrate:.0f} H/s")
|
|
# else:
|
|
# print(f" Target: 1 share every {self.target_share_interval}s (miner hashrate unknown)")
|
|
# print(f" 🔧 Per-miner adjustment: Difficulty will adapt to each device's actual hashrate")
|
|
# return initial_difficulty
|
|
|
|
# # For existing clients, adjust based on actual hashrate performance
|
|
# client_data = self.clients.get(addr, {})
|
|
# if not client_data:
|
|
# return self.calculate_optimal_difficulty(addr, is_new_client=True)
|
|
|
|
# current_time = time.time()
|
|
# connect_time = client_data.get('connect_time', current_time)
|
|
# share_count = client_data.get('share_count', 0)
|
|
# current_difficulty = client_data.get('stratum_difficulty', network_diff * 0.005)
|
|
# estimated_hashrate = client_data.get('estimated_hashrate', 0)
|
|
|
|
# # Need at least 3 shares to make adjustments
|
|
# if share_count < 3:
|
|
# return current_difficulty
|
|
|
|
# # Calculate target difficulty based on hashrate and desired share interval
|
|
# # Target: 1 share every 15 seconds (self.target_share_interval)
|
|
# if estimated_hashrate > 0:
|
|
# # Formula: difficulty = (hashrate * target_time) / (2^32)
|
|
# diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
|
|
# target_difficulty = (estimated_hashrate * self.target_share_interval) / (2**32)
|
|
|
|
# # Bounds checking
|
|
# min_difficulty = network_diff * 0.0001 # 0.01% of network
|
|
# max_difficulty = network_diff * 0.02 # 2% of network
|
|
# target_difficulty = max(min_difficulty, min(max_difficulty, target_difficulty))
|
|
|
|
# # Conservative adjustment - move only 50% towards target each time
|
|
# adjustment_factor = 0.5
|
|
# new_difficulty = current_difficulty + (target_difficulty - current_difficulty) * adjustment_factor
|
|
|
|
# print(f" 📊 {addr}: {estimated_hashrate:.0f} H/s, {share_count} shares, adjusting {current_difficulty:.6f} → {new_difficulty:.6f}")
|
|
# return new_difficulty
|
|
|
|
# return current_difficulty
|
|
|
|
# except Exception as e:
|
|
# print(f"Difficulty calculation error: {e}")
|
|
# # Fallback to conservative difficulty
|
|
# network_diff = self.calculate_network_difficulty(self.current_job['target']) if self.current_job else 1.0
|
|
# return max(network_diff * 0.001, 0.0001)
|
|
|
|
# def adjust_global_difficulty_if_needed(self):
|
|
# """Adjust difficulty globally if share rate is too high/low"""
|
|
# try:
|
|
# current_rate = self.stats['current_share_rate']
|
|
|
|
# # Target: 0.5-2 shares per second (30-120 second intervals)
|
|
# target_min_rate = 0.008 # ~1 share per 2 minutes
|
|
# target_max_rate = 0.033 # ~1 share per 30 seconds
|
|
|
|
# if current_rate > target_max_rate:
|
|
# # Too many shares - increase difficulty for all clients
|
|
# multiplier = min(2.0, current_rate / target_max_rate)
|
|
# print(f" 🚨 HIGH SHARE RATE: {current_rate:.3f}/s > {target_max_rate:.3f}/s - increasing difficulty by {multiplier:.2f}x")
|
|
# for addr in self.clients:
|
|
# current_diff = self.clients[addr].get('stratum_difficulty', 0.001)
|
|
# new_diff = min(0.001, current_diff * multiplier)
|
|
# self.clients[addr]['stratum_difficulty'] = new_diff
|
|
# print(f" 📈 {addr}: {current_diff:.6f} → {new_diff:.6f}")
|
|
|
|
# elif current_rate < target_min_rate and current_rate > 0:
|
|
# # Too few shares - decrease difficulty for all clients
|
|
# multiplier = max(0.5, target_min_rate / current_rate)
|
|
# print(f" 🐌 LOW SHARE RATE: {current_rate:.3f}/s < {target_min_rate:.3f}/s - decreasing difficulty by {multiplier:.2f}x")
|
|
# for addr in self.clients:
|
|
# current_diff = self.clients[addr].get('stratum_difficulty', 0.001)
|
|
# new_diff = max(0.000001, current_diff / multiplier)
|
|
# self.clients[addr]['stratum_difficulty'] = new_diff
|
|
# print(f" 📉 {addr}: {current_diff:.6f} → {new_diff:.6f}")
|
|
|
|
# except Exception as e:
|
|
# print(f"Global difficulty adjustment error: {e}")
|
|
|
|
# def adjust_client_difficulty(self, addr):
|
|
# """Adjust difficulty for a specific client if needed"""
|
|
# try:
|
|
# current_time = time.time()
|
|
|
|
# # Only adjust every 2 minutes minimum
|
|
# last_adjustment = self.clients[addr].get('last_difficulty_adjustment', 0)
|
|
# if current_time - last_adjustment < 120:
|
|
# return
|
|
|
|
# new_difficulty = self.calculate_optimal_difficulty(addr, is_new_client=False)
|
|
# current_difficulty = self.clients[addr].get('stratum_difficulty', 0.001)
|
|
|
|
# # Only send update if difficulty changed significantly (>20%)
|
|
# if abs(new_difficulty - current_difficulty) / current_difficulty > 0.2:
|
|
# self.clients[addr]['stratum_difficulty'] = new_difficulty
|
|
# self.clients[addr]['last_difficulty_adjustment'] = current_time
|
|
|
|
# # Send new difficulty to client
|
|
# if 'socket' in self.clients[addr]:
|
|
# self.send_stratum_notification(self.clients[addr]['socket'], "mining.set_difficulty", [new_difficulty])
|
|
# print(f" 🎯 Updated difficulty for {addr}: {current_difficulty:.6f} → {new_difficulty:.6f}")
|
|
|
|
# except Exception as e:
|
|
# print(f"Difficulty adjustment error for {addr}: {e}")
|
|
|
|
# def submit_share(self, job, extranonce1, extranonce2, ntime, nonce, addr=None, target_address=None):
|
|
# """Validate share and submit block if valid - FIXED VERSION"""
|
|
# try:
|
|
# # Use provided address or default
|
|
# address = target_address or self.target_address
|
|
|
|
# # Build coinbase (with and without witness)
|
|
# coinbase_wit, coinbase_nowit = self.build_coinbase_transaction_for_address(
|
|
# job['template'], extranonce1, extranonce2, address)
|
|
# if not coinbase_wit or not coinbase_nowit:
|
|
# return False, "Coinbase construction failed"
|
|
|
|
# # Calculate coinbase txid (non-witness serialization)
|
|
# coinbase_txid = hashlib.sha256(hashlib.sha256(coinbase_nowit).digest()).digest()[::-1]
|
|
|
|
# # Calculate merkle root
|
|
# merkle_root = self.calculate_merkle_root(coinbase_txid, job['transactions'])
|
|
|
|
# # Build block header - FIXED ENDIANNESS
|
|
# header = b''
|
|
# 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']) # Bits (big-endian in block)
|
|
# header += struct.pack('<I', int(nonce, 16)) # Nonce (little-endian)
|
|
|
|
# # Calculate block hash - FIXED DOUBLE SHA256
|
|
# block_hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
|
|
# 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 stratum difficulty first, then network target
|
|
# hash_int = int(block_hash_hex, 16)
|
|
# network_target_int = int(job['target'], 16)
|
|
|
|
# # Get the stratum difficulty that was sent to this miner
|
|
# client_stratum_diff = self.clients.get(addr, {}).get('stratum_difficulty', 0.001)
|
|
# diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
|
|
# # Correct stratum target calculation: target = diff1_target / difficulty
|
|
# stratum_target_int = int(diff1_target / client_stratum_diff)
|
|
|
|
# meets_stratum_target = hash_int <= stratum_target_int
|
|
# meets_network_target = hash_int <= network_target_int
|
|
|
|
# # CRITICAL FIX: Check if share difficulty meets minimum requirements
|
|
# meets_stratum_difficulty = share_difficulty >= client_stratum_diff
|
|
# meets_network_difficulty = share_difficulty >= network_difficulty
|
|
|
|
# # Track share rate
|
|
# current_time = time.time()
|
|
# self.stats['shares_last_minute'].append(current_time)
|
|
# # Remove shares older than 60 seconds
|
|
# self.stats['shares_last_minute'] = [t for t in self.stats['shares_last_minute'] if current_time - t <= 60]
|
|
# self.stats['current_share_rate'] = len(self.stats['shares_last_minute']) / 60.0
|
|
|
|
# # Enhanced logging
|
|
# timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
# network_percentage = (share_difficulty / network_difficulty) * 100 if network_difficulty > 0 else 0
|
|
# stratum_percentage = (share_difficulty / client_stratum_diff) * 100 if client_stratum_diff > 0 else 0
|
|
|
|
# # Progress indicator based on difficulty comparison
|
|
# if meets_network_difficulty:
|
|
# progress_icon = "🎉" # Block found!
|
|
# elif meets_stratum_difficulty:
|
|
# progress_icon = "✅" # Valid share for stratum
|
|
# elif network_percentage >= 50:
|
|
# progress_icon = "🔥" # Very close to network
|
|
# elif network_percentage >= 10:
|
|
# progress_icon = "⚡" # Getting warm
|
|
# elif network_percentage >= 1:
|
|
# progress_icon = "💫" # Some progress
|
|
# else:
|
|
# progress_icon = "📊" # Low progress
|
|
|
|
# # Calculate network and pool hashrates
|
|
# block_time = 60 # RinCoin 1-minute blocks
|
|
# network_hashrate = (network_difficulty * (2**32)) / block_time
|
|
# network_mhs = network_hashrate / 1e6
|
|
|
|
# # Calculate pool hashrate (sum of all connected miners)
|
|
# pool_hashrate = 0
|
|
# for client_addr, client_data in self.clients.items():
|
|
# pool_hashrate += client_data.get('estimated_hashrate', 0)
|
|
# pool_mhs = pool_hashrate / 1e6
|
|
|
|
# # Calculate percentages
|
|
# pool_network_percentage = (pool_mhs / network_mhs) * 100 if network_mhs > 0 else 0
|
|
# miner_pool_percentage = (0.87 / pool_mhs) * 100 if pool_mhs > 0 else 0 # Assuming 870kH/s miner
|
|
|
|
# print(f"[{timestamp}] {progress_icon} SHARE: job={job['job_id']} | nonce={nonce} | hash={block_hash_hex[:16]}...")
|
|
# print(f" 🎯 Share Diff: {share_difficulty:.2e} | Stratum Diff: {client_stratum_diff:.6f} | Network Diff: {network_difficulty:.6f}")
|
|
# print(f" 📈 Progress: {network_percentage:.4f}% of network, {stratum_percentage:.1f}% of stratum")
|
|
# print(f" 📊 Share Rate: {self.stats['current_share_rate']:.2f}/s | Total: {len(self.stats['shares_last_minute'])}/min")
|
|
# print(f" 🌐 Network: {network_mhs:.1f} MH/s | Pool: {pool_mhs:.1f} MH/s ({pool_network_percentage:.2f}% of network)")
|
|
# print(f" ⛏️ Miner: 0.87 MH/s ({miner_pool_percentage:.1f}% of pool) | Expected solo: {network_mhs/0.87:.0f}h")
|
|
# print(f" 📍 Target: {job['target'][:16]}... | Height: {job['height']}")
|
|
# print(f" ⏰ Time: {ntime} | Extranonce: {extranonce1}:{extranonce2}")
|
|
# print(f" 🔍 Difficulty Check: Share {share_difficulty:.2e} vs Stratum {client_stratum_diff:.6f} = {'✅' if meets_stratum_difficulty else '❌'}")
|
|
# print(f" 🔍 Difficulty Check: Share {share_difficulty:.2e} vs Network {network_difficulty:.6f} = {'✅' if meets_network_difficulty else '❌'}")
|
|
|
|
# # Initialize submission variables
|
|
# submit_network_difficulty = meets_network_difficulty
|
|
# submit_debug_threshold = share_difficulty >= (network_difficulty * self.submit_threshold)
|
|
|
|
# if submit_network_difficulty:
|
|
# submit_reason = "meets network difficulty"
|
|
# elif submit_debug_threshold:
|
|
# submit_reason = f"meets debug threshold ({self.submit_threshold*100:.0f}% of network)"
|
|
# else:
|
|
# submit_reason = "does not meet minimum requirements"
|
|
|
|
# # Handle submit_all_blocks mode - bypass all difficulty checks
|
|
# if self.submit_all_blocks:
|
|
# print(f" 🧪 TEST MODE: Submitting ALL shares to node for validation")
|
|
# # Update stats for test mode
|
|
# self.stats['total_shares'] += 1
|
|
# self.stats['accepted_shares'] += 1
|
|
|
|
# # Always submit in test mode
|
|
# should_submit = True
|
|
# else:
|
|
# # Normal mode - check stratum difficulty properly
|
|
# if not meets_stratum_difficulty:
|
|
# # Share doesn't meet minimum stratum difficulty - reject
|
|
# print(f" ❌ Share rejected (difficulty too low: {share_difficulty:.2e} < {client_stratum_diff:.6f})")
|
|
# self.stats['total_shares'] += 1
|
|
# self.stats['rejected_shares'] += 1
|
|
# return False, "Share does not meet stratum difficulty"
|
|
|
|
# # Valid stratum share! Update client stats
|
|
# if addr and addr in self.clients:
|
|
# current_time = time.time()
|
|
# self.clients[addr]['share_count'] = self.clients[addr].get('share_count', 0) + 1
|
|
# self.clients[addr]['last_share_time'] = current_time
|
|
|
|
# # Calculate hashrate from this share
|
|
# # Hashrate = difficulty * 2^32 / time_to_find_share
|
|
# client_difficulty = self.clients[addr].get('stratum_difficulty', 0.001)
|
|
# last_share_time = self.clients[addr].get('last_share_time', current_time - 60)
|
|
# time_since_last = max(1, current_time - last_share_time) # Avoid division by zero
|
|
|
|
# # Calculate instantaneous hashrate for this share
|
|
# diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
|
|
# instant_hashrate = (client_difficulty * (2**32)) / time_since_last
|
|
|
|
# # Store hashrate sample (keep last 10 samples)
|
|
# if 'hashrate_samples' not in self.clients[addr]:
|
|
# self.clients[addr]['hashrate_samples'] = []
|
|
# self.clients[addr]['hashrate_samples'].append((current_time, instant_hashrate))
|
|
# # Keep only last 10 samples
|
|
# if len(self.clients[addr]['hashrate_samples']) > 10:
|
|
# self.clients[addr]['hashrate_samples'] = self.clients[addr]['hashrate_samples'][-10:]
|
|
|
|
# # Calculate average hashrate from recent samples
|
|
# if self.clients[addr]['hashrate_samples']:
|
|
# total_hashrate = sum(hr for _, hr in self.clients[addr]['hashrate_samples'])
|
|
# self.clients[addr]['estimated_hashrate'] = total_hashrate / len(self.clients[addr]['hashrate_samples'])
|
|
|
|
# print(f" ⛏️ Miner {addr}: {self.clients[addr]['estimated_hashrate']:.0f} H/s (avg of {len(self.clients[addr]['hashrate_samples'])} samples)")
|
|
|
|
# # Update global stats
|
|
# self.stats['total_shares'] += 1
|
|
# self.stats['accepted_shares'] += 1
|
|
|
|
# # Check if we should adjust difficulty
|
|
# self.adjust_client_difficulty(addr)
|
|
|
|
# # Global difficulty adjustment based on share rate
|
|
# self.adjust_global_difficulty_if_needed()
|
|
|
|
# should_submit = submit_network_difficulty or submit_debug_threshold
|
|
|
|
# # Submit block if conditions are met
|
|
# if should_submit:
|
|
# if submit_network_difficulty:
|
|
# print(f" 🎉 VALID BLOCK FOUND! Hash: {block_hash_hex}")
|
|
# print(f" 💰 Reward: {job['coinbasevalue']/100000000:.2f} RIN -> {address}")
|
|
# print(f" 📊 Block height: {job['height']}")
|
|
# print(f" 🔍 Difficulty: {share_difficulty:.6f} (target: {network_difficulty:.6f})")
|
|
# print(f" 📋 Submit reason: {submit_reason}")
|
|
|
|
# # Log the found hash - ONLY for actual network-valid blocks
|
|
# reward_rin = job['coinbasevalue'] / 100000000
|
|
# self.log_hash_found(block_hash_hex, share_difficulty, job['height'], reward_rin, nonce, ntime)
|
|
# elif submit_debug_threshold:
|
|
# print(f" 🧪 DEBUG SUBMISSION! Hash: {block_hash_hex} ({submit_reason})")
|
|
# print(f" 📊 Block height: {job['height']} | Difficulty: {share_difficulty:.6f}")
|
|
# print(f" 💡 This is a test submission - not a real block")
|
|
# else:
|
|
# print(f" 🧪 TEST BLOCK SUBMISSION! Hash: {block_hash_hex} (submit_all_blocks=True)")
|
|
# print(f" 📊 Block height: {job['height']} | Difficulty: {share_difficulty:.6f}")
|
|
# print(f" 💡 This is a test submission - not a real block")
|
|
|
|
# # Build complete block
|
|
# block = header
|
|
|
|
# # Transaction count
|
|
# tx_count = 1 + len(job['transactions'])
|
|
# block += self.encode_varint(tx_count)
|
|
|
|
# # Add coinbase transaction (witness variant for block body)
|
|
# block += coinbase_wit
|
|
|
|
# # Add other transactions
|
|
# for tx in job['transactions']:
|
|
# block += bytes.fromhex(tx['data'])
|
|
|
|
# # Submit block
|
|
# block_hex = block.hex()
|
|
# print(f" 📦 Submitting block of size {len(block_hex)//2} bytes...")
|
|
# print(f" 🚀 Calling RPC: submitblock([block_hex={len(block_hex)//2}_bytes])")
|
|
|
|
# result = self.rpc_call("submitblock", [block_hex])
|
|
# print(f" 📡 RPC RESPONSE: {result}") # Log the actual RPC response
|
|
|
|
# if result is None:
|
|
# print(f" ✅ Block accepted by network!")
|
|
# print(f" 🎊 SUCCESS: Block {job['height']} submitted successfully!")
|
|
# print(f" 💰 Reward earned: {job['coinbasevalue']/100000000:.8f} RIN")
|
|
# # Update block stats
|
|
# self.stats['blocks_found'] += 1
|
|
# # Log wallet balance after successful block submission
|
|
# self.log_wallet_balance()
|
|
# return True, "Block found and submitted"
|
|
# else:
|
|
# print(f" ❌ Block rejected: {result}")
|
|
# print(f" 🔍 Debug: Block size {len(block_hex)//2} bytes, {len(job['transactions'])} transactions")
|
|
# print(f" 📋 Full RPC error details: {result}")
|
|
# return False, f"Block rejected: {result}"
|
|
# else:
|
|
# # Valid stratum share but not network-valid block (normal mode only)
|
|
# if not self.submit_all_blocks:
|
|
# print(f" ✅ Valid stratum share accepted")
|
|
# return True, "Valid stratum share"
|
|
# else:
|
|
# # This shouldn't happen in test mode since should_submit would be True
|
|
# return True, "Test mode share processed"
|
|
|
|
# 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"""
|
|
# try:
|
|
# response = {
|
|
# "id": msg_id,
|
|
# "result": result,
|
|
# "error": error
|
|
# }
|
|
# message = json.dumps(response) + "\n"
|
|
# client.send(message.encode('utf-8'))
|
|
# except Exception as e:
|
|
# print(f"Send response error: {e}")
|
|
|
|
# def send_stratum_notification(self, client, method, params):
|
|
# """Send Stratum notification to client"""
|
|
# try:
|
|
# notification = {
|
|
# "id": None,
|
|
# "method": method,
|
|
# "params": params
|
|
# }
|
|
# message = json.dumps(notification) + "\n"
|
|
# client.send(message.encode('utf-8'))
|
|
# except Exception as e:
|
|
# print(f"Send notification error: {e}")
|
|
|
|
# def handle_stratum_message(self, client, addr, message):
|
|
# """Handle incoming Stratum message from miner"""
|
|
# try:
|
|
# # Debug: log raw message
|
|
# print(f"[{addr}] Raw message: {repr(message)}")
|
|
|
|
# data = json.loads(message.strip())
|
|
# method = data.get("method")
|
|
# msg_id = data.get("id")
|
|
# params = data.get("params", [])
|
|
|
|
# print(f"[{addr}] Parsed: method={method}, id={msg_id}, params={params}")
|
|
|
|
# if method == "mining.subscribe":
|
|
# # Generate unique extranonce1 for this connection
|
|
# self.extranonce1_counter += 1
|
|
# extranonce1 = f"{self.extranonce1_counter:08x}"
|
|
|
|
# # Store extranonce1 for this client
|
|
# if addr not in self.clients:
|
|
# self.clients[addr] = {}
|
|
# self.clients[addr]['extranonce1'] = extranonce1
|
|
|
|
# # Subscribe response
|
|
# self.send_stratum_response(client, msg_id, [
|
|
# [["mining.set_difficulty", "subscription_id"], ["mining.notify", "subscription_id"]],
|
|
# extranonce1,
|
|
# 4 # extranonce2 size
|
|
# ])
|
|
|
|
# # Calculate optimal stratum difficulty for this client
|
|
# initial_difficulty = self.calculate_optimal_difficulty(addr, is_new_client=True)
|
|
# # Store stratum difficulty for this client
|
|
# if addr not in self.clients:
|
|
# self.clients[addr] = {}
|
|
# self.clients[addr]['stratum_difficulty'] = initial_difficulty
|
|
# self.clients[addr]['last_share_time'] = time.time()
|
|
# self.clients[addr]['share_count'] = 0
|
|
# self.clients[addr]['connect_time'] = time.time()
|
|
# self.clients[addr]['hashrate_samples'] = [] # Store recent hashrate measurements
|
|
# self.clients[addr]['estimated_hashrate'] = 0 # Current estimated hashrate
|
|
|
|
# self.send_stratum_notification(client, "mining.set_difficulty", [initial_difficulty])
|
|
# print(f" 🎯 Set initial difficulty {initial_difficulty:.6f} for {addr}")
|
|
|
|
# # Send initial job
|
|
# if self.current_job:
|
|
# self.send_job_to_client(client, self.current_job)
|
|
# else:
|
|
# if self.get_block_template():
|
|
# self.send_job_to_client(client, self.current_job)
|
|
|
|
# elif method == "mining.authorize":
|
|
# username = params[0] if params else "anonymous"
|
|
# self.clients[addr]['username'] = username
|
|
# self.send_stratum_response(client, msg_id, True)
|
|
# timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
# print(f"[{timestamp}] 🔐 [{addr}] Authorized as {username}")
|
|
|
|
# elif method == "login":
|
|
# # Handle xmrig's login method (JSON-RPC format with object params)
|
|
# if isinstance(params, dict):
|
|
# # xmrig format: {"login": "username", "pass": "password", "agent": "...", "algo": [...]}
|
|
# username = params.get('login', 'anonymous')
|
|
# password = params.get('pass', 'x')
|
|
# agent = params.get('agent', 'unknown')
|
|
# algorithms = params.get('algo', [])
|
|
# else:
|
|
# # Standard stratum format: ["username", "password"]
|
|
# username = params[0] if params else "anonymous"
|
|
# password = params[1] if len(params) > 1 else "x"
|
|
# agent = "unknown"
|
|
# algorithms = []
|
|
|
|
# self.clients[addr]['username'] = username
|
|
# self.clients[addr]['password'] = password
|
|
# self.clients[addr]['agent'] = agent
|
|
# self.clients[addr]['algorithms'] = algorithms
|
|
|
|
# # Check if rinhash is supported
|
|
# rinhash_supported = any('rinhash' in algo.lower() or 'rin' in algo.lower() for algo in algorithms)
|
|
# if not rinhash_supported:
|
|
# print(f"[{addr}] Warning: rinhash not in supported algorithms: {algorithms}")
|
|
|
|
# self.send_stratum_response(client, msg_id, True)
|
|
# timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
# print(f"[{timestamp}] 🔐 [{addr}] xmrig Login as {username} (agent: {agent})")
|
|
# print(f"[{addr}] Supported algorithms: {algorithms}")
|
|
|
|
# # Send initial job after login
|
|
# if self.current_job:
|
|
# self.send_job_to_client(client, self.current_job)
|
|
# else:
|
|
# if self.get_block_template():
|
|
# self.send_job_to_client(client, self.current_job)
|
|
|
|
# elif method == "mining.extranonce.subscribe":
|
|
# self.send_stratum_response(client, msg_id, True)
|
|
|
|
# elif method == "mining.submit":
|
|
# if len(params) >= 5:
|
|
# username = params[0]
|
|
# job_id = params[1]
|
|
# extranonce2 = params[2]
|
|
# ntime = params[3]
|
|
# nonce = params[4]
|
|
|
|
# print(f"[{addr}] Submit: {username} | job={job_id} | nonce={nonce}")
|
|
|
|
# # 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, addr)
|
|
|
|
# # 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:
|
|
# self.send_stratum_response(client, msg_id, True)
|
|
# else:
|
|
# self.send_stratum_response(client, msg_id, False, "Invalid parameters")
|
|
|
|
# else:
|
|
# print(f"[{addr}] Unknown method: {method}")
|
|
# self.send_stratum_response(client, msg_id, None, "Unknown method")
|
|
|
|
# except json.JSONDecodeError as e:
|
|
# print(f"[{addr}] Invalid JSON: {message}")
|
|
# print(f"[{addr}] JSON Error: {e}")
|
|
# except Exception as e:
|
|
# print(f"[{addr}] Message handling error: {e}")
|
|
# print(f"[{addr}] Error type: {type(e).__name__}")
|
|
|
|
# def send_job_to_client(self, client, job):
|
|
# """Send mining job to specific client with proper stratum parameters"""
|
|
# try:
|
|
# # Get network difficulty for display
|
|
# network_difficulty = self.calculate_network_difficulty(job['target'])
|
|
|
|
# # Build proper coinbase transaction parts for stratum protocol
|
|
# template = job.get('template', {})
|
|
# height = job.get('height', 0)
|
|
|
|
# # Encode height as minimal push (BIP34 compliance)
|
|
# if height == 0:
|
|
# height_push = b''
|
|
# else:
|
|
# height_bytes = struct.pack('<I', height)
|
|
# # Remove trailing zero bytes
|
|
# while len(height_bytes) > 1 and height_bytes[-1] == 0:
|
|
# height_bytes = height_bytes[:-1]
|
|
# height_push = bytes([len(height_bytes)]) + height_bytes
|
|
|
|
# # Build coinbase input script: height + arbitrary data + extranonces
|
|
# coinb1_script = height_push + b'/RinCoin/'
|
|
|
|
# # Build coinbase transaction structure
|
|
# # Version (4 bytes)
|
|
# coinb1 = struct.pack('<I', 1)
|
|
# # Input count (1 byte)
|
|
# coinb1 += b'\x01'
|
|
# # Previous output hash (32 bytes of zeros)
|
|
# coinb1 += b'\x00' * 32
|
|
# # Previous output index (4 bytes of 0xFF)
|
|
# coinb1 += b'\xff\xff\xff\xff'
|
|
# # Script length (will include extranonces)
|
|
# script_len_pos = len(coinb1)
|
|
# coinb1 += b'\x00' # Placeholder for script length
|
|
# # Script data up to extranonce1
|
|
# coinb1 += coinb1_script
|
|
|
|
# # coinb2: everything after extranonces
|
|
# # For now, just the sequence and outputs
|
|
# coinb2 = b''
|
|
# coinb2 += b'\xff\xff\xff\xff' # Sequence
|
|
|
|
# # Outputs
|
|
# script_pubkey = self.decode_bech32_address(self.target_address)
|
|
# if script_pubkey:
|
|
# value = template.get('coinbasevalue', 0)
|
|
# # Output count
|
|
# output_count = 1
|
|
# witness_commitment = template.get('default_witness_commitment')
|
|
# if witness_commitment:
|
|
# output_count = 2
|
|
|
|
# coinb2 += self.encode_varint(output_count)
|
|
|
|
# # Main output (to mining address)
|
|
# coinb2 += struct.pack('<Q', value)
|
|
# coinb2 += self.encode_varint(len(script_pubkey))
|
|
# coinb2 += script_pubkey
|
|
|
|
# # Witness commitment output if present
|
|
# if witness_commitment:
|
|
# commit_script = bytes.fromhex(witness_commitment)
|
|
# coinb2 += struct.pack('<Q', 0) # Zero value
|
|
# coinb2 += self.encode_varint(len(commit_script))
|
|
# coinb2 += commit_script
|
|
|
|
# # Locktime
|
|
# coinb2 += struct.pack('<I', 0)
|
|
|
|
# # Calculate total script length (coinb1_script + extranonces lengths)
|
|
# # extranonce1 is 8 hex chars (4 bytes), extranonce2 is 8 hex chars (4 bytes)
|
|
# total_script_len = len(coinb1_script) + 4 + 4 # extranonce1 + extranonce2 (binary)
|
|
|
|
# # Update script length in coinb1
|
|
# coinb1_list = list(coinb1)
|
|
# if total_script_len < 253:
|
|
# coinb1_list[script_len_pos] = total_script_len
|
|
# else:
|
|
# # Handle larger script lengths with varint encoding
|
|
# coinb1 = coinb1[:script_len_pos] + self.encode_varint(total_script_len) + coinb1[script_len_pos+1:]
|
|
# coinb1 = bytes(coinb1_list) if total_script_len < 253 else coinb1
|
|
|
|
# # Calculate merkle branches
|
|
# tx_hashes = []
|
|
# for tx in job.get('transactions', []):
|
|
# tx_hashes.append(bytes.fromhex(tx['hash'])[::-1]) # Little-endian
|
|
|
|
# merkle_branches = []
|
|
# if tx_hashes:
|
|
# # For coinbase at index 0, calculate merkle path
|
|
# merkle_branches = self.calculate_merkle_branches([b'\x00' * 32] + tx_hashes, 0)
|
|
|
|
# self.send_stratum_notification(client, "mining.notify", [
|
|
# job["job_id"],
|
|
# job["prevhash"],
|
|
# coinb1.hex(),
|
|
# coinb2.hex(),
|
|
# merkle_branches,
|
|
# f"{job['version']:08x}",
|
|
# job["bits"],
|
|
# job["ntime"],
|
|
# True # clean_jobs
|
|
# ])
|
|
|
|
# print(f" 📤 Sent job to miner: Height {height} | NetDiff {network_difficulty:.6f} | Txs {len(job.get('transactions', []))}")
|
|
|
|
# except Exception as e:
|
|
# print(f"Failed to send job: {e}")
|
|
# import traceback
|
|
# traceback.print_exc()
|
|
|
|
# def update_job_after_block(self):
|
|
# """Update job after a block is found"""
|
|
# time.sleep(2) # Brief delay to let network propagate
|
|
# if self.get_block_template():
|
|
# self.broadcast_new_job()
|
|
|
|
# def broadcast_new_job(self):
|
|
# """Broadcast new job to all connected clients"""
|
|
# if not self.current_job:
|
|
# return
|
|
|
|
# print(f"Broadcasting new job to {len(self.clients)} clients")
|
|
|
|
# for addr, client_data in list(self.clients.items()):
|
|
# try:
|
|
# if 'socket' in client_data:
|
|
# self.send_job_to_client(client_data['socket'], self.current_job)
|
|
# except Exception as e:
|
|
# print(f"Failed to send job to {addr}: {e}")
|
|
|
|
# def handle_client(self, client, addr):
|
|
# """Handle individual client connection"""
|
|
# # Check connection limits
|
|
# if len(self.clients) >= self.max_connections:
|
|
# print(f"[{addr}] Connection rejected - max connections ({self.max_connections}) reached")
|
|
# client.close()
|
|
# return
|
|
|
|
# print(f"[{addr}] Connected (clients: {len(self.clients) + 1}/{self.max_connections})")
|
|
# if addr not in self.clients:
|
|
# self.clients[addr] = {}
|
|
# self.clients[addr]['socket'] = client
|
|
# self.stats['connections'] = len(self.clients)
|
|
|
|
# try:
|
|
# while self.running:
|
|
# data = client.recv(4096)
|
|
# if not data:
|
|
# break
|
|
|
|
# # Handle multiple messages in one packet
|
|
# messages = data.decode('utf-8').strip().split('\n')
|
|
# for message in messages:
|
|
# if message:
|
|
# self.handle_stratum_message(client, addr, message)
|
|
|
|
# except Exception as e:
|
|
# print(f"[{addr}] Client error: {e}")
|
|
# finally:
|
|
# client.close()
|
|
# if addr in self.clients:
|
|
# del self.clients[addr]
|
|
# self.stats['connections'] = len(self.clients)
|
|
# print(f"[{addr}] Disconnected (clients: {len(self.clients)}/{self.max_connections})")
|
|
|
|
# def print_stats(self):
|
|
# """Print pool statistics"""
|
|
# try:
|
|
# uptime = time.time() - self.stats['start_time']
|
|
# uptime_str = f"{int(uptime//3600)}h {int((uptime%3600)//60)}m"
|
|
|
|
# accept_rate = 0
|
|
# if self.stats['total_shares'] > 0:
|
|
# accept_rate = (self.stats['accepted_shares'] / self.stats['total_shares']) * 100
|
|
|
|
# print(f"\n📊 POOL STATISTICS:")
|
|
# print(f" ⏰ Uptime: {uptime_str}")
|
|
# print(f" 👥 Connected miners: {self.stats['connections']}")
|
|
# print(f" 📈 Shares: {self.stats['accepted_shares']}/{self.stats['total_shares']} ({accept_rate:.1f}% accepted)")
|
|
# print(f" 🎉 Blocks found: {self.stats['blocks_found']}")
|
|
# print(f" 🎯 Network difficulty: {self.calculate_network_difficulty(self.current_job['target']) if self.current_job else 'unknown':.6f}")
|
|
|
|
# # Calculate hashrate estimate from connected clients
|
|
# total_hashrate = 0
|
|
# for addr, client_data in self.clients.items():
|
|
# share_count = client_data.get('share_count', 0)
|
|
# connect_time = client_data.get('connect_time', time.time())
|
|
# mining_duration = time.time() - connect_time
|
|
# if mining_duration > 60 and share_count > 0:
|
|
# stratum_diff = client_data.get('stratum_difficulty', 0.001)
|
|
# # Rough hashrate estimate: shares * difficulty * 2^32 / time
|
|
# hashrate = (share_count * stratum_diff * 4294967296) / mining_duration
|
|
# total_hashrate += hashrate
|
|
# print(f" 🔥 {addr}: ~{hashrate/1000:.0f} kH/s")
|
|
|
|
# if total_hashrate > 0:
|
|
# print(f" 🚀 Total pool hashrate: ~{total_hashrate/1000:.0f} kH/s")
|
|
# print()
|
|
|
|
# except Exception as e:
|
|
# print(f"Stats error: {e}")
|
|
|
|
# def job_updater(self):
|
|
# """Periodically update mining jobs"""
|
|
# balance_log_counter = 0
|
|
# stats_counter = 0
|
|
|
|
# while self.running:
|
|
# try:
|
|
# time.sleep(30) # Update every 30 seconds
|
|
|
|
# old_height = self.current_job['height'] if self.current_job else 0
|
|
|
|
# if self.get_block_template():
|
|
# new_height = self.current_job['height']
|
|
# 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
|
|
|
|
# # Print stats every 5 minutes (10 cycles of 30 seconds)
|
|
# stats_counter += 1
|
|
# if stats_counter >= 10:
|
|
# self.print_stats()
|
|
# stats_counter = 0
|
|
|
|
# except Exception as e:
|
|
# print(f"Job updater error: {e}")
|
|
|
|
# def validate_mining_capability(self):
|
|
# """Validate that we can mine valid blocks against the RinCoin node"""
|
|
# try:
|
|
# print("🔍 Validating mining capability...")
|
|
|
|
# # Get block template
|
|
# template = self.rpc_call("getblocktemplate", [{"rules": ["segwit", "mweb"]}])
|
|
# if not template:
|
|
# print("❌ Cannot get block template")
|
|
# return False
|
|
|
|
# # Test address validation
|
|
# result = self.rpc_call("validateaddress", [self.target_address])
|
|
# if not result or not result.get('isvalid'):
|
|
# print(f"❌ Target address {self.target_address} is invalid")
|
|
# return False
|
|
|
|
# print(f"✅ Target address {self.target_address} is valid")
|
|
|
|
# # Test coinbase construction
|
|
# coinbase_wit, coinbase_nowit = self.build_coinbase_transaction_for_address(
|
|
# template, "00000001", "01000000", self.target_address)
|
|
|
|
# if not coinbase_wit or not coinbase_nowit:
|
|
# print("❌ Cannot construct coinbase transaction")
|
|
# return False
|
|
|
|
# print(f"✅ Coinbase construction works")
|
|
|
|
# # Test block header construction with dummy values
|
|
# test_nonce = "12345678"
|
|
# test_ntime = f"{int(time.time()):08x}"
|
|
|
|
# # Calculate merkle root
|
|
# coinbase_txid = hashlib.sha256(hashlib.sha256(coinbase_nowit).digest()).digest()[::-1]
|
|
# merkle_root = self.calculate_merkle_root(coinbase_txid, template.get('transactions', []))
|
|
|
|
# # Build test header
|
|
# header = b''
|
|
# header += struct.pack('<I', template.get('version', 1))
|
|
# header += bytes.fromhex(template.get("previousblockhash", "0" * 64))[::-1]
|
|
# header += merkle_root
|
|
# header += struct.pack('<I', int(test_ntime, 16))
|
|
# header += bytes.fromhex(template.get('bits', '1d00ffff'))
|
|
# header += struct.pack('<I', int(test_nonce, 16))
|
|
|
|
# # Calculate hash
|
|
# block_hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
|
|
# block_hash_hex = block_hash[::-1].hex()
|
|
|
|
# print(f"✅ Block header construction works")
|
|
# print(f" Test hash: {block_hash_hex}")
|
|
|
|
# # Check difficulty calculation
|
|
# target = self.bits_to_target(template.get('bits', '1d00ffff'))
|
|
# network_diff = self.calculate_network_difficulty(target)
|
|
|
|
# print(f"✅ Difficulty calculation works")
|
|
# print(f" Network difficulty: {network_diff:.6f}")
|
|
# print(f" Bits: {template.get('bits', '1d00ffff')}")
|
|
# print(f" Target: {target[:16]}...")
|
|
|
|
# # Test RPC submission (dry run - don't actually submit)
|
|
# print(f"✅ Ready to mine valid blocks!")
|
|
# print(f" Block height: {template.get('height', 0)}")
|
|
# print(f" Reward: {template.get('coinbasevalue', 0) / 100000000:.2f} RIN")
|
|
# print(f" Transactions: {len(template.get('transactions', []))}")
|
|
|
|
# return True
|
|
|
|
# except Exception as e:
|
|
# print(f"❌ Mining validation failed: {e}")
|
|
# import traceback
|
|
# traceback.print_exc()
|
|
# return False
|
|
|
|
# def start(self):
|
|
# """Start the Stratum proxy server"""
|
|
# try:
|
|
# # Test RPC connection
|
|
# blockchain_info = self.rpc_call("getblockchaininfo")
|
|
# if not blockchain_info:
|
|
# print("❌ Failed to connect to RinCoin node!")
|
|
# return
|
|
|
|
# print(f"✅ Connected to RinCoin node (block {blockchain_info.get('blocks', 'unknown')})")
|
|
# print(f" Chain: {blockchain_info.get('chain', 'unknown')}")
|
|
# print(f" Difficulty: {blockchain_info.get('difficulty', 'unknown')}")
|
|
|
|
# # Validate mining capability
|
|
# if not self.validate_mining_capability():
|
|
# print("❌ Mining validation failed - cannot continue")
|
|
# return
|
|
|
|
# # 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!")
|
|
# return
|
|
|
|
# # Start job updater thread
|
|
# job_thread = threading.Thread(target=self.job_updater, daemon=True)
|
|
# job_thread.start()
|
|
|
|
# # Start Stratum server
|
|
# server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
# server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
# server_socket.bind((self.stratum_host, self.stratum_port))
|
|
# server_socket.listen(10)
|
|
|
|
# timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
# 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(f" 🧪 Debug mode: Submit blocks at {self.submit_threshold*100:.0f}% of network difficulty")
|
|
# print("")
|
|
# print(" 🔧 Miner command:")
|
|
# print(f" ./cpuminer -a rinhash -o stratum+tcp://{self.stratum_host}:{self.stratum_port} -u worker1 -p x -t 4")
|
|
# print("")
|
|
|
|
# while self.running:
|
|
# try:
|
|
# client, addr = server_socket.accept()
|
|
# client_thread = threading.Thread(
|
|
# target=self.handle_client,
|
|
# args=(client, addr),
|
|
# daemon=True
|
|
# )
|
|
# client_thread.start()
|
|
# except KeyboardInterrupt:
|
|
# print("\nShutting down...")
|
|
# self.running = False
|
|
# break
|
|
# except Exception as e:
|
|
# print(f"Server error: {e}")
|
|
|
|
# except Exception as e:
|
|
# print(f"Failed to start server: {e}")
|
|
# finally:
|
|
# print("Server stopped")
|
|
|
|
# if __name__ == "__main__":
|
|
# import sys
|
|
|
|
# # Parse command line arguments
|
|
# submit_all = False
|
|
# submit_threshold = 0.1 # Default 10%
|
|
|
|
# for i, arg in enumerate(sys.argv[1:], 1):
|
|
# if arg == "--submit-all-blocks":
|
|
# submit_all = True
|
|
# print("🧪 TEST MODE: Will submit ALL blocks for validation (submit_all_blocks=True)")
|
|
# elif arg == "--submit-threshold" and i + 1 < len(sys.argv):
|
|
# try:
|
|
# submit_threshold = float(sys.argv[i + 1])
|
|
# if submit_threshold <= 0:
|
|
# print(f"❌ Invalid threshold {submit_threshold}. Must be greater than 0")
|
|
# sys.exit(1)
|
|
# print(f"🧪 DEBUG MODE: Will submit blocks at {submit_threshold:.1f}x network difficulty")
|
|
# except ValueError:
|
|
# print(f"❌ Invalid threshold value: {sys.argv[i + 1]}")
|
|
# sys.exit(1)
|
|
|
|
# proxy = RinCoinStratumProxy(submit_all_blocks=submit_all, submit_threshold=submit_threshold)
|
|
# proxy.start()
|