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 secp256k1 as ice
import bitcoin

target= "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"
print("Target:", target)
Target_upub= ice.pub2upub(target)

for i in range (100):
    A= ice.scalar_multiplication(i)
    B= ice.point_subtraction(Target_upub, A)
    C= ice.to_cpub(B.hex())
    D= bitcoin.divide(C, 100)

    data = open("S-1.txt","a")
    data.write(str(i)+" = "+str(C)+"\n")
    data.close()

    data = open("D-1.txt","a")
    data.write(str(i)+" = "+str(D)+"\n")
    data.close()