Bitcoin puzzle transaction ~32 BTC prize to who solves it

[WanderingPhilospher]

Here is my python program running on the CPU

Here is my python program running on the processor

maybe it will be useful to someone.
if you want to improve it, share the improved version. Thanks.

Maybe learn to use the code block so your post is not 2397864923473298 lines long. That is my suggestion for improving your python program for your CPU and processor.

[COBRAS]

Yes, this phenomenon is called "overflow" or "aliasing".

Overflow occurs when the number of possible outcomes is limited, but the number of input values exceeds this limit. As a result, many input values will correspond to the same output value.

Aliasing is a more general term that describes the phenomenon where different input values correspond to the same output value. This can occur due to various reasons, including overflow, but also due to other factors such as non-linearity of the function or limitations on the range of input values.

In the context of dividing 2^120 by numbers from 2^79 to 2^80, overflow occurs because the number of possible outcomes is limited to 2^40, but the number of input values (2^80) exceeds this limit. As a result, many input values will correspond to the same output value from the 2^40 possible outcomes.

[WanderingPhilospher]

In the context of dividing 2^120 by numbers from 2^79 to 2^80, overflow occurs because the number of possible outcomes is limited to 2^40, but the number of input values (2^80) exceeds this limit. As a result, many input values will correspond to the same output value from the 2^40 possible outcomes.

If you are talking about points, or a single point, on the curve...public keys; in the context of this puzzle/challenge, then the above is false. But I don't think you are, hopefully not anyways. But then I have to ask, what in the heck are you talking about overflow/aliasing with normal integers for?!?! What does this have to do with the puzzle/challenge?

And I really hope it was not a follow up from your other comment:

they have same start of privkey ?

if they have same starts, range from 0000 to ffff only for eqel starts

[madogss]

Surprised no one's mentioned hashcat for WIF solving.

Still will take you much longer than priv to h160 but since it's open source and has cpu, gpu, and fpga support it is a great resource for people trying to create their own software.

[Vilandro]

I can't understand what is the purpose of collecting addresses with the same prefix within the same private key range.

Is there some sort of secret formula that would help in getting the private key of the puzzle?

Someone enlighten me please.

[WanderingPhilospher]

I can't understand what is the purpose of collecting addresses with the same prefix within the same private key range.

Is there some sort of secret formula that would help in getting the private key of the puzzle?

Someone enlighten me please.

I can't understand why someone would create a brand new account, and out of all the questions to ask, ask that one, especially since all of it has been discussed...very recently.

Enlighten yourself via reading the last 10 pages or so of this topic. Read, or don't. Collect addresses, or don't.

But I will enlighten you. If you can find 2 prefixes where they match at least 53 bits of your target address, you can solve the private key using the Pythagorean theorem. In this case, "C" would be your target address!

[Cryptocurrency hipsters]

That's such a good thing, it seems like a scam

[AlanJohnson]

I can't understand what is the purpose of collecting addresses with the same prefix within the same private key range.

Is there some sort of secret formula that would help in getting the private key of the puzzle?

Someone enlighten me please.

I can't understand why someone would create a brand new account, and out of all the questions to ask, ask that one, especially since all of it has been discussed...very recently.

Enlighten yourself via reading the last 10 pages or so of this topic. Read, or don't. Collect addresses, or don't.

But I will enlighten you. If you can find 2 prefixes where they match at least 53 bits of your target address, you can solve the private key using the Pythagorean theorem. In this case, "C" would be your target address!

The question is : Is finding TWO 53bit prefixes really easier than solving the puzzle without them ?

[kTimesG]

But I will enlighten you. If you can find 2 prefixes where they match at least 53 bits of your target address, you can solve the private key using the Pythagorean theorem. In this case, "C" would be your target address!

Didn't we sign the NDA of this intel to never be made public?

I'm going fishing, I don't want to hear about these address puzzles again. Everyone's on their own both in theory and in practice. It only ends up as knowing how to manage a large GPU grid as long as the cash balance is positive, which gets.... boring.

[Vilandro]

I can't understand what is the purpose of collecting addresses with the same prefix within the same private key range.

Is there some sort of secret formula that would help in getting the private key of the puzzle?

Someone enlighten me please.

I can't understand why someone would create a brand new account, and out of all the questions to ask, ask that one, especially since all of it has been discussed...very recently.

Enlighten yourself via reading the last 10 pages or so of this topic. Read, or don't. Collect addresses, or don't.

But I will enlighten you. If you can find 2 prefixes where they match at least 53 bits of your target address, you can solve the private key using the Pythagorean theorem. In this case, "C" would be your target address!

