Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Bram24732]

Is it so difficult for you to post an entire code?

Entire code (https://bitcointalk.org/index.php?topic=5539190.0) with one line modification which changes the prefix check to a random draw.
Please explain to us why result is the same, even when no prefix check is made.

Code:

import hashlib
import random
import time

# Configuration
TOTAL_SIZE = 100_000
RANGE_SIZE = 4_096
PREFIX_LENGTH = 3
SIMULATIONS = 500
SECP256K1_ORDER = int("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)

print(f"""
=== Configuration ===
Total numbers: {TOTAL_SIZE:,}
Block size: {RANGE_SIZE:,}
Prefix: {PREFIX_LENGTH} characters (16^{PREFIX_LENGTH} combinations)
Simulations: {SIMULATIONS}
secp256k1 Order: {SECP256K1_ORDER}
""")

def generate_h160(data):
    h = hashlib.new('ripemd160', str(data).encode('utf-8'))
    return h.hexdigest()

def shuffled_range(n):
    arr = list(range(n + 1))
    random.shuffle(arr)
    return arr

def sequential_search(dataset, block, target_hash, order):
    checks = 0
    for idx in order:
        start = idx * block
        end = start + block
        for i in range(start, end):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def precise_search(dataset, block, prefix, target_hash, order):
    prefix_hash = target_hash[:prefix]
    checks = 0
    ranges = []
    for idx in order:
        start = idx * block
        end = start + block
        found_prefix = False
        for i in range(start, end):
            checks += 1
            h = generate_h160(dataset[i])
            if h == target_hash:
                return {"checks": checks, "found": True}
            if random.randint(0, RANGE_SIZE) == 0:  
                found_prefix = True
                ranges.append({"start": i + 1, "end": end})
                break
    for r in ranges:
        for i in range(r["end"] - 1, r["start"] - 1, -1):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def compare_methods():
    results = {
        "sequential": {"wins": 0, "total_checks": 0, "total_time": 0},
        "precise": {"wins": 0, "total_checks": 0, "total_time": 0},
        "ties": 0
    }

    for i in range(SIMULATIONS):
        max_range = SECP256K1_ORDER - TOTAL_SIZE - 1
        random_offset = random.randrange(max_range)
        R = 1 + random_offset

        dataset = [R + i for i in range(TOTAL_SIZE)]
        target_num = random.choice(dataset)
        target_hash = generate_h160(target_num)
        blocks = TOTAL_SIZE // RANGE_SIZE
        order = shuffled_range(blocks - 1)

        start_time = time.perf_counter()
        seq_result = sequential_search(dataset, RANGE_SIZE, target_hash, order)
        end_time = time.perf_counter()
        seq_time = end_time - start_time

        start_time = time.perf_counter()
        pre_result = precise_search(dataset, RANGE_SIZE, PREFIX_LENGTH, target_hash, order)
        end_time = time.perf_counter()
        pre_time = end_time - start_time

        results["sequential"]["total_checks"] += seq_result["checks"]
        results["precise"]["total_checks"] += pre_result["checks"]
        results["sequential"]["total_time"] += seq_time
        results["precise"]["total_time"] += pre_time

        if seq_result["checks"] < pre_result["checks"]:
            results["sequential"]["wins"] += 1
        elif seq_result["checks"] > pre_result["checks"]:
            results["precise"]["wins"] += 1
        else:
            results["ties"] += 1

        print(f"Simulation {i + 1}: Sequential = {seq_result['checks']} checks in {seq_time:.6f}s | Prefix = {pre_result['checks']} checks in {pre_time:.6f}s")

    avg_success_rate_sequential = (results["sequential"]["total_checks"] / results["sequential"]["wins"]
                                   if results["sequential"]["wins"] > 0 else float('inf'))
    avg_success_rate_precise = (results["precise"]["total_checks"] / results["precise"]["wins"]
                                if results["precise"]["wins"] > 0 else float('inf'))
    avg_time_sequential = (results["sequential"]["total_time"] / results["sequential"]["wins"]
                           if results["sequential"]["wins"] > 0 else float('inf'))
    avg_time_precise = (results["precise"]["total_time"] / results["precise"]["wins"]
                        if results["precise"]["wins"] > 0 else float('inf'))

    print(f"""
=== FINAL RESULTS ===
Wins:
Sequential: {results['sequential']['wins']}
Prefix: {results['precise']['wins']}
Ties: {results['ties']}

Total Checks:

Sequential: {results['sequential']['total_checks']}
Prefix: {results['precise']['total_checks']}
Total Time:

Sequential: {results['sequential']['total_time']:.6f} seconds
Prefix: {results['precise']['total_time']:.6f} seconds

Averages (Total Time / Wins):

Sequential : {avg_time_sequential:.6f} seconds/victory
Prefix : {avg_time_precise:.6f} seconds/victory

Checks per Win:
Sequential : {avg_success_rate_sequential:.2f} checks/win
Prefix : {avg_success_rate_precise:.2f} checks/win
""")

if __name__ == '__main__':
    compare_methods()

[kTimesG]

Everyone: here's this algorithm that works better or same than whatever you had there. Also, here's the empirical proof.

A sane person's response: but it doesn't work better or same; where's the proof?

Makes sense.

To the normal people who read this: there is no advantage or proof of this prefix theory as having any advantages over a normal sequential search. They both work exactly the same. There isn't even that edge that it finishes faster - because that only happens when the traversal order of the two methods was identical, which statistically introduces a bias (because the target match is always at the same position and the traversal is in the same order, creating a larger statistical variance). Once you simply decide to use a different traversal order than the one prefix uses, results converge to a perfect 50% to 50% wins, chances, average checks, and whatever else you can expect from a random search. Hell, even randomly picking the next key to check from the remaining unchecked keys, instead of doing it sequentially, yields the same results.

That's the takeaway for normal sane people. If you prefer the total insanity path, even after all the empirical proofs in the universe were brought to the table, just follow whatever mcdouglasx has to say.  

[WanderingPhilospher]

ktimesg, bram, McD, and fixedpaul

You all really need to stop lol. It's like you have to have the last word, over really, nothing.

McD isn't even running to try and find a puzzle; he has said this many times. Noone else in here is using this prefix search method; the way yours/his tests are testing. Bibli is one (that I know of) using prefixes and calculations, and it's different from the "test" scripts lol. Other people may find prefixes and post them here, but that is all. And what does it hurt? Nothing.

Let it go.

If, and I mean IF, some new person gets on here and is lazy and doesn't read over the last 49 pages you all have wasted about random + sequential vs prefix blah blah blah, and asks a question of which one is better, by all means, voice your "opinions". Maybe have a prefilled response to post. Post it once, and let it go lol.

But to keep going on with McD who isn't even running a single core python script to solve the puzzle, is comical, at best. And even if he had 39847679347327 GPUs running and wanted to search his way, so? Would that bother you? If so, whew, I dunno what to say lol.

normal sane people

After all your ramblings and back and forth over really nothing, I am not sure many believe you to be normal or sane LOL!

[Bram24732]

You all really need to stop lol. It's like you have to have the last word, over really, nothing.

That's what happens when you have people with way too much free time arguing over the internet.
I don't really care for last word tbh, I'd just like for McD to understand what we're saying. I'm sure this would have been resolved pages ago if we had the same terminology and actually read each other's posts.

[kTimesG]

Let's get back to the puzzles guys.

Did anyone else notice that Puzzle 16 is fully contained in Puzzle 42?

And that's not all: the end of Puzzle 15, the entire Puzzle 16, and the first bits of Puzzle 17, they are fully contained in Puzzle 42. That's one long sequence: 22 continuous bits. Just sitting there in the middle of #42.

I'm framing this on the wall for future research.

[Bram24732]

Is it so difficult for you to post an entire code?

Entire code (https://bitcointalk.org/index.php?topic=5539190.0) with one line modification which changes the prefix check to a random draw.
Please explain to us why result is the same, even when no prefix check is made.

Code:

import hashlib
import random
import time

# Configuration
TOTAL_SIZE = 100_000
RANGE_SIZE = 4_096
PREFIX_LENGTH = 3
SIMULATIONS = 500
SECP256K1_ORDER = int("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)

print(f"""
=== Configuration ===
Total numbers: {TOTAL_SIZE:,}
Block size: {RANGE_SIZE:,}
Prefix: {PREFIX_LENGTH} characters (16^{PREFIX_LENGTH} combinations)
Simulations: {SIMULATIONS}
secp256k1 Order: {SECP256K1_ORDER}
""")

def generate_h160(data):
    h = hashlib.new('ripemd160', str(data).encode('utf-8'))
    return h.hexdigest()

def shuffled_range(n):
    arr = list(range(n + 1))
    random.shuffle(arr)
    return arr

def sequential_search(dataset, block, target_hash, order):
    checks = 0
    for idx in order:
        start = idx * block
        end = start + block
        for i in range(start, end):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def precise_search(dataset, block, prefix, target_hash, order):
    prefix_hash = target_hash[:prefix]
    checks = 0
    ranges = []
    for idx in order:
        start = idx * block
        end = start + block
        found_prefix = False
        for i in range(start, end):
            checks += 1
            h = generate_h160(dataset[i])
            if h == target_hash:
                return {"checks": checks, "found": True}
            if random.randint(0, RANGE_SIZE) == 0:  
                found_prefix = True
                ranges.append({"start": i + 1, "end": end})
                break
    for r in ranges:
        for i in range(r["end"] - 1, r["start"] - 1, -1):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def compare_methods():
    results = {
        "sequential": {"wins": 0, "total_checks": 0, "total_time": 0},
        "precise": {"wins": 0, "total_checks": 0, "total_time": 0},
        "ties": 0
    }

    for i in range(SIMULATIONS):
        max_range = SECP256K1_ORDER - TOTAL_SIZE - 1
        random_offset = random.randrange(max_range)
        R = 1 + random_offset

        dataset = [R + i for i in range(TOTAL_SIZE)]
        target_num = random.choice(dataset)
        target_hash = generate_h160(target_num)
        blocks = TOTAL_SIZE // RANGE_SIZE
        order = shuffled_range(blocks - 1)

        start_time = time.perf_counter()
        seq_result = sequential_search(dataset, RANGE_SIZE, target_hash, order)
        end_time = time.perf_counter()
        seq_time = end_time - start_time

        start_time = time.perf_counter()
        pre_result = precise_search(dataset, RANGE_SIZE, PREFIX_LENGTH, target_hash, order)
        end_time = time.perf_counter()
        pre_time = end_time - start_time

        results["sequential"]["total_checks"] += seq_result["checks"]
        results["precise"]["total_checks"] += pre_result["checks"]
        results["sequential"]["total_time"] += seq_time
        results["precise"]["total_time"] += pre_time

        if seq_result["checks"] < pre_result["checks"]:
            results["sequential"]["wins"] += 1
        elif seq_result["checks"] > pre_result["checks"]:
            results["precise"]["wins"] += 1
        else:
            results["ties"] += 1

        print(f"Simulation {i + 1}: Sequential = {seq_result['checks']} checks in {seq_time:.6f}s | Prefix = {pre_result['checks']} checks in {pre_time:.6f}s")

    avg_success_rate_sequential = (results["sequential"]["total_checks"] / results["sequential"]["wins"]
                                   if results["sequential"]["wins"] > 0 else float('inf'))
    avg_success_rate_precise = (results["precise"]["total_checks"] / results["precise"]["wins"]
                                if results["precise"]["wins"] > 0 else float('inf'))
    avg_time_sequential = (results["sequential"]["total_time"] / results["sequential"]["wins"]
                           if results["sequential"]["wins"] > 0 else float('inf'))
    avg_time_precise = (results["precise"]["total_time"] / results["precise"]["wins"]
                        if results["precise"]["wins"] > 0 else float('inf'))

    print(f"""
=== FINAL RESULTS ===
Wins:
Sequential: {results['sequential']['wins']}
Prefix: {results['precise']['wins']}
Ties: {results['ties']}

Total Checks:

Sequential: {results['sequential']['total_checks']}
Prefix: {results['precise']['total_checks']}
Total Time:

Sequential: {results['sequential']['total_time']:.6f} seconds
Prefix: {results['precise']['total_time']:.6f} seconds

Averages (Total Time / Wins):

Sequential : {avg_time_sequential:.6f} seconds/victory
Prefix : {avg_time_precise:.6f} seconds/victory

Checks per Win:
Sequential : {avg_success_rate_sequential:.2f} checks/win
Prefix : {avg_success_rate_precise:.2f} checks/win
""")

if __name__ == '__main__':
    compare_methods()

I don’t think I need to explain why that line of code turns the script into a completely different method, just like modifying a single line of Bitcoin’s code to make it vulnerable and then claiming, “Bitcoin is insecure”. No, changing that line of code does not yield the same results; it simply turns the method into random + sequential versus "some other arbitrary approach".

Why? Because when you change that line, the omitted space does not reduce the probability of finding the prefix from 1/4096 to 0.0xx/4096, instead, it increases the risk of skipping the target entirely.

In conclusion, modifying that line turns the prefix-based method into a "pure luck" script, which means the original robust logic is lost.

Now, can you stop embarrassing yourselves publicly?

I understand that changing the logic makes the script gibberish.
What I dont understand is why it gives the same results (the precise method still gives more wins), even if no prefix is used.

[AlanJohnson]

Let's get back to the puzzles guys.

Did anyone else notice that Puzzle 16 is fully contained in Puzzle 42?

And that's not all: the end of Puzzle 15, the entire Puzzle 16, and the first bits of Puzzle 17, they are fully contained in Puzzle 42. That's one long sequence: 22 continuous bits. Just sitting there in the middle of #42.

I'm framing this on the wall for future research.

No , it's not.

Where did you see it ?

[kTimesG]

Let's get back to the puzzles guys.

Did anyone else notice that Puzzle 16 is fully contained in Puzzle 42?

And that's not all: the end of Puzzle 15, the entire Puzzle 16, and the first bits of Puzzle 17, they are fully contained in Puzzle 42. That's one long sequence: 22 continuous bits. Just sitting there in the middle of #42.

I'm framing this on the wall for future research.

No , it's not.

Where did you see it ?

Off by one error, sorry

Continuous unknown bits sequences:

Puzzle 16 100100100110110
Puzzle 17                0111011001001111
Puzzle 18                                10000100000001101
Puzzle 43     101011110100111011001001111100010110010001

[AlanJohnson]

Let's get back to the puzzles guys.

Did anyone else notice that Puzzle 16 is fully contained in Puzzle 42?

And that's not all: the end of Puzzle 15, the entire Puzzle 16, and the first bits of Puzzle 17, they are fully contained in Puzzle 42. That's one long sequence: 22 continuous bits. Just sitting there in the middle of #42.

I'm framing this on the wall for future research.

No , it's not.

Where did you see it ?

Off by one error, sorry

Continuous unknown bits sequences:

Puzzle 16 100100100110110
Puzzle 17                0111011001001111
Puzzle 18                                10000100000001101
Puzzle 43     101011110100111011001001111100010110010001

It's coincidence...IMO

[Akito S. M. Hosana]

Why doesn’t anyone have a script to search for WIF patterns? Is it too hard?    

Not only is it difficult—it's impossible. Let's say we know that for puzzle 69, the WIF will start with KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q — 19 characters are missing. Somehow, you might manage to guess 11 or 12 characters... but 19 is impossible. Here's a useless script you can test :

Code:

import sys
import os
import time
import multiprocessing
from multiprocessing import cpu_count, Event, Value, Process
import numpy as np
from numba import njit, prange
import secp256k1 as ice

# Configuration - puzzle 68
START_WIF = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qd7sDG4F"
MISSING_CHARS = 52 - len(START_WIF)
TARGET_HEX = "e0b8a2baee1b77fc703455f39d51477451fc8cfc"
TARGET_BINARY = bytes.fromhex(TARGET_HEX)
BATCH_SIZE = 100000

# Global variables
STOP_EVENT = Event()
KEY_COUNTER = Value('i', 0)
START_TIME = Value('d', 0.0)
CHARS = np.frombuffer(
    b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
    dtype=np.uint8
)
START_BYTES = START_WIF.encode('ascii')  # Precompute this

@njit(cache=True, parallel=True)
def numba_generate_batch(start_bytes, miss, batch_size, chars):
    results = np.empty((batch_size, len(start_bytes) + miss), dtype=np.uint8)
    char_len = len(chars)
    for i in prange(batch_size):
        # Copy the fixed prefix
        results[i, :len(start_bytes)] = start_bytes
        # Generate random suffix with indices within bounds
        for j in range(miss):
            results[i, len(start_bytes)+j] = np.random.randint(0, char_len)
    return results

def generate_batch(batch_size):
    indices = numba_generate_batch(
        np.frombuffer(START_BYTES, dtype=np.uint8),
        MISSING_CHARS,
        batch_size,
        CHARS
    )
    return [START_BYTES + CHARS[indices[i, -MISSING_CHARS:]].tobytes() 
            for i in range(batch_size)]

def check_private_key_batch(target_binary):
    local_counter = 0
    
    while not STOP_EVENT.is_set():
        # Generate a batch of keys
        wif_batch = generate_batch(BATCH_SIZE)
        local_counter += BATCH_SIZE
        
        # Update global counter
        with KEY_COUNTER.get_lock():
            KEY_COUNTER.value += BATCH_SIZE
        
        # Process the batch
        for wif_bytes in wif_batch:
            if STOP_EVENT.is_set():
                break
                
            try:
                private_key_hex = ice.btc_wif_to_pvk_hex(wif_bytes.decode('ascii'))
                dec = int(private_key_hex, 16)
                ripemd160_hash = ice.privatekey_to_h160(0, True, dec)
                
                if ripemd160_hash == target_binary:
                    handle_success(dec)
                    return
                    
            except:
                continue
    
    # Add any remaining keys if we were interrupted
    with KEY_COUNTER.get_lock():
        KEY_COUNTER.value += local_counter % BATCH_SIZE

def handle_success(dec):
    t = time.ctime()
    wif_compressed = ice.btc_pvk_to_wif(dec)
    elapsed = time.time() - START_TIME.value
    
    with open('winner.txt', 'a') as f:
        f.write(f"\n\nMatch Found: {t}")
        f.write(f"\nPrivatekey (dec): {dec}")
        f.write(f"\nPrivatekey (hex): {hex(dec)[2:]}")
        f.write(f"\nPrivatekey (wif): {wif_compressed}")
        f.write(f"\nTotal keys checked: {KEY_COUNTER.value:,}")
        f.write(f"\nAverage speed: {KEY_COUNTER.value/elapsed:,.0f} keys/sec")
    
    STOP_EVENT.set()
    print(f"\n\033[01;33m[+] BINGO!!! {t}\n")

if __name__ == '__main__':
    os.system("clear")
    print(f"\033[01;33m[+] {time.ctime()}")
    print(f"[+] Missing chars: {MISSING_CHARS}")
    print(f"[+] Target: {TARGET_HEX}")
    print(f"[+] Starting WIF: {START_WIF}")
    print(f"[+] Cores: {cpu_count()}")
    
    # Initialize START_TIME
    START_TIME.value = time.time()
    
    try:
        os.nice(-20)
        import psutil
        p = psutil.Process()
        p.cpu_affinity(list(range(cpu_count())))
    except:
        pass

    workers = []
    for _ in range(cpu_count()):
        p = Process(target=check_private_key_batch, args=(TARGET_BINARY,))
        p.start()
        workers.append(p)
    
    try:
        while not STOP_EVENT.is_set():
            time.sleep(1)
            current_count = KEY_COUNTER.value
            elapsed = max(time.time() - START_TIME.value, 0.001)
            speed = current_count / elapsed
            sys.stdout.write(f"\r[+] Speed: {speed:,.0f} keys/sec | Total: {current_count:,} keys")
            sys.stdout.flush()
    except KeyboardInterrupt:
        STOP_EVENT.set()
        print("\n[!] Stopping workers...")
    
    for p in workers:
        p.join()
    
    print(f"\nSearch completed. Final count: {KEY_COUNTER.value:,} keys")

• Sat Apr 12 12:23:07 2025
• Missing chars: 12
• Target: e0b8a2baee1b77fc703455f39d51477451fc8cfc
• Starting WIF: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qd7sDG4F
  
• Cores: 12
• Speed: 301,173 keys/sec | Total: 78,100,000 keys
• BINGO!!! Sat Apr 12 12:27:27 2025
• Speed: 300,400 keys/sec | Total: 78,200,000 keys

Search completed. Final count: 78,200,000 keys

Match Found: Sat Apr 12 12:27:27 2025
Privatekey (dec): 219898266213316039825
Privatekey (hex): bebb3940cd0fc1491
Privatekey (wif): KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qd7sDG4F2sdMtzNe8y2U
Total keys checked: 78,100,000
Average speed: 300,812 keys/sec


You need a remote viewer to tell you exactly 7 characters (here is d7sDG4F) that are missing.  

This script is really insane. I can't find 12 characters even after 5 hours on the WIF-Roulette C++ version, although it is 10 times faster. However, there is a bug: the counter and speed go into the negative after one or two hours. Also, if 15 characters are missing, the ranges overlap between one puzzle and another. Can this be fixed? Please upload it to GitHub. 

[nomachine]

This script is really insane. I can't find 12 characters even after 5 hours on the WIF-Roulette C++ version, although it is 10 times faster. However, there is a bug: the counter and speed go into the negative after one or two hours. Also, if 15 characters are missing, the ranges overlap between one puzzle and another. Can this be fixed? Please upload it to GitHub.  

I have not yet managed to reproduce the Numba random method in a way that works as efficiently in C++ as it does in Python, including the same filtering functionality.

In reality, there are 12 missing Base58 characters, which results in 58¹² ≈ 1.4×10²¹ possible combinations.

At a speed of 300,812 keys per second, a full brute-force search would take:

1.4×10²¹ ÷ 300,812 ≈ 4.65×10¹⁵ seconds ≈ 147 million years.

However, in this case, a valid WIF (Wallet Import Format) has the following structure:

[Version Byte (1)][32-byte Key][4-byte Checksum].

The starting WIF string, START_WIF = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qd7sDG4F", is almost complete. Only ~2-3 bytes are truly random , and the checksum helps filter out invalid keys early in the process.

The function ice.btc_wif_to_pvk_hex() fails quickly on invalid checksums. Most generated keys are discarded immediately, meaning you only test valid candidates. As a result, the speed you observe on the screen reflects only the processing of valid characters.

The actual entropy is MUCH lower than 12 characters!

I will upload the fixed Python script soon.  

https://github.com/NoMachine1/WIF-Cracker

[Dom1nic]

Ola, tudo bem, comecei agora tenho uma 3090 qual programa vcs mais utilizam para varrer os ranges ?

You can use my VanitySearch-bitcrack version

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

Does your VanitySearch have a stride option? Does anyone know of one?

[fixedpaul]

Ola, tudo bem, comecei agora tenho uma 3090 qual programa vcs mais utilizam para varrer os ranges ?

You can use my VanitySearch-bitcrack version

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

Does your VanitySearch have a stride option? Does anyone know of one?

For stride you mean "counting by..."? I haven't but I can add It quite easily.

[Dom1nic]

Ola, tudo bem, comecei agora tenho uma 3090 qual programa vcs mais utilizam para varrer os ranges ?

You can use my VanitySearch-bitcrack version

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

Does your VanitySearch have a stride option? Does anyone know of one?

For stride you mean "counting by..."? I haven't but I can add It quite easily.

That would be wonderful. I tried to modify the precompiled points, but it's not working as I expected.

[fixedpaul]

Ola, tudo bem, comecei agora tenho uma 3090 qual programa vcs mais utilizam para varrer os ranges ?

You can use my VanitySearch-bitcrack version

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

Does your VanitySearch have a stride option? Does anyone know of one?

For stride you mean "counting by..."? I haven't but I can add It quite easily.

That would be wonderful. I tried to modify the precompiled points, but it's not working as I expected.

Sure, if you're not in a hurry, I'll do it in the next few days

It should be enough to update Gn Points and 2Gn, and adjust the counters.

[Dom1nic]

Ola, tudo bem, comecei agora tenho uma 3090 qual programa vcs mais utilizam para varrer os ranges ?

You can use my VanitySearch-bitcrack version

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

Does your VanitySearch have a stride option? Does anyone know of one?

For stride you mean "counting by..."? I haven't but I can add It quite easily.

That would be wonderful. I tried to modify the precompiled points, but it's not working as I expected.

Sure, if you're not in a hurry, I'll do it in the next few days

It should be enough to update Gn Points and 2Gn, and adjust the counters.

Thank you, I got stuck at the counters.
I’ll wait... just waiting for Bram to spend some of his budget. 

[fixedpaul]

Another mystery solved!

The ghost turned out to be an imposter.

What happens if in Scooby Doo method you use 4095 Instead of 5000?

I said 4095 beacause is 16^3-1, which is the number of prefix combination (16^3).

Code:

=== FINAL RESULTS ===
Wins:
Scooby_Doo: 242
Prefix: 245
Ties: 13

Total Checks:

Scooby_Doo: 24659497
Prefix: 25177201
Total Time:

Scooby_Doo: 319.437524 seconds
Prefix: 312.082084 seconds

Averages (Total Time / Wins):

Scooby_Doo : 1.319990 seconds/victory
Prefix : 1.273804 seconds/victory

Checks per Win:
Scooby_Doo : 101898.75 checks/win
Prefix : 102764.09 checks/win

Code:

=== FINAL RESULTS ===
Wins:
Scooby_Doo: 242
Prefix: 243
Ties: 15

Total Checks:

Scooby_Doo: 24255742
Prefix: 24184105
Total Time:

Scooby_Doo: 315.602728 seconds
Prefix: 303.996729 seconds

Averages (Total Time / Wins):

Scooby_Doo : 1.304144 seconds/victory
Prefix : 1.251015 seconds/victory

Checks per Win:
Scooby_Doo : 100230.34 checks/win
Prefix : 99523.07 checks/win

Maybe generating an hash and looking at the first 3 hex digits (12 bits) is basically the same as generating a random number between 1 and 4096?

[kTimesG]

Introducing Scooby Doo: The Mystery Returns!

also called "The Return of the Sequential".

Because, literally, this is what we're gonna do! Just hold on and check your seat belts - this is going to be a wild ride!

We all know about Rock Scissors Paper, right? Well, it turns out someone discovered an existential dilemma:

Rock beats Scissors.
Scissors beats Paper.
Paper beats Rock.

Who's the real winner here? We'll never know. Just like we'll never know if the original Scooby Doo method is better or worse than advertised originally.

Did it win in a larger proportion when compared to sequential, when compared with other method that compared themselves to sequential? Hell yes!

But, just like a 3-way game, things weren't so simple. It turns out there's a catch: OG Scooby Doo was never directly compared to its competitors!

Stupid, right? After all, everything that matters is the winnings, no matter to what we compare with (be it other methods or the popularity of other animated cartoons). Total failure.

And because only a Guru can ever tell us how methods should really be compared or what the criteria really is (who knows, anyway?)....

... Let's fix this!

Main features and enhancements of the Scooby Doo: The Mystery Returns! method:

- does not break the Search Method API: same initial conditions are received as the method input arguments;
- Faster! Simpler! Addresses code readability issues!
- More efficient than the prefix method, when compared against, uhm, the prefix method, not against potatoes (e.g. the OG sequential method)
- Security updates: removes reliance on possibility of random being rigged down to the chipset;
- Added support for reproducible tests, so people don't throw "RIGGED" rocks at each other heads (note: if the programming language is rigged, this is not guaranteed)
- Added basic validation tests to check that if the target isn't found, the something is awfully wrong (like, really really wrong -by default, this means Python's rigged or something)
- Easter Egg included! Seeds the Random Number Generator (whatever that means) with a seed that reminds forever of the source of inspiration for the development of Scooby Doo collection of algorithms

Code:

import hashlib
import random
import time

# Configuration
TOTAL_SIZE = 100_000
RANGE_SIZE = 5_000
PREFIX_LENGTH = 3
SIMULATIONS = 1000
SECP256K1_ORDER = int("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)

# ENABLE REPRODUCIBLE TESTING
# Note: this line can be safely kept for a release build
random.seed(int.from_bytes(b'mcdouglasx'))

def ScoobyDoo_ReturnOfTheSequential(dataset, block, target_hash, order):
    checks = 0
    for k in reversed(dataset):
        checks += 1
        if generate_h160(k) == target_hash:
            return {"checks": checks, "found": True}

    raise Exception('OHNOES. Your Programming Language Is Rigged!')

def generate_h160(data):
    h = hashlib.new('ripemd160', str(data).encode('utf-8'))
    return h.hexdigest()

def shuffled_range(n):
    arr = list(range(n + 1))
    random.shuffle(arr)
    return arr

def prefixes_search(dataset, block, prefix, target_hash, order):
    prefix_hash = target_hash[:prefix]
    checks = 0
    ranges = []
    for idx in order:
        start = idx * block
        end = start + block
        found_prefix = False
        for i in range(start, end):
            checks += 1
            h = generate_h160(dataset[i])
            if h == target_hash:
                return {"checks": checks, "found": True}
            if not found_prefix and h.startswith(prefix_hash):
                found_prefix = True
                ranges.append({"start": i + 1, "end": end})
                break
    for r in ranges:
        for i in range(r["end"] - 1, r["start"] - 1, -1):
            checks += 1
            if generate_h160(dataset[i]) == target_hash:
                return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def compare_methods():
    results = {
        "Scooby_Doo": {"wins": 0, "total_checks": 0, "total_time": 0},
        "prefixes": {"wins": 0, "total_checks": 0, "total_time": 0},
        "ties": 0
    }

    for i in range(SIMULATIONS):
        max_range = SECP256K1_ORDER - TOTAL_SIZE - 1
        random_offset = random.randrange(max_range)
        R = 1 + random_offset

        dataset = [R + i for i in range(TOTAL_SIZE)]
        target_num = random.choice(dataset)
        target_hash = generate_h160(target_num)
        blocks = TOTAL_SIZE // RANGE_SIZE
        order = shuffled_range(blocks - 1)

        start_time = time.perf_counter()
        seq_result = ScoobyDoo_ReturnOfTheSequential(dataset, RANGE_SIZE, target_hash, order)
        end_time = time.perf_counter()
        seq_time = end_time - start_time

        start_time = time.perf_counter()
        pre_result = prefixes_search(dataset, RANGE_SIZE, PREFIX_LENGTH, target_hash, order)
        end_time = time.perf_counter()
        pre_time = end_time - start_time

        results["Scooby_Doo"]["total_checks"] += seq_result["checks"]
        results["prefixes"]["total_checks"] += pre_result["checks"]
        results["Scooby_Doo"]["total_time"] += seq_time
        results["prefixes"]["total_time"] += pre_time

        if seq_result["checks"] < pre_result["checks"]:
            results["Scooby_Doo"]["wins"] += 1
        elif seq_result["checks"] > pre_result["checks"]:
            results["prefixes"]["wins"] += 1
        else:
            results["ties"] += 1

        print(f"Simulation {i + 1}: Scooby_Doo = {seq_result['checks']} checks in {seq_time:.6f}s | Prefix = {pre_result['checks']} checks in {pre_time:.6f}s")

    avg_success_rate_Scooby_Doo = (results["Scooby_Doo"]["total_checks"] / results["Scooby_Doo"]["wins"]
                                   if results["Scooby_Doo"]["wins"] > 0 else float('inf'))
    avg_success_rate_prefixes = (results["prefixes"]["total_checks"] / results["prefixes"]["wins"]
                                 if results["prefixes"]["wins"] > 0 else float('inf'))
    avg_time_Scooby_Doo = (results["Scooby_Doo"]["total_time"] / results["Scooby_Doo"]["wins"]
                           if results["Scooby_Doo"]["wins"] > 0 else float('inf'))
    avg_time_prefixes = (results["prefixes"]["total_time"] / results["prefixes"]["wins"]
                         if results["prefixes"]["wins"] > 0 else float('inf'))

    print(f"""
=== FINAL RESULTS ===
Wins:
Scooby_Doo: {results['Scooby_Doo']['wins']}
Prefix: {results['prefixes']['wins']}
Ties: {results['ties']}

Total Checks:

Scooby_Doo: {results['Scooby_Doo']['total_checks']}
Prefix: {results['prefixes']['total_checks']}
Total Time:

Scooby_Doo: {results['Scooby_Doo']['total_time']:.6f} seconds
Prefix: {results['prefixes']['total_time']:.6f} seconds

Averages (Total Time / Wins):

Scooby_Doo : {avg_time_Scooby_Doo:.6f} seconds/victory
Prefix : {avg_time_prefixes:.6f} seconds/victory

Checks per Win:
Scooby_Doo : {avg_success_rate_Scooby_Doo:.2f} checks/win
Prefix : {avg_success_rate_prefixes:.2f} checks/win
""")

print(f"""
=== Configuration ===
Total numbers: {TOTAL_SIZE:,}
Block size: {RANGE_SIZE:,}
Prefix: {PREFIX_LENGTH} characters (16^{PREFIX_LENGTH} combinations)
Simulations: {SIMULATIONS}
secp256k1 Order: {SECP256K1_ORDER}
""")

if __name__ == '__main__':
    compare_methods()

Code:

=== FINAL RESULTS ===
Wins:
Scooby_Doo: 524
Prefix: 476
Ties: 0

Total Checks:

Scooby_Doo: 48668301
Prefix: 49836559
Total Time:

Scooby_Doo: 50.705403 seconds
Prefix: 52.393383 seconds

Averages (Total Time / Wins):

Scooby_Doo : 0.096766 seconds/victory
Prefix : 0.110070 seconds/victory

Checks per Win:
Scooby_Doo : 92878.44 checks/win
Prefix : 104698.65 checks/win

[farou9]

ktimesG.
any insites on solution for my problem

[kTimesG]

ktimesG.
any insites on solution for my problem

Let's say you build that database with 1 billion points from G to 1B * G
(likely a 50 GB or so sqlite database since you want to index by X[0:2]

Then what? You weren't clear what you want to do with it. If you want to break 135 with this, then you should forget this plan and think again.