.from qiskit import QuantumCircuit, execute, Aer
from qiskit.circuit.library import PhaseOracle

target_address_hex = "20d45a6a762535700ce9e0b216e31994335db8a5"
target_address_decimal = int(target_address_hex, 16)

def sha256_compression_function(qc, message_bits):
    # Implement SHA-256 compression using quantum gates
    # You need to add the actual logic here

    # For demonstration purposes, we'll just apply a simple quantum oracle
    oracle = PhaseOracle(message_bits, target=target_address_decimal)
    qc.append(oracle, range(qc.num_qubits))

# Define the range for iteration
start_range = 36893488147419103232
end_range = -73786976294838206464

# Main loop
for decimal_value in range(start_range, end_range+1):
    # Convert decimal value to bytes and binary string
    message_bytes = decimal_value.to_bytes(32, byteorder="big")
    binary_message = ''.join(format(byte, '08b') for byte in message_bytes)

    # Create quantum circuit
    qc = QuantumCircuit(256)

    # Apply bit operations to encode the initial state and message onto the qubits
    # Implement encoding logic based on your requirements

    # Implement the SHA-256 compression function using a quantum oracle
    sha256_compression_function(qc, binary_message)

    # Measure the final state of the qubits
    qc.measure_all()

    # Simulate the circuit
    job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=1024)

    # Get the results and extract the final state
    counts = job.result().get_counts(qc)
    final_state = [int(bits, 2) for bits in counts.keys()][0]

    # Check if the generated hash matches the target address
    if final_state == target_address_decimal:
        print(f"Target address found!")
        print(f"Decimal Value: {decimal_value}")
        print(f"Simulated Bitcoin hash160: {hex(final_state)[2:].zfill(40)}")
        break

.target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),
    bytes.fromhex('bf7413e8df4e7a34ce9dc13e2f2648783ec54adb')
]

target_hashes_found = []

# Define the lower and upper bounds for the decimal number search range
lower_bound = Decimal('36893488147420166522')
upper_bound = Decimal('55340232221128654832')

# List of additional hex numbers to modify the decimal number
additional_hex_numbers = [
    '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
    '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f',
    '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b', '4c', '4d', '4e', '4f',
    '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e', '5f',
    '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f',
    '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f',
    '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f',
    '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9a', '9b', '9c', '9d', '9e', '9f',
    'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa', 'ab', 'ac', 'ad', 'ae', 'af',
    'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd', 'be', 'bf',
    'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf',
    'd0', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df',
    'e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef',
    'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff'
]

import subprocess
import time
import os
from decimal import Decimal
import base58
import hashlib
import ecdsa

# Function to clear the terminal screen
def clear_terminal():
    subprocess.call('clear', shell=True)

# Function to calculate the Hash 160 of a public key
def calculate_public_key_hash(public_key):
    sha256_hash = hashlib.sha256(public_key).digest()
    ripemd160_hash = hashlib.new('ripemd160')
    ripemd160_hash.update(sha256_hash)
    return ripemd160_hash.digest()

# Function to convert a decimal number to a private key in hexadecimal format
def decimal_to_private_key_hex(decimal_number):
    private_key_bytes = int(decimal_number).to_bytes(32, byteorder='big')
    private_key_hex = private_key_bytes.hex()
    private_key_hex_flipped = private_key_hex.replace('2', '3', 2)
    return private_key_hex, private_key_hex_flipped

# Function to check if a target Hash 160 is found
def check_target_hash(public_key_hash, decimal_number, private_key_hex):
    if public_key_hash in target_public_key_hashes:
        target_hashes_found.append(public_key_hash)
        print(f"Target Hash 160 found: {public_key_hash.hex()}")
        print(f"Decimal Number: {decimal_number}")
        print(f"Private Key Hex: {private_key_hex}")

        # Write the found Hash 160 to the file found_addresses.txt
        with open("found_addresses.txt", "a") as found_file:
            found_file.write(f"Target Hash 160 found: {public_key_hash.hex()}\n")
            found_file.write(f"Decimal Number: {decimal_number}\n")
            found_file.write(f"Private Key Hex: {private_key_hex}\n\n")
            found_file.flush()  # Flush the buffer to ensure data is written immediately

        return True
    return False

# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),


]

target_hashes_found = []

# Define the lower and upper bounds for the decimal number search range
lower_bound = Decimal('37000000000000000000')
upper_bound = Decimal('55340232221128654832')

# List of additional hex numbers to modify the decimal number
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ]

# Initialize time and iteration tracking variables
start_time = time.time()
total_iterations = 0

