Bitcoin puzzle transaction ~32 BTC prize to who solves it

[analyticnomad]

It was literally designed to be even more solvable by reducing the range and exposing pub keys.

Give me the public key for puzzle 71

No. But I'll give you a dramatically reduced range. Somewhere in there: 400000000000000000:7fffffffffffffffff

Stop complaining about everything and try to find it with us.

[_AFK_]

With an RTX 2070 graphics card, what is the maximum and fastest number of keys that can be scanned?

It depends on which program is used:

https://github.com/FixedPaul/VanitySearch-Bitcrack

RTX2070 ~ 1600Mkeys/s

RTX3060 ~ 2000Mkeys/s

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

PUZZLE #69

SPEED: [8.2 GK/s] - SEARCH: [2^36.25 - 7.42%] - RUN: [00:00:10] - END: [00:02:05] - TOTAL: [1]

=================================================================
!!! ADDRESS FOUND !!!
=================================================================

SEARCH TIME: 00:00:10 (10.6 seconds)
TOTAL KEYS SEARCHED: 81,604,378,624 KEYS

ADDRESS: 19YZECXj3SxEZMoUeJ1yiPsw8xANe7M7QR
KEY (WIF): KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qt5RQNhFCn1r58in2E78
KEY (HEX): 0x349b84b6431a6c4ef1

THE PRIVATE KEY FOR THIS ADDRESS HAS BEEN FOUND AND SAVED!
CHECK YOUR OUTPUT FILE FOR THE PRIVATE KEY DETAILS.
=================================================================

[kTimesG]

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

Does your "custom code" actually do H160 in a specific key range (not endo, etc.)? 8.2 Gk/s with only 84 SM sounds too good to believe. Not impossible, though it would be really impressive, if actually true.

[_AFK_]

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

Does your "custom code" actually do H160 in a specific key range (not endo, etc.)? 8.2 Gk/s with only 84 SM sounds too good to believe. Not impossible, though it would be really impressive, if actually true.

Sent you a DM, just check it. 

[aby3er]

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

PUZZLE #69

SPEED: [8.2 GK/s] - SEARCH: [2^36.25 - 7.42%] - RUN: [00:00:10] - END: [00:02:05] - TOTAL: [1]  Very NICE,ur code mast be faster then RC kangaroo code ,would u show how fast it's can find 85?
RC kangaroo code make it in 2 and a half minutes with just 4070 and 2060 gpu


>RCKangaroo.exe -gpu 01 -tames tames85.dat -dp 17 -range 85 -start 1000000000000000000000 -pubkey 0329c4574a4fd8c810b7e42a4b398882b381bcd85e40c6883712912d167c83e73a
********************************************************************************
*                    RCKangaroo v3.0  (c) 2024 RetiredCoder                    *
********************************************************************************

This software is free and open-source: https://github.com/RetiredC
It demonstrates fast GPU implementation of SOTA Kangaroo method for solving ECDLP
Windows version
CUDA devices: 2, CUDA driver/runtime: 12.9/12.8
GPU 0: NVIDIA GeForce RTX 4070 Ti, 11.99 GB, 60 CUs, cap 8.9, PCI 1, L2 size: 49152 KB
GPU 1: NVIDIA GeForce RTX 2060 SUPER, 8.00 GB, 34 CUs, cap 7.5, PCI 4, L2 size: 4096 KB
Total GPUs for work: 2

MAIN MODE

Solving public key
X: 29C4574A4FD8C810B7E42A4B398882B381BCD85E40C6883712912D167C83E73A
Y: 0E02C3AFD79913AB0961C95F12498F36A72FFA35C93AF27CEE30010FA6B51C53
Offset: 0000000000000000000000000000000000000000001000000000000000000000

