HISTORY = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855), (66, 46346217550346335726),
    (67, 132656943602386256302)
]

# The constant in hex: 0x80000000000000000 (2^67)
CONST = 147573952589676412928

for puzzle, key in HISTORY:
    hex_key = hex(key)
    # Multiply key by 1.004 (as in your earlier example)
    multiplied = key * 1.004
    # Check if multiplied value is near a multiple of CONST
    ratio = multiplied CONST
    print(f"Puzzle {puzzle}:")
    print(f"  Private Key (dec): {key}")
    print(f"  Private Key (hex): {hex_key}")
    print(f"  Multiplied by 1.004: {multiplied:.2f}")
    print(f"  Ratio to CONST (0x800...): {ratio:.10f}")
    print("-" * 50)

import math

# Historical data: (puzzle_number, private_key_in_decimal)
HISTORY = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855), (66, 46346217550346335726),
    (67, 132656943602386256302)
]

# Calculate exact bit flips between consecutive puzzles
EXACT_FLIPS = []
for i in range(1, len(HISTORY)):
    prev_num, prev_key = HISTORY[i-1]
    curr_num, curr_key = HISTORY[i]
    flips = bin(prev_key ^ curr_key).count('1')
    EXACT_FLIPS.append((prev_num, curr_num, flips))
    print(f"Puzzle {prev_num}→{curr_num}: {flips} bit flips")

print("\nFull flip count table:")
print("Start → End | Bit Flips")
print("-----------------------")
for entry in EXACT_FLIPS:
    print(f"{entry[0]:3} → {entry[1]:3} | {entry[2]:3}")

import sys
import time
import multiprocessing
from itertools import combinations
from concurrent.futures import ProcessPoolExecutor, as_completed
import os
from functools import partial

sys.path.append(r'E:\Work\python\secp256k1')
import secp256k1 as ice

NUM_WORKERS = 1
TARGET_ADDRESS = "b907c3a2a3b27789dfb509b730dd47703c272868"

stop_event = multiprocessing.Event()
key_found = multiprocessing.Value('b', False)

# Original key (from puzzle 19)
KEY_67_HEX = "000000000000000000000000000000000000000000000000000000000005749f"

# We fix the senior 236 bits (zero bits)
KEY_67_BIN = bin(int(KEY_67_HEX, 16))[2:].zfill(256)
FIXED_BITS = KEY_67_BIN[:236]  # Fixed 236 bits
CHANGING_BITS = list(KEY_67_BIN[236:]) # Changeable bits (68 bits)


def mutate_fixed_bits(start_index, num_workers):
    for i, bit_indices in enumerate(combinations(range(20), 8)):
        if (i % num_workers) == start_index:
            mutated_bits = CHANGING_BITS[:]
            for index in bit_indices:
                mutated_bits[index] = '1' if mutated_bits[index] == '0' else '0'
           
            mutated_key_bin = FIXED_BITS + "".join(mutated_bits)
            mutated_key_hex = hex(int(mutated_key_bin, 2))[2:].zfill(64)
            yield mutated_key_hex


def check_key(worker_id, num_workers, keys_checked, lock):
    local_counter = 0 
    start_time = time.time()

    for mutated_key_hex in mutate_fixed_bits(worker_id, num_workers):
        if key_found.value or stop_event.is_set():
            return None

        generated_address = ice.privatekey_to_h160(0, True, int(mutated_key_hex, 16)).hex()

        if generated_address.startswith(TARGET_ADDRESS[:7]):
            print(f"  Private Key: {mutated_key_hex}")
            print(f"  Generated Hash: {generated_address}")
            print(f"  Target Hash: {TARGET_ADDRESS}")

        if generated_address == TARGET_ADDRESS:
            with lock:
                if not key_found.value:
                    print(f"\n Key found {worker_id}: {mutated_key_hex} to address {TARGET_ADDRESS}!")
                    with open("key.txt", "w") as f:
                        f.write(f"Key found: {mutated_key_hex}\n")
                    key_found.value = True
                    stop_event.set()
            return mutated_key_hex
       
        local_counter += 1 
        if time.time() - start_time >= 300:
            with lock:
                keys_checked.value += local_counter
            local_counter = 0 
            start_time = time.time() 

    with lock:
        keys_checked.value += local_counter 

    return None 


def print_status(start_time, keys_checked, lock):
    while not stop_event.is_set():
        time.sleep(300)
        with lock:
            checked = keys_checked.value 
        elapsed_time = time.time() - start_time
        print(f"Full time: {elapsed_time:.2f} sec. | Total Key: {checked}")


def main():
    start_time = time.time()

    with multiprocessing.Manager() as manager:
        keys_checked = manager.Value('i', 0)
        lock = manager.Lock()

        tracker_process = multiprocessing.Process(target=print_status, args=(start_time, keys_checked, lock))
        tracker_process.start()

        check_key_partial = partial(check_key, num_workers=NUM_WORKERS, keys_checked=keys_checked, lock=lock)

        with ProcessPoolExecutor(max_workers=NUM_WORKERS) as executor:
            futures = {executor.submit(check_key_partial, i): i for i in range(NUM_WORKERS)}

            for future in as_completed(futures):
                result = future.result()
                if result:
                    break

        stop_event.set()
        tracker_process.terminate()
        tracker_process.join()

    end_time = time.time()
    if not key_found.value:
        print("Key not found")

    print(f"⏳ Full time: {end_time - start_time:.2f} sec.")
    os._exit(0)


