Bitcoin puzzle transaction ~32 BTC prize to who solves it

[deep_seek]

Nikola Tesla lucky number 369
Page 369 appear before and my post was 369 too and about this lucky number 369
After my post 369 Late night, mod shuffle and maybe removed unused post and page appear 367

So sad Bro... Now my 3rd post becomes 7369 in page no. 369
What does that mean we have to go for above idea ? one more thing when i try to post i got a warning - as a newbie you have to wait 360 seconds for your new post. Lol 

[cctv5go]

At most, I will solve puzzle 67 by September this year. Everyone is waiting for my good news.

[WanderingPhilospher]

Nikola Tesla lucky number 369
Page 369 appear before and my post was 369 too and about this lucky number 369
After my post 369 Late night, mod shuffle and maybe removed unused post and page appear 367

3-6-9, damn she fine
Hoping she can sock it to me one more time
Get low, get low (get low), get low (get low), get low (get low)
To the window (to the window), to the wall (to the wall)
'Til the sweat drop down my balls (my balls)
'Til all these females crawl
'Til all skeet-skeet, mosukcer (mosukcer)
'Til all skeet-skeet, gotdang (gotdang)
'Til all skeet-skeet, mosukcer (mosukcer)
'Til all skeet-skeet, gotdang (gotdang)

[jdx009]

Nikola Tesla lucky number 369
Page 369 appear before and my post was 369 too and about this lucky number 369
After my post 369 Late night, mod shuffle and maybe removed unused post and page appear 367

I'm just leaving a comment here on page 369 - as I was waiting for a long time to see what comes at 369 - I have been so obsessed with this number for a long time.

[frozenen]

Deepseek how do you know bc1qgp48hjxp9uctzysq458dtlhk7ewtf9k4xpjpjj is the creator, their reason for sending 184USD TO #66 is not clear, but you are assuming it is a clue to #67?

Also if it was a clue why ignore the zeros, 0.00189717 = 0.007C553B1ADE27BE0A11   and 0.00010392  =  0.0006CF7D005BC5789A9B

I think you stretching cause as far as I know nobody ever correctly guessed #66 started with 283 , how could they guess #67 but not #66

https://www.talkimg.com/images/2025/02/17/qMGlW.png

I was about 8 hours short of opening 66, I was rummaging through this range that day. It's a shame.
I started with the logarithm 19.666 and didn't get there. Which was found through triangles in AutoCAD.
Sry i use translater.

Could you explain more how you were doing this?

[kTimesG]

Guys, while flipping randomly through my 3 notebooks full of OCD-induced EC investigations, I found on one corner the proof on how ECDSA is broken. Unluckily, my cat made confetti out of the rest of the page, and I don't remember squat about how I anded up at that result. All I could recover is that it has to do with inter-dimensional mathematics, specifically fractal theory.

For those unaware, fractals are a cutting edge area of mathematics, since they behave outside of the normal framework of dimensionality (such as points on a line, 2D or 3D shapes). They were developed in the 80s, so they are actually newer than elliptic curves. Since they were impossible to analyze analiticaly due to their immense complexity and recurrent relations, they only made sense once the first computers started to became mainstream in the science community.

In short, there is a way to map Weierstrass curves over to some fractal (of course, not the same one). The fractal can then be looked up and zoomed-in to analyze a particular range. Depending on the intensity of the particular XY (which is simply the fractal recurrent formula landing there), we can derive back private keys. Unfortunately, while my proof seemed to work out OK, the part of the paper that contained the formula for the mapping was lost (but at least the cat had an happy hour).

Note: this doesn't work with addresses.

[JavaSandcrawler]

Could you explain more how you were doing this?

It will be pointless. 99.9% of ideas are criticized and easily destroyed.
Therefore, I see no point in showing my results, because they are rather based on chance and the dark side. lol.

But for 67 my approach is still the same. I also keep a log of prefixes so I can understand what ranges I've gone through. It makes absolutely no sense, but I just like to see thats prefixes.

I have some good work on random libraries, but not perfect. For example, for 130 bits, my library guesses from 90 to 95 bits in 15-25 seconds.
But for example for 66 from 50 to 58 bits.
Likewise for 40 from 30 to 39 bits.
https://www.talkimg.com/images/2025/02/18/qPIol.png
https://www.talkimg.com/images/2025/02/18/qPsx1.png
https://www.talkimg.com/images/2025/02/18/qPNuo.png

For any prefix 67bits these are the results.
https://www.talkimg.com/images/2025/02/18/qPyCC.png
67, I have absolutely no idea where he might be. I’m probably doing this for the sake of an idea, since bots will instantly change tx. This is of course very disappointing.
Good luck everyone.

[karrask]

Could you explain more how you were doing this?

