Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

many people make similar mistakes when they are in a hurry. To be honest, I only noticed the error myself.
The main thing is that 1000 kW hours of energy were not wasted. Please

Thank you very much - I changed it in the original post. This is proof that I'm not an AI...I admit when I'm wrong.

anyway,  I just solved Puzzle 60 in 16 seconds

• STARTED: Sat Dec 23 11:52:59 2023
• [Puzzle]: 60
• [Lower range limit]: 576460752303423488
• [Upper range limit]: 1152921504606846975
• [Using  12 CPU cores for parallel search]:
• [Core]: 11, [Random seed]: b'a\xc6?\xb5\xd8$\xc9*\xe1'
• [Core]: 12, [Random seed]: b'\x17\xd7%&\xaa&\xbfL\x94'
• [Core]: 02, [Random seed]: b'\xca[s\xfex3\x9d\xe3I'
• [Core]: 04, [Random seed]: b'\xf9\x84Z\x16\xeb\xd4\xef%\x83'
• [Core]: 03, [Random seed]: b'\xab\xba\xaa\x90\xd0\xd5H\xa0\xeb'
• [Core]: 05, [Random seed]: b'\xd6\x1aA{]\xb3s\xc8\x0f'
• [Core]: 06, [Random seed]: b'<\x04t\xacV0LB\xc5'
• [Core]: 08, [Random seed]: b'\xde\x1d\x1f\xef\xab\x8aL\xbb\xc6'
• [Core]: 10, [Random seed]: b'\x03\xadO\x97\xd8\xdf \xf4\x08'
• [Core]: 11, [Random seed]: b'*E\x99\xf3f\xe9\xf6\xb48'
• [Core]: 12, [Random seed]: b'\xa0\xb7\xf4r\xc2*\x1b"\xc4'
• [Core]: 01, [Random seed]: b'ahP+B\xb6rJ\xf6'
• PUZZLE SOLVED: Sat Dec 23 11:53:15 2023, total time: 16.213455915 sec
• WIF:  KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYkzijLsc5qE43yZ5eLV
• PUZZLE SOLVED! Stopping the loop.

Code:

import sys, os, time, hashlib, gmpy2, random, multiprocessing
from multiprocessing import Pool, cpu_count
from gmpy2 import mpz
import secp256k1 as ice

if os.name=='nt':os.system('cls')
else:os.system('clear')
t = time.ctime()
sys.stdout.write(f"\033[?25l")
sys.stdout.write(f"\033[01;33m[+] STARTED: {t}\n")
sys.stdout.flush()

MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

class Point:
    def __init__(self, x=0, y=0):
        self.x = gmpy2.mpz(x)
        self.y = gmpy2.mpz(y)

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

def multiply_by_2(P, p=MODULO):
    x_squared = P.x**2 % p
    c = (3 * x_squared * gmpy2.invert((P.y + P.y) % p, p)) % p

    R = Point()
    R.x = (c**2 - 2 * P.x) % p
    R.y = (c * (P.x - R.x) - P.y) % p

    return R

def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dx_inv = gmpy2.invert(dx, p)
    dy_dx_inv = (Q.y - P.y) * dx_inv

    R = Point()
    R.x = (dy_dx_inv**2 - P.x - Q.x) % p
    R.y = (dy_dx_inv * (P.x - R.x) - P.y) % p

    return R

def mod_pow(base, exponent, modulus):
    result = 1
    base = base % modulus

    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % modulus
        exponent = exponent // 2
        base = (base * base) % modulus

    return result

def x_to_y(X, y_parity, p=MODULO):
    X_cubed = (X**3) % p
    X = (X_cubed + 7) % p

    Y = (p + 1) // 4
    tmp = mod_pow(X, Y, p)

    if gmpy2.is_odd(tmp) != y_parity:
        tmp = -tmp % p

    return tmp

def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()
STOP_EVENT = multiprocessing.Event()

