Bitcoin puzzle transaction ~32 BTC prize to who solves it

[albert0bsd]

is there anyway to use Keyhunt for wallets that starts with 3 and bc ?

Please for keyhunt doubts use the topic of keyhunt that I open in this forum: https://bitcointalk.org/index.php?topic=5322040.0

The answer is No, there is no way to use it against address with 3 or bc1

[AliBah]

is there anyway to use Keyhunt for wallets that starts with 3 and bc ?

Please for keyhunt doubts use the topic of keyhunt that I open in this forum: https://bitcointalk.org/index.php?topic=5322040.0

The answer is No, there is no way to use it against address with 3 or bc1

ok sure, thank you

[Akito S. M. Hosana]

This code will generate a random string.

Target Bitcoin Address: 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG
Process Process-2:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
Process Process-1:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
Process Process-3:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
Process Process-4:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
^CTraceback (most recent call last):
  File "/kern/Desktop/test.py", line 106, in <module>
    result, attempts = multiprocessing_search(target_address)
  File "/kern/Desktop/test.py", line 85, in multiprocessing_search
    result, attempts = result_queue.get()
  File "/usr/lib/python3.9/multiprocessing/queues.py", line 103, in get
    res = self._recv_bytes()
  File "/usr/lib/python3.9/multiprocessing/connection.py", line 221, in recv_bytes
    buf = self._recv_bytes(maxlength)
  File "/usr/lib/python3.9/multiprocessing/connection.py", line 419, in _recv_bytes
    buf = self._recv(4)
  File "/usr/lib/python3.9/multiprocessing/connection.py", line 384, in _recv
    chunk = read(handle, remaining)

[cnk1220]

This code will generate a random string.
Then it will adjust each column range(1, 16)
If column 1 is 0x2 then the next string is 0x3, 0x4, 0x5 - 0x1
It will do this for each column.

Code:

from bitcoin import privtopub, pubtoaddr
import random
import string
import multiprocessing
import time
import os
import secrets
def create_random_slider_field(columns):
    return [random.choice(string.hexdigits.lower()) for _ in range(columns)]

def adjust_slider(slider, column, direction):
    hex_chars = string.hexdigits.lower()
    current_index = hex_chars.index(slider[column])
    new_index = (current_index + direction) % len(hex_chars)
    slider[column] = hex_chars[new_index]
    return slider

def check_address(private_key, target_address):
    try:
        address = pubtoaddr(privtopub(private_key))
        return address == target_address
    except Exception as e:
        print(f"Error generating address: {e}")
        return False

def search_process(target_address, process_attempts, result_queue):
    byte_values = list(range(256))
    random_bytes = [secrets.choice(byte_values) for _ in range(8)]
    random.seed(int.from_bytes(random_bytes))

    slider_columns = 19 
    attempts = 0
    hex_chars = string.hexdigits.lower()

    while attempts < process_attempts:
        slider = create_random_slider_field(slider_columns)
       
        for column in range(slider_columns):
            original_value = slider[column]
            original_index = hex_chars.index(original_value)
           
            # Check original value
            private_key = '0' * 46 + '1' + ''.join(slider)     # Updated prefix, adjust leading zeros.
            if check_address(private_key, target_address):
                result_queue.put((private_key, attempts))
                return
            attempts += 1

            # Optimized range checking
            for i in range(1, 16):
                # Check increasing values
                new_index = (original_index + i) % 16
                slider[column] = hex_chars[new_index]
                private_key = '0' * 46 + '1' + ''.join(slider)   # Updated prefix, adjust leading zeros.
                if check_address(private_key, target_address):
                    result_queue.put((private_key, attempts))
                    return
                attempts += 1
 
   # Reset to original value before moving to next column
            slider[column] = original_value

        if attempts % 1000 == 0:
            print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: {''.join(slider)}")

    result_queue.put((None, attempts))

def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4):   #max_attempts / 4 cores
    processes = []
    result_queue = multiprocessing.Queue()
    attempts_per_process = max_attempts // num_processes

    start_time = time.time()

    for i in range(num_processes):
        p = multiprocessing.Process(
            target=search_process,
            args=(target_address, attempts_per_process, result_queue)
        )
        processes.append(p)
        p.start()

    total_attempts = 0
    for _ in range(num_processes):
        result, attempts = result_queue.get()
        total_attempts += attempts
        if result:
            # Stop all processes
            for p in processes:
                p.terminate()
            return result, total_attempts

    # Wait for all processes to complete
    for p in processes:
        p.join()

    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")
    return None, total_attempts