It will be pointless. 99.9% of ideas are criticized and easily destroyed.
Therefore, I see no point in showing my results, because they are rather based on chance and the dark side. lol.

But for 67 my approach is still the same. I also keep a log of prefixes so I can understand what ranges I've gone through. It makes absolutely no sense, but I just like to see thats prefixes.

I have some good work on random libraries, but not perfect. For example, for 130 bits, my library guesses from 90 to 95 bits in 15-25 seconds.
But for example for 66 from 50 to 58 bits.
Likewise for 40 from 30 to 39 bits.
https://www.talkimg.com/images/2025/02/18/qPIol.png
https://www.talkimg.com/images/2025/02/18/qPsx1.png
https://www.talkimg.com/images/2025/02/18/qPNuo.png

For any prefix 67bits these are the results.
https://www.talkimg.com/images/2025/02/18/qPyCC.png
67, I have absolutely no idea where he might be. I’m probably doing this for the sake of an idea, since bots will instantly change tx. This is of course very disappointing.
Good luck everyone.

share the code))) бpo)

or write to me in private messages, I have a couple of questions.

[Baskentliia]

At most, I will solve puzzle 67 by September this year. Everyone is waiting for my good news.

İMPOSSİBLE BROOO

[Gtsg]

I've been analyzing the puzzle formation algorithm for two years. Just look at this information. After you figure this out, I'm ready for further dialogue.
https://i.postimg.cc/dVHh5k8h/XLS.jpg

It's part of the algorithm, there's another part, but what's the point of it all if the bots take the entire reward?

[singlethread1]

Wondering if anyone can help me with this.

Just curious - how long would it take for the average household desktop computer now in 2025 to get through 50% of the keys for puzzle 67?

I want to know to better explain this puzzle to my family/friends.

Thanks!!

[HABJo12]

Dear Sir first try to know your RAM processor unit quantity your device generation and graphics cards then you can check it by making random code like this 
import ecdsa
import time

def generate_key():
    sk = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
    return sk.to_string().hex()

start_time = time.time()
num_keys = 1000  # number of keys to generate for testing
for _ in range(num_keys):
    generate_key()

end_time = time.time()
speed = num_keys / (end_time - start_time)
print(f"Generated {num_keys} keys in {end_time - start_time:.2f} seconds.")
print(f"Speed: {speed:.2f} keys per second.")             

[frozenen]

Wondering if anyone can help me with this.

Just curious - how long would it take for the average household desktop computer now in 2025 to get through 50% of the keys for puzzle 67?

I want to know to better explain this puzzle to my family/friends.

Thanks!!

#67 range is  73.79 quintillion
#68 range is 147.57 quintillion
#69 range is 295.15 quintillion

73.79 quintillion = 73790000000000000000

your new houshold Pc can prob do 8 Mkeys/s without high end GPU!

so about 292,277 years or  148,639 years for 50% of the range in #67 to answer your question!

[nomachine]

The fact that there are only 2^77 grains of sand on all the beaches in the world helps put the scale of the puzzle into perspective. This is a lot. It's like trying to find a specific grain of sand in a massive desert that’s far bigger than all the beaches in the world combined.

[fecell]

You know, guys, I noticed that if you generate tame and wild correctly, then the kangaroo gets to the target very quickly.
with Python (3.11) on a 40-bit PK, at i5-9300H (2.4Ghz) with 32Gb (used only 20%)... it's only 3 seconds to solve. no any RND was used - only bit range and bit unique rules.
No CUDA, multithreading, and so on - just one-thread calculation.

Code:

[+] Precomputed jump points ready: 33
[+] Puzzle complexity: 40-bit
[+] Search range: 2^39 - 2^40
[+] Distinguished point rarity: 2^10
[+] Distinguished point rarity: 1024
[+] Expected hops: 2^21.09 (2233466)
[+] Tame and wild herds initialized. 00:00:00
[+] Tame and wild points initialized. 00:00:00

[+] PUZZLE SOLVED
[+] Private key (dec): 1003651412950

[+] Total hops: 1144040

[+] Search duration: 00:00:03
[+] Total execution time: 00:00:03

for 135-bit tame's and wild's values needs very long time (about 48h) to fill.

[Akito S. M. Hosana]

for 135-bit tame's and wild's values needs very long time (about 48h) to fill.

You would need approximately 2^68.50 (417402170410649059328) hops to complete this. It’s unrealistic to achieve this within 48 hours, even if you precompute 2^33 hops.

Could you provide us some code to verify these calculations?

[nomachine]

No need to look at the code. I mentioned earlier that my Python script implementation is intended solely for educational, testing, and experimental purposes. Solving puzzle 135 is physically impossible on a typical PC due to fundamental physical limitations. Even with 3–4 high-end GPUs, it would be unfeasible (been there, done that). Literally due to the laws of physics. You would need at least 100 GPUs and extensive optimization in C++ and CUDA. Python alone cannot handle this.

