diff --git a/MINE/rin/README.md b/MINE/rin/README.md
index 97fcf50..d8f6f1d 100644
--- a/MINE/rin/README.md
+++ b/MINE/rin/README.md
@@ -151,6 +151,8 @@ Your Stratum proxy can be enhanced to work as a **full mining pool** that distri
 
 # 2. Miners connect with:
 ./cpuminer -a rinhash -o stratum+tcp://YOUR_IP:3333 -u username.workername -p x
+
+cd /mnt/shared/DEV/repos/d-popov.com/scripts/MINE/rin && python3 stratum_proxy.py --submit-all-blocks
 ```
 
 ### **Pool vs Solo Mining:**
diff --git a/MINE/rin/mining_log.txt b/MINE/rin/mining_log.txt
index 070a8c4..68e4b6d 100644
--- a/MINE/rin/mining_log.txt
+++ b/MINE/rin/mining_log.txt
@@ -1,10 +1,10 @@
 ================================================================================
 RinCoin Mining Log
 ================================================================================
-Started: 2025-09-23 11:51:14
+Started: 2025-09-23 13:26:20
 Target Address: rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q
 Stratum: 0.0.0.0:3334
 RPC: 127.0.0.1:9556
 ================================================================================
 
-[2025-09-23 11:51:14] 💰 Wallet Balance: 25.00000000 RIN
+[2025-09-23 13:26:20] 💰 Wallet Balance: 25.00000000 RIN
diff --git a/MINE/rin/start_mining_with_address.sh b/MINE/rin/start_mining_with_address.sh
deleted file mode 100644
index 5b135ad..0000000
--- a/MINE/rin/start_mining_with_address.sh
+++ /dev/null
@@ -1,81 +0,0 @@
-#!/bin/bash
-
-# Start RinCoin Solo Mining with Custom Address
-# Usage: ./start_mining_with_address.sh [rincoin_address] [threads]
-
-# Default values
-DEFAULT_ADDRESS="rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q"
-DEFAULT_THREADS="28"
-
-# Parse arguments
-RINCOIN_ADDRESS="${1:-$DEFAULT_ADDRESS}"
-THREADS="${2:-$DEFAULT_THREADS}"
-
-echo "=== RinCoin Solo Mining Setup ==="
-echo "RinCoin Address: $RINCOIN_ADDRESS"
-echo "Threads: $THREADS"
-echo ""
-
-# Validate RinCoin address format
-if [[ ! "$RINCOIN_ADDRESS" =~ ^rin1[a-zA-Z0-9]{25,}$ ]]; then
-    echo "❌ Error: Invalid RinCoin address format: $RINCOIN_ADDRESS"
-    echo "RinCoin addresses should start with 'rin1' and be ~30 characters long"
-    exit 1
-fi
-
-# Check if RinCoin node is running
-if ! sudo docker ps | grep -q "rincoin-node"; then
-    echo "❌ Error: rincoin-node container is not running!"
-    echo "Please start it first: sudo docker start rincoin-node"
-    exit 1
-fi
-
-echo "✅ RinCoin node is running"
-
-# Check dependencies
-if ! command -v python3 &> /dev/null; then
-    echo "❌ Error: python3 is not installed!"
-    exit 1
-fi
-
-python3 -c "import requests" 2>/dev/null || {
-    echo "Installing python3-requests..."
-    sudo apt-get update && sudo apt-get install -y python3-requests
-}
-
-echo "✅ Dependencies ready"
-echo ""
-
-# Create temporary proxy script with custom address
-TEMP_PROXY="/tmp/rincoin_proxy_${RANDOM}.py"
-sed "s/target_address='[^']*'/target_address='$RINCOIN_ADDRESS'/" MINE/rin/stratum_proxy.py > "$TEMP_PROXY"
-
-echo "🚀 Starting Stratum Proxy with address: $RINCOIN_ADDRESS"
-echo ""
-
-# Start proxy in background
-python3 "$TEMP_PROXY" &
-PROXY_PID=$!
-
-# Wait for proxy to start
-sleep 3
-
-echo "📋 Mining Commands:"
-echo ""
-echo "1. For Docker container mining:"
-echo "sudo docker exec -it amd-strix-halo-llama-rocm bash -c \"/mnt/dl/rinhash/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://172.17.0.1:3333 -u user -p pass -t $THREADS\""
-echo ""
-echo "2. For native mining (if cpuminer is installed locally):"
-echo "/home/db/Downloads/rinhash/cpuminer-opt-rin/cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u user -p pass -t $THREADS"
-echo ""
-echo "💡 Tips:"
-echo "- Use 172.17.0.1:3333 from Docker containers"
-echo "- Use 127.0.0.1:3333 from host system"
-echo "- All block rewards will go to: $RINCOIN_ADDRESS"
-echo ""
-echo "Press Ctrl+C to stop the proxy and mining"
-
-# Wait for user to stop
-trap "echo ''; echo 'Stopping proxy...'; kill $PROXY_PID 2>/dev/null; rm -f '$TEMP_PROXY'; exit 0" INT
-
-wait $PROXY_PID
diff --git a/MINE/rin/stratum_proxy copy.py b/MINE/rin/stratum_proxy copy.py
deleted file mode 100644
index 5b43c29..0000000
--- a/MINE/rin/stratum_proxy copy.py	
+++ /dev/null
@@ -1,550 +0,0 @@
-#!/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()
\ No newline at end of file
diff --git a/MINE/rin/stratum_proxy.py b/MINE/rin/stratum_proxy.py
index 64ebb95..aff5ee6 100644
--- a/MINE/rin/stratum_proxy.py
+++ b/MINE/rin/stratum_proxy.py
@@ -18,7 +18,8 @@ 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'):
+                 target_address='rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q',
+                 submit_all_blocks=False):
         
         self.stratum_host = stratum_host
         self.stratum_port = stratum_port
@@ -27,6 +28,7 @@ class RinCoinStratumProxy:
         self.rpc_user = rpc_user
         self.rpc_password = rpc_password
         self.target_address = target_address
+        self.submit_all_blocks = submit_all_blocks  # If True, submit even invalid blocks for testing
         
         self.clients = {}
         self.job_counter = 0
@@ -406,8 +408,8 @@ class RinCoinStratumProxy:
                 diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
                 optimal_difficulty = (estimated_hashrate * diff1_target) / (target_shares_per_second * (2**256))
                 
-                # More practical approach: start with network difficulty scaled down
-                optimal_difficulty = max(network_diff * 0.001, 0.0001)  # 0.1% of network, min 0.0001
+                # More practical approach: start with network difficulty scaled way down for solo mining
+                optimal_difficulty = max(network_diff * 0.00001, 0.000001)  # 0.001% of network, min 0.000001
                 
                 print(f"   📊 New client {addr}: Network diff {network_diff:.6f}, starting with {optimal_difficulty:.6f}")
                 return optimal_difficulty
@@ -442,9 +444,9 @@ class RinCoinStratumProxy:
                 elif difficulty_multiplier < (1.0 / max_change):
                     new_difficulty = current_difficulty / max_change
                 
-                # Bounds checking
-                min_difficulty = network_diff * 0.00001  # 0.001% of network minimum
-                max_difficulty = network_diff * 0.1      # 10% of network maximum
+                # Bounds checking for solo mining
+                min_difficulty = max(network_diff * 0.000001, 0.000001)  # 0.0001% of network minimum
+                max_difficulty = network_diff * 0.01      # 1% of network maximum
                 new_difficulty = max(min_difficulty, min(max_difficulty, new_difficulty))
                 
                 print(f"   📊 {addr}: {share_count} shares in {mining_duration:.0f}s ({actual_share_rate:.4f}/s), adjusting {current_difficulty:.6f} → {new_difficulty:.6f}")
@@ -582,9 +584,12 @@ class RinCoinStratumProxy:
                 self.stats['total_shares'] += 1
                 self.stats['rejected_shares'] += 1
 
-            # Check if it's also a valid network block
-            if meets_network_target:
-                print(f"   🎉 BLOCK FOUND! Hash: {block_hash_hex}")
+            # Check if it's also a valid network block OR if we should submit all blocks for testing
+            if meets_network_target or self.submit_all_blocks:
+                if meets_network_target:
+                    print(f"   🎉 VALID BLOCK FOUND! Hash: {block_hash_hex}")
+                else:
+                    print(f"   🧪 TEST BLOCK SUBMISSION! Hash: {block_hash_hex} (submit_all_blocks=True)")
                 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})")
@@ -1132,5 +1137,13 @@ class RinCoinStratumProxy:
             print("Server stopped")
 
 if __name__ == "__main__":
-    proxy = RinCoinStratumProxy()
+    import sys
+    
+    # Check for submit_all_blocks parameter
+    submit_all = False
+    if len(sys.argv) > 1 and sys.argv[1] == "--submit-all-blocks":
+        submit_all = True
+        print("🧪 TEST MODE: Will submit ALL blocks for validation (submit_all_blocks=True)")
+    
+    proxy = RinCoinStratumProxy(submit_all_blocks=submit_all)
     proxy.start()
diff --git a/MINE/rin/stratum_proxy_debug.py b/MINE/rin/stratum_proxy_debug.py
deleted file mode 100644
index e9e4bd6..0000000
--- a/MINE/rin/stratum_proxy_debug.py
+++ /dev/null
@@ -1,705 +0,0 @@
-#!/usr/bin/env python3
-"""
-RinCoin Stratum Proxy Server - FIXED VERSION
-Fixed block hash calculation and validation issues
-"""
-
-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
-        
-        # Logging setup
-        self.log_file = "mining_log.txt"
-        self.init_log_file()
-        
-        print(f"RinCoin Stratum Proxy Server")
-        print(f"Stratum: {stratum_host}:{stratum_port}")
-        print(f"RPC: {rpc_host}:{rpc_port}")
-        print(f"Target: {target_address}")
-        
-    def init_log_file(self):
-        """Initialize mining log file with header"""
-        try:
-            with open(self.log_file, 'w') as f:
-                f.write("=" * 80 + "\n")
-                f.write("RinCoin Mining Log\n")
-                f.write("=" * 80 + "\n")
-                f.write(f"Started: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
-                f.write(f"Target Address: {self.target_address}\n")
-                f.write(f"Stratum: {self.stratum_host}:{self.stratum_port}\n")
-                f.write(f"RPC: {self.rpc_host}:{self.rpc_port}\n")
-                f.write("=" * 80 + "\n\n")
-        except Exception as e:
-            print(f"Failed to initialize log file: {e}")
-    
-    def log_hash_found(self, hash_hex, difficulty, height, reward, nonce, ntime):
-        """Log found hash to file"""
-        try:
-            timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
-            with open(self.log_file, 'a') as f:
-                f.write(f"[{timestamp}] 🎉 HASH FOUND!\n")
-                f.write(f"   Hash: {hash_hex}\n")
-                f.write(f"   Difficulty: {difficulty:.6f}\n")
-                f.write(f"   Height: {height}\n")
-                f.write(f"   Reward: {reward:.8f} RIN\n")
-                f.write(f"   Nonce: {nonce}\n")
-                f.write(f"   Time: {ntime}\n")
-                f.write("-" * 40 + "\n")
-        except Exception as e:
-            print(f"Failed to log hash: {e}")
-    
-    def log_wallet_balance(self):
-        """Log current wallet balance to file"""
-        try:
-            balance = self.rpc_call("getbalance")
-            if balance is not None:
-                timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
-                with open(self.log_file, 'a') as f:
-                    f.write(f"[{timestamp}] 💰 Wallet Balance: {balance:.8f} RIN\n")
-        except Exception as e:
-            print(f"Failed to log wallet balance: {e}")
-    
-    def rpc_call(self, method, params=[]):
-        """Make RPC call to RinCoin node"""
-        try:
-            url = f"http://{self.rpc_host}:{self.rpc_port}/"
-            headers = {'content-type': 'text/plain'}
-            auth = HTTPBasicAuth(self.rpc_user, self.rpc_password)
-            
-            payload = {
-                "jsonrpc": "1.0",
-                "id": "stratum_proxy",
-                "method": method,
-                "params": params
-            }
-            
-            response = requests.post(url, json=payload, headers=headers, auth=auth, timeout=30)
-            
-            if response.status_code == 200:
-                result = response.json()
-                if 'error' in result and result['error'] is not None:
-                    print(f"RPC Error: {result['error']}")
-                    return None
-                return result.get('result')
-            else:
-                print(f"HTTP Error: {response.status_code}")
-                return None
-                
-        except Exception as e:
-            print(f"RPC Call Error: {e}")
-            return None
-
-    def encode_varint(self, n):
-        """Encode integer as Bitcoin-style varint"""
-        if n < 0xfd:
-            return bytes([n])
-        elif n <= 0xffff:
-            return b"\xfd" + struct.pack('<H', n)
-        elif n <= 0xffffffff:
-            return b"\xfe" + struct.pack('<I', n)
-        else:
-            return b"\xff" + struct.pack('<Q', n)
-
-    def decode_bech32_address(self, address):
-        """Decode RinCoin bech32 address to script"""
-        try:
-            if not address or not address.startswith('rin1'):
-                raise ValueError("Not a RinCoin bech32 address")
-            
-            result = self.rpc_call("validateaddress", [address])
-            if not result or not result.get('isvalid'):
-                raise ValueError("Address not valid per node")
-            script_hex = result.get('scriptPubKey')
-            if not script_hex:
-                raise ValueError("Node did not return scriptPubKey")
-            return bytes.fromhex(script_hex)
-        except Exception as e:
-            print(f"Address decode error: {e}")
-            return None
-
-    def build_coinbase_transaction(self, template, extranonce1, extranonce2):
-        """Build coinbase transaction variants (with and without witness) for default address"""
-        return self.build_coinbase_transaction_for_address(template, extranonce1, extranonce2, self.target_address)
-    
-    def build_coinbase_transaction_for_address(self, template, extranonce1, extranonce2, target_address):
-        """Build coinbase transaction variants (with and without witness)"""
-        try:
-            has_witness_commitment = template.get('default_witness_commitment') is not None
-
-            # Common parts
-            value = template.get('coinbasevalue', 0)
-            script_pubkey = self.decode_bech32_address(target_address)
-            if not script_pubkey:
-                return None, None
-            witness_commitment = template.get('default_witness_commitment')
-
-            # ScriptSig (block height minimal push + tag + extranonces)
-            height = template.get('height', 0)
-            height_bytes = struct.pack('<I', height)
-            height_compact = bytes([len(height_bytes.rstrip(b'\x00'))]) + height_bytes.rstrip(b'\x00')
-            scriptsig = height_compact + b'/RinCoin/' + extranonce1.encode() + extranonce2.encode()
-
-            # Helper to build outputs blob
-            def build_outputs_blob() -> bytes:
-                outputs_blob = b''
-                outputs_list = []
-                # Main output
-                outputs_list.append(struct.pack('<Q', value) + self.encode_varint(len(script_pubkey)) + script_pubkey)
-                # Witness commitment OP_RETURN output if present
-                if witness_commitment:
-                    commit_script = bytes.fromhex(witness_commitment)
-                    outputs_list.append(struct.pack('<Q', 0) + self.encode_varint(len(commit_script)) + commit_script)
-                outputs_blob += self.encode_varint(len(outputs_list))
-                for out in outputs_list:
-                    outputs_blob += out
-                return outputs_blob
-
-            # Build non-witness serialization (txid serialization)
-            cb_nowit = b''
-            cb_nowit += struct.pack('<I', 1)               # version
-            cb_nowit += b'\x01'                            # input count
-            cb_nowit += b'\x00' * 32                       # prevout hash
-            cb_nowit += b'\xff\xff\xff\xff'             # prevout index
-            cb_nowit += self.encode_varint(len(scriptsig)) + scriptsig
-            cb_nowit += b'\xff\xff\xff\xff'             # sequence
-            cb_nowit += build_outputs_blob()                # outputs
-            cb_nowit += struct.pack('<I', 0)               # locktime
-
-            # Build with-witness serialization (block serialization)
-            if has_witness_commitment:
-                cb_wit = b''
-                cb_wit += struct.pack('<I', 1)             # version
-                cb_wit += b'\x00\x01'                     # segwit marker+flag
-                cb_wit += b'\x01'                          # input count
-                cb_wit += b'\x00' * 32                     # prevout hash
-                cb_wit += b'\xff\xff\xff\xff'           # prevout index
-                cb_wit += self.encode_varint(len(scriptsig)) + scriptsig
-                cb_wit += b'\xff\xff\xff\xff'           # sequence
-                cb_wit += build_outputs_blob()              # outputs
-                # Witness stack for coinbase (32-byte reserved value)
-                cb_wit += b'\x01'                          # witness stack count
-                cb_wit += b'\x20'                          # item length
-                cb_wit += b'\x00' * 32                     # reserved value
-                cb_wit += struct.pack('<I', 0)             # locktime
-            else:
-                cb_wit = cb_nowit
-
-            return cb_wit, cb_nowit
-
-        except Exception as e:
-            print(f"Coinbase construction error: {e}")
-            return None, None
-
-    def calculate_merkle_root(self, coinbase_txid, transactions):
-        """Calculate merkle root with coinbase at index 0"""
-        try:
-            # Start with all transaction hashes (coinbase + others)
-            hashes = [coinbase_txid]
-            for tx in transactions:
-                hashes.append(bytes.fromhex(tx['hash'])[::-1])  # Reverse for little-endian
-            
-            # Build merkle tree
-            while len(hashes) > 1:
-                if len(hashes) % 2 == 1:
-                    hashes.append(hashes[-1])  # Duplicate last hash if odd
-                
-                next_level = []
-                for i in range(0, len(hashes), 2):
-                    combined = hashes[i] + hashes[i + 1]
-                    next_level.append(hashlib.sha256(hashlib.sha256(combined).digest()).digest())
-                
-                hashes = next_level
-            
-            return hashes[0] if hashes else b'\x00' * 32
-            
-        except Exception as e:
-            print(f"Merkle root calculation error: {e}")
-            return b'\x00' * 32
-
-    def bits_to_target(self, bits_hex):
-        """Convert bits to target - FIXED VERSION"""
-        try:
-            bits = int(bits_hex, 16)
-            exponent = bits >> 24
-            mantissa = bits & 0xffffff
-            
-            # Bitcoin target calculation
-            if exponent <= 3:
-                target = mantissa >> (8 * (3 - exponent))
-            else:
-                target = mantissa << (8 * (exponent - 3))
-            
-            return f"{target:064x}"
-        except Exception as e:
-            print(f"Bits to target error: {e}")
-            return "0000ffff00000000000000000000000000000000000000000000000000000000"
-
-    def get_block_template(self):
-        """Get new block template and create Stratum job"""
-        try:
-            template = self.rpc_call("getblocktemplate", [{"rules": ["segwit", "mweb"]}])
-            if not template:
-                return None
-                
-            self.job_counter += 1
-            
-            job = {
-                "job_id": f"job_{self.job_counter:08x}",
-                "template": template,
-                "prevhash": template.get("previousblockhash", "0" * 64),
-                "version": template.get('version', 1),
-                "bits": template.get('bits', '1d00ffff'),
-                "ntime": f"{int(time.time()):08x}",
-                "target": self.bits_to_target(template.get('bits', '1d00ffff')),
-                "height": template.get('height', 0),
-                "coinbasevalue": template.get('coinbasevalue', 0),
-                "transactions": template.get('transactions', [])
-            }
-            
-            self.current_job = job
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-            network_difficulty = self.calculate_network_difficulty(job['target'])
-            print(f"[{timestamp}] 🆕 NEW JOB: {job['job_id']} | Height: {job['height']} | Reward: {job['coinbasevalue']/100000000:.2f} RIN")
-            print(f"   🎯 Network Difficulty: {network_difficulty:.6f} | Bits: {job['bits']}")
-            print(f"   📍 Target: {job['target'][:16]}... | Transactions: {len(job['transactions'])}")
-            return job
-            
-        except Exception as e:
-            print(f"Get block template error: {e}")
-            return None
-
-    def calculate_share_difficulty(self, hash_hex, target_hex):
-        """Calculate actual share difficulty from hash - FIXED"""
-        try:
-            hash_int = int(hash_hex, 16)
-            
-            if hash_int == 0:
-                return float('inf')  # Perfect hash
-                
-            # Bitcoin-style difficulty calculation using difficulty 1 target
-            # Difficulty 1 target for mainnet
-            diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
-            
-            # Share difficulty = how much harder this hash was compared to diff 1
-            difficulty = diff1_target / hash_int
-            
-            return difficulty
-        except Exception as e:
-            print(f"Difficulty calculation error: {e}")
-            return 0.0
-
-    def calculate_network_difficulty(self, target_hex):
-        """Calculate network difficulty from target - FIXED"""
-        try:
-            target_int = int(target_hex, 16)
-            
-            # Bitcoin difficulty 1.0 target
-            diff1_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
-            
-            # Network difficulty = how much harder than difficulty 1.0
-            network_difficulty = diff1_target / target_int
-            
-            return network_difficulty
-        except Exception as e:
-            print(f"Network difficulty calculation error: {e}")
-            return 1.0
-
-    def submit_share(self, job, extranonce1, extranonce2, ntime, nonce, target_address=None):
-        """Validate share and submit block if valid - FIXED VERSION"""
-        try:
-            # Use provided address or default
-            address = target_address or self.target_address
-            
-            # Build coinbase (with and without witness)
-            coinbase_wit, coinbase_nowit = self.build_coinbase_transaction_for_address(
-                job['template'], extranonce1, extranonce2, address)
-            if not coinbase_wit or not coinbase_nowit:
-                return False, "Coinbase construction failed"
-            
-            # Calculate coinbase txid (non-witness serialization)
-            coinbase_txid = hashlib.sha256(hashlib.sha256(coinbase_nowit).digest()).digest()[::-1]
-            
-            # Calculate merkle root
-            merkle_root = self.calculate_merkle_root(coinbase_txid, job['transactions'])
-            
-            # Build block header - FIXED ENDIANNESS
-            header = b''
-            header += struct.pack('<I', job['version'])                    # Version (little-endian)
-            header += bytes.fromhex(job['prevhash'])[::-1]                # Previous block hash (big-endian in block)
-            header += merkle_root                                         # Merkle root (already in correct endian)
-            header += struct.pack('<I', int(ntime, 16))                  # Timestamp (little-endian)
-            header += bytes.fromhex(job['bits'])[::-1]                   # Bits (big-endian in block)
-            header += struct.pack('<I', int(nonce, 16))                  # Nonce (little-endian)
-            
-            # Calculate block hash - FIXED DOUBLE SHA256
-            block_hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
-            block_hash_hex = block_hash[::-1].hex()  # Reverse for display/comparison
-            
-            # Calculate real difficulties
-            share_difficulty = self.calculate_share_difficulty(block_hash_hex, job['target'])
-            network_difficulty = self.calculate_network_difficulty(job['target'])
-            
-            # Check if hash meets target - FIXED COMPARISON
-            hash_int = int(block_hash_hex, 16)
-            target_int = int(job['target'], 16)
-            meets_target = hash_int <= target_int  # FIXED: less than or equal
-            
-            # Enhanced logging
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-            difficulty_percentage = (share_difficulty / network_difficulty) * 100 if network_difficulty > 0 else 0
-            
-            # Progress indicator based on percentage
-            if meets_target:
-                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}")
-            print(f"   🔍 Hash vs Target: {hash_int} {'<=' if meets_target else '>'} {target_int}")
-            
-            if not meets_target:
-                # Share doesn't meet target - reject but still useful for debugging
-                print(f"   ❌ Share rejected (hash > target)")
-                return False, "Share too high"
-            
-            # Valid block! Build full block and submit
-            print(f"   🎉 BLOCK FOUND! Hash: {block_hash_hex}")
-            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})")
-            
-            # Log the found hash
-            reward_rin = job['coinbasevalue'] / 100000000
-            self.log_hash_found(block_hash_hex, share_difficulty, job['height'], reward_rin, nonce, ntime)
-            
-            # Build complete block
-            block = header
-            
-            # 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!")
-                # Log wallet balance after successful block submission
-                self.log_wallet_balance()
-                return True, "Block found and submitted"
-            else:
-                print(f"   ❌ Block rejected: {result}")
-                print(f"   🔍 Debug: Block size {len(block_hex)//2} bytes, {len(job['transactions'])} transactions")
-                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 - MUCH LOWER for testing
-                self.send_stratum_notification(client, "mining.set_difficulty", [0.00001])
-                
-                # Send initial job
-                if self.current_job:
-                    self.send_job_to_client(client, self.current_job)
-                else:
-                    if self.get_block_template():
-                        self.send_job_to_client(client, self.current_job)
-            
-            elif method == "mining.authorize":
-                username = params[0] if params else "anonymous"
-                self.clients[addr]['username'] = username
-                self.send_stratum_response(client, msg_id, True)
-                timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-                print(f"[{timestamp}] 🔐 [{addr}] Authorized as {username}")
-            
-            elif method == "mining.extranonce.subscribe":
-                self.send_stratum_response(client, msg_id, True)
-            
-            elif method == "mining.submit":
-                if len(params) >= 5:
-                    username = params[0]
-                    job_id = params[1]
-                    extranonce2 = params[2]
-                    ntime = params[3]
-                    nonce = params[4]
-                    
-                    print(f"[{addr}] Submit: {username} | job={job_id} | nonce={nonce}")
-                    
-                    # Always validate against current job
-                    if self.current_job:
-                        extranonce1 = self.clients[addr].get('extranonce1', '00000000')
-                        
-                        # Submit share
-                        success, message = self.submit_share(self.current_job, extranonce1, extranonce2, ntime, nonce)
-                        
-                        # Always accept shares for debugging, even if they don't meet target
-                        self.send_stratum_response(client, msg_id, True)
-                        
-                        if success and "Block found" in message:
-                            # Get new job after block found
-                            threading.Thread(target=self.update_job_after_block, daemon=True).start()
-                    else:
-                        self.send_stratum_response(client, msg_id, True)
-                else:
-                    self.send_stratum_response(client, msg_id, False, "Invalid parameters")
-            
-            else:
-                print(f"[{addr}] Unknown method: {method}")
-                self.send_stratum_response(client, msg_id, None, "Unknown method")
-                
-        except json.JSONDecodeError:
-            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 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"""
-        balance_log_counter = 0
-        while self.running:
-            try:
-                time.sleep(30)  # Update every 30 seconds
-                
-                old_height = self.current_job['height'] if self.current_job else 0
-                
-                if self.get_block_template():
-                    new_height = self.current_job['height']
-                    if new_height > old_height:
-                        print(f"New block detected! Broadcasting new job...")
-                        self.broadcast_new_job()
-                
-                # Log wallet balance every 10 minutes (20 cycles of 30 seconds)
-                balance_log_counter += 1
-                if balance_log_counter >= 20:
-                    self.log_wallet_balance()
-                    balance_log_counter = 0
-                        
-            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')}")
-            
-            # Log initial wallet balance
-            self.log_wallet_balance()
-            
-            # Get initial block template
-            if not self.get_block_template():
-                print("Failed to get initial block template!")
-                return
-            
-            # Start job updater thread
-            job_thread = threading.Thread(target=self.job_updater, daemon=True)
-            job_thread.start()
-            
-            # Start Stratum server
-            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            server_socket.bind((self.stratum_host, self.stratum_port))
-            server_socket.listen(10)
-            
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-            print(f"[{timestamp}] 🚀 Mining Stratum proxy ready!")
-            print(f"   📡 Listening on {self.stratum_host}:{self.stratum_port}")
-            print(f"   💰 Mining to: {self.target_address}")
-            print(f"   📊 Current job: {self.current_job['job_id'] if self.current_job else 'None'}")
-            print(f"   📝 Mining log: {self.log_file}")
-            print("")
-            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()
diff --git a/MINE/rin/stratum_proxy_explanation.sh b/MINE/rin/stratum_proxy_explanation.sh
deleted file mode 100644
index 3f9ec4c..0000000
--- a/MINE/rin/stratum_proxy_explanation.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/bin/bash
-
-# RinCoin Stratum Proxy for cpuminer-opt-rin
-# Bridges cpuminer's Stratum protocol to RinCoin's RPC mining
-
-echo "=== RinCoin Stratum Proxy ==="
-echo "This script creates a bridge between cpuminer and RinCoin node"
-echo ""
-
-# Configuration
-RPC_HOST="127.0.0.1"
-RPC_PORT="9556"
-RPC_USER="rinrpc"
-RPC_PASS="745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90"
-STRATUM_PORT="3333"
-TARGET_ADDRESS="rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q"
-
-# Function to call RPC
-call_rpc() {
-    local method="$1"
-    local params="$2"
-    
-    curl -s --user "$RPC_USER:$RPC_PASS" \
-        -H 'content-type: text/plain' \
-        --data "{\"jsonrpc\":\"1.0\",\"id\":\"curl\",\"method\":\"$method\",\"params\":$params}" \
-        "http://$RPC_HOST:$RPC_PORT/"
-}
-
-echo "⚠️  IMPORTANT: This is a simplified proxy demonstration."
-echo "For production use, you would need a full Stratum server implementation."
-echo ""
-
-echo "Current RinCoin mining options:"
-echo "1. Built-in Core Mining (Recommended for solo):"
-echo "   bash MINE/rin/solo_mining_core.sh -t 28"
-echo ""
-echo "2. Pool Mining (Recommended for consistent rewards):"
-echo "   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 28\""
-echo ""
-echo "3. Direct RPC Mining (Advanced - requires custom miner):"
-echo "   Use getblocktemplate RPC calls directly"
-echo ""
-
-echo "❌ cpuminer-opt-rin cannot directly mine to RinCoin node because:"
-echo "   - cpuminer uses Stratum protocol"
-echo "   - RinCoin node uses RPC protocol"
-echo "   - No built-in protocol conversion"
-echo ""
-
-echo "✅ Recommended approach:"
-echo "   Use the built-in core mining script for solo mining"
-echo "   Use pool mining for consistent rewards"
diff --git a/MINE/rin/test_address_validation.sh b/MINE/rin/test_address_validation.sh
deleted file mode 100644
index 34ebd9c..0000000
--- a/MINE/rin/test_address_validation.sh
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/bin/bash
-
-# Test RinCoin Address Validation and Behavior
-
-echo "=== RinCoin Address Validation Test ==="
-echo ""
-
-# Kill any existing processes
-./MINE/rin/kill_stratum_proxy.sh
-
-echo "🧪 Testing different address types with RinCoin node:"
-echo ""
-
-echo "1️⃣ Valid RinCoin address:"
-curl -s -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 \
-  -H 'content-type: text/plain' \
-  --data '{"jsonrpc":"1.0","id":"curl","method":"validateaddress","params":["rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q"]}' \
-  http://127.0.0.1:9556/ | jq '.result'
-
-echo ""
-echo "2️⃣ Invalid BTC address:"
-curl -s -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 \
-  -H 'content-type: text/plain' \
-  --data '{"jsonrpc":"1.0","id":"curl","method":"validateaddress","params":["bc1qjn4m6rmrveuxhk02a5qhe4r6kdcsvvt3vhdn9j"]}' \
-  http://127.0.0.1:9556/ | jq '.result'
-
-echo ""
-echo "3️⃣ Invalid Litecoin address:"
-curl -s -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 \
-  -H 'content-type: text/plain' \
-  --data '{"jsonrpc":"1.0","id":"curl","method":"validateaddress","params":["LQnYyekHhQ7nMUTGJ1ZnYz8s9QJ2mKLM9P"]}' \
-  http://127.0.0.1:9556/ | jq '.result'
-
-echo ""
-echo "4️⃣ Test generatetoaddress with invalid address:"
-curl -s -u rinrpc:745ce784d5d537fc06105a1b935b7657903cfc71a5fb3b90 \
-  -H 'content-type: text/plain' \
-  --data '{"jsonrpc":"1.0","id":"curl","method":"generatetoaddress","params":[1, "bc1qjn4m6rmrveuxhk02a5qhe4r6kdcsvvt3vhdn9j", 1]}' \
-  http://127.0.0.1:9556/ | jq '.error'
-
-echo ""
-echo "🚀 Starting mining pool to test address validation..."
-./MINE/rin/start_mining_pool.sh &
-POOL_PID=$!
-
-echo ""
-echo "⏳ Waiting for pool to start..."
-sleep 5
-
-echo ""
-echo "🧪 Testing pool with different address types:"
-echo ""
-
-echo "Test 1: Valid RinCoin address"
-echo "Expected: ✅ Accept connection"
-timeout 5s ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q -p x -t 1
-
-echo ""
-echo "Test 2: Invalid BTC address"
-echo "Expected: ❌ Reject connection"
-timeout 5s ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u bc1qjn4m6rmrveuxhk02a5qhe4r6kdcsvvt3vhdn9j -p x -t 1
-
-echo ""
-echo "Test 3: Traditional username (no address)"
-echo "Expected: ⚠️ Accept but warn no address"
-timeout 5s ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u user.worker -p x -t 1
-
-echo ""
-echo "🧹 Cleaning up..."
-kill $POOL_PID 2>/dev/null
-./MINE/rin/kill_stratum_proxy.sh
-
-echo ""
-echo "📋 Summary:"
-echo "✅ Valid RinCoin addresses (rin1q...) - Accepted"
-echo "❌ Invalid addresses (bc1q..., LQnY...) - Rejected"
-echo "⚠️ Traditional usernames - Accepted but no rewards"
-echo "💰 Block rewards always go to pool address, then distributed"
diff --git a/MINE/rin/test_pool_connections.sh b/MINE/rin/test_pool_connections.sh
deleted file mode 100644
index 8d22208..0000000
--- a/MINE/rin/test_pool_connections.sh
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/bin/bash
-
-# Test different mining pool connection methods
-
-echo "=== Testing Mining Pool Connection Methods ==="
-echo ""
-
-# Kill any existing processes
-./MINE/rin/kill_stratum_proxy.sh
-
-echo "🚀 Starting mining pool..."
-./MINE/rin/start_mining_pool.sh &
-POOL_PID=$!
-
-echo ""
-echo "⏳ Waiting for pool to start..."
-sleep 5
-
-echo ""
-echo "🧪 Testing different connection methods:"
-echo ""
-
-echo "1️⃣ Test 1: Address as username"
-echo "Command: ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q -p x -t 2"
-echo "Expected: Pool should recognize this as a RinCoin address"
-echo ""
-
-echo "2️⃣ Test 2: Address.workername format"
-echo "Command: ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q.worker1 -p x -t 2"
-echo "Expected: Pool should recognize address and worker separately"
-echo ""
-
-echo "3️⃣ Test 3: Traditional username"
-echo "Command: ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u user.worker -p x -t 2"
-echo "Expected: Pool should use default pool address for rewards"
-echo ""
-
-echo "📊 Pool Status:"
-echo "Web Dashboard: http://127.0.0.1:8080"
-echo "Pool Address: rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q"
-echo ""
-
-echo "Press Enter to run test 1..."
-read
-
-echo "Running Test 1..."
-timeout 10s ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q -p x -t 2
-
-echo ""
-echo "Press Enter to run test 2..."
-read
-
-echo "Running Test 2..."
-timeout 10s ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u rin1qahvvv9d5f3443wtckeqavwp9950wacxfmwv20q.worker1 -p x -t 2
-
-echo ""
-echo "Press Enter to run test 3..."
-read
-
-echo "Running Test 3..."
-timeout 10s ./cpuminer -a rinhash -o stratum+tcp://127.0.0.1:3333 -u user.worker -p x -t 2
-
-echo ""
-echo "🧹 Cleaning up..."
-kill $POOL_PID 2>/dev/null
-./MINE/rin/kill_stratum_proxy.sh
-
-echo ""
-echo "✅ Test complete! Check the pool logs above to see how each connection was handled."
diff --git a/MINE/rin/view_mining_log.sh b/MINE/rin/view_mining_log.sh
deleted file mode 100644
index de4ec60..0000000
--- a/MINE/rin/view_mining_log.sh
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/bin/bash
-
-# View RinCoin Mining Log
-# Shows the latest mining activity and wallet balance
-
-LOG_FILE="mining_log.txt"
-
-if [ ! -f "$LOG_FILE" ]; then
-    echo "❌ Mining log file '$LOG_FILE' not found!"
-    echo "Make sure the stratum proxy has been started at least once."
-    exit 1
-fi
-
-echo "=== RinCoin Mining Log Viewer ==="
-echo ""
-
-# Show last 20 lines of the log
-echo "📊 Recent Activity (last 20 entries):"
-echo "----------------------------------------"
-tail -20 "$LOG_FILE"
-
-echo ""
-echo "💰 Current Wallet Balance:"
-echo "----------------------------------------"
-grep "Wallet Balance:" "$LOG_FILE" | tail -1 || echo "No balance logged yet"
-
-echo ""
-echo "🎉 Total Blocks Found:"
-echo "----------------------------------------"
-grep -c "HASH FOUND!" "$LOG_FILE" || echo "0"
-
-echo ""
-echo "📈 Total Mining Time:"
-echo "----------------------------------------"
-if grep -q "Started:" "$LOG_FILE"; then
-    START_TIME=$(grep "Started:" "$LOG_FILE" | head -1 | cut -d' ' -f2-3)
-    echo "Started: $START_TIME"
-    echo "Current: $(date '+%Y-%m-%d %H:%M:%S')"
-else
-    echo "Start time not available"
-fi
-
-echo ""
-echo "📝 Full log available at: $LOG_FILE"
-echo "🔄 To watch live updates: tail -f $LOG_FILE"