Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 154. (Read 231001 times)

import random
puzzle = 18
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
seed = b'\x97h6\xd9\x7f\xcbh\xc4'
random.seed(seed)
dec = random.randint(lower_range_limit, upper_range_limit)
print(f"{dec}, {seed}")

import sys
import os
import time
import random
import binascii
import base58
import hashlib
import ecdsa
from multiprocessing import cpu_count
import threading

# Set the Hash 160 address you want to check for
target_hex = "20d45a6a762535700ce9e0b216e31994335db8a5"
add_set = bytes.fromhex(target_hex)

puzzle = 66
min_number = 2 ** (puzzle - 1)
max_number = (2 ** puzzle) - 1

# Clear the terminal screen
if os.name == 'nt':
    os.system('cls')
else:
    os.system('clear')

# Print information about the program
t = time.ctime()
sys.stdout.write("\033[01;33m")
sys.stdout.write("\033[?25l")
sys.stdout.write(f"[+] [Bytea HASH160 Search] {t}" + "\n")
sys.stdout.write(f"[+] [Puzzle]: {puzzle}" + "\n")
sys.stdout.write(f"[+] [Lower range limit]: {min_number}" + "\n")
sys.stdout.write(f"[+] [Upper range limit]: {max_number}" + "\n")
sys.stdout.flush()

# Define the check_private_key function
def check_private_key(add_set):
    while True:
        constant_prefix = b''  #Can be b'\xbc\x9b' or any random_bytes
        prefix_length = len(constant_prefix)
        length = 8
        ending_length = length - prefix_length
        ending_bytes = os.urandom(ending_length)
        random_bytes = constant_prefix + ending_bytes
        random.seed(random_bytes)
        dec = random.randint(min_number, max_number)
        dec_bytes = dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        private_key_bytes = b'\x00' * 32
        private_key_bytes = private_key_bytes[:-len(dec_bytes)] + dec_bytes
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        compressed_public_key = signing_key.get_verifying_key().to_string("compressed")
        sha256_hash = hashlib.sha256(compressed_public_key).digest()
        HASH160 = hashlib.new('ripemd160', sha256_hash).digest()
        extended_private_key = b'\x80' + private_key_bytes + b'\x01'
        extended_ripe160_hash = b'\x00' + HASH160
        checksum = hashlib.sha256(hashlib.sha256(extended_private_key).digest()).digest()[:4]
        checksum_ripe160 = hashlib.sha256(hashlib.sha256(extended_ripe160_hash).digest()).digest()[:4]
        private_key_with_checksum = extended_private_key + checksum
        HASH160_wif = base58.b58encode(private_key_with_checksum).decode()
        address_bytes = extended_ripe160_hash + checksum_ripe160
        bitcoin_address = base58.b58encode(address_bytes).decode()
        message = "\r[+] Public Key Hash (Hash 160): {}             ".format(HASH160.hex())
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        if bitcoin_address.startswith("13zb1h"):
            sys.stdout.write(f"\n[+]\033[32m Pattern Found: {bitcoin_address}, {dec}, {random_bytes}              \033[0m")
            sys.stdout.write(f"\n[+] continue...\n")
        if HASH160 == add_set:
            dec_to_hex = hex(dec).split('x')[-1]
            t = time.ctime()
            sys.stdout.write(f"\033[0m\n\n")
            sys.stdout.write(f"[+] SOLVED:    |\033[32m{t}                                                                 \033[0m\n")
            sys.stdout.write(f"[+] Key Found: |\033[32m {dec_to_hex}                                               \033[0m\n"
                                        f"[+] WIF:       |\033[32m {HASH160_wif}                                                 \033[0m\n"
                                        f"[+] Address:   |\033[32m {bitcoin_address}                                          \033[0m\n"
                                        f"[+] Seed:      |\033[32m {random_bytes}                                               \033[0m\n\n")
            sys.stdout.flush()
            with open("KEYFOUNDKEYFOUND.txt", "a") as f:
                f.write("SOLVED: " + str(t) + '\n' + "HEX: " + str(dec_to_hex) + '\n' + "Address: " + str(bitcoin_address) + '\n' + "Private Key:  " + str(HASH160_wif)+ '\n' + "Random Seed:  " + str(random_bytes) + '\n\n')
                f.flush()
                f.close()
            sys.stdout.write("\033[?25h")
            sys.stdout.flush()
            return

# Create multiple threads for generating addresses
num_threads = cpu_count()
threads = []

for _ in range(num_threads):
    thread = threading.Thread(target=check_private_key, args=(add_set,))
    thread.start()
    threads.append(thread)

# Wait for all threads to finish
for thread in threads:
    thread.join()