Solving point: Range 85 bits, DP 17, start...
SOTA method, estimated ops: 2^42.702, RAM for DPs: 2.220 GB. DP and GPU overheads not included!
Estimated DPs per kangaroo: 36.804.
load tames...
tames loaded
GPU 0: allocated 1128 MB, 368640 kangaroos. OldGpuMode: No
GPU 1: allocated 3284 MB, 1114112 kangaroos. OldGpuMode: Yes
GPUs started...
MAIN: Speed: 5320 MKeys/s, Err: 0, DPs: 273121K/54571K, Time: 0d:00h:00m/0d:00h:22m
MAIN: Speed: 5755 MKeys/s, Err: 0, DPs: 273566K/54571K, Time: 0d:00h:00m/0d:00h:20m
MAIN: Speed: 5699 MKeys/s, Err: 0, DPs: 274003K/54571K, Time: 0d:00h:00m/0d:00h:20m
MAIN: Speed: 5735 MKeys/s, Err: 0, DPs: 274439K/54571K, Time: 0d:00h:00m/0d:00h:20m
MAIN: Speed: 5783 MKeys/s, Err: 0, DPs: 274873K/54571K, Time: 0d:00h:00m/0d:00h:20m
MAIN: Speed: 5723 MKeys/s, Err: 0, DPs: 275310K/54571K, Time: 0d:00h:01m/0d:00h:20m
MAIN: Speed: 5722 MKeys/s, Err: 0, DPs: 275744K/54571K, Time: 0d:00h:01m/0d:00h:20m
MAIN: Speed: 5723 MKeys/s, Err: 0, DPs: 276172K/54571K, Time: 0d:00h:01m/0d:00h:20m
MAIN: Speed: 5712 MKeys/s, Err: 0, DPs: 276606K/54571K, Time: 0d:00h:01m/0d:00h:20m
MAIN: Speed: 5711 MKeys/s, Err: 0, DPs: 277042K/54571K, Time: 0d:00h:01m/0d:00h:20m
MAIN: Speed: 5711 MKeys/s, Err: 0, DPs: 277476K/54571K, Time: 0d:00h:01m/0d:00h:20m
MAIN: Speed: 5656 MKeys/s, Err: 0, DPs: 277912K/54571K, Time: 0d:00h:02m/0d:00h:21m
MAIN: Speed: 5607 MKeys/s, Err: 0, DPs: 278332K/54571K, Time: 0d:00h:02m/0d:00h:21m
MAIN: Speed: 5704 MKeys/s, Err: 0, DPs: 278769K/54571K, Time: 0d:00h:02m/0d:00h:20m
MAIN: Speed: 5700 MKeys/s, Err: 0, DPs: 279205K/54571K, Time: 0d:00h:02m/0d:00h:20m
MAIN: Speed: 5702 MKeys/s, Err: 0, DPs: 279638K/54571K, Time: 0d:00h:02m/0d:00h:20m
MAIN: Speed: 5695 MKeys/s, Err: 0, DPs: 280066K/54571K, Time: 0d:00h:02m/0d:00h:20m
MAIN: Speed: 5697 MKeys/s, Err: 0, DPs: 280500K/54571K, Time: 0d:00h:03m/0d:00h:20m
MAIN: Speed: 5702 MKeys/s, Err: 0, DPs: 280937K/54571K, Time: 0d:00h:03m/0d:00h:20m
MAIN: Speed: 5700 MKeys/s, Err: 0, DPs: 281363K/54571K, Time: 0d:00h:03m/0d:00h:20m
Stopping work ...
Point solved, K: 0.191 (with DP and GPU overheads)


PRIVATE KEY: 00000000000000000000000000000000000000000011720C4F018D51B8CEBBA8

[analyticnomad]

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

Does your "custom code" actually do H160 in a specific key range (not endo, etc.)? 8.2 Gk/s with only 84 SM sounds too good to believe. Not impossible, though it would be really impressive, if actually true.

Sent you a DM, just check it. 

Think you could do this on CUDA?

[_AFK_]

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

Does your "custom code" actually do H160 in a specific key range (not endo, etc.)? 8.2 Gk/s with only 84 SM sounds too good to believe. Not impossible, though it would be really impressive, if actually true.

Sent you a DM, just check it. 

Think you could do this on CUDA?

It's CUDA

[0x1FFFFFF]

Great speed but dont have range Start and End.

I have modified FixedPaul VanitySearch, which allow custom start:end range and add new pure (blind random) mode without any sequential approach, the current default random mode is using some hybrid approach.

But in this process, I'd like to focus on spesific range, slice it using my own code for slicing the range based on bit length / custom distance between sliced start:end , so i use sequential in this process :

Code:

PS C:\Users\Asus\Desktop\Vanbitxx> ./x64/Release/VanitySearch.exe -gpuId 0 -f newrx.txt -seq 1PWo3JeB

VanitySearch-Bitcrack v2.2 by FixedPaul

[*] Processing range file: newrx.txt
[*] Found range file at: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] Loading ranges from file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] File size: 16669574 bytes
[*] Parsed 438673 non-empty lines
[*] Found 438673 ranges in file
[*] Successfully loaded 438673 ranges into cache

Range file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
Range: 40BD1588A9B58ADC43 -> 40BD1588AC0996C042 (Keys: 10000000000, Remaining: 438672)

