Create app.py

app.py

@@ -0,0 +1,182 @@
+import socket
+import json
+import struct
+import binascii
+import hashlib
+import time
+import sys
+
+HOST = 'sha256.unmineable.com'
+PORT = 3333
+USERNAME = 'TRX:THBhffMkmQzKPhmWdJznyGv6X4MjhoHWwq.sssj'
+PASSWORD = 'x'
+
+def create_tcp_connection(host, port):
+    try:
+        print(f"🌐 Connecting to {host}:{port} via TCP...")
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(30)
+        sock.connect((host, port))
+        print(f"✅ Connected successfully to {host}:{port}!")
+        return sock
+    except Exception as e:
+        print(f"❌ ERROR: Connection failed - {e}")
+        sys.exit(1)
+
+def receive_message(sock):
+    response = ""
+    try:
+        while True:
+            part = sock.recv(4096).decode('utf-8')
+            if not part:
+                print("❌ ERROR: Connection closed by server.")
+                sys.exit(1)
+            response += part
+            if "\n" in response:
+                break
+    except socket.timeout:
+        print("❌ ERROR: Socket timeout.")
+        sys.exit(1)
+    messages = response.strip().split("\n")
+    parsed_messages = []
+    for msg in messages:
+        try:
+            parsed_messages.append(json.loads(msg))
+        except json.JSONDecodeError:
+            print(f"❌ ERROR: Failed to parse JSON: {msg}")
+    return parsed_messages
+
+def subscribe_sha256(sock):
+    print("🔗 Subscribing...")
+    subscribe_msg = {
+        "id": 1,
+        "method": "mining.subscribe",
+        "params": ["python-miner/1.0"]
+    }
+    sock.sendall((json.dumps(subscribe_msg) + '\n').encode())
+    responses = receive_message(sock)
+    for res in responses:
+        if "result" in res:
+            print("✅ Subscribed!")
+            extranonce1 = res['result'][1]
+            extranonce2_size = res['result'][2]
+            return res, extranonce1, extranonce2_size
+    print("❌ Subscription failed.")
+    sys.exit(1)
+
+def authorize_sha256(sock, username, password):
+    print("🔑 Authorizing...")
+    auth_msg = {
+        "id": 2,
+        "method": "mining.authorize",
+        "params": [username, password]
+    }
+    sock.sendall((json.dumps(auth_msg) + '\n').encode())
+    responses = receive_message(sock)
+    for res in responses:
+        if res.get("result") is True:
+            print("✅ Authorized!")
+            return res
+    print("❌ Authorization failed.")
+    sys.exit(1)
+
+def calculate_merkle_root(coinbase_hash, merkle_branch):
+    current_hash = coinbase_hash
+    for h in merkle_branch:
+        branch_hash = binascii.unhexlify(h)[::-1]
+        combined = current_hash.digest() + branch_hash # Use digest() to get bytes from hash object
+        current_hash = hashlib.sha256(hashlib.sha256(combined).digest()) # Reassign current_hash to hash object
+    return binascii.hexlify(current_hash.digest()[::-1]).decode() # Use digest() and reverse for final output
+
+def mine_sha256(sock, username, extranonce1, extranonce2_size):
+    extranonce2_counter = 0
+    hashes_per_second = 0  # Initialize hashrate variable
+    hash_count = 0         # Counter for hashes in the current interval
+    last_report_time = time.time() # Time of last hashrate report
+    report_interval = 10     # Report hashrate every 10 seconds
+
+    try:
+        while True:
+            messages = receive_message(sock)
+            for data in messages:
+                if data.get("method") == "mining.notify":
+                    params = data["params"]
+                    job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime, _ = params
+                    # Generate extranonce2
+                    extranonce2 = f"{extranonce2_counter:0{extranonce2_size * 2}x}"
+                    extranonce2_counter += 1
+                    # Build coinbase transaction
+                    coinbase_tx = binascii.unhexlify(coinb1) + binascii.unhexlify(extranonce1) + binascii.unhexlify(extranonce2) + binascii.unhexlify(coinb2)
+                    coinbase_hash = hashlib.sha256(hashlib.sha256(coinbase_tx).digest())
+                    # Compute Merkle root
+                    merkle_root_hex = calculate_merkle_root(coinbase_hash, merkle_branch)
+                    merkle_root = binascii.unhexlify(merkle_root_hex)[::-1]
+                    # Construct block header
+                    version_bytes = struct.pack("<I", int(version, 16))
+                    prevhash_bytes = binascii.unhexlify(prevhash)[::-1]
+                    nbits_bytes = binascii.unhexlify(nbits)[::-1]
+                    ntime_bytes = struct.pack("<I", int(ntime, 16))
+                    nonce = 0
+                    target = bits_to_target(nbits)
+                    print(f"🔨 Mining job {job_id}, Target: {target}")
+                    # Start mining
+                    start_time = time.time()
+                    while time.time() - start_time < 10:
+                        nonce_bytes = struct.pack("<I", nonce)
+                        block_header = (
+                            version_bytes +
+                            prevhash_bytes +
+                            merkle_root +
+                            ntime_bytes +
+                            nbits_bytes +
+                            nonce_bytes
+                        )
+                        # Double SHA-256
+                        hash_result = hashlib.sha256(hashlib.sha256(block_header).digest()).hexdigest()
+                        hash_int = int(hash_result, 16)
+                        hash_count += 1  # Increment hash count for hashrate calculation
+                        if hash_int < target:
+                            print(f"🎉 Valid share found! Nonce: {nonce}")
+                            submit_msg = {
+                                "id": 4,
+                                "method": "mining.submit",
+                                "params": [
+                                    username,
+                                    job_id,
+                                    extranonce2,
+                                    ntime,
+                                    f"{nonce:08x}"
+                                ]
+                            }
+                            sock.sendall((json.dumps(submit_msg) + '\n').encode())
+                            print("📤 Submitted share.")
+                            break
+                        nonce += 1
+
+                    current_time = time.time()
+                    if current_time - last_report_time >= report_interval:
+                        elapsed_time = current_time - last_report_time
+                        hashes_per_second = hash_count / elapsed_time
+                        print(f"📊 Hashrate: {hashes_per_second:.2f} H/s") # Display Hashrate
+                        hash_count = 0 # Reset hash counter
+                        last_report_time = current_time # Update last report time
+
+
+    except KeyboardInterrupt:
+        print("⏹️ Mining stopped.")
+    finally:
+        sock.close()
+def bits_to_target(nbits_hex):
+    nbits = int(nbits_hex, 16)
+    exponent = nbits >> 24
+    mantissa = nbits & 0xffffff
+    return mantissa << (8 * (exponent - 3))
+
+def main_sha256():
+    sock = create_tcp_connection(HOST, PORT)
+    sub_res, extranonce1, extranonce2_size = subscribe_sha256(sock)
+    authorize_sha256(sock, USERNAME, PASSWORD)
+    mine_sha256(sock, USERNAME, extranonce1, extranonce2_size)
+
+if __name__ == "__main__":
+    main_sha256()