# Main program
if __name__ == "__main__":
    target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"    #  puzzle address
    print(f"Target Bitcoin Address: {target_address}")

    result, attempts = multiprocessing_search(target_address)

    if result:
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
        print(f"Matching private key found: {result}")
        print(f"Total attempts: {attempts}")
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
    else:
        print(f"No match found after {attempts} attempts")

Sorry, but did I lost something?
What is that about?

[unclevito]

If just for puzzle 69 try these adjustments

from bitcoin import privtopub, pubtoaddr
import random
import string
import multiprocessing
import time
import os
import secrets

def create_random_slider_field(columns):
    return [random.choice(string.hexdigits.lower()) for _ in range(columns)]

def adjust_slider(slider, column, direction):
    hex_chars = string.hexdigits.lower()
    current_index = hex_chars.index(slider[column])
    new_index = (current_index + direction) % len(hex_chars)
    slider[column] = hex_chars[new_index]
    return slider

def check_address(private_key, target_address):
    try:
        address = pubtoaddr(privtopub(private_key))
        return address == target_address
    except Exception as e:
        print(f"Error generating address: {e}")
        return False

def search_process(target_address, process_attempts, result_queue):
    byte_values = list(range(256))
    random_bytes = [secrets.choice(byte_values) for _ in range(8)]
    random.seed(int.from_bytes(random_bytes, byteorder='big'))

    slider_columns = 17  # Adjusted to 17 for remaining digits
    attempts = 0
    hex_chars = string.hexdigits.lower()

    while attempts < process_attempts:
        slider = create_random_slider_field(slider_columns)

        # Construct private key with fixed '1' at the start
        private_key = '0' * 46 + '1' + ''.join(slider)

        # Check the constructed private key
        if check_address(private_key, target_address):
            result_queue.put((private_key, attempts))
            return
        attempts += 1

        if attempts % 1000 == 0:
            print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: 1{''.join(slider)}")

    result_queue.put((None, attempts))

def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4):   #max_attempts / 4 cores
    processes = []
    result_queue = multiprocessing.Queue()
    attempts_per_process = max_attempts // num_processes

    start_time = time.time()

    for i in range(num_processes):
        p = multiprocessing.Process(
            target=search_process,
            args=(target_address, attempts_per_process, result_queue)
        )
        processes.append(p)
        p.start()

    total_attempts = 0
    for _ in range(num_processes):
        result, attempts = result_queue.get()
        total_attempts += attempts
        if result:
            # Stop all processes
            for p in processes:
                p.terminate()
            return result, total_attempts

    # Wait for all processes to complete
    for p in processes:
        p.join()

    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")
    return None, total_attempts

if __name__ == "__main__":
    target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"    #  puzzle address
    print(f"Target Bitcoin Address: {target_address}")

    result, attempts = multiprocessing_search(target_address)

    if result:
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
        print(f"Matching private key found: {result}")
        print(f"Total attempts: {attempts}")
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
    else:
        print(f"No match found after {attempts} attempts")

[digitalbear]

This code ^^^ is working for me: https://prnt.sc/AZN7Pvw8fbQS
But is just slow, I have about 3-5keys keys/s since is using only CPU, is better to use vanityseach with random mode Vbcr.exe where I have like 200-300Million keys/s using GPU

[unclevito]

No I don't use it either I just made some adjustments that I saw could be causing errors for some. I use lostcoins.exe and get about  1.6 billion/s and vbcr.exe about 950 million/s

[nomachine]

The idea for the code was obviously a slot machine type rotating wheel.

Almost all the scripts in this thread are some kind of slot machine. 

[albert0bsd]

Almost all the scripts in this thread are some kind of slot machine. 

You mean SLOW machines?

[kTimesG]

My take on Puzzle #66 (65 missing bits)