Initial range from file:
Start: 40BD1588A9B58ADC43
End: 40BD1588AC0996C042
Next: 40BD1588A9B58ADC43
Sequential Mode Enabled !
Search: 1PWo3JeB [Compressed]
Current task START time: Sun Jun 15 20:58:00 2025
GPU: GPU #0 NVIDIA GeForce RTX 2050 (16x128 cores) Grid(2048x256)
Starting keys set in 0.21 seconds

Range: 465C3F524916AE3D6E -> 465C3F524B6ABA216D (Keys: 10000000000, Remaining: 438561) - Speed: 564.2 [MK/s] - Found: 0
Public Addr: 1PWo3JeBFpmV6hk6gyvUHRZ5yMtLSySU8p
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qzbxieRo41BuDkkstQDr
Priv (HEX): 0x0000000000000000000000000000000000000000000000465C3F524B26D02B36

Range: 4AD8C8A8E1D4D5FB6D -> 4AD8C8A8E428E1DF6C (Keys: 10000000000, Remaining: 438449) - Speed: 564.0 [MK/s] - Found: 1
Public Addr: 1PWo3JeBHpRhh6uasKKNBSVFcREHB5X9P8
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r2FdEJec4RhDmzHm8GkV
Priv (HEX): 0x00000000000000000000000000000000000000000000004AD8C8A8E2772B6382

Range: 45B791FF293F7EC654 -> 45B791FF2B938AAA53 (Keys: 10000000000, Remaining: 438272) - Speed: 564.7 [MK/s] - Found: 2

[citb0in]

I have modified FixedPaul VanitySearch, which allow custom start:end range and add new totally random mode without any sequential approach, but since i also create my own version of range slicing code, i use sequential in this process -snip-

reinventing the wheel?

[MrGPBit]

Great speed but dont have range Start and End.

I have modified FixedPaul VanitySearch, which allow custom start:end range and add new totally random mode without any sequential approach, but since i also create my own version of range slicing code, i use sequential in this process :

Code:

PS C:\Users\Asus\Desktop\Vanbitxx> ./x64/Release/VanitySearch.exe -gpuId 0 -f newrx.txt -seq 1PWo3JeB

VanitySearch-Bitcrack v2.2 by FixedPaul

[*] Processing range file: newrx.txt
[*] Found range file at: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] Loading ranges from file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] File size: 16669574 bytes
[*] Parsed 438673 non-empty lines
[*] Found 438673 ranges in file
[*] Successfully loaded 438673 ranges into cache

Range file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
Range: 40BD1588A9B58ADC43 -> 40BD1588AC0996C042 (Keys: 10000000000, Remaining: 438672)

Initial range from file:
Start: 40BD1588A9B58ADC43
End: 40BD1588AC0996C042
Next: 40BD1588A9B58ADC43
Sequential Mode Enabled !
Search: 1PWo3JeB [Compressed]
Current task START time: Sun Jun 15 20:58:00 2025
GPU: GPU #0 NVIDIA GeForce RTX 2050 (16x128 cores) Grid(2048x256)
Starting keys set in 0.21 seconds

Range: 465C3F524916AE3D6E -> 465C3F524B6ABA216D (Keys: 10000000000, Remaining: 438561) - Speed: 564.2 [MK/s] - Found: 0
Public Addr: 1PWo3JeBFpmV6hk6gyvUHRZ5yMtLSySU8p
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qzbxieRo41BuDkkstQDr
Priv (HEX): 0x0000000000000000000000000000000000000000000000465C3F524B26D02B36

Range: 4AD8C8A8E1D4D5FB6D -> 4AD8C8A8E428E1DF6C (Keys: 10000000000, Remaining: 438449) - Speed: 564.0 [MK/s] - Found: 1
Public Addr: 1PWo3JeBHpRhh6uasKKNBSVFcREHB5X9P8
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r2FdEJec4RhDmzHm8GkV
Priv (HEX): 0x00000000000000000000000000000000000000000000004AD8C8A8E2772B6382

Range: 45B791FF293F7EC654 -> 45B791FF2B938AAA53 (Keys: 10000000000, Remaining: 438272) - Speed: 564.7 [MK/s] - Found: 2

Can you please upload your version to github?

[Frequence]

Great speed but dont have range Start and End.

I have modified FixedPaul VanitySearch, which allow custom start:end range and add new totally random mode without any sequential approach, but since i also create my own version of range slicing code, i use sequential in this process :

Code:

PS C:\Users\Asus\Desktop\Vanbitxx> ./x64/Release/VanitySearch.exe -gpuId 0 -f newrx.txt -seq 1PWo3JeB

VanitySearch-Bitcrack v2.2 by FixedPaul