# Function to search for target Hash 160 values within a specified range
def search_decimal_range(decimal_number, upper_bound):
    global total_iterations  # Use the global variable
    iterations = 0
    update_interval = 1
    step_size = 10000000000000000  # Initial step size

    while decimal_number <= upper_bound:
        private_key_hex, flipped_private_key_hex = decimal_to_private_key_hex(decimal_number)
        private_key = int(decimal_number).to_bytes(32, byteorder='big')
        signing_key = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256)
        verifying_key = signing_key.verifying_key
        public_key = verifying_key.to_string("compressed")
        public_key_hash = calculate_public_key_hash(public_key)

        if check_target_hash(public_key_hash, decimal_number, private_key_hex):
            return True  # Stop the loop if a match is found

        found_match = False

        additional_hashes = []
        for hex_number in additional_hex_numbers:
            modified_decimal_number = int(hex(int(decimal_number))[2:].replace('2', hex_number, 1), 16)
            modified_private_key_hex, _ = decimal_to_private_key_hex(modified_decimal_number)
            modified_private_key = int(modified_decimal_number).to_bytes(32, byteorder='big')
            modified_signing_key = ecdsa.SigningKey.from_string(modified_private_key, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256)
            modified_verifying_key = modified_signing_key.verifying_key
            modified_public_key = modified_verifying_key.to_string("compressed")
            modified_hash = calculate_public_key_hash(modified_public_key)
            additional_hashes.append(modified_hash)

            if check_target_hash(modified_hash, modified_decimal_number, modified_private_key_hex):
                found_match = True
                break

        if found_match:
            return True

        if len(target_hashes_found) == len(target_public_key_hashes):
            return True

        if iterations % update_interval == 0:
            elapsed_time = time.time() - start_time
            iterations_per_second = iterations / elapsed_time
            print(f"Reached {iterations} iterations.")
            print(f"Elapsed Time: {elapsed_time:.2f} seconds")
            print(f"Iterations per Second: {iterations_per_second:.2f}")
            print(f"Decimal Number: {decimal_number}")
            print(f"Private Key Hex: {private_key_hex}")
            print(f"Target Hash 160: {public_key_hash.hex()}")
            print(f"Target Decimal Number: {decimal_number}")
            if target_hashes_found:
                print_hashes_side_by_side(target_hashes_found[-1], decimal_number, private_key_hex, additional_hashes)
            print("\n")

        decimal_number += step_size  # Increase the decimal number by the current step size
        iterations += 1

        # Adjust the step size dynamically based on the search space
        if iterations % 1000 == 0:
            step_size *= 2  # Double the step size every 1 million iterations

# Function to print the target Hash 160 and additional Hash 160 values side by side
def print_hashes_side_by_side(target_hash, decimal_number, private_key_hex, additional_hashes):
    print(f"Decimal Number: {decimal_number}")
    print(f"Target Hash 160: {target_hash.hex()}")
    print(f"Private Key Hex: {private_key_hex}")
    print(f"Target Decimal Number: {decimal_number}")
    for i, hash in enumerate(additional_hashes):
        print(f" ({additional_hex_numbers[i]}): {hash.hex()}")
    print("\n")

# Function to continuously search for target Hash 160 values in the specified range
def continuous_search(lower_bound, upper_bound):
    global total_iterations, start_time  # Use the global variables
    current_decimal = lower_bound

    while True:
        elapsed_time = time.time() - start_time
        total_iterations += 1

        if search_decimal_range(current_decimal, upper_bound):
            print("All target Hash 160 values found. Restarting search...")
            time.sleep(0)  # Optional: Add a delay before restarting the search
            current_decimal = lower_bound  # Reset the current_decimal to the lower_bound
        else:
            current_decimal += 1484585542367  # Increment by 1

# Start the continuous search
while True:
    continuous_search(lower_bound, upper_bound)

# Add sound notification when the script completes
print("Glass sound (indicating script completion)")
subprocess.run(["afplay", "/System/Library/Sounds/glass.aiff"])

import ecdsa
import hashlib
import base58
import random
import time

def generate_bitcoin_address(private_key_hex):
    private_key = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
    public_key = private_key.get_verifying_key()
    public_key_bytes = public_key.to_string("compressed")
   
    sha256_hash = hashlib.sha256(public_key_bytes)
    ripemd160_hash = hashlib.new("ripemd160")
    ripemd160_hash.update(sha256_hash.digest())
    bitcoin_address = ripemd160_hash.digest()

    # Mainnet prefix (0x00)
    network_byte = b'\x00'
    bitcoin_address = network_byte + bitcoin_address

    # Double SHA-256 hash for checksum
    checksum = hashlib.sha256(hashlib.sha256(bitcoin_address).digest()).digest()[:4]
   
    bitcoin_address += checksum
   
    base58_address = base58.b58encode(bitcoin_address)

    return base58_address.decode()