Generated 60 million DP all of which have X ending in 17 zero bits.
This took less than 8 hours using a slow GPU (around 500 M op/s).
Offline storage for DP search tree: 1.5 GB (64-bit keys + 10 bytes distance to base point payload)
The DP tree is a B*-tree. No need to store all of it in RAM.

Patched libsecp256k1 to do batched affine jumps --> got around 10 M op/s single-threaded.

Running random private key solving on this foundation... any key is solved in less than 5 seconds. On a CPU - using only 512 Wild kangaroos.

RAM consumption: 20 MB
Storage: 1.5 GB (B*-tree)
Device: Intel i9 13900H CPU
GPU: not required.

Next steps: building tables all the way up to 100 bits.

Can BSGS compete with this?

Code:

[000] Solving for random private key: 0x1aff3ddb034b5e55d -> 03240e9d8d78ff7b1ef805b98f68693a255090a0f4c4a52006d2692c92e07c5223
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 064546b5d64d0bf3
PRIVATE KEY: 1aff3ddb034b5e55d
[000] Solve time / key: 0.687 s
[001] Solving for random private key: 0xac48a090862abf76 -> 0344a0a999bdddefb1fba4845ce25dd2907f0e13c742b99687ccb0b284d7e5f3a5
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10016607 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 9c6d9c083735e9a1
PRIVATE KEY: ac48a090862abf76
[001] Solve time / key: 3.084 s
[002] Solving for random private key: 0x9300e54ba34c75d7 -> 0220290834adbbd6a1c42468d4b3a8ab134c681629b9cdb2b0048a28f6615e5a72
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10014562 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 716fd239faaa1276
PRIVATE KEY: 9300e54ba34c75d7
[002] Solve time / key: 3.556 s
[003] Solving for random private key: 0xa1cf51c457122fd3 -> 02b0bf220404ad97f33610325c836dab6a6c39125072f1f956f282582a0bedfc2d
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10019382 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10021298 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: f42b808056af65b2
PRIVATE KEY: a1cf51c457122fd3
[003] Solve time / key: 4.504 s
[004] Solving for random private key: 0xa2bd8f3a435e2d36 -> 02b63eeb94b4fd1fe85ae767e64731c0c74f8120e2ac41e17a9034312766d020f5
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10020020 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10019617 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 010628ab5d861d54
PRIVATE KEY: a2bd8f3a435e2d36
[004] Solve time / key: 5.122 s
[005] Solving for random private key: 0x60771fb71eb3aefc -> 025fd9940fef8c2d0549da3108a65f419f9df7486736017eb6ba9be068e9d4d301
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015183 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 2be577bb94cd3aa3
PRIVATE KEY: 60771fb71eb3aefc
[005] Solve time / key: 4.876 s
[006] Solving for random private key: 0x17d86000f53262f88 -> 02dbaf5d00d3f26d94d04c80d4d7810099079a221514e05ac7c804ffbe3cca417a
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 4faa98c4869c148d
PRIVATE KEY: 17d86000f53262f88
[006] Solve time / key: 4.482 s
[007] Solving for random private key: 0x1f4aa45c588edfd62 -> 03b22c18653d4ba3fad4acc6c4f1e0c48fcc05eefa78bc8e3e7e52f40e6ef17240
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10014356 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: d43507795ac781dc
PRIVATE KEY: 1f4aa45c588edfd62
[007] Solve time / key: 4.663 s
[008] Solving for random private key: 0xd74fbfc1772631f7 -> 025f9c1c93e5049a039e138ca7d7551c39bec80f910167a8eb5d574a413dbf28b5
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10017025 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: e9fb03cbbc40241d
PRIVATE KEY: d74fbfc1772631f7
[008] Solve time / key: 4.833 s
[009] Solving for random private key: 0x22af69bdd474d055 -> 03a413485290a45629fae44582c92b0efff4f86f9f37aa006227c991eec9edd431
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10017498 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10018371 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 3d2a25b3c1b7f0dd
PRIVATE KEY: 22af69bdd474d055
[009] Solve time / key: 5.023 s
[010] Solving for random private key: 0x1ce81735afd57d92d -> 03144bea86943352105f01260f35df2d6fee052f56fd2640ecc9e1680b3c8fcdc0
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10010573 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: e2971ba23f7cca42
PRIVATE KEY: 1ce81735afd57d92d
[010] Solve time / key: 5.008 s
[011] Solving for random private key: 0x16d78eaad443ec9d7 -> 03b5bf0e73d2e230c2795c3a74ba07a1fe0403b0bc6c9eb60fb34c48170900356c
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 73712a66401660ad
PRIVATE KEY: 16d78eaad443ec9d7
[011] Solve time / key: 4.792 s
[012] Solving for random private key: 0xac897c2f44e218ad -> 032cc52f8bcfd1980ff2fa93238dcbee32b3856a838e1733590a34fe426ff517e1
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10019304 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: a43d77c660406b54
PRIVATE KEY: ac897c2f44e218ad
[012] Solve time / key: 4.842 s
[013] Solving for random private key: 0xc080166608fdd537 -> 03d60fee4a6be8e359deb56c8fc82d37dfd16e5b893288b0d5db7d1fc1afb219cc
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015324 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: a5ed600bf1ff8796
PRIVATE KEY: c080166608fdd537
[013] Solve time / key: 4.861 s
[014] Solving for random private key: 0x15176634735559589 -> 025ffc6426ae01e832aae04edf0f1e2a24b4ca89b8e0d1f294bd6c02abb19aa97e
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10011870 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 74ede73b91d65d45
PRIVATE KEY: 15176634735559589
[014] Solve time / key: 4.787 s
[015] Solving for random private key: 0x172e65e285533dac3 -> 03b574c6f26a57e77aef676f8d75c722aa275d3e6035dc8c8a57df67098b91d002
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: fe2a8394c3dc456a
PRIVATE KEY: 172e65e285533dac3
[015] Solve time / key: 4.686 s
[016] Solving for random private key: 0xa44ecac3c9b00e51 -> 0227349606b63a8e8e1b7508d3bf52aa8d1a54d74189edcc9186d5d75d7d1eb832
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10014487 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 04ee6e30b37592e1
PRIVATE KEY: a44ecac3c9b00e51
[016] Solve time / key: 4.620 s
[017] Solving for random private key: 0x1ea856bf547b0c99b -> 0217bb9fef5ea4ca18bfa6085d64fc8ad70cb1b8ffc9ca608da5f2911713dbd867
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 8e35d51bc7e5a58f
PRIVATE KEY: 1ea856bf547b0c99b
[017] Solve time / key: 4.463 s
[018] Solving for random private key: 0x465a7d5f108b9618 -> 0221490f554bbc14ac88d60a2b8df7ae947cfe7f9c63de856985688956b7dda13e
Creating 512 kangaroos to fill a herd
prepare: 6 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015937 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 69d1ec33eaf23a66
PRIVATE KEY: 465a7d5f108b9618
[018] Solve time / key: 4.415 s
[019] Solving for random private key: 0x4ac140e1add537a5 -> 03f9bde44a6b7f1df7f62a66c5a70c0148ec3f4fe47c08bd745c2b0d8b0785d7aa
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: a675b57193d63bfd
PRIVATE KEY: fff915bdb1ec91d317
[019] Solve time / key: 4.225 s
[020] Solving for random private key: 0xc5cbebd7b68bd04a -> 0279678b7e3d70348c7e53810a147b9c472601ad08902f48b97f91a4126891db9a
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10013896 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10015644 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
 10.05s   6.00%  100663296 | 10015729 op/s | ETA 157 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 100663296
 13.40s   8.00%  134217728 | 10015936 op/s | ETA 154 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 134217728