[*] Processing range file: newrx.txt
[*] Found range file at: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] Loading ranges from file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] File size: 16669574 bytes
[*] Parsed 438673 non-empty lines
[*] Found 438673 ranges in file
[*] Successfully loaded 438673 ranges into cache

Range file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
Range: 40BD1588A9B58ADC43 -> 40BD1588AC0996C042 (Keys: 10000000000, Remaining: 438672)

Initial range from file:
Start: 40BD1588A9B58ADC43
End: 40BD1588AC0996C042
Next: 40BD1588A9B58ADC43
Sequential Mode Enabled !
Search: 1PWo3JeB [Compressed]
Current task START time: Sun Jun 15 20:58:00 2025
GPU: GPU #0 NVIDIA GeForce RTX 2050 (16x128 cores) Grid(2048x256)
Starting keys set in 0.21 seconds

Range: 465C3F524916AE3D6E -> 465C3F524B6ABA216D (Keys: 10000000000, Remaining: 438561) - Speed: 564.2 [MK/s] - Found: 0
Public Addr: 1PWo3JeBFpmV6hk6gyvUHRZ5yMtLSySU8p
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qzbxieRo41BuDkkstQDr
Priv (HEX): 0x0000000000000000000000000000000000000000000000465C3F524B26D02B36

Range: 4AD8C8A8E1D4D5FB6D -> 4AD8C8A8E428E1DF6C (Keys: 10000000000, Remaining: 438449) - Speed: 564.0 [MK/s] - Found: 1
Public Addr: 1PWo3JeBHpRhh6uasKKNBSVFcREHB5X9P8
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r2FdEJec4RhDmzHm8GkV
Priv (HEX): 0x00000000000000000000000000000000000000000000004AD8C8A8E2772B6382

Range: 45B791FF293F7EC654 -> 45B791FF2B938AAA53 (Keys: 10000000000, Remaining: 438272) - Speed: 564.7 [MK/s] - Found: 2

Can you please upload this version ? Thanks

[analyticnomad]

RTX5080 ~ 8200MKeys/s (custom code, not Vanity)

Does your "custom code" actually do H160 in a specific key range (not endo, etc.)? 8.2 Gk/s with only 84 SM sounds too good to believe. Not impossible, though it would be really impressive, if actually true.

Sent you a DM, just check it. 

Think you could do this on CUDA?

It's CUDA

Nice man, Can you drop your Github?

[0x1FFFFFF]

Great speed but dont have range Start and End.

I have modified FixedPaul VanitySearch, which allow custom start:end range and add new totally random mode without any sequential approach, but since i also create my own version of range slicing code, i use sequential in this process :

Code:

PS C:\Users\Asus\Desktop\Vanbitxx> ./x64/Release/VanitySearch.exe -gpuId 0 -f newrx.txt -seq 1PWo3JeB

VanitySearch-Bitcrack v2.2 by FixedPaul

[*] Processing range file: newrx.txt
[*] Found range file at: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] Loading ranges from file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
[*] File size: 16669574 bytes
[*] Found 438673 ranges in file
[*] Successfully loaded 438673 ranges into cache

Range file: C:\Users\Asus\Desktop\Vanbitxx\newrx.txt
Range: 40BD1588A9B58ADC43 -> 40BD1588AC0996C042 (Keys: 10000000000, Remaining: 438672)

Initial range from file:

Start: 40BD1588A9B58ADC43
End: 40BD1588AC0996C042

Sequential Mode Enabled !
Search: 1PWo3JeB [Compressed]
Current task START time: Sun Jun 15 20:58:00 2025
GPU: GPU #0 NVIDIA GeForce RTX 2050 (16x128 cores) Grid(2048x256)
Starting keys set in 0.21 seconds

Range: 465C3F524916AE3D6E -> 465C3F524B6ABA216D (Keys: 10000000000, Remaining: 438561) - Speed: 564.2 [MK/s] - Found: 0
Public Addr: 1PWo3JeBFpmV6hk6gyvUHRZ5yMtLSySU8p
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qzbxieRo41BuDkkstQDr
Priv (HEX): 0x0000000000000000000000000000000000000000000000465C3F524B26D02B36

Range: 4AD8C8A8E1D4D5FB6D -> 4AD8C8A8E428E1DF6C (Keys: 10000000000, Remaining: 438449) - Speed: 564.0 [MK/s] - Found: 1
Public Addr: 1PWo3JeBHpRhh6uasKKNBSVFcREHB5X9P8
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r2FdEJec4RhDmzHm8GkV
Priv (HEX): 0x00000000000000000000000000000000000000000000004AD8C8A8E2772B6382