# Define the lower and upper bounds for the private key hex range
lower_bound = '20000000000000000'
upper_bound = '2ffffffffffffffff'
batch_size = 1000  # Number of private keys to search in each batch
total_parts = 100 # Total number of parts to break the range into

# Calculate the part size to make them equal
start_int = int(lower_bound, 16)
end_int = int(upper_bound, 16)
total_keys = end_int - start_int
part_size = total_keys // total_parts

# Generate a list of parts to search and reverse it
parts_to_search = [i for i in range(total_parts)][::-1]

target_addresses = ['13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so', '1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9', '1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ']

additional_hex_numbers = ['2','3','4','5','6','7','8','9','a','b','c','d','e','f']

update_interval = 1
iteration_count = 0

found_addresses = set()

for current_part in parts_to_search:
    current_private_key_hex_start = start_int + current_part * part_size
    current_private_key_hex_end = current_private_key_hex_start + part_size
    iteration_start_time = time.time()

    while time.time() - iteration_start_time < 30:  # Iterate for 15 seconds
        if current_private_key_hex_start >= current_private_key_hex_end:
            break

        private_key_hex = hex(current_private_key_hex_start)[2:].zfill(64)  # Ensure the hex string is 64 characters long

        # Check if the private_key_hex contains non-hexadecimal characters
        if all(c in '0123bcdef' for c in private_key_hex):
            bitcoin_address = generate_bitcoin_address(private_key_hex)
            iteration_count += 1

            if iteration_count % update_interval == 0:
                print(f"Current Iteration Count: {iteration_count}")
                print(f"Current Private Key Hex: {private_key_hex}")
                print(f"Current Bitcoin Address: {bitcoin_address}")

            if bitcoin_address in target_addresses:
                print(f"Target address found: {bitcoin_address}")
                print(f"Private Key Hex: {private_key_hex}")
                found_addresses.add((bitcoin_address, private_key_hex))
                with open("found_addresses.txt", "a") as file:
                    file.write(f"Address: {bitcoin_address}, Private Key: {private_key_hex}\n")
                break

        found_match = False
        for hex_number in additional_hex_numbers:
            modified_private_key_hex = private_key_hex.replace('2', hex_number, 1).zfill(64)

            # Check if the modified_private_key_hex contains non-hexadecimal characters
            if all(c in '0123456789abcdef' for c in modified_private_key_hex):
                modified_bitcoin_address = generate_bitcoin_address(modified_private_key_hex)
                iteration_count += 1

                if iteration_count % update_interval == 0:
                    print(f"Current Iteration Count: {iteration_count}")
                    print(f"Current Private Key Hex (Modified): {modified_private_key_hex}")
                    print(f"Current Bitcoin Address (Modified): {modified_bitcoin_address}")

                if modified_bitcoin_address in target_addresses:
                    print(f"Target address found (Modified): {modified_bitcoin_address}")
                    print(f"Modified Private Key Hex: {modified_private_key_hex}")
                    found_addresses.add((modified_bitcoin_address, modified_private_key_hex))
                    with open("found_addresses.txt", "a") as file:
                        file.write(f"Address: {modified_bitcoin_address}, Private Key: {modified_private_key_hex}\n")
                    found_match = True
                    break
       
        if found_match:
            break
   
        current_private_key_hex_start += -1

import subprocess
import time
import os
from decimal import Decimal
import base58
import hashlib
import ecdsa

# Function to clear the terminal screen
def clear_terminal():
    subprocess.call('clear', shell=True)

# Function to convert a decimal number to a compressed Bitcoin address
def decimal_to_compressed_address(decimal_number):
    private_key = int(decimal_number).to_bytes(32, byteorder='big')
    signing_key = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256)
    verifying_key = signing_key.verifying_key
    compressed_public_key = verifying_key.to_string("compressed")
    hashed_string = hashlib.sha256(compressed_public_key).digest()
    ripemd_string = hashlib.new('ripemd160', hashed_string).digest()
    ripemd_string = b'\x00' + ripemd_string
    hashed_string = hashlib.sha256(ripemd_string).digest()
    hashed_string = hashlib.sha256(hashed_string).digest()
    checksum = hashed_string[:4]
    address = ripemd_string + checksum
    base58_address = base58.b58encode(address)
    return base58_address.decode()