[fecell]

Could you provide us some code to verify these calculations?

need to put at "twset" with name "twset_b11.py"

Code:

import gmpy2

def gen_tame_wild(lower_bound, upper_bound, herd_size, N):

    tame = []
    wild = []
    (lower, lower_idx), (upper, upper_idx) = closest_triangular_numbers(lower_bound)

    print(f'[~] Tame/Wild helds: {herd_size}, lower: {lower_bound}, upper: {upper_bound}, size: {upper_bound - lower_bound}')

    generator = get_next_triangular(upper, upper_idx, N, 1)
    while len(tame) != herd_size:
        (upper, upper_idx) = next(generator)
        if upper > upper_bound:
            print(f'\nFail fill Tame/Wild with N={N}')
            exit()
        tame.append(gmpy2.mpz(upper))
        wild.append(gmpy2.mpz(upper_idx))
        print(f'[~] Tame/Wild herds current: {len(tame)}', end = '\r')

    return (tame, wild)

################################################################################################
def check_consecutive_bits(number, N):
    if N == 0:
        return True
        
    count_zeros = 0
    count_ones = 0
    
    # Пpoxoдим пo кaждoмy битy чиcлa
    while number > 0:
        # Пpoвepяeм тeкyщий бит чиcлa
        if number & 1 == 0:
            count_zeros += 1
            count_ones = 0
        else:
            count_ones += 1
            count_zeros = 0
        
        # Ecли пoдpяд N oдинaкoвыx битoв нaйдeнo, вoзвpaщaeм True
        if count_zeros > N or count_ones > N:
            return False
        
        # Cдвигaeм чиcлo нa 1 впpaвo для пpoвepки cлeдyющeгo битa
        number >>= 1
    
    # Ecли нe нaшли пoдpяд N oдинaкoвыx битoв
    return True

def closest_triangular_numbers(n):
    def triangular_number(i):
        return (i * (i + 1)) // 2

    left, right = 1, int((2 * n) ** 0.5) + 1

    while left <= right:
        mid = (left + right) // 2
        t_mid = triangular_number(mid)
        if t_mid == n:
            upper_i = mid + 1
            upper_t = triangular_number(upper_i)
            return ( (t_mid, mid), (upper_t, upper_i) )
        elif t_mid < n:
            left = mid + 1
        else:
            right = mid - 1

    lower_i = right
    lower_t = triangular_number(lower_i)
    upper_i = right + 1
    upper_t = triangular_number(upper_i)
    return ( (lower_t, lower_i), (upper_t, upper_i) )

def get_next_triangular(value, index, N, operation):
    while True:
        index += operation
        value += index * operation
        if check_consecutive_bits(value, N) and check_consecutive_bits(index, N):
            yield (value, index)


################################################################################################
def test(puzzle_complexity, compressed_pubkey, N):

    import time
    start_time = time.time()


    herd_size   = 2 ** (puzzle_complexity // 5)
    lower_bound = 2 ** (puzzle_complexity - 1)
    upper_bound = (2 ** puzzle_complexity) - 1

    tame_start_values, wild_start_values = gen_tame_wild(lower_bound, upper_bound, herd_size, N)

    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'\n[+] Tame and Wild herds initialized. {elapsed_str}')

    for x in tame_start_values:
        print(bin(x)[2:])
    for x in wild_start_values:
        print(bin(x)[2:])


if __name__ == '__main__':

    N = 4

    puzzle_complexity = 40
    compressed_pubkey = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4"
    
    #puzzle_complexity = 53
    #compressed_pubkey = "020faaf5f3afe58300a335874c80681cf66933e2a7aeb28387c0d28bb048bc6349"
    
    test(puzzle_complexity, compressed_pubkey, N)

main code:

Code:

import gmpy2

from twset.twset_b11 import gen_tame_wild
#from twset.twset_b12 import gen_tame_wild
#from twset.twset_b21 import gen_tame_wild
#from twset.twset_b22 import gen_tame_wild

N = gmpy2.mpz(6)

puzzle_complexity = 40
compressed_pubkey = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4"

#puzzle_complexity = 41
#compressed_pubkey = "03b357e68437da273dcf995a474a524439faad86fc9effc300183f714b0903468b"

#puzzle_complexity = 160
#compressed_pubkey = "02e0a8b039282faf6fe0fd769cfbc4b6b4cf8758ba68220eac420e32b91ddfa673"

#puzzle_complexity = 135
#compressed_pubkey = "02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16"

#puzzle_complexity = 53
#compressed_pubkey = "020faaf5f3afe58300a335874c80681cf66933e2a7aeb28387c0d28bb048bc6349"