if __name__ == "__main__":
    multiprocessing.freeze_support()
    main()

import time
import multiprocessing
import secp256k1 as ice
import random
from math import comb
import numpy as np

# Configuration
TARGET_ADDR = "1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum"  # Puzzle 20
BASE_KEY = "000000000000000000000000000000000000000000000000000000000005749f"  # Puzzle 19 Private Key
PUZZLE_NUM = 20
WORKERS = multiprocessing.cpu_count()

# Historical flip counts
FLIP_TABLE = {
    20:8, 21:8, 22:9, 23:9, 24:10, 25:11, 26:12, 27:13, 28:14, 29:15,
    30:16, 31:17, 32:18, 33:19, 34:20, 35:21, 36:22, 37:23, 38:24, 39:25,
    40:26, 41:27, 42:28, 43:29, 44:30, 45:31, 46:32, 47:33, 48:34, 49:35,
    50:36, 51:37, 52:38, 53:39, 54:40, 55:41, 56:42, 57:43, 58:44, 59:45,
    60:46, 61:47, 62:48, 63:49, 64:50, 65:51, 66:52, 67:53
}

def predict_flips(puzzle_num):
    """Predict flip count using linear regression with bounds"""
    if puzzle_num in FLIP_TABLE:
        return FLIP_TABLE[puzzle_num]
   
    # Linear regression
    x = np.array(list(FLIP_TABLE.keys()))
    y = np.array(list(FLIP_TABLE.values()))
    coeffs = np.polyfit(x, y, 1)
    predicted = round(coeffs[0] * puzzle_num + coeffs[1])
   
    # Apply bounds (50-60% of bits)
    bit_length = puzzle_num
    lower = max(8, int(bit_length * 0.5))
    upper = min(int(bit_length * 0.6), bit_length-5)
    return min(max(predicted, lower), upper)

def mutate_key(base_int, flip_positions):
    """Ultra-fast bit flipping using XOR mask"""
    flip_mask = sum(1 << bit for bit in flip_positions)
    return base_int ^ flip_mask

def worker(base_int, bit_length, flip_count, results, stop_event):
    checked = 0
    bit_positions = list(range(bit_length))
    start_time = time.time()
   
    while not stop_event.is_set():
        # Generate random flip positions
        flip_pos = random.sample(bit_positions, flip_count)
       
        # Create mutated key
        priv_int = mutate_key(base_int, flip_pos)
        checked += 1
       
        # Generate address
        addr = ice.privatekey_to_address(0, True, priv_int)
       
        if addr == TARGET_ADDR:
            hex_key = "%064x" % priv_int
            actual_flips = bin(base_int ^ priv_int).count('1')
            results.put((hex_key, checked, actual_flips))
            stop_event.set()
            return
           
        # Progress update
        if checked % 10000 == 0:
            elapsed = time.time() - start_time
            speed = checked/elapsed if elapsed > 0 else 0
            print(f"Checked {checked:,} | {speed:,.0f} keys/sec", end='\r')

def parallel_search():
    bit_length = PUZZLE_NUM
    base_int = int(BASE_KEY, 16)
    flip_count = predict_flips(PUZZLE_NUM)
    total_combs = comb(bit_length, flip_count)
   
    print(f"\nSearching Puzzle {PUZZLE_NUM} (256-bit)")
    print(f"Base Key: {BASE_KEY}")
    print(f"Target: {TARGET_ADDR}")
    print(f"Predicted Flip Count: {flip_count} bits")
    print(f"Total Possible Combinations: 2^{int(np.log2(total_combs)):,}")
    print(f"Using {WORKERS} workers...\n")
   
    manager = multiprocessing.Manager()
    results = manager.Queue()
    stop_event = manager.Event()
   
    start_time = time.time()
   
    with multiprocessing.Pool(WORKERS) as pool:
        for _ in range(WORKERS):
            pool.apply_async(worker, (base_int, bit_length, flip_count, results, stop_event))
       
        try:
            hex_key, checked, actual_flips = results.get(timeout=86400)  # 24h timeout
            stop_event.set()
           
            elapsed = time.time() - start_time
            print(f"\nFound in {elapsed/3600:.2f} hours")
            print(f"Private Key: {hex_key}")
            print(f"Actual Bit Flips: {actual_flips}")
            print(f"Keys Checked: {checked:,}")
            print(f"Speed: {checked/elapsed:,.0f} keys/sec")
           
            solution_file = f"puzzle_{PUZZLE_NUM}_solution.txt"
            with open(solution_file, "w") as f:
                f.write(hex_key)
            print(f"\nSolution saved to {solution_file}")
            return hex_key
           
        except:
            print("\nKey not found in 24 hours - try adjusting flip count ±2")
            return None
        finally:
            pool.terminate()

if __name__ == "__main__":
    flip_count = predict_flips(PUZZLE_NUM)  # First calculate flip_count
    print(f"Predicted flip count for {PUZZLE_NUM}: {flip_count} bits")
    solution = parallel_search()