# Function to convert a decimal number to a private key in hexadecimal format
def decimal_to_private_key_hex(decimal_number):
    private_key_bytes = int(decimal_number).to_bytes(32, byteorder='big')
    private_key_hex = private_key_bytes.hex()
    private_key_hex_flipped = private_key_hex.replace('2', '3', 2)
    return private_key_hex, private_key_hex_flipped

# Function to check if a target address is found
def check_target_address(address, decimal_number, private_key_hex):
    if address in target_addresses:
        target_addresses_found.append(address)
        print(f"Target address found: {address}")
        print(f"Decimal Number: {decimal_number}")
        print(f"Private Key Hex: {private_key_hex}")

        # Write the found address to the file add to found addresses.txt
        with open("found_addresses.txt", "a") as found_file:
            found_file.write(f"Target address found: {address}\n")
            found_file.write(f"Decimal Number: {decimal_number}\n")
            found_file.write(f"Private Key Hex: {private_key_hex}\n\n")
            found_file.flush()  # Flush the buffer to ensure data is written immediately

        return True
    return False

# List of target Bitcoin addresses to search for
target_addresses = ['13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so', '1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9', '1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ', '19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG', '1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU']

# List of additional hex numbers to modify the decimal number
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ]

# Define the lower and upper bounds for the decimal number search range
lower_bound = Decimal('37000000000000000000')
upper_bound = Decimal('55340232221128654832')

target_addresses_found = []

# Initialize time and iteration tracking variables
start_time = time.time()
total_iterations = 0

# Function to search for target addresses within a specified range
def search_decimal_range(decimal_number, upper_bound):
    global total_iterations  # Use the global variable
    iterations = 0
    update_interval = 1
    step_size = 100000000000000  # Initial step size

    while decimal_number <= upper_bound:
        compressed_address = decimal_to_compressed_address(decimal_number)
        private_key_hex, flipped_private_key_hex = decimal_to_private_key_hex(decimal_number)

        if check_target_address(compressed_address, decimal_number, private_key_hex):
            return True  # Stop the loop if a match is found

        found_match = False

        additional_addresses = []
        for hex_number in additional_hex_numbers:
            modified_decimal_number = int(hex(int(decimal_number))[2:].replace('2', hex_number, 1), 16)
            modified_compressed_address = decimal_to_compressed_address(modified_decimal_number)
            additional_addresses.append(modified_compressed_address)

            if check_target_address(modified_compressed_address, modified_decimal_number, private_key_hex):
                found_match = True
                break

        if found_match:
            return True

        if len(target_addresses_found) == len(target_addresses):
            return True

        if iterations % update_interval == 0:
            elapsed_time = time.time() - start_time
            iterations_per_second = iterations / elapsed_time
            print(f"Reached {iterations} iterations.")
            print(f"Elapsed Time: {elapsed_time:.2f} seconds")
            print(f"Iterations per Second: {iterations_per_second:.2f}")
            print(f"Decimal Number: {decimal_number}")
            print(f"Compressed Bitcoin Address: {compressed_address}")
            print(f"Private Key Hex: {private_key_hex}")
            if target_addresses_found:
                print_addresses_side_by_side(target_addresses_found[-1], decimal_number, private_key_hex, additional_addresses)
            print("\n")

        if iterations % 100000 == 0:
            clear_terminal()

        decimal_number += step_size  # Increase the decimal number by the current step size
        iterations += 1

        # Adjust the step size dynamically based on the search space
        if iterations % 1000 == 0:
            step_size *= 2  # Double the step size every 1 million iterations

# Function to print the target address and additional addresses side by side
def print_addresses_side_by_side(target_address, decimal_number, private_key_hex, additional_addresses):
    print(f"Decimal Number: {decimal_number}")
    print(f"Target Address: {target_address}")
    print(f"Private Key Hex: {private_key_hex}")
    for i, address in enumerate(additional_addresses):
        print(f" ({additional_hex_numbers[i]}): {address}")
    print("\n")

# Function to continuously search for target addresses in the specified range
def continuous_search(lower_bound, upper_bound):
    global total_iterations, start_time  # Use the global variables
    current_decimal = lower_bound

    while True:
        elapsed_time = time.time() - start_time
        total_iterations += 1

        if search_decimal_range(current_decimal, upper_bound):
            print("All target addresses found. Restarting search...")
            time.sleep(0)  # Optional: Add a delay before restarting the search
            current_decimal = lower_bound  # Reset the current_decimal to the lower_bound
        else:
            current_decimal += 1  # Increment by 1

# Start the continuous search
while True:
    continuous_search(lower_bound, upper_bound)

# Add sound notification when the script completes
print("Glass sound (indicating script completion)")
subprocess.run(["afplay", "/System/Library/Sounds/glass.aiff"])