import random
import secp256k1 as ice
import concurrent.futures

# Configuration
START = 131071
END = 262143
BLOCK_SIZE = 4096
MIN_PREFIX = 3
MAX_WORKERS = 4
TOTAL_RUNS = 100

def generate_blocks(start, end, block_size):
    """
    Split the keyspace [start..end] into blocks of size block_size,
    then shuffle the block list for randomized dispatch.
    """
    total_keys = end - start + 1
    num_blocks = (total_keys + block_size - 1) // block_size
    blocks = [
        (start + i * block_size,
         min(start + (i + 1) * block_size - 1, end))
        for i in range(num_blocks)
    ]
    random.shuffle(blocks)
    return blocks

def scan_block(b0, b1, target):
    """
    Scan keys in [b0..b1] looking for target.
    Prune the block only if both conditions happen in order:
      1) A false positive on MIN_PREFIX hex chars
      2) Later, a match on the first MIN_PREFIX-1 hex chars
    """
    full_pref = target[:MIN_PREFIX]
    half_pref = target[:MIN_PREFIX - 1]

    for key in range(b0, b1 + 1):
        addr = ice.privatekey_to_h160(0, 1, key).hex()
        if addr == target:
            return True, key
        if addr.startswith(full_pref) and addr != target:
            next_key = key + 1
            break
    else:
        return False, None

    for key in range(next_key, b1 + 1):
        addr = ice.privatekey_to_h160(0, 1, key).hex()
        if addr == target:
            return True, key
        if addr.startswith(half_pref):
            break

    return False, None

def worker(block_chunk, target):
    """
    Scan each block in block_chunk sequentially.
    Return the key if found, else None.
    """
    for b0, b1 in block_chunk:
        found, key = scan_block(b0, b1, target)
        if found:
            return key
    return None

def parallel_scan(blocks, target):
    """
    Distribute blocks round-robin across MAX_WORKERS processes.
    Returns the discovered key or None.
    """
    chunks = [blocks[i::MAX_WORKERS] for i in range(MAX_WORKERS)]
    with concurrent.futures.ProcessPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futures = [executor.submit(worker, chunk, target) for chunk in chunks]
        for future in concurrent.futures.as_completed(futures):
            key = future.result()
            if key is not None:
                for f in futures:
                    f.cancel()
                return key
    return None

if __name__ == "__main__":
    found_count = 0
    not_found_count = 0

    for run in range(1, TOTAL_RUNS + 1):
        target_key = random.randint(START, END)
        target = ice.privatekey_to_h160(0, 1, target_key).hex()

        blocks = generate_blocks(START, END, BLOCK_SIZE)
        key = parallel_scan(blocks, target)

        if key is not None:
            found_count += 1
        else:
            not_found_count += 1

    print(f"\nOf {TOTAL_RUNS} runs, found: {found_count}, not found: {not_found_count}")