def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        message = "\r[+] [Pindex]: {}".format(Pindex)
        messages = []
        messages.append(message)
        output = ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        return comparator(A, Ak, B, Bk)
    else:
        return False

def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        t = time.ctime()
        total_time = time.time() - starttime
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        HEX = "%064x" % abs(Ak[sol_kt] - Bk[sol_kw])
        dec = int(HEX, 16)
        wifc = ice.btc_pvk_to_wif(HEX)
        wifu = ice.btc_pvk_to_wif(HEX, False)
        caddr = ice.privatekey_to_address(0, True, dec)   
        uaddr = ice.privatekey_to_address(0, False, dec) 
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        sys.stdout.write("\033[?25h")
        sys.stdout.flush()
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.9f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.9f} sec")
            file.write("\nPrivate Key (decimal): " + str(dec))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write("\nPrivate key (wif) Compressed : " + wifc)
            file.write("\nPrivate key (wif) Uncompressed: " + wifu)
            file.write("\nBitcoin address Compressed: " + caddr)
            file.write("\nBitcoin address Uncompressed: " + uaddr)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

ECMULTIPLY_MEMO = {}

def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Configuration for the Puzzle
puzzle = 60
compressed_public_key = "0348e843dc5b1bd246e6309b4924b81543d02b16c8083df973a89ce2c7eb89a10d" 
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
power = (puzzle // cpu_count()) + 1
Nt = Nw = (2 ** power // puzzle) * puzzle + cpu_count()
DP_rarity = (puzzle * puzzle)
hop_modulo = (puzzle // 2) + cpu_count()

powers_of_two = generate_powers_of_two(hop_modulo)
T, t, dt = [], [], []
W, w, dw = [], [], []

if len(compressed_public_key) == 66:
    X = mpz(compressed_public_key[2:66], 16)
    Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
else:
    print("[error] pubkey len(66/130) invalid!")

print(f"[+] [Puzzle]: {puzzle}")
print(f"[+] [Lower range limit]: {lower_range_limit}")
print(f"[+] [Upper range limit]: {upper_range_limit}")

W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0

def search_worker(
    Nt, Nw, puzzle, power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()
    core_number = pid % cpu_count()
    #Random Seed Config
    constant_prefix = b''  # b'' is back to no constant
    prefix_length = len(constant_prefix)
    length = 9
    ending_length = length - prefix_length
    ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)
    t = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
   
    w = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nw)]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0
    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

if __name__ == "__main__":
    process_count = cpu_count()
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

Loop script in bash (seed hunter)

Code:

#!/bin/bash

while true; do
    timeout 30 python3 puzzle.py
    sleep 2
    if [ -n "$(find . -maxdepth 1 -type f -name 'KEYFOUNDKEYFOUND.txt' -print -quit)" ]; then
        echo "[+] PUZZLE SOLVED! Stopping the loop."
        break
    fi
done

set the timeout as you wish.

[mabdlmonem]

many people make similar mistakes when they are in a hurry. To be honest, I only noticed the error myself.
The main thing is that 1000 kW hours of energy were not wasted. Please

Thank you very much - I changed it in the original post. This is proof that I'm not an AI...I admit when I'm wrong.

anyway,  I just solved Puzzle 60 in 16 seconds

• STARTED: Sat Dec 23 11:52:59 2023
• [Puzzle]: 60
• [Lower range limit]: 576460752303423488
• [Upper range limit]: 1152921504606846975
• [Using  12 CPU cores for parallel search]:
• [Core]: 11, [Random seed]: b'a\xc6?\xb5\xd8$\xc9*\xe1'
• [Core]: 12, [Random seed]: b'\x17\xd7%&\xaa&\xbfL\x94'
• [Core]: 02, [Random seed]: b'\xca[s\xfex3\x9d\xe3I'
• [Core]: 04, [Random seed]: b'\xf9\x84Z\x16\xeb\xd4\xef%\x83'
• [Core]: 03, [Random seed]: b'\xab\xba\xaa\x90\xd0\xd5H\xa0\xeb'
• [Core]: 05, [Random seed]: b'\xd6\x1aA{]\xb3s\xc8\x0f'
• [Core]: 06, [Random seed]: b'<\x04t\xacV0LB\xc5'
• [Core]: 08, [Random seed]: b'\xde\x1d\x1f\xef\xab\x8aL\xbb\xc6'
• [Core]: 10, [Random seed]: b'\x03\xadO\x97\xd8\xdf \xf4\x08'
• [Core]: 11, [Random seed]: b'*E\x99\xf3f\xe9\xf6\xb48'
• [Core]: 12, [Random seed]: b'\xa0\xb7\xf4r\xc2*\x1b"\xc4'
• [Core]: 01, [Random seed]: b'ahP+B\xb6rJ\xf6'
• PUZZLE SOLVED: Sat Dec 23 11:53:15 2023, total time: 16.213455915 sec
• WIF:  KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYkzijLsc5qE43yZ5eLV
• PUZZLE SOLVED! Stopping the loop.

Code:

import sys, os, time, hashlib, gmpy2, random, multiprocessing
from multiprocessing import Pool, cpu_count
from gmpy2 import mpz
import secp256k1 as ice

if os.name=='nt':os.system('cls')
else:os.system('clear')
t = time.ctime()
sys.stdout.write(f"\033[?25l")
sys.stdout.write(f"\033[01;33m[+] STARTED: {t}\n")
sys.stdout.flush()

MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

class Point:
    def __init__(self, x=0, y=0):
        self.x = gmpy2.mpz(x)
        self.y = gmpy2.mpz(y)

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

def multiply_by_2(P, p=MODULO):
    x_squared = P.x**2 % p
    c = (3 * x_squared * gmpy2.invert((P.y + P.y) % p, p)) % p

    R = Point()
    R.x = (c**2 - 2 * P.x) % p
    R.y = (c * (P.x - R.x) - P.y) % p

    return R

def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dx_inv = gmpy2.invert(dx, p)
    dy_dx_inv = (Q.y - P.y) * dx_inv

    R = Point()
    R.x = (dy_dx_inv**2 - P.x - Q.x) % p
    R.y = (dy_dx_inv * (P.x - R.x) - P.y) % p

    return R

def mod_pow(base, exponent, modulus):
    result = 1
    base = base % modulus

    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % modulus
        exponent = exponent // 2
        base = (base * base) % modulus

    return result

def x_to_y(X, y_parity, p=MODULO):
    X_cubed = (X**3) % p
    X = (X_cubed + 7) % p

    Y = (p + 1) // 4
    tmp = mod_pow(X, Y, p)

    if gmpy2.is_odd(tmp) != y_parity:
        tmp = -tmp % p

    return tmp

def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()
STOP_EVENT = multiprocessing.Event()

def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        message = "\r[+] [Pindex]: {}".format(Pindex)
        messages = []
        messages.append(message)
        output = ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        return comparator(A, Ak, B, Bk)
    else:
        return False

def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        t = time.ctime()
        total_time = time.time() - starttime
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        HEX = "%064x" % abs(Ak[sol_kt] - Bk[sol_kw])
        dec = int(HEX, 16)
        wifc = ice.btc_pvk_to_wif(HEX)
        wifu = ice.btc_pvk_to_wif(HEX, False)
        caddr = ice.privatekey_to_address(0, True, dec)   
        uaddr = ice.privatekey_to_address(0, False, dec) 
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        sys.stdout.write("\033[?25h")
        sys.stdout.flush()
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.9f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.9f} sec")
            file.write("\nPrivate Key (decimal): " + str(dec))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write("\nPrivate key (wif) Compressed : " + wifc)
            file.write("\nPrivate key (wif) Uncompressed: " + wifu)
            file.write("\nBitcoin address Compressed: " + caddr)
            file.write("\nBitcoin address Uncompressed: " + uaddr)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