DP COLLISION: f75a07a7af834651
PRIVATE KEY: c5cbebd7b68bd04a
[020] Solve time / key: 4.700 s
[021] Solving for random private key: 0x1396e04bf63708b68 -> 03f42364f5a018f9bfc1d2f53781ce3f1f6b3ef47fa87c9ce9413e0b81eb4380e4
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015235 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 9f732a70c71200be
PRIVATE KEY: 1396e04bf63708b68
[021] Solve time / key: 4.734 s
[022] Solving for random private key: 0x10ea77053bbdbf904 -> 027dab1fc5dfb8b3d686e0eb13c2b2b562348b0152d780cd21cd15bed36fa037b7
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10014645 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: a62bd36aef66ae55
PRIVATE KEY: 10ea77053bbdbf904
[022] Solve time / key: 4.693 s
[023] Solving for random private key: 0x601efb73c8fbd41b -> 032e9dd1d29ed481a86182e0bc39e190afcad7bfb927746ce97db03ace3917a0ca
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10008450 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10012360 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 534ef9b1f6f7611d
PRIVATE KEY: 601efb73c8fbd41b
[023] Solve time / key: 4.794 s
[024] Solving for random private key: 0x17c7b1f721591a86a -> 022aa262a59a45d69a21b195abf90d2108a21030e034dc01a1d1566451f6c8883d
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10013970 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 3232c3f1124dd1ff
PRIVATE KEY: 17c7b1f721591a86a
[024] Solve time / key: 4.740 s
[025] Solving for random private key: 0x14071ec95e8bc839b -> 037c71ab7b557021c484eef140cdeed3ff9a0067838a1a3dae6ffb45f728f75ca9
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.36s   2.00%   33554432 | 9982688 op/s | ETA 165 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: f0b4eaf75d1076f4
PRIVATE KEY: 14071ec95e8bc839b
[025] Solve time / key: 4.723 s
[026] Solving for random private key: 0x9575fd3c7120207f -> 037b278b424b88195b10eaa039ab30515dd9a4f3f47730ded3346c5eea771e9927
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.36s   2.00%   33554432 | 9997706 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.71s   4.00%   67108864 | 10008719 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 02eddc154150913b
PRIVATE KEY: 9575fd3c7120207f
[026] Solve time / key: 4.807 s
[027] Solving for random private key: 0x16a50bdd54acabb5 -> 039e1d57f57455e4a187c2f56cf622e4e2dddee3cbe5cf7bae5e151fc9d300d5c7
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015877 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10016237 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 48f5b971d42d7c14
PRIVATE KEY: 16a50bdd54acabb5
[027] Solve time / key: 4.948 s
[028] Solving for random private key: 0x1a554ce1457bb49be -> 034268ad4874a56f40bffea05117fe417ba29121e2d160bdd825365dfcf4d1bf25
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 953588735706990f
PRIVATE KEY: 1a554ce1457bb49be
[028] Solve time / key: 4.887 s
[029] Solving for random private key: 0x1023dcfdb57669105 -> 03c9fe8fd0baa717aa2346ac85cb8acbb80419a4c59488192e813cec1722b33f2e
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10013746 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 858c30cb0ad9e092
PRIVATE KEY: 1023dcfdb57669105
[029] Solve time / key: 4.842 s
[030] Solving for random private key: 0x1a75b6c3a451d4ab6 -> 02019dd67243d2d2c7838be52fb9d4c3ecd79674d2e86b3ac7679b83b77c8799cf
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10014974 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: fe4fe22214eee437
PRIVATE KEY: 1a75b6c3a451d4ab6
[030] Solve time / key: 4.795 s
[031] Solving for random private key: 0x168cb9ddb0d88504d -> 02daa1b97df8933c9c9c8965953c944a48070ec6dffd888c2c1b4359e362ed9a49
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 8ff40134f7ea91e0
PRIVATE KEY: 168cb9ddb0d88504d
[031] Solve time / key: 4.723 s
[032] Solving for random private key: 0x14b5ec495a1c95663 -> 027664faafcc3e26d9461648ce04209bf35fa0282029b4e45af23793ac7644fe55
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015620 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10010178 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: c4fa8f7eff2d225f
PRIVATE KEY: 14b5ec495a1c95663
[032] Solve time / key: 4.802 s
[033] Solving for random private key: 0x54c33562418c8987 -> 037ef296765e0388853025cdd70b190fa3eb17f8b65bd25b2f97b8a154b83e5647
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10017426 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10018063 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: edbdf2f63a0b159a
PRIVATE KEY: 54c33562418c8987
[033] Solve time / key: 4.874 s
[034] Solving for random private key: 0x1fdbd1db056ba3822 -> 03b3a361e153c4db80767fdf8f59542482d752cce41045d8276a6f8a9a1666e643
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10018033 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 2a4a7296a7627e45
PRIVATE KEY: 1fdbd1db056ba3822
[034] Solve time / key: 4.890 s
[035] Solving for random private key: 0x1b11c14646cf5b85f -> 028abe5d7b337ee94e08df4cbe7a7eed76294a52a5ee63d330ed16c9b836e983d0
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 65790871936e4bb7
PRIVATE KEY: 1b11c14646cf5b85f
[035] Solve time / key: 4.815 s
[036] Solving for random private key: 0xcc2e94d189943178 -> 03691739875405307e8cdeacbd462509ab14cebaacc2e7201e2b7dd6545ff80b91
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: a7292a211b889eea
PRIVATE KEY: cc2e94d189943178
[036] Solve time / key: 4.754 s
[037] Solving for random private key: 0x153dbc8e6475532ce -> 03047f77a3e9ab96ecd8248531b513a3d47cc07ea5a5960c7d48dad36903c7f5e1
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10014938 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 2e2033da0db2031b
PRIVATE KEY: 153dbc8e6475532ce
[037] Solve time / key: 4.730 s
[038] Solving for random private key: 0x5b0c6f75664672cf -> 02d0fea28f433237c0e050d1465f07951fe058f02f62eb8eb63d350d94eeb1f935
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10016690 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
  6.70s   4.00%   67108864 | 10014032 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 27fafd8a79c35e5a
