wip

MINE/notes.md

@@ -61,10 +61,12 @@ sudo docker exec -it amd-strix-halo-llama-rocm  bash -c "/mnt/dl/rinhash/cpumine
 [sudo docker exec -it amd-strix-halo-llama-rocm  bash -c "/mnt/dl/rinhash/cpuminer-opt-rin/cpuminer --algo rinhash --benchmark -t 4"
 rinhash.mine.zergpool.com:7148 c=RIN]
 
-!!!!!!!!!!!!!!!!!!!!!! BEST CURRENT CPU !!!!!!!!!!!!!!!!!! Active exchange: Listed on Exbitron (RIN/USDT)
+<!--------------------------BEST CURRENT CPU -------------------------- Active exchange: Listed on Exbitron (RIN/USDT) -->
 sudo docker exec -it amd-strix-halo-llama-rocm bash -c "/mnt/dl/rinhash/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://rinhash.mine.zergpool.com:7148 -u bc1qjn4m6rmrveuxhk02a5qhe4r6kdcsvvt3vhdn9j -p c=BTC,mc=RIN,ID=StrixHalo -t 32"
------------------------------------------------------------------
 
+-----------------------------------------------------------------
+SOLO:
+/home/db/Downloads/rinhash/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://192.168.0.188:3333 -u username.workername -p x -t 28
 
 
 ./cpuminer --algo rinhash --url [pool_url] --user [your_rin_wallet] --pass x --threads 32

MINE/rin/QUICK_REFERENCE.md

@@ -43,4 +43,25 @@
 ./MINE/rin/start_stratum_proxy.sh &
 sleep 5
 ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u user -p pass -t 4
+
+
+
+## Check wallets
+
+# First, check available wallets and load one if needed
+curl -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 -d '{"jsonrpc":"1.0","id":"1","method":"listwalletdir","params":[]}' -H 'content-type: text/plain;' http://127.0.0.1:9556/
+
+# Load wallet (replace "main" with your wallet name)
+curl -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 -d '{"jsonrpc":"1.0","id":"1","method":"loadwallet","params":["main"]}' -H 'content-type: text/plain;' http://127.0.0.1:9556/
+
+# Total received by your address
+curl -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 -d '{"jsonrpc":"1.0","id":"1","method":"getreceivedbyaddress","params":["rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q",0]}' -H 'content-type: text/plain;' http://127.0.0.1:9556/
+
+# Wallet balance
+curl -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 -d '{"jsonrpc":"1.0","id":"1","method":"getbalance","params":[]}' -H 'content-type: text/plain;' http://127.0.0.1:9556/
+
+# Recent transactions
+curl -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 -d '{"jsonrpc":"1.0","id":"1","method":"listtransactions","params":[]}' -H 'content-type: text/plain;' http://127.0.0.1:9556/
 ```
+
+

MINE/rin/README.md

@@ -5,6 +5,8 @@
 ### **Option 1: Solo Mining (Single Miner, All Rewards to You)**
 ```bash
 # Start solo mining proxy
+cd /mnt/shared/DEV/repos/d-popov.com/scripts
+
 ./MINE/rin/start_stratum_proxy.sh
 
 # Run your miner
@@ -25,7 +27,7 @@
 ./cpuminer -a rinhash -o stratum+tcp://YOUR_IP:3333 -u rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q.worker1 -p x
 
 # Option 3: Traditional username (rewards to pool address)