ECMULTIPLY_MEMO = {}

def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Configuration for the Puzzle
puzzle = 60
compressed_public_key = "0348e843dc5b1bd246e6309b4924b81543d02b16c8083df973a89ce2c7eb89a10d" 
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
power = (puzzle // cpu_count()) + 1
Nt = Nw = (2 ** power // puzzle) * puzzle + cpu_count()
DP_rarity = (puzzle * puzzle)
hop_modulo = (puzzle // 2) + cpu_count()

powers_of_two = generate_powers_of_two(hop_modulo)
T, t, dt = [], [], []
W, w, dw = [], [], []

if len(compressed_public_key) == 66:
    X = mpz(compressed_public_key[2:66], 16)
    Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
else:
    print("[error] pubkey len(66/130) invalid!")

print(f"[+] [Puzzle]: {puzzle}")
print(f"[+] [Lower range limit]: {lower_range_limit}")
print(f"[+] [Upper range limit]: {upper_range_limit}")

W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0

def search_worker(
    Nt, Nw, puzzle, power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()
    core_number = pid % cpu_count()
    #Random Seed Config
    constant_prefix = b''  # b'' is back to no constant
    prefix_length = len(constant_prefix)
    length = 9
    ending_length = length - prefix_length
    ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)
    t = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
   
    w = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nw)]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0
    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

if __name__ == "__main__":
    process_count = cpu_count()
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

Loop script in bash (seed hunter)

Code:

#!/bin/bash

while true; do
    timeout 30 python3 puzzle.py
    sleep 2
    if [ -n "$(find . -maxdepth 1 -type f -name 'KEYFOUNDKEYFOUND.txt' -print -quit)" ]; then
        echo "[+] PUZZLE SOLVED! Stopping the loop."
        break
    fi
done

set the timeout as you wish.

why you can not solve 130 then with this code ?

[AlanJohnson]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

[mabdlmonem]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

• STARTED: Sat Dec 23 14:21:34 2023
• [Puzzle]: 60
• [Lower range limit]: 576460752303423488
• [Upper range limit]: 1152921504606846975
• [Using  32 CPU cores for parallel search]:
• [Core]: 17, [Random seed]: b'\x9aK\xff\x01\x11$o\xc9B'
• [Core]: 18, [Random seed]: b'\x8c5\xef\xdevy\xdf \x95'
• [Core]: 19, [Random seed]: b'\xe3:\xf7\r\x9e\xbc5\xf31'
• [Core]: 20, [Random seed]: b'i`)7\xe3]\xf3\xe60'
• [Core]: 21, [Random seed]: b'I\xc2\xa8\x14,\x03\x84\xc6\x1b'
• [Core]: 22, [Random seed]: b'\xf8\xa3r\x12!\xdf\x19$\x1c'
• [Core]: 23, [Random seed]: b'H\xff\x8a\xd4\xe5lt{\x10'
• [Core]: 24, [Random seed]: b'\xe7\x1f\x81\x86x\xff,c\x1d'
• [Core]: 25, [Random seed]: b'\xad\xeb\x95\xceG\x86\xbbkP'
• [Core]: 26, [Random seed]: b'Y\x9e&j\xaa=]\xad\t'
• [Core]: 27, [Random seed]: b'\x02\xfe\x1b\x81\x05\x9fRWz'
• [Core]: 28, [Random seed]: b'\xb8R!WY\xb8\xc3\x8c%'
• [Core]: 29, [Random seed]: b'\x1a\x15<<)Z\x1f\xfe\xfe'
• [Core]: 30, [Random seed]: b'sJB\xc6\xeed\xb3\xe6('
• [Core]: 31, [Random seed]: b'*Y\x1a\x84@L4\xe0\xdc'
• [Core]: 32, [Random seed]: b'\x9f\xaf\xabC\x0eQ\x95"\xa8'
• [Core]: 01, [Random seed]: b'\x0fY\x98\x02\x80\x06\xb4\xb0\xfd'
• [Core]: 02, [Random seed]: b'\x077\xd5\xc5\xa9\xcb\x13\xccL'
• [Core]: 03, [Random seed]: b'\xae7\xcaR\xf1\xda\x07\xc0\x06'
• [Core]: 05, [Random seed]: b"\xd1 \xa5\xc4\xcd'K\x8a\x9f"
• [Core]: 06, [Random seed]: b'u5\xfd\xe5\xe8\xd9\x0c\xd2\xc2'
• [Core]: 04, [Random seed]: b'\x91n\xbeN:\x00\xb5\xbfi'
• [Core]: 07, [Random seed]: b'\xf5\xbd\xe0Wh\xa3\xcb/#'
• [Core]: 08, [Random seed]: b'e@1\xec\x17d\xc5\xb9\xba'
• [Core]: 09, [Random seed]: b'\xab\xbd\xc0\xa7J9\x13\x1e\xae'
• [Core]: 10, [Random seed]: b'\x89\x8d\x07\x9c/s\xcc\x8b\xb8'
• [Core]: 11, [Random seed]: b'\xc0E\xc2\xdd\xc9\x9f\x8b]7'
• [Core]: 12, [Random seed]: b'\xd5{F\x006\xe6\x1c\xcc\xac'
• [Core]: 13, [Random seed]: b'%X81\n\x82\x97\x85\xdc'
• [Core]: 14, [Random seed]: b'm\x93\x95\xadg\xc9)\\\xd7'
• [Core]: 15, [Random seed]: b'L\xe3\x00\xd6Q\xa92\xf1\xb9'
• [Core]: 16, [Random seed]: b'\x95\xdaS\x1d\xbd\xc9\x84\x9d@'
• [Pindex]: 47101021642875518756392

i am trying your code still not found is there something like constant seed needs to write in code ?

[tmar777]

First 4 Bytes of all solved 20:3F puzzle... Someone Notice Something Here ?
https://www.talkimg.com/images/2023/12/12/EzmvT.gif

Puzzle: 02 frontHex: 00000003 Binary: 000000000000000000000000000011        Zeros: 0        Ones: 2 
Puzzle: 06 frontHex: 00000031 Binary: 000000000000000000000000110001        Zeros: 3        Ones: 3 
Puzzle: 10 frontHex: 00000202 Binary: 000000000000000000001000000010        Zeros: 8        Ones: 2 
Puzzle: 14 frontHex: 00002930 Binary: 000000000000000010100100110000        Zeros: 9        Ones: 5 
Puzzle: 18 frontHex: 0003080d Binary: 000000000000110000100000001101        Zeros: 12       Ones: 6 
Puzzle: 22 frontHex: 002de40f Binary: 000000001011011110010000001111        Zeros: 10       Ones: 12
Puzzle: 26 frontHex: 0340326e Binary: 000011010000000011001001101110        Zeros: 15       Ones: 11
puzzle: 30 frontHex: 3d94cd64 Binary: 111101100101001100110101100100        Zeros: 14        Ones: 16
puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14
puzzle: 42 frontHex: 2a221c58 Binary: 101010001000100001110001011000        Zeros: 19        Ones: 11
puzzle: 46 frontHex: 2ec18388 Binary: 101110110000011000001110001000        Zeros: 18        Ones: 12
puzzle: 50 frontHex: 22bd43c2 Binary: 100010101111010100001111000010        Zeros: 16        Ones: 14
puzzle: 54 frontHex: 236fb6d5 Binary: 100011011011111011011011010101        Zeros: 11        Ones: 19
puzzle: 58 frontHex: 2c675b85 Binary: 101100011001110101101110000101        Zeros: 14        Ones: 16
puzzle: 62 frontHex: 363d541e Binary: 110110001111010101010000011110        Zeros: 14        Ones: 16

Do you see any pattern or something? I don't see something valuable here.

[nomachine]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

I keep 3600  as timeout for 130.

[AlanJohnson]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

I keep 3600  as timeout for 130.

I don't get what you are trying to do with your code, cause if your are trying to break a seed and get all the keys from deterministic wallet that not gonna work... It's like trying to crack 256 private key. Maybe i'm wrong so please enlighten me then.

[nomachine]

if your are trying to break a seed and get all the keys from deterministic wallet that not gonna work...

Something other than that. If you haven't seen what this script does, it's not worth explaining. Start in order from Puzzle 15.

[zahid888]

I have converted almost all Bitcoin addresses (P2PKH, P2SH) from base58 to hex and matched them with 40 million addresses. Below are some examples. Additionally, I have explored using these base58 values as a seed (from max-35 to min-8). Apart from this, I have also generated MD5, SHA1, SHA224, SHA256, SHA384[:64], SHA512[:64], BLAKE2B, and BLAKE2S hex values from these base58. Please refrain from attempting these and avoid wasting time.

Do you see any pattern or something? I don't see something valuable here.

I have noticed that there is a very small difference in each pair. And puzzle 66 is a pair of puzzle 70
So we have to make minor changes here

                 Puzzle 70


One more thing: every pair is smaller than its second, instead of only one pair.

puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14

Based on this assumption 66 is smaller then 349b84b6...... Hope so.. .. If there are any other assumptions in someone's mind, they are welcome, because life is too short to guess even 30 bit.. 

[tmar777]

I have converted almost all Bitcoin addresses (P2PKH, P2SH) from base58 to hex and matched them with 40 million addresses. Below are some examples. Additionally, I have explored using these base58 values as a seed (from max-35 to min-8). Apart from this, I have also generated MD5, SHA1, SHA224, SHA256, SHA384[:64], SHA512[:64], BLAKE2B, and BLAKE2S hex values from these base58. Please refrain from attempting these and avoid wasting time.
https://www.talkimg.com/images/2023/12/24/Izsbj.png

Do you see any pattern or something? I don't see something valuable here.

I have noticed that there is a very small difference in each pair. And puzzle 66 is a pair of puzzle 70
So we have to make minor changes here

                 Puzzle 70
https://www.talkimg.com/images/2023/11/14/zTZS8.png

One more thing: every pair is smaller than its second, instead of only one pair.

puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14

Based on this assumption 66 is smaller then 349b84b6...... Hope so.. .. If there are any other assumptions in someone's mind, they are welcome, because life is too short to guess even 30 bit.. 

Man, sorry it may be my brain that doesn't get it but I understand nothing.
"I have noticed that there is a very small difference in each pair. And puzzle 66 is a pair of puzzle 70 " in what pair do you refer to? pair mean there 2 things...
 "every pair is smaller than its second, instead of only one pair."
Also, can you provide a link to the binary graph that you use?

[nomachine]

life is too short to guess even 30 bit.. 

Everything is great up to 50bit. Above that, I either don't have enough CPU or RAM or the number of GPUs or all together. And I don't have money to rent 100 GPUs.

[citb0in]

And I don't have money to rent 100 GPUs.

even if you did, what would you hope to achieve?

[AlanJohnson]

life is too short to guess even 30 bit.. 

Everything is great up to 50bit. Above that, I either don't have enough CPU or RAM or the number of GPUs or all together. And I don't have money to rent 100 GPUs.

50bit ?   

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

[zahid888]

in what pair do you refer to?

       Pair - 1                    Pair - 2                   Pair - 3                     Pair - 4                    Pair - 5                     Pair - 6                    Pair - 7                   Pair - 8              Pair 9 Assumption
                 
Upon observing this, I bear no responsibility if someone's eyesight is adversely affected. LoL   Again, I would like to say that making assumptions instead of blindly following random numbers is not inherently negative, whether the outcome is favorable or not.

life is too short to guess even 30 bit..  

Everything is great up to 50bit. Above that, I either don't have enough CPU or RAM or the number of GPUs or all together. And I don't have money to rent 100 GPUs.

50bit ?  

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

Hmmm.. i can do this in a second

Pubkey : 026a6cb130f0f374bbe6cf5499cce541d2b2a86c1ca2007424547f686907f79c36
Address : 13z11bUYcdnHNn4NKwrxdf6r695YxKh5so
Range : 66 Bit

Someone put There fund i don't know what the helll he is trying to do.. you guys can sweep it.. https://blockchair.com/bitcoin/address/13z11bUYcdnHNn4NKwrxdf6r695YxKh5so

[mcdouglasx]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

[AlanJohnson]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

Cause estimated time for solving 100bit i have in DAYS while estimated time for 130bit i have in HUNDREDS OF YEARS. This shows how massive is the gap between these two ranges. People seems to not realize that.

[WanderingPhilospher]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

Cause estimated time for solving 100bit i have in DAYS while estimated time for 130bit i have in HUNDREDS OF YEARS. This shows how massive is the gap between these two ranges. People seems to not realize that.

I mean it’s “only” 2^30 times bigger. 😂
So if you could solve 2^100 in a day, it would “only” take 1 billion days to solve 2^130.
That’s using traditional Kangaroo method only.
Maybe some ways you can shortcut it, but having enough equipment helps.

[mcdouglasx]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

Cause estimated time for solving 100bit i have in DAYS while estimated time for 130bit i have in HUNDREDS OF YEARS. This shows how massive is the gap between these two ranges. People seems to not realize that.

That's assuming you unlock directly using the publickey of puzzle #130, but certain techniques allow you to go from 130 to 100 or less.

[WanderingPhilospher]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

Cause estimated time for solving 100bit i have in DAYS while estimated time for 130bit i have in HUNDREDS OF YEARS. This shows how massive is the gap between these two ranges. People seems to not realize that.

That's assuming you unlock directly using the publickey of puzzle #130, but certain techniques allow you to go from 130 to 100 or less.

You can go to 80, 64, 52, 12 or 1. Doesn't mean it's faster.

Just by reducing the bit range doesn't make it faster, without new code being able to run multiple pub keys at once, etc.


I really find it hard to believe, actually, I don't find it hard to believe, that within this community of people who follow these posts, we can't get enough people, that have a combined total of 500 GPUs, whether it's 500 people with 1 GPU each or 100 people with 5 GPUs each, or a mixture of people and GPU quantities...
But we can't get 500 GPUs to crack #66 in less than a year, if we had 1,000 GPUs, right at 6 months.
It's kind of funny, but not

The current 66 bit pool, that is running, is doing double the work.

I may do some tinkering over the next few weeks and set up some sort of pool, more than likely just keep it personal, because exposing servers to the public, there's always those 1 or 2 peeps who spend time trying to hack it lol.

Anywho, 500 GPUs = #66 found in less than a year.

[AlanJohnson]

I really find it hard to believe, actually, I don't find it hard to believe, that within this community of people who follow these posts, we can't get enough people, that have a combined total of 500 GPUs, whether it's 500 people with 1 GPU each or 100 people with 5 GPUs each, or a mixture of people and GPU quantities...
But we can't get 500 GPUs to crack #66 in less than a year, if we had 1,000 GPUs, right at 6 months.
It's kind of funny, but not

The current 66 bit pool, that is running, is doing double the work.

I may do some tinkering over the next few weeks and set up some sort of pool, more than likely just keep it personal, because exposing servers to the public, there's always those 1 or 2 peeps who spend time trying to hack it lol.

Anywho, 500 GPUs = #66 found in less than a year.

There is massive lack of trust in crypro sphere. Why should i trust anybody that he will pay me anything in case of solving puzzle or even my part for scanning some ranges ?