PRIVATE KEY: 5b0c6f75664672cf
[038] Solve time / key: 4.817 s
[039] Solving for random private key: 0x1d83532d7399e5d8c -> 03690646657c41c6d51e87b14dabe9f69d73014fbe225e7fb82dacba95f6ab7284
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 3c1287417331dcb8
PRIVATE KEY: 1d83532d7399e5d8c
[039] Solve time / key: 4.749 s
[040] Solving for random private key: 0x14cd127e35d257e91 -> 03fe5a60fb826927cf54395be40d9a0aecd9d2f2d568d8e4e9911a0ef414ef5a6a
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
  3.35s   2.00%   33554432 | 10015393 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 7d8ac74143c1a1f8
PRIVATE KEY: 14cd127e35d257e91
[040] Solve time / key: 4.756 s

[albert0bsd]

Can BSGS compete with this?

Of course NOT we all (those who has some time in this topic) knows that Kangaroo is faster than BSGS there is no point to debate that.

BSGS can solve any 65 bit key in some 30 seconds with 16 GB of precalculated data with a i7 13700K 24 threads.

Kangaroo is still a mystery for me, i don't know exactly what those DP are used for or how they help to its algorithm. I don't know how the collision should happen or how those jumos between tame and wild kangaroos need to be made.

Repeat It is a mistery for me, It is a little of shame for me but i need to admit it.