Thanks for the response. However I assure you that this is my only account. Previously I was only observing without participating.

Going back to the main topic, the probability of finding at least 53 bits of the target address seems to me as hard as finding the target address itself, that's why I was wondering why this approach would be better or faster than trying to find the target address itself!

[Bram24732]

I can't understand what is the purpose of collecting addresses with the same prefix within the same private key range.

Is there some sort of secret formula that would help in getting the private key of the puzzle?

Someone enlighten me please.

There isn’t.
Some people are using those prefixes to “guide” the way they search the space. Some claim to do it for fun, some claim it gives you better odds. I disagree and proved it both formally and empirically.
It turns out that people want this edge to exist so badly that they won’t change their mind regardless of how many proofs you show them.

[zahid888]

Hey everyone, If you have a high-core CPU (e.g., 16 cores or more), could you kindly run this script for me and send me back the generated found_seeds.txt file?.. Thanks

Code:

import random
import multiprocessing
import sys

# Shared counter and total for progress
counter = None
found_counter = None
total = None

def init_globals(shared_counter, shared_found_counter, total_count):
    global counter, found_counter, total
    counter = shared_counter
    found_counter = shared_found_counter
    total = total_count

def check_seed(a):
    random.seed(a)
    b = random.randrange(2**31, 2**32)

    target_values = {
    int('b862a62e', 16), int('9de820a7', 16), int('e9ae4933', 16),
    int('e02b35a3', 16), int('ade6d7ce', 16), int('efae164c', 16),
    int('9d18b63a', 16), int('fc07a182', 16), int('f7051f27', 16),
    int('bebb3940', 16)}
    
    match = b in target_values

    if match:
        with found_counter.get_lock():
            found_counter.value += 1
        with open("found_seeds.txt", "a") as f:
            f.write(f"seed: {a} - FOUND! {hex(b)}\n")

    with counter.get_lock():
        counter.value += 1
        percent = counter.value / total
        bar_length = 30
        filled = int(bar_length * percent)
        bar = '█' * filled + '░' * (bar_length - filled)
        print(f"\rProgress: [{bar}] {percent * 100:.2f}% | Found_Seed: {found_counter.value}", end='', flush=True)

def chunked_range(start, end, chunk_size):
    for i in range(start, end, chunk_size):
        yield range(i, min(i + chunk_size, end))

if __name__ == '__main__':
    start = 1706200000
    end = 10_000_000_000
    chunk_size = 100_000_0
    cpu_count = multiprocessing.cpu_count()
    total_seeds = end - start

    shared_counter = multiprocessing.Value('i', 0)
    shared_found_counter = multiprocessing.Value('i', 0)

    with multiprocessing.Pool(cpu_count, initializer=init_globals,
                              initargs=(shared_counter, shared_found_counter, total_seeds)) as pool:
        for subrange in chunked_range(start, end, chunk_size):
            pool.map(check_seed, subrange)

    print(input("\nDone."))

[fantom06]