#puzzle_complexity = 20
#compressed_pubkey = "033c4a45cbd643ff97d77f41ea37e843648d50fd894b864b0d52febc62f6454f7c"

##########################################################################################

import time
import os
import sys
import random
from math import log2, sqrt, log

# Oчиcткa экpaнa в зaвиcимocти oт OC
if os.name == 'nt':
    os.system('cls')
else:
    os.system('clear')
current_time = time.ctime()
sys.stdout.write("\033[?25l")  # Cкpыть кypcop
sys.stdout.write(f"\033[01;33m[+] Kangaroo: {current_time}\n")
sys.stdout.flush()

# Пapaмeтpы эллиптичecкoй кpивoй secp256k1
modulus = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
curve_order = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
generator_x = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
generator_y = gmpy2.mpz(0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)

base_point = (generator_x, generator_y)

def elliptic_curve_add(point1, point2):
    infinity = (0, 0)
    if point1 == infinity:
        return point2
    if point2 == infinity:
        return point1
   
    x1, y1 = point1
    x2, y2 = point2

    if x1 == x2:
        if y1 == y2:
            # Удвoeниe тoчки
            denominator = (y1 << 1) % modulus
            inv_denominator = gmpy2.invert(denominator, modulus)
            slope = (3 * x1 * x1 * inv_denominator) % modulus
        else:
            return infinity
    else:
        x_diff = (x2 - x1) % modulus
        inv_x_diff = gmpy2.invert(x_diff, modulus)
        slope = ((y2 - y1) * inv_x_diff) % modulus

    result_x = (slope * slope - x1 - x2) % modulus
    result_y = (slope * (x1 - result_x) - y1) % modulus
   
    return (result_x, result_y)

def scalar_multiply(scalar, point=base_point):
    result = (0, 0)
    current_point = point
    while scalar:
        if scalar & 1:
            result = elliptic_curve_add(result, current_point)
        current_point = elliptic_curve_add(current_point, current_point)
        scalar >>= 1
    return result