Range: 45B791FF293F7EC654 -> 45B791FF2B938AAA53 (Keys: 10000000000, Remaining: 438272) - Speed: 564.7 [MK/s] - Found: 2

Can you please upload your version to github?

Sure, I will upload it later to github.. maybe tomorrow after finalizing some minor fix

[Akito S. M. Hosana]

Hello, what do you think about this idea?
I hope it is useful and I am waiting for your comments

Good idea. It will only take 100,000 years to find puzzle 71 private key. 

Here is the AI script

Code:

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

[Akito S. M. Hosana]

Пoчeмy 16 cлoв abandon ,1 cлoвo about, и 7 cлoв paндoмныx ?

Code:

import secp256k1 as ice
import mnemonic


def calculate_puzzle_parts():
    start = 1180591620717411303424
    end =  2361183241434822606847
    num_parts = 10

    part_size = (end - start) // num_parts
    for i in range(num_parts):
        start_dec = start + i * part_size
        end_dec = start + (i + 1) * part_size - 1

        start_hex = "%064x" % start_dec
        start_wif = ice.btc_pvk_to_wif(start_hex)  # Compressed WIF
        private_key = bytes.fromhex(start_hex)
        language = 'english'  
        mnemonic_words = mnemonic.Mnemonic(language).to_mnemonic(private_key)
        mnemonic_word_list = " ".join(mnemonic_words.split())
        print(f"Part {i + 1}", start_dec, start_wif, mnemonic_word_list)


calculate_puzzle_parts()

Part 1 1180591620717411303424 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qxGLkchTagWEWquHPtvw abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon able abandon abandon abandon abandon abandon abandon between
Part 2 1298650782789152433766 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qzcomN2tkj1Srntequ8e abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon able creek office smoke grid creek office ten
Part 3 1416709944860893564108 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r2yGn7NKvmWfCjtNq4xH abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon able grid creek office smoke grid creek loyal
Part 4 1534769106932634694450 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r5Kjnrhm6p1sYgtJyVwp abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon able office smoke grid creek office smoke excuse
Part 5 1652828269004375824792 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3r7gCoc3CGrX5tdmxEtfs abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon able smoke grid creek office smoke grid bottom
Part 6 1770887431076116955134 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3rA2fpMNdSu2JEanwRKxh abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon able zoo zoo zoo zoo zoo zoo spike
Part 7 1888946593147858085476 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3rCP8q6i4cwXWaXjXjtnt abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about creek office smoke grid creek office normal
Part 8 2007005755219599215818 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3rEjbqr3Vnz2ivUmns4h3 abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about grid creek office smoke grid creek escape
Part 9 2125064917291340346160 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3rH64rbNvy2XwGRg1SxL4 abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about office smoke grid creek office smoke auction
Part 10 2243124079363081476502 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3rKSXsLiN9539cNkQWuLv abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about smoke grid creek office smoke green spin

I assume that the private key is from 1888946593147858085476 to 2243124079363081476502.
So it is 16 abandon + about and 7 random words.
You can also go for 16 abandon and 8 random words. It's just madness to solve. The program 100% works on 1 or 2 missing words. I tested.

Maybe someone knows how to find a better method? I see that some words are repeated throughout the entire range.

[nomachine]

Maybe someone knows how to find a better method? I see that some words are repeated throughout the entire range.

If you manage to condense it down to 4 words that are missing, maybe. Or that you have a special word list for each position. Otherwise, it is impossible with all combinations. You can immediately reduce position 17 to have a word list from "able" - to - "about". From 18 to 24 good luck in choosing words.  

[Akito S. M. Hosana]

You can immediately reduce position 17 to have a word list from "able" - to - "about". From 18 to 24 good luck in choosing words.  

How ??

[nomachine]

You can immediately reduce position 17 to have a word list from "able" - to - "about". From 18 to 24 good luck in choosing words.  

How ??

Code:

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

Make sure you have these files in the same directory:

17.txt, 18.txt, 19.txt, 20.txt, 21.tx,t 22.txt, 23.txt and 24.txt

17.txt content:

able
about
above

(17.txt will only work for puzzle 71 with these words)

The fewer words you have in them, the faster and faster the entire script will run.

[Akito S. M. Hosana]

Make sure you have these files in the same directory:

17.txt, 18.txt, 19.txt, 20.txt, 21.tx,t 22.txt, 23.txt and 24.txt


The fewer words you have in them, the faster and faster the entire script will run.

How can I create these files automatically ? 

[nomachine]

How can I create these files automatically ? 

Code:

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.

python3 words.py > 24.txt

for position 24 and so on 

P.S.
There's no way this can be solved this way.  .. go away now.