Exception in thread Thread-1 (_handle_workers):
Traceback (most recent call last):
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "\Python\Python311\Lib\threading.py", line 1045, in _bootstrap_inner
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    self.run()
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "\Python\Python311\Lib\threading.py", line 982, in run
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    self._target(*self._args, **self._kwargs)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "Python\Python311\Lib\multiprocessing\pool.py", line 522, in _handle_workers
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    cls._wait_for_updates(current_sentinels, change_notifier)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "rograms\Python\Python311\Lib\multiprocessing\pool.py", line 502, in _wait_for_updates
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    wait(sentinels, timeout=timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "ograms\Python\Python311\Lib\multiprocessing\connection.py", line 896, in wait
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    ready_handles = _exhaustive_wait(waithandle_to_obj.keys(), timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "ms\Python\Python311\Lib\multiprocessing\connection.py", line 828, in _exhaustive_wait
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    res = _winapi.WaitForMultipleObjects(L, False, timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0ValueError: need at most 63 handles, got a sequence of length 74
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 1


I restarted the process and I still have 0.03%

[zahid888]

Exception in thread Thread-1 (_handle_workers):
Traceback (most recent call last):
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "\Python\Python311\Lib\threading.py", line 1045, in _bootstrap_inner
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    self.run()
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "\Python\Python311\Lib\threading.py", line 982, in run
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    self._target(*self._args, **self._kwargs)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "Python\Python311\Lib\multiprocessing\pool.py", line 522, in _handle_workers
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    cls._wait_for_updates(current_sentinels, change_notifier)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "rograms\Python\Python311\Lib\multiprocessing\pool.py", line 502, in _wait_for_updates
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    wait(sentinels, timeout=timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "ograms\Python\Python311\Lib\multiprocessing\connection.py", line 896, in wait
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    ready_handles = _exhaustive_wait(waithandle_to_obj.keys(), timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "ms\Python\Python311\Lib\multiprocessing\connection.py", line 828, in _exhaustive_wait
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    res = _winapi.WaitForMultipleObjects(L, False, timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0ValueError: need at most 63 handles, got a sequence of length 74
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 1

ValueError: need at most 63 handles, got a sequence of length 74 on Windows systems with high core counts due to a limitation in the Windows, which can handle only 63 processes at a time. To resolve this, I recommend modifying the line that initializes the multiprocessing.Pool to limit the number of worker processes.
Modified Line :

Code:

with multiprocessing.Pool(min(cpu_count, 60), initializer=init_globals,
                         initargs=(shared_counter, shared_found_counter, total_seeds)) as pool:

[fantom06]

Exception in thread Thread-1 (_handle_workers):
Traceback (most recent call last):
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "\Python\Python311\Lib\threading.py", line 1045, in _bootstrap_inner
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    self.run()
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "\Python\Python311\Lib\threading.py", line 982, in run
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    self._target(*self._args, **self._kwargs)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "Python\Python311\Lib\multiprocessing\pool.py", line 522, in _handle_workers
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    cls._wait_for_updates(current_sentinels, change_notifier)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "rograms\Python\Python311\Lib\multiprocessing\pool.py", line 502, in _wait_for_updates
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    wait(sentinels, timeout=timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "ograms\Python\Python311\Lib\multiprocessing\connection.py", line 896, in wait
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    ready_handles = _exhaustive_wait(waithandle_to_obj.keys(), timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0  File "ms\Python\Python311\Lib\multiprocessing\connection.py", line 828, in _exhaustive_wait
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0    res = _winapi.WaitForMultipleObjects(L, False, timeout)
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 0ValueError: need at most 63 handles, got a sequence of length 74
Progress: [░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 0.00% | Found_Seed: 1

ValueError: need at most 63 handles, got a sequence of length 74 on Windows systems with high core counts due to a limitation in the Windows, which can handle only 63 processes at a time. To resolve this, I recommend modifying the line that initializes the multiprocessing.Pool to limit the number of worker processes.
Modified Line :

Code:

with multiprocessing.Pool(min(cpu_count, 60), initializer=init_globals,
                         initargs=(shared_counter, shared_found_counter, total_seeds)) as pool:

It doesn't use my cores. I only have 4% out of 100!!!

[zahid888]

It doesn't use my cores. I only have 4% out of 100!!!

(4% out of 100%) , may i know how many cores you have ?
The modification I suggested, which limits the multiprocessing.Pool to 60 workers, was necessary to avoid the ValueError: need at most 63 handles caused by the Windows API’s limitation of 63 simultaneous processes.

Try this:

Code:

with multiprocessing.Pool(min(cpu_count, cpu_count - 2), initializer=init_globals,
                         initargs=(shared_counter, shared_found_counter, total_seeds)) as pool:

Or try experimenting with a smaller chunk size, like 1 million or 100,000, to see if it improves utilization,, Smaller chunks allow more frequent task distribution to workers, which can help keep all cores busy  

[Akito S. M. Hosana]

Hey everyone, If you have a high-core CPU (e.g., 16 cores or more), could you kindly run this script for me and send me back the generated found_seeds.txt file?.. Thanks

I have seed FOUND!

found_seeds.txt

Code:

U2FsdGVkX1/KvMRb2nEjaEexb199YXoFU6RaglK/Tx4IeDrQYmuycE2uREDryzAqOYUqDuIl+ZZLoq1WmYZNsw==

Want to unlock this gem ? Reach out to Akito for the secret password! 

[nomachine]

Want to unlock this gem ? Reach out to Akito for the secret password! 

I almost fell out of the boat. 

[fantom06]

Hey everyone, If you have a high-core CPU (e.g., 16 cores or more), could you kindly run this script for me and send me back the generated found_seeds.txt file?.. Thanks

I have seed FOUND!

found_seeds.txt

Code:

U2FsdGVkX1/KvMRb2nEjaEexb199YXoFU6RaglK/Tx4IeDrQYmuycE2uREDryzAqOYUqDuIl+ZZLoq1WmYZNsw==

Want to unlock this gem ? Reach out to Akito for the secret password! 

Have you already done everything 100%?

[fantom06]

I narrowed the range a bit 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG 15000fffffffffffff 1b2ff0000000000000