BSGS is clear like water, but kangaroo no

https://andrea.corbellini.name/2015/06/08/elliptic-curve-cryptography-breaking-security-and-a-comparison-with-rsa/

[Akito S. M. Hosana]

My take on Puzzle #66 (65 missing bits)

Running random private key solving on this foundation... any key is solved in less than 5 seconds. On a CPU - using only 512 Wild kangaroos.

How exactly are you using the kangaroo algorithm to solve random private keys?

My understanding is that the kangaroo algorithm is typically used for solving discrete logarithm problems when the public key (EC Point X, Y Coordinates) is known. Are you using it differently here, or is there some additional context or method you're employing that allows it to work with random private keys?

[nomachine]

He turned the game around like a fast slot machine.  

[kTimesG]

BSGS can solve any 65 bit key in some 30 seconds with 16 GB of precalculated data with a i7 13700K 24 threads.

Did I get this right? With a slight adjustment from 5 s on a i9 to 7 s on i7 (might not matter though).

BSGS   24 threads ... 30 seconds. ... 16    GB RAM
Kang      1 thread. ...   7 seconds. ...  1.5 GB storage

So, BSGS takes 720 seconds to do the same job, when it runs on 1 thread? With precomputed data in both cases, this makes BSGS 100 times slower, and also requires a ton of data to be stored in RAM, correct?

How exactly are you using the kangaroo algorithm to solve random private keys?

My understanding is that the kangaroo algorithm is typically used for solving discrete logarithm problems when the public key (EC Point X, Y Coordinates) is known. Are you using it differently here, or is there some additional context or method you're employing that allows it to work with random private keys?