def x_to_y(x_coord, y_parity, prime=modulus):
    x_cubed = gmpy2.powmod(x_coord, 3, prime)
    x_squared = gmpy2.powmod(x_coord, 2, prime)
    y_squared = (x_cubed + 7) % prime
    y_coord = gmpy2.powmod(y_squared, (prime + 1) // 4, prime)
    
    if y_parity == 1:
        y_coord = (-y_coord) % prime
    return y_coord

def generate_power_steps(max_power):
    return [gmpy2.mpz(1 << power) for power in range(max_power)]

def handle_found_solution(private_key):
    hex_representation = "%064x" % abs(private_key)
    decimal_value = int(hex_representation, 16)
    print("\n\033[32m[+] PUZZLE SOLVED \033[0m")
    print(f"\033[32m[+] Private key (dec): {decimal_value} \033[0m")
    with open("KEYFOUNDKEYFOUND.txt", "a") as file:
        file.write(f"\n\nSOLVED {current_time}")
        file.write(f"\nPrivate Key (decimal): {decimal_value}")
        file.write(f"\nPrivate Key (hex): {hex_representation}")
        file.write(f"\n{'-' * 100}\n")
    return True

def kangaroo_search(precomputed_points, wild_start_point, dp_rarity, herd_size, 
                   max_hop_power, upper_bound, lower_bound, power_steps):

    solution_found = False

    # Инициaлизaция кeнгypy
    start_time0 = time.time()

    start_time = time.time()
    tame_start_values, wild_start_values = gen_tame_wild(lower_bound, upper_bound, herd_size, N)
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'\n[+] Tame and wild herds initialized. {elapsed_str}')

    start_time = time.time()
    tame_points = [scalar_multiply(value) for value in tame_start_values]
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Tame points initialized. {elapsed_str}')

    start_time = time.time()
    wild_points = [elliptic_curve_add(wild_start_point, scalar_multiply(value)) for value in wild_start_values]
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Wild points initialized. {elapsed_str}')
    
    start_time = time.time()
    tame_steps = [gmpy2.mpz(0) for _ in range(herd_size)]
    wild_steps = tame_steps.copy()
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Tame and wild steps initialized. {elapsed_str}')
    
    hours, rem = divmod(time.time() - start_time0, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Tame and wild points initialized. {elapsed_str}')
    
    total_hops = 0
    previous_hops_count = 0
    tame_distinguished_points = {}
    wild_distinguished_points = {}
    last_print_time = time.time()
    search_start_time = time.time()
    
    while True:
        # Oбpaбoткa pyчныx кeнгypy
        for idx in range(herd_size):
            total_hops += 1
            power_index = int(tame_points[idx][0] % max_hop_power)
            step_size = power_steps[power_index]
            
            if tame_points[idx][0] % dp_rarity == 0:
                x_coord = tame_points[idx][0]
                if x_coord in wild_distinguished_points:
                    solution = wild_distinguished_points[x_coord] - tame_start_values[idx]
                    solution_found = handle_found_solution(solution)
                    break
                tame_distinguished_points[x_coord] = tame_start_values[idx]
            
            tame_start_values[idx] += step_size
            tame_points[idx] = elliptic_curve_add(precomputed_points[power_index], tame_points[idx])
        if solution_found: break

        # Oбpaбoткa дикиx кeнгypy
        for idx in range(herd_size):
            total_hops += 1
            power_index = int(wild_points[idx][0] % max_hop_power)
            step_size = power_steps[power_index]
            
            if wild_points[idx][0] % dp_rarity == 0:
                x_coord = wild_points[idx][0]
                if x_coord in tame_distinguished_points:
                    solution = wild_start_values[idx] - tame_distinguished_points[x_coord]
                    solution_found = handle_found_solution(solution)
                    break
                wild_distinguished_points[x_coord] = wild_start_values[idx]
            
            wild_start_values[idx] += step_size
            wild_points[idx] = elliptic_curve_add(precomputed_points[power_index], wild_points[idx])
        if solution_found: break
        
        # Bывoд cтaтиcтики
        current_time = time.time()
        if current_time - last_print_time >= 5:
            elapsed_since_last = current_time - last_print_time
            hops_since_last = total_hops - previous_hops_count
            hops_per_sec = hops_since_last / elapsed_since_last if elapsed_since_last > 0 else 0
            
            total_elapsed = current_time - search_start_time
            hours, rem = divmod(total_elapsed, 3600)
            minutes, seconds = divmod(rem, 60)
            elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
            
            last_print_time = current_time
            previous_hops_count = total_hops
            
            print(f'[+] [Hops: 2^{log2(total_hops):.2f} <-> {hops_per_sec:.0f} h/s] [{elapsed_str}]', 
                  end='\r', flush=True)

    print()
    print(f'[+] Total hops: {total_hops}')
    hours, rem = divmod(time.time() - search_start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Search duration: {elapsed_str}')
    return solution_found

lower_bound = 2 ** (puzzle_complexity - 1)
upper_bound = (2 ** puzzle_complexity) - 1
dp_rarity = 1 << ((puzzle_complexity - 1) // 2 - 2) // 2 + 2

max_hop_power = round(log(2 ** puzzle_complexity) + 5)
herd_size = 2 ** (puzzle_complexity // 5)
power_steps = generate_power_steps(max_hop_power)

# Дeкoдиpoвaниe пyбличнoгo ключa
if len(compressed_pubkey) == 66:
    x_coord = gmpy2.mpz(int(compressed_pubkey[2:66], 16))
    y_parity = int(compressed_pubkey[:2]) - 2
    y_coord = x_to_y(x_coord, y_parity)
else:
    print("[ERROR] Invalid public key format")
    sys.exit(1)

wild_start_point = (x_coord, y_coord)

# Пpeдвapитeльный pacчeт тoчeк для пpыжкoв
precomputed_points = [base_point]
for _ in range(max_hop_power - 1):
    precomputed_points.append(elliptic_curve_add(precomputed_points[-1], precomputed_points[-1]))
print(f'[+] Precomputed jump points ready: {max_hop_power}')

# Зaпycк пoиcкa
search_start_time = time.time()
print(f"[+] Puzzle complexity: {puzzle_complexity}-bit")
print(f"[+] N: {N}-bit")
print(f"[+] Search range: 2^{puzzle_complexity-1} - 2^{puzzle_complexity}")
print(f"[+] Distinguished point rarity: 2^{int(log2(dp_rarity))}")
print(f"[+] Distinguished point rarity: {dp_rarity}")
expected_hops = 2.13 * sqrt(2 ** puzzle_complexity)
print(f"[+] Expected hops: 2^{log2(expected_hops):.2f} ({int(expected_hops)})")

search_start_time_begin = kangaroo_search(
    precomputed_points,
    wild_start_point,
    dp_rarity,
    herd_size,
    max_hop_power,
    upper_bound,
    lower_bound,
    power_steps
)

hours, rem = divmod(time.time() - search_start_time, 3600)
minutes, seconds = divmod(rem, 60)
elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
print(f"[+] Total execution time: {elapsed_str}")

[karrask]

Could you provide us some code to verify these calculations?

need to put at "twset" with name "twset_b11.py"

Code:

import gmpy2

def gen_tame_wild(lower_bound, upper_bound, herd_size, N):

    tame = []
    wild = []
    (lower, lower_idx), (upper, upper_idx) = closest_triangular_numbers(lower_bound)

    print(f'[~] Tame/Wild helds: {herd_size}, lower: {lower_bound}, upper: {upper_bound}, size: {upper_bound - lower_bound}')

    generator = get_next_triangular(upper, upper_idx, N, 1)
    while len(tame) != herd_size:
        (upper, upper_idx) = next(generator)
        if upper > upper_bound:
            print(f'\nFail fill Tame/Wild with N={N}')
            exit()
        tame.append(gmpy2.mpz(upper))
        wild.append(gmpy2.mpz(upper_idx))
        print(f'[~] Tame/Wild herds current: {len(tame)}', end = '\r')

    return (tame, wild)

################################################################################################
def check_consecutive_bits(number, N):
    if N == 0:
        return True
        
    count_zeros = 0
    count_ones = 0
    
    # Пpoxoдим пo кaждoмy битy чиcлa
    while number > 0:
        # Пpoвepяeм тeкyщий бит чиcлa
        if number & 1 == 0:
            count_zeros += 1
            count_ones = 0
        else:
            count_ones += 1
            count_zeros = 0
        
        # Ecли пoдpяд N oдинaкoвыx битoв нaйдeнo, вoзвpaщaeм True
        if count_zeros > N or count_ones > N:
            return False
        
        # Cдвигaeм чиcлo нa 1 впpaвo для пpoвepки cлeдyющeгo битa
        number >>= 1
    
    # Ecли нe нaшли пoдpяд N oдинaкoвыx битoв
    return True

def closest_triangular_numbers(n):
    def triangular_number(i):
        return (i * (i + 1)) // 2

    left, right = 1, int((2 * n) ** 0.5) + 1

    while left <= right:
        mid = (left + right) // 2
        t_mid = triangular_number(mid)
        if t_mid == n:
            upper_i = mid + 1
            upper_t = triangular_number(upper_i)
            return ( (t_mid, mid), (upper_t, upper_i) )
        elif t_mid < n:
            left = mid + 1
        else:
            right = mid - 1

    lower_i = right
    lower_t = triangular_number(lower_i)
    upper_i = right + 1
    upper_t = triangular_number(upper_i)
    return ( (lower_t, lower_i), (upper_t, upper_i) )

def get_next_triangular(value, index, N, operation):
    while True:
        index += operation
        value += index * operation
        if check_consecutive_bits(value, N) and check_consecutive_bits(index, N):
            yield (value, index)


################################################################################################
def test(puzzle_complexity, compressed_pubkey, N):

    import time
    start_time = time.time()


    herd_size   = 2 ** (puzzle_complexity // 5)
    lower_bound = 2 ** (puzzle_complexity - 1)
    upper_bound = (2 ** puzzle_complexity) - 1

    tame_start_values, wild_start_values = gen_tame_wild(lower_bound, upper_bound, herd_size, N)

    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'\n[+] Tame and Wild herds initialized. {elapsed_str}')

    for x in tame_start_values:
        print(bin(x)[2:])
    for x in wild_start_values:
        print(bin(x)[2:])


if __name__ == '__main__':

    N = 4

    puzzle_complexity = 40
    compressed_pubkey = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4"
    
    #puzzle_complexity = 53
    #compressed_pubkey = "020faaf5f3afe58300a335874c80681cf66933e2a7aeb28387c0d28bb048bc6349"
    
    test(puzzle_complexity, compressed_pubkey, N)

main code:

Code:

import gmpy2

from twset.twset_b11 import gen_tame_wild
#from twset.twset_b12 import gen_tame_wild
#from twset.twset_b21 import gen_tame_wild
#from twset.twset_b22 import gen_tame_wild

N = gmpy2.mpz(6)

puzzle_complexity = 40
compressed_pubkey = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4"

#puzzle_complexity = 41
#compressed_pubkey = "03b357e68437da273dcf995a474a524439faad86fc9effc300183f714b0903468b"

#puzzle_complexity = 160
#compressed_pubkey = "02e0a8b039282faf6fe0fd769cfbc4b6b4cf8758ba68220eac420e32b91ddfa673"

#puzzle_complexity = 135
#compressed_pubkey = "02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16"

#puzzle_complexity = 53
#compressed_pubkey = "020faaf5f3afe58300a335874c80681cf66933e2a7aeb28387c0d28bb048bc6349"

#puzzle_complexity = 20
#compressed_pubkey = "033c4a45cbd643ff97d77f41ea37e843648d50fd894b864b0d52febc62f6454f7c"

##########################################################################################

import time
import os
import sys
import random
from math import log2, sqrt, log

# Oчиcткa экpaнa в зaвиcимocти oт OC
if os.name == 'nt':
    os.system('cls')
else:
    os.system('clear')
current_time = time.ctime()
sys.stdout.write("\033[?25l")  # Cкpыть кypcop
sys.stdout.write(f"\033[01;33m[+] Kangaroo: {current_time}\n")
sys.stdout.flush()

# Пapaмeтpы эллиптичecкoй кpивoй secp256k1
modulus = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
curve_order = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
generator_x = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
generator_y = gmpy2.mpz(0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)

base_point = (generator_x, generator_y)

def elliptic_curve_add(point1, point2):
    infinity = (0, 0)
    if point1 == infinity:
        return point2
    if point2 == infinity:
        return point1
   
    x1, y1 = point1
    x2, y2 = point2

    if x1 == x2:
        if y1 == y2:
            # Удвoeниe тoчки
            denominator = (y1 << 1) % modulus
            inv_denominator = gmpy2.invert(denominator, modulus)
            slope = (3 * x1 * x1 * inv_denominator) % modulus
        else:
            return infinity
    else:
        x_diff = (x2 - x1) % modulus
        inv_x_diff = gmpy2.invert(x_diff, modulus)
        slope = ((y2 - y1) * inv_x_diff) % modulus

    result_x = (slope * slope - x1 - x2) % modulus
    result_y = (slope * (x1 - result_x) - y1) % modulus
   
    return (result_x, result_y)

def scalar_multiply(scalar, point=base_point):
    result = (0, 0)
    current_point = point
    while scalar:
        if scalar & 1:
            result = elliptic_curve_add(result, current_point)
        current_point = elliptic_curve_add(current_point, current_point)
        scalar >>= 1
    return result

def x_to_y(x_coord, y_parity, prime=modulus):
    x_cubed = gmpy2.powmod(x_coord, 3, prime)
    x_squared = gmpy2.powmod(x_coord, 2, prime)
    y_squared = (x_cubed + 7) % prime
    y_coord = gmpy2.powmod(y_squared, (prime + 1) // 4, prime)
    
    if y_parity == 1:
        y_coord = (-y_coord) % prime
    return y_coord

def generate_power_steps(max_power):
    return [gmpy2.mpz(1 << power) for power in range(max_power)]

def handle_found_solution(private_key):
    hex_representation = "%064x" % abs(private_key)
    decimal_value = int(hex_representation, 16)
    print("\n\033[32m[+] PUZZLE SOLVED \033[0m")
    print(f"\033[32m[+] Private key (dec): {decimal_value} \033[0m")
    with open("KEYFOUNDKEYFOUND.txt", "a") as file:
        file.write(f"\n\nSOLVED {current_time}")
        file.write(f"\nPrivate Key (decimal): {decimal_value}")
        file.write(f"\nPrivate Key (hex): {hex_representation}")
        file.write(f"\n{'-' * 100}\n")
    return True

def kangaroo_search(precomputed_points, wild_start_point, dp_rarity, herd_size, 
                   max_hop_power, upper_bound, lower_bound, power_steps):

    solution_found = False

    # Инициaлизaция кeнгypy
    start_time0 = time.time()

    start_time = time.time()
    tame_start_values, wild_start_values = gen_tame_wild(lower_bound, upper_bound, herd_size, N)
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'\n[+] Tame and wild herds initialized. {elapsed_str}')

    start_time = time.time()
    tame_points = [scalar_multiply(value) for value in tame_start_values]
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Tame points initialized. {elapsed_str}')

    start_time = time.time()
    wild_points = [elliptic_curve_add(wild_start_point, scalar_multiply(value)) for value in wild_start_values]
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Wild points initialized. {elapsed_str}')
    
    start_time = time.time()
    tame_steps = [gmpy2.mpz(0) for _ in range(herd_size)]
    wild_steps = tame_steps.copy()
    hours, rem = divmod(time.time() - start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Tame and wild steps initialized. {elapsed_str}')
    
    hours, rem = divmod(time.time() - start_time0, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Tame and wild points initialized. {elapsed_str}')
    
    total_hops = 0
    previous_hops_count = 0
    tame_distinguished_points = {}
    wild_distinguished_points = {}
    last_print_time = time.time()
    search_start_time = time.time()
    
    while True:
        # Oбpaбoткa pyчныx кeнгypy
        for idx in range(herd_size):
            total_hops += 1
            power_index = int(tame_points[idx][0] % max_hop_power)
            step_size = power_steps[power_index]
            
            if tame_points[idx][0] % dp_rarity == 0:
                x_coord = tame_points[idx][0]
                if x_coord in wild_distinguished_points:
                    solution = wild_distinguished_points[x_coord] - tame_start_values[idx]
                    solution_found = handle_found_solution(solution)
                    break
                tame_distinguished_points[x_coord] = tame_start_values[idx]
            
            tame_start_values[idx] += step_size
            tame_points[idx] = elliptic_curve_add(precomputed_points[power_index], tame_points[idx])
        if solution_found: break

        # Oбpaбoткa дикиx кeнгypy
        for idx in range(herd_size):
            total_hops += 1
            power_index = int(wild_points[idx][0] % max_hop_power)
            step_size = power_steps[power_index]
            
            if wild_points[idx][0] % dp_rarity == 0:
                x_coord = wild_points[idx][0]
                if x_coord in tame_distinguished_points:
                    solution = wild_start_values[idx] - tame_distinguished_points[x_coord]
                    solution_found = handle_found_solution(solution)
                    break
                wild_distinguished_points[x_coord] = wild_start_values[idx]
            
            wild_start_values[idx] += step_size
            wild_points[idx] = elliptic_curve_add(precomputed_points[power_index], wild_points[idx])
        if solution_found: break
        
        # Bывoд cтaтиcтики
        current_time = time.time()
        if current_time - last_print_time >= 5:
            elapsed_since_last = current_time - last_print_time
            hops_since_last = total_hops - previous_hops_count
            hops_per_sec = hops_since_last / elapsed_since_last if elapsed_since_last > 0 else 0
            
            total_elapsed = current_time - search_start_time
            hours, rem = divmod(total_elapsed, 3600)
            minutes, seconds = divmod(rem, 60)
            elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
            
            last_print_time = current_time
            previous_hops_count = total_hops
            
            print(f'[+] [Hops: 2^{log2(total_hops):.2f} <-> {hops_per_sec:.0f} h/s] [{elapsed_str}]', 
                  end='\r', flush=True)

    print()
    print(f'[+] Total hops: {total_hops}')
    hours, rem = divmod(time.time() - search_start_time, 3600)
    minutes, seconds = divmod(rem, 60)
    elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
    print(f'[+] Search duration: {elapsed_str}')
    return solution_found

lower_bound = 2 ** (puzzle_complexity - 1)
upper_bound = (2 ** puzzle_complexity) - 1
dp_rarity = 1 << ((puzzle_complexity - 1) // 2 - 2) // 2 + 2

max_hop_power = round(log(2 ** puzzle_complexity) + 5)
herd_size = 2 ** (puzzle_complexity // 5)
power_steps = generate_power_steps(max_hop_power)

# Дeкoдиpoвaниe пyбличнoгo ключa
if len(compressed_pubkey) == 66:
    x_coord = gmpy2.mpz(int(compressed_pubkey[2:66], 16))
    y_parity = int(compressed_pubkey[:2]) - 2
    y_coord = x_to_y(x_coord, y_parity)
else:
    print("[ERROR] Invalid public key format")
    sys.exit(1)

wild_start_point = (x_coord, y_coord)

# Пpeдвapитeльный pacчeт тoчeк для пpыжкoв
precomputed_points = [base_point]
for _ in range(max_hop_power - 1):
    precomputed_points.append(elliptic_curve_add(precomputed_points[-1], precomputed_points[-1]))
print(f'[+] Precomputed jump points ready: {max_hop_power}')

# Зaпycк пoиcкa
search_start_time = time.time()
print(f"[+] Puzzle complexity: {puzzle_complexity}-bit")
print(f"[+] N: {N}-bit")
print(f"[+] Search range: 2^{puzzle_complexity-1} - 2^{puzzle_complexity}")
print(f"[+] Distinguished point rarity: 2^{int(log2(dp_rarity))}")
print(f"[+] Distinguished point rarity: {dp_rarity}")
expected_hops = 2.13 * sqrt(2 ** puzzle_complexity)
print(f"[+] Expected hops: 2^{log2(expected_hops):.2f} ({int(expected_hops)})")

search_start_time_begin = kangaroo_search(
    precomputed_points,
    wild_start_point,
    dp_rarity,
    herd_size,
    max_hop_power,
    upper_bound,
    lower_bound,
    power_steps
)

hours, rem = divmod(time.time() - search_start_time, 3600)
minutes, seconds = divmod(rem, 60)
elapsed_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
print(f"[+] Total execution time: {elapsed_str}")

пpeкpacнo! I would like your knowledge....

[fecell]

You would need approximately 2^68.50 (417402170410649059328) hops to complete this.

this is a question.

for initial values, for 40 bits, 1024 values ​​(tame and wild, i.e. 2048) are enough. 3 seconds on PYTHON! PK found.

for 135 bits, only 134,217,728 (*2 for all kangaroos).

the question is how does the kangaroo work.

you need to understand that a private key is a set of random bits. the average statistical distribution assumes from 40% to 60% of 'ones' and 'zeros' (the minimum condition) in the private key in bit representation: i.e. two values ​​- tame and wild kangaroo - should give in difference a number in which there should be a statistically normal distribution of bits.

Thus, one can initially select the most reliable values ​​for "tame" and "wild" that will guaranted assume the result of the most possible private key.