import mnemonic
import secp256k1 as ice
import multiprocessing
import time
import random

# Configuration
TARGET_HASH160 = "f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8"  # target hash160
FIXED_WORDS = ["abandon"] * 16 + ["about"]  # Fixed part of mnemonic
LANGUAGE = 'english'
BATCH_SIZE = 10000  # Print progress every X valid attempts

# Initialize components
mnemo = mnemonic.Mnemonic(LANGUAGE)
wordlist = mnemo.wordlist
target_binary = bytes.fromhex(TARGET_HASH160)

# Shared counters
attempts = multiprocessing.Value('i', 0)        # Total tries
valid_attempts = multiprocessing.Value('i', 0)  # Valid mnemonics only
start_time = time.time()
lock = multiprocessing.Lock()

def worker(result_queue):
    while True:
        try:
            # Generate 7 random words
            random_words = random.choices(wordlist, k=7)

            # Build full mnemonic phrase
            candidate_words = FIXED_WORDS + random_words
            mnemonic_phrase = ' '.join(candidate_words)

            #Skip if mnemonic is not valid
            if not mnemo.check(mnemonic_phrase):
                with lock:
                    attempts.value += 1  # Count total attempts
                continue

            # Valid mnemonic found
            with lock:
                attempts.value += 1
                valid_attempts.value += 1

                # Print progress based on valid attempts
                if valid_attempts.value % BATCH_SIZE == 0:
                    elapsed = time.time() - start_time
                    rate = valid_attempts.value max(1, elapsed)
                    print(f"[Valid] {valid_attempts.value:,} | {rate:,.0f} valid/sec | Current: {' '.join(random_words)}")

            # Convert to private key
            entropy = mnemo.to_entropy(mnemonic_phrase.split())
            private_key_int = int.from_bytes(entropy, 'big')

            # Generate hash160
            h160 = ice.privatekey_to_h160(0, True, private_key_int)

            # Check for match
            if h160 == target_binary:
                result_queue.put((
                    True,
                    mnemonic_phrase,
                    private_key_int.to_bytes(32, 'big').hex(),
                    h160.hex()
                ))
                return

        except Exception as e:
            continue  # Skip on error

if __name__ == '__main__':
    print(f"Starting random mnemonic search with {multiprocessing.cpu_count()} workers...")

    result_queue = multiprocessing.Queue()
    processes = []

    # Start workers
    for _ in range(multiprocessing.cpu_count()):
        p = multiprocessing.Process(target=worker, args=(result_queue,))
        processes.append(p)
        p.start()

    # Wait for results
    while True:
        success, mnemonic_phrase, privkey_hex, found_hash160 = result_queue.get()
        if success:
            print("\nSUCCESS! Found matching mnemonic:")
            print(f"Full Mnemonic: {mnemonic_phrase}")
            print(f"Private Key: {privkey_hex}")
            print(f"Hash160: {found_hash160}")

            # Terminate all workers
            for p in processes:
                p.terminate()
            break

    # Cleanup
    for p in processes:
        p.join()

    elapsed = time.time() - start_time
    print(f"\nTotal attempts: {attempts.value:,}")
    print(f"Valid mnemonics tested: {valid_attempts.value:,}")
    print(f"Time elapsed: {elapsed:.2f} seconds")
    print(f"Speed: {valid_attempts.value max(1, elapsed):,.0f} valid mnemonics/sec")

import mnemonic
import secp256k1 as ice
import multiprocessing
import time
import random
import os
from multiprocessing import cpu_count

# Configuration
TARGET_HASH160 = "f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8"  # target hash160
FIXED_WORDS = ["abandon"] * 16  # 16 fixed words
LANGUAGE = 'english'
BATCH_SIZE = 10000  # Print progress every X valid attempts

# Load custom wordlists for positions 17 to 24 (i.e., indices 16 to 23)
CUSTOM_WORDLISTS = []
for i in range(17, 25):  # 17.txt to 24.txt
    filename = f"{i}.txt"
    if not os.path.isfile(filename):
        raise FileNotFoundError(f"Missing wordlist file: {filename}")
    with open(filename, 'r') as f:
        words = [line.strip() for line in f if line.strip()]
        CUSTOM_WORDLISTS.append(words)

# Shared counters
attempts = multiprocessing.Value('i', 0)        # Total tries
valid_attempts = multiprocessing.Value('i', 0)  # Valid mnemonics only
start_time = time.time()
lock = multiprocessing.Lock()

# Initialize mnemonic object and target hash
mnemo = mnemonic.Mnemonic(LANGUAGE)
target_binary = bytes.fromhex(TARGET_HASH160)