Sorry for the confusion. I meant solving random public keys - e.g. pick a random key in the interval, compute its public key, feed it to the solver, and check that it returns the correct private key.

The set of Tame distinguished points that are used for cracking any public key are the same ones, no matter what public key is being cracked. That is the precomputation part. So since the total ops to perform are somewhere around 2 * sqrt(b) the probability of success remains almost the same if you have a lot of ops performed in advance just for finding Tame DPs. It's similar to having a lot of traps into which Wild kangaroos can fall into once the public key is known.

[albert0bsd]

Did I get this right? With a slight adjustment from 5 s on a i9 to 7 s on i7 (might not matter though).

...

this makes BSGS 100 times slower, and also requires a ton of data to be stored in RAM, correct?

Yes you get it right BSGS it is slower because it direct dependency of the size of the precalculated data.

The set of Tame distinguished points that are used for cracking any public key are the same ones, no matter what public key is being cracked. That is the precomputation part. So since the total ops to perform are somewhere around 2 * sqrt(b) the probability of success remains almost the same if you have a lot of ops performed in advance just for finding Tame DPs. It's similar to having a lot of traps into which Wild kangaroos can fall into once the public key is known.

Thank you for the explanation. question... The Set of tame Points depends of the KEY Range?

My take on Puzzle #66 (65 missing bits)

Generated 60 million DP all of which have X ending in 17 zero bits.
This took less than 8 hours using a slow GPU (around 500 M op/s).

My questions is: those set of 60 Million of DP can be used in the 130 bit range or any other bit range?

[kTimesG]

The set of Tame distinguished points that are used for cracking any public key are the same ones, no matter what public key is being cracked.

Thank you for the explanation. question... The Set of tame Points depends of the KEY Range?
My questions is: those set of 60 Million of DP can be used in the 130 bit range or any other bit range?

1. Yes, but indirectly. 2. No. Let's look at an example: puzzle 66. Interval size is 2**65.

If we put the theory into practice (Pollard 1978, Oorschot parallelization in 1996, etc.) than the deterministic jumps need to have somewhat of an optimal average jump distance.

And that value directly depends on the interval size. So in effect the set of detected DPs (though valid) between problems of different interval sizes will differ a lot, so while they could be looked up to, there is a very low chance they will ever get hit when used for a different interval size.

Practical example: to solve interval 2**65 the optimal average jump requires a deterministic jump table of 53 points. For higher intervals the jump table size increases, and this results in different deterministic walks. So the traversed DPs will most likely not intersect with the DPs that were encountered on problems of different sizes.

For puzzle 66 with a DP of 17 there exists around 2**(65 - 17) valid DPs in the interval = 281 trillion points.

However since it's basically guaranteed that a collision will be found after 2**32.5 operations, and the DP is 17, it means that only around 2**16 out of all those 2**48 DPs will be collected during a solving session.

Out of those, we can collect before-hand 2**16 Tame DPs (using 2**33 ops), and then on average we'll need another 2**32 ops to solve any key in the interval, once we have its public key.

But if we collect more and more Tame DPs, than we decrease the average required number of ops to solve for any public key in that interval

So, precomputing 2**24 DP (in 2**41 ops) decreases a lot the number of ops that will be needed to solve any key, from the initial remaining 2**32.5 ops to a lot less, smth like 2**25 ops (200 times faster). On average.. Double the amounts of collected DPs = decrease somewhat by half the time needed to solve. Hope it makes sense!

It's tempting to think that DPs could be reused between search intervals of different sizes, but in practice this will not work. The whole shenanigan works because:

1. we chose parameters that minimize the number of expected operations - if we want to reuse the same DPs it means we'd have to make jumps that are on average more than or less than the optimal value, resulting in more number of operations.

2. All kangaroos jump the same way. They don't (usually) jump the same way between intervals of different size, in order to minimize the number of expected ops. So the hit DPs will be a different subset of the whole set of possible DPs.

[nomachine]

Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]

How much storage is needed to precompute Puzzle 130 ?

[kTimesG]

Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]

How much storage is needed to precompute Puzzle 130 ?

