583 lines
24 KiB
Python
583 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
RinCoin Stratum Proxy Server - REAL MINING VERSION
|
|
Properly constructs Stratum jobs and validates/submits real blocks
|
|
"""
|
|
|
|
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'):
|
|
|
|
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.clients = {}
|
|
self.job_counter = 0
|
|
self.current_job = None
|
|
self.running = True
|
|
self.extranonce1_counter = 0
|
|
|
|
print(f"RinCoin Stratum Proxy Server - REAL MINING")
|
|
print(f"Stratum: {stratum_host}:{stratum_port}")
|
|
print(f"RPC: {rpc_host}:{rpc_port}")
|
|
print(f"Target: {target_address}")
|
|
|
|
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.startswith('rin1'):
|
|
raise ValueError("Not a RinCoin bech32 address")
|
|
|
|
# Use generatetoaddress to get a proper script for this address
|
|
# This ensures we create valid outputs that can actually be spent
|
|
result = self.rpc_call("validateaddress", [address])
|
|
if result and result.get('isvalid') and 'scriptPubKey' in result:
|
|
script_hex = result['scriptPubKey']
|
|
return bytes.fromhex(script_hex)
|
|
else:
|
|
# Fallback: create a basic P2WPKH script if RPC validation fails
|
|
# Extract the witness program (assuming it's standard 20-byte)
|
|
# This is a simplified approach - in production use a proper bech32 library
|
|
print(f"Warning: Using fallback script for {address}")
|
|
return bytes([0x00, 0x14]) + bytes(20) # OP_0 + 20 zero bytes
|
|
|
|
except Exception as e:
|
|
print(f"Address decode error: {e}")
|
|
# Emergency fallback - this should never happen in production
|
|
return bytes([0x00, 0x14]) + bytes(20)
|
|
|
|
def build_coinbase_transaction(self, template, extranonce1, extranonce2):
|
|
"""Build complete coinbase transaction"""
|
|
try:
|
|
coinbase = b''
|
|
|
|
# Version
|
|
coinbase += struct.pack('<I', 1)
|
|
|
|
# Check if we need segwit format based on template
|
|
has_witness_commitment = template.get('default_witness_commitment') is not None
|
|
|
|
if has_witness_commitment:
|
|
# Segwit marker and flag (only if witness commitment present)
|
|
coinbase += b'\x00\x01'
|
|
|
|
# Input count
|
|
coinbase += b'\x01'
|
|
|
|
# Coinbase input
|
|
coinbase += b'\x00' * 32 # prev hash (null)
|
|
coinbase += b'\xff\xff\xff\xff' # prev index
|
|
|
|
# Script sig (height + extranonces + signature)
|
|
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()
|
|
coinbase += self.encode_varint(len(scriptsig)) + scriptsig
|
|
|
|
# Sequence
|
|
coinbase += b'\xff\xff\xff\xff'
|
|
|
|
# Prepare outputs
|
|
outputs = []
|
|
|
|
# Main output to mining address
|
|
value = template.get('coinbasevalue', 0)
|
|
script_pubkey = self.decode_bech32_address(self.target_address)
|
|
outputs.append(struct.pack('<Q', value) + self.encode_varint(len(script_pubkey)) + script_pubkey)
|
|
|
|
# Witness commitment output if present
|
|
witness_commitment = template.get('default_witness_commitment')
|
|
if witness_commitment:
|
|
commit_script = bytes.fromhex(witness_commitment)
|
|
outputs.append(struct.pack('<Q', 0) + self.encode_varint(len(commit_script)) + commit_script)
|
|
|
|
# Add outputs
|
|
coinbase += self.encode_varint(len(outputs))
|
|
for output in outputs:
|
|
coinbase += output
|
|
|
|
# Witness data (only if segwit format)
|
|
if has_witness_commitment:
|
|
coinbase += b'\x01' # witness stack count for input
|
|
coinbase += b'\x20' # witness item length (32 bytes)
|
|
coinbase += b'\x00' * 32 # witness nonce
|
|
|
|
# Locktime
|
|
coinbase += struct.pack('<I', 0)
|
|
|
|
return coinbase
|
|
|
|
except Exception as e:
|
|
print(f"Coinbase construction error: {e}")
|
|
return 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 bits_to_target(self, bits_hex):
|
|
"""Convert bits to target"""
|
|
try:
|
|
bits = int(bits_hex, 16)
|
|
exponent = bits >> 24
|
|
mantissa = bits & 0xffffff
|
|
target = mantissa * (256 ** (exponent - 3))
|
|
return f"{target:064x}"
|
|
except:
|
|
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
|
|
print(f"New job: {job['job_id']} | Height: {job['height']} | Reward: {job['coinbasevalue']/100000000:.2f} RIN")
|
|
return job
|
|
|
|
except Exception as e:
|
|
print(f"Get block template error: {e}")
|
|
return None
|
|
|
|
def submit_share(self, job, extranonce1, extranonce2, ntime, nonce):
|
|
"""Validate share and submit block if valid"""
|
|
try:
|
|
print(f"Share: job={job['job_id']} nonce={nonce}")
|
|
|
|
# Build coinbase transaction
|
|
coinbase = self.build_coinbase_transaction(job['template'], extranonce1, extranonce2)
|
|
if not coinbase:
|
|
return False, "Coinbase construction failed"
|
|
|
|
# Calculate coinbase transaction hash
|
|
coinbase_hash = hashlib.sha256(hashlib.sha256(coinbase).digest()).digest()[::-1]
|
|
|
|
# Calculate merkle root
|
|
merkle_root = self.calculate_merkle_root(coinbase_hash, job['transactions'])
|
|
|
|
# Build block header
|
|
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
|
|
|
|
# Calculate block hash
|
|
block_hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
|
|
block_hash_hex = block_hash[::-1].hex()
|
|
|
|
# Check if hash meets target
|
|
hash_int = int(block_hash_hex, 16)
|
|
target_int = int(job['target'], 16)
|
|
|
|
if hash_int > target_int:
|
|
# Valid share but not a block
|
|
return True, "Share accepted"
|
|
|
|
# Valid block! Build full block and submit
|
|
print(f"BLOCK FOUND! Hash: {block_hash_hex}")
|
|
|
|
# Build complete block
|
|
block = header
|
|
|
|
# Transaction count
|
|
tx_count = 1 + len(job['transactions'])
|
|
block += self.encode_varint(tx_count)
|
|
|
|
# Add coinbase transaction
|
|
block += coinbase
|
|
|
|
# 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...")
|
|
|
|
result = self.rpc_call("submitblock", [block_hex])
|
|
|
|
if result is None:
|
|
print(f"✅ Block accepted: {block_hash_hex}")
|
|
print(f"💰 Reward: {job['coinbasevalue']/100000000:.2f} RIN -> {self.target_address}")
|
|
print(f"📊 Block height: {job['height']}")
|
|
return True, "Block found and submitted"
|
|
else:
|
|
print(f"❌ Block rejected: {result}")
|
|
print(f"📦 Block hash: {block_hash_hex}")
|
|
print(f"📊 Block height: {job['height']}")
|
|
print(f"🔍 Debug: Block size {len(block_hex)//2} bytes, {len(job['transactions'])} transactions")
|
|
return False, f"Block rejected: {result}"
|
|
|
|
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:
|
|
data = json.loads(message.strip())
|
|
method = data.get("method")
|
|
msg_id = data.get("id")
|
|
params = data.get("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
|
|
])
|
|
|
|
# Send difficulty
|
|
self.send_stratum_notification(client, "mining.set_difficulty", [0.0001])
|
|
|
|
# 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)
|
|
print(f"[{addr}] Authorized as {username}")
|
|
|
|
elif method == "mining.extranonce.subscribe":
|
|
# Handle extranonce subscription
|
|
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}")
|
|
|
|
# Validate submission
|
|
if self.current_job and job_id == self.current_job['job_id']:
|
|
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)
|
|
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)
|
|
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:
|
|
print(f"[{addr}] Invalid JSON: {message}")
|
|
except Exception as e:
|
|
print(f"[{addr}] Message handling error: {e}")
|
|
|
|
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"],
|
|
"", # coinb1 (empty for now - miner handles coinbase)
|
|
"", # coinb2 (empty for now - miner handles coinbase)
|
|
[], # merkle_branch (empty for now - we calculate merkle root)
|
|
f"{job['version']:08x}",
|
|
job["bits"],
|
|
job["ntime"],
|
|
True # clean_jobs
|
|
])
|
|
except Exception as e:
|
|
print(f"Failed to send job: {e}")
|
|
|
|
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"""
|
|
print(f"[{addr}] Connected")
|
|
if addr not in self.clients:
|
|
self.clients[addr] = {}
|
|
self.clients[addr]['socket'] = client
|
|
|
|
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]
|
|
print(f"[{addr}] Disconnected")
|
|
|
|
def job_updater(self):
|
|
"""Periodically update mining jobs"""
|
|
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()
|
|
|
|
except Exception as e:
|
|
print(f"Job updater error: {e}")
|
|
|
|
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")
|
|
print(f"Current height: {blockchain_info.get('blocks', 'unknown')}")
|
|
print(f"Chain: {blockchain_info.get('chain', 'unknown')}")
|
|
|
|
# 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)
|
|
|
|
print(f"REAL 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("")
|
|
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__":
|
|
proxy = RinCoinStratumProxy()
|
|
proxy.start() |