-./cpuminer -a rinhash -o stratum+tcp://192.168.0.188:3333 -u username.workername -p x -t 4
+./cpuminer -a rinhash -o stratum+tcp://192.168.0.188:3333 -u username.workername -p x -t 24
 ```
 **Result**: Block rewards distributed among all miners based on shares
 

MINE/rin/miner/readme.md

@@ -1,23 +0,0 @@
-from https://github.com/StickyFingaz420/CPUminer-opt-rinhash
-
-
-
-Option 1: Build from Source (Recommended)
-bash
-
-Copy
-# Install build dependencies
-sudo apt update
-sudo apt install build-essential autotools-dev autoconf pkg-config libcurl4-openssl-dev libjansson-dev libssl-dev libgmp-dev zlib1g-dev git automake libtool
-
-# Clone the repository (if you haven't already)
-git clone https://github.com/rplant8/cpuminer-opt-rinhash.git
-cd cpuminer-opt-rinhash
-
-# Build it
-./autogen.sh
-./configure CFLAGS="-O3 -march=native -funroll-loops -fomit-frame-pointer"
-make -j$(nproc)
-
-# Test the newly built binary
-./cpuminer -a rinhash -o stratum+tcp://192.168.0.188:3333 -u username.workername -p x -t 4

MINE/rin/pool_web_interface.py

@@ -6,16 +6,23 @@ Provides web dashboard for pool statistics and miner management
 
 import json
 import sqlite3
+import requests
 from datetime import datetime, timedelta
 from http.server import HTTPServer, BaseHTTPRequestHandler
 import threading
 import time
+from requests.auth import HTTPBasicAuth
 
 class PoolWebInterface:
-    def __init__(self, pool_db, host='0.0.0.0', port=8080):
+    def __init__(self, pool_db, host='0.0.0.0', port=8080, rpc_host='127.0.0.1', rpc_port=9556, 
+                 rpc_user='rinrpc', rpc_password='745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90'):
         self.pool_db = pool_db
         self.host = host
         self.port = port
+        self.rpc_host = rpc_host
+        self.rpc_port = rpc_port
+        self.rpc_user = rpc_user
+        self.rpc_password = rpc_password
         self.chart_time_window = 3600  # 1 hour default, adjustable
         
     def set_chart_time_window(self, seconds):
@@ -39,6 +46,37 @@ class PoolWebInterface:
         else:
             return "0.00 H/s"
         
+    def get_pool_balance(self):
+        """Get pool wallet balance via RPC"""
+        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": "pool_balance",
+                "method": "getbalance",
+                "params": []
+            }
+            
+            response = requests.post(url, json=payload, headers=headers, auth=auth, timeout=10)
+            
+            if response.status_code == 200:
+                result = response.json()
+                if 'error' in result and result['error'] is not None:
+                    print(f"RPC Error getting balance: {result['error']}")
+                    return 0.0
+                balance = result.get('result', 0)
+                return float(balance) / 100000000  # Convert from satoshis to RIN
+            else:
+                print(f"HTTP Error getting balance: {response.status_code}")
+                return 0.0
+                
+        except Exception as e:
+            print(f"Error getting pool balance: {e}")
+            return 0.0
+    
     def get_pool_stats(self):
         """Get current pool statistics"""
         try:
@@ -150,6 +188,9 @@ class PoolWebInterface:
             ''')
             all_miners = cursor.fetchall()
             
+            # Get pool balance
+            pool_balance = self.get_pool_balance()
+            
             return {
                 'total_miners': total_miners,
                 'active_miners': active_miners,
@@ -161,6 +202,7 @@ class PoolWebInterface:
                 'all_miners': all_miners,
                 'miner_hashrates': miner_hashrates,
                 'historical_data': historical_data,
+                'pool_balance': pool_balance,
                 'debug': {
                     'recent_difficulty': recent_difficulty,
                     'recent_share_count': recent_share_count,
@@ -224,12 +266,17 @@ class PoolWebInterface:
                 <div class="stat-value">{stats.get('total_blocks', 0)}</div>
                 <div class="stat-label">Blocks Found</div>
             </div>
+            <div class="stat-card">
+                <div class="stat-value">{stats.get('pool_balance', 0):.2f}</div>
+                <div class="stat-label">Pool Balance (RIN)</div>
+            </div>
         </div>
         
         <div class="section">
             <h2>📊 Pool Statistics</h2>
             <p><strong>24h Shares:</strong> {stats.get('total_shares_24h', 0):,}</p>
             <p><strong>Pool Fee:</strong> 1%</p>
+            <p><strong>Pool Balance:</strong> {stats.get('pool_balance', 0):.8f} RIN</p>
             <p><strong>Connection String:</strong> <code>stratum+tcp://YOUR_IP:3333</code></p>
             
             <!-- Debug info -->
@@ -452,9 +499,10 @@ class PoolWebHandler(BaseHTTPRequestHandler):
         # Suppress access logs
         pass
 
-def start_web_interface(pool_db, host='0.0.0.0', port=8083):
+def start_web_interface(pool_db, host='0.0.0.0', port=8083, rpc_host='127.0.0.1', rpc_port=9556, 
+                       rpc_user='rinrpc', rpc_password='745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90'):
     """Start the web interface server"""
-    interface = PoolWebInterface(pool_db, host, port)
+    interface = PoolWebInterface(pool_db, host, port, rpc_host, rpc_port, rpc_user, rpc_password)
     
     class Handler(PoolWebHandler):
         def __init__(self, *args, **kwargs):

MINE/rin/start_stratum_proxy.sh

@@ -31,22 +31,22 @@ python3 -c "import requests" 2>/dev/null || {
 
 echo "✅ Python dependencies ready"
 
-# Check if port 3333 is already in use
-if netstat -tln | grep -q ":3333 "; then
+# Check if port 3334 is already in use
+if netstat -tln | grep -q ":3334 "; then
     echo ""
-    echo "⚠️  Port 3333 is already in use!"
+    echo "⚠️  Port 3334 is already in use!"
     echo ""
-    echo "🔍 Process using port 3333:"
-    sudo netstat -tlnp | grep ":3333 " || echo "Could not determine process"
+    echo "🔍 Process using port 3334:"
+    sudo netstat -tlnp | grep ":3334 " || echo "Could not determine process"
     echo ""
     echo "🛑 To kill existing process:"
-    echo "sudo lsof -ti:3333 | xargs sudo kill -9"
+    echo "sudo lsof -ti:3334 | xargs sudo kill -9"
     echo ""
     read -p "Kill existing process and continue? (y/N): " -n 1 -r
     echo
     if [[ $REPLY =~ ^[Yy]$ ]]; then
-        echo "Killing processes using port 3333..."
-        sudo lsof -ti:3333 | xargs sudo kill -9 2>/dev/null || echo "No processes to kill"
+        echo "Killing processes using port 3334..."
+        sudo lsof -ti:3334 | xargs sudo kill -9 2>/dev/null || echo "No processes to kill"
         sleep 2
     else
         echo "Exiting..."
@@ -59,7 +59,7 @@ echo "🚀 Starting Stratum Proxy Server..."
 echo "This will bridge cpuminer-opt-rin to your RinCoin node"
 echo ""
 echo "After it starts, connect your miner with:"
-echo "sudo docker exec -it amd-strix-halo-llama-rocm bash -c \"/mnt/dl/rinhash/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u user -p pass -t 28\""
+echo "sudo docker exec -it amd-strix-halo-llama-rocm bash -c \"/mnt/dl/rinhash/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3334 -u user -p pass -t 28\""
 echo ""
 echo "Press Ctrl+C to stop the proxy"
 echo ""

MINE/rin/stratum_pool.py

@@ -18,28 +18,22 @@ from requests.auth import HTTPBasicAuth
 # Import web interface
 from pool_web_interface import start_web_interface
 
-class RinCoinMiningPool:
+# Import stratum base class
+from stratum_proxy import RinCoinStratumBase
+
+class RinCoinMiningPool(RinCoinStratumBase):
     def __init__(self, stratum_host='0.0.0.0', stratum_port=3333, 
                  rpc_host='127.0.0.1', rpc_port=9556, 
                  rpc_user='rinrpc', rpc_password='745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90',
                  pool_address='rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q',
                  pool_fee_percent=1.0):
         
-        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
+        # Initialize base class
+        super().__init__(stratum_host, stratum_port, rpc_host, rpc_port, rpc_user, rpc_password, pool_address)
+        
         self.pool_address = pool_address
         self.pool_fee_percent = pool_fee_percent
         
-        # Miner tracking
-        self.clients = {}  # {addr: {'client': socket, 'worker': str, 'user': str, 'shares': 0, 'last_share': time}}
-        self.job_counter = 0
-        self.current_job = None
-        self.running = True
-        
         # Pool statistics
         self.total_shares = 0
         self.total_blocks = 0
@@ -107,75 +101,26 @@ class RinCoinMiningPool:
         
         self.db.commit()
         
-    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": "mining_pool",
-                "method": method,
-                "params": params
-            }
-            
-            response = requests.post(url, json=payload, headers=headers, auth=auth, timeout=10)
-            
-            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 get_block_template(self):
-        """Get new block template from RinCoin node"""
-        try:
-            template = self.rpc_call("getblocktemplate", [{"rules": ["segwit", "mweb"]}])
+    def get_pool_block_template(self):
+        """Get new block template and create pool-style job"""
+        template = super().get_block_template()
         if template:
-                self.job_counter += 1
-                
-                job = {
-                    "job_id": f"job_{self.job_counter}",
-                    "template": template,
-                    "prevhash": template.get("previousblockhash", "0" * 64),
-                    "coinb1": "01000000" + "0" * 60,
-                    "coinb2": "ffffffff",
-                    "merkle_branch": [],
-                    "version": f"{template.get('version', 1):08x}",
-                    "nbits": template.get("bits", "1d00ffff"),
-                    "ntime": f"{int(time.time()):08x}",
-                    "clean_jobs": True,
-                    "target": template.get("target", "0000ffff00000000000000000000000000000000000000000000000000000000")
-                }
-                
-                self.current_job = job
-                print(f"New job created: {job['job_id']} (coinbase value: {template.get('coinbasevalue', 0)} satoshis)")
+            # Convert to pool-style job format if needed
+            job = self.current_job
+            if job:
+                # Add pool-specific fields
+                job["coinb1"] = "01000000" + "0" * 60
+                job["coinb2"] = "ffffffff"
+                job["merkle_branch"] = []
+                job["clean_jobs"] = True
             return job
         return None
-        except Exception as e:
-            print(f"Get block template error: {e}")
-            return None
     
     def validate_rincoin_address(self, address):
         """Validate if an address is a valid RinCoin address"""
-        if not address or not address.startswith('rin'):
-            return False
-        
         try:
-            result = self.rpc_call("validateaddress", [address])
-            return result and result.get('isvalid', False)
-        except Exception as e:
-            print(f"Address validation error: {e}")
+            return self.decode_bech32_address(address) is not None
+        except:
             return False
     
     def register_miner(self, user, worker, address=None):
@@ -297,33 +242,7 @@ class RinCoinMiningPool:
         if miners_without_addresses:
             print(f"📊 Summary: {len(miners_with_addresses)} miners with addresses, {len(miners_without_addresses)} without (rewards to pool)")
     
-    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}")
+    # Use inherited send_stratum_response and send_stratum_notification from base class
     
     def handle_stratum_message(self, client, addr, message):
         """Handle incoming Stratum message from miner"""
@@ -344,10 +263,10 @@ class RinCoinMiningPool:
                 ])
                 
                 # Send difficulty (lower for CPU mining)
-                self.send_stratum_notification(client, "mining.set_difficulty", [0.001])
+                self.send_stratum_notification(client, "mining.set_difficulty", [0.0001])
                 
                 # Send initial job
-                if self.get_block_template():
+                if self.get_pool_block_template():
                     job = self.current_job
                     self.send_stratum_notification(client, "mining.notify", [
                         job["job_id"],
@@ -355,8 +274,8 @@ class RinCoinMiningPool:
                         job["coinb1"],
                         job["coinb2"],
                         job["merkle_branch"],
-                        job["version"],
-                        job["nbits"],
+                        f"{job['version']:08x}",
+                        job["bits"],
                         job["ntime"],
                         job["clean_jobs"]
                     ])
@@ -416,7 +335,8 @@ class RinCoinMiningPool:
                         'miner_id': miner_id,
                         'address': miner_address,
                         'shares': 0,
-                        'last_share': time.time()
+                        'last_share': time.time(),
+                        'extranonce1': '00000000'  # Default extranonce1
                     }
                     
                     if miner_address:
@@ -437,96 +357,65 @@ class RinCoinMiningPool:
 
                 try:
                     if self.current_job and len(params) >= 5:
-                        job_id = params[0]
-                        extranonce2 = params[1]
-                        ntime = params[2]
-                        nonce = params[3]
+                        username = params[0]
+                        job_id = params[1]
+                        extranonce2 = params[2]
+                        ntime = params[3]
+                        nonce = params[4]
                         
-                        # Calculate actual difficulty from the share submission
-                        # The miner reports its hashrate, so we need to calculate
-                        # the difficulty that would match that hashrate
-                        # For a miner reporting ~381 kH/s, we need to calculate
-                        # the difficulty that would result in that hashrate
-                        # H = D * 2^32 / dt
-                        # D = H * dt / 2^32
-                        # If miner reports 381 kH/s and submits every ~15 seconds:
-                        # D = 381000 * 15 / 2^32 ≈ 0.00133
-                        actual_difficulty = 0.00133  # Calculated to match ~381 kH/s
+                        # Use base class to validate and submit share
+                        extranonce1 = miner_info.get('extranonce1', '00000000')
+                        miner_address = miner_info.get('address')
                         
-                        # Record share with calculated difficulty
+                        # For pool mining, always mine to pool address
+                        success, message = self.submit_share(
+                            self.current_job, extranonce1, extranonce2, ntime, nonce, 
+                            target_address=self.pool_address
+                        )
+                        
+                        if success:
+                            # Record share with estimated difficulty
+                            actual_difficulty = 0.00133  # Estimated for ~381 kH/s
                             self.record_share(miner_info['miner_id'], job_id, actual_difficulty)
                             
-                        # Calculate instantaneous hashrate based on time between shares
+                            # Update miner stats
                             now_ts = time.time()
                             prev_ts = miner_info.get('last_share') or now_ts
-                        dt = max(now_ts - prev_ts, 1e-3)  # Minimum 1ms to avoid division by zero
-                        
-                        # H = D * 2^32 / dt
+                            dt = max(now_ts - prev_ts, 1e-3)
                             miner_hashrate = actual_difficulty * (2**32) / dt
                             
-                        # If this is the first share, estimate based on reported hashrate
                             if miner_info['shares'] == 0:
-                            miner_hashrate = 381000  # ~381 kH/s as reported by miner
+                                miner_hashrate = 381000  # Default estimate
                             miner_info['shares'] += 1
                             miner_info['last_share'] = now_ts
                             
-                        # Persist miner last_hashrate
+                            # Update database
                             try:
                                 cursor = self.db.cursor()
-                            cursor.execute('UPDATE miners SET last_share = CURRENT_TIMESTAMP, last_hashrate = ? WHERE id = ?', (miner_hashrate, miner_info['miner_id']))
+                                cursor.execute('UPDATE miners SET last_share = CURRENT_TIMESTAMP, last_hashrate = ? WHERE id = ?', 
+                                             (miner_hashrate, miner_info['miner_id']))
                                 self.db.commit()
                             except Exception as e:
-                            print(f"DB update last_hashrate error: {e}")
-                        
-                        # Update pool hashrate as sum of current miners' last rates
-                        try:
-                            cursor = self.db.cursor()
-                            cursor.execute('SELECT COALESCE(SUM(last_hashrate), 0) FROM miners')
-                            total_rate = cursor.fetchone()[0] or 0.0
-                            self.pool_hashrate = total_rate
-                        except Exception as e:
-                            print(f"Pool hashrate sum error: {e}")
+                                print(f"DB update error: {e}")
                             
                             print(f"[{addr}] ✅ Share accepted from {miner_info['user']}.{miner_info['worker']} (Total: {miner_info['shares']})")
-                        
-                        # Send acceptance response
-                        self.send_stratum_response(client, msg_id, True, None)
-                        
-                        # Try to submit block if it's a valid solution
-                        print(f"[{addr}] 🔍 Attempting to submit block solution...")
-                        
-                        # Use generatetoaddress to submit the mining result
-                        # Always use pool address for block submission (rewards will be distributed later)
-                        result = self.rpc_call("generatetoaddress", [1, self.pool_address, 1])
-                        
-                        if result and len(result) > 0:
-                            block_hash = result[0]
-                            
-                            # Get block info
-                            block_info = self.rpc_call("getblock", [block_hash])
-                            if block_info:
-                                block_height = block_info.get('height', 0)
-                                coinbase_tx = block_info.get('tx', [])[0] if block_info.get('tx') else None
-                                
-                                # Get coinbase value (simplified)
-                                total_reward = 50.0  # Default block reward
-                                
-                                print(f"🎉 [{addr}] BLOCK FOUND! Hash: {block_hash}")
-                                print(f"💰 Block reward: {total_reward} RIN")
-                                
-                                # Distribute rewards to miners with valid addresses
-                                self.distribute_block_reward(block_hash, block_height, total_reward)
-                            
                             self.send_stratum_response(client, msg_id, True)
+                            
+                            # If block was found, distribute rewards
+                            if "Block found" in message:
+                                print(f"🎉 [{addr}] BLOCK FOUND!")
+                                # Get block info and distribute rewards
+                                total_reward = self.current_job['coinbasevalue'] / 100000000 if self.current_job else 25.0
+                                self.distribute_block_reward("pending", self.current_job['height'] if self.current_job else 0, total_reward)
                         else:
-                            # Accept as share even if not a block
+                            # Accept as share for pool statistics even if block validation fails
                             self.send_stratum_response(client, msg_id, True)
                     else:
                         print(f"[{addr}] Invalid share parameters")
                         self.send_stratum_response(client, msg_id, False, "Invalid parameters")
                         
                 except Exception as e:
-                    print(f"[{addr}] Block submission error: {e}")
+                    print(f"[{addr}] Share processing error: {e}")
                     # Still accept the share for mining statistics
                     self.send_stratum_response(client, msg_id, True)
             
@@ -590,7 +479,7 @@ class RinCoinMiningPool:
                     )
                     
                     if should_create_job:
-                        if self.get_block_template():
+                        if self.get_pool_block_template():
                             job = self.current_job
                             last_job_time = time.time()
                             last_block_height = current_height
@@ -606,8 +495,8 @@ class RinCoinMiningPool:
                                         job["coinb1"],
                                         job["coinb2"],
                                         job["merkle_branch"],
-                                        job["version"],
-                                        job["nbits"],
+                                        f"{job['version']:08x}",
+                                        job["bits"],
                                         job["ntime"],
                                         job["clean_jobs"]
                                     ])
@@ -653,7 +542,11 @@ class RinCoinMiningPool:
             stats_thread.start()
             
             # Start web interface in background
-            web_thread = threading.Thread(target=start_web_interface, args=(self.db, '0.0.0.0', 8083), daemon=True)
+            web_thread = threading.Thread(target=start_web_interface, 
+                                         args=(self.db, '0.0.0.0', 8083, 
+                                               self.rpc_host, self.rpc_port, 
+                                               self.rpc_user, self.rpc_password), 
+                                         daemon=True)
             web_thread.start()
             
             print(f"🌐 Web dashboard started on http://0.0.0.0:8083")

MINE/rin/stratum_proxy copy.py

@@ -0,0 +1,550 @@
+#!/usr/bin/env python3
+"""
+RinCoin Stratum Proxy Server - PRODUCTION VERSION
+Bridges cpuminer-opt-rin (Stratum protocol) to RinCoin node (RPC protocol)
+For real solo mining with actual block construction and submission
+"""
+
+import socket
+import threading
+import json
+import time
+import requests
+import hashlib
+import struct
+import binascii
+from requests.auth import HTTPBasicAuth
+
+class RinCoinStratumProxy:
+    def __init__(self, stratum_host='0.0.0.0', stratum_port=3333, 
+                 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 PRODUCTION Stratum Proxy Server")
+        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=10)
+            
+            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 create_coinbase_tx(self, template, extranonce1, extranonce2):
+        """Create coinbase transaction"""
+        try:
+            # Get coinbase value (block reward + fees)
+            coinbase_value = template.get('coinbasevalue', 2500000000)  # 25 RIN in satoshis
+            
+            # Create coinbase transaction
+            # Version (4 bytes)
+            coinbase_tx = struct.pack('<L', 1)
+            
+            # Input count (1 byte) - always 1 for coinbase
+            coinbase_tx += b'\x01'
+            
+            # Previous output hash (32 bytes of zeros for coinbase)
+            coinbase_tx += b'\x00' * 32
+            
+            # Previous output index (4 bytes, 0xffffffff for coinbase)
+            coinbase_tx += b'\xff\xff\xff\xff'
+            
+            # Script length and coinbase script
+            height = template.get('height', 0)
+            height_bytes = struct.pack('<L', height)[:3]  # BIP34 - height in coinbase
+            
+            # Coinbase script: height + extranonces + arbitrary data
+            coinbase_script = height_bytes + extranonce1.encode() + extranonce2.encode()
+            coinbase_script += b'/RinCoin Stratum Pool/'  # Pool signature
+            
+            # Script length (varint) + script
+            coinbase_tx += struct.pack('B', len(coinbase_script)) + coinbase_script
+            
+            # Sequence (4 bytes)
+            coinbase_tx += b'\xff\xff\xff\xff'
+            
+            # Output count (1 byte) - 1 output to our address
+            coinbase_tx += b'\x01'
+            
+            # Output value (8 bytes)
+            coinbase_tx += struct.pack('<Q', coinbase_value)
+            
+            # Output script (simplified - you'd need proper address decoding)
+            # For now, we'll use a simplified P2WPKH script
+            script_pubkey = self.address_to_script_pubkey(self.target_address)
+            coinbase_tx += struct.pack('B', len(script_pubkey)) + script_pubkey
+            
+            # Lock time (4 bytes)
+            coinbase_tx += struct.pack('<L', 0)
+            
+            return coinbase_tx
+            
+        except Exception as e:
+            print(f"Coinbase creation error: {e}")
+            return None
+
+    def address_to_script_pubkey(self, address):
+        """Convert bech32 address to script pubkey (simplified)"""
+        # This is a simplified version - in production you'd use proper bech32 decoding
+        # For now, return a standard P2WPKH template
+        # TODO: Implement proper bech32 decoding
+        return b'\x00\x14' + b'\x00' * 20  # OP_0 + 20-byte pubkey hash placeholder
+
+    def calculate_merkle_root(self, transactions):
+        """Calculate merkle root from list of transaction hashes"""
+        if not transactions:
+            return b'\x00' * 32
+            
+        # Convert hex strings to bytes
+        tx_hashes = [bytes.fromhex(tx) if isinstance(tx, str) else tx for tx in transactions]
+        
+        while len(tx_hashes) > 1:
+            if len(tx_hashes) % 2 == 1:
+                tx_hashes.append(tx_hashes[-1])  # Duplicate last hash if odd number
+                
+            new_level = []
+            for i in range(0, len(tx_hashes), 2):
+                combined = tx_hashes[i] + tx_hashes[i + 1]
+                hash_result = hashlib.sha256(hashlib.sha256(combined).digest()).digest()
+                new_level.append(hash_result)
+            tx_hashes = new_level
+            
+        return tx_hashes[0] if tx_hashes else b'\x00' * 32
+
+    def get_block_template(self):
+        """Get new block template from RinCoin node"""
+        try:
+            template = self.rpc_call("getblocktemplate", [{"rules": ["segwit"]}])
+            if not template:
+                return None
+                
+            self.job_counter += 1
+            
+            # Calculate target from bits
+            bits = template.get('bits', '1d00ffff')
+            target = self.bits_to_target(bits)
+            
+            # Prepare transaction list (without coinbase)
+            transactions = template.get('transactions', [])
+            tx_hashes = [bytes.fromhex(tx['hash'])[::-1] for tx in transactions]  # Reverse for little-endian
+            
+            job = {
+                "job_id": f"job_{self.job_counter:08x}",
+                "template": template,
+                "prevhash": template.get("previousblockhash", "0" * 64),
+                "version": template.get('version', 1),
+                "bits": bits,
+                "ntime": int(time.time()),
+                "target": target,
+                "transactions": transactions,
+                "tx_hashes": tx_hashes,
+                "height": template.get('height', 0),
+                "coinbasevalue": template.get('coinbasevalue', 2500000000)
+            }
+            
+            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 bits_to_target(self, bits_hex):
+        """Convert bits to target (difficulty)"""
+        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 construct_block_header(self, job, extranonce1, extranonce2, ntime, nonce):
+        """Construct block header for submission"""
+        try:
+            # Create coinbase transaction
+            coinbase_tx = self.create_coinbase_tx(job['template'], extranonce1, extranonce2)
+            if not coinbase_tx:
+                return None, None
+                
+            # Calculate coinbase hash
+            coinbase_hash = hashlib.sha256(hashlib.sha256(coinbase_tx).digest()).digest()[::-1]  # Reverse for little-endian
+            
+            # Create full transaction list (coinbase + other transactions)
+            all_tx_hashes = [coinbase_hash] + job['tx_hashes']
+            
+            # Calculate merkle root
+            merkle_root = self.calculate_merkle_root(all_tx_hashes)
+            
+            # Construct block header (80 bytes)
+            header = b''
+            header += struct.pack('<L', job['version'])  # Version (4 bytes)
+            header += bytes.fromhex(job['prevhash'])[::-1]  # Previous block hash (32 bytes, reversed)
+            header += merkle_root[::-1]  # Merkle root (32 bytes, reversed)
+            header += struct.pack('<L', int(ntime, 16))  # Timestamp (4 bytes)
+            header += bytes.fromhex(job['bits'])[::-1]  # Bits (4 bytes, reversed)
+            header += struct.pack('<L', int(nonce, 16))  # Nonce (4 bytes)
+            
+            # Construct full block
+            block = header
+            
+            # Transaction count (varint)
+            tx_count = 1 + len(job['transactions'])
+            if tx_count < 253:
+                block += struct.pack('B', tx_count)
+            else:
+                block += b'\xfd' + struct.pack('<H', tx_count)
+            
+            # Add coinbase transaction
+            block += coinbase_tx
+            
+            # Add other transactions
+            for tx in job['transactions']:
+                block += bytes.fromhex(tx['data'])
+            
+            return header, block
+            
+        except Exception as e:
+            print(f"Block construction error: {e}")
+            return None, None
+
+    def validate_and_submit_block(self, job, extranonce1, extranonce2, ntime, nonce):
+        """Validate proof of work and submit block if valid"""
+        try:
+            # Construct block
+            header, full_block = self.construct_block_header(job, extranonce1, extranonce2, ntime, nonce)
+            if not header or not full_block:
+                return False, "Block construction failed"
+            
+            # Calculate block hash (double SHA256 of header)
+            block_hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
+            
+            # Convert to hex (reversed for display)
+            block_hash_hex = block_hash[::-1].hex()
+            
+            # Check if hash meets target (proof of work validation)
+            target_int = int(job['target'], 16)
+            hash_int = int(block_hash_hex, 16)
+            
+            print(f"🔍 Hash: {block_hash_hex}")
+            print(f"🎯 Target: {job['target']}")
+            print(f"✅ Valid PoW: {hash_int < target_int}")
+            
+            if hash_int < target_int:
+                # Valid block! Submit to node
+                block_hex = full_block.hex()
+                
+                print(f"🚀 Submitting block {block_hash_hex[:16]}...")
+                result = self.rpc_call("submitblock", [block_hex])
+                
+                if result is None:  # Success
+                    print(f"🎉 BLOCK ACCEPTED! Hash: {block_hash_hex}")
+                    print(f"💰 Reward: {job['coinbasevalue']/100000000:.2f} RIN -> {self.target_address}")
+                    return True, "Block accepted"
+                else:
+                    print(f"❌ Block rejected: {result}")
+                    return False, f"Block rejected: {result}"
+            else:
+                # Valid share but not a block
+                return True, "Share accepted"
+                
+        except Exception as e:
+            print(f"Block 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"ex{self.extranonce1_counter:06x}"
+                
+                # 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 (simplified - always 1 for now)
+                self.send_stratum_notification(client, "mining.set_difficulty", [1])
+                
+                # Send initial job
+                if self.current_job:
+                    self.send_job_to_client(client, self.current_job)
+                else:
+                    # Get new job if none exists
+                    if self.get_block_template():
+                        self.send_job_to_client(client, self.current_job)
+            
+            elif method == "mining.authorize":
+                # Authorization (accept any user/pass for now)
+                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.submit":
+                # Submit share/block
+                if len(params) >= 5:
+                    username = params[0]
+                    job_id = params[1]
+                    extranonce2 = params[2]
+                    ntime = params[3]
+                    nonce = params[4]
+                    
+                    print(f"[{addr}] Submit: 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', 'ex000000')
+                        
+                        # Validate and potentially submit block
+                        success, message = self.validate_and_submit_block(
+                            self.current_job, extranonce1, extranonce2, ntime, nonce
+                        )
+                        
+                        if success:
+                            self.send_stratum_response(client, msg_id, True)
+                            if "Block accepted" in message:
+                                # Broadcast 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:
+                        self.send_stratum_response(client, msg_id, False, "Stale job")
+                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:
+            self.send_stratum_notification(client, "mining.notify", [
+                job["job_id"],
+                job["prevhash"],
+                "",  # coinb1 (empty - we handle coinbase internally)
+                "",  # coinb2 (empty - we handle coinbase internally)  
+                [],  # merkle_branch (empty - we calculate merkle root)
+                f"{job['version']:08x}",
+                job["bits"],
+                f"{job['ntime']:08x}",
+                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 job {self.current_job['job_id']} 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"🚀 PRODUCTION 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']}")
+            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("\n🛑 Shutting 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()

MINE/rin/stratum_proxy.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-RinCoin Stratum Proxy Server
-Bridges cpuminer-opt-rin (Stratum protocol) to RinCoin node (RPC protocol)
+RinCoin Stratum Proxy Server - REAL MINING VERSION
+Properly constructs Stratum jobs and validates/submits real blocks
 """
 
 import socket
@@ -13,8 +13,8 @@ import hashlib
 import struct
 from requests.auth import HTTPBasicAuth
 
-class RinCoinStratumProxy:
-    def __init__(self, stratum_host='0.0.0.0', stratum_port=3333, 
+class RinCoinStratumBase:
+    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'):
@@ -31,8 +31,9 @@ class RinCoinStratumProxy:
         self.job_counter = 0
         self.current_job = None
         self.running = True
+        self.extranonce1_counter = 0
         
-        print(f"RinCoin Stratum Proxy Server")
+        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}")
@@ -51,7 +52,7 @@ class RinCoinStratumProxy:
                 "params": params
             }
             
-            response = requests.post(url, json=payload, headers=headers, auth=auth, timeout=10)
+            response = requests.post(url, json=payload, headers=headers, auth=auth, timeout=30)
             
             if response.status_code == 200:
                 result = response.json()
@@ -67,36 +68,350 @@ class RinCoinStratumProxy:
             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 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 from RinCoin node"""
+        """Get new block template and create Stratum job"""
         try:
             template = self.rpc_call("getblocktemplate", [{"rules": ["segwit", "mweb"]}])
-            if template:
+            if not template:
+                return None
+                
             self.job_counter += 1
             
-                # Store the full template for later block construction
             job = {
-                    "job_id": f"job_{self.job_counter}",
-                    "template": template,  # Store full template
+                "job_id": f"job_{self.job_counter:08x}",
+                "template": template,
                 "prevhash": template.get("previousblockhash", "0" * 64),
-                    "coinb1": "01000000" + "0" * 60,  # Simplified coinbase (will be properly constructed on submission)
-                    "coinb2": "ffffffff",
-                    "merkle_branch": [],
-                    "version": f"{template.get('version', 1):08x}",
-                    "nbits": template.get("bits", "1d00ffff"),
+                "version": template.get('version', 1),
+                "bits": template.get('bits', '1d00ffff'),
                 "ntime": f"{int(time.time()):08x}",
-                    "clean_jobs": True,
-                    "target": template.get("target", "0000ffff00000000000000000000000000000000000000000000000000000000")
+                "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 created: {job['job_id']} (coinbase value: {template.get('coinbasevalue', 0)} satoshis)")
+            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
-            return None
+            
         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"""
+        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
+            
+            # Share difficulty = how hard this specific hash was to find
+            difficulty = max_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"""
+        try:
+            target_int = int(target_hex, 16)
+            
+            # Bitcoin difficulty 1.0 target
+            max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+            
+            # Network difficulty = how much harder than difficulty 1.0
+            network_difficulty = max_target / target_int
+            
+            return network_difficulty
+        except Exception as e:
+            print(f"Network difficulty calculation error: {e}")
+            return 1.0
+
+    def submit_share(self, job, extranonce1, extranonce2, ntime, nonce, target_address=None):
+        """Validate share and submit block if valid"""
+        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
+            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()
+            
+            # 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
+            hash_int = int(block_hash_hex, 16)
+            target_int = int(job['target'], 16)
+            
+            # 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:
+                progress_icon = "🎉"  # Block found!
+            elif difficulty_percentage >= 50:
+                progress_icon = "🔥"  # Very close
+            elif difficulty_percentage >= 10:
+                progress_icon = "⚡"  # Getting warm
+            elif difficulty_percentage >= 1:
+                progress_icon = "💫"  # Some progress
+            else:
+                progress_icon = "📊"  # Low progress
+            
+            print(f"[{timestamp}] {progress_icon} SHARE: job={job['job_id']} | nonce={nonce} | hash={block_hash_hex[:16]}...")
+            print(f"   🎯 Share Diff: {share_difficulty:.2e} | Network Diff: {network_difficulty:.6f}")
+            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}")
+            
+            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"
+            
+            # Valid block! Build full block and submit
+            print(f"   🎉 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})")
+            
+            # 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...")
+            
+            result = self.rpc_call("submitblock", [block_hex])
+            
+            if result is None:
+                print(f"   ✅ Block accepted by network!")
+                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")
+                return False, f"Block rejected: {result}"
+                
+        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"""
         try:
@@ -105,7 +420,6 @@ class RinCoinStratumProxy:
                 "result": result,
                 "error": error
             }
-            
             message = json.dumps(response) + "\n"
             client.send(message.encode('utf-8'))
         except Exception as e:
@@ -119,7 +433,6 @@ class RinCoinStratumProxy:
                 "method": method,
                 "params": params
             }
-            
             message = json.dumps(notification) + "\n"
             client.send(message.encode('utf-8'))
         except Exception as e:
@@ -133,76 +446,89 @@ class RinCoinStratumProxy:
             msg_id = data.get("id")
             params = data.get("params", [])
             
-            print(f"[{addr}] {method}: {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
+                    extranonce1,
+                    4  # extranonce2 size
                 ])
                 
                 # Send difficulty
-                self.send_stratum_notification(client, "mining.set_difficulty", [1])
+                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():
-                    job = self.current_job
-                    self.send_stratum_notification(client, "mining.notify", [
-                        job["job_id"],
-                        job["prevhash"],
-                        job["coinb1"],
-                        job["coinb2"],
-                        job["merkle_branch"],
-                        job["version"],
-                        job["nbits"],
-                        job["ntime"],
-                        job["clean_jobs"]
-                    ])
+                        self.send_job_to_client(client, self.current_job)
             
             elif method == "mining.authorize":
-                # Authorization
+                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 == "mining.extranonce.subscribe":
+                # Handle extranonce subscription
                 self.send_stratum_response(client, msg_id, True)
-                print(f"[{addr}] Authorized")
             
             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
-                print(f"[{addr}] Share submitted: {params}")
+                        success, message = self.submit_share(self.current_job, extranonce1, extranonce2, ntime, nonce)
                         
-                # Try to submit block if it's a valid solution
-                try:
-                    if self.current_job and len(params) >= 5:
-                        job_id = params[0]
-                        extranonce2 = params[1]
-                        ntime = params[2]
-                        nonce = params[3]
+                        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)
                             
-                        print(f"[{addr}] Attempting to submit block solution...")
-                        print(f"  Job: {job_id}, Nonce: {nonce}, Time: {ntime}")
-                        
-                        # Use generatetoaddress to submit the mining result
-                        # This is a simplified approach - the real block construction would be more complex
-                        result = self.rpc_call("generatetoaddress", [1, self.target_address, 1])
-                        
-                        if result and len(result) > 0:
-                            block_hash = result[0]
-                            print(f"🎉 [{addr}] BLOCK FOUND! Hash: {block_hash}")
-                            print(f"💰 Block reward sent to: {self.target_address}")
+                            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:
-                            # Accept as share even if not a block
-                            print(f"[{addr}] Share accepted (not a block)")
                             self.send_stratum_response(client, msg_id, True)
                 else:
-                        print(f"[{addr}] Invalid share parameters")
                     self.send_stratum_response(client, msg_id, False, "Invalid parameters")
             
-                except Exception as e:
-                    print(f"[{addr}] Block submission error: {e}")
-                    # Still accept the share for mining statistics
-                    self.send_stratum_response(client, msg_id, True)
-            
             else:
                 print(f"[{addr}] Unknown method: {method}")
                 self.send_stratum_response(client, msg_id, None, "Unknown method")
@@ -212,10 +538,50 @@ class RinCoinStratumProxy:
         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")
-        self.clients[addr] = client
+        if addr not in self.clients:
+            self.clients[addr] = {}
+        self.clients[addr]['socket'] = client
         
         try:
             while self.running:
@@ -241,29 +607,15 @@ class RinCoinStratumProxy:
         """Periodically update mining jobs"""
         while self.running:
             try:
-                # Update job every 30 seconds
-                time.sleep(30)
+                time.sleep(30)  # Update every 30 seconds
+                
+                old_height = self.current_job['height'] if self.current_job else 0
                 
                 if self.get_block_template():
-                    job = self.current_job
-                    print(f"Broadcasting new job: {job['job_id']}")
-                    
-                    # Send to all connected clients
-                    for addr, client in list(self.clients.items()):
-                        try:
-                            self.send_stratum_notification(client, "mining.notify", [
-                                job["job_id"],
-                                job["prevhash"],
-                                job["coinb1"],
-                                job["coinb2"],
-                                job["merkle_branch"],
-                                job["version"],
-                                job["nbits"],
-                                job["ntime"],
-                                job["clean_jobs"]
-                            ])
-                        except Exception as e:
-                            print(f"Failed to send job to {addr}: {e}")
+                    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}")
@@ -274,10 +626,17 @@ class RinCoinStratumProxy:
             # Test RPC connection
             blockchain_info = self.rpc_call("getblockchaininfo")
             if not blockchain_info:
-                print("❌ Failed to connect to RinCoin node!")
+                print("Failed to connect to RinCoin node!")
                 return
             
-            print(f"✅ Connected to RinCoin node (block {blockchain_info.get('blocks', 'unknown')})")
+            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)
@@ -289,13 +648,14 @@ class RinCoinStratumProxy:
             server_socket.bind((self.stratum_host, self.stratum_port))
             server_socket.listen(10)
             
-            print(f"🚀 Stratum proxy listening on {self.stratum_host}:{self.stratum_port}")
-            print("Ready for cpuminer-opt-rin connections...")
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+            print(f"[{timestamp}] 🚀 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(f"💰 Block rewards will be sent to: {self.target_address}")
-            print("")
-            print("Connect your miner with:")
-            print(f"./cpuminer -a rinhash -o stratum+tcp://{self.stratum_host}:{self.stratum_port} -u user -p pass -t 28")
+            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:
@@ -314,24 +674,20 @@ class RinCoinStratumProxy:
                 except Exception as e:
                     print(f"Server error: {e}")
                     
-        except OSError as e:
-            if "Address already in use" in str(e):
-                print(f"❌ Port {self.stratum_port} is already in use!")
-                print("")
-                print("🔍 Check what's using the port:")
-                print(f"sudo netstat -tlnp | grep :{self.stratum_port}")
-                print("")
-                print("🛑 Kill existing process:")
-                print(f"sudo lsof -ti:{self.stratum_port} | xargs sudo kill -9")
-                print("")
-                print("🔄 Or use a different port by editing the script")
-            else:
-                print(f"Failed to start server: {e}")
         except Exception as e:
             print(f"Failed to start server: {e}")
         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()