1. That number is kind of a reference point, can vary ± 20% Besides, the best known complexity is rather 1.66 * sqrt(b) but requires special attention when jumping through the point at infinity. Speed is better when we're certain we'll never need to double a point or go through O, since that special branch goes away..

2. It's non-sense to precompute stuff when you know all the variables. It's just faster to solve the problem. Pre-computation makes sense to search and save traps inside the same space where the wild kangaroos will jump around.

You don't need any storage to solve 130 or 160 or 66 or 250+ bits. Storage is only needed if DP > 0 or if you have more than a single Tame and Wild kangaroo. But since we don't have forever to do all those gazillion ops, the catch is to compute a lot of kangaroos in parallel - as we definitely can't compute just two kangaroos in parallel, the next jump depends on their current value.

So storage depends on whatever you wish to accomplish. Might as well just save an ID of the kangaroo that reached a DP, and re-create the walk when a match occurs, to get the distance. But it's slow if the walk was a long one.

[WanderingPhilospher]

Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]

How much storage is needed to precompute Puzzle 130 ?

1. That number is kind of a reference point, can vary ± 20% Besides, the best known complexity is rather 1.66 * sqrt(b) but requires special attention when jumping through the point at infinity. Speed is better when we're certain we'll never need to double a point or go through O, since that special branch goes away..

2. It's non-sense to precompute stuff when you know all the variables. It's just faster to solve the problem. Pre-computation makes sense to search and save traps inside the same space where the wild kangaroos will jump around.

You don't need any storage to solve 130 or 160 or 66 or 250+ bits. Storage is only needed if DP > 0 or if you have more than a single Tame and Wild kangaroo. But since we don't have forever to do all those gazillion ops, the catch is to compute a lot of kangaroos in parallel - as we definitely can't compute just two kangaroos in parallel, the next jump depends on their current value.

So storage depends on whatever you wish to accomplish. Might as well just save an ID of the kangaroo that reached a DP, and re-create the walk when a match occurs, to get the distance. But it's slow if the walk was a long one.

Agreed, no need to pre-compute a huge range like 130, unless you are going to run through it multiple times looking for different pub keys, but not really even then because you can tame every wild kangaroo that ran through the range, after the key is found.

Pre-compute is just running all "tames"... (k*g) through whatever range and store the points (public key x points, not the whole thing but however many bits you chose (not to few though or then you have false collisions)) That's all pre-computing really is. Same as BSGS, 1*g all the way up to however many points you want in your baby step file. And all of those points are DP 0.

For the 130 puzzle, we are using DP 32. So we will roughly need to find 2^33.55 distinguished points. File size, should be right around 400GB; that's my estimate.

And albert0, since you know BSGS better than most, a 100,000 view way to look at Kangaroo, consider the baby step file the tame kangaroos, and the giant steps, the wilds (offsets). BSGS is like a brute force mixed with Kangaroo lol. But Kangaroo is just more spread out with it's jumps, whereas BSGS takes the exact same "step" each time. Kangaroo creates multiple offset pubkeys (addition or subtraction or both), those are the wilds. And once one of those offset points matches a tame point, basic math just like BSGS.

Tames are just k*g, with some distinguishable point. The 130 pool, DP 32, so we save every x point that has at least 8 zeros at the end (trailing). The wilds are k*g + public key, that you are searching for. Same thing, if it ends with 8 zeros, it gets stored. Once we get a collision / match, we merely take the tame distance (k*g or private key really) and subtract the wild distance. And like BSGS, if you reduced the range by subtracting the start range up front, then you have to add it back. (tame distance - wild distance) + initial subtracted start range.

[bitcoinpuzzles621]

Does anyone know if this one forum post of 288 pages is the only place for most of the puzzle discussion about puzzles 66 - 160?  Or are there actual other community groups too like a discord or telegram for example?   Just thought I would ask since I had more free time during the last 2 days and finally managed to read through at least 200 pages here.   Decided to skip reading the first 88 pages though since they are probably only about the puzzles below 66 that were already solved since a very long time ago,  lol.  And thought I would just ask about the withdrawal problem too.   The creator made no announcement still about it right?   So even if anyone manages to solve, they also must find their own method to not lose the funds during transfer to their own wallet?   I havent solved it either,  just wondered if the situation was still the same.   Guessing it is unfortunately.