def worker(result_queue):
    while True:
        try:
            # Generate one word per position from each custom list (positions 17–24)
            random_words = [random.choice(lst) for lst in CUSTOM_WORDLISTS]

            # Build full 24-word mnemonic
            candidate_words = FIXED_WORDS + random_words
            mnemonic_phrase = ' '.join(candidate_words)

            # Skip invalid mnemonics
            if not mnemo.check(mnemonic_phrase):
                with lock:
                    attempts.value += 1
                continue

            # Count valid attempt
            with lock:
                attempts.value += 1
                valid_attempts.value += 1

                # Progress update
                if valid_attempts.value % BATCH_SIZE == 0:
                    elapsed = time.time() - start_time
                    rate = valid_attempts.value max(1, elapsed)
                    print(f"[Valid] {valid_attempts.value:,} | {rate:,.0f} valid/sec | Current: {' '.join(random_words)}")

            # Convert mnemonic to entropy → private key
            entropy = mnemo.to_entropy(candidate_words)
            private_key_int = int.from_bytes(entropy, 'big')

            # Compute hash160
            h160 = ice.privatekey_to_h160(0, True, private_key_int)

            # Match found?
            if h160 == target_binary:
                result_queue.put((
                    True,
                    mnemonic_phrase,
                    private_key_int.to_bytes(32, 'big').hex(),
                    h160.hex()
                ))
                return

        except Exception as e:
            continue  # Skip errors silently

if __name__ == '__main__':
    print(f"Starting random mnemonic search with {multiprocessing.cpu_count()} workers...")
   
    # Try to increase process priority
    try:
        os.nice(-15)
        import psutil
        p = psutil.Process()
        p.cpu_affinity(list(range(cpu_count())))
    except:
        pass

    result_queue = multiprocessing.Queue()
    processes = []

    # Start workers
    for _ in range(multiprocessing.cpu_count()):
        p = multiprocessing.Process(target=worker, args=(result_queue,))
        processes.append(p)
        p.start()

    try:
        # Wait for match
        while True:
            success, mnemonic_phrase, privkey_hex, found_hash160 = result_queue.get()
            if success:
                print("\nSUCCESS! Found matching mnemonic:")
                print(f"Full Mnemonic: {mnemonic_phrase}")
                print(f"Private Key: {privkey_hex}")
                print(f"Hash160: {found_hash160}")
                break

    except KeyboardInterrupt:
        print("\n[!] Stopping workers...")

    # Terminate all workers
    for p in processes:
        p.terminate()

    # Cleanup
    for p in processes:
        p.join()

    elapsed = time.time() - start_time
    print(f"\nTotal attempts: {attempts.value:,}")
    print(f"Valid mnemonics tested: {valid_attempts.value:,}")
    print(f"Time elapsed: {elapsed:.2f} seconds")
    print(f"Speed: {valid_attempts.value max(1, elapsed):,.0f} valid mnemonics/sec")

import mnemonic
from collections import Counter

def calculate_puzzle_parts(position_selector=17):  # Default: check position 17
    start = 1180591620717411303424
    end = 2361183241434822606847
    num_parts = 10000

    part_size = (end - start)/ num_parts

    word_counter = Counter()

    for i in range(num_parts):
        start_dec = start + i * part_size
        start_hex = "%064x" % start_dec
        private_key = bytes.fromhex(start_hex)
        language = 'english'
        mnemonic_words = mnemonic.Mnemonic(language).to_mnemonic(private_key)
        mnemonic_word_list = mnemonic_words.split()

        if len(mnemonic_word_list) < position_selector:
            print(f"Mnemonic too short at iteration {i}: {mnemonic_word_list}")
            continue

        selected_word = mnemonic_word_list[position_selector - 1]  # Convert 1-based to 0-based index

        word_counter.update([selected_word])

    # Output the most common words at this position
    for word, count in word_counter.most_common():
        print(f"{word}")

calculate_puzzle_parts(position_selector=24)  # Change this to analyze other positions like 16, 18, etc.

Unfilled base58 digits: 21
Adjusting min H160 up from "1PWo3JeB9jrGvzzzzzzzzzzzzzzzza76BM"
min NB+H160+CS: 00f6f5431d25bbf7b129329c4be9ce9c7064f457fc76e8cd54 len: 25 minAddr: 1PWo3JeB9jrGw1111111111111117sfssh
Address right before the computed minimum: 1PWo3JeB9jrGvzzzzzzzzzzzzzzzza76BM
max NB+H160+CS: 00f6f5431d25bbf7b1314bbfcb22658f6370ac8ac91e478669 len: 25 maxAddr: 1PWo3JeB9jrGwzzzzzzzzzzzzzzzwVNymA
Address right after the computed maximum: 1PWo3JeB9jrGx11111111111111163WUG8
H160 target prefix len: 67 bits
Total possible H160: 2506270853702237716179595982 = 91.01760089767902 bits
Expected average in subset: 2.02
99% confidence interval: [0, 6] successes

Total possible H160: 9903520314283042199192993792 = 93.0 bits
Expected average in subset: 8.00
99% confidence interval: [2, 16] successes