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()